ElmAST.elm

module ElmAST where

import Json.Decode
import Json.Decode exposing ((:=))
import Json.Encode exposing (Value)
-- The following module comes from bartavelle/json-helpers
import Json.Helpers exposing (..)
import Dict
import Set


type alias Module phase =
   { name: Canonical
   , path: FilePath
   , info: phase
   }

jsonDecModule : Json.Decode.Decoder phase -> Json.Decode.Decoder ( Module phase )
jsonDecModule localDecoder_phase =
   ("name" := jsonDecCanonical) `Json.Decode.andThen` \pname ->
   ("path" := jsonDecFilePath) `Json.Decode.andThen` \ppath ->
   ("info" := localDecoder_phase) `Json.Decode.andThen` \pinfo ->
   Json.Decode.succeed {name = pname, path = ppath, info = pinfo}

jsonEncModule : (phase -> Value) -> Module phase -> Value
jsonEncModule localEncoder_phase val =
   Json.Encode.object
   [ ("name", jsonEncCanonical val.name)
   , ("path", jsonEncFilePath val.path)
   , ("info", localEncoder_phase val.info)
   ]



type Effects pkg ports =
    None 
    | Manager pkg Info
    | Port ports

jsonDecEffects : Json.Decode.Decoder pkg -> Json.Decode.Decoder ports -> Json.Decode.Decoder ( Effects pkg ports )
jsonDecEffects localDecoder_pkg localDecoder_ports =
    let jsonDecDictEffects = Dict.fromList
            [ ("None", Json.Decode.succeed None)
            , ("Manager", Json.Decode.tuple2 Manager (localDecoder_pkg) (jsonDecInfo))
            , ("Port", Json.Decode.map Port (localDecoder_ports))
            ]
    in  decodeSumObjectWithSingleField  "Effects" jsonDecDictEffects

jsonEncEffects : (pkg -> Value) -> (ports -> Value) -> Effects pkg ports -> Value
jsonEncEffects localEncoder_pkg localEncoder_ports val =
    let keyval v = case v of
                    None  -> ("None", encodeValue (Json.Encode.list []))
                    Manager v1 v2 -> ("Manager", encodeValue (Json.Encode.list [localEncoder_pkg v1, jsonEncInfo v2]))
                    Port v1 -> ("Port", encodeValue (localEncoder_ports v1))
    in encodeSumObjectWithSingleField keyval val



type alias Info  =
   { _tag: Region
   , _init: Region
   , _onEffects: Region
   , _onSelfMsg: Region
   , _managerType: ManagerType
   }

jsonDecInfo : Json.Decode.Decoder ( Info )
jsonDecInfo =
   ("_tag" := jsonDecRegion) `Json.Decode.andThen` \p_tag ->
   ("_init" := jsonDecRegion) `Json.Decode.andThen` \p_init ->
   ("_onEffects" := jsonDecRegion) `Json.Decode.andThen` \p_onEffects ->
   ("_onSelfMsg" := jsonDecRegion) `Json.Decode.andThen` \p_onSelfMsg ->
   ("_managerType" := jsonDecManagerType) `Json.Decode.andThen` \p_managerType ->
   Json.Decode.succeed {_tag = p_tag, _init = p_init, _onEffects = p_onEffects, _onSelfMsg = p_onSelfMsg, _managerType = p_managerType}

jsonEncInfo : Info -> Value
jsonEncInfo  val =
   Json.Encode.object
   [ ("_tag", jsonEncRegion val._tag)
   , ("_init", jsonEncRegion val._init)
   , ("_onEffects", jsonEncRegion val._onEffects)
   , ("_onSelfMsg", jsonEncRegion val._onSelfMsg)
   , ("_managerType", jsonEncManagerType val._managerType)
   ]



type alias PortCanonical  =
   { _name: String
   , _kind: Kind
   , _type: Canonical
   }

