(.module:
  [library
   [lux #*
    [abstract
     [functor (#+ Functor)]
     [comonad (#+ CoMonad)]]
    [control
     ["//" continuation (#+ Cont)]
     ["<>" parser
      ["<.>" code (#+ Parser)]]]
    [macro (#+ with_identifiers)
     [syntax (#+ syntax:)]
     ["." code]]
    [data
     ["." bit]
     [collection
      ["." list ("#\." monad)]]]
    [math
     [number
      ["n" nat]]]]])

(type: .public (Sequence a)
  (Cont [a (Sequence a)]))

(def: .public (iterations step init)
  (All [a b]
    (-> (-> a [a b]) a (Sequence b)))
  (let [[next x] (step init)]
    (//.pending [x (iterations step next)])))

(def: .public (repeated x)
  (All [a]
    (-> a (Sequence a)))
  (//.pending [x (repeated x)]))

(def: .public (cycle [start next])
  (All [a]
    (-> [a (List a)] (Sequence a)))
  (loop [head start
         tail next]
    (//.pending [head (case tail
                        #.End
                        (recur start next)
                        
                        (#.Item head' tail')
                        (recur head' tail'))])))

(template [<name> <return>]
  [(def: .public (<name> sequence)
     (All [a] (-> (Sequence a) <return>))
     (let [[head tail] (//.result sequence)]
       <name>))]

  [head a]
  [tail (Sequence a)]
  )

(def: .public (item idx sequence)
  (All [a] (-> Nat (Sequence a) a))
  (let [[head tail] (//.result sequence)]
    (case idx
      0 head
      _ (item (-- idx) tail))))

(template [<taker> <dropper> <pred_type> <pred_test> <pred_step> <post_test>]
  [(def: .public (<taker> pred xs)
     (All [a]
       (-> <pred_type> (Sequence a) (List a)))
     (let [[x xs'] (//.result xs)]
       (if (<post_test> <pred_test>)
         (list& x (<taker> <pred_step> xs'))
         (list))))

   (def: .public (<dropper> pred xs)
     (All [a]
       (-> <pred_type> (Sequence a) (Sequence a)))
     (let [[x xs'] (//.result xs)]
       (if (<post_test> <pred_test>)
         (<dropper> <pred_step> xs')
         xs)))]
  
  [while until (-> a Bit) (pred x)     pred       |>]
  [first after Nat        (n.= 0 pred) (-- pred) not]
  )

(template [<splitter> <pred_type> <pred_test> <pred_step>]
  [(def: .public (<splitter> pred xs)
     (All [a]
       (-> <pred_type> (Sequence a) [(List a) (Sequence a)]))
     (let [[x xs'] (//.result xs)]
       (if <pred_test>
         [(list) xs]
         (let [[tail next] (<splitter> <pred_step> xs')]
           [(#.Item [x tail]) next]))))]
  
  [split_when (-> a Bit) (pred x)     pred]
  [split_at   Nat        (n.= 0 pred) (-- pred)]
  )

(def: .public (only predicate sequence)
  (All [a] (-> (-> a Bit) (Sequence a) (Sequence a)))
  (let [[head tail] (//.result sequence)]
    (if (predicate head)
      (//.pending [head (only predicate tail)])
      (only predicate tail))))

(def: .public (partition left? xs)
  (All [a] (-> (-> a Bit) (Sequence a) [(Sequence a) (Sequence a)]))
  [(..only left? xs)
   (..only (bit.complement left?) xs)])

(implementation: .public functor
  (Functor Sequence)
  
  (def: (map f fa)
    (let [[head tail] (//.result fa)]
      (//.pending [(f head) (map f tail)]))))

(implementation: .public comonad
  (CoMonad Sequence)
  
  (def: &functor ..functor)
  
  (def: out head)
  
  (def: (split wa)
    (let [[head tail] (//.result wa)]
      (//.pending [wa (split tail)]))))

(syntax: .public (^sequence& [patterns (<code>.form (<>.many <code>.any))
                              body <code>.any
                              branches (<>.some <code>.any)])
  (with_identifiers [g!sequence]
    (let [body+ (` (let [(~+ (list\join (list\map (function (_ pattern)
                                                    (list (` [(~ pattern) (~ g!sequence)])
                                                          (` ((~! //.result) (~ g!sequence)))))
                                                  patterns)))]
                     (~ body)))]
      (in (list& g!sequence body+ branches)))))