Elm communication

Child1.elm

module Child1 exposing (Msg(..), Model, init, update)

import WebData exposing (..)


type Msg
    = Response (WebData (List String))


type alias Model =
    { data : WebData (List String) }


init : ( Model, Cmd Msg )
init =
    ( { data = NotAsked }, Cmd.none )


update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        Response data ->
            ( { model | data = data }, Cmd.none )

Child2.elm

module Child2 exposing (Model, init, updateData)

import WebData exposing (..)


type alias Model =
    { data : WebData (List String) }


init : ( Model, Cmd a )
init =
    ( { data = NotAsked }, Cmd.none )


updateData : WebData (List String) -> Model -> ( Model, Cmd a )
updateData data model =
    ( { model | data = data }, Cmd.none )

Main.elm

module Main exposing (..)

import Child1
import Child2
import Html exposing (..)
import Process
import Task
import Time
import WebData exposing (..)


type Msg
    = Response (WebData (List String))
    | Child1Msg Child1.Msg


type alias Model =
    { data : WebData (List String)
    , child1 : Child1.Model
    , child2 : Child2.Model
    }


init : ( Model, Cmd Msg )
init =
    let
        ( child1, child1Cmd ) =
            Child1.init

        ( child2, child2Cmd ) =
            Child2.init

        cmd =
            -- Simulate latency
            Process.sleep (2 * Time.second)
                |> Task.andThen (\_ -> Task.succeed [ "foo", "bar" ])
                |> Task.perform (\list -> Response (Success list))
    in
        ( { data = NotAsked
          , child1 = child1
          , child2 = child2
          }
        , Cmd.batch
            [ Cmd.map Child1Msg child1Cmd
            , child2Cmd
            , cmd
            ]
        )


update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        Response data ->
            let
                ( child1, child1Cmd ) =
                    Child1.update (Child1.Response data) model.child1

                ( child2, child2Cmd ) =
                    Child2.updateData data model.child2
            in
                ( { model | data = data, child1 = child1, child2 = child2 }
                , Cmd.batch
                    [ Cmd.map Child1Msg child1Cmd
                    , child2Cmd
                    ]
                )

        Child1Msg msg ->
            let
                ( child1, child1Cmd ) =
                    Child1.update msg model.child1
            in
                ( { model | child1 = child1 }, Cmd.map Child1Msg child1Cmd )


view : Model -> Html Msg
view model =
    pre [] [ text <| toString <| model ]


main : Program Never Model Msg
main =
    Html.program
        { init = init
        , update = update
        , view = view
        , subscriptions = always Sub.none
        }

WebData.elm

module WebData exposing (..)


type WebData a
    = NotAsked
    | Success a