xx2b, bitwise, b_halve

bu4/common_interface.py

@@ -1,6 +1,8 @@
-from bu4.evaluation.proxy import eproxy
+from bu4.evaluation.constructs.evalue import EValue
-from bu4.evaluation.aftervalue import EValue
+from bu4.evaluation.constructs.proxy import eproxy
-from bu4.toolchain.sync import sync
+from bu4.evaluation.sync import sync
+
+__all__ = ('to_bool', 'with_common_interface',)
 
 
 def to_bool(_01):

bu4/evaluation/av/aftervalue.py

@@ -1,19 +1,8 @@
-import abc
+from bu4.evaluation.targets.avtarget import AVTarget
-from typing import Mapping
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
 
-from bu4.evaluation.evaluable import Evaluable
+__all__ = ('AfterValue',)
-
-try:
-    from typing import TypeAlias
-except ImportError:
-    TypeAlias = type
-
-envtype: TypeAlias = Mapping[bytes, 'AfterValue']
-
-
-class AVTarget:
-    def given(self, value: 'EValue') -> Evaluable:
-        raise NotImplementedError
 
 
 class AfterValue(Evaluable):
@@ -21,30 +10,22 @@ class AfterValue(Evaluable):
         self.evaluable = evaluable
         self.target = target
 
-    def next(self) -> 'Evaluable':
+    def next(self) -> Evaluable:
         if isinstance(self.evaluable, EValue):
-            if isinstance(self.target, AVAV):
+            if isinstance(self.target, AVChain):
                 self.evaluable, self.target = self.target.target.given(self.evaluable), self.target.aftertarget
                 return self
             return self.target.given(self.evaluable)
         if isinstance(self.evaluable, AfterValue):
-            self.evaluable, self.target = self.evaluable.evaluable, AVAV(self.evaluable.target, self.target)
+            self.evaluable, self.target = self.evaluable.evaluable, AVChain(self.evaluable.target, self.target)
         self.evaluable = self.evaluable.next()
         return self
 
 
-class AVAV(AVTarget):
+class AVChain(AVTarget):
     def __init__(self, target: AVTarget, aftertarget: AVTarget):
         self.target = target
         self.aftertarget = aftertarget
 
-    def given(self, value: 'EValue') -> Evaluable:
+    def given(self, value: EValue) -> Evaluable:
         return AfterValue(self.target.given(value), self.aftertarget)
-
-
-class EValue(Evaluable, abc.ABC):
-    def next(self) -> 'EValue':
-        return self
-
-    def call(self, argument: Evaluable) -> Evaluable:
-        raise NotImplementedError

bu4/evaluation/av/envtype.py

@@ -0,0 +1,12 @@
+from typing import Mapping
+
+from bu4.evaluation.av.aftervalue import AfterValue
+
+__all__ = ('envtype',)
+
+try:
+    from typing import TypeAlias
+except ImportError:
+    TypeAlias = type
+
+envtype: TypeAlias = Mapping[bytes, AfterValue]

bu4/evaluation/av/lambdaenv.py

@@ -1,7 +1,11 @@
 from typing import Mapping, Iterator
 
-from bu4.evaluation.avcontainer import AVContainer
+from bu4.evaluation.av.aftervalue import AfterValue
-from bu4.evaluation.aftervalue import AfterValue, envtype, Evaluable
+from bu4.evaluation.targets.avcontainer import AVContainer
+from bu4.evaluation.av.envtype import envtype
+from bu4.evaluation.constructs.evaluable import Evaluable
+
+__all__ = ('LambdaEnv',)
 
 
 class LambdaEnv(Mapping):

bu4/evaluation/avcall.py

@@ -1,14 +0,0 @@
-from bu4.evaluation.elinked import ELinked
-from bu4.parsing.linked import Linked
-from bu4.evaluation.aftervalue import Evaluable, EValue, AVTarget, envtype
-
-__all__ = ('AVCall',)
-
-
-class AVCall(AVTarget):
-    def __init__(self, env: envtype, argument: Linked):
-        self.env = env
-        self.argument = argument
-
-    def given(self, value: EValue) -> Evaluable:
-        return value.call(ELinked(self.env, self.argument))

bu4/evaluation/constructs/elambda.py

