TransformState + EAttachable

bu4/evaluation/av/lambdaenv.py

@@ -4,7 +4,7 @@ from typing import Mapping, Iterator
 
 from bu4.evaluation.av.envtype import envtype
 from bu4.evaluation.constructs.evaluable import Evaluable
-from bu4.evaluation.targets.avcontainer import AVContainer
+from bu4.evaluation.targets.avnamedcontainer import AVNamedContainer
 
 __all__ = ('LambdaEnv',)
 
@@ -26,7 +26,7 @@ class LambdaEnv(Mapping[bytes, Evaluable]):
     def __init__(self, env: envtype, name: bytes, evaluable: Evaluable, *, memoize):
         self.env = env
         self.name = name
-        self.container = AVContainer(evaluable, name).after_value if memoize else evaluable
+        self.container = AVNamedContainer(evaluable, name).after_value if memoize else evaluable
 
     @staticmethod
     def strfy(self):

bu4/evaluation/av/lambdaev.py

@@ -4,7 +4,7 @@ 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
+from bu4.evaluation.targets.avanonymouscontainer import AVAnonymousContainer
 
 __all__ = ('LambdaEv',)
 
@@ -21,4 +21,4 @@ class LambdaEv(Sequence[Evaluable]):
 
     def __init__(self, ev: evtype, evaluable: Evaluable, *, memoize):
         self.ev = ev
-        self.container = AVIContainer(evaluable).after_value if memoize else evaluable
+        self.container = AVAnonymousContainer(evaluable).after_value if memoize else evaluable

bu4/evaluation/constructs/attachable.py

@@ -0,0 +1,14 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import Generic, TypeVar
+
+__all__ = ('Attachable',)
+
+from bu4.evaluation.constructs.evaluable import Evaluable
+
+T = TypeVar('T')
+
+
+class Attachable(Generic[T]):
+    def attach(self, t: T) -> Evaluable:
+        raise NotImplementedError

bu4/evaluation/constructs/eattachable.py

@@ -0,0 +1,22 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import TypeVar, Generic
+
+from bu4.evaluation.constructs.attachable import Attachable
+from bu4.evaluation.constructs.evaluable import Evaluable
+
+__all__ = ('EAttachable',)
+
+T = TypeVar('T')
+
+
+class EAttachable(Evaluable, Generic[T]):
+    def __init__(self, t: T, attachable: Attachable[T]):
+        self.t = t
+        self.attachable = attachable
+
+    def next(self) -> Evaluable:
+        return self.attachable.attach(self.t)
+
+    def __str__(self):
+        return f'{self.attachable}'

bu4/evaluation/constructs/edelayed.py

@@ -1,7 +1,7 @@
 #  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.eattachable import EAttachable
 from bu4.evaluation.constructs.evaluable import Evaluable
 from bu4.evaluation.constructs.evalue import EValue
 from bu4.linking.constructs.linked import Linked
@@ -13,7 +13,7 @@ class EDelayed(EValue):
     def __init__(self, env: envtype, value: Linked):
         self.env = env
         self.value = value
