Elm.Arg

An Arg can be used to pattern match on the arguments of a function.

let
    args =
        Elm.Arg.tuple (Arg.var "first") (Arg.var "second")
in
Elm.fn args
    (\( first, second ) ->
        Elm.record
            [ ( "first", first )
            , ( "second", second )
            ]
    )

Will generate

\( first, second ) ->
    { first = first
    , second = second
    }

Or they can be used to unpack values in the branch of a case expression.

Elm.Case.custom (Elm.val "myVar") (Elm.Annotation.named [] "MyCustomType)
    [ Elm.branch "MyCustomType" (Arg.tuple (Arg.var "first") (Arg.var "second"))
        (\( first, second ) ->
            Elm.record
                [ ( "first", first )
                , ( "second", second )
                ]
        )
    ]

Will generate

  case myVar of
      MyCustomType first second ->
          { first = first
          , second = second
          }

unit : Arg Expression

An empty tuple () is generally called "unit".

var : String -> Arg Expression

varWith : String -> Annotation -> Arg Expression

tuple : Arg one -> Arg two -> Arg ( one, two )

triple : Arg one -> Arg two -> Arg three -> Arg ( one, two, three )

record : fields -> Arg fields

Unpack record fields.

let
    args =
        Elm.Arg.record
            |> Elm.Arg.field "first" (Arg.var "first")
            |> Elm.Arg.field "second" (Arg.var "second")
in
Elm.fn args
    (\{ first, second } ->
        Elm.record
            [ ( "first", first )
            , ( "second", second )
            ]
    )

Would generate

\{ first, second } ->
    { first = first
    , second = second
    }

field : String -> Arg (Expression -> a) -> Arg a

aliasAs : String -> Arg arg -> Arg ( arg, Expression )

Unpack a pattern, but keep a reference to the original value.

let
    args =
        Elm.Arg.customType "MyCustomType" Tuple.pair
            |> Elm.Arg.item (Arg.var "first")
            |> Elm.Arg.item (Arg.var "second")
            |> Elm.Arg.aliasAs "myAlias"
in
Elm.fn args
    (\( ( first, second ), myAlias ) ->
        Elm.record
            [ ( "first", first )
            , ( "second", second )
            , ( "myAlias", myAlias )
            ]
    )

Will generate

\((MyCustomType first second) as myAlias) ->
    { first = first
    , second = second
    , myAlias = myAlias
    }

Useful for case expressions

ignore : Arg Expression

Will generate _ to ignore an argument or pattern.

string : String -> Arg Expression

char : Char -> Arg Expression

list : a -> Arg a

Arg.list Tuple.pair
    |> Arg.item (Arg.var "first")
    |> Arg.item (Arg.var "second")

Will genrate

[ first, second ]

And

 Arg.list
    (\one two remaining ->
        { one = one
        , two = two
        , remaining = remaining
        }
    )
    |> Arg.item (Arg.var "first")
    |> Arg.item (Arg.var "second")
    |> Arg.listRemaining "remaining"

Will generate

first :: second :: remaining

item : Arg arg -> Arg (arg -> a) -> Arg a

items : List (Arg arg) -> Arg (List arg -> a) -> Arg a

This is for the situation where you only know the number of arguments when you run the generator.

This isn't super common.

listRemaining : String -> Arg (Expression -> a) -> Arg a

customType : String -> a -> Arg a

Let's say you have a custom type like

type MyCustomType
    = MyCustomType String Int

And you want to extract the String and Int

let
    args =
        Elm.Arg.customType "MyCustomType" Tuple.pair
            |> Elm.Arg.item (Arg.var "first")
            |> Elm.Arg.item (Arg.var "second")
in
Elm.fn args
    (\( first, second ) ->
        Elm.record
            [ ( "first", first )
            , ( "second", second )
            ]
    )

Which will generate

\(MyCustomType first second) ->
    { first = first
    , second = second
    }

mdgriffith/elm-codegen/5.0.0

Elm.Arg

Useful for case expressions

Modules