@@ -1,7 +1,9 @@
-from bu4.evaluation.elinked import ELinked
+from bu4.evaluation.constructs.elinked import ELinked
-from bu4.evaluation.lambdaenv import LambdaEnv
+from bu4.evaluation.av.envtype import envtype
-from bu4.parsing.linked import Linked
+from bu4.evaluation.constructs.evaluable import Evaluable
-from bu4.evaluation.aftervalue import EValue, envtype, Evaluable
+from bu4.evaluation.constructs.evalue import EValue
+from bu4.evaluation.av.lambdaenv import LambdaEnv
+from bu4.parsing.constructs.linked import Linked
 
 __all__ = ('ELambda',)
 

bu4/evaluation/constructs/elinked.py

@@ -1,5 +1,8 @@
-from bu4.parsing.linked import Linked
+from bu4.evaluation.av.envtype import envtype
-from bu4.evaluation.aftervalue import Evaluable, envtype
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.parsing.constructs.linked import Linked
+
+__all__ = ('ELinked',)
 
 
 class ELinked(Evaluable):

bu4/evaluation/constructs/enull.py

@@ -1,4 +1,5 @@
-from bu4.evaluation.aftervalue import EValue, Evaluable
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
 
 __all__ = ('ENull',)
 

bu4/evaluation/constructs/evaluable.py

@@ -1,3 +1,6 @@
+__all__ = ('Evaluable',)
+
+
 class Evaluable:
     def next(self) -> 'Evaluable':
         raise NotImplementedError

bu4/evaluation/constructs/evalue.py

@@ -0,0 +1,13 @@
+import abc
+
+from bu4.evaluation.constructs.evaluable import Evaluable
+
+__all__ = ('EValue',)
+
+
+class EValue(Evaluable, abc.ABC):
+    def next(self) -> 'EValue':
+        return self
+
+    def call(self, argument: Evaluable) -> Evaluable:
+        raise NotImplementedError

bu4/evaluation/constructs/proxy.py

@@ -1,7 +1,12 @@
 from typing import Any
 
-from bu4.evaluation.aftervalue import AVTarget, EValue, Evaluable, AfterValue
+from bu4.evaluation.av.aftervalue import AfterValue
-from bu4.toolchain.sync import sync
+from bu4.evaluation.targets.avtarget import AVTarget
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
+from bu4.evaluation.sync import sync
+
+__all__ = ('eproxy', 'antiproxy')
 
 
 class AVProxyCall(AVTarget):

bu4/evaluation/sync.py

@@ -1,4 +1,7 @@
-from bu4.evaluation.aftervalue import Evaluable, EValue
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
+
+__all__ = ('sync',)
 
 
 def sync(evaluable: Evaluable) -> EValue:

bu4/evaluation/synced.py

@@ -0,0 +1,14 @@
+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.parsing.toolchain.parse import parse
+from bu4.parsing.toolchain.transply import transply
+
+__all__ = ('synced',)
+
+
+def synced(source: str) -> EValue:
+    bsource = transply(source)
+    parsed = parse(bsource)
+    evaluable = evaluable_from_parsed({}, parsed)
+    return sync(evaluable)

bu4/evaluation/targets/avcall.py

@@ -0,0 +1,17 @@
+from bu4.evaluation.targets.avtarget import AVTarget
+from bu4.evaluation.constructs.elinked import ELinked
+from bu4.evaluation.av.envtype import envtype
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
+from bu4.parsing.constructs.linked import Linked
+
+__all__ = ('AVCall',)
+
+
+class AVCall(AVTarget):
+    def __init__(self, env: envtype, argument: Linked):
+        self.env = env
+        self.argument = argument
+
+    def given(self, value: EValue) -> Evaluable:
+        return value.call(ELinked(self.env, self.argument))

bu4/evaluation/targets/avcontainer.py

@@ -1,4 +1,9 @@
-from bu4.evaluation.aftervalue import EValue, AfterValue, Evaluable, AVTarget
+from bu4.evaluation.av.aftervalue import AfterValue
+from bu4.evaluation.targets.avtarget import AVTarget
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
+
+__all__ = ('AVContainer',)
 
 
 class AVContainer(AVTarget):

bu4/evaluation/targets/avtarget.py

@@ -0,0 +1,9 @@
+from bu4.evaluation.constructs.evaluable import Evaluable
+from bu4.evaluation.constructs.evalue import EValue
+
+__all__ = ('AVTarget',)
+
+
+class AVTarget:
+    def given(self, value: EValue) -> Evaluable:
+        raise NotImplementedError

bu4/linking/altarget.py

@@ -1,6 +0,0 @@
-from bu4.parsing.linked import Linked, LinkingState
-
-
-class ALTarget:
-    def given(self, linked: Linked) -> LinkingState:
-        raise NotImplementedError

bu4/linking/evaluable_from_parsed.py

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