jsonDecPortCanonical : Json.Decode.Decoder ( PortCanonical )
jsonDecPortCanonical =
   ("_name" := Json.Decode.string) `Json.Decode.andThen` \p_name ->
   ("_kind" := jsonDecKind) `Json.Decode.andThen` \p_kind ->
   ("_type" := jsonDecCanonical) `Json.Decode.andThen` \p_type ->
   Json.Decode.succeed {_name = p_name, _kind = p_kind, _type = p_type}

jsonEncPortCanonical : PortCanonical -> Value
jsonEncPortCanonical  val =
   Json.Encode.object
   [ ("_name", Json.Encode.string val._name)
   , ("_kind", jsonEncKind val._kind)
   , ("_type", jsonEncCanonical val._type)
   ]



type Kind  =
    Outgoing Canonical
    | Incoming Canonical

jsonDecKind : Json.Decode.Decoder ( Kind )
jsonDecKind =
    let jsonDecDictKind = Dict.fromList
            [ ("Outgoing", Json.Decode.map Outgoing (jsonDecCanonical))
            , ("Incoming", Json.Decode.map Incoming (jsonDecCanonical))
            ]
    in  decodeSumObjectWithSingleField  "Kind" jsonDecDictKind

jsonEncKind : Kind -> Value
jsonEncKind  val =
    let keyval v = case v of
                    Outgoing v1 -> ("Outgoing", encodeValue (jsonEncCanonical v1))
                    Incoming v1 -> ("Incoming", encodeValue (jsonEncCanonical v1))
    in encodeSumObjectWithSingleField keyval val



type ManagerType  =
    CmdManager (Located String)
    | SubManager (Located String)
    | FxManager (Located String) (Located String)

jsonDecManagerType : Json.Decode.Decoder ( ManagerType )
jsonDecManagerType =
    let jsonDecDictManagerType = Dict.fromList
            [ ("CmdManager", Json.Decode.map CmdManager (jsonDecLocated (Json.Decode.string)))
            , ("SubManager", Json.Decode.map SubManager (jsonDecLocated (Json.Decode.string)))
            , ("FxManager", Json.Decode.tuple2 FxManager (jsonDecLocated (Json.Decode.string)) (jsonDecLocated (Json.Decode.string)))
            ]
    in  decodeSumObjectWithSingleField  "ManagerType" jsonDecDictManagerType

jsonEncManagerType : ManagerType -> Value
jsonEncManagerType  val =
    let keyval v = case v of
                    CmdManager v1 -> ("CmdManager", encodeValue ((jsonEncLocated (Json.Encode.string)) v1))
                    SubManager v1 -> ("SubManager", encodeValue ((jsonEncLocated (Json.Encode.string)) v1))
                    FxManager v1 v2 -> ("FxManager", encodeValue (Json.Encode.list [(jsonEncLocated (Json.Encode.string)) v1, (jsonEncLocated (Json.Encode.string)) v2]))
    in encodeSumObjectWithSingleField keyval val



type alias Facts  =
   { dependencies: (List TopLevel)
   }

jsonDecFacts : Json.Decode.Decoder ( Facts )
jsonDecFacts =
   ("dependencies" := Json.Decode.list (jsonDecTopLevel)) `Json.Decode.andThen` \pdependencies ->
   Json.Decode.succeed {dependencies = pdependencies}

jsonEncFacts : Facts -> Value
jsonEncFacts  val =
   Json.Encode.object
   [ ("dependencies", (Json.Encode.list << List.map jsonEncTopLevel) val.dependencies)
   ]



type Def  =
    Def Facts Canonical Expr (Maybe (Located Canonical))

jsonDecDef : Json.Decode.Decoder ( Def )
jsonDecDef =
    Json.Decode.tuple4 Def (jsonDecFacts) (jsonDecCanonical) (jsonDecExpr) (Json.Decode.maybe (jsonDecLocated (jsonDecCanonical)))


jsonEncDef : Def -> Value
jsonEncDef (Def v1 v2 v3 v4) =
    Json.Encode.list [jsonEncFacts v1, jsonEncCanonical v2, jsonEncExpr v3, (maybeEncode ((jsonEncLocated (jsonEncCanonical)))) v4]



