Haskell

An advanced, purely functional programming language

TODO

References

[haskell-wikibook] Haskell by en.wikibooks.org
wiki.haskell.org/Learning_Haskell
wiki.haskell.org/Meta-tutorial
wiki.haskell.org/Keywords
www.haskell.org/documentation/
[a-gentle-introduction-to-haskell] A Gentle Introduction To Haskell by Paul Hudak, John Peterson, Joseph Fasel
[haskell-2010] Haskell 2010 Language Report
[haskell-98] Haskell 98 Language and Libraries The Revised Report December 2002
[a-history-of-haskell] A History of Haskell: Being Lazy With Class
[learn-you-a-haskell] Learn You a Haskell for Great Good! A Beginner’s Guide by Miran Lipovača
[cheatsheet] Haskell Cheat Sheet
Introduction to Haskell (Spring 2013) by Brent Yorgey at University of Pennsylvania
en.wikibooks.org/wiki/Yet_Another_Haskell_Tutorial
wiki.haskell.org/Literate_programming

Basics

So far, if I could pick just one resource from which to learn Haskell, it would be the [haskell-wikibook].

$ curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh

Start Haskell REPL (interactive session)

$ ghci

Comment Text Until the End of a Line

ghci> -- Double dash makes comment up to the end of the line.

Evaluation of Expressions

Because Haskell is a purely functional language, all computations are done via the evaluation of expressions (syntactic terms) to yield values

— [a-gentle-introduction-to-haskell]
chapter 2 Values, Types, and Other Goodies

Expression False yields boolean value False.

ghci> False
False

Expression [] yields empty list [].

ghci> []
[]

Expression [ False , True ] yields list [False,True].

ghci> [ False  ,   True    ]
[False,True]

Types

NOTE: :type is one of GHCi commands.

Value False has type (::) boolean type (Bool).

ghci> :type False
False :: Bool

Empty list ([]) has type (::) list of type a ([a]).

ghci> :type []
[] :: [a]

List with False value ([False]) has type (::) list of booleans ([Bool]).

ghci> :type [False]
[False] :: [Bool]

Zero (0) has type (::) type a constrained (=>) to be instance of class Num (Num a).

ghci> :type 0
0 :: Num a => a

List of three numbers ([1,2,3]) has type (::) list of type a ([a]) constrained (=>) to be instance of class Num (Num a).

ghci> :type [1,2,3]
[1,2,3] :: Num a => [a]

Kinds

Nullary kind

ghci> :kind Bool
Bool :: *
ghci> :kind [Bool]
[Bool] :: *
ghci> :kind [] Bool
[] Bool :: *
ghci> :kind (Bool -> Bool)
(Bool -> Bool) :: *
ghci> :kind (->) Bool Bool
(->) Bool Bool :: *

Unary kind

ghci> :kind []
[] :: * -> *
ghci> :kind (->) Bool
(->) Bool :: * -> *

Binary kind

ghci> :kind (->)
(->) :: * -> * -> *

Lazy Evaluation

Generate list of numbers from 1 to 10 inclusive.

ghci> [1..10]
[1,2,3,4,5,6,7,8,9,10]

Take the first 10 values from infinite sequence of numbers starting with 1.

ghci> take 10 [1..]
[1,2,3,4,5,6,7,8,9,10]

Because Haskell is lazy, it won’t try to evaluate the infinite list immediately because it would never finish. It’ll wait to see what you want to get out of that infinite lists.

— learnyouahaskell.com/starting-out#texas-ranges

Function Application

Function application is denoted by juxtaposition and associates to the left. Thus, f x y is parsed (f x) y.

— [a-history-of-haskell]

ghci> take 10 [1..]
[1,2,3,4,5,6,7,8,9,10]
ghci>
ghci> (take 10) [1..]
[1,2,3,4,5,6,7,8,9,10]

Function Type

Function not has type (::) applied to boolean (Bool) returns (->) boolean (Bool).

ghci> :type not
not :: Bool -> Bool

Function not applied to value True returns False.

ghci> not True
False

Currying

