klongpy 0.6.9__py3-none-any.whl → 0.7.1__py3-none-any.whl

klongpy/interpreter.py

@@ -2,10 +2,12 @@ import time
 from collections import deque
 
 from .adverbs import get_adverb_fn
+from .backends import get_backend
 from .core import *
 from .dyads import create_dyad_functions
 from .monads import create_monad_functions
 from .sys_fn import create_system_functions
+from .sys_fn_autograd import create_system_functions_autograd
 from .sys_fn_ipc import create_system_functions_ipc, create_system_var_ipc
 from .sys_fn_timer import create_system_functions_timer
 from .sys_var import *
@@ -52,9 +54,10 @@ class KlongContext():
 
     """
 
-    def __init__(self, system_contexts):
+    def __init__(self, system_contexts, strict_mode=1):
         self._context = deque([{}, *system_contexts])
         self._min_ctx_count = len(system_contexts)
+        self._strict_mode = strict_mode
 
     def start_module(self, name):
         self.push(KGModule(name))
@@ -68,11 +71,28 @@ class KlongContext():
 
     def __setitem__(self, k, v):
         assert isinstance(k, KGSym)
+
         if k not in reserved_fn_symbols:
+            # Check if variable exists in any scope
             for d in self._context:
                 if in_map(k, d):
                     d[k] = v
                     return k
+
+        # Variable doesn't exist - check strict mode
+        if self._strict_mode >= 1:
+            # Check if we're inside a function (more than just global scope)
+            in_function = len(self._context) > self._min_ctx_count + 1
+
+            if in_function:
+                # Inside function - disallow creating new variables
+                raise KlongException(
+                    f"undefined variable: {k}\n"
+                    f"  To create a local variable, declare it in the parameter list: {{[{k}]; ...}}\n"
+                    f"  To modify an existing global, ensure it exists before calling the function"
+                )
+
+        # Create new variable in current scope
         set_context_var(self._context[0], k, v)
         return k
 
@@ -141,6 +161,7 @@ def create_system_contexts():
 
     sys_d = {}
     add_context_key_values(sys_d, create_system_functions())
+    add_context_key_values(sys_d, create_system_functions_autograd())
     add_context_key_values(sys_d, create_system_functions_ipc())
     add_context_key_values(sys_d, create_system_functions_timer())
     set_context_var(sys_d, KGSym('.e'), eval_sys_var_epsilon()) # TODO: support lambda
@@ -210,13 +231,36 @@ def chain_adverbs(klong, arr):
 
 class KlongInterpreter():
 
-    def __init__(self):
-        self._context = KlongContext(create_system_contexts())
+    def __init__(self, backend=None, device=None):
+        """
+        Initialize a Klong interpreter.
+
+        Parameters
+        ----------
+        backend : str, optional
+            Backend name ('numpy' or 'torch'). Defaults to 'numpy'.
+        device : str, optional
+            Device for torch backend ('cpu', 'cuda', 'mps'). Only applies
+            when backend='torch'. If None, auto-selects best available device.
+        """
+        self._backend = get_backend(backend, device=device)
+        strict_mode = 0  # 0=unsafe (default for backward compat), 1=strict, 2=pedantic
+        self._context = KlongContext(create_system_contexts(), strict_mode=strict_mode)
         self._vd = create_dyad_functions(self)
         self._vm = create_monad_functions(self)
         self._start_time = time.time()
         self._module = None
 
+    @property
+    def backend(self):
+        """Return the backend provider for this interpreter."""
+        return self._backend
+
+    @property
+    def np(self):
+        """Return the numpy-compatible array module for this interpreter."""
+        return self._backend.np
+
     def __setitem__(self, k, v):
         k = k if isinstance(k, KGSym) else KGSym(k)
         self._context[k] = v
@@ -224,7 +268,8 @@ class KlongInterpreter():
     def __getitem__(self, k):
         k = k if isinstance(k, KGSym) else KGSym(k)
         r = self._context[k]
-        return KGFnWrapper(self, r) if issubclass(type(r), KGFn) else r
+        # Pass the symbol name to avoid O(n) context search
+        return KGFnWrapper(self, r, sym=k) if issubclass(type(r), KGFn) else r
 
     def __delitem__(self, k):
         k = k if isinstance(k, KGSym) else KGSym(k)
@@ -304,7 +349,7 @@ class KlongInterpreter():
             return i+1,arr
         k = i
         while True:
-            ii,c = kg_read(t,i,ignore_newline=True,module=self.current_module())
+            ii,c = kg_read(t, i, ignore_newline=True, module=self.current_module())
             if safe_eq(c, ';'):
                 i = ii
                 if k == i - 1:
@@ -352,7 +397,7 @@ class KlongInterpreter():
            | V P
 
        """
