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

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

(fn concat [...]
  (local res [])
  (var cur 1)
  (each [_ t (pairs [...])]
   (each [_ v (pairs t)]
    (tset res cur v)
    (set cur (+ 1 cur))))
  res)

(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 res [])
  (var cursor 1)
  (each [_ v (pairs obj)]
    (tset res cursor v)
    (set cursor (+ 1 cursor)))
  ;; sort so we always return the same list for the same object
  (table.sort res)
  res)

(local join table.concat)

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