a function of two arguments may be represented as a function of one argument that itself returns a function of one argument.

— [a-history-of-haskell]

Function take has type (::) applied to Int returns (->) function with type [a] -> [a].

ghci> :type take
take :: Int -> [a] -> [a]

Definition of takeFirst10 by application of function take to the number 10.

ghci> takeFirst10 = take 10
ghci> :type takeFirst10
takeFirst10 :: [a] -> [a]
ghci>
ghci> takeFirst10 [1..]
[1,2,3,4,5,6,7,8,9,10]

Infix Operators

[Lexically, infix operators consist entirely of "symbols," as opposed to normal identifiers which are alphanumeric (§2.4). Haskell has no prefix operators, with the exception of minus (-), which is both infix and prefix.]

— [a-gentle-introduction-to-haskell]
chapter 3 Functions

Infix Operator Examples

ghci> 0 - 1
-1
ghci> 10 ^ 2
100
ghci> 0 : []
[0]
ghci> 1 : 0 : []
[1,0]
ghci> [0] ++ [1]
[0,1]
ghci> ['a'..] !! 9
'j'

A section is a partial application of an infix operator to no arguments, the left argument, or the right argument—and by surrounding the result in parentheses

— [history-of-haskell]

Sections

ghci> power = (^)
ghci> 2 `power` 3
8
ghci> power 2 3
8
ghci>
ghci> cube = (^3)
ghci> cube 2
8
ghci>
ghci> powerOf2 = (2^)
ghci> powerOf2 3
8

WARNING: (-42) equals to -42 not to a function that subtracts 42. In order to get the later, write (subtract 42)

There are very few predefined “operators” in Haskell - most that do look predefined are actually syntax (e.g., “=”). Instead, operators are simply functions that take two arguments and have special syntax support.

— [cheatsheet]

Allowable symbols which can be used to define operators are:
# $ % & * + . / < = > ? @ \ ^ | - ~
However, there are several “operators” which cannot be redefined. They are: <-, -> and =. The last, =, cannot be redefined by itself, but can be used as part of multi-character operator.

— [cheatsheet]

Precedence and Associativity

A fixity declaration can be given for any infix operator or constructor (including those made from ordinary identifiers, such as elem). This declaration specifies a precedence level from 0 to 9 (with 9 being the strongest; normal application is assumed to have a precedence level of 10), and left-, right-, or non-associativity.

— [a-gentle-introduction-to-haskell]
chapter 3 Functions

If no fixity declaration is given for a particular operator, it defaults to infixl 9.

— [a-gentle-introduction-to-haskell]
chapter 3 Functions

Fixity information can be can be obtained using :info command in ghci.

ghci> :info /
type Fractional :: * -> Constraint
class Num a => Fractional a where
  (/) :: a -> a -> a
  ...
  	-- Defined in ‘GHC.Real’
infixl 7 /

Fixity infixl 7 / means infix operator, left associativity, precedence 7.

Left Associativity

ghci> 1 / 2 / 3
0.16666666666666666
ghci> (1 / 2) / 3
0.16666666666666666
ghci> 1 * 2 / 3
0.6666666666666666

Right Associativity

ghci> 3 ^ 2 ^ 1 ^ 0
9
ghci> 3 ^ (2 ^ (1 ^ 0))
9
ghci> ((3 ^ 2) ^ 1) ^ 0
1

Definition of division operator /// with right associativity in file RightDivision.hs