-        i,a = kg_read(t, i, ignore_newline=ignore_newline, module=self.current_module())
+        i,a = kg_read_array(t, i, self._backend, ignore_newline=ignore_newline, module=self.current_module())
         if a is None:
             return i,a
         if safe_eq(a, '{'): # read fn
@@ -569,14 +614,14 @@ class KlongInterpreter():
         ctx = {} if f_args is None else {reserved_fn_symbol_map[p]: self.call(q) for p,q in zip(reserved_fn_args,f_args)}
 
         if is_list(f) and len(f) > 1 and is_list(f[0]) and len(f[0]) > 0:
-            have_locals = True
-            for q in f[0]:
-                if not isinstance(q, KGSym):
-                    have_locals = False
-                    break
+            # Filter out semicolons and check if all remaining elements are symbols
+            params = [q for q in f[0] if isinstance(q, KGSym)]
+            have_locals = len(params) > 0 and all(isinstance(q, KGSym) for q in params)
             if have_locals:
-                for q in f[0]:
-                    ctx[q] = q
+                for q in params:
+                    # Don't overwrite function parameters (x, y, z)
+                    if q not in ctx:
+                        ctx[q] = q
                 f = f[1:]
 
         ctx[reserved_dot_f_symbol] = f
@@ -618,7 +663,7 @@ class KlongInterpreter():
                 f = self._get_op_fn(x.a.a, x.a.arity)
                 fa = (x.args if isinstance(x.args, list) else [x.args]) if x.args is not None else x.args
                 _y = self.eval(fa[1]) if x.a.arity == 2 else None
-                _x = fa[0] if x.a.a == '::' else self.eval(fa[0])
+                _x = fa[0] if x.a.a in ['::','∇'] else self.eval(fa[0])
                 return f(_x) if x.a.arity == 1 else f(_x, _y)
             elif x.is_adverb_chain():
                 return chain_adverbs(self, x.a)()
@@ -626,7 +671,7 @@ class KlongInterpreter():
                 return self._eval_fn(x)
         elif isinstance(x, KGCond):
             q = self.call(x[0])
-            p = not ((is_number(q) and q == 0) or is_empty(q))
+            p = not ((self._backend.is_number(q) and q == 0) or is_empty(q))
             return self.call(x[1]) if p else self.call(x[2])
         elif isinstance(x,list) and len(x) > 0:
             return [self.call(y) for y in x][-1]

klongpy/monads.py

@@ -1,5 +1,6 @@
 from .core import *
-import sys
+from .autograd import grad_of_fn
+
 
 def eval_monad_atom(a):
     """
@@ -18,7 +19,7 @@ def eval_monad_atom(a):
     return kg_truth(is_atom(a))
 
 
-def eval_monad_char(a):
+def eval_monad_char(a, backend):
     """
 
         :#a                                                       [Char]
@@ -31,10 +32,10 @@ def eval_monad_char(a):
                   :#10  -->  :"newline character"
 
     """
-    return rec_fn(a, lambda x: KGChar(chr(x))) if is_list(a) else KGChar(chr(a))
+    return backend.rec_fn(a, lambda x: KGChar(chr(x))) if is_list(a) else KGChar(chr(a))
 
 
-def eval_monad_enumerate(a):
+def eval_monad_enumerate(a, backend):
     """
 
         !a                                                   [Enumerate]
@@ -46,9 +47,9 @@ def eval_monad_enumerate(a):
                   !10  -->  [0 1 2 3 4 5 6 7 8 9]
 
     """
-    if not is_integer(a):
+    if not backend.is_integer(a):
         raise RuntimeError(f"enumerate: invalid type error: {a}")
-    return np.arange(int(a))
+    return bknp.arange(int(a))
 
 
 def eval_monad_expand_where(a):
@@ -75,7 +76,7 @@ def eval_monad_expand_where(a):
 
     """
     arr = a if is_list(a) else [a]
