_mod_mul

bu4/parsing/constructs/lcall.py

@@ -53,9 +53,9 @@ class LCall(Linked):
 
 
 class PCall(Parsed):
-    def __init__(self, value: Parsed, lambda_: Parsed):
+    def __init__(self, argument: Parsed, lambda_: Parsed):
-        self.value = value
+        self.argument = argument
         self.lambda_ = lambda_
 
     def link(self, promise: set[bytes]) -> Linked:
-        return LCall(promise, self.value, self.lambda_)
+        return LCall(promise, self.argument, self.lambda_)

bu4/parsing/parser.py

@@ -8,6 +8,7 @@ from bu4.parsing.constructs.linked import Parsed
 from bu4.parsing.constructs.llambda import PLambda
 from bu4.parsing.constructs.lname import PName
 from bu4.parsing.constructs.lnull import PNull
+from bu4.parsing.states.parsestate import ParseState
 from bu4.parsing.states.psafter import PSAfter
 from bu4.parsing.states.pscall import pscall
 from bu4.parsing.states.psfinal import PSFinal
@@ -20,14 +21,14 @@ __all__ = ('Parser',)
 
 
 class Parser(AbstractParser):
-    def __init__(self, s: bytes):
+    def __init__(self, source: bytes):
-        self.__s = BytesIO(s)
+        self.__source = BytesIO(source)
 
     def read(self) -> int:
-        bytes_ = self.__s.read(1)
+        bytes_ = self.__source.read(1)
         return bytes_[0] if bytes_ else 0
 
-    def parse_name(self) -> bytes:
+    def _parse_name(self) -> bytes:
         s = BytesIO()
         while True:
             c = self.read()
@@ -35,21 +36,22 @@ class Parser(AbstractParser):
                 return s.getvalue()
             s.write(bytes([c]))
 
-    def _state_read(self, state: PSAfter):
+    def _state_read(self, state: PSAfter) -> ParseState:
         c = self.read()
         if c == CODE_NULL:
             state.state = PSFinal(PNull())
         elif c == CODE_CALL:
-            state.state = pscall
+            state.state = pscall()
         elif c == CODE_MAKE:
-            state.state = (lambda name: PSAfter(
+            name = self._parse_name()
+            state.state = PSAfter(
                 PSRead(),
                 PSLambda(
                     lambda value: PSFinal(PLambda(name, value))
                 )
-            ))(self.parse_name())
+            )
         elif c == CODE_NAME:
-            state.state = PSFinal(PName(self.parse_name()))
+            state.state = PSFinal(PName(self._parse_name()))
         elif c == CODE_SKIP:
             pass
         elif c == CODE_QUOT:
@@ -60,13 +62,15 @@ class Parser(AbstractParser):
             raise ValueError(f"unknown control: {hex(c)}")
         return state
 
-    def _state_next(self, state: PSAfter):
+    def _state_next(self, state: PSAfter) -> ParseState:
         if isinstance(state.state, PSAfter):
             state.state, state.target = state.state.state, PSChain(state.state.target, state.target)
         elif isinstance(state.state, PSFinal):
             state = state.target.given(state.state.parsed)
         elif isinstance(state.state, PSRead):
             state = self._state_read(state)
+        else:
+            raise TypeError
         return state
 
     def parse(self) -> Parsed:

bu4/parsing/states/pscall.py

@@ -8,7 +8,9 @@ from bu4.parsing.targets.pslambda import PSLambda
 
 __all__ = ('pscall',)
 
-pscall = PSAfter(
+
+def pscall():
+    return PSAfter(
         PSRead(),
         PSLambda(
             lambda argument: PSAfter(
@@ -23,4 +25,4 @@ pscall = PSAfter(
                 )
             )
         )
-)
+    )

bu4/parsing/targets/psendswith.py

@@ -10,11 +10,11 @@ __all__ = ('PSEndsWith',)
 
 
 class PSEndsWith(PSTarget):
-    def __init__(self, parser: AbstractParser, c: int, msg: str):
+    def __init__(self, parser: AbstractParser, expected: int, message: str):
         self.parser = parser
-        self.c = c
+        self.expected = expected
-        self.msg = msg
+        self.message = message
 
     def given(self, parsed: Parsed) -> ParseState:
-        assert self.parser.read() == self.c, self.msg
+        assert self.parser.read() == self.expected, self.message
         return PSFinal(parsed)

bu4/parsing/toolchain/transply.py

@@ -8,35 +8,35 @@ __all__ = ('transply',)
 
 
 def transply(source: str) -> bytes:
-    b = BytesIO()
+    transplied = BytesIO()
     for c in source:
         if c.isspace():
             pass
         elif c in '/':
-            b.write(bytes([CODE_CALL]))
+            transplied.write(bytes([CODE_CALL]))
         elif c in '{‹':
-            b.write(bytes([CODE_CALL, CODE_QOPN]))
+            transplied.write(bytes([CODE_CALL, CODE_QOPN]))
         elif c in '(':
-            b.write(bytes([CODE_MAKE]))
+            transplied.write(bytes([CODE_MAKE]))
         elif c in '|':
-            b.write(bytes([CODE_QCLS, CODE_MAKE]))
+            transplied.write(bytes([CODE_QCLS, CODE_MAKE]))
         elif c in '})':
-            b.write(bytes([CODE_NULL]))
+            transplied.write(bytes([CODE_NULL]))
         elif c in '#':
-            b.write(bytes([CODE_SKIP]))
+            transplied.write(bytes([CODE_SKIP]))
         elif c in '?':
-            b.write(bytes([CODE_QOPN, CODE_NULL, CODE_QCLS]))
+            transplied.write(bytes([CODE_QOPN, CODE_NULL, CODE_QCLS]))
         elif c in ']':
-            b.write(bytes([CODE_NULL, CODE_QCLS]))
+            transplied.write(bytes([CODE_NULL, CODE_QCLS]))
         elif c in '[':
-            b.write(bytes([CODE_QOPN, CODE_NAME]))
+            transplied.write(bytes([CODE_QOPN, CODE_NAME]))
         elif c in '"':
-            b.write(bytes([CODE_QUOT]))
+            transplied.write(bytes([CODE_QUOT]))
         elif c in '<':
-            b.write(bytes([CODE_QOPN]))
+            transplied.write(bytes([CODE_QOPN]))
         elif c in '>›':
-            b.write(bytes([CODE_QCLS]))
+            transplied.write(bytes([CODE_QCLS]))
         else:
             value = c.encode()
-            b.write(value if len(value) == 1 else f'[{value.hex()}]'.encode())
+            transplied.write(value if len(value) == 1 else f'[{value.hex()}]'.encode())
-    return b.getvalue()
+    return transplied.getvalue()

main.py

@@ -1,15 +1,13 @@
 #  Copyright (c) PARRRATE T&V 2021. All rights reserved.
-import sys
+import random
 
 from bu4.common_interface import with_common_interface
 from bu4.evaluation.constructs.proxy import antiproxy, eproxy
 from bu4.evaluation.sync import sync
-from bu4.synced import synced
 from bu4.parsing.toolchain.readfile import readfile
+from bu4.synced import synced
 from timesample import TimeSample
 
-sys.setrecursionlimit(13)
-
 with TimeSample('all'):
     with TimeSample('sys0'):
         with TimeSample('compilation'):
@@ -58,8 +56,10 @@ with TimeSample('all'):
         TimeSample.print(sys3)
     with TimeSample('sys1'):
         sys1 = with_common_interface(synced(readfile('src/sys1')))
-        sys1 = sync(sys1.call(eproxy(5)))
+        random.seed(42)
-        sys1 = sync(sys1.call(eproxy(6)))
+        sys1 = sync(sys1.call(eproxy(random.randrange(2 ** 10))))
+        sys1 = sync(sys1.call(eproxy(random.randrange(2 ** 10))))
+        sys1 = sync(sys1.call(eproxy(random.randrange(2 ** 10))))
         TimeSample.print(sys1)
     with TimeSample('sys4'):
         TimeSample.print(with_common_interface(synced(readfile('src/sys4'))))

src/math/@.bu4

@@ -1,2 +1,3 @@
 @gcd
 @exp
+@mod_mul

src/math/mod_mul.bu4

@@ -0,0 +1,17 @@
+{
+    (_div) (_mul) (_m)
+        (_a) (_b)
+            /
+                /
+                    /
+                        [_b]
+                    /
+                        [_a]
+                    [_mul]
+                /
+                    [_m]
+                [_div]
+            [second]
+|
+    _mod_mul
+}

src/sys1.bu4

@@ -4,9 +4,11 @@
 @ci
 
 { /[b_zq]/[b_div][_gcd] | gcd }
-{ /[b1]/[b_halve]/[b_lb]/[b_zq]/[b_mul][_exp] | exp }
 
-(a)(b)
+(a)(b)(m)
+
+{   /</[m][n_to_b]>/[b_mul]/[b_div][_mod_mul]       |   mod_mul }
+{   /[b1]/[b_halve]/[b_lb]/[b_zq]/[mod_mul][_exp]   |   exp     }
 
     /
         /