indexing + indexed + delayed

bu4/evaluation/av/evtype.py

@@ -0,0 +1,14 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import Sequence
+
+__all__ = ('evtype',)
+
+from bu4.evaluation.constructs.evaluable import Evaluable
+
+try:
+    from typing import TypeAlias
+except ImportError:
+    TypeAlias = type
+
+evtype: TypeAlias = Sequence[Evaluable]

bu4/evaluation/av/lambdaev.py

@@ -0,0 +1,24 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import Sequence
+
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.targets.avicontainer import AVIContainer
+
+__all__ = ('LambdaEv',)
+
+
+class LambdaEv(Sequence[Evaluable]):
+    def __getitem__(self, i: int) -> Evaluable:
+        if i == 0:
+            return self.container
+        else:
+            return self.ev[i - 1]
+
+    def __len__(self) -> int:
+        return len(self.ev) + 1
+
+    def __init__(self, ev: evtype, evaluable: Evaluable, *, memoize):
+        self.ev = ev
+        self.container = AVIContainer(evaluable).after_value if memoize else evaluable

bu4/evaluation/constructs/edelayed.py

@@ -0,0 +1,25 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.envtype import envtype
+from bu4.evaluation.constructs.elinked import ELinked
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
+from bu4.linking.constructs.linked import Linked
+
+__all__ = ('EDelayed',)
+
+
+class EDelayed(EValue):
+    def __init__(self, env: envtype, value: Linked):
+        self.env = env
+        self.value = value
+        self.evaluable = ELinked(
+            self.env,
+            self.value
+        )
+
+    def call(self, argument: Evaluable) -> Evaluable:
+        return self.evaluable
+
+    def __str__(self):
+        return f'(()){self.value}'

bu4/evaluation/constructs/eidelayed.py

@@ -0,0 +1,25 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.constructs.eindexed import EIndexed
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
+from bu4.indexing.constructs.indexed import Indexed
+
+__all__ = ('EIDelayed',)
+
+
+class EIDelayed(EValue):
+    def __init__(self, ev: evtype, value: Indexed):
+        self.ev = ev
+        self.value = value
+        self.evaluable = EIndexed(
+            self.ev,
+            self.value
+        )
+
+    def call(self, argument: Evaluable) -> Evaluable:
+        return self.evaluable
+
+    def __str__(self):
+        return f'(()){self.value}'

bu4/evaluation/constructs/eilambda.py

@@ -0,0 +1,26 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.av.lambdaev import LambdaEv
+from bu4.evaluation.constructs.eindexed import EIndexed
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
+from bu4.indexing.constructs.indexed import Indexed
+
+__all__ = ('EILambda',)
+
+
+class EILambda(EValue):
+    def __init__(self, ev: evtype, value: Indexed, *, memoize: bool):
+        self.ev = ev
+        self.value = value
+        self.memoize = memoize
+
+    def call(self, argument: Evaluable) -> Evaluable:
+        return EIndexed(
+            LambdaEv(self.ev, argument, memoize=self.memoize),
+            self.value
+        )
+
+    def __str__(self):
+        return f'(){self.value}'

bu4/evaluation/constructs/eindexed.py

@@ -0,0 +1,19 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.indexing.constructs.indexed import Indexed
+
+__all__ = ('EIndexed',)
+
+
+class EIndexed(Evaluable):
+    def __init__(self, ev: evtype, indexed: Indexed):
+        self.ev = ev
+        self.indexed = indexed
+
+    def next(self) -> Evaluable:
+        return self.indexed.evaluable(self.ev)
+
+    def __str__(self):
+        return f'{self.indexed}'

bu4/evaluation/targets/avIcall.py

@@ -0,0 +1,22 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.constructs.eindexed import EIndexed
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
+from bu4.evaluation.targets.avtarget import AVTarget
+from bu4.indexing.constructs.indexed import Indexed
+
+__all__ = ('AVICall',)
+
+
+class AVICall(AVTarget):
+    def __init__(self, ev: evtype, argument: Indexed):
+        self.ev = ev
+        self.argument = argument
+
+    def given(self, value: EValue) -> Evaluable:
+        return value.call(EIndexed(self.ev, self.argument))
+
+    def __str__(self):
+        return f'({self.argument})'

bu4/evaluation/targets/avicontainer.py

@@ -0,0 +1,20 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.aftervalue import AfterValue
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
+from bu4.evaluation.targets.avtarget import AVTarget
+
+__all__ = ('AVIContainer',)
+
+
+class AVIContainer(AVTarget):
+    def __init__(self, evaluable: Evaluable):
+        self.after_value = AfterValue(evaluable, self)
+
+    def given(self, value: EValue) -> Evaluable:
+        self.after_value.evaluable = value
+        return value
+
+    def __str__(self):
+        return f'[]'

bu4/indexing/constructs/icall.py

