fez-lisp 1.5.49 → 1.5.51

package/README.md

@@ -1,82 +1,9 @@
-# Fez [Lisp Evaluator in JavaScript](https://medium.com/@antony.k.tonev/lisp-evaluator-in-javascript-b7ee0d817a58)
+# Fez Programming Language
 
 <p align="center">
-<img width="64" src="./logo.svg"/>
+<img width="128" src="./logo.svg"/>
 </p>
 
-```lisp
-; 3 types only
-; Numbers
-; Arrays
-; Functions
-(do 42 (array 1 2 3) (lambda x (* x x)))
-; Variables are immutable
-(let x 42)
-; But array items are not
-(let arr (array 1 2 3))
-(set! arr 0 10)
-(set! arr (length arr) 100)
-; arr is now will make it [10 2 3 100]
-; No strings - instead they are array of charcodes
-"Hello World!" ; This is syntactic suggar turning it into the one below
-(array 72 101 108 108 111 32  87 111 114 108 100  33) ; "Hello World!"
-; multiline strings support (it just captures whole string and adds new lines within the arrays)
-"Hello
-World
-!"
-; No Objects Sets Lists Classes etc. Yet all implemented using the 3 types above
-(let object (new:map
-  (array "id" 16
-  "power" (lambda x (* x x))
-  "backpack" (array 100 100 200 300)
-  "unique-set-of-things"
-  (new:set (array "10" "232" "42" "32")))))
-(apply (map:get object "power") (map:get object "id")) ; 256
-; There are many useful functions in the STD library
-; They get "tree shacked" - final program has only the functions it needs
-(math:permutations (array 1 2 3))
-; Pipe operator is syntactic sugar for readable function composition
-(|> (math:range 1 10) (array:map math:square) (math:summation))
-```
-
-```js
-import { parse, evaluate } from 'fez-lisp'
-evaluate(
-  parse(`(let *input* "1721,979,366,299,675,1456")
-(let solve (lambda arr cb
-     (array:fold arr (lambda a b (do
-        (let res (array:binary-search arr (cb b)))
-        (if (truthy? res) (array:merge a (array res)) a)))
-     ())))
-(|> *input*
-    (string:commas)
-    (array:map (lambda d (|> d (from:chars->digits) (from:digits->integer))))
-    (array:sort (lambda a b (> a b)))
-    (solve (lambda x (- 2020 x)))
-    (math:product)
-    (log))`)
-)
-```
-
-```lisp
-; https://leetcode.com/problems/maximum-count-of-positive-integer-and-negative-integer/description/
-(let max-count-of (lambda nums
-  (math:max
-    (array:count-of nums math:positive?)
-    (array:count-of nums math:negative?))))
-
-(|>
-  (array -2 -1 -1 0 0 1 2)
-  (max-count-of)
-  (log!)) ; 3
-```
-
-Installation:
-
-```
-npm i fez-lisp
-```
-
 ```lisp
 (let fizz-buzz (lambda n
         (cond
@@ -85,23 +12,28 @@ npm i fez-lisp
           (= (mod n 5) 0) "Buzz"
           (*) (from:integer->string n))))
 
-(|> (math:range 1 100) (array:map fizz-buzz) (array:commas) (log "str"))
+(|> (math:range 1 100) (array:map fizz-buzz) (array:spaces) (string))
 ```
 
-```js
-import { parse, compile } from 'fez-lisp'
-console.log(compile(parse("(+ 1 2)")))
-// '(()=>{;return(()=>{return (1+2);})()})()'
-console.log(compile(parse("(math:power 2 4)")))
-// (()=>{;return(()=>{var math_power;return (math_power=((base,exp)=>{return (+(exp<0)?(+(base===0)?[]:(1/(base*math_power(base,((exp*-1)-1))))):(+(exp===0)?1:(+(exp===1)?base:(1?(base*math_power(base,(exp-1))):0))));}),math_power(2,4));})()})()
-console.log(compile(parse("(|> [1 2 3 4] (array:map math:square) (math:summation))")))
-/* (()=>{var __tco=fn=>(...args)=>{let result=fn(...args);while(typeof result==='function')result=result();return result},length=(arr)=>arr.length,alter_effect=function(array,index,value){if(arguments.length===1){array.pop()}else{array[index] = value};return array},get=(arr,i)=>arr[i];
-;return(()=>{var math_summation,math_square,array_map,array_fold;return (math_summation=((xs)=>{return array_fold(xs,((a,b)=>{return (a+b);}),0);}),math_square=((x)=>{return (x*x);}),array_map=((xs,callback)=>{var recursive_array_map,recursive_9271675;return ((recursive_array_map=(__tco(recursive_9271675=(i,out)=>{return (+(length(xs)>i)?()=>recursive_9271675((i+1),alter_effect(out,length(out),callback(get(xs, i)))):out);}, recursive_9271675))),recursive_array_map(0,[]));}),array_fold=((xs,callback,initial)=>{var recursive_array_fold,recursive_927729;return ((recursive_array_fold=(__tco(recursive_927729=(i,out)=>{return (+(length(xs)>i)?()=>recursive_927729((i+1),callback(out,get(xs, i))):out);}, recursive_927729))),recursive_array_fold(0,initial));}),math_summation(array_map([1,2,3,4],math_square)));})()})() * /
-```
+## [Try it in online editor](https://at-290690.github.io/fez/)
 
 ```lisp
-; Build-in all keywords
+; Build-in keywords
 (/ ...) (+ ...) (* ...) (- ...) (= ...) (< ...) (> ...) (>= ...) (<= ...) (& ...) (~ ...) (| ...) (^ ...) (<< ...) (>> ...)
 (mod ...) (let ...) (if ...) (not ...) (and ...) (or ...) (atom? ...) (lambda? ...)
 (length ...) (do ...) (array ...) (set! ...) (pop! ...) (get ...) (lambda ...) (apply ...) (throw ...)
 ```
+
+## ⚠️ Important: Do not use this programming language in production!
+
+Here is how to install the compiler:
+
+```
+npm i fez-lisp
+```
+
+```js
+import { parse, compile } from 'fez-lisp'
+console.log(compile(parse('(+ 1 2)')))
+// '(()=>{;return(()=>{return (1+2);})()})()'
+```

package/favicon.svg

@@ -0,0 +1,5 @@
+<svg width="17" height="16" viewBox="0 0 17 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M12.9624 3.54516C12.5818 1.96655 1.39379 2.36647 0.792468 3.54516C0.191149 4.72386 0.792468 15.7151 0.792468 15.7151L12.9624 15.7151C12.9624 15.7151 13.3431 5.12378 12.9624 3.54516Z" fill="#B44637"/>
+<path d="M12.9624 3.54516C12.5818 1.96655 1.39379 2.36647 0.792468 3.54516C0.191149 4.72386 0.792468 15.7151 0.792468 15.7151L12.9624 15.7151C12.9624 15.7151 13.3431 5.12378 12.9624 3.54516Z" fill="#B44637"/>
+<path d="M14.9574 10.9932C11.603 9.9267 16.5755 1.79352 10 1.97363" stroke="#F9B949" stroke-width="2" stroke-linecap="round"/>
+</svg>