reworking towards full proper reference counting implementation

[klapaucius] / demos.kl

(def comment (rest (K nil)))

(def CC (B (C B (C B cdr)) (B (Phi cons) (C B car))))

(def D (B B)) (comment Dabcd -> ab(cd))
(def T (C I)) (comment Tab -> ba)
(def V (B C T)) (comment Vabc -> cab)
(def O (S I)) (comment Oab -> b(ab))
(def M (S I I)) (comment Ma -> aa)
(def Q (C B)) (comment Qabc -> b(ac))
(def L (C B M)) (comment Lab -> a(bb))
(def G (B B C)) (comment Gabcd -> ad(bc))
(def E (B (B B B))) (comment Eabcde -> ab(cde))
(def R (B B T)) (comment Rabc -> bca)
(def H (B W (B C))) (comment Habc -> abcb)
(def U (L O)) (comment Uab -> b(aab))
(def F (E T T E T)) (comment Fabc -> cba)

(def B1 (B B B)) (comment B1abcd -> a(bcd))
(def B2 (B B1 B)) (comment B2abcde -> a(bcde))
(def B3 (B (B B) B)) (comment B3abcd -> a(b(cd)))

(def C* (B C))
(def C** (B C*))
(def C*** (B C**))

(def C*n (Z (B (S (C (eq 0) C)) (B D (C B (C - 1))))))

(def C1 (C* (B C)))
(def C2 (C* (B C1)))
(def C3 (C* (B C2)))

(def Cn (Z (B (S (C (eq 0) C)) (B (B (B C)) (B D (C B (C - 1)))))))

(def import (B (B B) B (map unquote) parse readfile))
(comment apparently it is that easy)


(def abstract-generator (Z (B (B (B (B (C (C C nil))))) (B (Phi B (B S (B cons))) (B (B W) (B (B B)))))))

(def abstract-rec (B (B (B (C B cons))) (B (B (B B)) (B (B (B Z)) (C (B B (B B (B B (B S (C (C Phi cdr) car))))) (B (B (C B)) (B (C B (C B cdr)) (B (Phi cons) (C (C Phi car) cdr)))))))))


(def zd-identity I)
(def zd-constant K)
(def zd-compose B)
(def zd-flip C)
(def zd-duplicate W)
(def zd-left t)
(def zd-right nil)
(def zd-recombine Phi)
(def zd-under Psi)
(def zd-conditional (B (B S) S))

(def if I)

(def church-and (B W (B C) I))
(def church-or (S I I))
(def church-not (B C (C I) nil t))
(def church-xor (C (C Phi not) I))
(def church-zerop (B C (C I) (t nil) t))

(def fac (Z (D S (C (eq 0) 1) (D S * (C B (C - 1))))))

(def range (abstract-rec (eq 0) (C cons) (C - 1) nil))
(comment def range (S (C (eq 0) nil) (B (Z (B B S (S (B (eq 0) car) cdr) (C B (Phi cons (B (C - 1) car) (Phi cons car cdr))))) (C cons nil))))

(def reverse (abstract-rec not (C (B cons car)) cdr nil))
(comment def reverse (B (Z (B (S (S (B (eq nil) cdr) car)) (C B (Phi cons (Phi cons (B car cdr) car) (B cdr cdr))))) (cons nil)))

(def nth (B (B car) (B (C I cdr) (C - 1))))

(def list (rest (map unquote)))

(def len (abstract-rec not (B K (+ 1)) cdr 0))
(comment def len (B (Z (B (S (S (B (eq nil) cdr) car)) (C B (CC (+ 1) cdr)))) (cons 0)))

(def map (B (B reverse) (B (B (Z (B (S (S (B (eq nil) (2 cdr)) (B car cdr))) (C B (S (B cons car) (Phi cons (Phi cons (S car (B (B car cdr) cdr)) (B car cdr)) (3 cdr))))))) (C (B B cons) (cons nil)))))

(def fold (B (S (C (C (eq nil) nil) (Z (B (S (S (B (eq nil) (B cdr cdr)) (B car cdr))) (C B (S (B cons car) (Phi cons (S (S car (B car cdr)) (B car (2 cdr))) (3 cdr)))))))) cons))


(def compose-all (rest (B (fold (B (C B unquote) B)) (cons I))))

(def fibonacci-generator (Z (B (B (C (C C nil))) (B (Phi cons (Phi + car cdr)) (C B (Phi cons (Phi + car cdr) car))))))

(comment def tr-fac (B (S (Phi (eq 0) cdr car)) (C B (Phi cons (Phi * car cdr) (B (C - 1) cdr)))))

(def append (B (C (abstract-rec not (B (C B car) (C cons)) cdr)) reverse))

(def filter (C (C (B (abstract-rec not) (B W (B (B C) (C (B C (B (B B) (C (B B S) (C cons)))) car)))) cdr) nil))

(def qsort ((B Z (B (B (S (W atom))) (Phi (Phi (Phi append)) (B (C B) (C (B (Phi filter) (B (B (B not)) (C B car))) cdr)) (B (B (Phi cons car)) (B (C B) (C (B (Phi filter) (C B car)) cdr))))))))

(def x-times-n (C (C (D abstract-rec (eq 0) (D B K cons)) (C - 1)) nil))
(comment (x-times-n x 5) -> (x x x x x))

(def m-rand-n (B (C (C (D abstract-rec (eq 0) (D B K cons)) (C - 1)) nil) rand))