Between the move and the election and the holidays, took me a long time to finish this chapter.
But I’m glad I did, because Elm is – dare I say – fun?
The error messages are fantastic. The syntax feels like Haskell without being as obtuse. Even the package management system just feels nice.
A sign of how much I liked working in Elm: the examples for Day Two and Three of the book were written for Elm 0.14, using a concept called signals. Unfortunately, signals were completely removed in Elm 0.17 (!). So to get the book examples working in Elm 0.18, I had to basically rebuild them. Which meant spending a lot of time with the (admittedly great) Elm tutorial and trial-and-erroring things until they worked again.
None of which I minded because, well, Elm is a great language to work in.
Here’s the results of my efforts:
And here's what I learned:Day One
- haskell-inspired
- elm-installer: damn, that was easy
- it's got a repl!
- emacs mode also
- types come back with all the values (expression results)
- holy sh*t: "Maybe you forgot some parentheses? Or a comma?"
- omg: "Hint: All elements should be the same type of value so that we can iterate through the list without running into unexpected values."
- type inferred: don't have to explicitly declare the type of every variable
- polymorphism via type classes
- single-assignment, but the repl is a little looser
- pipe syntax for if statement in book is gone in elm 0.17
- case statement allows pattern matching
- case statement needs the newlines, even in the repl (use `\`)
- can build own complex data types (but not type classes)
- case also needs indentation to work (especially if using result for assignment in the repl)
- records: abstract types for people without beards
- changing records: use `=` instead of `<-`: { blackQueen | color = White }
- records look like they're immutable now, when they weren't before? code altering them in day one doesn't work
- parens around function calls are optional
- infers types of function parameters
- both left and right (!) function composition <| and |>
- got map and filter based off the List type (?)
- no special syntax for defining a function versus a regular variable, just set a name equal to the function body (with the function args before the equal sign)
- head::tail pattern matching in function definition no longer works; elm is now stricter about requiring you to define all the possible inputs, including the empty list
- elm is a curried language (!)
- no reduce: foldr or foldl
- have to paren the infix functions to use in foldr: List.foldr (*) 1 list
- hard exercise seems to depend on elm being looser than it is; afaict, it won't let you pass in a list of records with differing fields (type volation), nor will it let you try to access a field that isn't there (another type violation)
Day Two
- section is built around signals, which were removed in Elm 0.17 (!)
- elm has actually deliberately moved away from FRP as a paradigm
- looks like will need to completely rewrite the sample code for each one as we go...thankfully, there's good examples in the elm docs (whew!)
- [check gists for rewritten code]
- module elm-lang/keyboard isn't imported in the elm online editor by default anymore
Day Three
- can fix the errors from loading Collage and Element into main by using toHtml method of the Collage object
- elm-reactor will give you a hot-updated project listening on port 8000 (so, refresh web page of localhost:8000 and get updated view of what your project looks like)
- error messages are very descriptive, can work through upgrading a project just by following along (and refreshing alot)
- critical to getting game working: https://ohanhi.github.io/base-for-game-elm-017.html (multiple subscriptions)
