module Hydra.Impl.Haskell.Sources.Ext.Haskell.Ast where

import Hydra.Impl.Haskell.Sources.Core

import Hydra.All
import Hydra.Impl.Haskell.Dsl.Types as Types
import Hydra.Impl.Haskell.Dsl.Standard


haskellAstModule :: Module Meta
haskellAstModule :: Module Meta
haskellAstModule = forall m.
Namespace -> [Element m] -> [Module m] -> Maybe String -> Module m
Module Namespace
ns [Element Meta]
elements [] forall a b. (a -> b) -> a -> b
$
    forall a. a -> Maybe a
Just String
"A Haskell syntax model, loosely based on Language.Haskell.Tools.AST"
  where
    ns :: Namespace
ns = String -> Namespace
Namespace String
"hydra/ext/haskell/ast"
    def :: String -> Type m -> Element m
def = forall m. Namespace -> String -> Type m -> Element m
datatype Namespace
ns
    ast :: String -> Type m
ast = forall m. Namespace -> String -> Type m
nsref Namespace
ns

    elements :: [Element Meta]
elements = [

      forall {m}. String -> Type m -> Element m
def String
"Alternative" forall a b. (a -> b) -> a -> b
$ -- UAlt
        String -> Type Meta -> Type Meta
doc String
"A pattern-matching alternative" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"pattern"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Pattern",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"CaseRhs",
          String
"binds"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"LocalBindings"],

      forall {m}. String -> Type m -> Element m
def String
"Assertion" forall a b. (a -> b) -> a -> b
$ -- UAssertion (UClassAssert)
        String -> Type Meta -> Type Meta
doc String
"A type assertion" forall a b. (a -> b) -> a -> b
$
        -- omitted for now: implicit and infix assertions
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"types"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Type"],

      forall {m}. String -> Type m -> Element m
def String
"CaseRhs" forall a b. (a -> b) -> a -> b
$ -- UCaseRhs'
        String -> Type Meta -> Type Meta
doc String
"The right-hand side of a pattern-matching alternative" forall a b. (a -> b) -> a -> b
$
        -- omitted for now: guarded
        forall {m}. String -> Type m
ast String
"Expression",

      forall {m}. String -> Type m -> Element m
def String
"Constructor" forall a b. (a -> b) -> a -> b
$ -- UConDecl
        String -> Type Meta -> Type Meta
doc String
"A data constructor" forall a b. (a -> b) -> a -> b
$
        -- omitted for now: ordinary (positional), infix
        forall m. [FieldType m] -> Type m
union [
          String
"ordinary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Constructor.Ordinary",
          String
"record"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Constructor.Record"],

      forall {m}. String -> Type m -> Element m
def String
"Constructor.Ordinary" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"An ordinary (positional) data constructor" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"fields"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Type"],

      forall {m}. String -> Type m -> Element m
def String
"Constructor.Record" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A record-style data constructor" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"fields"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"FieldWithComments"],

      forall {m}. String -> Type m -> Element m
def String
"ConstructorWithComments" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A data constructor together with any comments" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Constructor",
          String
"comments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall m. Type m
string],

      forall {m}. String -> Type m -> Element m
def String
"DataDeclaration" forall a b. (a -> b) -> a -> b
$ -- UDataDecl
        String -> Type Meta -> Type Meta
doc String
"A data type declaration" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"keyword"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"DataDeclaration.Keyword",
          String
"context"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Assertion",
          String
"head"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"DeclarationHead",
          String
"constructors"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"ConstructorWithComments",
          String
"deriving"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Deriving"],

      forall {m}. String -> Type m -> Element m
def String
"DataDeclaration.Keyword" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"The 'data' versus 'newtype keyword" forall a b. (a -> b) -> a -> b
$
        forall m. [String] -> Type m
enum [String
"data", String
"newtype"],

      forall {m}. String -> Type m -> Element m
def String
"DeclarationWithComments" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A data declaration together with any comments" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Declaration",
          String
"comments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall m. Type m
string],

      forall {m}. String -> Type m -> Element m
def String
"Declaration" forall a b. (a -> b) -> a -> b
$ -- UDecl
        String -> Type Meta -> Type Meta
doc String
"A data or value declaration" forall a b. (a -> b) -> a -> b
$
        -- omitted for now: typeFamily, typeSignature, closedTypeFamily, gDataDecl, typeInst, dataInst, gDataInst, class, inst,
        --                  patternSynonym, deriv, fixity, default, patTypeSig, foreignImport, foreignExport, pragma,
        --                  role, splice
        forall m. [FieldType m] -> Type m
union [
          String
"data"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"DataDeclaration",
          String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"TypeDeclaration",
          String
"valueBinding"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"ValueBinding",
          String
"typedBinding"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"TypedBinding"],

      forall {m}. String -> Type m -> Element m
