diff --git a/flake.nix b/flake.nix index 99bfad6..307c390 100644 --- a/flake.nix +++ b/flake.nix @@ -19,6 +19,36 @@ inherit system; overlays = [ moz_overlay.overlay ]; }; + newlisp = pkgs.stdenv.mkDerivation rec { + pname = "newLisp"; + version = "10.7.5"; + + src = pkgs.fetchurl { + url = "http://www.newlisp.org/downloads/newlisp-10.7.5.tgz"; + sha256 = "sha256-3C0P9lHCsnW8SvOvi6WYUab7bh6t3CCudftgsekBJuw="; + }; + + nativeBuildInputs = [ + pkgs.autoPatchelfHook + ]; + + buildInputs = [ + pkgs.stdenv.cc.cc.lib + pkgs.libffi + pkgs.readline + ]; + + installPhase = '' + mkdir -p $out/bin + cp newlisp $out/bin + ''; + + meta = with pkgs.lib; { + homepage = "http://www.newlisp.org/index.cgi"; + description = "A Lisp-like, general-purpose scripting language"; + platforms = platforms.linux; + }; + }; wavm = pkgs.stdenv.mkDerivation rec { pname = "wavm"; version = "0.0.0"; @@ -81,7 +111,9 @@ ocaml jdk swift + picolisp + newlisp ]; }; } diff --git a/koka_bench/CMakeLists.txt b/koka_bench/CMakeLists.txt index 3a9ed34..abd6ae7 100644 --- a/koka_bench/CMakeLists.txt +++ b/koka_bench/CMakeLists.txt @@ -19,3 +19,4 @@ add_subdirectory(swift) add_subdirectory(python) add_subdirectory(scheme) add_subdirectory(picolisp) +add_subdirectory(newlisp) diff --git a/koka_bench/newlisp/CMakeLists.txt b/koka_bench/newlisp/CMakeLists.txt new file mode 100644 index 0000000..01e7fe4 --- /dev/null +++ b/koka_bench/newlisp/CMakeLists.txt @@ -0,0 +1,22 @@ + +set(copy_wrapper "../../copy_wrapper.sh") + +set(sources newlisp-fib.nl newlisp-fib-let.nl) +foreach (source IN LISTS sources) + + get_filename_component(name "${source}" NAME_WE) + + set(out_dir "${CMAKE_CURRENT_BINARY_DIR}/out/bench") + set(out_path "${out_dir}/${name}") + + add_custom_command( + OUTPUT ${out_path} + COMMAND ${copy_wrapper} "${CMAKE_CURRENT_SOURCE_DIR}/${source}" ${out_dir} ${name} + DEPENDS ${source} + VERBATIM) + + add_custom_target(update-${name} ALL DEPENDS "${out_path}") + add_executable(${name}-exe IMPORTED) + set_target_properties(${name}-exe PROPERTIES IMPORTED_LOCATION "${out_path}") +endforeach () + diff --git a/koka_bench/newlisp/newlisp-fib-let.nl b/koka_bench/newlisp/newlisp-fib-let.nl new file mode 100755 index 0000000..b6496ff --- /dev/null +++ b/koka_bench/newlisp/newlisp-fib-let.nl @@ -0,0 +1,17 @@ +#!/usr/bin/env newlisp +;; +;; fibonacci series +;; mostly from http://www.newlisp.org/syntax.cgi?benchmarks/fibo.newlisp.txt +;; modified slightly to match others +;; + +(define (fib n) + (cond ((= 0 n) 1) + ((= 1 n) 1) + (true (let (a (fib (- n 1)) + b (fib (- n 2)) + ) (+ a b))))) + +(println (fib (integer (main-args 2)))) + +(exit) diff --git a/koka_bench/newlisp/newlisp-fib.nl b/koka_bench/newlisp/newlisp-fib.nl new file mode 100755 index 0000000..f6aa549 --- /dev/null +++ b/koka_bench/newlisp/newlisp-fib.nl @@ -0,0 +1,15 @@ +#!/usr/bin/env newlisp +;; +;; fibonacci series +;; mostly from http://www.newlisp.org/syntax.cgi?benchmarks/fibo.newlisp.txt +;; modified slightly to match others +;; + +(define (fib n) + (cond ((= 0 n) 1) + ((= 1 n) 1) + (true (+ (fib (- n 1)) (fib (- n 2)))))) + +(println (fib (integer (main-args 2)))) + +(exit) diff --git a/misc_tests/basic_match.kp b/misc_tests/basic_match.kp new file mode 100644 index 0000000..978d12f --- /dev/null +++ b/misc_tests/basic_match.kp @@ -0,0 +1,175 @@ +((wrap (vau root_env (quote) +((wrap (vau (let1) +(let1 lambda (vau se (p b1) (wrap (eval (array vau p b1) se))) +(let1 current-env (vau de () de) +(let1 cons (lambda (h t) (concat (array h) t)) +(let1 Y (lambda (f3) + ((lambda (x1) (x1 x1)) + (lambda (x2) (f3 (wrap (vau app_env (& y) (lapply (x2 x2) y app_env))))))) +(let1 vY (lambda (f) + ((lambda (x3) (x3 x3)) + (lambda (x4) (f (vau de1 (& y) (vapply (x4 x4) y de1)))))) +(let1 let (vY (lambda (recurse) (vau de2 (vs b) (cond (= (len vs) 0) (eval b de2) + true (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de2))))) + (let ( + lcompose (lambda (g f) (lambda (& args) (lapply g (array (lapply f args))))) + rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) + if (vau de (con than & else) (eval (array cond con than + true (cond (> (len else) 0) (idx else 0) + true false)) de)) + + map (lambda (f5 l5) + (let (helper (rec-lambda recurse (f4 l4 n4 i4) + (cond (= i4 (len l4)) n4 + (<= i4 (- (len l4) 4)) (recurse f4 l4 (concat n4 (array + (f4 (idx l4 (+ i4 0))) + (f4 (idx l4 (+ i4 1))) + (f4 (idx l4 (+ i4 2))) + (f4 (idx l4 (+ i4 3))) + )) (+ i4 4)) + true (recurse f4 l4 (concat n4 (array (f4 (idx l4 i4)))) (+ i4 1))))) + (helper f5 l5 (array) 0))) + + + map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (cond (= i (len l)) n + (<= i (- (len l) 4)) (recurse f l (concat n (array + (f (+ i 0) (idx l (+ i 0))) + (f (+ i 1) (idx l (+ i 1))) + (f (+ i 2) (idx l (+ i 2))) + (f (+ i 3) (idx l (+ i 3))) + )) (+ i 4)) + true (recurse f l (concat n (array (f i (idx l i)))) (+ i 1))))) + (helper f l (array) 0))) + + filter_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (if (f i (idx l i)) (recurse f l (concat n (array (idx l i))) (+ i 1)) + (recurse f l n (+ i 1)))))) + (helper f l (array) 0))) + filter (lambda (f l) (filter_i (lambda (i x) (f x)) l)) + + ; Huge thanks to Oleg Kiselyov for his fantastic website + ; http://okmij.org/ftp/Computation/fixed-point-combinators.html + Y* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (lambda (& x) (lapply (lapply li (p p)) x))) l)))) + vY* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (vau ide (& x) (vapply (lapply li (p p)) x ide))) l)))) + + let-rec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array Y*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + let-vrec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array vY*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + + flat_map (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + flat_map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f i (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + + ; with all this, we make a destrucutring-capable let + let (let ( + destructure_helper (rec-lambda recurse (vs i r) + (cond (= (len vs) i) r + (array? (idx vs i)) (let (bad_sym (str-to-symbol (str (idx vs i))) + new_vs (flat_map_i (lambda (i x) (array x (array idx bad_sym i))) (idx vs i)) + ) + (recurse (concat new_vs (slice vs (+ i 2) -1)) 0 (concat r (array bad_sym (idx vs (+ i 1)))))) + true (recurse vs (+ i 2) (concat r (slice vs i (+ i 2)))) + ))) (vau de (vs b) (vapply let (array (destructure_helper vs 0 (array)) b) de))) + + nil (array) + not (lambda (x) (if x false true)) + or (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) false + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp 'tmp (recurse bs (+ i 1))))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + and (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) true + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp (recurse bs (+ i 1)) 'tmp))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + + + + foldl (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (recurse f (lapply f (cons z (map (lambda (x) (idx x i)) vs))) vs (+ i 1))))) + (lambda (f z & vs) (helper f z vs 0))) + foldr (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (lapply f (cons (recurse f z vs (+ i 1)) (map (lambda (x) (idx x i)) vs)))))) + (lambda (f z & vs) (helper f z vs 0))) + reverse (lambda (x) (foldl (lambda (acc i) (cons i acc)) (array) x)) + zip (lambda (& xs) (lapply foldr (concat (array (lambda (a & ys) (cons ys a)) (array)) xs))) + + match (let ( + evaluate_case (rec-lambda evaluate_case (access c) (cond + (symbol? c) (array true (lambda (b) (array let (array c access) b))) + (and (array? c) (= 2 (len c)) (= 'unquote (idx c 0))) (array (array = access (idx c 1)) (lambda (b) b)) + (and (array? c) (= 2 (len c)) (= 'quote (idx c 0))) (array (array = access c) (lambda (b) b)) + (array? c) (let ( + tests (array and (array array? access) (array = (len c) (array len access))) + (tests body_func) ((rec-lambda recurse (tests body_func i) (if (= i (len c)) + (array tests body_func) + (let ( (inner_test inner_body_func) (evaluate_case (array idx access i) (idx c i)) ) + (recurse (concat tests (array inner_test)) + (lambda (b) (body_func (inner_body_func b))) + (+ i 1))))) + tests (lambda (b) b) 0) + ) (array tests body_func)) + true (array (array = access c) (lambda (b) b)) + )) + helper (rec-lambda helper (x_sym cases i) (cond (< i (- (len cases) 1)) (let ( (test body_func) (evaluate_case x_sym (idx cases i)) ) + (concat (array test (body_func (idx cases (+ i 1)))) (helper x_sym cases (+ i 2)))) + true (array true (array error "none matched")))) + ) (vau de (x & cases) (eval (array let (array '___MATCH_SYM x) (concat (array cond) (helper '___MATCH_SYM cases 0))) de))) + + ll-nil nil + ll-cons array + ll-make (rec-lambda ll-make (n) (if (= 0 n) ll-nil + (ll-cons n (ll-make (- n 1))))) + ll-sum (rec-lambda ll-sum (l) (match l + ,nil 0 + (hh (h t)) (+ h hh (ll-sum t)) + (h t) (+ h (ll-sum t)) + )) + + + monad (array 'write 1 (str "running tree test") (vau (written code) + (array 'args (vau (args code) + ;(array 'exit (log (reduce-test-tree (make-test-tree (read-string (idx args 1)) map-empty)))) + (array 'exit (log (let (l (ll-make (read-string (idx args 1))) + _ (log "swapping to sum") + ) (ll-sum l)))) + )) + )) + + ) monad) +; end of all lets +)))))) +; impl of let1 +)) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de))) +; impl of quote +)) (vau (x5) x5))