type Main typ =
    VDom 
    | NoFlags 
    | Flags typ

jsonDecMain : Json.Decode.Decoder typ -> Json.Decode.Decoder ( Main typ )
jsonDecMain localDecoder_typ =
    let jsonDecDictMain = Dict.fromList
            [ ("VDom", Json.Decode.succeed VDom)
            , ("NoFlags", Json.Decode.succeed NoFlags)
            , ("Flags", Json.Decode.map Flags (localDecoder_typ))
            ]
    in  decodeSumObjectWithSingleField  "Main" jsonDecDictMain

jsonEncMain : (typ -> Value) -> Main typ -> Value
jsonEncMain localEncoder_typ val =
    let keyval v = case v of
                    VDom  -> ("VDom", encodeValue (Json.Encode.list []))
                    NoFlags  -> ("NoFlags", encodeValue (Json.Encode.list []))
                    Flags v1 -> ("Flags", encodeValue (localEncoder_typ v1))
    in encodeSumObjectWithSingleField keyval val



type Expr' ann def var typ =
    Literal Literal
    | Var var
    | Range (Expr ann def var typ) (Expr ann def var typ)
    | ExplicitList (List (Expr ann def var typ))
    | Binop var (Expr ann def var typ) (Expr ann def var typ)
    | Lambda (Pattern ann var) (Expr ann def var typ)
    | App (Expr ann def var typ) (Expr ann def var typ)
    | If (List ((Expr ann def var typ), (Expr ann def var typ))) (Expr ann def var typ)
    | Let (List def) (Expr ann def var typ)
    | Case (Expr ann def var typ) (List ((Pattern ann var), (Expr ann def var typ)))
    | Data String (List (Expr ann def var typ))
    | Access (Expr ann def var typ) String
    | Update (Expr ann def var typ) (List (String, (Expr ann def var typ)))
    | Record (List (String, (Expr ann def var typ)))
    | Cmd Canonical
    | Sub Canonical
    | OutgoingPort String typ
    | IncomingPort String typ
    | Program (Main typ) (Expr ann def var typ)
    | SaveEnv Canonical Canonical
    | GLShader String String GLShaderTipe

jsonDecExpr' : Json.Decode.Decoder ann -> Json.Decode.Decoder def -> Json.Decode.Decoder var -> Json.Decode.Decoder typ -> Json.Decode.Decoder ( Expr' ann def var typ )
jsonDecExpr' localDecoder_ann localDecoder_def localDecoder_var localDecoder_typ =
    let jsonDecDictExpr' = Dict.fromList
            [ ("Literal", Json.Decode.map Literal (jsonDecLiteral))
            , ("Var", Json.Decode.map Var (localDecoder_var))
            , ("Range", Json.Decode.tuple2 Range (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)))
            , ("ExplicitList", Json.Decode.map ExplicitList (Json.Decode.list (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ))))
            , ("Binop", Json.Decode.tuple3 Binop (localDecoder_var) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)))
            , ("Lambda", Json.Decode.tuple2 Lambda (jsonDecPattern (localDecoder_ann) (localDecoder_var)) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)))
            , ("App", Json.Decode.tuple2 App (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)))
            , ("If", Json.Decode.tuple2 If (Json.Decode.list (Json.Decode.tuple2 (,) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)))) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)))
            , ("Let", Json.Decode.tuple2 Let (Json.Decode.list (localDecoder_def)) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)))
            , ("Case", Json.Decode.tuple2 Case (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)) (Json.Decode.list (Json.Decode.tuple2 (,) (jsonDecPattern (localDecoder_ann) (localDecoder_var)) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)))))
            , ("Data", Json.Decode.tuple2 Data (Json.Decode.string) (Json.Decode.list (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ))))
            , ("Access", Json.Decode.tuple2 Access (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)) (Json.Decode.string))
            , ("Update", Json.Decode.tuple2 Update (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)) (Json.Decode.list (Json.Decode.tuple2 (,) (Json.Decode.string) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)))))
            , ("Record", Json.Decode.map Record (Json.Decode.list (Json.Decode.tuple2 (,) (Json.Decode.string) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)))))
            , ("Cmd", Json.Decode.map Cmd (jsonDecCanonical))
            , ("Sub", Json.Decode.map Sub (jsonDecCanonical))
            , ("OutgoingPort", Json.Decode.tuple2 OutgoingPort (Json.Decode.string) (localDecoder_typ))
            , ("IncomingPort", Json.Decode.tuple2 IncomingPort (Json.Decode.string) (localDecoder_typ))
            , ("Program", Json.Decode.tuple2 Program (jsonDecMain (localDecoder_typ)) (jsonDecExpr (localDecoder_ann) (localDecoder_def) (localDecoder_var) (localDecoder_typ)))
            , ("SaveEnv", Json.Decode.tuple2 SaveEnv (jsonDecCanonical) (jsonDecCanonical))
            , ("GLShader", Json.Decode.tuple3 GLShader (Json.Decode.string) (Json.Decode.string) (jsonDecGLShaderTipe))
            ]
    in  decodeSumObjectWithSingleField  "Expr'" jsonDecDictExpr'

