Elm guideやりながらメモ

"butter" ++ "fly"

> "a" + "i"
-- TYPE MISMATCH --------------------------------------------------------- /repl

I cannot do addition with String values like this one:

3|   "a" + "i"
     ^^^
The (+) operator only works with Int and Float values.

Hint: Switch to the (++) operator to append strings!

> 'a' ++ 'i'
-- TYPE MISMATCH --------------------------------------------------------- /repl

The (++) operator cannot append this type of value:

3|   'a' ++ 'i'
     ^^^
I am seeing a character of type:

    Char

But the (++) operator is only for appending List and String values. Maybe put
this value in [] to make it a list?

Hint: I only know how to append strings and lists.

3002 + 4004 == 7006  -- all ints
3.14 + 3.14 == 6.28  -- all floats

List.map (modBy 4) [ -5, -4, -3, -2, -1,  0,  1,  2,  3,  4,  5 ]
--                 [  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1 ]

func param = 処理

// JavaScript
madlib("cat", "ergonomic")
madlib("butter" + "fly", "metallic")

-- Elm
madlib "cat" "ergonomic"
madlib ("butter" ++ "fly") "metallic"

if name == "Abraham Lincoln" then
  "Greetings Mr.President!"
else
  "Hey!"

names = ["Alice", "Bob", "Chuck"]

List.isEmpty names
-- False

List.length names
-- 3

List.reverse names
-- ["Chuck", "Bob", "Alice"]

numbers = [4, 3, 2, 1]

List.sort numbers
-- [1, 2, 3, 4]

increment n = n + 1
List.map increment numbers
-- [5, 4, 3, 2]

isGoodName name =
  if String.length name <= 20 then
    (True, "name accepted")
  else
    (False, "name was too long; please limit it to 20 characters")

john =
  { first = "John"
  , last = "Hobson"
  , age = 81
  }

john.last
-- "Hobson"

.last john
-- "Hobson"

List.map .last [john, john, john]
-- ["Hobson", "Hobson", "Hobson"]

{ john | last = "Adams" }
-- { age = 81, first = "John", last = "Adams" }

{ john | age = 22 }
-- { age = 22, first = "John", last = "Hobson" }

celebrateBirthday person =
 { person | age = person.age + 1 }

celebrateBirthday john
-- { age = 82, first = "John", last = "Hobson" }

celebrateBirthday : { a | age : number } -> { a | age : number }
celebrateBirthday person =
 { person | age = person.age + 1 }

main =
  Browser.sandbox { init = init, update = update, view = view }

view : Model -> Html Msg

view : Model -> Html Msg
view model =
  div []
    [ input [ placeholder "Text to reverse", value model.content, onInput Change ] []
    , div [] [ text (String.reverse model.content) ]
    , div [] [ text (String.fromInt (String.length model.content)) ]
    ]

view : Model -> Html Msg
view model =
  div []
    [ input [ placeholder "Text to reverse", value model.content, onInput Change ] []
    , div [] [ text (String.reverse model.content) ]
    , div [] [ text (model.content |> String.length |> String.fromInt) ]
    ]

type UserStatus = Regular | Visitor

type UserStatus
  = Regular
  | Visitor

type alias User =
  { status : UserStatus
  , name : String
  }

thomas = { status = Regular, name = "Thomas" }
kate95 = { status = Visitor, name = "kate95" }

type User
  = Regular String
  | Visitor String

thomas = Regular "Thomas"
kate95 = Visitor "kate95"

-- 「Userを受け取ってStringを返す方である」と型注釈をつける
toName: User -> String
-- 実装
toName user =
  case user of
    -- UserはRegular String Int | Visitor Stringと定義されているので、そのパターンを書く
    Regular name age ->
      name

    Visitor name ->
      name

type alias Model =
  { name: String
  , password: String
  , passwordAgain: String
  }

update: Msg -> Model -> Model

type Msg
  = Name String
  | Password String
  | PasswordAgain String

-- msgとmodelを受け取る（actionとstateを受け取るreducerっぽい）
update msg model =
  case msg of
    -- String型の「関連するデータ」にnameと名前をつけている
    Name name ->
      -- modelの中のnameだけ替えたものを返す
      { model | name =name }
    Password password ->
      { model | password = password }
    PasswordAgain password ->
      { model | passwordAgain = password }

viewInput : String -> String -> String -> (String -> msg) -> Html msg
viewInput t p v toMsg =
  input [ type_ t, placeholder p, value v, onInput toMsg ] []

viewValidation : Model -> Html msg
viewValidation model =
  if model.password == model.passwordAgain then
    div [ style "color" "green" ] [ text "OK" ]
  else
    div [ style "color" "red"] [ text "Password do not match!" ]

viewValidation : Model -> Html msg
viewValidation model =
  if model.password == model.passwordAgain then
    if String.length(model.password) > 8 then
      div [ style "color" "green" ] [ text "OK" ]
    else
      div [ style "color" "red" ] [ text "Passwords must be more than 8 characters!" ]
  else
    div [ style "color" "red" ] [ text "Passwords do not match!" ]

viewValidation : Model -> Html msg
viewValidation model =
  div []
    [ if not ( isSameString model )
      then div [ style "color" "red" ] [ text "Passwords do not match!" ]
      else div [] []
    , if not ( isStringMoreThanEight model )
      then div [ style "color" "red" ] [ text "Passwords must be more than 8 characters!" ]
      else div [] []
    , if isSameString model && isStringMoreThanEight model
      then div [ style "color" "green" ] [ text "OK" ]
      else div [] []
    ]

isSameString : Model -> Bool
isSameString model =
  model.password == model.passwordAgain

isStringMoreThanEight : Model -> Bool
isStringMoreThanEight model =
  String.length(model.password) > 8

type User
  = Regular String Int
  | Visitor String

type MaybeAge
  = Age Int
  | InvalidInput

toAge : String -> MayAge

type MaybePost
  = Post { title: String, content: String }
  | NotTitle
  | NoContent

toPost : String -> String -> MaybePost

type alias Friend =
  { name : String
  , hieght : Maybe Float
  , weight : Maybe Float
  }

type Friend
  = Less String
  | More String Info

type alias Info =
  { age : Int
  , height : Float
  , weight : Float
  }

I am partway through parsing a custom type, but I got stuck here:

25| type Model =
26|   { name : String
      ^
I was expecting to see a variant name next. Something like Success or Sandwich.
Any name that starts with a capital letter really!

Note: Here is an example of a valid `type` declaration for reference:

    type Status
      = Failure
      | Waiting
      | Success String

This defines a new `Status` type with three variants. This could be useful if we
are waiting for an HTTP request. Maybe we start with `Waiting` and then switch
to `Failure` or `Success "message from server"` depending on how things go.
Notice that the Success variant has some associated data, allowing us to store a
String if the request goes well!

isReasonableAge : String -> Result String Int
isReasonableAge input =
  case String.toInt input of
    Nothing ->
      Err "That is not a number"

    Just age ->
      if age < 0 then
        Err "Please try again after you are born."

      else if age > 135 then
        Err "Are you some kind of turtle?"

      else
        Ok age

type Result error value
  = Ok value
  | Err error

init : () -> (Model, Cmd Msg)
init _ =
  ( Loading
  , Http.get
    { url = "https://elm-lang.org/assets/public-opinion.txt"
    , expect = Http.expectString GotText
    }
  )