-    return np.repeat(np.arange(len(arr)), arr)
+    return bknp.repeat(bknp.arange(len(arr)), arr)
 
 
 def eval_monad_first(a):
@@ -97,7 +98,7 @@ def eval_monad_first(a):
     return a if is_empty(a) or not is_iterable(a) else a[0]
 
 
-def eval_monad_floor(a):
+def eval_monad_floor(a, backend):
     """
 
         _a                                                       [Floor]
@@ -115,10 +116,10 @@ def eval_monad_floor(a):
                   _1e100  -->  1.0e+100  :"if precision < 100 digits"
 
     """
-    return vec_fn(a, lambda x: np.floor(np.asarray(x, dtype=float)).astype(int))
+    return backend.vec_fn(a, backend.floor_to_int)
 
 
-def eval_monad_format(a):
+def eval_monad_format(a, backend):
     """
 
         $a                                                      [Format]
@@ -136,10 +137,10 @@ def eval_monad_format(a):
                     $:foo  -->  ":foo"
 
     """
-    return f":{a}" if isinstance(a, KGSym) else vec_fn(a, eval_monad_format) if is_list(a) else str(a)
+    return f":{a}" if isinstance(a, KGSym) else backend.vec_fn(a, lambda x: eval_monad_format(x, backend)) if is_list(a) else str(a)
 
 
-def eval_monad_grade_up(a):
+def eval_monad_grade_up(a, backend):
     """
 
         <a                                                    [Grade-Up]
@@ -164,10 +165,10 @@ def eval_monad_grade_up(a):
                     >[[1] [2] [3]]  -->  [2 1 0]
 
     """
-    return kg_argsort(kg_asarray(a))
+    return kg_argsort(backend.kg_asarray(a), backend)
 
 
-def eval_monad_grade_down(a):
+def eval_monad_grade_down(a, backend):
     """
 
         >a                                                  [Grade-Down]
@@ -175,10 +176,10 @@ def eval_monad_grade_down(a):
         See [Grade-Up].
 
     """
-    return kg_argsort(kg_asarray(a), descending=True)
+    return kg_argsort(backend.kg_asarray(a), backend, descending=True)
 
 
-def eval_monad_groupby(a):
+def eval_monad_groupby(a, backend):
     """
 
         =a                                                       [Group]
@@ -195,15 +196,15 @@ def eval_monad_groupby(a):
                   ="hello foo"  -->  [[0] [1] [2 3] [4 7 8] [5] [6]]
 
     """
-    arr = kg_asarray(a)
-    if arr.size == 0:
+    arr = backend.kg_asarray(a)
+    if backend.array_size(arr) == 0:
         return arr
-    vals, inverse = np.unique(arr, return_inverse=True)
-    groups = [np.where(inverse == i)[0] for i in range(len(vals))]
-    return kg_asarray(groups)
+    vals, inverse = bknp.unique(arr, return_inverse=True)
+    groups = [bknp.where(inverse == i)[0] for i in range(len(vals))]
+    return backend.kg_asarray(groups)
 
 
-def eval_monad_list(a):
+def eval_monad_list(a, backend):
     """
 
         ,a                                                        [List]
@@ -215,14 +216,12 @@ def eval_monad_list(a):
                   ,"xyz" -->  ["xyz"]
                    ,[1]  -->  [[1]]
     """
-    if isinstance(a, KGChar):
+    if is_char(a):
         return str(a)
-    if isinstance(a, KGSym):
-        return np.asarray([a],dtype=object) # np interprets ':foo" as ':fo"
-    return np.asarray([a])
+    return backend.kg_asarray([a])
 
 
-def eval_monad_negate(a):
+def eval_monad_negate(a, backend):
     """
 
         -a                                                      [Negate]
@@ -235,10 +234,10 @@ def eval_monad_negate(a):
                   -1.23  -->  -1.23
 
     """
