You may run into situations where you want to generate a function, and then call that generated function somewhere else.

This module will help you do that.

Here's an example, let's define a new function called add42

import Elm.Arg as Arg
import Elm.Declare as Declare


renderFile =
    let
        add42 =
            Declare.fn "add42"
                (Arg.value "firstInt")
                (\firstArgument ->
                    Elm.plus
                        (Elm.int 42)
                        firstArgument
                )
    in
    Elm.file [ "MyFile" ]
        -- add our declaration to our file
        [ add42.declaration


        -- and another place where we call that function!
        , Elm.declaration "mySweetNumber"
            (add42.call (Elm.int 82))
        ]

Virtual Modules

It's very common to have some modules that you both need to generate and use in your generated Elm code.

Here's an example, let's define a new module called MyModule:

import Elm
import Elm.Annotation
import Elm.Declare
import Elm.Op


type alias MyModule =
    { runCalculation : Elm.Expression -> Elm.Expression
    , myType : Elm.Annotation.Annotation
    }


myModule =
    Elm.Declare.module_ [ "MyModule" ] MyModule
        |> Elm.Declare.with
            (Elm.Declare.fn "runCalculation"
                (Elm.Arg.var "input")
                (\input -> Elm.Op.plus input (Elm.int 42))
            )
        |> Elm.Declare.with
            (Elm.Declare.customType "MyType"
                [ Elm.variant "One"
                , Elm.variant "Two"
                ]
            )

Once we've declared our module, we can do 2 things.

First, we can generate the Elm code for the module:

Elm.toFile myModule

Or we can include it in another module:

Elm.file [ "MyInternalFile" ]
    [ Elm.include myModule


    --... Whatever other declarations you want in this file.
    ]

Secondly, we can use the virtual module in our Elm code:

myModule.call.runCalculation (Elm.int 42)

Which will generate

MyModule.runCalculation 42

And handle the imports and everything.

Advanced Custom Types

In some cases you may want to generate a custom type and also have some helpers to

1. Create an instance of that type
2. Pattern match on that type

customTypeAdvanced is a helper function that will let you do that!

But it does get a little involved, so if you don't need it, trying something simpler may be the way to go.

As an example, here's how to create a helper for the Maybe type.

maybe =
    Elm.Declare.customTypeAdvanced "Maybe"
        { exposeConstructor = True }
        (\nothing just ->
            { nothing = nothing
            , just = just
            }
        )
        |> Elm.Declare.variant0 "Nothing" .nothing
        |> Elm.Declare.variant1 "Just" (Elm.Annotation.var "a") .just
        |> Elm.Declare.finishCustomType


-- Which then allows you to create an instance of the type via
maybe.make_.just (Elm.int 42)
-- Which would generate `Just 42`


-- And if you want to use it as a case expression, you can do this:


maybe.case_ (Elm.val "a")
    { just = \a -> a
    , nothing = Elm.string ""
    }


-- Which would generate
case a of
   Just a -> a
   Nothing -> ""

Advanced records

You can use these functions to declare a record type alias and to also get a constructor for it.

point =
    Elm.Declare.record "Point"
        |> Elm.Declare.withField "x" .x Elm.Annotation.float
        |> Elm.Declare.withField "y" .y Elm.Annotation.float
        |> Elm.Declare.buildRecord


p =
    point.make
        { x = Elm.float 0
        , y = Elm.float y
        }

This gives you compile time guarantees for the field names being correct.

Internal things