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
Posted by Gizra on Wed, 12/30/2015 - 00:00

In August 2015 I challenged myself (and later the rest of the Gizra devs) to create a typical web-app with all the bells and whistles in Elm. It's called elm-hedley, and I'm super proud it is now featuring in Elm's front page.

This post is going to give a high level overview and point out some parts that are worth noting. However, before diving into the technical section, it is important to emphasize the virtues of simply doing.

If you would go back in the commits history you would see some nasty stuff that have been completely overhauled and polished. The only way of getting to that "improving" part is of course by starting! Only after that will one become smarter and recognize what needs improving, as well as be more experienced to know how to do it.

Continue reading…

Posted by Rundis on Mon, 12/28/2015 - 01:00

Join me on my journey into statically typed functional languages. I’ve been living a pretty happily
dynamic life so far. What’s the fuzz with all those types ? What do they give me in a real life
scenario (aka is it worth using for work gigs) ? I need to make an effort and try to figure
some of this out. This blog series is an attempt to document some of my experiences along the way through a practical example.

There will be:

  • A single page web application with crud features
  • Lots of types, refactoring and hopefully some testing
  • An evolving web-app github repo for your amusement or amazement

Just a little background on me

For quite some time I’ve been wanting to learn more about functional languages that are statically (and strongly) typed.
What benefits do they really provide in practice and what are the downsides ?
My background is a from quite a few years with Java, and the last 3-4 years I’ve been working
mostly with Groovy, JavaScript and Clojure/ClojureScript.
I’ve dabbled a little with Elm recently (minesweeper in Elm)
, and I’ve tried to take on Haskell a couple of times (without much success I might add).

I mostly do web apps at work, so I figured I need to try and make something at least remotely
similar to what I do in real life.

Let’s get started

This is the point where I’ve run into analysis paralysis so many a time before.
So I set out to create a crud app, but what shall I build. After some deliberation
I settled on making something related to Music. You know Albums, Artists, Tracks and such.
I have no idea what the end result will be, but to start off I’ll make a simple spike.


The spike should

  • establish a base architecture
  • implement a simple feature: List artists

You will find the sample application code on github.
There will be a tag for each blog post in the series


I wanted to implement server component that would provide REST-services. There are quite
a few options available for Haskell that can help with that. After some research and trials
I ended up using Servant.

Some of the other options I looked at includes:

I just had to choose one, and Servant seemed like a nice fit for REST stuff and I managed to get it
working without to much hazzle.

Project set up

I’m using cabal, but you might also want to consider looking
at stack.

name: albums
synopsis: Albums rest backend
license: MIT
license-file: LICENSE
author: rundis
category: Web
build-type: Simple
cabal-version: >=1.10

executable albums
main-is: Main.hs (1)
base >= 4.7 && < 5
, either
, aeson >= 0.8 (2)
, servant (3)
, servant-server
, wai
, warp
hs-source-dirs: src (4)
default-language: Haskell2010

The entry point for the application

Provides JSON support

The servant library that helps us create type safe rest services

The directory(ies) where the source code for our app resides

For the purposes of this spike all haskell code will reside in Main.hs. This will
surely not be the case as the app progresses.

If you wan’t to try out automatic reloading support, you may want to check out halive.
Unfortunately I couldn’t get it to work on my machine (OS/X Maverick), but it might work our for you though :-)


data Artist = Artist
{ artistId :: Int
, name :: String
} deriving (Eq, Show, Generic)

A simple type describing the shape of an Artist in our app.

instance ToJSON Artist (1)

type ArtistAPI = (2)
Get '[JSON] [Artist] (3)
:<|> Capture "artistId" Int :> Get '[JSON] Artist (4)

artistsServer :: Server ArtistAPI
artistsServer = getArtists :<|> artistOperations (5)

where getArtists :: EitherT ServantErr IO [Artist]
getArtists = return artists (6)

artistOperations artistId =

where viewArtist :: EitherT ServantErr IO Artist
viewArtist = artistById artistId (7)