@@ -0,0 +1,26 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.aftervalue import AfterValue
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.constructs.eindexed import EIndexed
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.targets.avIcall import AVICall
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.parsing.codes import CODE_CALL
+
+__all__ = ('ICall',)
+
+
+class ICall(Indexed):
+    def __init__(self, argument: Indexed, lambda_: Indexed):
+        self.argument = argument
+        self.lambda_ = lambda_
+
+    def evaluable(self, ev: evtype) -> Evaluable:
+        return AfterValue(EIndexed(ev, self.lambda_), AVICall(ev, self.argument))
+
+    def __str__(self):
+        return f'/{self.argument}{self.lambda_}'
+
+    def __bytes__(self):
+        return bytes([CODE_CALL, *bytes(self.argument), *bytes(self.lambda_)])

bu4/indexing/constructs/idelayed.py

@@ -0,0 +1,26 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.constructs.eidelayed import EIDelayed
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.parsing.codes import CODE_DLYD
+
+__all__ = ('IDelayed',)
+
+
+class IDelayed(Indexed):
+    def __init__(self, value: Indexed):
+        self.value = value
+
+    def evaluable(self, ev: evtype) -> Evaluable:
+        return EIDelayed(
+            ev,
+            self.value
+        )
+
+    def __str__(self):
+        return f'(){self.value}'
+
+    def __bytes__(self):
+        return bytes([CODE_DLYD, *bytes(self.value)])

bu4/indexing/constructs/iexception.py

@@ -0,0 +1,23 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.constructs.eexception import EException
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.parsing.codes import CODE_XCPT
+
+__all__ = ('IException',)
+
+
+class IException(Indexed):
+    def __init__(self, name: bytes):
+        self.name = name
+
+    def evaluable(self, ev: evtype) -> Evaluable:
+        return EException(self.name)
+
+    def __str__(self):
+        return f'«{self.name.decode()}»'
+
+    def __bytes__(self):
+        return bytes([CODE_XCPT, *self.name, 0])

bu4/indexing/constructs/ilambda.py

@@ -0,0 +1,29 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.constructs.eilambda import EILambda
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.parsing.codes import CODE_MAKE
+
+__all__ = ('ILambda',)
+
+
+class ILambda(Indexed):
+    def __init__(self, value: Indexed, table: list[int], *, memoize: bool):
+        self.value = value
+        self.table = table
+        self.memoize = memoize
+
+    def evaluable(self, ev: evtype) -> Evaluable:
+        return EILambda(
+            [ev[i] for i in self.table],
+            self.value,
+            memoize=self.memoize
+        )
+
+    def __str__(self):
+        return f'(){self.value}'
+
+    def __bytes__(self):
+        return bytes([CODE_MAKE, len(self.table), *self.table, *bytes(self.value)])

bu4/indexing/constructs/iname.py

@@ -0,0 +1,22 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.parsing.codes import CODE_NAME
+
+__all__ = ('IName',)
+
+
+class IName(Indexed):
+    def __init__(self, index: int):
+        self.index = index
+
+    def evaluable(self, ev: evtype) -> Evaluable:
+        return ev[self.index]
+
+    def __str__(self):
+        return f'[[{self.index}]]'
+
+    def __bytes__(self):
+        return bytes([CODE_NAME, self.index])

bu4/indexing/constructs/indexed.py

@@ -0,0 +1,14 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.constructs.evaluable import Evaluable
+
+__all__ = ('Indexed',)
+
+
+class Indexed:
+    def evaluable(self, ev: evtype) -> Evaluable:
+        raise NotImplementedError
+
+    def __bytes__(self):
+        raise NotImplementedError

bu4/indexing/constructs/inull.py

@@ -0,0 +1,20 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.av.evtype import evtype
+from bu4.evaluation.constructs.enull import ENull
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.parsing.codes import CODE_NULL
+
+__all__ = ('INull',)
+
+
+class INull(Indexed):
+    def evaluable(self, ev: evtype) -> Evaluable:
+        return ENull()
+
+    def __str__(self):
+        return '?'
+
+    def __bytes__(self):
+        return bytes([CODE_NULL])

bu4/indexing/index_finish.py

@@ -0,0 +1,32 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.indexing.states.afterindexing import AfterIndexing
+from bu4.indexing.states.indexingfinished import IndexingFinished
+from bu4.indexing.states.indexinglinked import IndexingLinked
+from bu4.indexing.states.indexingstate import IndexingState
+from bu4.indexing.targets.aichain import AIChain
+
+__all__ = ('index_finish',)
+
+
+def _afterindexing_iteration(state: AfterIndexing) -> IndexingState:
+    if isinstance(state.state, IndexingFinished):
+        state = state.target.given(state.state.indexed)
+    elif isinstance(state.state, AfterIndexing):
+        state.state, state.target = state.state.state, AIChain(state.state.target, state.target)
+    elif isinstance(state.state, IndexingLinked):
+        state.state = state.state.linked.index(state.state.promise)
+    else:
+        raise TypeError
+    return state
+
+
+def index_finish(state: IndexingState) -> Indexed:
+    while True:
+        if isinstance(state, IndexingFinished):
+            return state.indexed
+        elif isinstance(state, AfterIndexing):
+            state = _afterindexing_iteration(state)
+        else:
+            raise TypeError

bu4/indexing/states/afterindexing.py

