(;module:
  lux
  (lux (control monad
                ["ex" exception #+ exception:])
       (data text/format)
       [meta #+ Monad<Meta> "Meta/" Monad<Meta>])
  (luxc ["&" base]
        (lang ["ls" synthesis])
        ["&;" analyser]
        ["&;" synthesizer]
        (synthesizer [";S" function])
        (generator ["&;" common]
                   ["&;" primitive]
                   ["&;" structure]
                   ["&;" eval]
                   ["&;" procedure]
                   ["&;" function]
                   ["&;" reference]
                   [";G" case]
                   (host ["$" jvm]))))

(exception: #export Unrecognized-Synthesis)

(def: #export (generate synthesis)
  (-> ls;Synthesis (Meta $;Inst))
  (case synthesis
    #ls;Unit
    &primitive;generate-unit

    (^template [<tag> <generator>]
      (<tag> value)
      (<generator> value))
    ([#ls;Bool &primitive;generate-bool]
     [#ls;Nat  &primitive;generate-nat]
     [#ls;Int  &primitive;generate-int]
     [#ls;Deg  &primitive;generate-deg]
     [#ls;Frac &primitive;generate-frac]
     [#ls;Text &primitive;generate-text])

    (#ls;Variant tag tail? member)
    (&structure;generate-variant generate tag tail? member)
    
    (#ls;Tuple members)
    (&structure;generate-tuple generate members)

    (#ls;Variable var)
    (if (functionS;captured? var)
      (&reference;generate-captured var)
      (&reference;generate-variable var))

    (#ls;Definition definition)
    (&reference;generate-definition definition)

    (#ls;Let register inputS exprS)
    (caseG;generate-let generate register inputS exprS)

    (#ls;Case inputS pathPS)
    (caseG;generate-case generate inputS pathPS)

    (#ls;Function arity env body)
    (&function;generate-function generate env arity body)

    (#ls;Call args function)
    (&function;generate-call generate function args)

    (#ls;Procedure name args)
    (&procedure;generate-procedure generate name args)

    _
    (&;throw Unrecognized-Synthesis "")
    ))