diff --git a/bu4/evaluation/constructs/edelayed.py b/bu4/evaluation/constructs/edelayed.py
index 29f3548..b0deb82 100644
--- a/bu4/evaluation/constructs/edelayed.py
+++ b/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}'
diff --git a/bu4/evaluation/constructs/eidelayed.py b/bu4/evaluation/constructs/eidelayed.py
deleted file mode 100644
index e80768e..0000000
--- a/bu4/evaluation/constructs/eidelayed.py
+++ /dev/null
@@ -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}'
diff --git a/bu4/evaluation/constructs/eilambda.py b/bu4/evaluation/constructs/eilambda.py
index 83af43d..c204a48 100644
--- a/bu4/evaluation/constructs/eilambda.py
+++ b/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}'
diff --git a/bu4/evaluation/constructs/evaluable.py b/bu4/evaluation/constructs/evaluable.py
index d689c8b..494e48e 100644
--- a/bu4/evaluation/constructs/evaluable.py
+++ b/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
diff --git a/bu4/indexing/constructs/idelayed.py b/bu4/indexing/constructs/idelayed.py
index 145f4c2..4093ae4 100644
--- a/bu4/indexing/constructs/idelayed.py
+++ b/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)])
diff --git a/bu4/indexing/constructs/ilambda.py b/bu4/indexing/constructs/ilambda.py
index 9fead31..d57faf7 100644
--- a/bu4/indexing/constructs/ilambda.py
+++ b/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)])
diff --git a/bu4/indexing/extensions/xicall.py b/bu4/indexing/extensions/xicall.py
index 0a59dd7..0b13219 100644
--- a/bu4/indexing/extensions/xicall.py
+++ b/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_
                 )
             )
         )
diff --git a/bu4/indexing/extensions/xidlyd.py b/bu4/indexing/extensions/xidlyd.py
index 967dd72..ea01517 100644
--- a/bu4/indexing/extensions/xidlyd.py
+++ b/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)
         )
diff --git a/bu4/indexing/extensions/ximake.py b/bu4/indexing/extensions/ximake.py
index a38fccb..3e22318 100644
--- a/bu4/indexing/extensions/ximake.py
+++ b/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)
         )
diff --git a/bu4/indexing/extensions/xiname.py b/bu4/indexing/extensions/xiname.py
index e18ea55..8700c1a 100644
--- a/bu4/indexing/extensions/xiname.py
+++ b/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()))
diff --git a/bu4/indexing/extensions/xinull.py b/bu4/indexing/extensions/xinull.py
index 3bdba28..246ab56 100644
--- a/bu4/indexing/extensions/xinull.py
+++ b/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())
diff --git a/bu4/indexing/extensions/xixcpt.py b/bu4/indexing/extensions/xixcpt.py
index f98f68f..5142b7a 100644
--- a/bu4/indexing/extensions/xixcpt.py
+++ b/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()))
diff --git a/bu4/isynced.py b/bu4/isynced.py
index 2db8fa9..6ad8ead 100644
--- a/bu4/isynced.py
+++ b/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([])
diff --git a/bu4/linkable/constructs/pcall.py b/bu4/linkable/constructs/pcall.py
index 870ae90..0327cfe 100644
--- a/bu4/linkable/constructs/pcall.py
+++ b/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
diff --git a/bu4/linkable/constructs/pdelayed.py b/bu4/linkable/constructs/pdelayed.py
index 93a7c9c..601468a 100644
--- a/bu4/linkable/constructs/pdelayed.py
+++ b/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
diff --git a/bu4/linkable/constructs/pexception.py b/bu4/linkable/constructs/pexception.py
index 14009ba..9da82ea 100644
--- a/bu4/linkable/constructs/pexception.py
+++ b/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
 
diff --git a/bu4/linkable/constructs/plambda.py b/bu4/linkable/constructs/plambda.py
index 4b7f54f..8bd6cab 100644
--- a/bu4/linkable/constructs/plambda.py
+++ b/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
diff --git a/bu4/linkable/constructs/pname.py b/bu4/linkable/constructs/pname.py
index 2345447..1c433a5 100644
--- a/bu4/linkable/constructs/pname.py
+++ b/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
 
