What does the : infix operator do in Haskell?

Question

I'm reading A Gentle Introduction to Haskell (which is not so gentle) and it repeatedly uses the : operator without directly explaining what it does.

So, what exactly does it do?

Answer 1

: is the “prepend” operator:

x : xs

Returns a list which has x as first element, followed by all elements in xs. In other functional languages, this is usually called cons, because it “cons”tructs a list recursively by repeated application from an empty list:

1 : 2 : 3 : 4 : []

is the list [1, 2, 3, 4].

Answer 2

Could always check out the types in GHCi/HUGS, as the first steps in the tutorial encourage you to download GHC/HUGS.

Prelude> :t (:)
(:) :: a -> [a] -> [a]
Prelude> :t (++)
(++) :: [a] -> [a] -> [a]

From their respective types, it's quite easy to deduce their usage.

PS: http://haskell.org/hoogle/ is awesome.

Answer 3

The : operator in Haskell is the constructor for lists. It 'cons' whatever is before the colon onto the list specified after it.

For instance, a list of integers is made by 'consing' each number onto the empty list, e.g;

The list [1,2,3,4] can be constructed as follows:

• 4 : [] (consing 4 to the empty list)
• 3 : [4] (consing 3 onto the list containing 4)
• 2 : [3,4] (consing 2 onto the list containing 3, 4)
• 1 : [2,3,4] (consing 1 onto the list containing 2,3,4)

giving you;

[1,2,3,4]

Written fully that's;

1 : 2 : 3 : 4 : []

Answer 4

It is the type constructor for lists. It is no different from any other type constructor like Just or Left, except that it is infix. Valid type constructors can either be words starting with a capital letter, or symbols starting with a colon.

So you can define infix constructors for your own data types. For example:

data MyList a = a :> MyList a
              | Empty

in the above code we define a type called MyList with two constructors: the first is a weird-looking constructor :> which takes an element and another MyList a; the second is an empty constructor Empty which is equivalent to [] in Haskell's native lists.

The above is equivalent to :

data MyList a = Cons a  (MyList a)
              | Empty