From 5a5115cdbefaa19357248788483f953439f9eca6 Mon Sep 17 00:00:00 2001 From: Fuexfollets Date: Mon, 24 Mar 2025 20:14:51 -0400 Subject: [PATCH] Fixed code --- nl.py | 122 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-- nl2.py | 101 ++++++++++++++++++++++++++++++++++++++++------- 2 files changed, 206 insertions(+), 17 deletions(-) diff --git a/nl.py b/nl.py index da7e64b..0381ff1 100644 --- a/nl.py +++ b/nl.py @@ -1,3 +1,119 @@ -import base64 as b64,re,functools as ft,operator as op,collections as cl,sys,importlib.abc as abc,importlib.machinery as mach -__version__,__doc__,z,ev,run,rf,repl,ps,initl='1.0.1','A pretty small lisp dialect',type('E',(cl.ChainMap,),{'__getitem__':lambda self,s:r if(r:=ft.reduce(lambda x,y:x or y,map(lambda d:d.get(s),self.maps)))else type('S',(str,),{})(s)})({'mk_str':lambda s:b64.b64decode(bytes(s,encoding='utf-8')).decode('utf-8'),'lookup':lambda s:z[s],'if':(mk_special:=lambda fn:[setattr(fn,'special',1),fn][1])(lambda e,c,a,b:ev(a if ev(c, e)else b,e)),'display':print,'define':mk_special(lambda e,a,b:e.__setitem__((a[0]if(c:=type(a)is tuple)else a),((lambda*s:ev(b,e.new_child(dict(zip(a[1:],s)))))if c else b))),'begin':lambda*a:a[-1],'exit':sys.exit,'+': op.add,'-':op.sub,'*':op.mul,'/':op.truediv,'^':pow,'abs':abs,'<':op.le,'>':op.gt,'=':op.eq}),lambda t,z:(fn:=ev(t[0],z))(*((z,*t[1:])if hasattr(fn,'special')else(ev(a,z)for a in t[1:])))if type(t)in[list,tuple]else(z[t]if type(t).__name__=='S'else t),lambda s:ev(eval(ft.reduce(lambda x,y:re.sub(*y,x),ps,f'(begin {s.strip()})'),{},z),z),lambda fl: run(open(fl).read()),lambda s="",f=input:[print(res)if(res:=run(s))else 0,repl()]if(t:=re.sub(r'"(.*?)(? '))).count('(')==t.count(')')else repl(s),[('\n',' '),(' +',' '),(r'"(.*?)(?<=']]+[(f'\\{x}',x)for x in'+*^']],('#t','True'),('#f','False'),(' ',','),(r'\)',',)')],lambda:sys.meta_path.append(type("SchemeFF",(abc.Finder,),{"find_spec":classmethod(lambda _,fl,a=None,b=None:mach.ModuleSpec(fl,(type("SchemeFI",(abc.Loader,),{"create_module":classmethod(lambda _,spec:type('E',(type(z),),{'__getattr__':lambda s,v:s[v]})([rf(spec.name+'.scm'),z][1]),),"exec_module":classmethod(lambda _,a:a)}))()))})) -if __name__=='__main__':(rf(sys.argv[1])if len(sys.argv)>1 else(print(f'Welcome to Nanolisp {__version__}!'),repl())) \ No newline at end of file +import base64 as b64 +import collections as cl +import functools as ft +import importlib.abc as abc +import importlib.machinery as mach +import operator as op +import re +import sys + +__version__, __doc__, z, ev, run, rf, repl, ps, initl = ( + "1.0.1", + "A pretty small lisp dialect", + type( + "E", + (cl.ChainMap,), + { + "__getitem__": lambda self, s: r + if (r := ft.reduce(lambda x, y: x or y, map(lambda d: d.get(s), self.maps))) + else type("S", (str,), {})(s) + }, + )( + { + "mk_str": lambda s: b64.b64decode(bytes(s, encoding="utf-8")).decode( + "utf-8" + ), + "lookup": lambda s: z[s], + "if": (mk_special := lambda fn: [setattr(fn, "special", 1), fn][1])( + lambda e, c, a, b: ev(a if ev(c, e) else b, e) + ), + "display": print, + "define": mk_special( + lambda e, a, b: e.__setitem__( + (a[0] if (c := type(a) is tuple) else a), + ((lambda *s: ev(b, e.new_child(dict(zip(a[1:], s))))) if c else b), + ) + ), + "begin": lambda *a: a[-1], + "exit": sys.exit, + "+": op.add, + "-": op.sub, + "*": op.mul, + "/": op.truediv, + "^": pow, + "abs": abs, + "<": op.le, + ">": op.gt, + "=": op.eq, + } + ), + lambda t, z: (fn := ev(t[0], z))( + *((z, *t[1:]) if hasattr(fn, "special") else (ev(a, z) for a in t[1:])) + ) + if type(t) in [list, tuple] + else (z[t] if type(t).__name__ == "S" else t), + lambda s: ev( + eval(ft.reduce(lambda x, y: re.sub(*y, x), ps, f"(begin {s.strip()})"), {}, z), + z, + ), + lambda fl: run(open(fl).read()), + lambda s="", f=input: [print(res) if (res := run(s)) else 0, repl()] + if ( + t := re.sub(r'"(.*?)(? ")) + ).count("(") + == t.count(")") + else repl(s), + [ + ("\n", " "), + (" +", " "), + ( + r'"(.*?)(?<="]] + + [(f"\\{x}", x) for x in "+*^"] + ], + ("#t", "True"), + ("#f", "False"), + (" ", ","), + (r"\)", ",)"), + ], + lambda: sys.meta_path.append( + type( + "SchemeFF", + (abc.Finder,), + { + "find_spec": classmethod( + lambda _, fl, a=None, b=None: mach.ModuleSpec( + fl, + ( + type( + "SchemeFI", + (abc.Loader,), + { + "create_module": classmethod( + lambda _, spec: type( + "E", + (type(z),), + {"__getattr__": lambda s, v: s[v]}, + )([rf(spec.name + ".scm"), z][1]), + ), + "exec_module": classmethod(lambda _, a: a), + }, + ) + )(), + ) + ) + }, + ) + ), +) +if __name__ == "__main__": + ( + rf(sys.argv[1]) + if len(sys.argv) > 1 + else (print(f"Welcome to Nanolisp {__version__}!"), repl()) + ) + diff --git a/nl2.py b/nl2.py index 090dfa4..0ef9b58 100644 --- a/nl2.py +++ b/nl2.py @@ -1,14 +1,87 @@ -(lambda f,o,r: [print(o(next(filter(lambda s: s.count('(') == s.count(')'), f.accumulate(map( -input, f.chain(['> '], f.repeat(' '))), lambda x,y: f'{x}\n{y}'))))) for _ in f.repeat(0)])( -__import__('itertools'), (lambda a,l,c,h,e,m,y:(lambda u: lambda s: a(eval(e.reduce(lambda s, -x: c.sub(*x, s),[('"(.*?)"', lambda r: 'σ'+h.b16encode(bytes(r.group(1),'utf-8')).decode()),( -f"({'|'.join(m.kwlist)}) " ,r'"ƒ\1",'), ("`(.*)`",r'"ƒ\1"'),('\s+',','),('\)',',)')],s),type( -'x',(dict,),{'__getitem__':lambda _,k:h.b16decode(bytes(k[1:],'u8')).decode()if k[0]=='σ'else -'ƒ' +k})()),u))(l.ChainMap({'ƒdefine': (ms:=lambda f: [setattr(f,'a',1), f][1])(lambda e,k,v: -e.__setitem__(k,run(v,e))),'ƒlambda':ms(lambda e,a,c:lambda*b:run(c,e.new_child(dict(zip(a,b) -)))),'ƒif':ms(lambda e,p,a,b:run(a if run(p, e)else b,e)),'ƒ<':y.lt,'ƒ+':lambda*x:sum(x),'ƒ-' -:lambda*x:x[0]-sum(x[1:]),'ƒ*':lambda*x:e.reduce(y.mul,x),'ƒ/':lambda*x:e.reduce(y.truediv,x) -,'ƒmacro':ms,'ƒcar':lambda x:x[0],'ƒcdr':lambda x:x[1:],'ƒdisplay':print,'ƒexit':exit})))(run -:=lambda s,e:(lambda f:f(*(e,)+s[1:]if hasattr(f, 'a')else map(lambda t:run(t,e),s[1:])))(run -(s[0],e))if type(s) == tuple else(e[s]if type(s) == str and s[0]=='ƒ'else s),*map(__import__, -'collections re base64 functools keyword operator'.split())),0) # => Perfection, consolidated +( + lambda f, o, r: [ + print( + o( + next( + filter( + lambda s: s.count("(") == s.count(")"), + f.accumulate( + map(input, f.chain(["> "], f.repeat(" "))), + lambda x, y: f"{x}\n{y}", + ), + ) + ) + ) + ) + for _ in f.repeat(0) + ] +)( + __import__("itertools"), + ( + lambda a, l, c, h, e, m, y: ( + lambda u: lambda s: a( + eval( + e.reduce( + lambda s, x: c.sub(*x, s), + [ + ( + '"(.*?)"', + lambda r: "σ" + + h.b16encode(bytes(r.group(1), "utf-8")).decode(), + ), + (f"({'|'.join(m.kwlist)}) ", r'"ƒ\1",'), + ("`(.*)`", r'"ƒ\1"'), + ("\s+", ","), + ("\)", ",)"), + ], + s, + ), + type( + "x", + (dict,), + { + "__getitem__": lambda _, k: h.b16decode( + bytes(k[1:], "u8") + ).decode() + if k[0] == "σ" + else "ƒ" + k + }, + )(), + ), + u, + ) + )( + l.ChainMap( + { + "ƒdefine": (ms := lambda f: [setattr(f, "a", 1), f][1])( + lambda e, k, v: e.__setitem__(k, run(v, e)) + ), + "ƒlambda": ms( + lambda e, a, c: lambda *b: run(c, e.new_child(dict(zip(a, b)))) + ), + "ƒif": ms(lambda e, p, a, b: run(a if run(p, e) else b, e)), + "ƒ<": y.lt, + "ƒ+": lambda *x: sum(x), + "ƒ-": lambda *x: x[0] - sum(x[1:]), + "ƒ*": lambda *x: e.reduce(y.mul, x), + "ƒ/": lambda *x: e.reduce(y.truediv, x), + "ƒmacro": ms, + "ƒcar": lambda x: x[0], + "ƒcdr": lambda x: x[1:], + "ƒdisplay": print, + "ƒexit": exit, + } + ) + ) + )( + run := lambda s, e: ( + lambda f: f( + *(e,) + s[1:] if hasattr(f, "a") else map(lambda t: run(t, e), s[1:]) + ) + )(run(s[0], e)) + if type(s) == tuple + else (e[s] if type(s) == str and s[0] == "ƒ" else s), + *map(__import__, "collections re base64 functools keyword operator".split()), + ), + 0, +) # => Perfection, consolidated