core.chi

(fn inc n (+ n 1))
(fn dec n (- n 1))
(fn even? n (= (% n 2) 0))
(fn odd? n (! (even? n)))
(fn pos? n (<= 0 n))
(fn neg? n (< n 0))
(fn neg n (- 0i n))
(fn min a b (if (< a b) a b))
(fn abs n (if (pos? n) n (neg n)))

(fn st   i (nth 0 i))
(fn nd   i (nth 1 1))
(fn last i (nth (dec (len i)) i))
(fn prepend v i [i (.. v)])
(fn append  v i [(.. v) i])
(fn join v1 v2 [(.. v1) (.. v2)])
(fn flatten v (reduce join v))
(fn ex-last i (sect i 0 (dec (len i))))
(fn empty? i (= (len i) 0))
(fn !empty? i (!= (len i) 0))

//e. (in? [1 2 3 4 5 6] 3) => T
//e. (in? [1 2 3 4 5] 6) => N
(fn in? v i
  (if (!empty? v)
    (if (= (st v) i)
      T
      (recur (sect v) i))))

//e. [1 2 3 3 3 [0 1] [0 1]] => [1 2 3 [0 1]]
(fn distinct v ;; out
  (if (empty? v)
    out
    (recur (sect v)
      (if (in? out (st v))
        out (append out (st v))))))

(fn every? vec f
  (if (empty? v)
    T
    (if (f (st v))
      (recur (sect v) f))))

(fn some v f
  (if (!empty v)
    (if (f (st v))
      (st v)
      (recur (sect v) f))))

(fn filter f v ;; out
  (if (empty? v)
    out
    (do next= (st v)
      (recur f (sect v)
        (if (f next)
          (append out next)
          out)))))

//Scans for first index of item or char `sub` within vec/str `v`, else nil
//e. (index "hello" \l) => 2
(fn index
  v i ;; x
  (if (empty? v) (return N))
  (if (= i (st v))
    x (recur (sect v) i (+ 1i x))))

//Scans for first index of item `sub` within vector/string `v`, else nil
//e. (str-index "hello" "ll") => 2
(fn str-index
  v sub ;; i
  (if (!empty? v)
    (if (= (str sub) (sect v 0 (len sub)))
      i (recur (sect v) sub (inc (or i 0i))))))

//e. (zip-select [F T F] [\a \b \c]) => \b
(fn zip-select select from
  (if (!empty? select)
    (if (st select)
      (st from)
      (recur (sect select) (sect from)))))

//e. (range 0 10 2) => [0 2 4 6 8]
//e. (range 10 0 -2i) => [10 8 6 4 2]
(fn range from to step ;; v
  (if (= from to)
    v (recur (+ from step) to step
             (append v from))))

//Returns item after `k` in vector/string `v`
(fn key v k
  (if (empty? v) (return N))
  (if (= (st v) k) (return (nd v)))
  (recur (sect v 2) k))

//e. (str->int "123") => 123i
(fn n*10^p-1 n p
  (if (== p 1) n
    (* n (** 10i (- p 1)))))

(fn str->int s
  (reduce +
    (map n*10^p-1
      (map {cast (- # 48) 18} [(.. s)])
      (range (len s) 0 -1i))))

//e. 1 -> "01", 10 -> "10"
(fn zpad n (str (if (< n 10) \0 "") n))

//e. (vec->str [1 2 3 [4 5]]) => "[1 2 3 [2]]"
(fn vec->str v (str "[" (reduce {str # \sp #1} v) "]"))

(fn tree-print i ;; n
  (if (type i [])
    (map {tree-print # (if $1 (+ $1 1) 1)} i)
    (print (loop "" 0 n {str # \.}) i \nl)))

//e. (destruct [1 2 [3 4]] [a= b= [c= d=]]) => [a= 1 b= 2 c= 3 d= 4]
(fn destruct data struct
  (if (type struct [])
    (reduce {vec (.. #) (.. #1)} []
      (map destruct data struct))
    [struct data]))

//e. (-> 2 {+ 65 #} {cast # 0x13}) => \C
(fn -> seed ; //N args
  (do-> seed (sect args)))
(fn do-> acc funcs
  (if (empty? funcs) (return acc))
  (do f= (st funcs)
    (recur (f acc) (sect funcs))))

(fn xorshift32 state
  (do x= state
      x= (^ .x (<< .x 13))
      x= (^ .x (>> .x 17))
      (^ x (<< x 5))))