bu4/linking/linkingfinished.py

@@ -1,6 +0,0 @@
-from bu4.parsing.linked import LinkingState, Linked
-
-
-class LinkingFinished(LinkingState):
-    def __init__(self, linked: Linked):
-        self.linked = linked

bu4/linking/prepare.py

@@ -1,15 +1,18 @@
-from bu4.linking.afterlinking import AfterLinking
+from bu4.linking.states.afterlinking import AfterLinking
-from bu4.linking.alal import ALAL
+from bu4.linking.targets.alchain import ALChain
-from bu4.parsing.linked import LinkingState, Linked
+from bu4.linking.states.linkingfinished import LinkingFinished
-from bu4.linking.linkingfinished import LinkingFinished
+from bu4.linking.states.linkingparsed import LinkingParsed
-from bu4.linking.linkingparsed import LinkingParsed
+from bu4.linking.states.linkingstate import LinkingState
+from bu4.parsing.constructs.linked import Linked
+
+__all__ = ('prepare',)
 
 
 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, ALAL(state.state.target, state.target)
+        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).link()
     else:

bu4/linking/states/afterlinking.py

@@ -1,5 +1,8 @@
-from bu4.linking.altarget import ALTarget
+from bu4.linking.targets.altarget import ALTarget
-from bu4.parsing.linked import LinkingState
+
+__all__ = ('AfterLinking',)
+
+from bu4.linking.states.linkingstate import LinkingState
 
 
 class AfterLinking(LinkingState):

bu4/linking/states/linkingfinished.py

@@ -0,0 +1,9 @@
+from bu4.linking.states.linkingstate import LinkingState
+from bu4.parsing.constructs.linked import Linked
+
+__all__ = ('LinkingFinished',)
+
+
+class LinkingFinished(LinkingState):
+    def __init__(self, linked: Linked):
+        self.linked = linked

bu4/linking/states/linkingparsed.py

@@ -1,4 +1,7 @@
-from bu4.parsing.linked import LinkingState, Parsed
+from bu4.linking.states.linkingstate import LinkingState
+from bu4.parsing.constructs.linked import Parsed
+
+__all__ = ('LinkingParsed',)
 
 
 class LinkingParsed(LinkingState):

bu4/linking/states/linkingstate.py

@@ -0,0 +1,5 @@
+__all__ = ('LinkingState',)
+
+
+class LinkingState:
+    pass

bu4/linking/targets/alchain.py

@@ -1,9 +1,12 @@
-from bu4.linking.afterlinking import AfterLinking
+from bu4.linking.states.afterlinking import AfterLinking
-from bu4.linking.altarget import ALTarget
+from bu4.linking.targets.altarget import ALTarget
-from bu4.parsing.linked import Linked, LinkingState
+from bu4.linking.states.linkingstate import LinkingState
+from bu4.parsing.constructs.linked import Linked
+
+__all__ = ('ALChain',)
 
 
-class ALAL(ALTarget):
+class ALChain(ALTarget):
     def __init__(self, target: ALTarget, aftertarget: ALTarget):
         self.target = target
         self.aftertarget = aftertarget

bu4/linking/targets/allambda.py

@@ -1,7 +1,10 @@
 from typing import Callable
 
-from bu4.linking.altarget import ALTarget
+from bu4.linking.targets.altarget import ALTarget
-from bu4.parsing.linked import Linked, LinkingState
+from bu4.linking.states.linkingstate import LinkingState
+from bu4.parsing.constructs.linked import Linked
+
+__all__ = ('ALLambda',)
 
 
 class ALLambda(ALTarget):

bu4/linking/targets/altarget.py

@@ -0,0 +1,9 @@
+from bu4.linking.states.linkingstate import LinkingState
+from bu4.parsing.constructs.linked import Linked
+
+__all__ = ('ALTarget',)
+
+
+class ALTarget:
+    def given(self, linked: Linked) -> LinkingState:
+        raise NotImplementedError

bu4/parsing/abstractparser.py

@@ -0,0 +1,6 @@
+__all__ = ('AbstractParser',)
+
+
+class AbstractParser:
+    def read(self) -> int:
+        raise NotImplementedError

bu4/parsing/constructs/lcall.py

