Return.elm

module Return exposing
    ( Return
    , map
    , return
    , toTuple
    , withCommand
    , withTask
    )

import Http
import Task exposing (Task)


type alias Return model msg =
    { model : model
    , effects : List (Effect msg)
    }


type Effect msg
    = EffectTask (Task Http.Error msg)
    | EffectCmd (Cmd msg)


return : model -> Return model msg
return model =
    { model = model, effects = [] }


withTask : Task Http.Error msg -> Return model msg -> Return model msg
withTask task ret =
    { ret | effects = ret.effects ++ [ EffectTask task ] }


withCommand : Cmd msg -> Return model msg -> Return model msg
withCommand cmd ret =
    { ret | effects = ret.effects ++ [ EffectCmd cmd ] }
    

toTuple :
    (model -> parentModel)
    -> (Http.Error -> parentMsg)
    -> (msg -> parentMsg)
    -> Return model msg
    -> ( parentModel, Cmd parentMsg )
toTuple transformModel transformError transformMsg return =
    ( transformModel return.model
    , Cmd.batch
        (return.effects
            |> List.map
                (\effect ->
                    case effect of
                        EffectTask task ->
                            Task.attempt
                                (\result ->
                                    case result of
                                        Ok msg ->
                                            transformMsg msg

                                        Err e ->
                                            transformError e
                                )
                                task

                        EffectCmd cmd ->
                            Cmd.map transformMsg cmd
                )
        )
    )


map : (a -> b) -> Return a msg -> Return b msg
map f r =
    { r | model = f r.model }