module RightDivision ((///)) where

infixr  7 ///
(///) :: Fractional a => a -> a -> a
a /// b = a / b

Load RightDivision.hs and use /// operator.

ghci> :load RightDivision
[1 of 1] Compiling RightDivision    ( RightDivision.hs, interpreted )
Ok, one module loaded.
ghci> 1 /// 2 /// 3
1.5

Different associativities of the same precedence operators leads to a parsing error.

ghci> 1 /// 2 * 3

<interactive>:6:1: error:
    Precedence parsing error
        cannot mix ‘///’ [infixr 7] and ‘*’ [infixl 7] in the same infix expression

Modules

A Haskell program is a collection of modules, one of which, by convention, must be called Main and must export the value main.

— [haskell-2010] Chapter 5 Modules

A module begins with a header: the keyword module, the module name, and a list of entities (enclosed in round parentheses) to be exported. The header is followed by a possibly-empty list of import declarations (impdecls, Section 5.3) that specify modules to be imported, optionally restricting the imported bindings. This is followed by a possibly-empty list of top-level declarations (topdecls, Chapter 4).

— [haskell-2010] Chapter 5 Modules

Example of module Main header

Following header creates module Main, which exports function main.

module Main(main) where

This exact header is inserted as a first line, if other header is omitted.

For more information, see en.wikibooks.org/wiki/Haskell/Modules.

base: Basic libraries

This package contains the Standard Haskell Prelude and its support libraries, and a large collection of useful libraries ranging from data structures to parsing combinators and debugging utilities.

Prelude

There is one distinguished module, Prelude, which is imported into all modules by default

— [haskell-2010] Chapter 5 Modules

Data.Maybe

Data.Function

Simple combinators working solely on and with functions.

Identity function id
Constant function const
Function composition. (.)
Flip function flip
Function application operator ($)
Reverse application operator (&)
fix is the least defined x such that f x = x
on b u x y runs the binary function b on the results of applying unary function u to two arguments x and y.

To understand fix I recommend reading en.wikibooks.org/wiki/Haskell/Fix_and_recursion and en.wikibooks.org/wiki/Haskell/Denotational_semantics.

Functor

Minimal complete definition: fmap

class Functor f where
        fmap :: (a -> b) -> f a -> f b

Applicative

A minimal complete definition must include implementations of pure and of either <*> or liftA2

class Functor f => Applicative f where
        pure :: a -> f a
        (<*>) :: f (a -> b) -> f a -> f b

Monad

Minimal complete definition (>>=)

class Applicative m => Monad m where
        (>>=) :: forall a b. m a -> (a -> m b) -> m b

Do Expressions

A do expression provides a more conventional syntax for monadic programming. It allows an expression such as
putStr "x: "    >>
getLine         >>= \l ->
return (words l)
to be written in a more traditional way as:
do putStr "x: "
   l <- getLine
   return (words l)

— [haskell-2010]
3.14 Do Expressions

wiki.haskell.org/Monad

ap                :: (Monad m) => m (a -> b) -> m a -> m b
ap m1 m2          = do { x1 <- m1; x2 <- m2; return (x1 x2) }

Semigroup

Minimal complete definition: (<>) | sconcat

class Semigroup a where
        (<>) :: a -> a -> a

Monoid

Minimal complete definition: mempty | mconcat

class Semigroup a => Monoid a where
        mempty :: a

Foldable

Minimal complete definition foldMap | foldr

class Foldable t where
        foldMap :: Monoid m => (a -> m) -> t a -> m

wiki.haskell.org/Fold

Traversable

Minimal complete definition traverse | sequenceA

class (Functor t, Foldable t) => Traversable t where
        traverse :: Applicative f => (a -> f b) -> t a -> f (t b)

Packages

Hackage is the Haskell community’s central package archive of open source software. Hackage has been online since January 2007 and is constantly growing.

— hackage.haskell.org/

containers: Assorted concrete container types: This package contains efficient general-purpose implementations of various immutable container types including sets, maps, sequences, trees, and graphs.
safe: Library of safe (exception free) functions: A library wrapping Prelude/Data.List functions that can throw exceptions, such as head and !!. Each unsafe function has up to four variants
lens: Lenses, Folds and Traversals: The combinators in Control.Lens provide a highly generic toolbox for composing families of getters, folds, isomorphisms, traversals, setters and lenses and their indexed variants.
repa: High performance, regular, shape polymorphic parallel arrays.: Repa provides high performance, regular, multi-dimensional, shape polymorphic parallel arrays.
array: Mutable and immutable arrays: In addition to providing the Data.Array module as specified in the Haskell 2010 Language Report, this package also defines the classes IArray of immutable arrays and MArray of arrays mutable within appropriate monads, as well as some instances of these classes.