@@ -1,14 +1,17 @@
-from bu4.codes import CODE_CALL
+from bu4.evaluation.av.aftervalue import AfterValue
-from bu4.evaluation.avcall import AVCall
+from bu4.evaluation.av.envtype import envtype
-from bu4.evaluation.elinked import ELinked
+from bu4.linking.states.linkingstate import LinkingState
-from bu4.linking.afterlinking import AfterLinking
+from bu4.parsing.codes import CODE_CALL
-from bu4.linking.allambda import ALLambda
+from bu4.evaluation.targets.avcall import AVCall
-from bu4.parsing.linked import Linked, Parsed, LinkingState
+from bu4.evaluation.constructs.elinked import ELinked
-from bu4.linking.linkingfinished import LinkingFinished
+from bu4.linking.states.afterlinking import AfterLinking
-from bu4.linking.linkingparsed import LinkingParsed
+from bu4.linking.targets.allambda import ALLambda
-from bu4.evaluation.aftervalue import envtype, Evaluable, AfterValue
+from bu4.parsing.constructs.linked import Linked, Parsed
+from bu4.linking.states.linkingfinished import LinkingFinished
+from bu4.linking.states.linkingparsed import LinkingParsed
+from bu4.evaluation.constructs.evaluable import Evaluable
 
-__all__ = ('LCall', 'PCall',)
+__all__ = ('PCall',)
 
 
 class LCall(Linked):

bu4/parsing/constructs/linked.py

@@ -1,8 +1,9 @@
-from bu4.evaluation.aftervalue import envtype, Evaluable
+from bu4.evaluation.av.envtype import envtype
+from bu4.evaluation.constructs.evaluable import Evaluable
 
+__all__ = ('Linked', 'Parsed',)
 
-class LinkingState:
+from bu4.linking.states.linkingstate import LinkingState
-    pass
 
 
 class Linked:

bu4/parsing/constructs/llambda.py

@@ -1,13 +1,15 @@
-from bu4.codes import CODE_MAKE, CODE_NULL
+from bu4.evaluation.av.envtype import envtype
-from bu4.evaluation.elambda import ELambda
+from bu4.linking.states.linkingstate import LinkingState
-from bu4.linking.afterlinking import AfterLinking
+from bu4.parsing.codes import CODE_MAKE, CODE_NULL
-from bu4.linking.allambda import ALLambda
+from bu4.evaluation.constructs.elambda import ELambda
-from bu4.parsing.linked import Linked, Parsed, LinkingState
+from bu4.linking.states.afterlinking import AfterLinking
-from bu4.linking.linkingfinished import LinkingFinished
+from bu4.linking.targets.allambda import ALLambda
-from bu4.linking.linkingparsed import LinkingParsed
+from bu4.parsing.constructs.linked import Linked, Parsed
-from bu4.evaluation.aftervalue import envtype, Evaluable
+from bu4.linking.states.linkingfinished import LinkingFinished
+from bu4.linking.states.linkingparsed import LinkingParsed
+from bu4.evaluation.constructs.evaluable import Evaluable
 
-__all__ = ('LLambda', 'PLambda',)
+__all__ = ('PLambda',)
 
 
 class LLambda(Linked):

bu4/parsing/constructs/lname.py

@@ -1,10 +1,12 @@
-from bu4.codes import CODE_NAME, CODE_NULL
+from bu4.evaluation.av.envtype import envtype
-from bu4.parsing.linked import Linked, LinkingState, Parsed
+from bu4.linking.states.linkingstate import LinkingState
-from bu4.linking.linkingfinished import LinkingFinished
+from bu4.parsing.codes import CODE_NAME, CODE_NULL
-from bu4.evaluation.aftervalue import envtype, Evaluable
+from bu4.parsing.constructs.linked import Linked, Parsed
+from bu4.linking.states.linkingfinished import LinkingFinished
+from bu4.evaluation.constructs.evaluable import Evaluable
 
 
-__all__ = ('LName', 'PName',)
+__all__ = ('PName',)
 
 
 class LName(Linked):

bu4/parsing/constructs/lnull.py

@@ -0,0 +1,35 @@
+from bu4.evaluation.constructs.enull import ENull
+from bu4.evaluation.av.envtype import envtype
+from bu4.linking.states.linkingstate import LinkingState
+from bu4.parsing.codes import CODE_NULL
+from bu4.parsing.constructs.linked import Linked, Parsed
+from bu4.linking.states.linkingfinished import LinkingFinished
+from bu4.evaluation.constructs.evaluable import Evaluable
+
+
+__all__ = ('PNull',)
+
+
+class LNull(Linked):
+    def __init__(self):
+        self.future = set()
+
+    def link(self) -> LinkingState:
+        return LinkingFinished(self)
+
+    def evaluable(self, env: envtype) -> Evaluable:
+        return ENull()
+
+    def __str__(self):
+        return '?'
+
+    def unlink(self) -> Parsed:
+        return PNull()
+
+
+class PNull(Parsed):
+    def link(self, promise: set[bytes]) -> Linked:
+        return LNull()
+
+    def __bytes__(self):
+        return bytes([CODE_NULL])