def String
"DeclarationHead" forall a b. (a -> b) -> a -> b
$ -- UDeclHead
        String -> Type Meta -> Type Meta
doc String
"The left-hand side of a declaration" forall a b. (a -> b) -> a -> b
$
        -- omitted for now: infix application
        forall m. [FieldType m] -> Type m
union [
          String
"application"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"DeclarationHead.Application",
          String
"parens"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"DeclarationHead",
          String
"simple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name"],

      forall {m}. String -> Type m -> Element m
def String
"DeclarationHead.Application" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"An application-style declaration head" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"function"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"DeclarationHead",
          String
"operand"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Variable"],

      forall {m}. String -> Type m -> Element m
def String
"Deriving" forall a b. (a -> b) -> a -> b
$ -- UDeriving
        String -> Type Meta -> Type Meta
doc String
"A 'deriving' statement" forall a b. (a -> b) -> a -> b
$
        -- omitted for now: infix, parenthesized, and application instance heads
        forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Name",

      forall {m}. String -> Type m -> Element m
def String
"Export" forall a b. (a -> b) -> a -> b
$ -- UExportSpec
        String -> Type Meta -> Type Meta
doc String
"An export statement" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"declaration"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"ImportExportSpec",
          String
"module"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"ModuleName"],

      forall {m}. String -> Type m -> Element m
def String
"Expression" forall a b. (a -> b) -> a -> b
$ -- UExpr
        String -> Type Meta -> Type Meta
doc String
"A data expression" forall a b. (a -> b) -> a -> b
$
        -- omitted for now: multi-if, unboxed tuple, tuple section, unboxed tuple section, parallel array,
        --                  enum, parallel array enum, list comp, parallel array comp, type application,
        --                  (all Template Haskell constructors), pragma, arrow definition, arrow application,
        --                  lambda cases, static, unboxed sum, hole
        forall m. [FieldType m] -> Type m
union [
          String
"application"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.Application",
          String
"case"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.Case",
          String
"constructRecord"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.ConstructRecord",
          String
"do"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Statement", -- omitted for now: do vs. mdo
          String
"if"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.If",
          String
"infixApplication"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.InfixApplication",
          String
"literal"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Literal",
          String
"lambda"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.Lambda",
          String
"leftSection"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.Section",
          String
"let"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.Let",
          String
"list"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Expression",
          String
"parens"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression",
          String
"prefixApplication"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.PrefixApplication",
          String
"rightSection"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.Section",
          String
"tuple"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Expression",
          String
"typeSignature"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.TypeSignature",
          String
"updateRecord"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression.UpdateRecord",
          String
"variable"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name"],

      forall {m}. String -> Type m -> Element m
def String
"Expression.Application" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"An application expression" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"function"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression",
          String
"argument"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression"],

      forall {m}. String -> Type m -> Element m
def String
"Expression.Case" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A case expression" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"case"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression",
          String
"alternatives"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Alternative"],

      forall {m}. String -> Type m -> Element m
def String
"Expression.ConstructRecord" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A record constructor expression" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"fields"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"FieldUpdate"],

      forall {m}. String -> Type m -> Element m
def String
"Expression.If" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"An 'if' expression" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"condition"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression",
          String
"then"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression",
          String
"else"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression"],

      forall {m}. String -> Type m -> Element m
def String
"Expression.InfixApplication" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"An infix application expression" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression",
          String
"operator"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Operator",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression"],

      forall {m}. String -> Type m -> Element m
def String
"Expression.Lambda" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A lambda expression" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"bindings"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Pattern",
          String
"inner"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression"],

      forall {m}. String -> Type m -> Element m
def String
"Expression.Let" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A 'let' expression" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"bindings"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Pattern",
          String
"inner"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression"],

      forall {m}. String -> Type m -> Element m
def String
"Expression.PrefixApplication" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A prefix expression" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"operator"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Operator",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression"],

      forall {m}. String -> Type m -> Element m
def String
"Expression.Section" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A section expression" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"operator"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Operator",
          String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression"],

      forall {m}. String -> Type m -> Element m
def String
"Expression.TypeSignature" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A type signature expression" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"inner"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression",
          String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type"],

      forall {m}. String -> Type m -> Element m
def String
"Expression.UpdateRecord" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"An update record expression" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"inner"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression",
          String
"fields"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"FieldUpdate"],

      forall {m}. String -> Type m -> Element m
def String
"Field" forall a b. (a -> b) -> a -> b
$ -- UFieldDecl
        String -> Type Meta -> Type Meta
doc String
"A field (name/type pair)" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type"],

      forall {m}. String -> Type m -> Element m
def String
"FieldWithComments" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A field together with any comments" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"field"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Field",
          String