-    return vec_fn(a, lambda x: np.negative(kg_asarray(x)))
+    return backend.vec_fn(a, lambda x: backend.np.negative(backend.kg_asarray(x)))
 
 
-def eval_monad_not(a):
+def eval_monad_not(a, backend):
     """
 
         ~a                                                         [Not]
@@ -254,11 +253,11 @@ def eval_monad_not(a):
 
     """
     def _neg(x):
-        return 1 if is_empty(x) else 0 if is_dict(x) or isinstance(x, (KGFn, KGSym)) else kg_truth(np.logical_not(np.asarray(x, dtype=object)))
-    return vec_fn(a, _neg) if not is_empty(a) else _neg(a)
+        return 1 if is_empty(x) else 0 if is_dict(x) or isinstance(x, (KGFn, KGSym)) else kg_truth(bknp.logical_not(bknp.asarray(x, dtype=object)))
+    return backend.vec_fn(a, _neg) if not is_empty(a) else _neg(a)
 
 
-def eval_monad_range(a):
+def eval_monad_range(a, backend):
     """
 
         ?a                                                       [Range]
@@ -271,28 +270,19 @@ def eval_monad_range(a):
                   ?"aaabbcccd"  -->  "abcd"
 
     """
+    np_backend = backend.np
     if isinstance(a, str):
-        return ''.join(np.unique(str_to_chr_arr(a)))
-    elif np.isarray(a):
-        if a.dtype != 'O' and a.ndim > 1:
-            _,ids = np.unique(a,axis=0,return_index=True)
+        return ''.join(bknp.unique(backend.str_to_chr_arr(a)))
+    elif np_backend.isarray(a):
+        dtype_kind = backend.get_dtype_kind(a)
+        if dtype_kind != 'O' and a.ndim > 1:
+            # Use numpy for unique with return_index across backends
+            a_np = backend.to_numpy(a) if backend.is_backend_array(a) else a
+            _, ids = bknp.unique(a_np, axis=0, return_index=True)
+            ids.sort()
+            return a[ids]
         else:
             # handle the jagged / mixed array case
-            # from functools import total_ordering
-            # @total_ordering
-            # class Wrapper:
-            #     def __init__(self, x):
-            #         self.x = x
-            #     def __eq__(self,o):
-            #         print("eq")
-            #         return array_equal(self.x, o.x)
-            #     def __ne__(self,o):
-            #         return not array_equal(self.x, o.x)
-            #     def __lt__(self, o):
-            #         u = np.sort(np.asarray([self.x, o.x]))
-            #         return u[0] == self.x
-            #         # return u[0] if isinstance(u,np.ndarray) else u
-            # _,ids = np.unique([Wrapper(x) for x in a], return_index=True)
             # TODO: Make UNIQUE work. this feels so dirty.
             s = set()
             arr = []
@@ -301,13 +291,11 @@ def eval_monad_range(a):
                 if sx not in s:
                     s.add(sx)
                     arr.append(x)
-            return np.asarray(arr, dtype=object)
-        ids.sort()
-        a = a[ids]
+            return backend.kg_asarray(arr)
     return a
 
 
-def eval_monad_reciprocal(a):
+def eval_monad_reciprocal(a, backend):
     """
 
         %a                                                  [Reciprocal]
@@ -321,7 +309,11 @@ def eval_monad_reciprocal(a):
                    %0.1  -->  10.0
 
     """
-    return vec_fn(a, lambda x: np.reciprocal(np.asarray(x,dtype=float)))
+    if not is_list(a) and backend.is_number(a):
+        a_val = backend.scalar_to_python(a) if backend.is_backend_array(a) else a
+        if a_val == 0:
+            return KLONG_UNDEFINED
+    return backend.vec_fn(a, lambda x: bknp.reciprocal(bknp.asarray(x, dtype=float)))
 
 
 def eval_monad_reverse(a):
@@ -341,7 +333,7 @@ def eval_monad_reverse(a):
     return a[::-1]
 
 
-def eval_monad_shape(a):
+def eval_monad_shape(a, backend):
     """
 
         ^a                                                       [Shape]
@@ -393,12 +385,20 @@ def eval_monad_shape(a):
 
     """
 
+    def _normalize_backend_array(x):
+        return backend.to_numpy(x) if backend.is_backend_array(x) else x
+
     def _a(x): # use numpy's natural shape by replacing all strings with arrays