@@ -0,0 +1,12 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.indexing.states.indexingstate import IndexingState
+from bu4.indexing.targets.aitargett import AITarget
+
+__all__ = ('AfterIndexing',)
+
+
+class AfterIndexing(IndexingState):
+    def __init__(self, state: IndexingState, target: AITarget):
+        self.state = state
+        self.target = target

bu4/indexing/states/indexingfinished.py

@@ -0,0 +1,11 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.indexing.states.indexingstate import IndexingState
+
+__all__ = ('IndexingFinished',)
+
+
+class IndexingFinished(IndexingState):
+    def __init__(self, indexed: Indexed):
+        self.indexed = indexed

bu4/indexing/states/indexinglinked.py

@@ -0,0 +1,12 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.indexing.states.indexingstate import IndexingState
+from bu4.linking.constructs.linked import Linked
+
+__all__ = ('IndexingLinked',)
+
+
+class IndexingLinked(IndexingState):
+    def __init__(self, promise: list[bytes], linked: Linked):
+        self.promise = promise
+        self.linked = linked

bu4/indexing/states/indexingstate.py

@@ -0,0 +1,7 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+__all__ = ('IndexingState',)
+
+
+class IndexingState:
+    pass

bu4/indexing/targets/aichain.py

@@ -0,0 +1,17 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.indexing.states.afterindexing import AfterIndexing
+from bu4.indexing.states.indexingstate import IndexingState
+from bu4.indexing.targets.aitargett import AITarget
+
+__all__ = ('AIChain',)
+
+
+class AIChain(AITarget):
+    def __init__(self, target: AITarget, aftertarget: AITarget):
+        self.target = target
+        self.aftertarget = aftertarget
+
+    def given(self, indexed: Indexed) -> IndexingState:
+        return AfterIndexing(self.target.given(indexed), self.aftertarget)

bu4/indexing/targets/ailambda.py

@@ -0,0 +1,17 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import Callable
+
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.indexing.states.indexingstate import IndexingState
+from bu4.indexing.targets.aitargett import AITarget
+
+__all__ = ('AILambda',)
+
+
+class AILambda(AITarget):
+    def __init__(self, lambda_: Callable[[Indexed], IndexingState]):
+        self.lambda_ = lambda_
+
+    def given(self, indexed: Indexed) -> IndexingState:
+        return self.lambda_(indexed)

bu4/indexing/targets/aitargett.py

@@ -0,0 +1,11 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.indexing.states.indexingstate import IndexingState
+
+__all__ = ('AITarget',)
+
+
+class AITarget:
+    def given(self, indexed: Indexed) -> IndexingState:
+        raise NotImplementedError

bu4/isynced.py

@@ -0,0 +1,20 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.evaluation.constructs.evalue import EValue
+from bu4.evaluation.sync import sync
+from bu4.indexing.index_finish import index_finish
+from bu4.linking.link_finish import link_finish
+from bu4.parsing.toolchain.parse import parse
+from bu4.parsing.toolchain.stdext import standard_extension
+from bu4.parsing.toolchain.transply import transply
+
+__all__ = ('isynced',)
+
+
+def isynced(source: str) -> EValue:
+    bsource = transply(source)
+    parsed = parse(bsource, standard_extension)
+    linked = link_finish(parsed.link(set()))
+    indexed = index_finish(linked.index([]))
+    evaluable = indexed.evaluable([])
+    return sync(evaluable)

bu4/linking/constructs/lcall.py

@@ -5,6 +5,12 @@ from bu4.evaluation.av.envtype import envtype
 from bu4.evaluation.constructs.elinked import ELinked
 from bu4.evaluation.constructs.evaluable import Evaluable
 from bu4.evaluation.targets.avcall import AVCall
+from bu4.indexing.constructs.icall import ICall
+from bu4.indexing.states.afterindexing import AfterIndexing
+from bu4.indexing.states.indexingfinished import IndexingFinished
+from bu4.indexing.states.indexinglinked import IndexingLinked
+from bu4.indexing.states.indexingstate import IndexingState
+from bu4.indexing.targets.ailambda import AILambda
 from bu4.linking.constructs.linked import Linked
 
 __all__ = ('LCall',)
@@ -27,5 +33,18 @@ class LCall(Linked):
     def evaluable(self, env: envtype) -> Evaluable:
         return AfterValue(ELinked(env, self.lambda_), AVCall(env, self.argument))
 
+    def index(self, promise: list[bytes]) -> IndexingState:
+        return AfterIndexing(
+            IndexingLinked(promise, self.argument),
+            AILambda(
+                lambda argument: AfterIndexing(
+                    IndexingLinked(promise, self.lambda_),
+                    AILambda(
+                        lambda lambda_: IndexingFinished(ICall(argument, lambda_))
+                    )
+                )
+            )
+        )
+
     def __str__(self):
         return f'/{self.argument}{self.lambda_}'

bu4/linking/constructs/lexception.py

@@ -3,6 +3,9 @@
 from bu4.evaluation.av.envtype import envtype
 from bu4.evaluation.constructs.eexception import EException
 from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.indexing.constructs.iexception import IException
