Enables you to initialize multiple submodules that cannot send effects.

let
    ( subModule, initSubModule ) =
        SubModule.init
            |> SubModule.init SubModuleMsg


    ( subModule2, initSubModule2 ) =
        SubModule2.init
            |> SubModule.init
                { toMsg = SubModule2Msg
                }
in
( { subModule = subModule, subModule2 = subModule2 }, Cmd.none )
    |> initSubModule
    |> initSubModule2

This only exists so you can use a similar strategy across modules that do and don't send effects. If you're only working with modules that don't you could just use this strategy:

let
    ( subModule, subModuleCmd ) =
        SubModule.init
            |> Tuple.mapSecond (Cmd.map SubModuleMsg)


    ( subModule2, subModule2Cmd ) =
        SubModule2.init
            |> Tuple.mapSecond (Cmd.map SubModule2Msg)
in
( { subModule = subModule, subModule2 = subModule2 }
, Cmd.batch [ subModuleCmd, subModule2Cmd ]
)

Enables you to initialize submodules that can send effects.

let
    -- This submodule can't send effects
    ( subModule, initSubModule ) =
        SubModule.init
            |> SubModule.init
                { toMsg = GotSubMsg
                }


    -- But this one can!
    ( subModule2, initSubModule2 ) =
        SubModule2.init
            |> SubModule.initWithEffect
                { toMsg = GotSubMsg2
                , effectToMsg = GotSubEffect2
                }
in
( { subModule = subModule
  , subModule2 = subModule2
  }
, Cmd.none
)
    |> initSubModule
    |> initSubModule2

Enables you to handle the updates of submodules that cannot send effects.

type Msg
    = GotSubMsg SubWidget.Msg
    | ...


update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        GotSubMsg subMsg ->
            SubModule.update subMsg model.subModule
                |> SubModule.update
                    { toMsg = GotSubMsg
                    , toModel = \subModule -> { model | subModule = subModule }
                    }
        ...

This only exists so you can use a similar strategy across modules that do and don't send effects. If you're only working with modules that don't you could just use this strategy:

update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        GotSubMsg subMsg ->
            SubModule.update subMsg model.subModule
                |> SubModule.update
                    |> Tuple.mapFirst \subModule -> { model | subModule = subModule }
                    |> Tuple.mapSecond (Cmd.map GotSubMsg)
        ...

Enables you to handle the updates of submodules that can send effects.

type Msg
    = GotSubMsg SubWidget.Msg
    | GotSubEffect SubWidget.Effect


update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        GotSubMsg subMsg ->
            SubWidget.update subMsg model.subModel
                |> SubWidget.updateWithEffect
                    { toMsg = GotSubMsg
                    , effectToMsg = GotSubEffect
                    , toModel =
                        \subModel -> { model | subModel = subModel }
                    }


        GotSubEffect subEffect ->
            case subEffect of
                SubWidget.SendValue value ->
                    ( { model | subValue = Just value }
                    , Cmd.none
                    )