-        return np.asarray([np.empty(len(y)) if isinstance(y,str) else (_a(y) if is_list(y) else y) for y in x])
-    return 0 if is_atom(a) else np.asarray([len(a)]) if isinstance(a,str) else np.asarray(_a(a).shape)
+        x = _normalize_backend_array(x)
+        return bknp.asarray([
+            bknp.empty(len(y)) if isinstance(y, str) else (_a(y) if is_list(y) else _normalize_backend_array(y))
+            for y in x
+        ])
+    a = _normalize_backend_array(a)
+    return 0 if is_atom(a) else bknp.asarray([len(a)]) if isinstance(a, str) else bknp.asarray(_a(a).shape)
 
 
-def eval_monad_size(a):
+def eval_monad_size(a, backend):
     """
 
         #a                                                        [Size]
@@ -417,7 +417,7 @@ def eval_monad_size(a):
                           #0cA  -->  65
 
     """
-    return np.abs(a) if is_number(a) else ord(a) if is_char(a) else len(a)
+    return backend.np.abs(a) if backend.is_number(a) else ord(a) if is_char(a) else len(a)
 
 
 def eval_monad_transpose(a):
@@ -432,10 +432,10 @@ def eval_monad_transpose(a):
                                  +[]  -->  []
 
     """
-    return np.transpose(np.asarray(a))
+    return bknp.transpose(bknp.asarray(a))
 
 
-def eval_monad_undefined(a):
+def eval_monad_undefined(a, backend):
     """
 
         :_a                                                  [Undefined]
@@ -450,20 +450,66 @@ def eval_monad_undefined(a):
                       :_:valid  -->  0
 
     """
-    return kg_truth(a is None or (np.isinf(a) if is_number(a) else False))
+    return kg_truth(a is None or a is KLONG_UNDEFINED)
 
 
-def create_monad_functions(klong):
-    def _get_name(s):
-        s = s.strip()
-        return s[:s.index('a')]
+def eval_monad_track(a):
+    """
+
+        ˙a                                                    [Track]
+
+        Identity operator used when marking values for gradient tracking.
+
+    """
+    return a
+
+
+def eval_monad_grad(klong, a):
+    """
 
-    registry = {}
+        ∇a                                                     [Grad]
 
-    m = sys.modules[__name__]
-    for x in filter(lambda n: n.startswith("eval_monad_"), dir(m)):
-        fn = getattr(m,x)
-        name = _get_name(fn.__doc__)
-        registry[name] = fn
+        Return a function that computes the numeric gradient of ``a``.
 
-    return registry
+    """
+    return KGLambda(lambda x, fn=a, k=klong: grad_of_fn(k, fn, x))
+
+
+def create_monad_functions(klong):
+    backend = klong._backend
+
+    # Simple monads that don't need backend or klong
+    simple = {
+        '@': eval_monad_atom,
+        '&': eval_monad_expand_where,
+        '*': eval_monad_first,
+        '|': eval_monad_reverse,
+        '+': eval_monad_transpose,
+        '˙': eval_monad_track,
+    }
+
+    # Monads needing backend
+    backend_monads = {
+        ',': lambda a: eval_monad_list(a, backend),
+        ':#': lambda a: eval_monad_char(a, backend),
+        '!': lambda a: eval_monad_enumerate(a, backend),
+        '_': lambda a: eval_monad_floor(a, backend),
+        '$': lambda a: eval_monad_format(a, backend),
+        '<': lambda a: eval_monad_grade_up(a, backend),
+        '>': lambda a: eval_monad_grade_down(a, backend),
+        '=': lambda a: eval_monad_groupby(a, backend),
+        '-': lambda a: eval_monad_negate(a, backend),
+        '~': lambda a: eval_monad_not(a, backend),
+        '?': lambda a: eval_monad_range(a, backend),
+        '%': lambda a: eval_monad_reciprocal(a, backend),
+        '#': lambda a: eval_monad_size(a, backend),
+        ':_': lambda a: eval_monad_undefined(a, backend),
+        '^': lambda a: eval_monad_shape(a, backend),
+    }
+
+    # Monads needing klong
+    klong_monads = {
+        '∇': lambda a: eval_monad_grad(klong, a),
+    }
+
+    return {**simple, **backend_monads, **klong_monads}