-        self.evaluable = ELinked(
+        self.evaluable = EAttachable(
             self.env,
             self.value
         )

bu4/evaluation/constructs/eidelayed.py

@@ -1,7 +1,7 @@
 #  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.eattachable import EAttachable
 from bu4.evaluation.constructs.evaluable import Evaluable
 from bu4.evaluation.constructs.evalue import EValue
 from bu4.indexing.constructs.indexed import Indexed
@@ -13,7 +13,7 @@ class EIDelayed(EValue):
     def __init__(self, ev: evtype, value: Indexed):
         self.ev = ev
         self.value = value
-        self.evaluable = EIndexed(
+        self.evaluable = EAttachable(
             self.ev,
             self.value
         )

bu4/evaluation/constructs/eilambda.py

@@ -2,7 +2,7 @@
 
 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.eattachable import EAttachable
 from bu4.evaluation.constructs.evaluable import Evaluable
 from bu4.evaluation.constructs.evalue import EValue
 from bu4.indexing.constructs.indexed import Indexed
@@ -17,7 +17,7 @@ class EILambda(EValue):
         self.memoize = memoize
 
     def call(self, argument: Evaluable) -> Evaluable:
-        return EIndexed(
+        return EAttachable(
             LambdaEv(self.ev, argument, memoize=self.memoize),
             self.value
         )

bu4/evaluation/constructs/eindexed.py

@@ -1,19 +0,0 @@
-#  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/constructs/elambda.py

@@ -2,7 +2,7 @@
 
 from bu4.evaluation.av.envtype import envtype
 from bu4.evaluation.av.lambdaenv import LambdaEnv
-from bu4.evaluation.constructs.elinked import ELinked
+from bu4.evaluation.constructs.eattachable import EAttachable
 from bu4.evaluation.constructs.evaluable import Evaluable
 from bu4.evaluation.constructs.evalue import EValue
 from bu4.linking.constructs.linked import Linked
@@ -19,7 +19,7 @@ class ELambda(EValue):
         self.memoize = name in value.multifuture
 
     def call(self, argument: Evaluable) -> Evaluable:
-        return ELinked(
+        return EAttachable(
             LambdaEnv(self.env, self.name, argument, memoize=self.memoize) if self.used else self.env,
             self.value
         )

bu4/evaluation/constructs/elinked.py

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

bu4/evaluation/targets/avIcall.py

@@ -1,22 +0,0 @@
-#  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/avanonymouscontainer.py

@@ -5,10 +5,10 @@ from bu4.evaluation.constructs.evaluable import Evaluable
 from bu4.evaluation.constructs.evalue import EValue
 from bu4.evaluation.targets.avtarget import AVTarget
 
-__all__ = ('AVIContainer',)
+__all__ = ('AVAnonymousContainer',)
 
 
-class AVIContainer(AVTarget):
+class AVAnonymousContainer(AVTarget):
     def __init__(self, evaluable: Evaluable):
         self.after_value = AfterValue(evaluable, self)
 

bu4/evaluation/targets/avcall.py

@@ -1,22 +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 typing import TypeVar, Generic
+
+from bu4.evaluation.constructs.attachable import Attachable
+from bu4.evaluation.constructs.eattachable import EAttachable
 from bu4.evaluation.constructs.evaluable import Evaluable
 from bu4.evaluation.constructs.evalue import EValue
 from bu4.evaluation.targets.avtarget import AVTarget
-from bu4.linking.constructs.linked import Linked
 
 __all__ = ('AVCall',)
 
+T = TypeVar('T')
 
-class AVCall(AVTarget):
-    def __init__(self, env: envtype, argument: Linked):
-        self.env = env
+
+class AVCall(AVTarget, Generic[T]):
+    def __init__(self, t: T, argument: Attachable[T]):
+        self.t = t
         self.argument = argument
 
     def given(self, value: EValue) -> Evaluable:
-        return value.call(ELinked(self.env, self.argument))
+        return value.call(EAttachable(self.t, self.argument))
 
     def __str__(self):
         return f'({self.argument})'

bu4/evaluation/targets/avnamedcontainer.py

@@ -5,10 +5,10 @@ from bu4.evaluation.constructs.evaluable import Evaluable
 from bu4.evaluation.constructs.evalue import EValue
 from bu4.evaluation.targets.avtarget import AVTarget
 
-__all__ = ('AVContainer',)
+__all__ = ('AVNamedContainer',)
 
 
-class AVContainer(AVTarget):
+class AVNamedContainer(AVTarget):
     def __init__(self, evaluable: Evaluable, name: bytes):
         self.after_value = AfterValue(evaluable, self)
         self.name = name

bu4/indexing/constructs/icall.py

@@ -2,9 +2,9 @@
 
 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.eattachable import EAttachable
 from bu4.evaluation.constructs.evaluable import Evaluable
-from bu4.evaluation.targets.avIcall import AVICall
+from bu4.evaluation.targets.avcall import AVCall
 from bu4.indexing.constructs.indexed import Indexed
 from bu4.parsing.codes import CODE_CALL
 
@@ -16,8 +16,8 @@ class ICall(Indexed):
         self.argument = argument
         self.lambda_ = lambda_
 
-    def evaluable(self, ev: evtype) -> Evaluable:
-        return AfterValue(EIndexed(ev, self.lambda_), AVICall(ev, self.argument))
+    def attach(self, ev: evtype) -> Evaluable:
+        return AfterValue(EAttachable(ev, self.lambda_), AVCall(ev, self.argument))
 
     def __str__(self):
         return f'/{self.argument}{self.lambda_}'

bu4/indexing/constructs/idelayed.py

@@ -13,7 +13,7 @@ class IDelayed(Indexed):
     def __init__(self, value: Indexed):
         self.value = value
 
-    def evaluable(self, ev: evtype) -> Evaluable:
+    def attach(self, ev: evtype) -> Evaluable:
         return EIDelayed(
             ev,
             self.value

bu4/indexing/constructs/iexception.py

@@ -13,7 +13,7 @@ class IException(Indexed):
     def __init__(self, name: bytes):
         self.name = name
 
-    def evaluable(self, ev: evtype) -> Evaluable:
+    def attach(self, ev: evtype) -> Evaluable:
         return EException(self.name)
 
     def __str__(self):

bu4/indexing/constructs/ilambda.py

@@ -15,7 +15,7 @@ class ILambda(Indexed):
         self.table = table
         self.memoize = memoize
 
-    def evaluable(self, ev: evtype) -> Evaluable:
+    def attach(self, ev: evtype) -> Evaluable:
         return EILambda(
             [ev[i] for i in self.table],
             self.value,

bu4/indexing/constructs/iname.py

@@ -12,7 +12,7 @@ class IName(Indexed):
     def __init__(self, index: int):
         self.index = index
 
-    def evaluable(self, ev: evtype) -> Evaluable:
+    def attach(self, ev: evtype) -> Evaluable:
         return ev[self.index]
 
     def __str__(self):

bu4/indexing/constructs/indexed.py

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

bu4/indexing/constructs/inull.py

@@ -10,7 +10,7 @@ __all__ = ('INull',)
 
 
 class INull(Indexed):
-    def evaluable(self, ev: evtype) -> Evaluable:
+    def attach(self, ev: evtype) -> Evaluable:
         return ENull()
 
     def __str__(self):

bu4/indexing/index_finish.py

@@ -1,32 +0,0 @@
-#  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

@@ -1,12 +0,0 @@
-#  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

@@ -1,11 +0,0 @@
-#  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

@@ -1,12 +0,0 @@
-#  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

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

bu4/indexing/targets/aichain.py

@@ -1,17 +0,0 @@
-#  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

@@ -1,17 +0,0 @@
-#  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

@@ -1,11 +0,0 @@
-#  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

@@ -2,11 +2,10 @@
 
 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
+from bu4.transform.transform import transform
 
 __all__ = ('isynced',)
 
@@ -14,7 +13,7 @@ __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([])
+    linked = transform(parsed.link(set()))
+    indexed = transform(linked.index([]))
+    evaluable = indexed.attach([])
     return sync(evaluable)

bu4/linking/constructs/lcall.py

@@ -2,16 +2,17 @@
 
 from bu4.evaluation.av.aftervalue import AfterValue
 from bu4.evaluation.av.envtype import envtype
-from bu4.evaluation.constructs.elinked import ELinked
+from bu4.evaluation.constructs.eattachable import EAttachable
 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.indexing.constructs.indexed import Indexed
 from bu4.linking.constructs.linked import Linked
+from bu4.transform.states.aftertransform import AfterTransform
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstart import TransformStart
+from bu4.transform.states.transformstate import TransformState
+from bu4.transform.targets.atlambda import ATLambda
 
 __all__ = ('LCall',)
 
@@ -30,17 +31,17 @@ class LCall(Linked):
                 (self.argument.future & self.lambda_.future)
         )
 
-    def evaluable(self, env: envtype) -> Evaluable:
-        return AfterValue(ELinked(env, self.lambda_), AVCall(env, self.argument))
+    def attach(self, env: envtype) -> Evaluable:
+        return AfterValue(EAttachable(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 index(self, promise: list[bytes]) -> TransformState[Indexed]:
+        return AfterTransform(
+            TransformStart(lambda: self.argument.index(promise)),
+            ATLambda(
+                lambda argument: AfterTransform(
+                    TransformStart(lambda: self.lambda_.index(promise)),
+                    ATLambda(
+                        lambda lambda_: TransformFinished(ICall(argument, lambda_))
                     )
                 )
             )

bu4/linking/constructs/lexception.py

@@ -4,9 +4,10 @@ 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.indexing.constructs.indexed import Indexed
 from bu4.linking.constructs.linked import Linked
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('LException',)
 
@@ -17,11 +18,11 @@ class LException(Linked):
         self.future = set()
         self.multifuture = set()
 
-    def evaluable(self, env: envtype) -> Evaluable:
+    def attach(self, env: envtype) -> Evaluable:
         return EException(self.name)
 
-    def index(self, promise: list[bytes]) -> IndexingState:
-        return IndexingFinished(IException(self.name))
+    def index(self, promise: list[bytes]) -> TransformState[Indexed]:
+        return TransformFinished(IException(self.name))
 
     def __str__(self):
         return f'«{self.name.decode()}»'

bu4/linking/constructs/linked.py

@@ -1,19 +1,20 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.evaluation.av.envtype import envtype
+from bu4.evaluation.constructs.attachable import Attachable
 from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.indexing.constructs.indexed import Indexed
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('Linked',)
 
-from bu4.indexing.states.indexingstate import IndexingState
 
-
-class Linked:
+class Linked(Attachable[envtype]):
     future: set[bytes]
     multifuture: set[bytes]
 
-    def evaluable(self, env: envtype) -> Evaluable:
+    def attach(self, env: envtype) -> Evaluable:
         raise NotImplementedError
 
-    def index(self, promise: list[bytes]) -> IndexingState:
+    def index(self, promise: list[bytes]) -> TransformState[Indexed]:
         raise NotImplementedError

bu4/linking/constructs/llambda.py

@@ -6,12 +6,13 @@ 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.indexing.constructs.indexed import Indexed
 from bu4.linking.constructs.linked import Linked
+from bu4.transform.states.aftertransform import AfterTransform
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstart import TransformStart
+from bu4.transform.states.transformstate import TransformState
+from bu4.transform.targets.atlambda import ATLambda
 
 __all__ = ('LLambda',)
 
@@ -27,7 +28,7 @@ class LLambda(Linked):
         self.used = name in value.future
         self.memoize = name in value.multifuture
 
-    def evaluable(self, env: envtype) -> Evaluable:
+    def attach(self, env: envtype) -> Evaluable:
         return (
             ELambda(
                 {name: env[name] for name in self.future} if self.used else env,
@@ -40,20 +41,20 @@ class LLambda(Linked):
             EDelayed(env, self.value)
         )
 
-    def index(self, promise: list[bytes]) -> IndexingState:
+    def index(self, promise: list[bytes]) -> TransformState[Indexed]:
         if not self.used:
-            return AfterIndexing(
-                IndexingLinked(promise, self.value),
-                AILambda(
-                    lambda value: IndexingFinished(IDelayed(value))
+            return AfterTransform(
+                TransformStart(lambda: self.value.index(promise)),
+                ATLambda(
+                    lambda value: TransformFinished(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(
+            return AfterTransform(
+                TransformStart(lambda: self.value.index([self.name] + [promise[i] for i in table])),
+                ATLambda(
+                    lambda value: TransformFinished(ILambda(
                         value,
                         table,
                         memoize=self.memoize

bu4/linking/constructs/lname.py

@@ -3,9 +3,10 @@
 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.indexing.constructs.indexed import Indexed
 from bu4.linking.constructs.linked import Linked
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('LName',)
 
@@ -16,11 +17,11 @@ class LName(Linked):
         self.future = {name}
         self.multifuture = set()
 
-    def evaluable(self, env: envtype) -> Evaluable:
+    def attach(self, env: envtype) -> Evaluable:
         return env[self.name]
 
-    def index(self, promise: list[bytes]) -> IndexingState:
-        return IndexingFinished(IName(promise.index(self.name)))
+    def index(self, promise: list[bytes]) -> TransformState[Indexed]:
+        return TransformFinished(IName(promise.index(self.name)))
 
     def __str__(self):
         return f'[{self.name.decode()}]'

bu4/linking/constructs/lnull.py

@@ -3,10 +3,11 @@
 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.indexed import Indexed
 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
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('LNull',)
 
@@ -16,11 +17,11 @@ class LNull(Linked):
         self.future = set()
         self.multifuture = set()
 
-    def evaluable(self, env: envtype) -> Evaluable:
+    def attach(self, env: envtype) -> Evaluable:
         return ENull()
 
-    def index(self, promise: list[bytes]) -> IndexingState:
-        return IndexingFinished(INull())
+    def index(self, promise: list[bytes]) -> TransformState[Indexed]:
+        return TransformFinished(INull())
 
     def __str__(self):
         return '?'

bu4/linking/evaluable_from_parsed.py

@@ -1,14 +1,13 @@
 #  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.linking.link_finish import link_finish
+from bu4.evaluation.constructs.eattachable import EAttachable
+from bu4.parsing.constructs.parsed import Parsed
+from bu4.transform.transform import transform
 
 __all__ = ('evaluable_from_parsed',)
 
-from bu4.parsing.constructs.parsed import Parsed
-
 
 def evaluable_from_parsed(env: envtype, parsed: Parsed):
-    linked = link_finish(parsed.link(set(env)))
-    return ELinked(env, linked)
+    linked = transform(parsed.link(set(env)))
+    return EAttachable(env, linked)

bu4/linking/link_finish.py

@@ -1,32 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from bu4.linking.states.afterlinking import AfterLinking
-from bu4.linking.states.linkingfinished import LinkingFinished
-from bu4.linking.states.linkingparsed import LinkingParsed
-from bu4.linking.states.linkingstate import LinkingState
-from bu4.linking.targets.alchain import ALChain
-from bu4.linking.constructs.linked import Linked
-
-__all__ = ('link_finish',)
-
-
-def _afterlinking_iteration(state: AfterLinking) -> LinkingState:
-    if isinstance(state.state, LinkingFinished):
-        state = state.target.given(state.state.linked)
-    elif isinstance(state.state, AfterLinking):
-        state.state, state.target = state.state.state, ALChain(state.state.target, state.target)
-    elif isinstance(state.state, LinkingParsed):
-        state.state = state.state.parsed.link(state.state.promise)
-    else:
-        raise TypeError
-    return state
-
-
-def link_finish(state: LinkingState) -> Linked:
-    while True:
-        if isinstance(state, LinkingFinished):
-            return state.linked
-        elif isinstance(state, AfterLinking):
-            state = _afterlinking_iteration(state)
-        else:
-            raise TypeError

bu4/linking/states/afterlinking.py

@@ -1,12 +0,0 @@
-#  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',)
-
-
-class AfterLinking(LinkingState):
-    def __init__(self, state: LinkingState, target: ALTarget):
-        self.state = state
-        self.target = target

bu4/linking/states/linkingfinished.py

@@ -1,11 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from bu4.linking.states.linkingstate import LinkingState
-from bu4.linking.constructs.linked import Linked
-
-__all__ = ('LinkingFinished',)
-
-
-class LinkingFinished(LinkingState):
-    def __init__(self, linked: Linked):
-        self.linked = linked

bu4/linking/states/linkingparsed.py

@@ -1,12 +0,0 @@
-#  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',)
-
-
-class LinkingParsed(LinkingState):
-    def __init__(self, promise: set[bytes], parsed: Parsed):
-        self.promise = promise
-        self.parsed = parsed

bu4/linking/states/linkingstate.py

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

bu4/linking/targets/alchain.py

@@ -1,17 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from bu4.linking.states.afterlinking import AfterLinking
-from bu4.linking.states.linkingstate import LinkingState
-from bu4.linking.targets.altarget import ALTarget
-from bu4.linking.constructs.linked import Linked
-
-__all__ = ('ALChain',)
-
-
-class ALChain(ALTarget):
-    def __init__(self, target: ALTarget, aftertarget: ALTarget):
-        self.target = target
-        self.aftertarget = aftertarget
-
-    def given(self, linked: Linked) -> LinkingState:
-        return AfterLinking(self.target.given(linked), self.aftertarget)

bu4/linking/targets/allambda.py

@@ -1,17 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from typing import Callable
-
-from bu4.linking.states.linkingstate import LinkingState
-from bu4.linking.targets.altarget import ALTarget
-from bu4.linking.constructs.linked import Linked
-
-__all__ = ('ALLambda',)
-
-
-class ALLambda(ALTarget):
-    def __init__(self, lambda_: Callable[[Linked], LinkingState]):
-        self.lambda_ = lambda_
-
-    def given(self, linked: Linked) -> LinkingState:
-        return self.lambda_(linked)

bu4/linking/targets/altarget.py

@@ -1,11 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from bu4.linking.states.linkingstate import LinkingState
-from bu4.linking.constructs.linked import Linked
-
-__all__ = ('ALTarget',)
-
-
-class ALTarget:
-    def given(self, linked: Linked) -> LinkingState:
-        raise NotImplementedError

bu4/parsing/abstractparser.py

@@ -1,12 +1,20 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from typing import TypeVar, Generic
+
+from bu4.parsing.extensions.abstractextension import AbstractExtension
 
 __all__ = ('AbstractParser',)
 
+T = TypeVar('T')
 
-class AbstractParser:
+
+class AbstractParser(Generic[T]):
     def read(self) -> int:
         raise NotImplementedError
 
     def parse_name(self) -> bytes:
         raise NotImplementedError
+
+    def extension_for(self, code: int) -> AbstractExtension[T]:
+        raise NotImplementedError

bu4/parsing/constructs/parsed.py

@@ -1,10 +1,11 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from bu4.linking.constructs.linked import Linked
+from bu4.transform.states.transformstate import TransformState
+
 __all__ = ('Parsed',)
 
-from bu4.linking.states.linkingstate import LinkingState
-
 
 class Parsed:
-    def link(self, promise: set[bytes]) -> LinkingState:
+    def link(self, promise: set[bytes]) -> TransformState[Linked]:
         raise NotImplementedError

bu4/parsing/constructs/pcall.py

@@ -1,14 +1,15 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
-__all__ = ('PCall',)
-
 from bu4.linking.constructs.lcall import LCall
-from bu4.linking.states.afterlinking import AfterLinking
-from bu4.linking.states.linkingfinished import LinkingFinished
-from bu4.linking.states.linkingparsed import LinkingParsed
-from bu4.linking.states.linkingstate import LinkingState
-from bu4.linking.targets.allambda import ALLambda
+from bu4.linking.constructs.linked import Linked
 from bu4.parsing.constructs.parsed import Parsed
+from bu4.transform.states.aftertransform import AfterTransform
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstart import TransformStart
+from bu4.transform.states.transformstate import TransformState
+from bu4.transform.targets.atlambda import ATLambda
+
+__all__ = ('PCall',)
 
 
 class PCall(Parsed):
@@ -16,14 +17,14 @@ class PCall(Parsed):
         self.argument = argument
         self.lambda_ = lambda_
 
-    def link(self, promise: set[bytes]) -> LinkingState:
-        return AfterLinking(
-            LinkingParsed(promise, self.argument),
-            ALLambda(
-                lambda argument: AfterLinking(
-                    LinkingParsed(promise, self.lambda_),
-                    ALLambda(
-                        lambda lambda_: LinkingFinished(LCall(argument, lambda_))
+    def link(self, promise: set[bytes]) -> TransformState[Linked]:
+        return AfterTransform(
+            TransformStart(lambda: self.argument.link(promise)),
+            ATLambda(
+                lambda argument: AfterTransform(
+                    TransformStart(lambda: self.lambda_.link(promise)),
+                    ATLambda(
+                        lambda lambda_: TransformFinished(LCall(argument, lambda_))
                     )
                 )
             )

bu4/parsing/constructs/pexception.py

@@ -1,16 +1,17 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
-__all__ = ('PException',)
-
 from bu4.linking.constructs.lexception import LException
-from bu4.linking.states.linkingfinished import LinkingFinished
-from bu4.linking.states.linkingstate import LinkingState
+from bu4.linking.constructs.linked import Linked
 from bu4.parsing.constructs.parsed import Parsed
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
+
+__all__ = ('PException',)
 
 
 class PException(Parsed):
     def __init__(self, name: bytes):
         self.name = name
 
-    def link(self, promise: set[bytes]) -> LinkingState:
-        return LinkingFinished(LException(self.name))
+    def link(self, promise: set[bytes]) -> TransformState[Linked]:
+        return TransformFinished(LException(self.name))

bu4/parsing/constructs/plambda.py

@@ -1,14 +1,15 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
-__all__ = ('PLambda',)
-
+from bu4.linking.constructs.linked import Linked
 from bu4.linking.constructs.llambda import LLambda
-from bu4.linking.states.afterlinking import AfterLinking
-from bu4.linking.states.linkingfinished import LinkingFinished
-from bu4.linking.states.linkingparsed import LinkingParsed
-from bu4.linking.states.linkingstate import LinkingState
-from bu4.linking.targets.allambda import ALLambda
 from bu4.parsing.constructs.parsed import Parsed
+from bu4.transform.states.aftertransform import AfterTransform
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstart import TransformStart
+from bu4.transform.states.transformstate import TransformState
+from bu4.transform.targets.atlambda import ATLambda
+
+__all__ = ('PLambda',)
 
 
 class PLambda(Parsed):
@@ -16,15 +17,12 @@ class PLambda(Parsed):
         self.name = name
         self.value = value
 
-    def link(self, promise: set[bytes]) -> LinkingState:
+    def link(self, promise: set[bytes]) -> TransformState[Linked]:
         assert self.name not in promise, f'overloaded: {self.name}'
-        return AfterLinking(
-            LinkingParsed(
-                promise | {self.name},
-                self.value
-            ),
-            ALLambda(
-                lambda value: LinkingFinished(LLambda(
+        return AfterTransform(
+            TransformStart(lambda: self.value.link(promise | {self.name})),
+            ATLambda(
+                lambda value: TransformFinished(LLambda(
                     self.name,
                     value
                 ))

bu4/parsing/constructs/pname.py

@@ -1,17 +1,18 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
-__all__ = ('PName',)
-
+from bu4.linking.constructs.linked import Linked
 from bu4.linking.constructs.lname import LName
-from bu4.linking.states.linkingfinished import LinkingFinished
-from bu4.linking.states.linkingstate import LinkingState
 from bu4.parsing.constructs.parsed import Parsed
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
+
+__all__ = ('PName',)
 
 
 class PName(Parsed):
     def __init__(self, name: bytes):
         self.name = name
 
-    def link(self, promise: set[bytes]) -> LinkingState:
+    def link(self, promise: set[bytes]) -> TransformState[Linked]:
         assert self.name in promise, f'undefined: {self.name}'
-        return LinkingFinished(LName(self.name))
+        return TransformFinished(LName(self.name))

bu4/parsing/constructs/pnull.py

@@ -1,13 +1,14 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from bu4.linking.constructs.linked import Linked
+from bu4.linking.constructs.lnull import LNull
+from bu4.parsing.constructs.parsed import Parsed
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
+
 __all__ = ('PNull',)
 
-from bu4.linking.constructs.lnull import LNull
-from bu4.linking.states.linkingfinished import LinkingFinished
-from bu4.linking.states.linkingstate import LinkingState
-from bu4.parsing.constructs.parsed import Parsed
-
 
 class PNull(Parsed):
-    def link(self, promise: set[bytes]) -> LinkingState:
-        return LinkingFinished(LNull())
+    def link(self, promise: set[bytes]) -> TransformState[Linked]:
+        return TransformFinished(LNull())

bu4/parsing/extensions/abstractextension.py

@@ -0,0 +1,16 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import TypeVar, Generic
+
+from bu4.transform.states.transformstate import TransformState
+
+__all__ = ('AbstractExtension',)
+
+T = TypeVar('T')
+
+
+class AbstractExtension(Generic[T]):
+    code: int
+
+    def apply(self) -> TransformState[T]:
+        raise NotImplementedError

bu4/parsing/extensions/extension.py

@@ -1,15 +1,17 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from abc import ABC
+from typing import TypeVar
+
 from bu4.parsing.abstractparser import AbstractParser
-from bu4.parsing.states.parsingstate import ParsingState
-from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.extensions.abstractextension import AbstractExtension
 
 __all__ = ('Extension',)
 
+T = TypeVar('T')
 
-class Extension:
-    code: int
 
+class Extension(AbstractExtension[T], ABC):
     def __init_subclass__(cls, /, code: int = None, **kwargs):
         super().__init_subclass__(**kwargs)
         if code is None:
@@ -18,6 +20,3 @@ class Extension:
 
     def __init__(self, parser: AbstractParser):
         self.parser = parser
-
-    def apply(self, state: AfterParsing) -> ParsingState:
-        raise NotImplementedError

bu4/parsing/extensions/xcall.py

@@ -1,15 +1,14 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.parsing.codes import CODE_CALL
+from bu4.parsing.constructs.parsed import Parsed
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingstate import ParsingState
-from bu4.parsing.states.afterparsing import AfterParsing
 from bu4.parsing.states.parsing_call import parsing_call
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('XCall',)
 
 
-class XCall(Extension, code=CODE_CALL):
-    def apply(self, state: AfterParsing) -> ParsingState:
-        state.state = parsing_call()
-        return state
+class XCall(Extension[Parsed], code=CODE_CALL):
+    def apply(self) -> TransformState[Parsed]:
+        return parsing_call(self.parser)

bu4/parsing/extensions/xmake.py

@@ -1,25 +1,24 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.parsing.codes import CODE_MAKE
+from bu4.parsing.constructs.parsed import Parsed
 from bu4.parsing.constructs.plambda import PLambda
 from bu4.parsing.extensions.extension import Extension
-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.transform.states.aftertransform import AfterTransform
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
+from bu4.transform.targets.atlambda import ATLambda
 
 __all__ = ('XMake',)
 
-from bu4.parsing.targets.aplambda import APLambda
 
-
-class XMake(Extension, code=CODE_MAKE):
-    def apply(self, state: AfterParsing) -> ParsingState:
+class XMake(Extension[Parsed], code=CODE_MAKE):
+    def apply(self) -> TransformState[Parsed]:
         name = self.parser.parse_name()
-        state.state = AfterParsing(
-            ParsingRead(),
-            APLambda(
-                lambda value: ParsingFinished(PLambda(name, value))
+        return AfterTransform(
+            ParsingRead(self.parser),
+            ATLambda(
+                lambda value: TransformFinished(PLambda(name, value))
             )
         )
-        return state

bu4/parsing/extensions/xname.py

@@ -1,16 +1,15 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.parsing.codes import CODE_NAME
+from bu4.parsing.constructs.parsed import Parsed
 from bu4.parsing.constructs.pname import PName
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingstate import ParsingState
-from bu4.parsing.states.afterparsing import AfterParsing
-from bu4.parsing.states.parsingfinished import ParsingFinished
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('XName',)
 
 
-class XName(Extension, code=CODE_NAME):
-    def apply(self, state: AfterParsing) -> ParsingState:
-        state.state = ParsingFinished(PName(self.parser.parse_name()))
-        return state
+class XName(Extension[Parsed], code=CODE_NAME):
+    def apply(self) -> TransformState[Parsed]:
+        return TransformFinished(PName(self.parser.parse_name()))

bu4/parsing/extensions/xnull.py

@@ -1,16 +1,15 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.parsing.codes import CODE_NULL
+from bu4.parsing.constructs.parsed import Parsed
 from bu4.parsing.constructs.pnull import PNull
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingstate import ParsingState
-from bu4.parsing.states.afterparsing import AfterParsing
-from bu4.parsing.states.parsingfinished import ParsingFinished
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('XNull',)
 
 
-class XNull(Extension, code=CODE_NULL):
-    def apply(self, state: AfterParsing) -> ParsingState:
-        state.state = ParsingFinished(PNull())
-        return state
+class XNull(Extension[Parsed], code=CODE_NULL):
+    def apply(self) -> TransformState[Parsed]:
+        return TransformFinished(PNull())

bu4/parsing/extensions/xqopn.py

@@ -1,16 +1,16 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.parsing.codes import CODE_QOPN, CODE_QCLS
+from bu4.parsing.constructs.parsed import Parsed
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingstate import ParsingState
-from bu4.parsing.states.afterparsing import AfterParsing
-from bu4.parsing.targets.apchain import APChain
+from bu4.parsing.states.parsingread import ParsingRead
 from bu4.parsing.targets.apendswith import APEndsWith
+from bu4.transform.states.aftertransform import AfterTransform
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('XQopn',)
 
 
-class XQopn(Extension, code=CODE_QOPN):
-    def apply(self, state: AfterParsing) -> ParsingState:
-        state.target = APChain(APEndsWith(self.parser, CODE_QCLS, 'quot expected'), state.target)
-        return state
+class XQopn(Extension[Parsed], code=CODE_QOPN):
+    def apply(self) -> TransformState[Parsed]:
+        return AfterTransform(ParsingRead(self.parser), APEndsWith(self.parser, CODE_QCLS, 'quot expected'))

bu4/parsing/extensions/xquot.py

@@ -1,16 +1,16 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.parsing.codes import CODE_QUOT
+from bu4.parsing.constructs.parsed import Parsed
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingstate import ParsingState
-from bu4.parsing.states.afterparsing import AfterParsing
-from bu4.parsing.targets.apchain import APChain
+from bu4.parsing.states.parsingread import ParsingRead
 from bu4.parsing.targets.apendswith import APEndsWith
+from bu4.transform.states.aftertransform import AfterTransform
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('XQuot',)
 
 
-class XQuot(Extension, code=CODE_QUOT):
-    def apply(self, state: AfterParsing) -> ParsingState:
-        state.target = APChain(APEndsWith(self.parser, CODE_QUOT, 'quot expected'), state.target)
-        return state
+class XQuot(Extension[Parsed], code=CODE_QUOT):
+    def apply(self) -> TransformState[Parsed]:
+        return AfterTransform(ParsingRead(self.parser), APEndsWith(self.parser, CODE_QUOT, 'quot expected'))

bu4/parsing/extensions/xskip.py

@@ -1,13 +1,14 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.parsing.codes import CODE_SKIP
+from bu4.parsing.constructs.parsed import Parsed
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingstate import ParsingState
-from bu4.parsing.states.afterparsing import AfterParsing
+from bu4.parsing.states.parsingread import ParsingRead
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('XSkip',)
 
 
-class XSkip(Extension, code=CODE_SKIP):
-    def apply(self, state: AfterParsing) -> ParsingState:
-        return state
+class XSkip(Extension[Parsed], code=CODE_SKIP):
+    def apply(self) -> TransformState[Parsed]:
+        return ParsingRead(self.parser)

bu4/parsing/extensions/xxcpt.py

@@ -1,16 +1,15 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from bu4.parsing.codes import CODE_XCPT
+from bu4.parsing.constructs.parsed import Parsed
 from bu4.parsing.constructs.pexception import PException
 from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingstate import ParsingState
-from bu4.parsing.states.afterparsing import AfterParsing
-from bu4.parsing.states.parsingfinished import ParsingFinished
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('XXcpt',)
 
 
-class XXcpt(Extension, code=CODE_XCPT):
-    def apply(self, state: AfterParsing) -> ParsingState:
-        state.state = ParsingFinished(PException(self.parser.parse_name()))
-        return state
+class XXcpt(Extension[Parsed], code=CODE_XCPT):
+    def apply(self) -> TransformState[Parsed]:
+        return TransformFinished(PException(self.parser.parse_name()))

bu4/parsing/parser.py

@@ -1,25 +1,23 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
 from io import BytesIO
-from typing import Iterable, Type
+from typing import Iterable, Type, TypeVar
 
 from bu4.parsing.abstractparser import AbstractParser
-from bu4.parsing.constructs.parsed import Parsed
+from bu4.parsing.extensions.abstractextension import AbstractExtension
 from bu4.parsing.extensions.extension import Extension
-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
+from bu4.transform.states.transformfinished import TransformFinished
 
 __all__ = ('Parser',)
 
+T = TypeVar('T')
 
-class Parser(AbstractParser):
-    def __init__(self, source: bytes, extensions: Iterable[Type[Extension]]):
+
+class Parser(AbstractParser[T]):
+    def __init__(self, source: bytes, extensions: Iterable[Type[Extension[T]]]):
         self.__source = BytesIO(source)
-        self.__extensions: dict[int, Extension] = {}
+        self.__extensions: dict[int, Extension[T]] = {}
         for extension in extensions:
             if extension.code in self.__extensions:
                 raise ValueError('code overload')
@@ -37,31 +35,15 @@ class Parser(AbstractParser):
                 return s.getvalue()
             s.write(bytes([c]))
 
-    def _state_read(self, state: AfterParsing) -> ParsingState:
-        code = self.read()
+    def extension_for(self, code: int) -> AbstractExtension[T]:
         extension = self.__extensions.get(code)
         if extension is None:
             raise ValueError(f'unknown control: {hex(code)}')
-        state = extension.apply(state)
-        return state
+        return extension
 
-    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, ParsingRead):
-            state = self._state_read(state)
-        else:
-            raise TypeError
-        return state
-
-    def parse(self) -> Parsed:
-        state = AfterParsing(ParsingRead(), APLambda(lambda parsed: ParsingFinished(parsed)))
+    def parse(self) -> T:
+        state = ParsingRead(self)
         while True:
-            if isinstance(state, ParsingFinished):
-                return state.parsed
-            elif isinstance(state, AfterParsing):
-                state = self._state_next(state)
-            else:
-                raise TypeError
+            if isinstance(state, TransformFinished):
+                return state.transformed
+            state = state.next()

bu4/parsing/states/afterparsing.py

@@ -1,12 +0,0 @@
-#  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

@@ -1,22 +1,25 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from bu4.parsing.abstractparser import AbstractParser
+from bu4.parsing.constructs.parsed import Parsed
 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
+from bu4.transform.states.aftertransform import AfterTransform
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
+from bu4.transform.targets.atlambda import ATLambda
 
 __all__ = ('parsing_call',)
 
 
-def parsing_call():
-    return AfterParsing(
-        ParsingRead(),
-        APLambda(
-            lambda argument: AfterParsing(
-                ParsingRead(),
-                APLambda(
-                    lambda lambda_: ParsingFinished(
+def parsing_call(parser: AbstractParser[Parsed]) -> TransformState[Parsed]:
+    return AfterTransform(
+        ParsingRead(parser),
+        ATLambda(
+            lambda argument: AfterTransform(
+                ParsingRead(parser),
+                ATLambda(
+                    lambda lambda_: TransformFinished(
                         PCall(
                             argument,
                             lambda_

bu4/parsing/states/parsingfinished.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.parsingstate import ParsingState
-
-__all__ = ('ParsingFinished',)
-
-
-class ParsingFinished(ParsingState):
-    def __init__(self, parsed: Parsed):
-        self.parsed = parsed

bu4/parsing/states/parsingread.py

@@ -1,9 +1,20 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
-from bu4.parsing.states.parsingstate import ParsingState
+from typing import TypeVar
+
+from bu4.parsing.abstractparser import AbstractParser
+from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('ParsingRead',)
 
+T = TypeVar('T')
 
-class ParsingRead(ParsingState):
-    pass
+
+class ParsingRead(TransformState[T]):
+    def __init__(self, parser: AbstractParser[T]):
+        self.parser = parser
+
+    def next(self) -> TransformState[T]:
+        code = self.parser.read()
+        extension = self.parser.extension_for(code)
+        return extension.apply()

bu4/parsing/states/parsingstate.py

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

bu4/parsing/targets/apchain.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.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

@@ -1,20 +1,23 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from typing import TypeVar
+
 from bu4.parsing.abstractparser import AbstractParser
-from bu4.parsing.constructs.parsed import Parsed
-from bu4.parsing.states.parsingstate import ParsingState
-from bu4.parsing.states.parsingfinished import ParsingFinished
-from bu4.parsing.targets.aptarget import APTarget
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
+from bu4.transform.targets.attarget import ATTarget
 
 __all__ = ('APEndsWith',)
 
+T = TypeVar('T')
 
-class APEndsWith(APTarget):
+
+class APEndsWith(ATTarget[T]):
     def __init__(self, parser: AbstractParser, expected: int, message: str):
         self.parser = parser
         self.expected = expected
         self.message = message
 
-    def given(self, parsed: Parsed) -> ParsingState:
+    def given(self, parsed: T) -> TransformState[T]:
         assert self.parser.read() == self.expected, self.message
-        return ParsingFinished(parsed)
+        return TransformFinished(parsed)

bu4/parsing/targets/aplambda.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.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

@@ -1,11 +0,0 @@
-#  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/toolchain/parse.py

@@ -9,8 +9,9 @@ from bu4.parsing.parser import Parser
 __all__ = ('parse',)
 
 
-def parse(source: bytes, extensions: Iterable[Type[Extension]]) -> Parsed:
-    return Parser(
+def parse(source: bytes, extensions: Iterable[Type[Extension[Parsed]]]) -> Parsed:
+    parser = Parser(
         source,
         extensions
-    ).parse()
+    )
+    return parser.parse()

bu4/transform/states/aftertransform.py

@@ -0,0 +1,35 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import TypeVar
+
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
+from bu4.transform.targets.attarget import ATTarget
+
+__all__ = ('AfterTransform',)
+
+T = TypeVar('T')
+
+
+class AfterTransform(TransformState[T]):
+    def __init__(self, state: TransformState[T], target: ATTarget[T]):
+        self.state = state
+        self.target = target
+
+    def next(self) -> TransformState[T]:
+        if isinstance(self.state, TransformFinished):
+            return self.target.given(self.state.transformed)
+        elif isinstance(self.state, AfterTransform):
+            self.state, self.target = self.state.state, ATChain(self.state.target, self.target)
+        else:
+            self.state = self.state.next()
+        return self
+
+
+class ATChain(ATTarget[T]):
+    def __init__(self, target: ATTarget[T], aftertarget: ATTarget[T]):
+        self.target = target
+        self.aftertarget = aftertarget
+
+    def given(self, transformed: T) -> TransformState[T]:
+        return AfterTransform(self.target.given(transformed), self.aftertarget)

bu4/transform/states/transformfinished.py

@@ -0,0 +1,17 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import TypeVar
+
+from bu4.transform.states.transformstate import TransformState
+
+__all__ = ('TransformFinished',)
+
+T = TypeVar('T')
+
+
+class TransformFinished(TransformState[T]):
+    def __init__(self, transformed: T):
+        self.transformed = transformed
+
+    def next(self) -> TransformState[T]:
+        return self

bu4/transform/states/transformstart.py

@@ -0,0 +1,17 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import TypeVar, Callable
+
+from bu4.transform.states.transformstate import TransformState
+
+__all__ = ('TransformStart',)
+
+T = TypeVar('T')
+
+
+class TransformStart(TransformState[T]):
+    def __init__(self, start: Callable[[], TransformState[T]]):
+        self.start = start
+
+    def next(self) -> TransformState[T]:
+        return self.start()

bu4/transform/states/transformstate.py

@@ -0,0 +1,12 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import TypeVar, Generic
+
+__all__ = ('TransformState',)
+
+T = TypeVar('T')
+
+
+class TransformState(Generic[T]):
+    def next(self) -> 'TransformState[T]':
+        raise NotImplementedError

bu4/transform/targets/atlambda.py

@@ -0,0 +1,18 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import Callable, TypeVar
+
+from bu4.transform.states.transformstate import TransformState
+from bu4.transform.targets.attarget import ATTarget
+
+__all__ = ('ATLambda',)
+
+T = TypeVar('T')
+
+
+class ATLambda(ATTarget[T]):
+    def __init__(self, lambda_: Callable[[T], TransformState[T]]):
+        self.lambda_ = lambda_
+
+    def given(self, transformed: T) -> TransformState[T]:
+        return self.lambda_(transformed)

bu4/transform/targets/attarget.py

@@ -0,0 +1,14 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import TypeVar, Generic
+
+from bu4.transform.states.transformstate import TransformState
+
+__all__ = ('ATTarget',)
+
+T = TypeVar('T')
+
+
+class ATTarget(Generic[T]):
+    def given(self, transformed: T) -> TransformState[T]:
+        raise NotImplementedError

bu4/transform/transform.py

@@ -0,0 +1,17 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from typing import TypeVar
+
+from bu4.transform.states.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
+
+__all__ = ('transform',)
+
+T = TypeVar('T')
+
+
+def transform(state: TransformState[T]) -> T:
+    while True:
+        if isinstance(state, TransformFinished):
+            return state.transformed
+        state = state.next()

main.py

@@ -1,4 +1,5 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
 import random
 from collections import deque
 

src/sys6.bu4

@@ -1,5 +1,6 @@
 @@
 """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+###
 /(g)
     (x)
         /