Infer types of value/Elm.Syntax.Expression.Function declarations in a module.

import Elm.Syntax.Node
import Elm.Syntax.Expression
import ElmSyntaxTypeInfer




[ { declaration =
        Elm.Syntax.Node.empty
            { name = Elm.Syntax.Node.empty "hello"
            , expression =
                Elm.Syntax.Node.empty
                    (Elm.Syntax.Expression.Literal "world")
            , arguments = []
            }
  , signature = Nothing
  , documentation = Nothing
  }
]
    |> ElmSyntaxTypeInfer.valueAndFunctionDeclarations
        { importedTypes = ElmSyntaxTypeInfer.elmCoreTypes
        , moduleOriginLookup = exampleModuleOriginLookup
        , otherModuleDeclaredTypes =
            []
                |> ElmSyntaxTypeInfer.moduleDeclarationsToTypes
                    exampleModuleOriginLookup
                |> .types
        }
-->
Ok
    (FastDict.singleton "hello"
        { type_ =
            ElmSyntaxTypeInfer.TypeNotVariable
                (ElmSyntaxTypeInfer.TypeConstruct
                    { moduleOrigin = [ "String" ], name = "String", arguments = [] }
                )
        ...
        }
    )




exampleModuleOriginLookup : ElmSyntaxTypeInfer.ModuleOriginLookup
exampleModuleOriginLookup =
    []
        |> ElmSyntaxTypeInfer.importsToModuleOriginLookup
            ElmSyntaxTypeInfer.elmCoreTypes

See ModuleTypes and ModuleOriginLookup

Warning! Always first verify that provided type alias declarations aren't (mutually) recursive. Otherwise this function might never terminate.

Known types of members in a module. Create with moduleDeclarationsToTypes and moduleInterfaceToTypes

ModuleTypes exposed in elm/core.

Please always start with elmCoreTypes and add further module info with FastDict.union using moduleDeclarationsToTypes and moduleInterfaceToTypes

And if for some reason you already know used dependencies at compile time, you can re-use the code generator used for these elm/core types

Extract all known types from declarations within a module. Un-annotated value/function declarations are ignored.

For dependency modules, use moduleInterfaceToTypes

Extract all known types from module metadata, usually from parsing the docs.json of a dependency.

For elm-syntax modules, use moduleDeclarationsToTypes

How to map names and symbols used in a module to their origin module. Create with importsToModuleOriginLookup.

Contains variants, type alias names, choice type names, port names, value/function declaration names and whether (|.) and or (|=) are imported from Parser.Advanced.

Also contains locally declared names when available.

Type- and expression/pattern-level members are separated since you can for example have a local List variant while also using an (implicitly) imported List type.

Calculate valid mappings of qualifications + name to origin module based on a module's imports.

Requires all exposed ModuleTypes so we can resolve exposing (..) and ChoiceType(..).

A part in the syntax tree with an attached

• range in the source
• global Type: concretely inferred, influenced by other branches and value/function (let) declaration type annotations

Since type is a parameter, you can fill it with any representation like Elm.Syntax.TypeAnnotation.TypeAnnotation

Like Elm.Syntax.Expression.Expression but its sub-nodes are TypedNodes

Like Elm.Syntax.Expression.LetDeclaration but its sub-nodes are TypedNodes

Like Elm.Syntax.Pattern.Pattern but all its sub-nodes are TypedNodes

Either decimal or hexadecimal. Used by PatternInt and ExpressionInteger

Type information attached to expressions and patterns, see TypedNode.

This is different from Elm.Syntax.TypeAnnotation.TypeAnnotation in that it doesn't contain information unrelated to type inference like ranges, qualification levels or parens.

Type except the variable case