dino-/haskell-symbols.md

## haskell-symbols.md

      
    Raw
  

              haskell-symbols.md
            
          
    Haskell symbols

When starting out with Haskell, I found it difficult to read a lot of the
symbols. I made this document explaining the names of some symbols and
how I read them.
:: "has type"

x :: Int

x has type Int
-> "to"

Int -> String

Int to String
The type Int -> String takes an Int as an argument and evaluates to a String.
We say this type is "Int to String".
Putting :: and -> together

foo :: a -> b -> c

foo has type a to b to c
=> "for all"

This symbol is for declaring type class constraints. A type class lets us
define common methods across types. It limits a type.
foo :: (Bar a) => a -> b

for all a of type class Bar, foo has type a to b
[a] "list of a"

: "cons"

List cons operator. Adds the first argument to the front of the second. In
module Data.List. I believe the name comes from Lisp, for "constructing"
or "construction"
(:) :: a -> [a] -> [a]
1 : [2, 3] == [1, 2, 3]

!! "element at"

List index operator
(!!) :: [a] -> Int -> a
[1, 2, 3] !! 1 == 2

Element in the list [1, 2, 3] at index 1
<- "drawn from"

Used in list comprehensions (and called a generator there) and monadic do notation
x <- something

x drawn from something
| "such that" in list comprehensions

Also used for function guards.
Putting | and <- together in a list comprehension:

[ x * x | x <- [1, 2, 3], x > 1 ]

A list of x multiplied by x such that x is drawn from the list [1, 2, 3], where
x is greater than 1.
>>= "bind"

Monadic bind operator. Part of type class Monad.
(>>=) :: Monad m => m a -> (a -> m b) -> m b

>> "then"

Monadic sequence operator. Part of type class Monad.
(>>) :: Monad m => m a -> m b -> m b

x >> y

x then y
<$> "fmap"

An infix synonym for fmap