test.ape

;; test.ape
;;
;; Copyright (c) 2021-2024 Xiongfei Shi
;;
;; Author: Xiongfei Shi <xiongfei.shi(a)icloud.com>
;; License: Apache-2.0
;;
;; https://github.com/shixiongfei/ape
;;

(print (length '(1 2 3 4 5)))
(print (string-length "Hello, World!"))
(print (vector-length #(1 2 3 4 5)))

(print (list-ref 1 '(1 2 3 4 5)))
(print (string-ref 1 "Hello, World!"))
(print (vector-ref 1 #(1 2 3 4 5)))

(print (reverse '(1 2 3 4 5)))
(print (string-reverse "HelloWorld"))
(print (append '(1 2 3)))
(print (append '(1 2 3) '(4 5 6) '(7 8 9)))
(print (append '(1 2 3) 4))
(print (list->vector '(1 2 3 4 5)))
(print (vector->list #(1 2 3 4 5)))
(print (string->list "HelloWorld"))
(print (string->vector "HelloWorld"))

(print (car '(1 2 3 4 5)))
(print (cdr '(1 2 3 4 5)))

(print (do (cons 1 2)))

(print (+ 1 2 3 4 5))
(print (- 10 4 3 2))
(print (* 2 3 4 5 6))
(print (/ 10 4 3 2))
(print (rem 10 3))

(print (type (/ 10 3)))
(print (type (/ 10 2)))
(print (type (string 1234)))
(print (type (string 'xyz)))
(print (type (number "-12.34")))
(print (type (symbol (string-append "hello" "-" "world"))))

(print "gensym" (gensym))
(print "gensym" (gensym))

(def x 100)
(print "x =" x)

(set! x 150)
(print "x =" x)

(print (> 1 2))
(print (>= 1 2))
(print (> 2 1))
(print (>= 2 2))
(print (< 1 2))
(print (<= 1 2))
(print (< 2 1))
(print (<= 2 2))

(print (and 1 2))
(print (and 1 nil 2))
(print (or nil 2))
(print (or 1 2))
(print (not nil))

(def c (cons 1 2))
(print "c =" c)

(set-car! c 4)
(set-cdr! c 5)
(print "c =" c)


(defn say-hello ((name "Ape"))
  (string-append "Hello " name "!"))

(print (say-hello))
(print (say-hello "World"))


(defn sum (a b)
  (+ a b))

(print "sum 2 3 =" (sum 2 3))


(defn fib (n)
  (if (<= 2 n)
      (+ (fib (- n 1)) (fib (- n 2)))
    n))

(print "fib 28 =" (fib 28))


(defn counter (val step)
  (def count val)
  (fn ()
    (set! count (+ count step))))

(def count (counter 0 1))

(print "Count" (count))
(print "Count" (count))
(print "Count" (count))
(print "Count" (count))
(print "Count" (count))


(def items (list "cat" "dog" "fox"))

(push "owl" items)
(push "cow" items)
(push "wolf" items)

(print (pop items))
(print items)
(print (expand '(push "bird" items)))


(defn accum (n)
  (defn iter (acc step)
    (cond
      (> step n) acc
      (iter (+ acc step) (+ step 1))))
  (iter 0 0))

(print "accum 100 =" (accum 100))


(print (eval '(+ 1 2 3 4 5)))


(when true
  (set! x 200)
  (print "when x =" x))

(unless nil
  (set! x 250)
  (print "unless x =" x))


(set! x 10)

(while (> x 0)
  (print "x =" x)
  (set! x (- x 1)))


(print "global x =" x)

(print "let x + y =" (let (x (set! x (+ x 1))
                           y 8)
                       (+ x y)))

(print "global x =" x)


(for x items
  (print ">" x))

(print items)

(for x (list 1 2 3 4 5)
  (print x))

(for x '(a b c d e)
  (print x))


(def pl '(x 100 y 200 z 300))
(print "pl:" pl)
(print "pl x:" (get pl 'x))
(print "pl y:" (get pl 'y))
(print "pl z:" (get pl 'z))
(print "pl w:" (get pl 'w 400))


(def al (acons 'x 10 (acons 'y 20 (acons 'z 30 nil))))
(print "al:" al)
(print "al x:" (assoc 'x al))
(print "al y:" (assoc 'y al))
(print "al z:" (assoc 'z al))


(print "map 1+ =" (map (fn (x) (+ x 1))
                       '(1 2 3 4 5)))


(print "filter >5 =" (filter (fn (x) (> x 5))
                             '(1 2 3 4 5 6 7 8 9)))


(print "recude + =" (reduce + 0 '(1 2 3 4 5)))

(print "apply + =" (apply + '(1 2 3 4 5)))


(print "nesting unquote =" (let (x 100
                                 y 'x
                                 z 'y)
                             `(,,,z)))

(print "nesting unquote-splicing =" `(,@,@'('(1 2 3)))
                                    `(,@,''(4 5 6)))


(defn y-combinator (f)
  ((fn (u)
     (u u))
   (fn (x)
     (f (fn args
          (apply (x x) args))))))

(def y-fib
  (y-combinator
    (fn (fibonacci)
      (fn (n)
        (if (<= 2 n)
            (+ (fibonacci (- n 1)) (fibonacci (- n 2)))
          n)))))

(print "y-fib 10 =" (y-fib 10))

(def y-factorial
  (y-combinator
    (fn (factorial)
      (fn (n)
        (if (= n 0)
            1
          (* n (factorial (- n 1))))))))

(print "y-factorial 10 =" (y-factorial 10))


(defn heart ()
  (def rows (map (fn (row) (/ row 10))
                 (range 15 -15 -1)))
  (def cols (map (fn (col) (/ col 10))
                 (range -15 15 0.5)))

  (for y rows
    (for x cols
      (let (a (- (+ (* x x) (* y y)) 1.0))
        (if (<= (- (* a a a) (* x x y y y)) 0.0)
            (write "*")
          (write "."))))
    (print)))

(heart)