ToJSON is a type class. This line
basically is all we need to set up for json encoding an instance of our Artist type.

We describe our REST api using a type

Get on this api returns a list of Artists

Definition of how to get a single Artist by it’s id

The server type is the part where we descibe how we actually serve the api

The handler for listing artists. Currently it just returns a static list

The handler for retrieving a given artist by its id

:<> is a combinator that ships with Servant. It allows us to combine the various parts
of our API into a single type.

artistById :: Int -> EitherT ServantErr IO Artist
artistById idParam =
case a of
Nothing -> left (err404 {errBody = "No artist with given id exists"}) (1)
Just b -> return b (2)
a = find ((== idParam) . artistId) artists (3)

If the find (by id) in 3 returns Nothing (see Maybe monad).
We return a 404 error with a custom body

Upon success return the given artist instance

Find a given artist by id from our List of artists

EitherT - An either monad. Check out the description from the servant tutorial on EitherT

Wrapping it all up

type API = "artists" :> ArtistAPI (1)

api :: Proxy API
api = Proxy (2)

app :: Application
app = serve api artistsServer (3)

main :: IO ()
main = run 8081 app (4)

A generic type for our api. It let’s us combine multiple types, but the
main reason it’s factored out for now is to avoid repetion of the root path for our
api artists

TBH I haven’t grokked why this is needed, but it’s probably to do with some type magic ?

An "abstract" web application. serve gives us a WAI web application.
I guess WAI is like a common API for Haskell Web applicaitons.

The main entry point for our application. It starts our web application on port 8081
(and uses warp behind the scene to do so.)

To get the backend up and running, check out the readme for the sample application

Backend experiences

Following the Servant tutorial it was quite
easy to get a simple translated example to work. However I did start to struggle once I started
to venture off from the tutorial. Some of it is obviously due to my nearly non-existing haskell knowledge.
But I think what tripped me up most was the EitherT monad. Heck I still don’t really know what
a monad is. The error messages I got along the way didn’t help me much, but I guess gradually
they’ll make more and more sense, once my haskell foo improves.


So Elm is pretty cool. The syntax isn’t too far off from Haskell. I’ve already started
looking at Elm so it makes sense continuing with Elm to hopefully gain deeper knowledge of its
strenghts and weaknesses.

For a really pleasurable experience when developing elm I would suggest choosing an
editor with linting support. As a shameless plug, one suggestion would be to use Light Table
with my elm-light plugin. (Emacs, Vim, Sublime, Visual Code are other good options)

Project setup