+from bu4.indexing.states.indexingfinished import IndexingFinished
+from bu4.indexing.states.indexingstate import IndexingState
 from bu4.linking.constructs.linked import Linked
 
 __all__ = ('LException',)
@@ -17,5 +20,8 @@ class LException(Linked):
     def evaluable(self, env: envtype) -> Evaluable:
         return EException(self.name)
 
+    def index(self, promise: list[bytes]) -> IndexingState:
+        return IndexingFinished(IException(self.name))
+
     def __str__(self):
         return f'«{self.name.decode()}»'

bu4/linking/constructs/linked.py

@@ -5,6 +5,8 @@ from bu4.evaluation.constructs.evaluable import Evaluable
 
 __all__ = ('Linked',)
 
+from bu4.indexing.states.indexingstate import IndexingState
+
 
 class Linked:
     future: set[bytes]
@@ -12,3 +14,6 @@ class Linked:
 
     def evaluable(self, env: envtype) -> Evaluable:
         raise NotImplementedError
+
+    def index(self, promise: list[bytes]) -> IndexingState:
+        raise NotImplementedError

bu4/linking/constructs/llambda.py

@@ -1,8 +1,16 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.evaluation.av.envtype import envtype
+from bu4.evaluation.constructs.edelayed import EDelayed
 from bu4.evaluation.constructs.elambda import ELambda
 from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.indexing.constructs.idelayed import IDelayed
+from bu4.indexing.constructs.ilambda import ILambda
+from bu4.indexing.states.afterindexing import AfterIndexing
+from bu4.indexing.states.indexingfinished import IndexingFinished
+from bu4.indexing.states.indexinglinked import IndexingLinked
+from bu4.indexing.states.indexingstate import IndexingState
+from bu4.indexing.targets.ailambda import AILambda
 from bu4.linking.constructs.linked import Linked
 
 __all__ = ('LLambda',)
@@ -17,13 +25,41 @@ class LLambda(Linked):
         self.future = self.value.future - {name}
         self.multifuture = self.future
         self.used = name in value.future
+        self.memoize = name in value.multifuture
 
     def evaluable(self, env: envtype) -> Evaluable:
