Haskell

Functions in Haskell are pure. Pure functions have no side-effects. If a function is called twice with the same parameters, it's guaranteed to return the same result (referential transparency).

Haskell's if is an expression instead of a statement. Since expressions must return a value, the else is mandatory in Haskell.

doubleSmallNumber x = if x > 100 then x else x*2

In Haskell, lists are a homogeneous data structure; list elements must be the same type. Strings are syntactic sugar for character lists.

[1,2,3,4]

-- Concatenation
[1,2,3,4] ++ [9,10,11,12]

-- Cons operator
'A':" SMALL CAT"

-- Indexing
"Steve Buscemi" !! 6

Common list functions include head, tail, last, init (get all but last), length, null (test if empty), reverse, take, drop, maximum, minimum, sum, product, and elem (test for membership).

Tuples, unlike lists, don't have to be homogeneous. Tuples also have a specific length defined in their type. Denote tuples with parenthesis ((1,2)). fst and snd are useful functions that operate on pairs. zip is a function that produces pairs.

Haskell has a static type system; the type of every expression is known at compile time. The :t command in ghci gives an expression's type (e.g. "Hi" :: [Char]). :: is read as "has type of."

When writing functions, we can choose to given them an explicit type declaration (generally good practice).

removeNonUppercase :: [Char] -> [Char]
removeNonUppercase st = [c | c <- st, c `elem` ['A'..'Z']]

Haskell has type inference. However, we must sometimes add a type annotation (e.g. read "5" :: Int).

When defining functions, you can define separate bodies for different patterns. Patterns are checked from top to bottom. The program will crash if no patterns match.

factorial :: (Integral a) => a -> a
factorial 0 = 1
factorial n = n * factorial (n - 1)

Pattern matching can also be used on tuples (e.g. (x, y)) and lists (e.g. (x:xs))

As patterns let one break up according to a pattern and keep a reference to the whole thing. This is done by putting a name and an @ in front of a pattern. For example, all@(x:xs).

A guard is a boolean expression indicated with a pipe. A series of guards can appear after a function's name and parameters. If a guard evaluates to True, the corresponding function body is used. The last guard may be otherwise as a catch all. Use guards instead of patterns when testing for a boolean condition.

max' :: (Ord a) => a -> a -> a
max' a b
    | a > b     = a
    | otherwise = b

A where clause can appear after guards. This keyword can define several names and functions which will be visible across the guards. A let, in contrast, won't span across guards. Where bindings are a syntactic construct, lets are expressions.

A let binding is an expression that defines local variables. The form is let <bindings> in <expression>.

cylinder :: (RealFloat a) => a -> a -> a
cylinder r h =
    let sideArea = 2 * pi * r * h
        topArea = pi * r ^2
    in  sideArea + 2 * topArea

Let bindings can also appear in list comprehensions. Notice that in is omitted.

[bmi | (w, h) <- xs, let bmi = w / h ^ 2, bmi >= 25.0]

Case expressions are expressions that perform pattern matching. Note that pattern matching on parameters in function definitions is syntactic sugar for case expressions.

case expression of <pattern> -> <result>
                   <pattern> -> <result>
                   <pattern> -> <result>
                   ...

A higher order function is a function that either that accepts functions as parameters or returns functions. Indicate function parameters with parenthesis:

applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)

All Haskell functions that accept several parameters are curried functions. A function that takes two arguments is really a function that takes one argument and returns another function. If we call a function with too few parameters we get a partially applied function. Infix functions can be partially applied using sections. To section an infix function, simply surround it with parentheses and only supply a parameter on one side.

map, filter, foldl, and foldr are higher order functions. foldl1 and foldr1 are similar to foldl and foldr, but don't require an explicit starting value. They cause runtime errors if called with empty lists. scanl and scanr are also similar to foldl and foldr. They report all the intermediate accumulator states in the form of a list.

A Haskell module is a collection of related functions, types and typeclasses. A Haskell program is a collection of modules where the main module loads up the other modules and then uses the functions defined in them to do something. The Haskell standard library is split into modules. See this handy reference. Use import to load a module. In GHCi, load a module with :m.

-- Make Data.List exports available in the global namespace.
import Data.List

-- We can choose not to import certain functions.
import Data.List hiding (nub)

-- Qualified imports help avoid name clashes.
import qualified Data.Map

-- We can also choose to rename the module.
import qualified Data.Map as M

Modules export functions. These functions act as a sort of interface to the module. At the beginning of a module specify the name and function exports.

-- This would be at the top of Geometry.hs
module Geometry
( cubeVolume
, cubeArea
) where

Modules can also be given hierarchical structures. We just need to specify the directory name as part of the module name. For example, the module name could be Geomertry.Cube if we had a Cube.hs file in a Geometry folder.

Use the data keyword to define a type. Here's Bool from the standard library:

data Bool = False | True

The parts after the = are value constructors. The | is read as or. Both the type name and the value constructors have to be capital cased. Value constructors are functions that take parameters and return a value of a data type.

data Point = Point Float Float
data Shape = Circle Point Float | Rectangle Point Point

Circle (Point 0 0) 5

Notice that when defining a point, we used the same name for the data type and the value constructor. This has no special meaning, although it's common if there's only one value constructor.

The putStrLn function has the type declaration putStrLn :: String -> IO (). An I/O action carries out an action with a side effect. This action will be performed when we give it a name of main and run our program.

main = do
    putStrLn "Hello, what's your name?"
    name <- getLine
    putStrLn ("Hey " ++ name ++ ", you rock!")

The do syntax glues together several I/O actions into one. By convention, we don't usually specify a type declaration for main. \

The <- construct binds an I/O action's result value to a name. getLine has the type declaration getLine :: IO String. So in the example above, name will have the type String. In Haskell, return makes an I/O action out of a pure value. Return is the opposite of <-. For example return "haha" will have a type IO String. Haskell's return is nothing like the return in most other languages.

To run a program you can either compile it and then run the produced executable file by doing ghc --make helloworld and then ./helloworld or you can use the runhaskell command like so: runhaskell helloworld.hs and your program will be executed on the fly.

Useful functions for dealing with I/O are putStr, putChar, print, getChar, when, sequence, mapM, forM, forever, getContents, and interact.

Here's a program that reads a file and prints the contents:

import System.IO

main = do
    handle <- openFile "girlfriend.txt" ReadMode
    contents <- hGetContents handle
    putStr contents
    hClose handle

We can also do this with the withFile function:

import System.IO

main = do
    withFile "girlfriend.txt" ReadMode (\handle -> do
        contents <- hGetContents handle
        putStr contents)

We also have the nice constructs readFile, writeFile, and appendFile.