"comments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall m. Type m
string],

      forall {m}. String -> Type m -> Element m
def String
"FieldUpdate" forall a b. (a -> b) -> a -> b
$ -- UFieldUpdate
        String -> Type Meta -> Type Meta
doc String
"A field name and value" forall a b. (a -> b) -> a -> b
$
        -- omitted for now: pun, wildcard
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"value"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Expression"],

      forall {m}. String -> Type m -> Element m
def String
"Import" forall a b. (a -> b) -> a -> b
$ -- UImportDecl
        String -> Type Meta -> Type Meta
doc String
"An import statement" forall a b. (a -> b) -> a -> b
$
        -- omitted for now: source, safe, pkg
        forall m. [FieldType m] -> Type m
record [
          String
"qualified"forall m. String -> Type m -> FieldType m
>: forall m. Type m
boolean,
          String
"module"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"ModuleName",
          String
"as"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"ModuleName",
          String
"spec"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Import.Spec"],

      forall {m}. String -> Type m -> Element m
def String
"Import.Spec" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"An import specification" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"list"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"ImportExportSpec",
          String
"hiding"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"ImportExportSpec"],

      forall {m}. String -> Type m -> Element m
def String
"ImportModifier" forall a b. (a -> b) -> a -> b
$ -- UImportModifier
        String -> Type Meta -> Type Meta
doc String
"An import modifier ('pattern' or 'type')" forall a b. (a -> b) -> a -> b
$
        forall m. [String] -> Type m
enum [String
"pattern", String
"type"],

      forall {m}. String -> Type m -> Element m
def String
"ImportExportSpec" forall a b. (a -> b) -> a -> b
$ -- UIESpec
        String -> Type Meta -> Type Meta
doc String
"An import or export specification" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"modifier"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"ImportModifier",
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"subspec"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"ImportExportSpec.Subspec"],

      forall {m}. String -> Type m -> Element m
def String
"ImportExportSpec.Subspec" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
          String
"all"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
          String
"list"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Name"],

      forall {m}. String -> Type m -> Element m
def String
"Literal" forall a b. (a -> b) -> a -> b
$ -- ULiteral
        String -> Type Meta -> Type Meta
doc String
"A literal value" forall a b. (a -> b) -> a -> b
$
        -- omitted for now: frac, primChar
        forall m. [FieldType m] -> Type m
union [
          String
"char"forall m. String -> Type m -> FieldType m
>: forall m. Type m
uint16,
          String
"double"forall m. String -> Type m -> FieldType m
>: forall m. Type m
float64,
          String
"float"forall m. String -> Type m -> FieldType m
>: forall m. Type m
float32,
          String
"int"forall m. String -> Type m -> FieldType m
>: forall m. Type m
int32,
          String
"integer"forall m. String -> Type m -> FieldType m
>: forall m. Type m
bigint,
          String
"string"forall m. String -> Type m -> FieldType m
>: forall m. Type m
string],

      forall {m}. String -> Type m -> Element m
def String
"LocalBinding" forall a b. (a -> b) -> a -> b
$ -- ULocalBind
        -- omitted for now: fixity, pragma
        forall m. [FieldType m] -> Type m
union [
          String
"signature"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"TypeSignature",
          String
"value"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"ValueBinding"],

      forall {m}. String -> Type m -> Element m
def String
"LocalBindings" forall a b. (a -> b) -> a -> b
$ -- ULocalBinds
        forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"LocalBinding",

      forall {m}. String -> Type m -> Element m
def String
"Module" forall a b. (a -> b) -> a -> b
$ -- UModule
        -- omitted for now: pragma
        forall m. [FieldType m] -> Type m
record [
          String
"head"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"ModuleHead",
          String
"imports"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Import",
          String
"declarations"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"DeclarationWithComments"],

      forall {m}. String -> Type m -> Element m
def String
"ModuleHead" forall a b. (a -> b) -> a -> b
$ -- UModuleHead
        -- omitted for now: pragma
        forall m. [FieldType m] -> Type m