jsonEncExpr' : (ann -> Value) -> (def -> Value) -> (var -> Value) -> (typ -> Value) -> Expr' ann def var typ -> Value
jsonEncExpr' localEncoder_ann localEncoder_def localEncoder_var localEncoder_typ val =
    let keyval v = case v of
                    Literal v1 -> ("Literal", encodeValue (jsonEncLiteral v1))
                    Var v1 -> ("Var", encodeValue (localEncoder_var v1))
                    Range v1 v2 -> ("Range", encodeValue (Json.Encode.list [(jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v1, (jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v2]))
                    ExplicitList v1 -> ("ExplicitList", encodeValue ((Json.Encode.list << List.map (jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ))) v1))
                    Binop v1 v2 v3 -> ("Binop", encodeValue (Json.Encode.list [localEncoder_var v1, (jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v2, (jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v3]))
                    Lambda v1 v2 -> ("Lambda", encodeValue (Json.Encode.list [(jsonEncPattern (localEncoder_ann) (localEncoder_var)) v1, (jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v2]))
                    App v1 v2 -> ("App", encodeValue (Json.Encode.list [(jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v1, (jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v2]))
                    If v1 v2 -> ("If", encodeValue (Json.Encode.list [(Json.Encode.list << List.map (\(v1,v2) -> Json.Encode.list [((jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ))) v1,((jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ))) v2])) v1, (jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v2]))
                    Let v1 v2 -> ("Let", encodeValue (Json.Encode.list [(Json.Encode.list << List.map localEncoder_def) v1, (jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v2]))
                    Case v1 v2 -> ("Case", encodeValue (Json.Encode.list [(jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v1, (Json.Encode.list << List.map (\(v1,v2) -> Json.Encode.list [((jsonEncPattern (localEncoder_ann) (localEncoder_var))) v1,((jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ))) v2])) v2]))
                    Data v1 v2 -> ("Data", encodeValue (Json.Encode.list [Json.Encode.string v1, (Json.Encode.list << List.map (jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ))) v2]))
                    Access v1 v2 -> ("Access", encodeValue (Json.Encode.list [(jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v1, Json.Encode.string v2]))
                    Update v1 v2 -> ("Update", encodeValue (Json.Encode.list [(jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v1, (Json.Encode.list << List.map (\(v1,v2) -> Json.Encode.list [(Json.Encode.string) v1,((jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ))) v2])) v2]))
                    Record v1 -> ("Record", encodeValue ((Json.Encode.list << List.map (\(v1,v2) -> Json.Encode.list [(Json.Encode.string) v1,((jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ))) v2])) v1))
                    Cmd v1 -> ("Cmd", encodeValue (jsonEncCanonical v1))
                    Sub v1 -> ("Sub", encodeValue (jsonEncCanonical v1))
                    OutgoingPort v1 v2 -> ("OutgoingPort", encodeValue (Json.Encode.list [Json.Encode.string v1, localEncoder_typ v2]))
                    IncomingPort v1 v2 -> ("IncomingPort", encodeValue (Json.Encode.list [Json.Encode.string v1, localEncoder_typ v2]))
                    Program v1 v2 -> ("Program", encodeValue (Json.Encode.list [(jsonEncMain (localEncoder_typ)) v1, (jsonEncExpr (localEncoder_ann) (localEncoder_def) (localEncoder_var) (localEncoder_typ)) v2]))
                    SaveEnv v1 v2 -> ("SaveEnv", encodeValue (Json.Encode.list [jsonEncCanonical v1, jsonEncCanonical v2]))
                    GLShader v1 v2 v3 -> ("GLShader", encodeValue (Json.Encode.list [Json.Encode.string v1, Json.Encode.string v2, jsonEncGLShaderTipe v3]))
    in encodeSumObjectWithSingleField keyval val



type Literal  =
    IntNum Int
    | FloatNum Float
    | Chr Char
    | Str String
    | Boolean Bool

jsonDecLiteral : Json.Decode.Decoder ( Literal )
jsonDecLiteral =
    let jsonDecDictLiteral = Dict.fromList
            [ ("IntNum", Json.Decode.map IntNum (Json.Decode.int))
            , ("FloatNum", Json.Decode.map FloatNum (Json.Decode.float))
            , ("Chr", Json.Decode.map Chr (jsonDecChar))
            , ("Str", Json.Decode.map Str (Json.Decode.string))
            , ("Boolean", Json.Decode.map Boolean (Json.Decode.bool))
            ]
    in  decodeSumObjectWithSingleField  "Literal" jsonDecDictLiteral

jsonEncLiteral : Literal -> Value
jsonEncLiteral  val =
    let keyval v = case v of
                    IntNum v1 -> ("IntNum", encodeValue (Json.Encode.int v1))
                    FloatNum v1 -> ("FloatNum", encodeValue (Json.Encode.float v1))
                    Chr v1 -> ("Chr", encodeValue (jsonEncChar v1))
                    Str v1 -> ("Str", encodeValue (Json.Encode.string v1))
                    Boolean v1 -> ("Boolean", encodeValue (Json.Encode.bool v1))
    in encodeSumObjectWithSingleField keyval val



type alias GLShaderTipe  =
   { attribute: (Dict String GLTipe)
   , uniform: (Dict String GLTipe)
   , varying: (Dict String GLTipe)
   }

jsonDecGLShaderTipe : Json.Decode.Decoder ( GLShaderTipe )
jsonDecGLShaderTipe =
   ("attribute" := Json.Decode.dict (jsonDecGLTipe)) `Json.Decode.andThen` \pattribute ->
   ("uniform" := Json.Decode.dict (jsonDecGLTipe)) `Json.Decode.andThen` \puniform ->
   ("varying" := Json.Decode.dict (jsonDecGLTipe)) `Json.Decode.andThen` \pvarying ->
   Json.Decode.succeed {attribute = pattribute, uniform = puniform, varying = pvarying}

jsonEncGLShaderTipe : GLShaderTipe -> Value
jsonEncGLShaderTipe  val =
   Json.Encode.object
   [ ("attribute", (encodeMap (Json.Encode.string) (jsonEncGLTipe)) val.attribute)
   , ("uniform", (encodeMap (Json.Encode.string) (jsonEncGLTipe)) val.uniform)
   , ("varying", (encodeMap (Json.Encode.string) (jsonEncGLTipe)) val.varying)
   ]



type GLTipe  =
    Int 
    | Float 
    | V2 
    | V3 
    | V4 
    | M4 
    | Texture 

jsonDecGLTipe : Json.Decode.Decoder ( GLTipe )
jsonDecGLTipe = decodeSumUnaries "GLTipe" jsonDecDictGLTipe
jsonDecDictGLTipe = Dict.fromList [("Int", Int), ("Float", Float), ("V2", V2), ("V3", V3), ("V4", V4), ("M4", M4), ("Texture", Texture)]

jsonEncGLTipe : GLTipe -> Value
jsonEncGLTipe  val =
    case val of
        Int -> Json.Encode.string "Int"
        Float -> Json.Encode.string "Float"
        V2 -> Json.Encode.string "V2"
        V3 -> Json.Encode.string "V3"
        V4 -> Json.Encode.string "V4"
        M4 -> Json.Encode.string "M4"
        Texture -> Json.Encode.string "Texture"



type alias Canonical  =
   { _package: Name
   , _module: Raw
   }

jsonDecCanonical : Json.Decode.Decoder ( Canonical )
jsonDecCanonical =
   ("_package" := jsonDecName) `Json.Decode.andThen` \p_package ->
   ("_module" := jsonDecRaw) `Json.Decode.andThen` \p_module ->
   Json.Decode.succeed {_package = p_package, _module = p_module}

jsonEncCanonical : Canonical -> Value
jsonEncCanonical  val =
   Json.Encode.object
   [ ("_package", jsonEncName val._package)
   , ("_module", jsonEncRaw val._module)
   ]



type alias Module phase =
   { name: Canonical
   , path: FilePath
   , info: phase
   }

jsonDecModule : Json.Decode.Decoder phase -> Json.Decode.Decoder ( Module phase )
jsonDecModule localDecoder_phase =
   ("name" := jsonDecCanonical) `Json.Decode.andThen` \pname ->
   ("path" := jsonDecFilePath) `Json.Decode.andThen` \ppath ->
   ("info" := localDecoder_phase) `Json.Decode.andThen` \pinfo ->
   Json.Decode.succeed {name = pname, path = ppath, info = pinfo}

jsonEncModule : (phase -> Value) -> Module phase -> Value
jsonEncModule localEncoder_phase val =
   Json.Encode.object
   [ ("name", jsonEncCanonical val.name)
   , ("path", jsonEncFilePath val.path)
   , ("info", localEncoder_phase val.info)
   ]



type Pattern' ann var =
    Data var (List (Pattern ann var))
    | Record (List String)
    | Alias String (Pattern ann var)
    | Var String
    | Anything 
    | Literal Literal

jsonDecPattern' : Json.Decode.Decoder ann -> Json.Decode.Decoder var -> Json.Decode.Decoder ( Pattern' ann var )
jsonDecPattern' localDecoder_ann localDecoder_var =
    let jsonDecDictPattern' = Dict.fromList
            [ ("Data", Json.Decode.tuple2 Data (localDecoder_var) (Json.Decode.list (jsonDecPattern (localDecoder_ann) (localDecoder_var))))
            , ("Record", Json.Decode.map Record (Json.Decode.list (Json.Decode.string)))
            , ("Alias", Json.Decode.tuple2 Alias (Json.Decode.string) (jsonDecPattern (localDecoder_ann) (localDecoder_var)))
            , ("Var", Json.Decode.map Var (Json.Decode.string))
            , ("Anything", Json.Decode.succeed Anything)
            , ("Literal", Json.Decode.map Literal (jsonDecLiteral))
            ]
    in  decodeSumObjectWithSingleField  "Pattern'" jsonDecDictPattern'

jsonEncPattern' : (ann -> Value) -> (var -> Value) -> Pattern' ann var -> Value
jsonEncPattern' localEncoder_ann localEncoder_var val =
    let keyval v = case v of
                    Data v1 v2 -> ("Data", encodeValue (Json.Encode.list [localEncoder_var v1, (Json.Encode.list << List.map (jsonEncPattern (localEncoder_ann) (localEncoder_var))) v2]))
                    Record v1 -> ("Record", encodeValue ((Json.Encode.list << List.map Json.Encode.string) v1))
                    Alias v1 v2 -> ("Alias", encodeValue (Json.Encode.list [Json.Encode.string v1, (jsonEncPattern (localEncoder_ann) (localEncoder_var)) v2]))
                    Var v1 -> ("Var", encodeValue (Json.Encode.string v1))
                    Anything  -> ("Anything", encodeValue (Json.Encode.list []))
                    Literal v1 -> ("Literal", encodeValue (jsonEncLiteral v1))
    in encodeSumObjectWithSingleField keyval val



type Aliased t =
    Holey t
    | Filled t

jsonDecAliased : Json.Decode.Decoder t -> Json.Decode.Decoder ( Aliased t )
jsonDecAliased localDecoder_t =
    let jsonDecDictAliased = Dict.fromList
            [ ("Holey", Json.Decode.map Holey (localDecoder_t))
            , ("Filled", Json.Decode.map Filled (localDecoder_t))
            ]
    in  decodeSumObjectWithSingleField  "Aliased" jsonDecDictAliased

jsonEncAliased : (t -> Value) -> Aliased t -> Value
jsonEncAliased localEncoder_t val =
    let keyval v = case v of
                    Holey v1 -> ("Holey", encodeValue (localEncoder_t v1))
                    Filled v1 -> ("Filled", encodeValue (localEncoder_t v1))
    in encodeSumObjectWithSingleField keyval val



type Canonical  =
    Lambda Canonical Canonical
    | Var String
    | Type Canonical
    | App Canonical (List Canonical)
    | Record (List (String, Canonical)) (Maybe Canonical)
    | Aliased Canonical (List (String, Canonical)) (Aliased Canonical)

jsonDecCanonical : Json.Decode.Decoder ( Canonical )
jsonDecCanonical =
    let jsonDecDictCanonical = Dict.fromList
            [ ("Lambda", Json.Decode.tuple2 Lambda (jsonDecCanonical) (jsonDecCanonical))
            , ("Var", Json.Decode.map Var (Json.Decode.string))
            , ("Type", Json.Decode.map Type (jsonDecCanonical))
            , ("App", Json.Decode.tuple2 App (jsonDecCanonical) (Json.Decode.list (jsonDecCanonical)))
            , ("Record", Json.Decode.tuple2 Record (Json.Decode.list (Json.Decode.tuple2 (,) (Json.Decode.string) (jsonDecCanonical))) (Json.Decode.maybe (jsonDecCanonical)))
            , ("Aliased", Json.Decode.tuple3 Aliased (jsonDecCanonical) (Json.Decode.list (Json.Decode.tuple2 (,) (Json.Decode.string) (jsonDecCanonical))) (jsonDecAliased (jsonDecCanonical)))
            ]
    in  decodeSumObjectWithSingleField  "Canonical" jsonDecDictCanonical

jsonEncCanonical : Canonical -> Value
jsonEncCanonical  val =
    let keyval v = case v of
                    Lambda v1 v2 -> ("Lambda", encodeValue (Json.Encode.list [jsonEncCanonical v1, jsonEncCanonical v2]))
                    Var v1 -> ("Var", encodeValue (Json.Encode.string v1))
                    Type v1 -> ("Type", encodeValue (jsonEncCanonical v1))
                    App v1 v2 -> ("App", encodeValue (Json.Encode.list [jsonEncCanonical v1, (Json.Encode.list << List.map jsonEncCanonical) v2]))
                    Record v1 v2 -> ("Record", encodeValue (Json.Encode.list [(Json.Encode.list << List.map (\(v1,v2) -> Json.Encode.list [(Json.Encode.string) v1,(jsonEncCanonical) v2])) v1, (maybeEncode (jsonEncCanonical)) v2]))
                    Aliased v1 v2 v3 -> ("Aliased", encodeValue (Json.Encode.list [jsonEncCanonical v1, (Json.Encode.list << List.map (\(v1,v2) -> Json.Encode.list [(Json.Encode.string) v1,(jsonEncCanonical) v2])) v2, (jsonEncAliased (jsonEncCanonical)) v3]))
    in encodeSumObjectWithSingleField keyval val



type alias Canonical  =
   { home: Home
   , name: String
   }

jsonDecCanonical : Json.Decode.Decoder ( Canonical )
jsonDecCanonical =
   ("home" := jsonDecHome) `Json.Decode.andThen` \phome ->
   ("name" := Json.Decode.string) `Json.Decode.andThen` \pname ->
   Json.Decode.succeed {home = phome, name = pname}

jsonEncCanonical : Canonical -> Value
jsonEncCanonical  val =
   Json.Encode.object
   [ ("home", jsonEncHome val.home)
   , ("name", Json.Encode.string val.name)
   ]



type Home  =
    BuiltIn 
    | Module Canonical
    | TopLevel Canonical
    | Local 

jsonDecHome : Json.Decode.Decoder ( Home )
jsonDecHome =
    let jsonDecDictHome = Dict.fromList
            [ ("BuiltIn", Json.Decode.succeed BuiltIn)
            , ("Module", Json.Decode.map Module (jsonDecCanonical))
            , ("TopLevel", Json.Decode.map TopLevel (jsonDecCanonical))
            , ("Local", Json.Decode.succeed Local)
            ]
    in  decodeSumObjectWithSingleField  "Home" jsonDecDictHome

jsonEncHome : Home -> Value
jsonEncHome  val =
    let keyval v = case v of
                    BuiltIn  -> ("BuiltIn", encodeValue (Json.Encode.list []))
                    Module v1 -> ("Module", encodeValue (jsonEncCanonical v1))
                    TopLevel v1 -> ("TopLevel", encodeValue (jsonEncCanonical v1))
                    Local  -> ("Local", encodeValue (Json.Encode.list []))
    in encodeSumObjectWithSingleField keyval val



type alias TopLevel  =
   { topHome: Canonical
   , topName: String
   }

jsonDecTopLevel : Json.Decode.Decoder ( TopLevel )
jsonDecTopLevel =
   ("topHome" := jsonDecCanonical) `Json.Decode.andThen` \ptopHome ->
   ("topName" := Json.Decode.string) `Json.Decode.andThen` \ptopName ->
   Json.Decode.succeed {topHome = ptopHome, topName = ptopName}

jsonEncTopLevel : TopLevel -> Value
jsonEncTopLevel  val =
   Json.Encode.object
   [ ("topHome", jsonEncCanonical val.topHome)
   , ("topName", Json.Encode.string val.topName)
   ]



type Annotated annotation a =
    A annotation a

jsonDecAnnotated : Json.Decode.Decoder annotation -> Json.Decode.Decoder a -> Json.Decode.Decoder ( Annotated annotation a )
jsonDecAnnotated localDecoder_annotation localDecoder_a =
    Json.Decode.tuple2 A (localDecoder_annotation) (localDecoder_a)


jsonEncAnnotated : (annotation -> Value) -> (a -> Value) -> Annotated annotation a -> Value
jsonEncAnnotated localEncoder_annotation localEncoder_a(A v1 v2) =
    Json.Encode.list [localEncoder_annotation v1, localEncoder_a v2]



type alias Region  =
   { start: Position
   , end: Position
   }

jsonDecRegion : Json.Decode.Decoder ( Region )
jsonDecRegion =
   ("start" := jsonDecPosition) `Json.Decode.andThen` \pstart ->
   ("end" := jsonDecPosition) `Json.Decode.andThen` \pend ->
   Json.Decode.succeed {start = pstart, end = pend}

jsonEncRegion : Region -> Value
jsonEncRegion  val =
   Json.Encode.object
   [ ("start", jsonEncPosition val.start)
   , ("end", jsonEncPosition val.end)
   ]



type alias Position  =
   { line: Int
   , column: Int
   }

jsonDecPosition : Json.Decode.Decoder ( Position )
jsonDecPosition =
   ("line" := Json.Decode.int) `Json.Decode.andThen` \pline ->
   ("column" := Json.Decode.int) `Json.Decode.andThen` \pcolumn ->
   Json.Decode.succeed {line = pline, column = pcolumn}

jsonEncPosition : Position -> Value
jsonEncPosition  val =
   Json.Encode.object
   [ ("line", Json.Encode.int val.line)
   , ("column", Json.Encode.int val.column)
   ]