CodeExtension

bu4/evaluation/constructs/edelayed.py

@@ -1,25 +1,29 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
-from bu4.evaluation.av.envtype import envtype
+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.linking.constructs.linked import Linked
+from bu4.evaluation.targets.avanonymouscontainer import AVAnonymousContainer
 
 __all__ = ('EDelayed',)
 
+T = TypeVar('T')
 
-class EDelayed(EValue):
-    def __init__(self, env: envtype, value: Linked):
+
+class EDelayed(EValue, Generic[T]):
+    def __init__(self, env: T, value: Attachable[T]):
         self.env = env
         self.value = value
-        self.evaluable = EAttachable(
+        self.evaluable = AVAnonymousContainer(EAttachable(
             self.env,
             self.value
-        )
+        )).after_value
 
     def call(self, argument: Evaluable) -> Evaluable:
         return self.evaluable
 
     def __str__(self):
-        return f'(()){self.value}'
+        return f'&{self.value}'

bu4/evaluation/constructs/eidelayed.py

@@ -1,25 +0,0 @@
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
-from bu4.evaluation.av.evtype import evtype
-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
-
-__all__ = ('EIDelayed',)
-
-
-class EIDelayed(EValue):
-    def __init__(self, ev: evtype, value: Indexed):
-        self.ev = ev
-        self.value = value
-        self.evaluable = EAttachable(
-            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

@@ -2,25 +2,26 @@
 
 from bu4.evaluation.av.evtype import evtype
 from bu4.evaluation.av.lambdaev import LambdaEv
+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.indexing.constructs.indexed import Indexed
 
 __all__ = ('EILambda',)
 
 
 class EILambda(EValue):
-    def __init__(self, ev: evtype, value: Indexed, *, memoize: bool):
+    def __init__(self, ev: evtype, value: Attachable[evtype], *, memoize: bool):
         self.ev = ev
         self.value = value
         self.memoize = memoize
 
     def call(self, argument: Evaluable) -> Evaluable:
+        ev: evtype = LambdaEv(self.ev, argument, memoize=self.memoize)
         return EAttachable(
-            LambdaEv(self.ev, argument, memoize=self.memoize),
+            ev,
             self.value
         )
 
     def __str__(self):
-        return f'(){self.value}'
+        return f'(0){self.value}'

bu4/evaluation/constructs/evaluable.py

@@ -1,8 +1,8 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
 __all__ = ('Evaluable',)
 
 
-#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-
 class Evaluable:
     def next(self) -> 'Evaluable':
         raise NotImplementedError

bu4/indexing/constructs/idelayed.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.eidelayed import EIDelayed
+from bu4.evaluation.constructs.edelayed import EDelayed
 from bu4.evaluation.constructs.evaluable import Evaluable
 from bu4.indexing.constructs.indexed import Indexed
 from bu4.parsing.codes import CODE_DLYD
@@ -14,13 +14,13 @@ class IDelayed(Indexed):
         self.value = value
 
     def attach(self, ev: evtype) -> Evaluable:
-        return EIDelayed(
+        return EDelayed(
             ev,
             self.value
         )
 
     def __str__(self):
-        return f'(){self.value}'
+        return f'&{self.value}'
 
     def __bytes__(self):
         return bytes([CODE_DLYD, *bytes(self.value)])

bu4/indexing/constructs/ilambda.py

@@ -23,7 +23,7 @@ class ILambda(Indexed):
         )
 
     def __str__(self):
-        return f'(){self.value}'
+        return f'(0){self.value}'
 
     def __bytes__(self):
         return bytes([CODE_MAKE, self.memoize, len(self.table), *self.table, *bytes(self.value)])

bu4/indexing/extensions/xicall.py

@@ -3,31 +3,19 @@
 from bu4.indexing.constructs.icall import ICall
 from bu4.indexing.constructs.indexed import Indexed
 from bu4.parsing.codes import CODE_CALL
-from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingread import ParsingRead
-from bu4.transform.states.aftertransform import AfterTransform
-from bu4.transform.states.transformfinished import TransformFinished
+from bu4.parsing.extensions.CodeExtension import CodeExtension
 from bu4.transform.states.transformstate import TransformState
-from bu4.transform.targets.atlambda import ATLambda
 
 __all__ = ('XICall',)
 
 
-class XICall(Extension[Indexed], code=CODE_CALL):
+class XICall(CodeExtension[Indexed], code=CODE_CALL):
     def apply(self) -> TransformState[Indexed]:
-        return AfterTransform(
-            ParsingRead(self.parser),
-            ATLambda(
-                lambda argument: AfterTransform(
-                    ParsingRead(self.parser),
-                    ATLambda(
-                        lambda lambda_: TransformFinished(
-                            ICall(
-                                argument,
-                                lambda_
-                            )
-                        )
-                    )
+        return self.readlambda(
+            lambda argument: self.readlambdafinished(
+                lambda lambda_: ICall(
+                    argument,
+                    lambda_
                 )
             )
         )

bu4/indexing/extensions/xidlyd.py

@@ -3,21 +3,14 @@
 from bu4.indexing.constructs.idelayed import IDelayed
 from bu4.indexing.constructs.indexed import Indexed
 from bu4.parsing.codes import CODE_DLYD
-from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingread import ParsingRead
-from bu4.transform.states.aftertransform import AfterTransform
-from bu4.transform.states.transformfinished import TransformFinished
+from bu4.parsing.extensions.CodeExtension import CodeExtension
 from bu4.transform.states.transformstate import TransformState
-from bu4.transform.targets.atlambda import ATLambda
 
 __all__ = ('XIDlyd',)
 
 
-class XIDlyd(Extension[Indexed], code=CODE_DLYD):
+class XIDlyd(CodeExtension[Indexed], code=CODE_DLYD):
     def apply(self) -> TransformState[Indexed]:
-        return AfterTransform(
-            ParsingRead(self.parser),
-            ATLambda(
-                lambda value: TransformFinished(IDelayed(value))
-            )
+        return self.readlambdafinished(
+            lambda value: IDelayed(value)
         )

bu4/indexing/extensions/ximake.py

@@ -3,23 +3,16 @@
 from bu4.indexing.constructs.ilambda import ILambda
 from bu4.indexing.constructs.indexed import Indexed
 from bu4.parsing.codes import CODE_MAKE
-from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingread import ParsingRead
-from bu4.transform.states.aftertransform import AfterTransform
-from bu4.transform.states.transformfinished import TransformFinished
+from bu4.parsing.extensions.CodeExtension import CodeExtension
 from bu4.transform.states.transformstate import TransformState
-from bu4.transform.targets.atlambda import ATLambda
 
 __all__ = ('XIMake',)
 
 
-class XIMake(Extension[Indexed], code=CODE_MAKE):
+class XIMake(CodeExtension[Indexed], code=CODE_MAKE):
     def apply(self) -> TransformState[Indexed]:
         memoize = bool(self.parser.read())
         table = [self.parser.read() for _ in range(self.parser.read())]
-        return AfterTransform(
-            ParsingRead(self.parser),
-            ATLambda(
-                lambda value: TransformFinished(ILambda(value, table, memoize=memoize))
-            )
+        return self.readlambdafinished(
+            lambda value: ILambda(value, table, memoize=memoize)
         )

bu4/indexing/extensions/xiname.py

@@ -3,13 +3,13 @@
 from bu4.indexing.constructs.iname import IName
 from bu4.indexing.constructs.indexed import Indexed
 from bu4.parsing.codes import CODE_NAME
-from bu4.parsing.extensions.extension import Extension
+from bu4.parsing.extensions.CodeExtension import CodeExtension
 from bu4.transform.states.transformfinished import TransformFinished
 from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('XIName',)
 
 
-class XIName(Extension[Indexed], code=CODE_NAME):
+class XIName(CodeExtension[Indexed], code=CODE_NAME):
     def apply(self) -> TransformState[Indexed]:
         return TransformFinished(IName(self.parser.read()))

bu4/indexing/extensions/xinull.py

@@ -3,13 +3,13 @@
 from bu4.indexing.constructs.indexed import Indexed
 from bu4.indexing.constructs.inull import INull
 from bu4.parsing.codes import CODE_NULL
-from bu4.parsing.extensions.extension import Extension
+from bu4.parsing.extensions.CodeExtension import CodeExtension
 from bu4.transform.states.transformfinished import TransformFinished
 from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('XINull',)
 
 
-class XINull(Extension[Indexed], code=CODE_NULL):
+class XINull(CodeExtension[Indexed], code=CODE_NULL):
     def apply(self) -> TransformState[Indexed]:
         return TransformFinished(INull())

bu4/indexing/extensions/xixcpt.py

@@ -3,13 +3,13 @@
 from bu4.indexing.constructs.iexception import IException
 from bu4.indexing.constructs.indexed import Indexed
 from bu4.parsing.codes import CODE_XCPT
-from bu4.parsing.extensions.extension import Extension
+from bu4.parsing.extensions.CodeExtension import CodeExtension
 from bu4.transform.states.transformfinished import TransformFinished
 from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('XIXcpt',)
 
 
-class XIXcpt(Extension[Indexed], code=CODE_XCPT):
+class XIXcpt(CodeExtension[Indexed], code=CODE_XCPT):
     def apply(self) -> TransformState[Indexed]:
         return TransformFinished(IException(self.parser.parse_name()))

bu4/isynced.py

@@ -3,7 +3,7 @@
 from bu4.evaluation.constructs.evalue import EValue
 from bu4.evaluation.sync import sync
 from bu4.linkable.toolchain.parse import parse
-from bu4.linkable.toolchain.stdext import standard_extension
+from bu4.linkable.toolchain.stdext import standard_extensions
 from bu4.linkable.toolchain.transply import transply
 from bu4.transform.transform import transform
 
@@ -12,7 +12,7 @@ __all__ = ('isynced',)
 
 def isynced(source: str) -> EValue:
     bsource = transply(source)
-    parsed = parse(bsource, standard_extension)
+    parsed = parse(bsource, standard_extensions)
     linked = transform(parsed.link(set()))
     indexed = transform(linked.index([]))
     evaluable = indexed.attach([])

bu4/linkable/constructs/pcall.py

@@ -1,8 +1,8 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from bu4.linkable.constructs.parsed import Parsed
 from bu4.linking.constructs.lcall import LCall
 from bu4.linking.constructs.linked import Linked
-from bu4.linkable.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

bu4/linkable/constructs/pdelayed.py

@@ -1,8 +1,8 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from bu4.linkable.constructs.parsed import Parsed
 from bu4.linking.constructs.ldelayed import LDelayed
 from bu4.linking.constructs.linked import Linked
-from bu4.linkable.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

bu4/linkable/constructs/pexception.py

@@ -1,8 +1,8 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from bu4.linkable.constructs.parsed import Parsed
 from bu4.linking.constructs.lexception import LException
 from bu4.linking.constructs.linked import Linked
-from bu4.linkable.constructs.parsed import Parsed
 from bu4.transform.states.transformfinished import TransformFinished
 from bu4.transform.states.transformstate import TransformState
 

bu4/linkable/constructs/plambda.py

@@ -1,8 +1,8 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from bu4.linkable.constructs.parsed import Parsed
 from bu4.linking.constructs.linked import Linked
 from bu4.linking.constructs.llambda import LLambda
-from bu4.linkable.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

bu4/linkable/constructs/pname.py

@@ -1,8 +1,8 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from bu4.linkable.constructs.parsed import Parsed
 from bu4.linking.constructs.linked import Linked
 from bu4.linking.constructs.lname import LName
-from bu4.linkable.constructs.parsed import Parsed
 from bu4.transform.states.transformfinished import TransformFinished
 from bu4.transform.states.transformstate import TransformState
 

bu4/linkable/constructs/pnull.py

@@ -1,8 +1,8 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
 
+from bu4.linkable.constructs.parsed import Parsed
 from bu4.linking.constructs.linked import Linked
 from bu4.linking.constructs.lnull import LNull
-from bu4.linkable.constructs.parsed import Parsed
 from bu4.transform.states.transformfinished import TransformFinished
 from bu4.transform.states.transformstate import TransformState
 

bu4/linkable/extensions/xcall.py

@@ -3,31 +3,19 @@
 from bu4.linkable.constructs.parsed import Parsed
 from bu4.linkable.constructs.pcall import PCall
 from bu4.parsing.codes import CODE_CALL
-from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingread import ParsingRead
-from bu4.transform.states.aftertransform import AfterTransform
-from bu4.transform.states.transformfinished import TransformFinished
+from bu4.parsing.extensions.CodeExtension import CodeExtension
 from bu4.transform.states.transformstate import TransformState
-from bu4.transform.targets.atlambda import ATLambda
 
 __all__ = ('XCall',)
 
 
-class XCall(Extension[Parsed], code=CODE_CALL):
+class XCall(CodeExtension[Parsed], code=CODE_CALL):
     def apply(self) -> TransformState[Parsed]:
-        return AfterTransform(
-            ParsingRead(self.parser),
-            ATLambda(
-                lambda argument: AfterTransform(
-                    ParsingRead(self.parser),
-                    ATLambda(
-                        lambda lambda_: TransformFinished(
-                            PCall(
-                                argument,
-                                lambda_
-                            )
-                        )
-                    )
+        return self.readlambda(
+            lambda argument: self.readlambdafinished(
+                lambda lambda_: PCall(
+                    argument,
+                    lambda_
                 )
             )
         )

bu4/linkable/extensions/xdlyd.py

@@ -3,21 +3,14 @@
 from bu4.linkable.constructs.parsed import Parsed
 from bu4.linkable.constructs.pdelayed import PDelayed
 from bu4.parsing.codes import CODE_DLYD
-from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingread import ParsingRead
-from bu4.transform.states.aftertransform import AfterTransform
-from bu4.transform.states.transformfinished import TransformFinished
+from bu4.parsing.extensions.CodeExtension import CodeExtension
 from bu4.transform.states.transformstate import TransformState
-from bu4.transform.targets.atlambda import ATLambda
 
 __all__ = ('XDlyd',)
 
 
-class XDlyd(Extension[Parsed], code=CODE_DLYD):
+class XDlyd(CodeExtension[Parsed], code=CODE_DLYD):
     def apply(self) -> TransformState[Parsed]:
-        return AfterTransform(
-            ParsingRead(self.parser),
-            ATLambda(
-                lambda value: TransformFinished(PDelayed(value))
-            )
+        return self.readlambdafinished(
+            lambda value: PDelayed(value)
         )

bu4/linkable/extensions/xmake.py

@@ -3,22 +3,15 @@
 from bu4.linkable.constructs.parsed import Parsed
 from bu4.linkable.constructs.plambda import PLambda
 from bu4.parsing.codes import CODE_MAKE
-from bu4.parsing.extensions.extension import Extension
-from bu4.parsing.states.parsingread import ParsingRead
-from bu4.transform.states.aftertransform import AfterTransform
-from bu4.transform.states.transformfinished import TransformFinished
+from bu4.parsing.extensions.CodeExtension import CodeExtension
 from bu4.transform.states.transformstate import TransformState
-from bu4.transform.targets.atlambda import ATLambda
 
 __all__ = ('XMake',)
 
 
-class XMake(Extension[Parsed], code=CODE_MAKE):
+class XMake(CodeExtension[Parsed], code=CODE_MAKE):
     def apply(self) -> TransformState[Parsed]:
         name = self.parser.parse_name()
-        return AfterTransform(
-            ParsingRead(self.parser),
-            ATLambda(
-                lambda value: TransformFinished(PLambda(name, value))
-            )
+        return self.readlambdafinished(
+            lambda value: PLambda(name, value)
         )

bu4/linkable/extensions/xname.py

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

bu4/linkable/extensions/xnull.py

@@ -3,13 +3,13 @@
 from bu4.linkable.constructs.parsed import Parsed
 from bu4.linkable.constructs.pnull import PNull
 from bu4.parsing.codes import CODE_NULL
-from bu4.parsing.extensions.extension import Extension
+from bu4.parsing.extensions.CodeExtension import CodeExtension
 from bu4.transform.states.transformfinished import TransformFinished
 from bu4.transform.states.transformstate import TransformState
 
 __all__ = ('XNull',)
 
 
-class XNull(Extension[Parsed], code=CODE_NULL):
+class XNull(CodeExtension[Parsed], code=CODE_NULL):
     def apply(self) -> TransformState[Parsed]:
         return TransformFinished(PNull())

bu4/linkable/extensions/xqopn.py

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

bu4/linkable/extensions/xquot.py

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

bu4/linkable/extensions/xskip.py

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

bu4/linkable/extensions/xxcpt.py

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

bu4/linkable/toolchain/stdext.py

@@ -10,9 +10,9 @@ from bu4.linkable.extensions.xquot import XQuot
 from bu4.linkable.extensions.xskip import XSkip
 from bu4.linkable.extensions.xxcpt import XXcpt
 
-__all__ = ('standard_extension',)
+__all__ = ('standard_extensions',)
 
-standard_extension = (
+standard_extensions = (
     XNull,
     XCall,
     XMake,

bu4/linking/constructs/ldelayed.py

@@ -35,4 +35,4 @@ class LDelayed(Linked):
         )
 
     def __str__(self):
-        return f'(){self.value}'
+        return f'&{self.value}'

bu4/parsing/extensions/CodeExtension.py

@@ -0,0 +1,39 @@
+#  Copyright (c) PARRRATE T&V 2021. All rights reserved.
+
+from abc import ABC
+from typing import TypeVar, Callable
+
+from bu4.parsing.extensions.extension import Extension
+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.transformfinished import TransformFinished
+from bu4.transform.states.transformstate import TransformState
+from bu4.transform.targets.atlambda import ATLambda
+
+__all__ = ('CodeExtension',)
+
+T = TypeVar('T')
+
+
+class CodeExtension(Extension[T], ABC):
+    def __init_subclass__(cls, /, code: int = None):
+        super().__init_subclass__()
+        if code is None:
+            raise TypeError
+        cls.code = code
+
+    def readlambda(self, lambda_: Callable[[T], TransformState[T]]) -> TransformState[T]:
+        return AfterTransform(
+            ParsingRead(self.parser),
+            ATLambda(lambda_)
+        )
+
+    def readlambdafinished(self, lambda_: Callable[[T], T]) -> TransformState[T]:
+        return AfterTransform(
+            ParsingRead(self.parser),
+            ATLambda(lambda parsed: TransformFinished(lambda_(parsed)))
+        )
+
+    def endswith(self, expected: int, message: str):
+        return AfterTransform(ParsingRead(self.parser), APEndsWith(self.parser, expected, message))

bu4/parsing/extensions/extension.py

@@ -12,11 +12,5 @@ T = TypeVar('T')
 
 
 class Extension(AbstractExtension[T], ABC):
-    def __init_subclass__(cls, /, code: int = None, **kwargs):
-        super().__init_subclass__(**kwargs)
-        if code is None:
-            raise TypeError
-        cls.code = code
-
-    def __init__(self, parser: AbstractParser):
+    def __init__(self, parser: AbstractParser[T]):
         self.parser = parser

bu4/parsing/parser.py

@@ -7,12 +7,9 @@ from bu4.parsing.abstractparser import AbstractParser
 from bu4.parsing.extensions.abstractextension import AbstractExtension
 from bu4.parsing.extensions.extension import Extension
 from bu4.parsing.states.parsingread import ParsingRead
-
-__all__ = ('Parser',)
-
 from bu4.transform.states.transformstate import TransformState
 
-from bu4.transform.transform import transform
+__all__ = ('Parser',)
 
 T = TypeVar('T')
 

bu4/synced.py

@@ -2,16 +2,16 @@
 
 from bu4.evaluation.constructs.evalue import EValue
 from bu4.evaluation.sync import sync
-from bu4.linking.evaluable_from_parsed import evaluable_from_parsed
 from bu4.linkable.toolchain.parse import parse
-from bu4.linkable.toolchain.stdext import standard_extension
+from bu4.linkable.toolchain.stdext import standard_extensions
 from bu4.linkable.toolchain.transply import transply
+from bu4.linking.evaluable_from_parsed import evaluable_from_parsed
 
 __all__ = ('synced',)
 
 
 def synced(source: str) -> EValue:
     bsource = transply(source)
-    parsed = parse(bsource, standard_extension)
+    parsed = parse(bsource, standard_extensions)
     evaluable = evaluable_from_parsed({}, parsed)
     return sync(evaluable)