Step

A Step model msg a describes one state transition of an application, and is inteneded to be what gets returned from an update function.

It's helpful to look at how a Step is (roughly) represented under the hood

type Step model msg a
    = To model (Cmd msg)
    | Exit a
    | Stay

We provide a constructor for each of these options, but we hide the internal representation to make sure you're combining steps in principled ways.

That being said, if you find something that makes you want the data structure fully exposed, let me know what the use case is!

Transition to a new state, without executing any commands

Keep the interaction in the state it was in.

NOTE: This will prevent any commands from being returned

Step.stay == (Step.stay |> Step.withCmd myHttpCall)

If you want to stay in the same state, but run some commands, use Step.to explicitly

Step.to MySameState |> Step.withCmd myHttpCall

End the interaction by returning a value of type a

If we're stepping to a new state, add an command to fire off

This can be called on a step multiple times, and all the commands will fire.

No commands are fired if the Step turns out to be a stay or an exit

A helper for building steps out of tasks

Apply a function to the state inside a step, if it's there

Most useful in building a bigger step out of a sub-step you happen to have lying around

Apply a function to any msgs conteined in the step

Also used for building larger interaction steps out of smaller ones

Map over the output of an interaction, if we've reached the end

Run the first suceeding step, with priority given to the second argument

Intended to be used pipeline style

Step.to { loading = True } |> Step.orElse (Step.to { loading = False }) == Step.to { loading = True }


Step.noop |> Step.orElse Step.to { loading = True } == Step.to { loading = True }

Choose a step based on the result of another interaction

You can use this in combination with map and mapMsg to glue the end of one interaction to the beginning of another.

Notice that it looks a lot like Maybe.andThen and Maybe.result, but operating on the last type variable.

Turn a Step into the usual TEA update tuple

It must be a step in an interaction that continues forever. We know it is if the type variable o isn't a specifc type, and can thus be chosen to be Never

turn an update function that returns a Step to a normal Elm Architecture update function

uses run internally to default with the provided model in case of a stay

Build a step from a normal elm update tuple

Step to the state denoted by the model in the Just case, and stay otherwise

starting from an initial state, fold an update function over a list of messages