bu4/parsing/lnull.py

@@ -1,33 +0,0 @@
-from bu4.evaluation.enull import ENull
-from bu4.codes import CODE_NULL
-from bu4.parsing.linked import Linked, LinkingState, Parsed
-from bu4.linking.linkingfinished import LinkingFinished
-from bu4.evaluation.aftervalue import envtype, Evaluable
-
-
-__all__ = ('LNull', 'PNull',)
-
-
-class LNull(Linked):
-    def __init__(self):
-        self.future = set()
-
-    def link(self) -> LinkingState:
-        return LinkingFinished(self)
-
-    def evaluable(self, env: envtype) -> Evaluable:
-        return ENull()
-
-    def __str__(self):
-        return '?'
-
-    def unlink(self) -> Parsed:
-        return PNull()
-
-
-class PNull(Parsed):
-    def link(self, promise: set[bytes]) -> 'Linked':
-        return LNull()
-
-    def __bytes__(self):
-        return bytes([CODE_NULL])

bu4/parsing/parser.py

@@ -1,86 +1,23 @@
 from io import BytesIO
-from typing import Callable
 
-from bu4.parsing.linked import Parsed
+from bu4.parsing.abstractparser import AbstractParser
-from bu4.parsing.lname import PName
+from bu4.parsing.codes import *
-from bu4.codes import CODE_NULL, CODE_CALL, CODE_MAKE, CODE_NAME, CODE_SKIP, CODE_QUOT, CODE_QOPN, CODE_QCLS
+from bu4.parsing.constructs.linked import Parsed
-from bu4.parsing.lcall import PCall
+from bu4.parsing.constructs.llambda import PLambda
-from bu4.parsing.lnull import PNull
+from bu4.parsing.constructs.lname import PName
+from bu4.parsing.constructs.lnull import PNull
+from bu4.parsing.states.psafter import PSAfter
+from bu4.parsing.states.pscall import pscall
+from bu4.parsing.states.psfinal import PSFinal
+from bu4.parsing.states.psread import PSRead
+from bu4.parsing.targets.pschain import PSChain
+from bu4.parsing.targets.psendswith import PSEndsWith
+from bu4.parsing.targets.pslambda import PSLambda
 
-from bu4.parsing.llambda import PLambda
+__all__ = ('Parser',)
 
 
-class ParseState:
+class Parser(AbstractParser):
-    pass
-
-
-class PSRead(ParseState):
-    pass
-
-
-class PSFinal(ParseState):
-    def __init__(self, parsed: Parsed):
-        self.parsed = parsed
-
-
-class PSATarget:
-    def given(self, parsed: Parsed) -> ParseState:
-        raise NotImplementedError
-
-
-class PSAfter(ParseState):
-    def __init__(self, state, target: PSATarget):
-        self.state = state
-        self.target = target
-
-
-class PSAA(PSATarget):
-    def __init__(self, target: PSATarget, aftertarget: PSATarget):
-        self.target = target
-        self.aftertarget = aftertarget
-
-    def given(self, parsed: Parsed) -> ParseState:
-        return PSAfter(self.target.given(parsed), self.aftertarget)
-
-
-class PSALambda(PSATarget):
-    def __init__(self, lambda_: Callable[[Parsed], ParseState]):
-        self.lambda_ = lambda_
-
-    def given(self, parsed: Parsed) -> ParseState:
-        return self.lambda_(parsed)
-
-
-class PSAEndsWith(PSATarget):
-    def __init__(self, parser: 'Parser', c: int, msg: str):
-        self.parser = parser
-        self.c = c
-        self.msg = msg
-
-    def given(self, parsed: Parsed) -> ParseState:
-        assert self.parser.read() == self.c, self.msg
-        return PSFinal(parsed)
-
-
-_apacall = PSAfter(
-    PSRead(),
-    PSALambda(
-        lambda argument: PSAfter(
-            PSRead(),
-            PSALambda(
-                lambda lambda_: PSFinal(
-                    PCall(
-                        argument,
-                        lambda_
-                    )
-                )
-            )
-        )
-    )
-)
-
-
-class Parser:
     def __init__(self, s: bytes):
         self.__s = BytesIO(s)
 
@@ -101,11 +38,11 @@ class Parser:
         if c == CODE_NULL:
             state.state = PSFinal(PNull())
         elif c == CODE_CALL:
-            state.state = _apacall
+            state.state = pscall
         elif c == CODE_MAKE:
             state.state = (lambda name: PSAfter(
                 PSRead(),
-                PSALambda(
+                PSLambda(
                     lambda value: PSFinal(PLambda(name, value))
                 )
             ))(self.parse_name())
@@ -114,16 +51,16 @@ class Parser:
         elif c == CODE_SKIP:
             pass
         elif c == CODE_QUOT:
-            state.target = PSAA(PSAEndsWith(self, CODE_QUOT, "quot expected"), state.target)
+            state.target = PSChain(PSEndsWith(self, CODE_QUOT, "quot expected"), state.target)
         elif c == CODE_QOPN:
-            state.target = PSAA(PSAEndsWith(self, CODE_QCLS, "qcls expected"), state.target)
+            state.target = PSChain(PSEndsWith(self, CODE_QCLS, "qcls expected"), state.target)
         else:
             raise ValueError(f"unknown control: {hex(c)}")
         return state
 
     def _state_next(self, state: PSAfter):
         if isinstance(state.state, PSAfter):
-            state.state, state.target = state.state.state, PSAA(state.state.target, state.target)
+            state.state, state.target = state.state.state, PSChain(state.state.target, state.target)
         elif isinstance(state.state, PSFinal):
             state = state.target.given(state.state.parsed)
         elif isinstance(state.state, PSRead):
@@ -131,7 +68,7 @@ class Parser:
         return state
 
     def parse(self) -> Parsed:
-        state = PSAfter(PSRead(), PSALambda(lambda parsed: PSFinal(parsed)))
+        state = PSAfter(PSRead(), PSLambda(lambda parsed: PSFinal(parsed)))
         while True:
             if isinstance(state, PSFinal):
                 return state.parsed

bu4/parsing/states/parsestate.py

@@ -0,0 +1,5 @@
+__all__ = ('ParseState',)
+
+
+class ParseState:
+    pass

bu4/parsing/states/psafter.py

@@ -0,0 +1,10 @@
+from bu4.parsing.states.parsestate import ParseState
+from bu4.parsing.targets.pstarget import PSTarget
+
+__all__ = ('PSAfter',)
+
+
+class PSAfter(ParseState):
+    def __init__(self, state: ParseState, target: PSTarget):
+        self.state = state
+        self.target = target

bu4/parsing/states/pscall.py

@@ -0,0 +1,24 @@
+from bu4.parsing.constructs.lcall import PCall
+from bu4.parsing.states.psafter import PSAfter
+from bu4.parsing.states.psfinal import PSFinal
+from bu4.parsing.targets.pslambda import PSLambda
+from bu4.parsing.states.psread import PSRead
+
+__all__ = ('pscall',)
+
+pscall = PSAfter(
+    PSRead(),
+    PSLambda(
+        lambda argument: PSAfter(
+            PSRead(),
+            PSLambda(
+                lambda lambda_: PSFinal(
+                    PCall(
+                        argument,
+                        lambda_
+                    )
+                )
+            )
+        )
+    )
+)

bu4/parsing/states/psfinal.py

@@ -0,0 +1,9 @@
+from bu4.parsing.constructs.linked import Parsed
+from bu4.parsing.states.parsestate import ParseState
+
+__all__ = ('PSFinal',)
+
+
+class PSFinal(ParseState):
+    def __init__(self, parsed: Parsed):
+        self.parsed = parsed

bu4/parsing/states/psread.py

@@ -0,0 +1,7 @@
+from bu4.parsing.states.parsestate import ParseState
+
+__all__ = ('PSRead',)
+
+
+class PSRead(ParseState):
+    pass

bu4/parsing/targets/pschain.py

@@ -0,0 +1,15 @@
+from bu4.parsing.constructs.linked import Parsed
+from bu4.parsing.states.parsestate import ParseState
+from bu4.parsing.states.psafter import PSAfter
+from bu4.parsing.targets.pstarget import PSTarget
+
+__all__ = ('PSChain',)
+
+
+class PSChain(PSTarget):
+    def __init__(self, target: PSTarget, aftertarget: PSTarget):
+        self.target = target
+        self.aftertarget = aftertarget
+
+    def given(self, parsed: Parsed) -> ParseState:
+        return PSAfter(self.target.given(parsed), self.aftertarget)

bu4/parsing/targets/psendswith.py

@@ -0,0 +1,18 @@
+from bu4.parsing.abstractparser import AbstractParser
+from bu4.parsing.constructs.linked import Parsed
+from bu4.parsing.states.parsestate import ParseState
+from bu4.parsing.states.psfinal import PSFinal
+from bu4.parsing.targets.pstarget import PSTarget
+
+__all__ = ('PSEndsWith',)
+
+
+class PSEndsWith(PSTarget):
+    def __init__(self, parser: AbstractParser, c: int, msg: str):
+        self.parser = parser
+        self.c = c
+        self.msg = msg
+
+    def given(self, parsed: Parsed) -> ParseState:
+        assert self.parser.read() == self.c, self.msg
+        return PSFinal(parsed)

bu4/parsing/targets/pslambda.py

@@ -0,0 +1,15 @@
+from typing import Callable
+
+from bu4.parsing.constructs.linked import Parsed
+from bu4.parsing.states.parsestate import ParseState
+from bu4.parsing.targets.pstarget import PSTarget
+
+__all__ = ('PSLambda',)
+
+
+class PSLambda(PSTarget):
+    def __init__(self, lambda_: Callable[[Parsed], ParseState]):
+        self.lambda_ = lambda_
+
+    def given(self, parsed: Parsed) -> ParseState:
+        return self.lambda_(parsed)

bu4/parsing/targets/pstarget.py

@@ -0,0 +1,9 @@
+from bu4.parsing.constructs.linked import Parsed
+from bu4.parsing.states.parsestate import ParseState
+
+__all__ = ('PSTarget',)
+
+
+class PSTarget:
+    def given(self, parsed: Parsed) -> ParseState:
+        raise NotImplementedError

bu4/parsing/toolchain/parse.py

@@ -1,6 +1,9 @@
-from bu4.parsing.linked import Parsed
+from bu4.parsing.constructs.linked import Parsed
 from bu4.parsing.parser import Parser
 
 
+__all__ = ('parse',)
+
+
 def parse(source: bytes) -> Parsed:
     return Parser(source).parse()

bu4/parsing/toolchain/readfile.py

@@ -1,13 +1,15 @@
 import os
 from io import StringIO
 
+__all__ = ('readfile',)
+
 
 def readfile(path: str) -> str:
     srcio = StringIO()
     with open(path + '.bu4') as file:
         for line in file:
             if line.startswith('@'):
-                srcio.write(readfile(os.path.join(path, '..', line.removeprefix('@').strip())))
+                srcio.write(readfile(os.path.join(path, os.path.pardir, line.removeprefix('@').strip())))
             else:
                 srcio.write(line)
     return srcio.getvalue()

bu4/parsing/toolchain/transply.py

@@ -1,6 +1,8 @@
 from io import BytesIO
 
-from bu4.codes import CODE_CALL, CODE_QOPN, CODE_MAKE, CODE_QCLS, CODE_NULL, CODE_SKIP, CODE_NAME, CODE_QUOT
+from bu4.parsing.codes import *
+
+__all__ = ('transply',)
 
 
 def transply(source: str) -> bytes:

bu4/toolchain/elinked.py

@@ -1,10 +0,0 @@
-from bu4.evaluation.elinked import ELinked
-from bu4.parsing.linked import Parsed
-from bu4.evaluation.aftervalue import envtype
-from bu4.toolchain.prepare import prepare
-
-
-def elinked(env: envtype, parsed: Parsed):
-    linked = parsed.link(set(env))
-    prepare(linked)
-    return ELinked(env, linked)

bu4/toolchain/synced.py

@@ -1,12 +0,0 @@
-from bu4.evaluation.aftervalue import EValue
-from bu4.toolchain.elinked import elinked
-from bu4.toolchain.parse import parse
-from bu4.toolchain.sync import sync
-from bu4.toolchain.transply import transply
-
-
-def synced(source: str) -> EValue:
-    bsource = transply(source)
-    parsed = parse(bsource)
-    evaluable = elinked({}, parsed)
-    return sync(evaluable)

main.py

@@ -1,8 +1,8 @@
-from bu4.evaluation.proxy import antiproxy, eproxy
+from bu4.common_interface import with_common_interface
-from bu4.toolchain.readfile import readfile
+from bu4.evaluation.constructs.proxy import antiproxy, eproxy
-from bu4.toolchain.sync import sync
+from bu4.evaluation.sync import sync
-from bu4.toolchain.synced import synced
+from bu4.evaluation.synced import synced
-from bu4.utils import with_common_interface
+from bu4.parsing.toolchain.readfile import readfile
 from timesample import TimeSample
 
 with TimeSample('    compilation'):
@@ -49,3 +49,8 @@ with TimeSample('    full'):
     sys3 = with_common_interface(synced(readfile('src/sys3')))
     sys3 = sync(sys3.call(eproxy(5)))
     print(sys3)
+with TimeSample('    full'):
+    sys1 = with_common_interface(synced(readfile('src/sys1')))
+    sys1 = sync(sys1.call(eproxy(77)))
+    sys1 = sync(sys1.call(eproxy(194)))
+    print(sys1)

src/@.bu4

@@ -3,4 +3,5 @@
 @binary/@
 @convert/@
 @io/@
+@serialization/@
 @numbers

src/binary/@.bu4

@@ -3,3 +3,4 @@
 @add
 @mul
 @sub
+@bitwise

src/binary/add.bu4

@@ -1,4 +1,5 @@
 { (b)                 </[b]/[0][b!]>        | b_double }
+{ (b)         </ <(zq)(lb)(hb!) [hb!]> [b]> | b_halve  }
 
 {
     /(b_add)

src/binary/bitwise.bu4

@@ -0,0 +1,99 @@
+{
+    /(b_and)
+        (bA)(bB)
+            /(zqA)(lbA)(hb!A)
+                /
+                    /(zqB)(lbB)(hb!B)
+                        /
+                            /
+                                /[hb!B]/[hb!A][b_and]
+                            /
+                                /[lbB]/[lbA][and]
+                            [b!]
+                        /
+                            [b0]
+                        [zqB]
+                    [bB]
+                /
+                    [b0]
+                [zqA]
+            [bA]
+    [YC]
+|
+    b_and
+}
+
+{
+    /(b_or)
+        (bA)(bB)
+            /(zqA)(lbA)(hb!A)
+                /
+                    /(zqB)(lbB)(hb!B)
+                        /
+                            /
+                                /[hb!B]/[hb!A][b_or]
+                            /
+                                /[lbB]/[lbA][or]
+                            [b!]
+                        /
+                            [bA]
+                        [zqB]
+                    [bB]
+                /
+                    [bB]
+                [zqA]
+            [bA]
+    [YC]
+|
+    b_or
+}
+
+{
+    /(b_xor)
+        (bA)(bB)
+            /(zqA)(lbA)(hb!A)
+                /
+                    /(zqB)(lbB)(hb!B)
+                        /
+                            /
+                                /[hb!B]/[hb!A][b_xor]
+                            /
+                                /[lbB]/[lbA][xor]
+                            [b!]
+                        /
+                            [bA]
+                        [zqB]
+                    [bB]
+                /
+                    [bB]
+                [zqA]
+            [bA]
+    [YC]
+|
+    b_xor
+}
+
+{
+    /(b_exclude)
+        (bA)(bB)
+            /(zqA)(lbA)(hb!A)
+                /
+                    /(zqB)(lbB)(hb!B)
+                        /
+                            /
+                                /[hb!B]/[hb!A][b_exclude]
+                            /
+                                /</[lbB][not]>/[lbA][and]
+                            [b!]
+                        /
+                            [bA]
+                        [zqB]
+                    [bB]
+                /
+                    [b0]
+                [zqA]
+            [bA]
+    [YC]
+|
+    b_exclude
+}

src/serialization/@.bu4

@@ -0,0 +1 @@
+@hex

src/serialization/hex.bu4

@@ -0,0 +1,15 @@
+{
+    (b) ////[b][b_double][b_double][b_double][b_double]
+|
+    x16
+}
+
+{
+    {       (higher) (zq)(lb)(hb)    /  [higher]             /[lb][b!] | 2x2b }
+    {       (higher) (zq)(lb)(hb)    ///[higher][2x2b][hb   ]/[lb][b!] | 4x2b }
+    {       (higher) (zq)(lb)(hb)    ///[higher][4x2b][hb   ]/[lb][b!] | 8x2b }
+    {       (higher) (zq)(lb)(hb)    ///[higher][8x2b][hb   ]/[lb][b!] | xx2b }
+    (lower) (higher)      ////[b0][xx2b][higher][xx2b][lower]
+|
+    xx2b
+}

src/sys1.bu4

@@ -0,0 +1,15 @@
+@@
+
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+@ci
+
+(a)(b)
+
+    /
+        /
+            /[b][n_to_bx]
+        /
+            /[a][n_to_bx]
+        [xx2b]
+    [b_to_nx]
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

timesample.py

@@ -1,5 +1,7 @@
 import time
 
+__all__ = ('TimeSample',)
+
 
 class TimeSample:
     level = 0