Previously we mentioned that Elm has a static type system. The type of every expression is known at compile time, which leads to safer code. If you write a program where you try to divide a boolean type with some number, it won’t even compile. That’s good because it’s better to catch such errors at compile time instead of having your program crash. Everything in Elm has a type, so the compiler can reason quite a lot about your program before compiling it.
Unlike Java or Pascal, Elm has type inference. If we write a number, we don’t have to tell Elm it’s a number. It can infer that on its own, so we don’t have to explicitly write out the types of our functions and expressions to get things done. We covered some of the basics of Elm with only a very superficial glance at types. However, understanding the type system is a very important part of learning Elm.
A type is a kind of label that every expression has. It tells us in
which category of things that expression fits. The expression
True is a
"hello" is a string, etc.
Now we’ll use elm-repl to examine the types of some expressions. We’ll do that by typing expressions into elm-repl. After each valid expression, the repl tells us its type. Let’s give it a whirl.
TODO: Add a section on elm-repl, or come up with a different way to accomplish this in the online editor. Maybe type holes?
> 'a' 'a' : Char > True True : Bool > [1, 2] [1,2] : List number > (True, 'a') (True, 'a') : ( Bool, Char ) > 4 == 5 False : Bool
Here we see that typing an expression prints
out the value of that expression followed by
: and its type.
: is read as “has type of”. Explicit types are always denoted with the
first letter in capital case.
'a', as it would seem, has a type of
It’s not hard to conclude that it stands for character.
True is of a
Bool type. That makes sense. Examining the type of
[1, 2] yields a
List number. The lowercase
n in the type of number indicates
a built-in type variable. We’ll get to type variables later in this chapter.
A number can be either an
Int or a
Float, and will concretely become one or
the other depending on how it’s used. Unlike lists, each tuple length has
its own type. So the expression of
(True, 'a') has a type of
( Bool, Char ),
whereas an expression such as
('a','b','c') would have the type of
( Char, Char, Char ).
4 == 5 will always return
False, so its type is
Functions also have types. When writing our own functions, we can choose to give them an explicit type declaration. This is generally considered to be good practice. From here on, we’ll give all the functions that we make type declarations. Remember the first function we made previously that doubles a number? Here’s how it looks like with a type declaration.
doubleMe : number -> number doubleMe x = x + x
doubleMe has a type of
number -> number, meaning that it maps
from a number to a number. That’s because it takes one number as a
parameter and returns another as a result.
We didn’t have to give this function a type declaration because
the compiler can infer by itself that it’s a function from a number to a
number but we did anyway. But how do we write out the type of a function
that takes several parameters? Here’s a simple function that takes three
integers and adds them together:
addThree : Int -> Int -> Int -> Int addThree x y z = x + y + z
The parameters are separated with
-> and there’s no special distinction
between the parameters and the return type. The return type is the last
item in the declaration and the parameters are the first three. Later on
we’ll see why they’re all just separated with
-> instead of having some
more explicit distinction between the return types and the parameters
Int, Int, Int -> Int or something.
If you want to give your function a type declaration but are unsure as to what it should be, you can always just write the function without it and then check it in elm-repl. Functions are expressions too, so it works on them without a problem. To write a multi-line expression in elm-repl, add a backslash to the end of each line you want to continue on the line below, like this.
> addThree x y z = \ | x + y + z <function> : number -> number -> number -> number
Here’s an overview of some common types.
Int stands for integer. It’s used for whole numbers.
7 can be an
Int is bounded, which means that it has a minimum and a
maximum value. The maximum possible value of
2147483647 and the
circumference : Float -> Float circumference r = 2 * pi * r
toPrint = circumference 4.0 25.132742
Bool is a boolean type. It can have only two values:
Char represents a character. It’s denoted by single quotes.
String represents a string. It’s denoted by double or triple quotes and
can contain many characters. Triple quoted strings are string literals
that can span across multiple lines, with line breaks and whitespace
being preserved in the string.
Tuples are types but they are dependent on their length as well as the
types of their components, so there is theoretically an infinite number
of tuple types, which is too many to cover in this tutorial. Note that
the empty tuple
() is also a type which can only have a single value:
This value is read as
"unit" and is the common way to denote an empty
value with no specific meaning.
What do you think the type of the List
length function is? Well,
takes a list of any type and returns its length, so what could it be? Let’s check!
> List.length <function> : List a -> Int
Hmmm! What is this
a? Is it
a type? Remember that we previously stated that types are written in
capital case, so it can’t exactly be a type. Because it’s not in capital
case it’s actually a type variable. That means that
a can be of any
type. This is much like generics in other languages, only in Elm
it’s much more powerful because it allows us to easily write very
general functions if they don’t use any specific behavior of the types
in them. Functions that have type variables are called polymorphic
functions. The type declaration of
length states that it takes a list of
any type and returns an
Int representing the length of that list.
Although type variables can have names longer than one character, we usually give them names of a, b, c, d …
Earlier in this chapter we mentioned the
number type variable. This is a
type variable built-in to Elm that specifically represents either an
Float, but nothing else. There are other bult-in type variables
representing other important things.
comparable represents types that can
be compared for equality with the
== operator. This can be
Time, or a list or tuple containing only comparable values.
toPrint = 4 == 5 False
appendable represents items that can be appended to each other with the
++ operator. These are
toPrint = "Hello" ++ "!" "Hello!"
Tuple.first? It returns the first component of a pair. Let’s examine
> Tuple.first <function> : ( a1, a2 ) -> a1
We see that
first takes a tuple which contains two types and returns an
element which is of the same type as the pair’s first component. That’s
why we can use
first on a pair that contains any two types. Note that just
a2 are different type variables, they don’t have to be
different types. It just states that the first component’s type and the
return value’s type are the same.