elm concept: writing a shell with elm

ImperativeShell.elm

-- if elm was imperative

import Console
import Proc


type alias Model =
    { prompt : String
    }


initModel : Model
initModel =
    { prompt = "\n$ "
    }


getCmd : String -> List String
getCmd prompt =
    Console.input prompt
        |> String.split " "


main : Model -> Int
main model =
    case getCmd of
        [ "setprompt", newPrompt ] ->
            main { model | prompt = newPrompt }
        
        [ "exit" ] ->
            0
        
        args ->
            Proc.run ( \_ -> main model ) args


main initModel

Shell.elm

-- work in progress
port module Shell exposing ( main )

import Gp
import Gp.Cmd
import Gp.Sub
import Gp.Proc
import Gp.Console


port portOut : Gp.PortOut
port portIn : Gp.PortIn


main : Gp.Program Model Msg
main =
    Gp.program
        { init = init
        , update = update
        , subscriptions = subscriptions
        , portIn = portIn
        , portOut = portOut
        }


type alias Model =
    { prompt : String
    }


type Msg
    = ProcFinished Gp.Proc.FinishedProc
    | GetCmd
    | TypedCmd String


init : Gp.Flags -> ( Model, Gp.Cmd Msg )
init _ =
    ( { prompt = "\n$ " }
    , Gp.trigger GetCmd
    )


update : Msg -> Model -> ( Model, Gp.Cmd Msg )
update msg model =
    case msg of
        GetCmd ->
            ( model
            , Gp.Conosle.input TypedCmd model.prompt
            )
        
        TypedCmd command ->
            case String.split " " command of
                [ "setprompt", newPrompt ] ->
                    ( { model | prompt = newPrompt }
                    , Gp.Cmd.trigger GetCmd
                    )
                
                [ "exit" ] ->
                    ( model
                    , Gp.exit 0
                    )
                
                args ->
                    ( model
                    , Gp.Proc.run ProcFinished args
                    )
        
        ProcFinished { exitCode } ->
            ( model
            , Gp.Cmd.sequence
                [ Gp.Console.print <| "Command exited with code " ++ exitCode
                , Gp.Cmd.trigger GetCmd
                ]
            )


subscriptions : Model -> Gp.Sub Msg
subscriptions _ =
    Gp.Sub.none