diff --git a/bu4/linkable/constructs/pnull.py b/bu4/linkable/constructs/pnull.py
index 4127c3d..3e3e7ef 100644
--- a/bu4/linkable/constructs/pnull.py
+++ b/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
 
diff --git a/bu4/linkable/extensions/xcall.py b/bu4/linkable/extensions/xcall.py
index 0f9575a..e910018 100644
--- a/bu4/linkable/extensions/xcall.py
+++ b/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_
                 )
             )
         )
diff --git a/bu4/linkable/extensions/xdlyd.py b/bu4/linkable/extensions/xdlyd.py
index 62d87b7..f303801 100644
--- a/bu4/linkable/extensions/xdlyd.py
+++ b/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)
         )
diff --git a/bu4/linkable/extensions/xmake.py b/bu4/linkable/extensions/xmake.py
index a342bea..fa3db52 100644
--- a/bu4/linkable/extensions/xmake.py
+++ b/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)
         )
diff --git a/bu4/linkable/extensions/xname.py b/bu4/linkable/extensions/xname.py
index dbcf99e..83650c9 100644
--- a/bu4/linkable/extensions/xname.py
+++ b/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()))
diff --git a/bu4/linkable/extensions/xnull.py b/bu4/linkable/extensions/xnull.py
index 384bed1..fbd177f 100644
--- a/bu4/linkable/extensions/xnull.py
+++ b/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())
diff --git a/bu4/linkable/extensions/xqopn.py b/bu4/linkable/extensions/xqopn.py
index 7a64cbb..9e8b414 100644
--- a/bu4/linkable/extensions/xqopn.py
+++ b/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')
diff --git a/bu4/linkable/extensions/xquot.py b/bu4/linkable/extensions/xquot.py
index d67321f..1d2c189 100644
--- a/bu4/linkable/extensions/xquot.py
+++ b/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')
diff --git a/bu4/linkable/extensions/xskip.py b/bu4/linkable/extensions/xskip.py
index 02f8e1d..e3e8b04 100644
--- a/bu4/linkable/extensions/xskip.py
+++ b/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)
diff --git a/bu4/linkable/extensions/xxcpt.py b/bu4/linkable/extensions/xxcpt.py
index f771464..18808ad 100644
--- a/bu4/linkable/extensions/xxcpt.py
+++ b/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()))
diff --git a/bu4/linkable/toolchain/stdext.py b/bu4/linkable/toolchain/stdext.py
index 9b35a65..acaeaed 100644
--- a/bu4/linkable/toolchain/stdext.py
+++ b/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,
diff --git a/bu4/linking/constructs/ldelayed.py b/bu4/linking/constructs/ldelayed.py
index d4f3ab0..eb52d05 100644
--- a/bu4/linking/constructs/ldelayed.py
+++ b/bu4/linking/constructs/ldelayed.py
@@ -35,4 +35,4 @@ class LDelayed(Linked):
         )
 
     def __str__(self):
-        return f'(){self.value}'
+        return f'&{self.value}'
diff --git a/bu4/parsing/extensions/CodeExtension.py b/bu4/parsing/extensions/CodeExtension.py
new file mode 100644
index 0000000..d5a7a74
--- /dev/null
+++ b/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))
diff --git a/bu4/parsing/extensions/extension.py b/bu4/parsing/extensions/extension.py
index 1a34060..e480df2 100644
--- a/bu4/parsing/extensions/extension.py
+++ b/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
diff --git a/bu4/parsing/parser.py b/bu4/parsing/parser.py
index 54b23bf..7b5800a 100644
--- a/bu4/parsing/parser.py
+++ b/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')
 
diff --git a/bu4/synced.py b/bu4/synced.py
index ff26d99..b44a10e 100644
--- a/bu4/synced.py
+++ b/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)