-        return ELambda(
-            {name: env[name] for name in self.future} if self.used else env,
-            self.name,
-            self.value
+        return (
+            ELambda(
+                {name: env[name] for name in self.future} if self.used else env,
+                self.name,
+                self.value
+            )
+            if
+            self.used
+            else
+            EDelayed(env, self.value)
         )
 
+    def index(self, promise: list[bytes]) -> IndexingState:
+        if not self.used:
+            return AfterIndexing(
+                IndexingLinked(promise, self.value),
+                AILambda(
+                    lambda value: IndexingFinished(IDelayed(value))
+                )
+            )
+        else:
+            table = [i for i in range(len(promise)) if promise[i] in self.future]
+            return AfterIndexing(
+                IndexingLinked([self.name] + [promise[i] for i in table], self.value),
+                AILambda(
+                    lambda value: IndexingFinished(ILambda(
+                        value,
+                        table,
+                        memoize=self.memoize
+                    ))
+                )
+            )
+
     def __str__(self):
         return f'({self.name.decode()}){self.value}'

bu4/linking/constructs/lname.py

@@ -2,6 +2,9 @@
 
 from bu4.evaluation.av.envtype import envtype
 from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.indexing.constructs.iname import IName
+from bu4.indexing.states.indexingfinished import IndexingFinished
+from bu4.indexing.states.indexingstate import IndexingState
 from bu4.linking.constructs.linked import Linked
 
 __all__ = ('LName',)
@@ -16,5 +19,8 @@ class LName(Linked):
     def evaluable(self, env: envtype) -> Evaluable:
         return env[self.name]
 
+    def index(self, promise: list[bytes]) -> IndexingState:
+        return IndexingFinished(IName(promise.index(self.name)))
+
     def __str__(self):
         return f'[{self.name.decode()}]'

bu4/linking/constructs/lnull.py

@@ -3,6 +3,9 @@
 from bu4.evaluation.av.envtype import envtype
 from bu4.evaluation.constructs.enull import ENull
 from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.indexing.constructs.inull import INull
+from bu4.indexing.states.indexingfinished import IndexingFinished
+from bu4.indexing.states.indexingstate import IndexingState
 from bu4.linking.constructs.linked import Linked
 
 __all__ = ('LNull',)
@@ -16,5 +19,8 @@ class LNull(Linked):
     def evaluable(self, env: envtype) -> Evaluable:
         return ENull()
 
+    def index(self, promise: list[bytes]) -> IndexingState:
+        return IndexingFinished(INull())
+
     def __str__(self):
         return '?'

bu4/linking/evaluable_from_parsed.py

@@ -2,7 +2,7 @@
 
 from bu4.evaluation.av.envtype import envtype
 from bu4.evaluation.constructs.elinked import ELinked
-from bu4.linking.prepare import prepare
+from bu4.linking.link_finish import link_finish
 
 __all__ = ('evaluable_from_parsed',)
 
@@ -10,5 +10,5 @@ from bu4.parsing.constructs.parsed import Parsed
 
 
 def evaluable_from_parsed(env: envtype, parsed: Parsed):
-    linked = prepare(parsed.link(set(env)))
+    linked = link_finish(parsed.link(set(env)))
     return ELinked(env, linked)

bu4/linking/link_finish.py

@@ -7,7 +7,7 @@ from bu4.linking.states.linkingstate import LinkingState
 from bu4.linking.targets.alchain import ALChain
 from bu4.linking.constructs.linked import Linked
 
-__all__ = ('prepare',)
+__all__ = ('link_finish',)
 
 
 def _afterlinking_iteration(state: AfterLinking) -> LinkingState:
@@ -22,7 +22,7 @@ def _afterlinking_iteration(state: AfterLinking) -> LinkingState:
     return state
 
 
-def prepare(state: LinkingState) -> Linked:
+def link_finish(state: LinkingState) -> Linked:
     while True:
         if isinstance(state, LinkingFinished):
             return state.linked

bu4/linking/states/afterlinking.py

@@ -1,11 +1,10 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from bu4.linking.states.linkingstate import LinkingState
 from bu4.linking.targets.altarget import ALTarget
 
 __all__ = ('AfterLinking',)
 
-from bu4.linking.states.linkingstate import LinkingState
-
 
 class AfterLinking(LinkingState):
     def __init__(self, state: LinkingState, target: ALTarget):

bu4/linking/states/linkingparsed.py

@@ -1,11 +1,10 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.linking.states.linkingstate import LinkingState
+from bu4.parsing.constructs.parsed import Parsed
 
 __all__ = ('LinkingParsed',)
 
-from bu4.parsing.constructs.parsed import Parsed
-
 
 class LinkingParsed(LinkingState):
     def __init__(self, promise: set[bytes], parsed: Parsed):

bu4/parsing/codes.py

@@ -9,3 +9,4 @@ CODE_QUOT = 5
 CODE_QOPN = 6
 CODE_QCLS = 7
 CODE_XCPT = 8
+CODE_DLYD = 9

bu4/parsing/extensions/extension.py

@@ -1,8 +1,8 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.parsing.abstractparser import AbstractParser
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psafter import PSAfter
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.afterparsing import AfterParsing
 
 __all__ = ('Extension',)
 
@@ -19,5 +19,5 @@ class Extension:
     def __init__(self, parser: AbstractParser):
         self.parser = parser
 
-    def apply(self, state: PSAfter) -> ParseState:
+    def apply(self, state: AfterParsing) -> ParsingState:
         raise NotImplementedError

bu4/parsing/extensions/xcall.py

@@ -2,14 +2,14 @@
 
 from bu4.parsing.codes import CODE_CALL
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psafter import PSAfter
-from bu4.parsing.states.pscall import pscall
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.states.parsing_call import parsing_call
 
 __all__ = ('XCall',)
 
 
 class XCall(Extension, code=CODE_CALL):
-    def apply(self, state: PSAfter) -> ParseState:
-        state.state = pscall()
+    def apply(self, state: AfterParsing) -> ParsingState:
+        state.state = parsing_call()
         return state

bu4/parsing/extensions/xmake.py

@@ -3,23 +3,23 @@
 from bu4.parsing.codes import CODE_MAKE
 from bu4.parsing.constructs.plambda import PLambda
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psafter import PSAfter
-from bu4.parsing.states.psfinal import PSFinal
-from bu4.parsing.states.psread import PSRead
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.states.parsingfinished import ParsingFinished
+from bu4.parsing.states.parsingread import ParsingRead
 
 __all__ = ('XMake',)
 
-from bu4.parsing.targets.pslambda import PSLambda
+from bu4.parsing.targets.aplambda import APLambda
 
 
 class XMake(Extension, code=CODE_MAKE):
-    def apply(self, state: PSAfter) -> ParseState:
+    def apply(self, state: AfterParsing) -> ParsingState:
         name = self.parser.parse_name()
-        state.state = PSAfter(
-            PSRead(),
-            PSLambda(
-                lambda value: PSFinal(PLambda(name, value))
+        state.state = AfterParsing(
+            ParsingRead(),
+            APLambda(
+                lambda value: ParsingFinished(PLambda(name, value))
             )
         )
         return state

bu4/parsing/extensions/xname.py

@@ -3,14 +3,14 @@
 from bu4.parsing.codes import CODE_NAME
 from bu4.parsing.constructs.pname import PName
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psafter import PSAfter
-from bu4.parsing.states.psfinal import PSFinal
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.states.parsingfinished import ParsingFinished
 
 __all__ = ('XName',)
 
 
 class XName(Extension, code=CODE_NAME):
-    def apply(self, state: PSAfter) -> ParseState:
-        state.state = PSFinal(PName(self.parser.parse_name()))
+    def apply(self, state: AfterParsing) -> ParsingState:
+        state.state = ParsingFinished(PName(self.parser.parse_name()))
         return state

bu4/parsing/extensions/xnull.py

@@ -3,14 +3,14 @@
 from bu4.parsing.codes import CODE_NULL
 from bu4.parsing.constructs.pnull import PNull
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psafter import PSAfter
-from bu4.parsing.states.psfinal import PSFinal
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.states.parsingfinished import ParsingFinished
 
 __all__ = ('XNull',)
 
 
 class XNull(Extension, code=CODE_NULL):
-    def apply(self, state: PSAfter) -> ParseState:
-        state.state = PSFinal(PNull())
+    def apply(self, state: AfterParsing) -> ParsingState:
+        state.state = ParsingFinished(PNull())
         return state

bu4/parsing/extensions/xqopn.py

@@ -2,15 +2,15 @@
 
 from bu4.parsing.codes import CODE_QOPN, CODE_QCLS
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psafter import PSAfter
-from bu4.parsing.targets.pschain import PSChain
-from bu4.parsing.targets.psendswith import PSEndsWith
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.targets.apchain import APChain
+from bu4.parsing.targets.apendswith import APEndsWith
 
 __all__ = ('XQopn',)
 
 
 class XQopn(Extension, code=CODE_QOPN):
-    def apply(self, state: PSAfter) -> ParseState:
-        state.target = PSChain(PSEndsWith(self.parser, CODE_QCLS, 'quot expected'), state.target)
+    def apply(self, state: AfterParsing) -> ParsingState:
+        state.target = APChain(APEndsWith(self.parser, CODE_QCLS, 'quot expected'), state.target)
         return state

bu4/parsing/extensions/xquot.py

@@ -2,15 +2,15 @@
 
 from bu4.parsing.codes import CODE_QUOT
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psafter import PSAfter
-from bu4.parsing.targets.pschain import PSChain
-from bu4.parsing.targets.psendswith import PSEndsWith
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.targets.apchain import APChain
+from bu4.parsing.targets.apendswith import APEndsWith
 
 __all__ = ('XQuot',)
 
 
 class XQuot(Extension, code=CODE_QUOT):
-    def apply(self, state: PSAfter) -> ParseState:
-        state.target = PSChain(PSEndsWith(self.parser, CODE_QUOT, 'quot expected'), state.target)
+    def apply(self, state: AfterParsing) -> ParsingState:
+        state.target = APChain(APEndsWith(self.parser, CODE_QUOT, 'quot expected'), state.target)
         return state

bu4/parsing/extensions/xskip.py

@@ -2,12 +2,12 @@
 
 from bu4.parsing.codes import CODE_SKIP
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psafter import PSAfter
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.afterparsing import AfterParsing
 
 __all__ = ('XSkip',)
 
 
 class XSkip(Extension, code=CODE_SKIP):
-    def apply(self, state: PSAfter) -> ParseState:
+    def apply(self, state: AfterParsing) -> ParsingState:
         return state

bu4/parsing/extensions/xxcpt.py

@@ -3,14 +3,14 @@
 from bu4.parsing.codes import CODE_XCPT
 from bu4.parsing.constructs.pexception import PException
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psafter import PSAfter
-from bu4.parsing.states.psfinal import PSFinal
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.states.parsingfinished import ParsingFinished
 
 __all__ = ('XXcpt',)
 
 
 class XXcpt(Extension, code=CODE_XCPT):
-    def apply(self, state: PSAfter) -> ParseState:
-        state.state = PSFinal(PException(self.parser.parse_name()))
+    def apply(self, state: AfterParsing) -> ParsingState:
+        state.state = ParsingFinished(PException(self.parser.parse_name()))
         return state

bu4/parsing/parser.py

@@ -6,12 +6,12 @@ from typing import Iterable, Type
 from bu4.parsing.abstractparser import AbstractParser
 from bu4.parsing.constructs.parsed import Parsed
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psafter import PSAfter
-from bu4.parsing.states.psfinal import PSFinal
-from bu4.parsing.states.psread import PSRead
-from bu4.parsing.targets.pschain import PSChain
-from bu4.parsing.targets.pslambda import PSLambda
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.states.parsingfinished import ParsingFinished
+from bu4.parsing.states.parsingread import ParsingRead
+from bu4.parsing.targets.apchain import APChain
+from bu4.parsing.targets.aplambda import APLambda
 
 __all__ = ('Parser',)
 
@@ -37,7 +37,7 @@ class Parser(AbstractParser):
                 return s.getvalue()
             s.write(bytes([c]))
 
-    def _state_read(self, state: PSAfter) -> ParseState:
+    def _state_read(self, state: AfterParsing) -> ParsingState:
         code = self.read()
         extension = self.__extensions.get(code)
         if extension is None:
@@ -45,23 +45,23 @@ class Parser(AbstractParser):
         state = extension.apply(state)
         return state
 
-    def _state_next(self, state: PSAfter) -> ParseState:
-        if isinstance(state.state, PSAfter):
-            state.state, state.target = state.state.state, PSChain(state.state.target, state.target)
-        elif isinstance(state.state, PSFinal):
+    def _state_next(self, state: AfterParsing) -> ParsingState:
+        if isinstance(state.state, AfterParsing):
+            state.state, state.target = state.state.state, APChain(state.state.target, state.target)
+        elif isinstance(state.state, ParsingFinished):
             state = state.target.given(state.state.parsed)
-        elif isinstance(state.state, PSRead):
+        elif isinstance(state.state, ParsingRead):
             state = self._state_read(state)
         else:
             raise TypeError
         return state
 
     def parse(self) -> Parsed:
-        state = PSAfter(PSRead(), PSLambda(lambda parsed: PSFinal(parsed)))
+        state = AfterParsing(ParsingRead(), APLambda(lambda parsed: ParsingFinished(parsed)))
         while True:
-            if isinstance(state, PSFinal):
+            if isinstance(state, ParsingFinished):
                 return state.parsed
-            elif isinstance(state, PSAfter):
+            elif isinstance(state, AfterParsing):
                 state = self._state_next(state)
             else:
                 raise TypeError

bu4/parsing/states/afterparsing.py

@@ -0,0 +1,12 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.targets.aptarget import APTarget
+
+__all__ = ('AfterParsing',)
+
+
+class AfterParsing(ParsingState):
+    def __init__(self, state: ParsingState, target: APTarget):
+        self.state = state
+        self.target = target

bu4/parsing/states/parsing_call.py

@@ -0,0 +1,28 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.parsing.constructs.pcall import PCall
+from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.states.parsingfinished import ParsingFinished
+from bu4.parsing.states.parsingread import ParsingRead
+from bu4.parsing.targets.aplambda import APLambda
+
+__all__ = ('parsing_call',)
+
+
+def parsing_call():
+    return AfterParsing(
+        ParsingRead(),
+        APLambda(
+            lambda argument: AfterParsing(
+                ParsingRead(),
+                APLambda(
+                    lambda lambda_: ParsingFinished(
+                        PCall(
+                            argument,
+                            lambda_
+                        )
+                    )
+                )
+            )
+        )
+    )

bu4/parsing/states/parsingfinished.py

@@ -1,11 +1,11 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.parsing.constructs.parsed import Parsed
-from bu4.parsing.states.parsestate import ParseState
+from bu4.parsing.states.parsingstate import ParsingState
 
-__all__ = ('PSFinal',)
+__all__ = ('ParsingFinished',)
 
 
-class PSFinal(ParseState):
+class ParsingFinished(ParsingState):
     def __init__(self, parsed: Parsed):
         self.parsed = parsed

bu4/parsing/states/parsingread.py

@@ -0,0 +1,9 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.parsing.states.parsingstate import ParsingState
+
+__all__ = ('ParsingRead',)
+
+
+class ParsingRead(ParsingState):
+    pass

bu4/parsing/states/parsingstate.py

@@ -1,7 +1,7 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
-__all__ = ('ParseState',)
+__all__ = ('ParsingState',)
 
 
-class ParseState:
+class ParsingState:
     pass

bu4/parsing/states/psafter.py

@@ -1,12 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.targets.pstarget import PSTarget
-
-__all__ = ('PSAfter',)
-
-
-class PSAfter(ParseState):
-    def __init__(self, state: ParseState, target: PSTarget):
-        self.state = state
-        self.target = target

bu4/parsing/states/pscall.py

@@ -1,28 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from bu4.parsing.constructs.pcall import PCall
-from bu4.parsing.states.psafter import PSAfter
-from bu4.parsing.states.psfinal import PSFinal
-from bu4.parsing.states.psread import PSRead
-from bu4.parsing.targets.pslambda import PSLambda
-
-__all__ = ('pscall',)
-
-
-def pscall():
-    return PSAfter(
-        PSRead(),
-        PSLambda(
-            lambda argument: PSAfter(
-                PSRead(),
-                PSLambda(
-                    lambda lambda_: PSFinal(
-                        PCall(
-                            argument,
-                            lambda_
-                        )
-                    )
-                )
-            )
-        )
-    )

bu4/parsing/states/psread.py

@@ -1,9 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from bu4.parsing.states.parsestate import ParseState
-
-__all__ = ('PSRead',)
-
-
-class PSRead(ParseState):
-    pass

bu4/parsing/targets/apchain.py

@@ -0,0 +1,17 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.parsing.constructs.parsed import Parsed
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.targets.aptarget import APTarget
+
+__all__ = ('APChain',)
+
+
+class APChain(APTarget):
+    def __init__(self, target: APTarget, aftertarget: APTarget):
+        self.target = target
+        self.aftertarget = aftertarget
+
+    def given(self, parsed: Parsed) -> ParsingState:
+        return AfterParsing(self.target.given(parsed), self.aftertarget)

bu4/parsing/targets/apendswith.py

@@ -2,19 +2,19 @@
 
 from bu4.parsing.abstractparser import AbstractParser
 from bu4.parsing.constructs.parsed import Parsed
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psfinal import PSFinal
-from bu4.parsing.targets.pstarget import PSTarget
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.states.parsingfinished import ParsingFinished
+from bu4.parsing.targets.aptarget import APTarget
 
-__all__ = ('PSEndsWith',)
+__all__ = ('APEndsWith',)
 
 
-class PSEndsWith(PSTarget):
+class APEndsWith(APTarget):
     def __init__(self, parser: AbstractParser, expected: int, message: str):
         self.parser = parser
         self.expected = expected
         self.message = message
 
-    def given(self, parsed: Parsed) -> ParseState:
+    def given(self, parsed: Parsed) -> ParsingState:
         assert self.parser.read() == self.expected, self.message
-        return PSFinal(parsed)
+        return ParsingFinished(parsed)

bu4/parsing/targets/aplambda.py

@@ -0,0 +1,17 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import Callable
+
+from bu4.parsing.constructs.parsed import Parsed
+from bu4.parsing.states.parsingstate import ParsingState
+from bu4.parsing.targets.aptarget import APTarget
+
+__all__ = ('APLambda',)
+
+
+class APLambda(APTarget):
+    def __init__(self, lambda_: Callable[[Parsed], ParsingState]):
+        self.lambda_ = lambda_
+
+    def given(self, parsed: Parsed) -> ParsingState:
+        return self.lambda_(parsed)

bu4/parsing/targets/aptarget.py

@@ -0,0 +1,11 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from bu4.parsing.constructs.parsed import Parsed
+from bu4.parsing.states.parsingstate import ParsingState
+
+__all__ = ('APTarget',)
+
+
+class APTarget:
+    def given(self, parsed: Parsed) -> ParsingState:
+        raise NotImplementedError

bu4/parsing/targets/pschain.py

@@ -1,17 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from bu4.parsing.constructs.parsed import Parsed
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.states.psafter import PSAfter
-from bu4.parsing.targets.pstarget import PSTarget
-
-__all__ = ('PSChain',)
-
-
-class PSChain(PSTarget):
-    def __init__(self, target: PSTarget, aftertarget: PSTarget):
-        self.target = target
-        self.aftertarget = aftertarget
-
-    def given(self, parsed: Parsed) -> ParseState:
-        return PSAfter(self.target.given(parsed), self.aftertarget)

bu4/parsing/targets/pslambda.py

@@ -1,17 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from typing import Callable
-
-from bu4.parsing.constructs.parsed import Parsed
-from bu4.parsing.states.parsestate import ParseState
-from bu4.parsing.targets.pstarget import PSTarget
-
-__all__ = ('PSLambda',)
-
-
-class PSLambda(PSTarget):
-    def __init__(self, lambda_: Callable[[Parsed], ParseState]):
-        self.lambda_ = lambda_
-
-    def given(self, parsed: Parsed) -> ParseState:
-        return self.lambda_(parsed)

bu4/parsing/targets/pstarget.py

@@ -1,11 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from bu4.parsing.constructs.parsed import Parsed
-from bu4.parsing.states.parsestate import ParseState
-
-__all__ = ('PSTarget',)
-
-
-class PSTarget:
-    def given(self, parsed: Parsed) -> ParseState:
-        raise NotImplementedError

bu4/tracing/probe.py

@@ -1,9 +1,9 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
-from bu4.evaluation.constructs.elambda import ELambda
 from bu4.evaluation.constructs.evaluable import Evaluable
 from bu4.evaluation.constructs.evalue import EValue
-from bu4.evaluation.sync import sync
+
+__all__ = ('Probe', 'ProbeA',)
 
 
 class Probe(EValue):
@@ -33,17 +33,3 @@ class ProbeB(Probe):
     def __init__(self, prev: Probe, argument):
         self.prev = prev
         self.argument = argument
-
-
-_probe_index = 0
-
-
-def trace(lambda_: EValue):
-    global _probe_index
-    size = 0
-    while True:
-        if not isinstance(lambda_, ELambda):
-            return size, lambda_
-        lambda_ = sync(lambda_.call(ProbeA(_probe_index)))
-        _probe_index += 1
-        size += 1

bu4/tracing/trace.py

@@ -0,0 +1,20 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+from bu4.evaluation.constructs.elambda import ELambda
+from bu4.evaluation.constructs.evalue import EValue
+from bu4.evaluation.sync import sync
+from bu4.tracing.probe import ProbeA
+
+__all__ = ('trace',)
+
+_probe_index = 0
+
+
+def trace(lambda_: EValue):
+    global _probe_index
+    size = 0
+    while True:
+        if not isinstance(lambda_, ELambda):
+            return size, lambda_
+        lambda_ = sync(lambda_.call(ProbeA(_probe_index)))
+        _probe_index += 1
+        size += 1

docs/extensions.md

@@ -10,6 +10,7 @@ Common:
 * Quot
 * Qopn-Qcls
 * Skip
+* Delayed
 
 Special:
 * Namespaces (evaluable imports)

main.py

@@ -5,9 +5,10 @@ from collections import deque
 from bu4.common_interface import with_common_interface
 from bu4.evaluation.constructs.proxy import antiproxy, eproxy
 from bu4.evaluation.sync import sync
+from bu4.isynced import isynced as synced
 from bu4.parsing.toolchain.readfile import readfile
-from bu4.synced import synced
-from bu4.tracing.probe import trace, Probe
+from bu4.tracing.probe import Probe
+from bu4.tracing.trace import trace
 from timesample import TimeSample
 
 with TimeSample('all'):