Elm is an actively used programming language created in 2012.

 7Years Old 11,554Users 129Jobs

### Example code from the Hello World Collection:

```-- Hello world in Elm

import Text

main = Text.plainText "Hello, world!"```

### Example code from Linguist:

```main = asText (qsort [3,9,1,8,5,4,7])

qsort lst =
case lst of
x:xs -> qsort (filter ((>=)x) xs) ++ [x] ++ qsort (filter ((<)x) xs)
[] -> []

{---------------------

QuickSort works as follows:
- Choose a pivot element which be placed in the "middle" of the sorted list.
In our case we are choosing the first element as the pivot.
- Gather all of the elements less than the pivot (the first filter).
We know that these must come before our pivot element in the sorted list.
Note: ((>=)x) === (\y -> (>=) x y) === (\y -> x >= y)
- Gather all of the elements greater than the pivot (the second filter).
We know that these must come after our pivot element in the sorted list.
- Run `qsort` on the lesser elements, producing a sorted list that contains
only elements less than the pivot. Put these before the pivot.
- Run `qsort` on the greater elements, producing a sorted list. Put these
after the pivot.

Note that choosing a bad pivot can have bad effects. Take a sorted list with
N elements. The pivot will always be the lowest member, meaning that it does
not divide the list very evenly. The list of lessers has 0 elements
and the list of greaters has N-1 elemens. This means qsort will be called
N times, each call looking through the entire list. This means, in the worst
case, QuickSort will make N^2 comparisons.

----------------------}
```

### Example code from Wikipedia:

```-- This is a single line comment

{- This is a multi-line comment.
It can span multiple lines.
-}

{- It is possible to {- nest -} multi-line comments -}

-- Here we define a value named ''greeting''. The type is inferred as a String.
greeting =
"Hello World!"

-- It is best to add type annotations to top-level declarations.
hello : String
hello =
"Hi there."

-- Functions are declared the same way, with arguments following the function name.
x + y

-- Again, it is best to add type annotations.
hypotenuse : Float -> Float -> Float
hypotenuse a b =
sqrt (a^2 + b^2)

-- Functions are also curried; here we've curried the multiplication
-- infix operator with a `2`
multiplyBy2 : number -> number
multiplyBy2 =
(*) 2

-- If-expressions are used to branch on values
absoluteValue : number -> number
absoluteValue number =
if number < 0 then negate number else number

-- Records are used to hold values with named fields
book : { title : String, author : String, pages : Int }
book =
{ title = "Steppenwolf"
, author = "Hesse"
, pages = 237
}

-- Record access is done with `.`
title : String
title =
book.title

-- Record access `.` can also be used as a function
author : String
author =
.author book

-- We can create entirely new types with the `type` keyword.
-- The following value represents a binary tree.
type Tree a
= Empty
| Node a (Tree a) (Tree a)

-- It is possible to inspect these types with case-expressions.
depth : Tree a -> Int
depth tree =
case tree of
Empty ->
0

Node value left right ->
1 + max (depth left) (depth right)```
Edit

Last updated February 11th, 2019