(__ns__ pixie.stdlib)

(def libc (ffi-library pixie.platform/lib-c-name))

(def exit (ffi-fn libc "exit" [Integer] Integer))

(def puts (ffi-fn libc "puts" [String] Integer))

(def sh (ffi-fn libc "system" [String] Integer))

(def printf (ffi-fn libc "printf" [String] Integer))

(def getenv (ffi-fn libc "getenv" [String] String))

(def libreadline (ffi-library (str "libreadline." pixie.platform/so-ext)))

(def readline (ffi-fn libreadline "readline" [String] String))

(def rand (ffi-fn libc "rand" [Integer] Integer))

(def srand (ffi-fn libc "srand" [Integer] Integer))

(def fopen (ffi-fn libc "fopen" [String String] VoidP))

(def fread (ffi-fn libc "fread" [Buffer Integer Integer VoidP] Integer))

(def libm (ffi-library (str "libm." pixie.platform/so-ext)))

(def atan2 (ffi-fn libm "atan2" [Float Float] Float))

(def floor (ffi-fn libm "floor" [Float] Float))

(def lround (ffi-fn libm "lround" [Float] Integer))

(def reset! -reset!)

(def program-arguments [])

(def fn (fn* [& args]

(cons 'fn* args)))

(set-macro! fn)

(def let (fn* [& args]

(cons 'let* args)))

(set-macro! let)

(def identity

(fn ^{:doc "The identity function. Returns its argument."

:added "0.1"}

identity

[x]

x))

(def conj

(fn ^{:doc "Adds elements to the collection. Elements are added to the end except in the case of Cons lists"

:signatures [[] [coll] [coll item] [coll item & args]]

:added "0.1"}

conj

([] [])

([coll] coll)

([coll item] (-conj coll item))

([coll item & args]

(reduce -conj (-conj coll item) args))))

(def conj!

(fn ^{:doc "Adds elements to the transient collection. Elements are added to the end except in the case of Cons lists"

:signatures [[] [coll] [coll item] [coll item & args]]

:added "0.1"}

conj!

([] (-transient []))

([coll] (-persistent! coll))

([coll item] (-conj! coll item))

([coll item & args]

(reduce -conj! (-conj! coll item) args))))

(def disj (fn ^{:doc "Removes elements from the collection."

:signatures [[] [coll] [coll item]]

:added "0.1"}

disj

([] [])

([coll] coll)

([coll item] (-disj coll item))

([coll item & items]

(reduce -disj (-disj coll item) items))))

(comment (def disj! (fn ^{:doc "Removes elements from the transient collection."

:signatures [[] [coll] [coll item] [coll item & items]]

:added "0.1"}

disj!

([] (-transient []))

([result] (-persistent! result))

([result item] (-disj! result item))

([coll item & items]

(reduce -disj! (-disj! coll item) items)))))

(def transient (fn [coll] (-transient coll)))

(def persistent! (fn [coll] (-persistent! coll)))

(def transduce (fn transduce

([f coll]

(let [result (-reduce coll f (f))]

(f result)))

([xform rf coll]

(let [f (xform rf)

result (-reduce coll f (f))]

(f result)))

([xform rf init coll]

(let [f (xform rf)

result (-reduce coll f init)]

(f result)))))

(def map (fn ^{:doc "map - creates a transducer that applies f to every input element"

:signatures [[f] [f coll]]

:added "0.1"}

map

([f]

(fn [xf]

(fn

([] (xf))

([result] (xf result))

([result item] (xf result (f item))))))

([f coll]

(let [i (iterator coll)]

(loop []

(if (at-end? i)

nil

(do (yield (f (current i)))

(move-next! i)

(recur))))))))

(def reduce (fn [rf init col]

(-reduce col rf init)))

(def into (fn ^{:doc "Add the elements of `from` to the collection `to`."

:signatures [[to from]]

:added "0.1"}

into

[to from]

(if (satisfies? IToTransient to)

(persistent! (reduce conj! (transient to) from))

(reduce conj to from))))

(def interpose

(fn ^{:doc "Returns a transducer that inserts `val` in between elements of a collection."

:signatures [[val] [val coll]]

:added "0.1"}

interpose

([val] (fn [xf]

(let [first? (atom true)]

(fn

([] (xf))

([result] (xf result))

([result item] (if @first?

(do (reset! first? false)

(xf result item))

(xf (xf result val) item)))))))

([val coll]

(transduce (interpose val) conj coll))))

(def preserving-reduced

(fn [rf]

(fn [a b]

(let [ret (rf a b)]

(if (reduced? ret)

(reduced ret)

ret)))))

(def cat

(fn ^{:doc "A transducer that concatenates elements of a collection."

:added "0.1"}

cat

[rf]

(let [rrf (preserving-reduced rf)]

(fn cat-inner

([] (rf))

([result] (rf result))

([result input]

(reduce rrf result input))))))

(def mapcat

(fn ^{:doc "Maps f over the elements of coll and concatenates the result"

:added "0.1"}

mapcat

([f]

(comp (map f) cat))

([f coll]

(transduce (mapcat f) conj coll))))

(def seq-reduce (fn seq-reduce

[coll f init]

(loop [init init

coll (seq coll)]

(if (reduced? init)

@init

(if (seq coll)

(recur (f init (first coll))

(seq (next coll)))

init)))))

(def indexed-reduce (fn indexed-reduce

[coll f init]

(let [max (count coll)]

(loop [init init

i 0]

(if (reduced? init)

@init

(if (-eq i max)

init

(recur (f init (nth coll i)) (+ i 1))))))))

(def rest (fn ^{:doc "Returns the elements after the first element, or () if there are no more elements."

:signatures [[coll]]

:added "0.1"}

[coll]

(let [next (next coll)]

(if next next '()))))

;; Make all Function types extend IFn

(extend -invoke Code -invoke)

(extend -invoke NativeFn -invoke)

(extend -invoke VariadicCode -invoke)

(extend -invoke Closure -invoke)

(extend -invoke Var -invoke)

(extend -invoke PolymorphicFn -invoke)

(extend -invoke DoublePolymorphicFn -invoke)

(extend -reduce Cons seq-reduce)

(extend -reduce PersistentList seq-reduce)

(extend -reduce LazySeq seq-reduce)

(comment (extend -reduce Array indexed-reduce))

(extend -reduce Buffer indexed-reduce)

(extend -str Bool

(fn [x]

(if (identical? x true)

"true"

"false")))

(extend -repr Bool -str)

(extend -str Nil (fn [x] "nil"))

(extend -repr Nil -str)

(extend -reduce Nil (fn [self f init] init))

(extend -hash Nil (fn [self] 100000))

(extend -with-meta Nil (fn [self _] nil))

(extend -at-end? Nil (fn [_] true))

(extend -deref Nil (fn [_] nil))

(extend -hash Integer hash-int)

(extend -eq Integer -num-eq)

(extend -eq Float -num-eq)

(extend -eq Ratio -num-eq)

(def ordered-hash-reducing-fn

(fn ordered-hash-reducing-fn

([] (new-hash-state))

([state] (finish-hash-state state))

([state itm] (update-hash-ordered! state itm))))

(def unordered-hash-reducing-fn

(fn unordered-hash-reducing-fn

([] (new-hash-state))

([state] (finish-hash-state state))

([state itm] (update-hash-unordered! state itm))))

(extend -str PersistentVector

(fn [v]

(apply str "[" (conj (transduce (interpose " ") conj v) "]"))))

(extend -repr PersistentVector

(fn [v]

(apply str "[" (conj (transduce (comp (map -repr) (interpose " ")) conj v) "]"))))

(extend -str Cons

(fn [v]

(apply str "(" (conj (transduce (interpose " ") conj v) ")"))))

(extend -repr Cons

(fn [v]

(apply str "(" (conj (transduce (comp (map -repr) (interpose " ")) conj v) ")"))))

(extend -hash Cons

(fn [v]

(transduce ordered-hash-reducing-fn v)))

(extend -str PersistentList

(fn [v]

(apply str "(" (conj (transduce (interpose " ") conj v) ")"))))

(extend -repr PersistentList

(fn [v]

(apply str "(" (conj (transduce (comp (map -repr) (interpose " ")) conj v) ")"))))

(extend -str LazySeq

(fn [v]

(apply str "(" (conj (transduce (interpose " ") conj v) ")"))))

(extend -repr LazySeq

(fn [v]

(apply str "(" (conj (transduce (comp (map -repr) (interpose " ")) conj v) ")"))))

(extend -hash PersistentVector

(fn [v]

(transduce ordered-hash-reducing-fn v)))

(extend -hash PersistentHashSet

(fn [v]

(transduce ordered-hash-reducing-fn v)))

(extend -hash PersistentHashMap

(fn [v]

(transduce ordered-hash-reducing-fn v)))

(extend -hash EmptyList (fn [v] 5555555))

(extend -hash Bool

(fn [v]

(if v

1111111

3333333)))

(def stacklet->lazy-seq

(fn [k]

(if (-at-end? k)

nil

(cons (-current k)

(lazy-seq* (fn [] (stacklet->lazy-seq (-move-next! k))))))))

(def = -eq)

(extend -seq PersistentVector

(fn vector-seq

([self]

(vector-seq self 0))

([self x]

(if (= x (count self))

nil

(cons (nth self x) (lazy-seq* (fn [] (vector-seq self (+ x 1)))))))))

(def concat

(fn ^{:doc "Concatenates its arguments."

:signatures [[& args]]

:added "0.1"}

concat

[& args] (transduce cat conj args)))

(def key (fn [x] (-key x)))

(def val (fn [x] (-val x)))

(def defn (fn ^{:doc "Defines a new function."

:signatures [[nm doc? meta? & body]]}

defn

[nm & rest]

(let [meta (if (meta nm) (meta nm) {})

meta (if (instance? String (first rest))

(assoc meta :doc (first rest))

meta)

rest (if (instance? String (first rest)) (next rest) rest)

meta (if (satisfies? IMap (first rest))

(merge meta (first rest))

meta)

rest (if (satisfies? IMap (first rest)) (next rest) rest)

meta (if (-contains-key meta :signatures)

meta

(merge meta {:signatures

(if (satisfies? IVector (first rest))

[(first rest)]

(transduce (map first) conj rest))}))

nm (with-meta nm meta)]

`(def ~nm (fn ~nm ~@rest)))))

(set-macro! defn)

(defn defmacro

{:doc "Defines a new macro."

:added "0.1"}

[nm & rest]

`(do (defn ~nm ~@rest)

(set-macro! ~nm)

~nm))

(set-macro! defmacro)

(defmacro defn-

{:doc "Define a new non-public function. Otherwise the same as defn"

:signatures [[nm doc? meta? & body]]

:added "0.1"}

[nm & rest]

(let [nm (with-meta nm (assoc (meta nm) :private true))]

(cons `defn (cons nm rest))))

(defmacro ->

{:doc "Threads `x` through `forms`, passing the result of one step as the first argument of the next."

:examples [["(-> 3 inc inc)" nil 5]

["(-> \"James\" (str \" is \" \"awesome \") (str \"(and stuff)\" \"!\"))" nil "James is awesome (and stuff)!"]]

:signatures [[x & forms]]

:added "0.1"}

[x & forms]

(loop [x x, forms forms]

(if forms

(let [form (first forms)

threaded (if (seq? form)

(with-meta `(~(first form) ~x ~@(next form)) (meta form))

(list form x))]

(recur threaded (next forms)))

x)))

(defmacro ->>

{:doc "Threads `x` through `forms`, passing the result of one step as the last argument of the next."

:examples [["(->> \"James\" (str \"we \" \"like \") (str \"you \" \"know \" \"what? \"))" nil "you know what? we like James"]

["(->> 5 (range) (map inc) seq)" nil (1 2 3 4 5)]]

:signatures [[x & forms]]

:added "0.1"}

[x & forms]

(loop [x x, forms forms]

(if forms

(let [form (first forms)

threaded (if (seq? form)

(with-meta `(~(first form) ~@(next form) ~x) (meta form))

(list form x))]

(recur threaded (next forms)))

x)))

(defn not

{:doc "Inverts the input, if a truthy value is supplied, returns false, otherwise

returns true"

:signatures [[x]]

:added "0.1"}

[x]

(if x false true))

(defn +

{:doc "Adds the arguments, returning 0 if no arguments"

:signatures [[& args]]

:added "0.1"}

([] 0)

([x] x)

([x y] (-add x y))

([x y & args]

(reduce -add (-add x y) args)))

(defn -

([] 0)

([x] (-sub 0 x))

([x y] (-sub x y))

([x y & args]

(reduce -sub (-sub x y) args)))

(defn *

([] 1)

([x] x)

([x y] (-mul x y))

([x y & args]

(reduce -mul (-mul x y) args)))

(defn /

([x] (-div 1 x))

([x y] (-div x y))

([x y & args]

(reduce -div (-div x y) args)))

(defn quot [num div]

(-quot num div))

(defn rem [num div]

(-rem num div))

(defn =

{:doc "Returns true if all the arguments are equivalent. Otherwise, returns false. Uses

-eq to perform equality checks."

:signatures [[& args]]

:added "0.1"}

([x] true)

([x y] (eq x y))

([x y & rest] (if (eq x y)

(apply = y rest)

false)))

(defn not=

{:doc "Returns true if one (or more) of the arguments are not equivalent to the others. Uses

-eq to perform equality checks."

:signatures [[& args]]

:added "0.1"}

([x] false)

([x y] (not (eq x y)))

([x y & rest] (not (apply = x y rest))))

(defn <

([x] true)

([x y] (-lt x y))

([x y & rest] (if (-lt x y)

(apply < y rest)

false)))

(defn >

([x] true)

([x y] (-gt x y))

([x y & rest] (if (-gt x y)

(apply > y rest)

false)))

(defn <=

([x] true)

([x y] (-lte x y))

([x y & rest] (if (-lte x y)

(apply <= y rest)

false)))

(defn >=

([x] true)

([x y] (-gte x y))

([x y & rest] (if (-gte x y)

(apply >= y rest)

false)))

(defn pos?

{:doc "Returns true if x is greater than zero"

:signatures [[x]]

:added "0.1"}

[x]

(> x 0))

(defn neg?

{:doc "Returns true if x is less than zero"

:signatures [[x]]

:added "0.1"}

[x]

(< x 0))

(defn zero?

{:doc "Returns true if x is equal to zero"

:signatures [[x]]

:added "0.1"}

[x]

(= x 0))

(defn inc

{:doc "Increments x by one"

:signatures [[x]]

:added "0.1"}

[x]

(+ x 1))

(defn dec

{:doc "Decrements x by one"

:signatures [[x]]

:added "0.1"}

[x]

(- x 1))

(defn empty?

{:doc "returns true if the collection has no items, otherwise false"

:signatures [[coll]]

:added "0.1"}

[coll]

(not (seq coll)))

(defn not-empty?

{:doc "returns true if the collection has items, otherwise false"

:signatures [[coll]]

:added "0.1"}

[coll]

(if (seq coll) true false))

(defn even?

{:doc "Returns true if n is even"

:signatures [[n]]

:added "0.1"}

[n]

(zero? (rem n 2)))

(defn odd?

{:doc "Returns true of n is odd"

:signatures [[n]]

:added "0.1"}

[n]

(= (rem n 2) 1))

(defn first

{:doc "Returns the first item in coll, if coll implements IIndexed nth will be used to retreive

the item from the collection."

:signatures [[coll]]

:added "0.1"}

[coll]

(if (satisfies? IIndexed coll)

(nth coll 0)

(-first coll)))

(defn second

{:doc "Returns the second item in coll, if coll implements IIndexed nth will be used to retreive

the item from the collection."

:signatures [[coll]]

:added "0.1"}

[coll]

(if (satisfies? IIndexed coll)

(nth coll 1)

(first (next coll))))

(defn third

{:doc "Returns the third item in coll, if coll implements IIndexed nth will be used to retreive

the item from the collection."

:signatures [[coll]]

:added "0.1"}

[coll]

(if (satisfies? IIndexed coll)

(nth coll 2)

(first (next (next coll)))))

(defn fourth

{:doc "Returns the fourth item in coll, if coll implements IIndexed nth will be used to retreive

the item from the collection."

:signatures [[coll]]

:added "0.1"}

[coll]

(if (satisfies? IIndexed coll)

(nth coll 3)

(first (next (next (next coll))))))

(defn assoc

{:doc "Associates the key with the value in the collection"

:signatures [[m] [m k v] [m k v & kvs]]

:added "0.1"}

([m] m)

([m k v]

(-assoc m k v))

([m k v & rest]

(apply assoc (-assoc m k v) rest)))

(defn dissoc

{:doc "Removes the value associated with the keys from the collection"

:signatures [[m] [m & ks]]

:addded "0.1"}

([m] m)

([m & ks]

(reduce -dissoc m ks)))

(defn contains?

{:doc "Checks if there is a value associated with key in the collection.

Does *not* check for the presence of a value in the collection, only whether

there's a value associated with the key. Use `some` for checking for values."

:examples [["(contains? {:a 1} :a)" nil true]

["(contains? {:a 1} :b)" nil false]

["(contains? #{:a :b :c} :a)" nil true]

["(contains? [:a :b :c] 0)" nil true]

["(contains? [:a :b :c] 4)" nil false]

["(contains? [:a :b :c] :a)" nil false]]

:signatures [[coll key]]

:added "0.1"}

[coll key]

(-contains-key coll key))

(defn vec

{:doc "Converts a reducable collection into a vector using the (optional) transducer."

:signatures [[coll] [xform coll]]

:added "0.1"}

([coll]

(transduce conj! coll))

([xform coll]

(transduce xform conj! coll)))

(defn get-val [inst]

(get-field inst :val))

(defn comp

{:doc "Composes the given functions, applying the last function first."

:examples [["((comp inc first) [41 2 3])" nil 42]]

:signatures [[f] [f & fs]]

:added "0.1"}

([f] f)

([f1 f2]

(fn [& args]

(f1 (apply f2 args))))

([f1 f2 f3]

(fn [& args]

(f1 (f2 (apply f3 args)))))

([f1 f2 f3 & fs]

(fn [& args]

(apply (transduce comp (apply list f1 f2 f3 fs)) args))))

(defmacro cond

{:doc "Checks if any of the tests is truthy, if so, stops and returns the value of the corresponding body"

:signatures [[] [test then & clauses]]

:added "0.1"}

([] nil)

([test then & clauses]

`(if ~test

~then

(cond ~@clauses))))

(defmacro try [& body]

(loop [catch nil

catch-sym nil

body-items []

finally nil

body (seq body)]

(let [form (first body)]

(if form

(if (not (seq? form))

(recur catch catch-sym (conj body-items form) finally (next body))

(let [head (first form)]

(cond

(= head 'catch) (if catch

(throw "Can only have one catch clause per try")

(recur (next (next form)) (first (next form)) body-items finally (next body)))

(= head 'finally) (if finally

(throw "Can only have one finally clause per try")

(recur catch catch-sym body-items (next form) (next body)))

:else (recur catch catch-sym (conj body-items form) finally (next body)))))

`(-try-catch

(fn [] ~@body-items)

~(if catch

`(fn [~catch-sym] ~@catch)

`(fn [] nil))

(fn [] ~@finally))))))

(defn .

{:doc "Access the field named by the symbol.

If further arguments are passed, invokes the method named by symbol, passing the object and arguments."

:signatures [[obj sym] [obj sym & args]]

:added "0.1"}

([obj sym]

(get-field obj sym))

([obj sym & args]

(apply (get-field obj sym) obj args)))

(defn true? [v] (identical? v true))

(defn false? [v] (identical? v false))

(defn number? [v] (instance? Number v))

(defn integer? [v] (instance? Integer v))

(defn float? [v] (instance? Float v))

(defn ratio? [v] (instance? Ratio v))

(defn string? [v] (instance? String v))

(defn keyword? [v] (instance? Keyword v))

(defn list? [v] (instance? PersistentList v))

(defn map? [v] (satisfies? IMap v))

(defn fn? [v] (satisfies? IFn v))

(defn indexed? [v] (satisfies? IIndexed v))

(defn counted? [v] (satisfies? ICounted v))

(defn float

{:doc "Converts a number to a float."

:since "0.1"}

[x]

(cond

(number? x) (+ x 0.0)

:else (throw (str "Can't convert a value of type " (type x) " to a Float"))))

(defn int

{:doc "Converts a number to an integer."

:since "0.1"}

[x]

(cond

(integer? x) x

(float? x) (lround (floor x))

(ratio? x) (int (/ (float (numerator x)) (float (denominator x))))

:else (throw (str "Can't convert a value of type " (type x) " to an Integer"))))

(defn last

{:doc "Returns the last element of the collection, or nil if none."

:signatures [[coll]]

:added "0.1"}

[coll]

(if (next coll)

(recur (next coll))

(first coll)))

(defn butlast

{:doc "Returns all elements but the last from the collection."

:signatures [[coll]]

:added "0.1"}

[coll]

(loop [res []

coll coll]

(if (next coll)

(recur (conj res (first coll)) (next coll))

(seq res))))

(defn complement

{:doc "Given a function, return a new function which takes the same arguments

but returns the opposite truth value"}

[f]

(if (not (fn? f))

(throw "Complement must be passed a function")

(fn

([] (not (f)))

([x] (not (f x)))

([x y] (not (f x y)))

([x y & more] (not (apply f x y more))))))

(defn some

{:doc "Checks if the predicate is true for any element of the collection.

Stops if it finds such an element."

:signatures [[pred coll]]

:added "0.1"}

[pred coll]

(cond

(nil? (seq coll)) false

(pred (first coll)) true

:else (recur pred (next coll))))

(extend -count MapEntry (fn [self] 2))

(extend -nth MapEntry (fn [self idx not-found]

(cond (= idx 0) (-key self)

(= idx 1) (-val self)

:else not-found)))

(extend -reduce MapEntry indexed-reduce)

(extend -str MapEntry

(fn [v]

(apply str "[" (conj (transduce (interpose " ") conj v) "]"))))

(extend -repr MapEntry

(fn [v]

(apply str "[" (conj (transduce (comp (map -repr) (interpose " ")) conj v) "]"))))

(extend -hash MapEntry

(fn [v]

(transduce ordered-hash-reducing-fn v)))

(defn keys

{:doc "If called with no arguments returns a transducer that will extract the key from each map entry. If passed

a collection, will assume that it is a hashmap and return a vector of all keys from the collection."

:signatures [[] [coll]]

:added "0.1"}

([] (map key))

([m]

(transduce (map key) conj! m)))

(defn vals

{:doc "If called with no arguments returns a transducer that will extract the key from each map entry. If passed

a collection, will assume that it is a hashmap and return a vector of all keys from the collection."

:signatures [[] [coll]]

:added "0.1"}

([] (map val))

([m]

(transduce (map val) conj! m)))

(extend -seq PersistentHashMap

(fn [m]

(reduce conj nil m)))

(extend -str PersistentHashMap

(fn [v]

(let [entry->str (map (fn [e] (vector (key e) " " (val e))))]

(apply str "{" (conj (transduce (comp entry->str (interpose [", "]) cat) conj v) "}")))))

(extend -repr PersistentHashMap

(fn [v]

(let [entry->str (map (fn [e] (vector (-repr (key e)) " " (-repr (val e)))))]

(apply str "{" (conj (transduce (comp entry->str (interpose [", "]) cat) conj v) "}")))))

(extend -hash PersistentHashMap

(fn [v]

(transduce cat unordered-hash-reducing-fn v)))

(extend -seq PersistentHashSet (fn [self] (seq (iterator self))))

(extend -str PersistentHashSet

(fn [s]

(apply str "#{" (conj (transduce (interpose " ") conj s) "}"))))

(extend -repr PersistentHashSet

(fn [s]

(apply str "#{" (conj (transduce (comp (map -repr) (interpose " ")) conj s) "}"))))

(extend -empty Cons (fn [_] '()))

(extend -empty LazySeq (fn [_] '()))

(extend -empty PersistentList (fn [_] '()))

(extend -empty EmptyList (fn [_] '()))

(extend -empty PersistentVector (fn [_] []))

(extend -empty Array (fn [_] (make-array 0)))

(extend -empty PersistentHashMap (fn [_] {}))

(extend -empty PersistentHashSet (fn [_] #{}))

(extend -conj PersistentHashMap

(fn [coll x]

(cond

(instance? MapEntry x)

(assoc coll (key x) (val x))

(instance? PersistentVector x)

(if (= (count x) 2)

(assoc coll (nth x 0) (nth x 1))

(throw "Vector arg to map conj must be a pair"))

(satisfies? ISeqable x)

(reduce conj coll (-seq x))

:else

(throw (str (type x) " cannot be conjed to a map")))))

(extend -conj Cons

(fn [coll x]

(cons x coll)))

(defn empty

{:doc "Returns an empty collection of the same type, or nil."

:added "0.1"}

[coll]

(if (satisfies? IEmpty coll)

(-empty coll)

nil))

(extend -str Keyword

(fn [k]

(if (namespace k)

(str ":" (namespace k) "/" (name k))

(str ":" (name k)))))

(extend -repr Keyword -str)

(extend -repr Symbol -str)

(extend -invoke Keyword (fn [k m] (-val-at m k nil)))

(extend -invoke PersistentHashMap (fn [m k] (-val-at m k nil)))

(extend -invoke PersistentHashSet (fn [m k] (-val-at m k nil)))

(defn get

{:doc "Get an element from a collection implementing ILookup, return nil or the default value if not found."

:added "0.1"}

([mp k]

(get mp k nil))

([mp k not-found]

(-val-at mp k not-found)))

(defn get-in

{:doc "Get a value from a nested collection at the \"path\" given by the keys."

:examples [["(get-in {:a [{:b 42}]} [:a 0 :b])" nil 42]]

:signatures [[m ks] [m ks not-found]]

:added "0.1"}

([m ks]

(reduce get m ks))

([m ks not-found]

(loop [sentinel 'x

m m

ks (seq ks)]

(if ks

(let [m (get m (first ks) sentinel)]

(if (identical? sentinel m)

not-found

(recur sentinel m (next ks))))

m))))

(defn assoc-in

{:doc "Associate a value in a nested collection given by the path.

Creates new maps if the keys are not present."

:examples [["(assoc-in {} [:a :b :c] 42)" nil {:a {:b {:c 42}}}]]

:added "0.1"}

([m ks v]

(let [ks (seq ks)

k (first ks)

ks (next ks)]

(if ks

(assoc m k (assoc-in (get m k) ks v))

(assoc m k v)))))

(defn update-in

{:doc "Update a value in a nested collection."

:examples [["(update-in {:a {:b {:c 41}}} [:a :b :c] inc)" nil {:a {:b {:c 42}}}]]

:added "0.1"}

[m ks f & args]

(let [f (fn [m] (apply f m args))

update-inner-f (fn update-inner-f

([m f k]

(assoc m k (f (get m k))))

([m f k & ks]

(assoc m k (apply update-inner-f (get m k) f ks))))]

(apply update-inner-f m f ks)))

(def subs pixie.string.internal/substring)

(defmacro assert

([test]

`(if ~test

nil

(throw "Assert failed")))

([test msg]

`(if ~test

nil

(throw (str "Assert failed " ~msg)))))

(defmacro resolve

{:doc "Resolve the var associated with the symbol in the current namespace."

:added "0.1"}

[sym]

`(resolve-in (this-ns-name) ~sym))

(defmacro binding [bindings & body]

(let [bindings (apply hashmap bindings)

set-vars (reduce (fn [res binding]

(conj res `(set! (resolve (quote ~(key binding))) ~(val binding))))

[]

bindings)]

`(do (push-binding-frame!)

~@set-vars

(let [ret (do ~@body)]

(pop-binding-frame!)

ret))))

(defmacro require [ns kw as-nm]

(assert (= kw :as) "Require expects :as as the second argument")

`(do (load-ns (quote ~ns))