Posted by Trouble (::)entrating on Mon, 02/29/2016 - 03:33

I’ve just released elm-http-extra 5.0.0, and along with the links I wanted to
share the reasons for the changes and discuss some of the challenges that I
faced addressing them.

A huge thank you to Fred Yankowski for using
elm-http-extra, finding a serious flaw in the design, talking through
it with me on the Elm Slack, and
generally being an awesome member of the Elm community!

The problem

Prior to this release, Http.Extra.send accepted three arguments: a
Json.Decode.Decoder for the value expected on success, another
Json.Decode.Decoder for the value expected on server error, and a
RequestBuilder to pipe with (|>) and kick off the request. (For more
information on this API design, see Chainable APIs with the forward apply operator). This is a significant
improvement over elm-http because it lets you deal with the body of a response
in the case of a server error. You might be dealing with an API that returns an
object like the following on error:

"message": "There was an error",
"status": 500,
"success": false

With elm-http the process for accessing this data as a record is fairly
laborious, and with elm-http-extra it is easy and also required. I thought
this was a pretty clever design until Fred told me about how his API worked. On
a 404 error, his API returned the following body:

"404 page not found"

The Task failed as expected, but instead of failing with a
BadResponse String and providing access to the message, it always failed with
UnexpectedPayload and an error message "Unexpected token p”, even though
the error body was being decoded with Json.Decode.string. The problem is that
"404 page not found" is not valid JSON. "\"404 page not found\"" with the
included quotes is valid JSON. The type of value being accepted from the body
needed to be lifted one level higher.

The solution

I spent some time thinking about this and decided that the signature for send
should remain roughly the same, but include some polymorphism for how bodies are
handled. The first attempt I made was to create a tagged union which could
express either a plain text string body or a JSON body and contain a decoder:

type BodyReader a
= StringReader
| JsonReader (Json.Decode.Decoder a)

This might raise an immediate red flag in the experienced Elm programmer’s mind,
as this encoding of the transform as a union type implicitly expresses the
output type of a function on that type. Ultimately I couldn’t get a rework using
this method to compile without writing one function for each combination of
BodyReader instances for error and success cases.

So I scrapped that plan and went one step outward: generalizing the idea of what
a BodyReader does at the function level. In this case, BodyReader is just a
function interface:

type alias BodyReader a =
Http.Value -> Result String a

This interface bears a lot of resemblance to Json.Decode.decodeString, in
which a string value goes in and a Result String a comes out. Each
BodyReader is allows to take on any kind of Http.Value and optionally fail.
This has a two-fold benefit.

  1. Even though Text is the only supported Http.Value type right now, this
    generic function interface leaves room for extensibility once more values are
  2. Since we only need to write a function, readers can get even more specific
    than just accessing the string value contained by Text. jsonReader does
    this, and anyone can do the same by the output of

So there it is! Now, instead of having to pass a Json.Decode.Decoder and
always getting a parsing error, use stringReader to get a string, or continue
decoding JSON with jsonReader.

Other changes

Max Goldstein pointed out that the signature of
withHeader accepting a (String, String) added more visual noise than was
necessary. He is absolutely right, and now withHeader accepts two string, one
for the key and one for the value. See the example in the next section for a

New README example

In this example, we expect a successful response to be JSON array of strings,

["hello", "world", "this", "is", "the", "best", "json", "ever"]

and an error response might have a body which just includes text, such as the
following for a 404 error:

Not Found.

We’ll use HttpExtra.jsonReader and a Json.Decode.Decoder to parse the
successful response body and HttpExtra.stringReader to accept a string
body on error without trying to parse JSON.

import Time
import Http.Extra as HttpExtra exposing (..)
import Json.Decode as Json

itemsDecoder : Json.Decoder (List String)
itemsDecoder =
Json.list Json.string

addItem : String -> Task (HttpExtra.Error String) (HttpExtra.Response (List String))
addItem item = ""
|> withBody (Http.string "{ \"item\": \"" ++ item ++ "\" }")
|> withHeader "Content-Type" "application/json"
|> withTimeout (10 * Time.second)
|> withCredentials
|> send (jsonReader itemsDecoder) stringReader

Contributing to elm-http-extra

I’m always happy to receive any feedback and ideas about additional features or
anything at all! Any input and pull requests are very welcome and encouraged. If
you’d like to help or have ideas, get in touch with me at @luke_dot_js on
or @luke in the Elm Slack!

Posted by Trouble (::)entrating on Sat, 02/27/2016 - 19:36

The (|>) operator is, in my opinion, one of the most elegant features of the
Elm language. It lets us read function applications in the order the actually
happen and this readability gain can have a hugely positive influence on our API
and application design. While this operator is generally useful for expressing
data transformations, it has a particularly nice fit for building large or
high-complexity configuration objects more expressively.

Consider as a primary
candidate the low-level request interface in elm-http. Let’s say we want to
send a PATCH request to a cross-origin endpoint and we need to include a
cookie for authentication and we only want to wait 5 seconds for the request to
complete. Doing so requires two configuration objects:

import Http