"version": "1.0.0",
"summary": "The frontend for the Albums CRUD sample app",
"repository": "",
"license": "MIT",
"source-directories": [
"." (1)
"exposed-modules": [],
"dependencies": { (2)
"elm-lang/core": "3.0.0 <= v < 4.0.0",
"evancz/elm-effects": "2.0.1 <= v < 3.0.0",
"evancz/elm-html": "4.0.2 <= v < 5.0.0",
"evancz/elm-http": "3.0.0 <= v < 4.0.0",
"evancz/start-app": "2.0.2 <= v < 3.0.0"
"elm-version": "0.16.0 <= v < 0.17.0"

For simplicity source files currently resides in the root folder of the project.
This will change once the application grows

Initial set of dependencies used


Before you start you may want to check out start-app.
The frontend code is based on this.

type alias Artist = (1)
{ id : Int
, name : String

type alias Model = (2)
{ artists : List Artist}

type Action = ArtistRetrieved (Maybe (List Artist)) (3)

Front end representation of Artist. You’ll notice it’s strikingly similar
to it’s Haskell counterpart on the server side

Type for keeping track of our model. Currently it will only contain
a list of artists, but there is more to come later

"Tagged type" that describes the actions supported in the frontend app.

init : (Model, Effects Action)
init = (1)
( Model []
, getArtists

update : Action -> Model -> (Model, Effects Action)
update action model = (2)
case action of
ArtistRetrieved xs ->
( {model | artists = (Maybe.withDefault [] xs) }
, Effects.none

getArtists : Effects.Effects Action
getArtists = (3)
Http.get artists "http://localhost:8081/artists"
|> Task.toMaybe
|> ArtistRetrieved
|> Effects.task

artist : Json.Decoder Artist
artist = (4)
Json.object2 Artist
("artistId" :=
("name" := Json.string)

artists : Json.Decoder (List Artist)
artists = (5)
Json.list artist

Initializer function called by start-app when staring the application
it returns an empty model and an effect getArtists. Meaning getArtists will be
invoked once the page is loaded

The update function handles actions in our app. Currently it only supports
one action, and that is the a callback once getArtists have returned. It updates
the model with the retrieved artists and returns the updated model

Our ajax call ! We invoke the our rest endpoint using the elm http library. The first
argument to Http.get, artists, tells elm how to decode the result.
A lot is going on here, but the end result is that it does an xhr request decodes the result (if success)
using the given decoder and eventually invoke the update function with our list of artists (wrapped in a Maybe).

A decoder for decoding the json representation of an artist from the server to and Artist type instance

The response from our rest endpoint is a list of artists, so we use the JSON.list function
telling it to use our artist decoder for each item in the list

artistRow : Artist -> Html
artistRow artist = (1)
tr [] [
td [] [text (toString]
,td [] [text]

view : Signal.Address Action -> Model -> Html
view address model = (2)
div [class "container-fluid"] [
h1 [] [text "Artists" ]
, table [class "table table-striped"] [
thead [] [
tr [] [
th [] [text "Id"]
,th [] [text "Name"]
, tbody [] ( artistRow model.artists)

Function to generate the view for a single artist row

Our main view function for presenting a list of artists

We are not rendering dom nodes here, it’s just a representation of what we want
to render. The actual rendering uses Virual DOM.

Wrapping up the frontend

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

main : Signal Html
main = (2)

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

Using startapp to wire up our core functions (init, update and view)

The entry point function for our frontend app

When communicating with the outside world elm uses ports.
This is used for by our rest invocation. It does so using tasks which
is the elm way to describe asynchronous operations.

Frontend experiences

Elm ports, tasks and effects are concepts that are yet to dawn completely on me. I protect my brain
temporarily by giving them overy simplistic explanations.
I wasn’t sure how to do the JSON decoding stuff, but fired up an elm-repl in Light Table and just experiemented a little until
I had something workable.
I used the linter feature of my Light Table plugin quite heavily, and the error messages from elm proved yet again
to be very helpful.

Conclusion and next steps

I pretty sure I could have knocked this up with Clojure/ClojureScript, groovy/grails or plan old JavaScript
in a fraction of the time I’ve used. But that’s not really a fair or relevant comparison.
Learning completely new languages and new libraries takes time.
I think I’ve learned quite a bit already and I’m very pleased to have made it this far !

Elm was easier to get into than Haskell and the Elm compiler felt a lot more helpful to me than
ghc (haskell compiler). I had a head start on Elm, but I do remember getting started with Elm felt
a lot smoother than jumping into Haskell. I’m still very much looking forward to improving my haskell skills
and I’m sure that will proove very valuable eventually.

So what’s up next? Not sure, but i think adding persistence and the facility to add/update
artists might be next up. I will keep you posted !

Posted by codecentric on Fri, 12/18/2015 - 18:39

Nearly all modules you’ll write in Elm need to import other modules to do their work; also, all our examples so far had some import statements. In this episode, we take a closer look at the import statement and at the different ways to import modules.

About This Series
This is the eighth 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.
Qualified Imports
Let’s look at a basic example that just renders some static HTML:
import Html
import Html.Attributes

main : Html.Html
main =
Html.div []
[ Html.p [] [ Html.text "This is the first paragraph" ]
, Html.p [] [ Html.text "This is another paragraph" ]
, [] []
, Html.ul []
[ [] [ Html.text "some" ]
, [] [ Html.text "bullet" ]
, [] [ Html.text "points" ]
, Html.p []
[ Html.text "This is the "
, Html.span
[ [("font-weight", "bold")] ]
[ Html.text "closing"
, Html.text " paragraph."
This would render the following HTML:
<p>This is the first paragraph</p>
<p>This is another paragraph</p>
This is the <span style="font-weight: bold;">closing</span> paragraph.
As always, go ahead and try stuff out for yourself, for example by copying this into a file named Imports.elm and check the result with elm-reactor.
This piece of Elm imports two modules, Html and Html.Attributes:

import Html
import Html.Attributes

An import statement basically tells the Elm compiler to load these two modules and to use stuff from them whenever it encounters anything that is prefixed with Html. (or Html.Attributes., respectively). Thus, we know that the functions Html.text or that we are using in the example code come from said modules.
By the way, where do the imported modules come from? That depends. You can import modules from third party packages that have been installed via elm-package install. You can also import your own modules from your current project’s source folder (there will be a separate blog post on how to structure your code base with modules later).
In this example, we are importing modules from the package evancz/elm-html so you would need to install this via elm-package install --yes evancz/elm-html to follow along. If you already did the examples in episode 3 or episode 4 you can just create a new file (say, Imports.elm) in the same elm-playground directory and you are good to go. We already installed the elm-html package there.
Coming back to the example code, let’s be honest here: This code looks really bloated with all the redundant Html.qualifiers. This is where the exposing keyword comes in.
Open Imports aka Unqualified Imports
The following code example makes use of open imports by using import exposing, so that the imported identifiers can be used without prefix.

import Html exposing (Html, div, hr, li, p, span, text, ul)
import Html.Attributes exposing (style)

main : Html
main =
div []
[ p [] [ text "This is the first paragraph" ]
, p [] [ text "This is another paragraph" ]
, hr [] []
, ul []
[ li [] [ text "some" ]
, li [] [ text "bullet" ]
, li [] [ text "points" ]
, p []
[ text "This is the "
, span
[ style [("font-weight", "bold")] ]
[ text "closing"
, text " paragraph."

The first difference I would like to draw your attention to is in the import statement section:

import Html
import Html.Attributes


import Html exposing (Html, div, hr, li, p, span, text, ul)
import Html.Attributes exposing (style)

By appending exposing to the import statement we can specify a list of identifiers that can be used unqualified (that is, without the module name as a prefix) in our module. That’s the reason why we can drop all the Html. prefixes in the main function. Html.text becomes just text, Html.p becomes p, and so on.
Another detail is that this does not only apply to functions but to all identifiers that a modules exports. In particular, it also applies to types. The type annotation in the first example had to be written as

main : Html.Html

This is because the name of the module that we import is Html and the name of the type that this module exports is also Html. Thus, the full qualified name of that type is Html.Html.
In the second example we added the name of the type to the list of identifiers to be exposed for unqualified usage – if you look close enough, you can spot the Html in the exposing clause for the Html import. With that, the type annotation in the second example can be written as

main : Html

Expose Everything
The second example already looks a bit cleaner. However, as soon as you start to use more and more HTML tags (or, functions from the Html module, that is) you always need to add them to the exposing part of the import. This can be a bit annoying. Elm has a special import syntax to avoid this.

import Html exposing (..)
import Html.Attributes exposing (..)

-- main function is the same as in the second example

With import Html exposing (..) we tell the Elm compiler to expose every identifier the Html module has to offer and we can use them all in their unqualified form.
Import Aliases
Another feature of the import statement is that you can alias the imported module.
Say, you would not want to import unqualified from Html.Attributes, for whatever reason. You would have to prefix the styles function call with Html.Attributes again, as in our first example. Html.Attributes.styles is pretty long though. What you can do is define an alias for that:

import Html.Attributes as Attr
Html.Attributes by prefixing them with Attr, like this: [("font-weight", "bold")]

You can also combine aliases and exposing. This might make sense if you only expose a few of the imported identifiers but still want a shorthand notation for the qualified usages.

import Html as H exposing (Html)

main : Html
main =
H.div [] [ H.text "whatever" ]

Here, we only expose the type Html for unqualified usage (thus, we can write the type annotation as main : Html instead of main : Html.Html) but alias the module name Html as H and use this alias to refer to the functions from Html. (Note: I do not recommend this approach, see below for some recommended best practices regarding imports.)
Default Imports
A small number of modules are imported into every module by default, even if you do not have explicit import statements for them. Here is the set of default imports (for Elm 0.16):

import Basics exposing (..)
import Debug
import List exposing ( List, (::) )
import Maybe exposing ( Maybe( Just, Nothing ) )
import Result exposing ( Result( Ok, Err ) )
import Signal exposing ( Signal )

This means that, for example, you can use every function from the Basics module, without prefixing them.
There are two things that might need a little explaining with these import statements.
First, the import statement for List exposes ( List, (::) ): The module List has a type named List that gets exposed. This is pretty straight forward and we have already seen this with the Html module. But what is this (::) about that also gets exposed? Function names in Elm usually use alphanumeric characters, but you can also use identifiers that only use non-alphanumeric characters (:, |, <, $, ...), you just need to wrap those names in parantheses in the function definition and when importing them. As you might recall from our last episode, :: is the append operator for lists. It is actually not something special build into the Elm compiler but just a regular function definition on the List module. We can use the function (::) everywhere because it is imported and exposed by default. Also, you can always use functions like this without the parantheses as infix operators. That's the reason why you can write [1, 2] :: [3, 4] in Elm without importing anything explicitly. You can also define your own infix operators that way.
Second, the exposing clauses for the Maybe and Result imports use syntax we have not covered yet. The module Maybe exports a union type named Maybe. We did not talk about union types yet. For now, it suffices to say that a union type is just an enumeration of type values. Here is the definition of the Maybe type:

type Maybe a = Just a | Nothing

So a value of type Maybe can either be Nothing or Just a for some other type a.
The import statement import Maybe exposing ( Maybe( Just, Nothing ) ) makes the two individual values from the union type (Just and Nothing) available to our code.
Best Practices for Import Statements
Now that we have completed our short tour of import statements in Elm, it is time to talk about some recommendations regarding code style.
The following are my personal preferences, you are welcome to come up with your own.

  1. Use qualified imports as much as possible. That is, prefer import Array over import Array exposing (..). This makes your code a bit more verbose, but it is immediately obvious where an identifier comes from.
  2. Use exposing (..) only for a few selected modules. Actually, I tend to only use it for Html, Html.Attributes and Html.Events at all, nothing else.
  3. Expose types that have the same name as their module. That is, for a (fictional) module named LinkedList, that also exports a type LinkedList, use import LinkedList exposing (LinkedList). This way, you can use the type in type annotations like someFunction : LinkedList instead of writing someFunction : LinkedList.LinkedList.
  4. Do not use aliases (import Something as Sth) to shorten module names. In my opinion the savings in characters it is not worth the additional cognitive load, especially when modules are aliased differently all over your code base.
  5. Do use aliases for multi-segment module names and use the last segment as the alias. Example: import Some.Thing.MyModule as MyModule.

A Word About Writing HTML in Elm
This episode is about import statements but somehow we also briefly touched the topic of how to produce HTML in a readable fashion. The third example given above (using import Html exposing (..) is okay-ish, but probably not the best we can do.
If you are used to templating languages, you might not like how that looks in Elm. There is a very good discussion about that on the elm-discuss mailing list. Go read it if you are interested in patterns to do this in a nice way. In particular, this answer seems to get it quite right from my point of view.
Last but not least, the modules elm-html-shorthand and elm-bootstrap-html might come in handy for this.
Remarks About Pre-0.15 Syntax
Elm is still relatively young and the syntax has changed a few times with the latest versions. The syntax will probably stay much more stable with the 1.0 release. There are still a lot of examples out there using older syntax. With regard to imports, version 0.15 brought some important changes, introducing the exposing keyword.
You might stumble over examples using the old syntax without the exposing syntax, like this:

import Html (..)
import Html.Attributes (style)

For this, just insert exposing between the module name and the list of exposed identifiers.
With this we conclude the eighth episode of this blog post series on Elm. Stay tuned for the next episode. See you next time!
The post Elm Friday: Imports (Part VIII) appeared first on codecentric Blog.

Posted by LambdaCat on Tue, 12/15/2015 - 15:30

I recently decided to retrain myself as a terminal Emacs user (I'm nostalgic for the '80s and my old glorious green and black terminal :P)

So I switched all my Elm editing from Sublime Text (which works and is pretty nice) to Emacs (which also works and is pretty nice)

Posted by codecentric on Fri, 12/04/2015 - 23:45

Lists are one of the core data structures in Elm. Elm supports lists on the syntactical level and the List core module has the usual basic utilities you would expect from a functional language. In this post, we take a look at lists in general and some of the useful functions from that module.

About This Series
This is the seventh 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.
Prelude: elm-repl
A great way to follow along and immediately try the code of this episode (instead of just reading it, which would probably be quite boring) is Elm’s REPL (read-eval-print-loop). With Elm installed, just start elm-repl in the command line. You should see something like this:

---- elm repl 0.16.0 -----------------------------------------------------------
:help for help, :exit to exit, more at

Now any Elm expression that you type will be evaluated immediately and the result is printed back to you. You probably wouldn’t want to develop anything complicated in the REPL but it’s great for playing around with some basic code snippets. So each time you see some code in this episode, try it out in the REPL and tinker with it. Have fun!
Creating Lists
There are a number of ways to create lists in Elm. The most straight forward thing is to simply write down the elements, comma separated, between square brackets:

aList = [1, 2, 3, 4]

[1,2,3,4] : List number

This looks a lot like arrays in C-Style programming languages, but Lists in Elm do not support positional access (you can not simply read/set the element at index n). Elm also has Array module, that offers positional access. But only lists are directly supported by syntactical elements so most of the times you’ll be working with lists.
As mentioned in the last episode, the actual type of a list always contains the type of its elements, that’s why the REPL infers the type List number here (you could also annotate this as List Intnumber is a supertype of Int).
Of course you can build lists from any type of values, not just primitives like Int, as long as all elements have the same type. Here’s a list of tuples for you:

[(1, 2, "three"), (4, 5, "six"), (7, 8, "nine")]

However, the following would raise a type error, because the second tuple has a different type than the first.

[(1, 2, "three"), (4, "five")]


-- TYPE MISMATCH --------------------------------------------- repl-temp-000.elm

The 1st and 2nd elements are different types of values.

3│ [(1, 2, "three"), (4, "five")]
The 1st element has this type:

( number, number', String )

But the 2nd is:

( number, String )

Hint: All elements should be the same type of value so that we can iterate
through the list without running into unexpected values.

When lists get longer you can and should split their definition over multiple lines. The style most people are used to (and which works fine in Elm) would probably look similar to this:

aList = [(1, 2, "three"),
(4, 5, "six"),
(7, 8, "nine")]

However, a lot of Elm code (including the code in Elm core and several community packages) use a different style where the comma is at the start of the line:

aList : List (number, number, String)
aList = [ (1, 2, "three")
, (4, 5, "six")
, (7, 8, "nine")

Of course, this is simply a matter of taste but it probably helps to have seen this style once so you know what’s up here.
(A remark for those of you who are following along with the REPL: Multiline expressions are possible in the REPL, though a bit of a hassle. End each line with a \ and start all lines except the first with a space. Or just skip the REPL tinkering for the multiline code snippets.)
Another way to create lists is the dot notation. The following snippet creates a list of Ints from 1 to 10.



[1,2,3,4,5,6,7,8,9,10] : List number

Last but not the least, in addition to the syntactical constructs to create lists you can also use functions from the List module. List.repeat takes an integer n and one arbitrary value and returns a list with n copies of this value.

List.repeat 4 "Elm"


"Elm","Elm","Elm","Elm"] : List String

List Manipulation
While this section is called “List Manipulation” you can not actually manipulate an existing list. In Elm, everything is immutable. The functions to manipulate a list all create a new list and leave the original list unchanged.
The prepend operator :: prepends an item to the start of the list:

1 :: [2, 3, 4]


[1,2,3,4] : List number

You can prepend multiple times in a row. Theoretically you could always start with an empty list and build your lists only by prepending elements:

1 :: 2 :: 3 :: 4 :: []


[1,2,3,4] : List number

There is no operator to add a single element to the end of a list. You can however, append a list to another list:

List.append [1, 2, 3] [4, 5]


[1,2,3,4,5] : List number

There is an infix operator ++ that is an alias for append:

[1, 2, 3] ++ [4, 5]


[1,2,3,4,5] : List number

So to add a single element to the end of a list you usually just wrap it in a list and use `append`/`++`. like this:

[1, 2, 3] ++ [4]


[1,2,3,4] : List number

Another way to build up a single list from smaller lists is the concat function which takes a list of lists and concatenates all of the individual lists into one large list:

List.concat [ ["one", "two", "three"], ["four", "five"], ["six"], ["seven", "eight", "nine"] ]


["one","two","three","four","five","six","seven","eight","nine"] : List String

Classics of Functional Programming
Now that we know a few different ways to build and manipulate lists, let’s have a look at some of the classical list functions that go beyond that.
Where would functional programming be without a map function? Of course the List module has one. takes a function and a list and applies the function to all elements in the list. The result is a new list in which each element is the result of the function, applied to the respective element in the original list. Here is an example (please execute import String in the REPL before trying the example): ( word -> String.length word) ["a", "ab", "abc"]


[1,2,3] : List Int

In this example, we applied the length function to all elements in the list of strings.
List.filter is a similar evergreen. It takes a function and a list and removes all elements from the list for which the function returns False. The following snippet removes all negative numbers from the list.

List.filter ( n -> (n > 0)) [-1, 3, -2, 7]


[3,7] : List number

There are a lot more useful functions in the list module. Just to name a few:

  • List.head retrieves the first element of a list.
  • List.tail returns a new list where the first element has been dropped.
  • List.foldl and List.foldr reduce a list to a single element by combining the first two elements with a given function, then combining the result with the next element, and so on.

Best check the List module’s API docs what else it has to offer.
Finally, if the List module from core does not have what you need, check out the community package List.Extra for even more functional list goodness.
This concludes the seventh episode of this blog post series on Elm. Stay tuned for the next episode. See you next Friday!
The post Elm Friday: Lists (Part VII) appeared first on codecentric Blog.

Posted by codecentric on Fri, 11/27/2015 - 13:44

One of Elm’s most important characteristics is its static type system. This enables Elm to make much stronger guarantees during run time compared to dynamic languages like JavaScript. This boils down to “If it compiles, it’ll never throw a runtime exception”. In this episode, we’ll look into the type system and on type annotations in particular more closely.

About This Series
This is the sixth 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.
Type Annotations Versus Type Inference
Although Elm is a statically typed language, our examples in the previous posts had no type declarations whatsoever. The reason is that Elm can infer the type of almost any expression. That means that everything is typed, either explicitly by adding a type annotation or implicitly by relying on Elm’s type inference.
Let’s revisit some of the functions from the last episode and add type annotations to them. The type annotations are the line just before the function definition:

import Html

multiply : number -> number -> number
multiply a b = a * b

square : number -> number
square a = multiply a a

productOfSquares : number -> number -> number
productOfSquares a b = multiply (square a) (square b)

incrementAll : List number -> List number
incrementAll list = (\ n -> n + 1) list

incrementAll2 : List number -> List number
incrementAll2 = (\ n -> n + 1)

main : Html.Html
main =
print n = Html.text <| toString n
Html.p []
[ print <| multiply 3 5
, [] []
, print <| square 4
, [] []
, print <| productOfSquares 2 3
, [] []
, print <| incrementAll [1, 2, 3]
, [] []
, print <| incrementAll2 [1, 2, 3]

(Remark: I refactored the main function a bit from the last episode by extracting the duplicated conversion from number/list into an HTML text element.)
To pick one example, square : number -> number is the type annotation for the function definition of square. A type annotation should be written directly in the line above the function definition. It is comprised of the function name, a colon, and the types of all input parameters and the return type, each separated by ->.
There is no distinction between a parameter type and the return type. Coming from other languages, you might expect that the type annotation for multiply somehow makes it clear that two numbers go in and one number comes out. For example the type signature could read (number, number) -> number. It doesn't. The separator between the first and second input parameter is ->, just as the separator between the second input parameter and the return type. This is because talking about first and second input parameter is just one way of thinking about multiply. You could also say that multiply takes only one parameter and returns a function with the signature number -> number. Both are equally valid points of view. You can either think of this function as (number, number) -> number or number -> (number -> number). The reason is that Elm supports currying and partial function application naturally.
Here is a code example that illustrates this:

import Html

multiply : number -> number -> number
multiply a b = a * b

multiplyByFive : number -> number
multiplyByFive = multiply 5

-- The expression (multiply 5) yields a new function with signature
-- (number -> number) by partial appication, that is: the first argument to
-- multiply is provided, but not the second.

main : Html.Html
main = multiplyByFive 3 |> toString |> Html.text

-- As you probably have guessed, the output of this snippet is 15.

Composing Types
Let's also have a look at the other two functions from the previous episode (and their type annotations):

incrementAll : List number -> List number
incrementAll list = (\ n -> n + 1) list

incrementAll2 : List number -> List number
incrementAll2 = (\ n -> n + 1)

These functions work with lists, but when talking about lists it is also important which type the elements in the list have. Therefore the full type here is not simply List but List number, that is, a list of number elements. This is just an example for the more general concept of parameterized types. This is mostly used in containers (like List or Maybe) and usually defines which type the contained elements have.
Generating Type Annotations Automatically
You can even let the Elm compiler tell you the type annotations. If you have Elm code without type annotations and you compile it with elm-make with the --warn flag, it will tell you all type annotations it inferred.
Going back to the example from the previous post (which had no type annotations), here's how that looks like:
elm-make --warn Functions.elm

=================================== WARNINGS ===================================

-- missing type annotation -------------------------------------- Functions.elm

Top-level value `multiply` does not have a type annotation.

3│ multiply a b = a * b
I inferred the type annotation so you can copy it into your code:

multiply : number -> number -> number

Isn't that nice? I think it is.
Adding type annotations to your programs or omitting them is a matter of taste and style. However, the Elm style guide recommends having type annotations on all top level definitions. In my experience they often make it easier to solve compiler errors. And, to be quite honest, you'll do a fair share of fighting compiler errors when working with Elm. Therefore it usually pays off to add type annotations to your functions.
There is much more to Elm's type system then what have covered today -- union types, type aliases, type variables, tuples and records to name a few – but those will be topics for another Elm Friday.
This concludes the sixth episode of this blog post series on Elm. Stay tuned for the next episode. See you next Friday!
The post Elm Friday: Type Annotations (Part VI) appeared first on codecentric Blog.

Posted by on Wed, 11/25/2015 - 02:00

My slightly obsessive endeavour of reading and doing everything stipulated on the official Elm Get Started page meant that after reading the Elm Complete Guide the Pragmatic Studio was up next. The guide was great, although a lot of the later stuff went over my head on first reading and I got the impression that a video course would be a useful way of tying together several loose threads in my quest to learn Elm.

Continue reading…