record [
          String
"comments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall m. Type m
string,
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"ModuleName",
          String
"exports"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Export"], -- UExportSpecs

      forall {m}. String -> Type m -> Element m
def String
"ModuleName" -- UModuleName
        forall m. Type m
string,

      forall {m}. String -> Type m -> Element m
def String
"Name" forall a b. (a -> b) -> a -> b
$ -- UName
        forall m. [FieldType m] -> Type m
union [
          String
"implicit"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"QualifiedName",
          String
"normal"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"QualifiedName",
          String
"parens"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"QualifiedName"],

      forall {m}. String -> Type m -> Element m
def String
"NamePart" -- UNamePart
        forall m. Type m
string,

      forall {m}. String -> Type m -> Element m
def String
"Operator" forall a b. (a -> b) -> a -> b
$ -- UOperator
        forall m. [FieldType m] -> Type m
union [
          String
"backtick"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"QualifiedName",
          String
"normal"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"QualifiedName"],

      forall {m}. String -> Type m -> Element m
def String
"Pattern" forall a b. (a -> b) -> a -> b
$ -- UPattern
        -- omitted for now: unboxed tuples, parallel arrays, irrefutable, bang, view, splice, quasiquote, plusk, unboxed sum
        forall m. [FieldType m] -> Type m
union [
          String
"application"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Pattern.Application",
          String
"as"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Pattern.As",
          String
"list"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Pattern",
          String
"literal"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Literal",
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"parens"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Pattern",
          String
"record"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Pattern.Record",
          String
"tuple"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Pattern",
          String
"typed"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Pattern.Typed",
          String
"wildcard"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

      forall {m}. String -> Type m -> Element m
def String
"Pattern.Application" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"args"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Pattern"],

      forall {m}. String -> Type m -> Element m
def String
"Pattern.As" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"inner"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Pattern"],

      forall {m}. String -> Type m -> Element m
def String
"Pattern.Record" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"fields"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"PatternField"],

      forall {m}. String -> Type m -> Element m
def String
"Pattern.Typed" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"inner"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Pattern",
          String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type"],

      forall {m}. String -> Type m -> Element m
def String
"PatternField" forall a b. (a -> b) -> a -> b
$ -- UPatternField
        -- omitted for now: puns, wildcards
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"pattern"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Pattern"],

      forall {m}. String -> Type m -> Element m
def String
"QualifiedName" forall a b. (a -> b) -> a -> b
$ -- UQualifiedName
        forall m. [FieldType m] -> Type m
record [
          String
"qualifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"NamePart",
          String
"unqualified"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"NamePart"],

      forall {m}. String -> Type m -> Element m
def String
"RightHandSide" forall a b. (a -> b) -> a -> b
$ -- URhs
        -- omitted for now: guarded rhs
        forall {m}. String -> Type m
ast String
"Expression",

      forall {m}. String -> Type m -> Element m
def String
"Statement" forall a b. (a -> b) -> a -> b
$ -- UStmt
        forall {m}. String -> Type m
ast String
"Expression",

      forall {m}. String -> Type m -> Element m
def String
"Type" forall a b. (a -> b) -> a -> b
$ -- UType
        -- omitted for now: forall, ctx, unboxed tuple, parallel array, kinded, promoted, splice, quasiquote, bang,
        --                  lazy, unpack, nounpack, wildcard, named wildcard, sum
        forall m. [FieldType m] -> Type m
union [
          String
"application"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type.Application",
          String
"function"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type.Function",
          String
"infix"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type.Infix",
          String
"list"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type",
          String
"parens"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type",
          String
"tuple"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"Type",
          String
"variable"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name"],

      forall {m}. String -> Type m -> Element m
def String
"Type.Application" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"context"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type",
          String
"argument"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type"],

      forall {m}. String -> Type m -> Element m
def String
"Type.Function" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"domain"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type",
          String
"codomain"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type"],

      forall {m}. String -> Type m -> Element m
def String
"Type.Infix" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type",
          String
"operator"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Operator",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Operator"],

      forall {m}. String -> Type m -> Element m
def String
"TypeDeclaration" forall a b. (a -> b) -> a -> b
$ -- UTypeDecl
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"DeclarationHead",
          String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type"],

      forall {m}. String -> Type m -> Element m
def String
"TypeSignature" forall a b. (a -> b) -> a -> b
$ -- UTypeSignature
        forall m. [FieldType m] -> Type m
record [
          String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Name",
          String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Type"],

      forall {m}. String -> Type m -> Element m
def String
"TypedBinding" forall a b. (a -> b) -> a -> b
$ -- Added for convenience
        forall m. [FieldType m] -> Type m
record [
          String
"typeSignature"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"TypeSignature",
          String
"valueBinding"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"ValueBinding"],

      forall {m}. String -> Type m -> Element m
def String
"ValueBinding" forall a b. (a -> b) -> a -> b
$ -- UValueBind
        -- omitted for now: funBind
        forall m. [FieldType m] -> Type m
union [
          String
"simple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"ValueBinding.Simple"],

      forall {m}. String -> Type m -> Element m
def String
"ValueBinding.Simple" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"pattern"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"Pattern",
          String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
ast String
"RightHandSide",
          String
"localBindings"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
ast String
"LocalBindings"],

      forall {m}. String -> Type m -> Element m
def String
"Variable" forall a b. (a -> b) -> a -> b
$
        -- omitted for now: kind constraints
        forall {m}. String -> Type m
ast String
"Name"]