(import-macros {: reduce} :lib.macro)

(fn sort [a less-fn]
  (table.sort a less-fn)
  a)

(fn concat [a b]
  (local copy
   (fn [a b]
     (reduce
      (fn [_ v res]
       (table.insert res v)
       res)
      b a)))
  (copy a b))

(fn flip [a]
  (collect [k v (pairs a)]
    (values v k)))

(fn diff [a b]
  (local flip-b (flip b))
  (reduce
    (fn [_ v res]
      (when (not (. flip-b v))
        (table.insert res v))
      res)
    a []))

(fn unique [a]
  (var hash {})
  (reduce
    (fn [_ v res]
      (when (not (. hash v))
        (tset hash v true)
        (table.insert res v))
      res)
    a []))

(fn flatten [a]
 (reduce
  (fn [_ value rest]
    (concat
      rest
      (if (= (type value) "table")
        (flatten value)
        [value])))
  a []))

(fn contains [a want]
  (each [_ v (pairs a)]
    (if (= v want)
      (lua "return true")))
  false)

(fn list [obj]
  (local result [])
  (var cursor 1)
  (each [_ v (pairs obj)]
    (tset result cursor v)
    (set cursor (+ 1 cursor)))
  ;; sort so we always return the same list for the same object
  (table.sort result)
  result)

(local join table.concat)

{: sort : concat : diff : unique : flatten : join : contains : list}