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 Tue, 01/12/2016 - 18:37

Road to Elm - Table of Contents

If you haven't programmed in an ML-inspired language before, let and in are probably new to you.

In an imperative language you can get away with sprinkling your variables all over the place. Nothing is enforcing their placement in a particular place in

Posted by LambdaCat on Mon, 01/11/2016 - 18:52

Road to Elm - Table of Contents

If you haven't used FP languages much, you may see many little confusing things happening in Elm code.

For one, you might have found partially applied functions, which are functions that take n arguments but are called with a less than n number

Posted by LambdaCat on Mon, 01/11/2016 - 18:51

I've been using Elm a lot lately, so I'm going to write down a series of posts of findings, thoughts and observations, both small & large, on concepts and corners of Elm that I feel are easy to overlook, counterintuitive or generally assumed to be known from previous Functional Programming

Posted by Rundis on Fri, 01/01/2016 - 01:00

In an effort to making management of project dependencies in Elm projects a little easier, the Elm plugin
for Light Table the elm-light has a few neat features up it’s sleave.
Check out the demo below for a brief overview.

You can find the elm-light plugin here


ScreenCast demo

Other relevant demos:

Short implementation summary

I’m just going to give a very brief overview of a few key pieces for how the features are implemented here.
I might add a more detailed blog post if there is any interest for that in the future.

Package management

The package manager is just a thin wrapper around the elm-package executable.

(defn parse-json-file [json-file]
(when (files/exists? json-file)
(-> (->> (files/open-sync json-file)
(.parse js/JSON))
(js->clj :keywordize-keys true))))

(defn remove-pkg [path pkg]
(let [pkg-file (files/join path "elm-package.json")]
(-> (u/parse-json-file pkg-file)
(update-in [:dependencies] (fn [deps]
(-> (into {}
(map (fn [[k v]]
[(u/nskw->name k) v]) deps))
(dissoc pkg))))
((partial files/save pkg-file)))))

To list, update and remove dependencies it parses (and updates) the project file for elm projects; elm-package.json. In addition
it parses the exact-dependencies.json file for all resolved dependencies.

Working with json in ClojureScript feels almost seamless to working with native ClojureScript datastructures

View rendering

To render the package listing the plugin uses quiescent and react

(q/defcomponent PackageTable [props]
{:className "package-table"}
(d/th {} "Package")
(d/th {} "Range")
(d/th {} "Exact")
(d/th {} "")))
(apply d/tbody {}
(map #(PackageRow (assoc %
:on-remove (:on-remove props)
:on-browse (:on-browse props)))
(:packages props)))))

You can find a detailed blog post about some of the benefits of using react for view rendering in Light Table
in Implementing a Clojure ns-browser in Light Table with React

Dependency autocompletion

Whan adding dependencies there is a handy autocompleter. This uses a json resource from

(defn fetch-all-packages
"Fetch all packages from"
(fetch/xhr (str "" (.getTime (new js/Date)))
(fn [data]
(let [pkgs (js->clj (.parse js/JSON data) :keywordize-keys true)]
(callback pkgs)))))

Dependency graph

To implement the dependency graph d3 and dagreD3 is used. Both of these ships node-modules. Using node-modules from
Light Table plugins is definetely not rocket science !

(def dagreD3 (js/require (files/join u/elm-plugin-dir "node_modules/dagre-d3")))
(def d3 (js/require (files/join u/elm-plugin-dir "node_modules/d3")))

defn create-graph [data] (1)
(let [g (.setGraph (new dagreD3.graphlib.Graph) #js {})]
(doseq [x (:nodes data)]
(.setNode g (dep-id x) (node-label x)))
(doseq [x (:edges data)]
(.setEdge g (:a x) (:b x) #js {:label (:label x)
:style (when (:transitive x)
"stroke-dasharray: 5, 5;")}))

(behavior ::on-render (2)
:desc "Elm render dependencies"
:triggers #{:elm.graph.render}
:reaction (fn [this]
(let [svg (.select d3 "svg")
g (.select svg "g")
renderer (.render dagreD3)]
(renderer g (create-graph (:data @this)))
(init-zoom svg g)
(resize-graph this svg))))

The function to create the dependency graph. Helper functions omitted, but not much to it really

Light Table behavior that is responsible for rendering the graph


  • d3.js - Provides awesome graphing features
  • dagreD3 - Create Directed Acyclic Graphs in a breeze