(;module:
  lux
  (lux [io]
       (control ["F" functor]
                ["A" applicative]
                monad)
       (concurrency ["a" atom])
       [meta]
       (meta ["s" syntax #+ syntax:])
       (type opaque)))

(opaque: #export (Lazy a)
  (-> [] a)

  (def: #hidden (freeze' generator)
    (All [a] (-> (-> [] a) (Lazy a)))
    (let [cache (a;atom (: (Maybe ($ +0)) #;None))]
      (@opaque (function [_]
                 (case (io;run (a;get cache))
                   (#;Some value)
                   value

                   _
                   (let [value (generator [])]
                     (exec (io;run (a;compare-and-swap _ (#;Some value) cache))
                       value)))))))

  (def: #export (thaw l-value)
    (All [a] (-> (Lazy a) a))
    ((@repr l-value) [])))

(syntax: #export (freeze expr)
  (do @
    [g!_ (meta;gensym "_")]
    (wrap (list (` (freeze' (function [(~ g!_)] (~ expr))))))))

(struct: #export _ (F;Functor Lazy)
  (def: (map f fa)
    (freeze (f (thaw fa)))))

(struct: #export _ (A;Applicative Lazy)
  (def: functor Functor<Lazy>)

  (def: (wrap a)
    (freeze a))

  (def: (apply ff fa)
    (freeze ((thaw ff) (thaw fa)))))

(struct: #export _ (Monad Lazy)
  (def: applicative Applicative<Lazy>)

  (def: join thaw))