request : Http.Request
request =
{ verb = "PATCH"
, headers =
[ ("Origin", "")
, ("Access-Control-Request-Method", "PATCH")
, ("Content-Type", "application/json")
, url = ""
, body = Http.string (encodeItemUpdate itemUpdate)

settings : Http.Settings
settings =
{ Http.defaultSettings
| timeout = 5 * Time.second
, withCredentials = True

result : Task Http.RawError Http.Response
result =
Http.send settings request

This is a pretty obnoxious amount of work to send a request with parameters
that are not too far outside the norm. This is, of course, as it should be as
elm-http is intended to be a low-level interface to XMLHttpRequest in Elm
and not anything fancy or expressive. But as humans we want something that is
easy to read and understand. This is the intention of
elm-http-extra, and it will
serve as an excellent example of using (|>) to build configuration as needed
instead of supplying it all at once.
A roughly equivalent request using elm-http-extra looks like the following:

import Http.Extra as HttpExtra exposing (..)

result : Task (HttpExtra.Error ApiError) (HttpExtra.Response Item)
result =
HttpExtra.patch ""
|> withHeader ("Origin", "")
|> withHeader ("Access-Control-Request-Method", "PATCH")
|> withHeader ("Content-Type", "application/json")
|> withStringBody (encodeItemUpdate itemUpdate)
|> withTimeout (5 * Time.second)
|> withCredentials
|> send decodeItem decodeApiError

The advantages of the above are as follows:

  • We don’t need to know anything about the underlying configuration objects
  • We only need to learn or remember the functions which are relevant to the
    the task at hand
  • We can easily remove the final send and express the whole configuration
    building process as a separate function that is easy to test by doing
    equality comparison on the output.
  • We can combine existing operators into more high-level ones that are totally

As an example of the final point, we can extract the headers out into a separate
function that expresses the header needs of every API request and even use the
contents of the request configuration builder record to help us out:

import Http.Extra as HttpExtra exposing (..)

withApiHeaders : HttpExtra.RequestBuilder -> HttpExtra.RequestBuilder
withApiHeaders builder =
verb =
.verb (HttpExtra.toRequest builder)
|> withHeader ("Origin", "")
|> withHeader ("Access-Control-Request-Method", verb)
|> withHeader ("Content-Type", "application/json")

result : Task (HttpExtra.Error ApiError) (HttpExtra.Response Item)
result =
HttpExtra.patch ""
|> withApiHeaders
|> withStringBody (encodeItemUpdate itemUpdate)
|> withTimeout (5 * Time.second)
|> withCredentials
|> send decodeItem decodeApiError

Using the (|>) operator in this way allows us to build totally extensible DSL-
like APIs without all of the complexity of an actual DSL because everything is
just a function with a very specific type of interface. This even allows us to
abstract actual DSLs in a much nicer and easier-to-understand way. Consider
regular expressions, the confusing DSL to end them all. Using this technique
with the
package we can express a Regex using a human-readable, chainable interface.
Instead of constantly re-learning regular expressions to perform a simple task
like match a correctly formatted url, we can write the following:

import Regex exposing (Regex)
import VerbalExpressions as Verex exposing (..)

tester : Regex
tester =
|> startOfLine
|> followedBy "http"
|> possibly "s"
|> followedBy "://"
|> possibly "www."
|> anythingBut " "
|> endOfLine
|> toRegex

Every call in the pipeline above is just a function which operates on some
configuration builder which we can ultimately transform into a result which
would have been harder to obtain on its own. In the case of elm-http it was a
Task a b for the request result which took a lot of configuration, and in
this case it is a Regex which would have required a hard-to-understand
regular expression string.

Let’s try and generalize a few things about this pattern. The process of using a
chainable API with (|>) involves three stages, initialize, build, and
compile. During the initialize stage we start with generate a base object of a
particular type, called the builder. It could be a totally new record type or
a union type that wraps existing configuration types. In the case of
elm-http-extra it is a union type which holds an Http.Request and an
Http.Settings together. The value obtained during the initialize step should
always be valid for compilation straight away, which means several
initialization functions might be required.

This is the case with elm-http-extra since every request must have at least a
verb and a url. The case is much simpler with elm-verbal-expressions, since we
can start every VerbalExpression from a single base value. In this case we
just expose the one initial value and take advantage of immutability in Elm to
allow chaining from the basic case.

During the build step we make use of the (|>) operator by enforcing a specific
signature for the functions in our API. Every function must accept a builder as
its final argument and return a builder as its return value. Any additional
arguments should precede the builder. This data-last signature is a common style
in functional programming as it also makes function composition easy.

The compile step allows to actually make use of the builder. Compilation
functions can have any number of purposes, like extraction of data for testing
or actually running a Task. For example, in elm-http-extra there are three
compilation functions - toRequest, toSettings, and send. The first two
allow us to extract and inspect information from the builder whereas send
actually creates a Task. Compilation functions that do not create a Task can
be used during the build step as well since they are pure.


As the amount of configuration or mental overhead to perform a particular
operation increases it can be useful to dissociate the various components of
that configuration into a series of smaller, step-wise operations. Such an
effort is best expressed through functions that play to the strengths of the
(|>) operator. As examples, elm-http requires much configuration for many
common request cases, and regular expressions require a lot of research and
preparation to use correctly. Through the use of chainable APIs and then (|>),
elm-http-extra and elm-verbal-expressions make those processes easy to
read and maintainable. The success of this API design in these cases can be
easily applied to many similar use cases by simply following the initialize-
build-compile pattern.

Posted by on Mon, 02/15/2016 - 02:00

On Wednesday last week I flew over to London from Amsterdam to attend the newly formed Elm London’s inaugural meetup. I was glad to have RSVPed early as the event quickly became oversubscribed with the waiting list outnumbering the attendee list three to one. That in itself is a clear indication of the kind of interest in Elm from all quarters.

Continue reading…

Posted by dennisreimann on Thu, 02/04/2016 - 13:00

By defining a union type one always creates a new type that did not exist before. A union type can be an amalgamation of different types – but it does not have to be.

Posted by dennisreimann on Mon, 02/01/2016 - 13:00

Records and tuples can contain an arbitrary amount of elements – as opposed to lists, arrays, sets, and dictionaries these elements do not have to be of the same data type.

Posted by dennisreimann on Wed, 01/27/2016 - 13:00

In Elm there are different kinds of data structures that can contain elements. This article spotlights the iterable structures lists, arrays, sets, and dictionaries.

Posted by dennisreimann on Thu, 01/21/2016 - 13:00

This article spotlights the central construct of the Elm programming language: Functions. What does the definition of a function look like, how can functions be chained via piping and what the heck is currying?

Posted by FullyForged on Thu, 01/21/2016 - 12:30

When working with Phoenix channels and Elm it may be useful to keep track of the websockets connection status. In this blog post, we’ll see how this can be accomplished by leveraging interoperability.

Posted by dennisreimann on Tue, 01/19/2016 - 02:00

Importing a module exposes its functionality in the context of the program that is loading the module. In Elm there are different ways to import modules and we will have a look at these in this article.

Posted by Rundis on Tue, 01/19/2016 - 01:00

Any serious Single Page Application needs to have routing. Right ? So before we add
any further pages it’s time to add routing support to the Elm frontend.

In episode 2, we implemented
a Micky Mouse solution for page routing. Clearly that approach won’t scale. Now is a good time to
implement something that can handle multiple pages, history navigation, direct linking etc.
We could do it all from scratch, but lets opt for pulling in a library.
In this episode we’ll introduce elm-transit-router
to the Albums sample application.

Useful resources

  • Check out the other episodes in this blog series.
  • The accompanying Albums sample app is on github, and there is a tag
    for each episode


I decided pretty early on to try out the elm-transit-router library.
It seemed to cover most of what I was looking for. It even has some pretty cool support for animations when doing page transitions.

Static typing is supposed to be really helpful when doing refactoring. Introducing routing should be a nice little excersize to
see if that holds. Remember, there still isn’t a single test in our sample app, so it better hold.
The elm-transit-router library github repo contains a great example app that proved very helpful
in getting it up and running for the Albums app.

Hop is an alternative routing library you might want to check out too.

Implementation changes


// (...
"source-directories": [
"src/" (1)

// ...
"dependencies": {
//... others ommitted
"etaque/elm-route-parser": "2.1.0 <= v < 3.0.0", (2)
"etaque/elm-transit-style": "1.0.1 <= v < 2.0.0", (3)
"etaque/elm-transit-router": "1.0.1 <= v < 2.0.0" (4)


We’ve moved all elm files but Main.elm to the a src sub directory. So we need to add src to the list of source directories

A typed route parser with a nice DSL in Elm: We use it for defining our routes

Html animations for elm-transit

Drop-in router with animated route transitions for single page apps in Elm. Drop in, as in fitting very nicely with elm start-app.

Album dependencies
Click for larger diagram

The addition of the 3 new dependencies also adds quite a few transitive dependencies. The diagram
above is automatically generated by the elm-light plugin for Light Table.

Defining routes (frontend/src/Routes.elm)

type Route (1)
= Home
| ArtistListingPage
| ArtistDetailPage Int
| NewArtistPage
| EmptyRoute

routeParsers : List (Matcher Route)
routeParsers =
[ static Home "/" (2)
, static ArtistListingPage "/artists"
, static NewArtistPage "/artists/new"
, dyn1 ArtistDetailPage "/artists/" int "" (3)

decode : String -> Route
decode path = (4)
RouteParser.match routeParsers path
|> Maybe.withDefault EmptyRoute

encode : Route -> String
encode route = (5)
case route of
Home -> "/"
ArtistListingPage -> "/artists"
NewArtistPage -> "/artists/new"
ArtistDetailPage i -> "/artists/" ++ toString i
EmptyRoute -> ""

Union type that defines the different routes for the application

A static route matcher (static is a function from the RouteParser dsl)

Dynamic route matcher with one dynamic param

We try to match a given path with the route matchers defined above. Returns route of first successful match, or the EmptyRoute route
if no match is found.

Encode a given route as a path

A few handy router utils (frontend/src/Routes.elm)

redirect : Route -> Effects ()
redirect route = (1)
encode route
|> Signal.send TransitRouter.pushPathAddress
|> Effects.task

clickAttr : Route -> Attribute
clickAttr route = (2)
on "click" Json.value (\_ -> Signal.message TransitRouter.pushPathAddress <| encode route)

linkAttrs : Route -> List Attribute
linkAttrs route = (3)
path = encode route
[ href path
, onWithOptions
{ stopPropagation = True, preventDefault = True }
(\_ -> Signal.message TransitRouter.pushPathAddress path)

This function allows us to perform routing through a redirect kind of effect. Comes in handy when we need to switch
routes as a result of performing a task or doing an update action of some sort.

Helper function that creates a click handler attribute. When clicked the signal is forwarded to an address of the internal mailbox for the
elm-transit-router library. By means of delegation the internal TransitRouter.Action type is wrapped into our app’s Action type.
We’ll get back to this when we wire it all together !

Another helper function, similar to clickAttr, but this is more specific for links that also has a href attribute

Changes in Main.elm

Too hook in elm-transit-router we need to make a couple of changes to how we wire up our model, actions, view and update function.
It’s also worth noting that from episode 2 have removed all direct update delegation from ArtistListing to ArtistDetail, this now
all will happen through route transitions. An immediate benefit of that is that the ArtistDetail page becomes much reusable.

Model, actions, transitions and initialization

type alias Model = WithRoute Routes.Route (1)
{ homeModel : Home.Model
, artistListingModel : ArtistListing.Model
, artistDetailModel : ArtistDetail.Model

type Action =
| HomeAction Home.Action
| ArtistListingAction ArtistListing.Action
| ArtistDetailAction ArtistDetail.Action
| RouterAction (TransitRouter.Action Routes.Route) (2)

initialModel : Model
initialModel =
{ transitRouter = TransitRouter.empty Routes.EmptyRoute (3)
, homeModel = Home.init
, artistListingModel = ArtistListing.init
, artistDetailModel = ArtistDetail.init

actions : Signal Action
actions = RouterAction TransitRouter.actions (4)

mountRoute : Route -> Route -> Model -> (Model, Effects Action)
mountRoute prevRoute route model = (5)
case route of

Home ->
(model, Effects.none)

ArtistListingPage -> (6)
(model, ArtistListingAction (ServerApi.getArtists ArtistListing.HandleArtistsRetrieved))

ArtistDetailPage artistId ->
(model, ArtistDetailAction (ServerApi.getArtist artistId ArtistDetail.ShowArtist))

NewArtistPage ->
({ model | artistDetailModel = ArtistDetail.init } , Effects.none)

EmptyRoute ->
(model, Effects.none)

routerConfig : TransitRouter.Config Routes.Route Action Model
routerConfig = (7)
{ mountRoute = mountRoute
, getDurations = \_ _ _ -> (50, 200)
, actionWrapper = RouterAction
, routeDecoder = Routes.decode

init : String -> (Model, Effects Action)
init path = (8)
TransitRouter.init routerConfig path initialModel

We extend our model using WithRoute for our Route type in routes. This extends our type with a transitRouter property

We add a RouteAction to our Action type. We will handle that explicitly in the update function we’ll cover in the next section

We define an initial model, which has the initial models for the various pages. In addition we initialize the transitRouter property
with an empty state and EmptyRoute route (that didn’t read to well). Basically a route that shouldn’t render anything, because it will transition
to an actual route. It’s just an intermediary

Transformer for mapping TransitRouter actions to our own RouterAction. This allows start-app to map external input signals to inputs with an action type our application
can recognize and process.

mountRoute is a function that provides what we want to happen in our update when a new route is mounted. Currently we
only pattern match on route to be mounted, but we could also match on the combination of previous route and new route to provide
custom behaviour depending on where you came from and where your are going to. Very powerful !

When the ArtistListingPage route is mounted we return an effect to retrieve artists (when that effect returns the ArtistListing.HandleArtistRetrieved action is then eventually passed to the update function of ArtistListing)

routerConfig wires together the various bits that TransitRouter needs to do it’s thing

The init function now just initializes the TransitRouter with our config, and initial path (which we receive from a port) and our Initial model

There’s quite a bit going on here, but once this is all in place, adding new routes is quite a breeze. I’d recommend reading
through the Readme for elm-transit-router to understand more about the details of each step

The update function

update : Action -> Model -> (Model, Effects Action)
update action model =
case action of

NoOp ->
(model, Effects.none)

HomeAction homeAction ->
let (model', effects) = Home.update homeAction model.homeModel
in ( { model | homeModel = model' }
, HomeAction effects )

ArtistListingAction act -> (1)
let (model', effects) = ArtistListing.update act model.artistListingModel
in ( { model | artistListingModel = model' }
, ArtistListingAction effects )

ArtistDetailAction act -> (2)
let (model', effects) = ArtistDetail.update act model.artistDetailModel
in ( { model | artistDetailModel = model' }
, ArtistDetailAction effects )

RouterAction routeAction -> (3)
TransitRouter.update routerConfig routeAction model

You should recognize this pattern from the previous episode. We delegate all actions tagged with ArtistListingAction
to the update function for ArtistListing. The we update the model with the updated model from ArtistListing and
map any effects returned.

If you remember from episode 2 this used to reside in ArtistListing, but
has been moved here.

RouterAction action types are handled by the update function in TransitRouter. If you Debug.log this function you will see this
is called repeadly when there is a transition from one route to the next. (To handle the animation effects most notably)

The main view/layout

menu : Signal.Address Action -> Model -> Html
menu address model = (1)
header [class "navbar navbar-default"] [
div [class "container"] [
div [class "navbar-header"] [
div [ class "navbar-brand" ] [
a (linkAttrs Home) [ text "Albums galore" ]
, ul [class "nav navbar-nav"] [
li [] [a (linkAttrs ArtistListingPage) [ text "Artists" ]] (2)

contentView : Signal.Address Action -> Model -> Html
contentView address model = (3)
case (TransitRouter.getRoute model) of
Home ->
Home.view (Signal.forwardTo address HomeAction) model.homeModel

ArtistListingPage -> (4)
ArtistListing.view (Signal.forwardTo address ArtistListingAction) model.artistListingModel

ArtistDetailPage i ->
ArtistDetail.view (Signal.forwardTo address ArtistDetailAction) model.artistDetailModel

NewArtistPage ->
ArtistDetail.view (Signal.forwardTo address ArtistDetailAction) model.artistDetailModel

EmptyRoute ->
text "Empty WHAT ?"

view : Signal.Address Action -> Model -> Html
view address model =
div [class "container-fluid"] [
menu address model
, div [ class "content"
, style (TransitStyle.fadeSlideLeft 100 (getTransition model))] (5)
[contentView address model]

Menu view function for the app

Here we use the linkAttrs util function from Routes.elm to get a click handler. When the link is click
a route transition to the given page will occur (with addressbar update, history tracking and the whole shebang)

We render the appropriate main content view based which route is current in our model.

Getting the view for a page is used in the typical start-app way. Call the view function of the sub component and make sure
to provide a forwarding addres that main can handle in its update function !

We define the route transition animation using the style attribute (function) in elm-html. Here we use a transition style
defined in elm-transit-style.

How to navigate from one page to another ?

Move from artistlisting to artistdetail (frontend/src/ArtistListing.elm)

artistRow : Signal.Address Action -> Artist -> Html
artistRow address artist =
tr [] [
td [] [text]
,td [] [button [ Routes.clickAttr <| Routes.ArtistDetailPage ] [text "Edit"]] (1)
,td [] [button [ onClick address (DeleteArtist (.id artist))] [ text "Delete!" ]]

view : Signal.Address Action -> Model -> Html
view address model =
div [] [
h1 [] [text "Artists" ]
, button [
class "pull-right btn btn-default"
, Routes.clickAttr Routes.NewArtistPage (2)
[text "New Artist"]
, table [class "table table-striped"] [
thead [] [
tr [] [
th [] [text "Name"]
,th [] []
,th [] []
, tbody [] ( (artistRow address) model.artists)

For navigation using links we just use the util function Routes.clickAttr function we defined earlier. This will trigger the necessary
route transition to the appropriate page (with params as necessary)

It’s worth noting that we since episode 2 have introduced a separate route for handling NewArtist (/artists/new). We are still
using the same behaviour otherwise, so it’s just a minor modification to have a separate transition for a new artist (since that doesn’t have a numeric id as part of its route path)

Move to the artist listing after saving an artist (frontend/src/ArtistDetail.elm)

-- ... inside update function

HandleSaved maybeArtist ->
case maybeArtist of
Just artist ->
({ model | id = Just
, name = }
, (\_ -> NoOp) (Routes.redirect Routes.ArtistListingPage) (1)

Nothing ->
Debug.crash "Save failed... we're not handling it..."

We use the Routes.redirect function we defined earlier. When the task fro saving is completed we trigger an effect
that will transtion route to the ArtistListing page. To allow the effect to work in our update function we need to map it to
an action that ArtistDetail knows about (we don’t have access to the RouterAction in main here!). That’s why we map the effect
to a NoOp action.

The final wiring


app : StartApp.App Model
app =
{ init = init initialPath (1)
, update = update
, view = view
, inputs = [actions] (2)

main : Signal Html
main =

port tasks : Signal (Task.Task Never ())
port tasks =

port initialPath : String (3)

We call the init function previously defined with a initialPath (which we get from a port, see 3 below)

The inputs fields of the start-app config is for external signals. We wire it to our actions defintion defined earlier

We get the initialPath through a port from JavaScript. See the next section for how

INFO: Initially I forgot to wire up the inputs. The net result of that was that none of the links actually did anything.
Was lost for a while there, but the author of elm-transit-router etaque was able to spot it easily
when I reached out in the elm-lang slack channel


<!DOCTYPE html>
<html lang="en">
<meta charset="utf-8">
<link rel="stylesheet" href="assets/css/bootstrap.min.css">
<script type="text/javascript" src="main.js"></script> (1)
<script type="text/javascript" src="/_reactor/debug.js"></script> (2)

<script type="text/javascript">
var main = Elm.fullscreen(Elm.Main, {initialPath: "/"}); (3)


This is the transpiled elm to js for our frontend app

We don’t really need this one, but if reactor in debug mode had worked with ports this would be necessary for debug tracing etc

We start our elm app with an input param for our initialPath. This is sent to the port defined above. It’s currently hardcoded to / (home), but
once we move to a proper web server we would probably use something like window.location.pathname to allow linking directly to
a specific route within our Single Page App.

Summary and next steps

This was an all Elm episode. Hopefully I didn’t loose all Haskellites along the way because of that. We’ve added a crucial
feature for any Single Page (Web) Application in this episode. The end result was pretty neat and tidy too.

So how was the refactoring experience this time ? Well the compiler was certainly my best buddy along the way. Obviously I also
had to consult the documentation of elm-transit-router quite often. i had a few times where things appeared to be compiling fine
in Light Table, but actually there was some error in a Module referred by Main. I’m not sure if it’s make’s fault or just that there is
something missing in the elm-light plugin. I’ll certainly look into that. Always handy to have the command line available when you’re
not sure about whether your IDE/Editor is tripping you up or not. I don’t think tests would have caught many of the issues I encountered.
Forgetting to wire up inputs to startapp was probably my biggest blunder, and I’m sure no test would have covered that. I needed to know that this
was something I had to wire up for it to work. RTFM etc.

Next up I think we will look at how much effort there is to add additional features. The hypothesis is that it should be
fairly straighforward, but who knows !

Posted by dennisreimann on Sun, 01/17/2016 - 02:00

How to install Elm and which tools do you need to build your first project? Besides clarifying these questions we will also look at a toolchain that goes beyond the simple Hello World.

Posted by codecentric on Sat, 01/16/2016 - 15:57

We have already touched the topic of Elm’s type system briefly (for example in post VI about type annotations) but Elm provides a few type constructs that we have not examined yet. We also talked about the advantages of having a strong type system, namely the stronger guarantees it enables as compared to dynamic languages like JavaScript. This boils down to “If it compiles, it’ll never throw a runtime exception”. In this episodes, we’ll revisit tuples and introduce type aliases and records.

About This Series
This is the ninth post in a series of short and sweet blog posts about Elm. The stated goal of this series is to take you from “completely clueless about Elm” to “chief Elm guru”, step by step. If you have missed the previous episodes, you might want to check out the table of contents.
We have already used tuples in previous examples but since they are one of the basic building blocks for types, let’s review the concept shortly.
Tuples are similar to lists as they represent collections of multiple items. However, in a list, all elements need to have the same type. The number of elements is variable. In contrast, the elements of a tuple can all have different types but all tuples of the same type have the same length.
Here are some examples for a tuples (representing human beings with a name, weight in kilograms and their height in meters):

alice : (String, Int, Float)
alice = ("Alice", 61, 1.68)

bob : (String, Int, Float)
bob = ("Bob", 78, 1.82)

So, tuples are pairs (or triplets, quadruplets, …) of values. They are enclosed in ( and ) in Elm.
You can use pattern matching to access individual parts of the tuple. The following function takes a 3-tuple like in the example above and returns the name by doing a pattern matching on the incoming tuple. Since we do not care about the weight and the height here, we use the underscore (_) for those values.
getName : (String, Int, Float) -> String
getName (name, _, _) = name
Type Aliases
You can assign type aliases to make your code more readable. If the first element of a tuple is meant to represent a name, why not call it just that?
type alias Name = String
type alias Weight = Int
type alias Height = Float

alice : (Name, Weight, Height)
alice = ("Alice", 61, 1.68)

bob : (Name, Weight, Height)
bob = ("Bob", 78, 1.82)
Here, we used type aliases for basic types that are provided by Elm out of the box. You can use type aliases for any type construct you like, as we’ll see later.
Tuples are one way to represent data structures. They are best suited for structures with only a few attributes, like pairs of values. For more structured data, Elm offers an alternative called records. This is how records looks like:
type alias Person =
{ name : String
, weight : Int
, height : Float

alice : Person
alice =
{ name = "Alice"
, weight = 61
, height = 1.68

bob : Person
bob =
{ name = "Bob"
, weight = 78
, height = 1.82 }
Note how we used a type alias here to have an identifier for the record type. This identifier (Person) can be used in type annotations then. The two values alice and bob show how to create new records.
There are a few more things that you can do with records and we will get to that in the next sections.
Access Record Attributes
Record attributes are accessed using a dot notation. To access the name of a Person record, you would write, or person.height to access the person’s height attribute.
The dot notation can even be used as a standalone function. This is valid Elm code which converts a list of Person records into a list of their names:
toNames : List Person -> List String
toNames list = .name list
Update Record Fields
Elm also provides a mechanism to update records. Since all values in Elm are immutable, “updating” a record translates to creating a copy of the original record and changing one (or several) attributes in the process.
The following example demonstrates how to update one attribute.
rename : Person -> String -> Person
rename person newName =
{ person | name = newName }
The next example updates multiple attributes at once.
grow : Person -> Int -> Float -> Person
grow person weightIncrease heightIncrease =
{ person |
weight = person.weight + weightIncrease,
height = person.height + heightIncrease }

That’s it for today. Now that we have reviewed tuples, type aliases and records, there is only one major type construct missing, which is called union types. This will be covered in the next episode. See you next time!
The post Elm Friday: Type System Basics – Type Aliases and Records (Part IX) appeared first on codecentric Blog.

Posted by Rundis on Thu, 01/14/2016 - 01:00

My journey into Elm and Haskell continues. It’s time to add database support.

Since episode 1 I’ve
managed to implement simple CRUD features for the Artist entity of the Albums sample application.
It’s been anything but plain sailing, but it’s been a blast so far. Trying to wrap my head around two
new languages and their libraries in parallell is somewhat daunting. The journey would probably
have been smoother if I took more time to learn the language proper. Learning by doing is at times
frustrating, at the same time very rewarding when stuff finally works.

There seems to be a pretty close correlation between it compiles and it works when programming
in Elm and Haskell

— Magnus
(yeah I know; correlation does not imply causation)

Table of Contents


Useful resources

  • Check out the other episodes in this blog series.
  • The accompanying Albums sample app is on github, and there is a tag
    for each episode

So what have I done for this episode ?

  • Added persistence support to the haskell/servant backend server using SQLite
  • REST API now supports POST, PUT, DELETE and GET (multiple/single) Artists
  • The Elm frontend has features for listing, deleting, updating and creating new artists


I’ve taken a bottom up approach to developing the features. For both the Frontend and the Backend I’ve
implemented everything in one module. After that I’ve done pretty substantial refactorings into smaller
modules while letting the respective compilers guide me along the way. So how did that work out ?


Pretty early on I managed to get halive to start working. Having live recompiling is
really nice and seriously improved my workflow. I have very limited editor support because my editor (Light Table)
currently doesn’t provide much in terms of haskell support. I was almost derailed with developing a Haskell plugin (or making the existing one work), but
managed to keep on track.

Adding cors support

During development of the spike for the previous episode I used a chrome plugin to get around CORS
restrictions from my browser. Surely this has to be solvable ? Indeed it was, wai-cors to the rescue.


-- ...
, wai-cors
-- ...



import Network.Wai.Middleware.Cors


albumCors :: Middleware
albumCors = cors $ const (Just albumResourcePolicy) (1)

albumResourcePolicy :: CorsResourcePolicy (2)
albumResourcePolicy =
{ corsOrigins = Nothing -- gives you /*
, corsMethods = ["GET", "POST", "PUT", "DELETE", "HEAD", "OPTION"]
, corsRequestHeaders = simpleHeaders -- adds "Content-Type" to defaults
, corsExposedHeaders = Nothing
, corsMaxAge = Nothing
, corsVaryOrigin = False
, corsRequireOrigin = False
, corsIgnoreFailures = False

main :: IO ()
main = do
run 8081 $ albumCors $ app (3)

Define wai cors middleware

Define a cors policy. This one is very lax. You wouldn’t want to use this for anything public facing as is

Apply the middleware to our app. Now cross origin headers are added and OPTION prefligh requests are supported. Nice

Cors inspiration harvested from btw

Enter SQLite

I looked at a few different options for database support. Most examples and tutorials related
to servant and database usage seems to favor persistent.
I’m surely going to have a closer look at that, but my initial impression was that perhaps there was just
a little bit to much going on there. Just a little bit to much "magic" ? Having lost my taste
for ORM’s in the JVM spehere (hibernate in particular) I wanted to start with something closer to the metal.

So to make it a little harder for myself I went for the sqlite-simple library.
Pretty happy with the choice so far.


-- ...
, sqlite-simple
-- ...


{-# LANGUAGE OverloadedStrings #-}
module Main where

import qualified Storage as S (1)
import qualified Api as A (2)
import Network.Wai
import Network.Wai.Handler.Warp
import Servant
import Network.Wai.Middleware.Cors
import Control.Exception (bracket)
import Database.SQLite.Simple as Sql

app :: Sql.Connection -> Application
app conn = serve A.api (A.artistsServer conn) (3)

testConnect :: IO Sql.Connection
testConnect = ":memory:" (4)

withTestConnection :: (Sql.Connection -> IO a) -> IO a
withTestConnection cb = (5)
withConn $ \conn -> cb conn
withConn = bracket testConnect Sql.close (6)

cors stuff omitted, already covered

main :: IO ()
main = do
withTestConnection $ \conn -> do
S.bootstrapDB conn (7)
run 8081 $ albumCors $ app conn (8)

Module with functions for communication with the Albums database. Only used for bootstrapping with test data in main

Module that defines the webservice api

We make sure to pass a connection to our webservice server

For simplicity we are using an in memory database

Wrap a function (cb) giving it a connection and cleaning up when done

bracket ensures we also release the connection in case of any exceptions.

Creates schema and bootstraps with some sample data

Ensure we pass the connection to our app function

Read more about the bracket pattern


{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE DataKinds #-}

module Api where

import qualified Model as M (1)
import qualified Storage as S
import Data.Aeson
import Control.Monad.IO.Class (MonadIO, liftIO)
import Control.Monad.Trans.Either
import Servant
import Database.SQLite.Simple as Sql

instance ToJSON M.Artist
instance FromJSON M.Artist

type ArtistAPI = (2)
Get '[JSON] [M.Artist]
:<|> ReqBody '[JSON] M.Artist :> Post '[JSON] M.Artist
:<|> Capture "artistId" Int :> Get '[JSON] M.Artist
:<|> Capture "artistId" Int :> ReqBody '[JSON] M.Artist :> Put '[JSON] M.Artist
:<|> Capture "artistId" Int :> Delete '[] ()

-- '

artistsServer :: Sql.Connection -> Server ArtistAPI (3)
artistsServer conn =
getArtists :<|> postArtist :<|> getArtist :<|> updateArtist :<|> deleteArtist

getArtists = liftIO $ S.findArtists conn (4)
getArtist artistId = liftIOMaybeToEither err404 $ S.artistById conn artistId
postArtist artist = liftIO $ S.newArtist conn artist
updateArtist artistId artist = liftIO $ S.updateArtist conn artist artistId
deleteArtist artistId = liftIO $ S.deleteArtist conn artistId

liftIOMaybeToEither :: (MonadIO m) => a -> IO (Maybe b) -> EitherT a m b
liftIOMaybeToEither err x = do (5)
m <- liftIO x
case m of
Nothing -> left err
Just x -> right x

type API = "artists" :> ArtistAPI

api :: Proxy API
api = Proxy

The record definitions for our API lives in this module

We’ve extended the api type defintions from episode 1
to define the shape of get multiple, get single, post, put and delete.

Connection has been added as a parameter to our artist server

liftIO is a monad transformer. I’d love to be able to explain
how it works, but well…​ Anyways net result is that I don’t have to define EitherT ServantErr IO .. all over the place

liftIOMaybeToEither - what it says. Handy function to return a servant error (which again maps to a http error) if a function like getArtist doesn’t return
a result. Tx to ToJans for inspiration

put aka update artist should also return a 404 when a non existing artist id is provided.
Actually, error handling is pretty light throughout, but we’ll get back to that in a later episode !


{-# LANGUAGE DeriveGeneric #-}

module Model where

import GHC.Generics

data Artist = Artist (1)
{ artistId :: Maybe Int (2)
, artistName :: String (3)
} deriving (Eq, Show, Generic)

Moved record defintions to a separate module. Currently just Artist

Make id optional. This is a quick and dirty way to be able to use the same
record definiton for new artists as for updates and gets.

Names in records are not scoped withing the record so one solution is to manually
make sure names stay unique.

From what I gather record syntax is a bit clunky in Haskell (atleast when compared to Elm).
This stackoverflow post
didn’t bring any warm fuzzy feelings. If anyone has some better solutions which also plays
well with the handy servant and SQLite simple functions feel free to leave a comment below !


{-# LANGUAGE OverloadedStrings #-}
module Storage where

import qualified Model as M
import qualified Data.Text as Txt

import Database.SQLite.Simple as Sql
import Database.SQLite.Simple.Types as SqlTypes

instance Sql.FromRow M.Artist where (1)
fromRow = M.Artist <$> Sql.field <*> Sql.field

artistById :: Sql.Connection -> Int -> IO (Maybe M.Artist) (2)
artistById conn idParam =
findById conn "artist" idParam :: IO (Maybe M.Artist)

findArtists :: Sql.Connection -> IO [M.Artist]
findArtists conn =
Sql.query_ conn "select * from artist" :: IO [M.Artist]

newArtist :: Sql.Connection -> M.Artist -> IO M.Artist
newArtist conn artist = do
Sql.execute conn "insert into artist (name) values (?) " (Sql.Only $ M.artistName artist)
rawId <- lastInsertRowId conn
let updArtist = artist { M.artistId = Just (fromIntegral rawId) } (3)
return updArtist

-- Really we should check whether the artist exists here
updateArtist :: Sql.Connection -> M.Artist -> Int -> IO M.Artist
updateArtist conn artist idParam = do
Sql.executeNamed conn "update artist set name = :name where id = :id" params
return artist { M.artistId = Just idParam } (4)
params = [":id" := (idParam :: Int), ":name" := ((M.artistName artist) :: String)]

deleteArtist :: Sql.Connection -> Int -> IO ()
deleteArtist conn idParam =
Sql.execute conn "delete from artist where id = ?" (Sql.Only idParam)

findById :: (FromRow a) => Sql.Connection -> String -> Int -> IO (Maybe a)
findById conn table idParam = do
rows <- Sql.queryNamed conn (createFindByIdQuery table) [":id" := (idParam :: Int)]
let result = case (length rows) of
0 -> Nothing
_ -> Just $ head rows (5)

return result

createFindByIdQuery :: String -> SqlTypes.Query
createFindByIdQuery table =
SqlTypes.Query $ Txt.pack $ "SELECT * from " ++ table ++ " where id = :id" (6)

-- ... boostrap function left out, check the source repo for details

Define SQLite row converter to create artist records for rows with id and name

Finding an artist by Id may return empty results. Prematurely factored out a generic findById function that is used here

Add the id of the newly inserted artist row to the resulting artist. (The Maybe artistId starts to smell)

Yuck, this smells even worse. The decision to support an optional id on the Artist record doesn’t ring true

Using let allows us to "work inside" the IO monad. Otherwise the compiler complains along the lines of Couldn’t match expected type ‘[r1]’ with actual type ‘IO [r0]’

Whacking strings together is discouraged (helps avoid sql injection for one), but getting around it is possible with a little serimony

Backend summary

Well now we got persistence up and running with a good ole' relational database. That’s
not very exciting and I might return to change that in a future episode. The REST api is quite simple and lacking in validation and error handling, but it’s hopefully a decent start and foundation
for future changes.

After working with Clojure and Leiningen not to long ago, the server startup time feels blistering fast in comparison.
Getting halive to work made significant improvements to the development workflow.
When working with Haskell I get a constant reminder that I would benefit from learning more about the language
and fundemental concepts. The compiler messages still throws me off a lot of times, but the situation is gradually improving as I’m learning.
I guess I’m already spoilt with the error messages from Elm which feels a lot clearer and better at highlighting the root cause(s) of my mistakes.

I’m still fumbling to design a sensible structure for the custom data types. I have a feeling
several iterations will be needed as I add support for additional services.


It’s a shame the hot reloading support in elm-reactor is broken at the time of writing, otherwise the development experience
would have been a lot better. Makereload browser is just a keystroak away in Light Table, but still.
Having the informative compiler error and warning messages inline in my Editor is really nice though.

Do better understand the elm-architecture I’ve tried to follow, you should really check out the
tutorial. It does a much better job at explaining the core
concepts than I do.

albums pages


module Main where

import ArtistListing
import Html exposing (..)
import Html.Attributes exposing (..)
import Html.Events exposing (onClick)
import Task exposing (..)
import Effects exposing (Effects, Never)
import StartApp

type alias Model = (1)
{ artistListing : ArtistListing.Model}

type Action = (2)
| ArtistListingAction ArtistListing.Action

init : (Model, Effects Action) (3)
init =
(artistListing, fx) = ArtistListing.init
( Model artistListing
, ArtistListingAction fx (4)

update : Action -> Model -> (Model, Effects Action)
update action model =
case action of

ShowHomePage -> (5)
(artistListing, fx) = ArtistListing.init
( {model | artistListing = artistListing}
, ArtistListingAction fx

ArtistListingAction sub -> (6)
(artistListing, fx) = ArtistListing.update sub model.artistListing
( {model | artistListing = artistListing}
, ArtistListingAction fx

menu : Signal.Address Action -> Model -> Html
menu address model =
header [class "navbar navbar-default"] [
div [class "container"] [
div [class "navbar-header"] [
button [ class "btn-link navbar-brand", onClick address ShowHomePage ]
[text "Albums Crud"]

view : Signal.Address Action -> Model -> Html
view address model =
div [class "container-fluid"] [
menu address model (7)
, ArtistListing.view (Signal.forwardTo address ArtistListingAction) model.artistListing

-- ... app, main and port for tasks left out, no changes since previous episode

The main model composes the artistlisting page model

Actions for main, currently just holds the actions for ArtistListing + a convenience action to reset/show home page

The init function from ArtistListing returns it’s model and an effect (get artist from server task). We initialize the
main model with the artistlisting model

We map the effect from ArtistListing to an Main module effect which is then handled by the startapp "signal loop"

Quick and dirty way to trigger showing of the artist listing page (re-initialized)

All ArtistListing actions are tagged with ArtistListingAction, we delegate to the update function for ArtistListing
, update the main model accordingly and the map the returne effect

To get/create the view for ArtistListing we call it’s view function, but we need to ensure signals sent from ArtistListing makes it back to the main view mailbox address. Signal.forwardTo helps us create a forwarding address.

Read more about Mailboxes, Messages and Addresses


module ArtistListing (Model, Action (..), init, view, update) where

import ServerApi exposing (..) (1)
import ArtistDetail
-- ... other imports ommited

type Page = ArtistListingPage | ArtistDetailPage

type alias Model =
{ artists : List Artist
, artistDetail : ArtistDetail.Model
, page : Page}

type Action =
HandleArtistsRetrieved (Maybe (List Artist))
| SelectArtist (Int)
| DeleteArtist (Int)
| HandleArtistDeleted (Maybe Http.Response)
| ArtistDetailAction ArtistDetail.Action
| NewArtist

init : (Model, Effects Action)
init =
(artistDetail, fx) = ArtistDetail.init
( Model [] artistDetail ArtistListingPage
, getArtists HandleArtistsRetrieved (2)

update : Action -> Model -> (Model, Effects Action)
update action model =
case action of

HandleArtistsRetrieved xs -> (3)
( {model | artists = (Maybe.withDefault [] xs) }
, Effects.none

DeleteArtist id ->
(model, deleteArtist id HandleArtistDeleted)

HandleArtistDeleted res ->
(model, getArtists HandleArtistsRetrieved)

NewArtist -> (4)
update (ArtistDetailAction <| ArtistDetail.ShowArtist Nothing) model

SelectArtist id ->
update (ArtistDetailAction <| ArtistDetail.GetArtist id) model

ArtistDetailAction sub -> (5)
(detailModel, fx) = ArtistDetail.update sub model.artistDetail
( { model | artistDetail = detailModel
, page = ArtistDetailPage } (6)
, ArtistDetailAction fx

-- ... artistView details ommitted for brevity

view : Signal.Address Action -> Model -> Html
view address model =
div [class "content"] [
case of (7)

ArtistListingPage ->
artistsView address model

ArtistDetailPage ->
ArtistDetail.view (Signal.forwardTo address ArtistDetailAction) model.artistDetail


The ServerApi module exposes functions to interact with the backend server

getArtists HandleArtistsRetrieved calls the serverAPI with a action param, so that when the ajax/xhr callback finally makes in back into the elm signal loop, the update function is called with the action we want

Update the model with the list of artists retrieved (if any)

To show the artist detail page in "create" mode we create a ArtistDetailAction with the appropriate ArtistDetail.action

ArtistDetailAction sub actions are actions that are delegated to the actions of the ArtistDetail module.

Note that we change "page context" here so that the view function displays the appropriate page

Our naive page routing, just toggles display of pages by the page attribute of our model

We’ve implemented a very simplistic page routing here. In a later episode we will refactor to
something more managable for handling proper page routing.

This page handles update/creation of a single Artist. I’ll leave it to you to check out
the details of the sample code on github.


module ServerApi where

import Json.Decode as JsonD exposing ((:=))
import Json.Encode as JsonE
import Effects exposing (Effects)
import Http
import Task

type alias ArtistRequest a = (1)
{ a | name : String }

type alias Artist =
{ id : Int
, name : String

baseUrl : String
baseUrl = "http://localhost:8081"

getArtist : Int -> (Maybe Artist -> a) -> Effects.Effects a
getArtist id action = (2)
Http.get artistDecoder (baseUrl ++ "/artists/" ++ toString id)
|> Task.toMaybe
|> action (3)
|> Effects.task

getArtists : (Maybe (List Artist) -> a) -> Effects a
getArtists action =
Http.get artistsDecoder (baseUrl ++ "/artists")
|> Task.toMaybe
|> action
|> Effects.task

createArtist : ArtistRequest a -> (Maybe Artist -> b) -> Effects.Effects b
createArtist artist action = (4)
Http.send Http.defaultSettings
{ verb = "POST"
, url = baseUrl ++ "/artists"
, body = Http.string (encodeArtist artist) (5)
, headers = [("Content-Type", "application/json")]
|> Http.fromJson artistDecoder
|> Task.toMaybe
|> action
|> Effects.task

-- .. the remaining services and encoding|decoding left out for brevity

This type is an extensible record type. It allows our
artist related services to be a little bit more generic and still keep a level of type checking

GET a single artist from our backend api. (Actually it returns and effect that will executa a task which upon callback will eventually call the update function in our app with the given action)

We’ve relented on type safety for actions by allowing it to be a generic param, but we gain some flexibility
that allows our service to be usable in many different contexts

To take more control over http actions we use Http.send. It’s closer to the metal so it’s a little
bit more boilerplate.

Encode the artist (request) to a json string

To see the remaining services and details of decoding and encoding please consolt the sample code on github.

Frontend summary

We are beginning to see the resmblance of a Single Page Application. We have started to compose
views and pages using the Elm Architecture. The app supports basic CRUD oparations for an Artist entity.
Error handling is light, there is no validation and our routing solution is overly simplistic, but we’ll get
to that soonish !

Working with Elm has been an absolute pleasure. The compiler messages really do help. Doing refactoring (without tests I might add)
doesn’t feel anywhere near as scary as I’m used to from other languages.
I’m starting to understand more about the Elm Architecture, but I’m still getting a little confused about the details
of Signals, Tasks, Mailboxes, Effects etc. It’s coming to me gradually. The important thing is I can still be quite productive
even though I don’t understand all the details.

I have to say I’m not looking forward to my next refactoring in some messy imperative jquery page mutant at work.

Conclusion and next steps

I’m aware this blog post got way to long even though I tried to shave of some of the code from the
code listings. I’ll have to try to take on smaller/more targeted chunks in future episodes.

Anyways. I’m staring to feel I’m getting somewhere now. Both with Haskell and Elm. Learning Haskell is
by far the most challenging but getting my head around Functional Reactive Programming in Elm isn’t without challenges either.
My motivation is still strong and I’m learning a ton of stuff.

Candidate areas to address for the next episode are; routing, validation, error handling and obviously more useful features.
I’m thinking perhaps routing comes first, but we’ll see.

Posted by LambdaCat on Wed, 01/13/2016 - 16:30

Road to Elm - Table of Contents

Destructuring is a handy tool, available in many functional languages (also in Javascript ES6).

It's a more succinct syntax to extract single values from collections of various types.

Extracting values from objects or arrays and assigning them to local variables is one of

Posted by LambdaCat on Wed, 01/13/2016 - 16:30

Road to Elm - Table of Contents

Destructuring is a handy tool, available in many functional languages (also in Javascript ES6).

It's a more succinct syntax to extract single values from collections of various types.

Extracting values from objects or arrays and assigning them to local variables is one of