(.module:
  lux
  (lux (control monad
                ["ex" exception #+ exception:]
                ["p" parser])
       (data ["e" error]
             text/format)
       [macro]
       (macro ["s" syntax])
       ["//" lang]
       (lang ["//." reference #+ Register]
             ["//." synthesis #+ Synthesis]
             ["//." extension]))
  (luxc (lang (host ["$" jvm])))
  (// [".T" common]
      [".T" primitive]
      [".T" structure]
      [".T" eval]
      [".T" function]
      [".T" reference]
      [".T" case]
      [".T" procedure]))

(do-template [<name>]
  [(exception: #export (<name> {message Text})
     message)]

  [Invalid-Function-Syntax]
  [Unrecognized-Synthesis]
  )

(def: #export (translate synthesis)
  (-> Synthesis (Meta $.Inst))
  (case synthesis
    (^ (//synthesis.bool value))
    (primitiveT.translate-bool value)
    
    (^ (//synthesis.i64 value))
    (primitiveT.translate-i64 value)
    
    (^ (//synthesis.f64 value))
    (primitiveT.translate-f64 value)
    
    (^ (//synthesis.text value))
    (primitiveT.translate-text value)

    (^code ((~ [_ (#.Nat tag)]) (~ [_ (#.Bool last?)]) (~ valueS)))
    (structureT.translate-variant translate tag last? valueS)

    (^code [(~+ members)])
    (structureT.translate-tuple translate members)

    (^ [_ (#.Form (list [_ (#.Int var)]))])
    (if (variableL.captured? var)
      (referenceT.translate-captured var)
      (referenceT.translate-local var))

    [_ (#.Symbol definition)]
    (referenceT.translate-definition definition)

    (^code ("lux let" (~ [_ (#.Nat register)]) (~ inputS) (~ exprS)))
    (caseT.translate-let translate register inputS exprS)

    (^code ("lux case" (~ inputS) (~ pathPS)))
    (caseT.translate-case translate inputS pathPS)

    (^code ("lux function" (~ [_ (#.Nat arity)]) [(~+ environment)] (~ bodyS)))
    (case (s.run environment (p.some s.int))
      (#e.Success environment)
      (functionT.translate-function translate environment arity bodyS)

      _
      (//.throw Invalid-Function-Syntax (%code synthesis)))

    (^code ("lux call" (~ functionS) (~+ argsS)))
    (functionT.translate-call translate functionS argsS)

    (^code ((~ [_ (#.Text procedure)]) (~+ argsS)))
    (procedureT.translate-procedure translate procedure argsS)
    ## (do macro.Monad<Meta>
    ##   [translation (extensionL.find-translation procedure)]
    ##   (translation argsS))

    _
    (//.throw Unrecognized-Synthesis (%code synthesis))
    ))