HOOG `M \M ! - : < > @ _ a c
d e
# f g
h ! ! # # i
k l
m n
! ! o p " " q r
# # s
t ! " u v
w # # x y " " |$ $ ~% % { s k i a Y ] e o w % { e Q 7 u _ G / u a M 7 ) ~! ~% |/ |$ whereA where# typeV type" thenj then! qualified qualified of of newtype newtype module module mdo mdo let let keyword keyword instance instance infixr: infixr infixlR infixl infixi infix in| in import import if if hiding hiding foreign foreign forall forall else else do do deriving( deriving
defaultC default dataZ data classo class
case case as as _ _ @ @ > > <- <- :: :: -> -> -- -- ! ! % I H \G F E E C B A : 9 h7 5 3 2 1 - C- + * ) 5' $ c" a * = '
~ keyword ~ Lazy pattern bindings. Matching the pattern ~pat against a value
always suceeds, and matching will only diverge when one of the
variables bound in the pattern is used.
(f *** g) ~(x,y) = (f x, g y)
| keyword | & The "pipe" is used in several places
Data type definitions, "or"
data Maybe a = Just a | Nothing
List comprehensions, "where"
squares = [a*a | a <- [1..]]
Guards, do this "if this is true"
safeTail x | null x = []
| otherwise = tail x
where keyword where
Used to introduce a module, instance or class:
module Main where
class Num a where
...
instance Num Int where
...
And to bind local variables:
f x = y
where y = x * 2
g z | z > 2 = y
where y = x * 2
type keyword type9 The type declaration is how one introduces an alias for an
algebraic data type into Haskell. As an example, when writing a
compiler one often creates an alias for identifiers:
type Identifier = String
This allows you to use Identifer wherever you had used
String and if something is of type Identifier it may
be used wherever a String is expected.
See the page on types for more information, links and examples.
Some common type declarations in the Prelude include:
type FilePath = String
type String = [Char]
type Rational = Ratio Integer
type ReadS a = String -> [(a,String)]
type ShowS = String -> String
then keyword then A conditional expression has the form:
if e1 then e2 else e3
and returns the value of e2 if the value of e1 is True, e3 if e1 is
False, and _|_ otherwise.
max a b = if a > b then a else b
qualified keyword qualified Used to import a module, but not introduce a name into scope. For
example, Data.Map exports lookup, which would clash with the Prelude
version of lookup, to fix this:
import qualified Data.Map
f x = lookup x -- use the Prelude version
g x = Data.Map.lookup x -- use the Data.Map version
Of course, Data.Map is a bit of a mouthful, so qualified also allows
the use of as.
import qualified Data.Map as M
f x = lookup x -- use Prelude version
g x = M.lookup x -- use Data.Map version
of keyword ofF A case expression has the general form
case e of { p1 match1; ...; pn matchn }
where each match is of the general form
| g1 -> e1
...
| gm -> em
where decls
Each alternative consists of a pattern pi and its matches, matchi.
Each match in turn consists of a sequence of pairs of guards gj and
bodies ej (expressions), followed by optional bindings (decls) that
scope over all of the guards and expressions of the alternative. An
alternative of the form
pat -> exp where decls
is treated as shorthand for:
pat | True -> exp
where decls
A case expression must have at least one alternative and each
alternative must have at least one body. Each body must have the same
type, and the type of the whole expression is that type.
A case expression is evaluated by pattern matching the expression e
against the individual alternatives. The alternatives are tried
sequentially, from top to bottom. If e matches the pattern in the
alternative, the guards for that alternative are tried sequentially
from top to bottom, in the environment of the case expression extended
first by the bindings created during the matching of the pattern, and
then by the declsi in the where clause associated with that
alternative. If one of the guards evaluates to True, the corresponding
right-hand side is evaluated in the same environment as the guard. If
all the guards evaluate to False, matching continues with the next
alternative. If no match succeeds, the result is _|_.
newtype keyword newtypef The newtype declaration is how one introduces a renaming for
an algebraic data type into Haskell. This is different from
type below, as a newtype requires a new constructor
as well. As an example, when writing a compiler one sometimes further
qualifies Identifiers to assist in type safety checks:
newtype SimpleIdentifier = SimpleIdentifier Identifier
newtype FunctionIdentifier = FunctionIdentifier Identifier
Most often, one supplies smart constructors and destructors for these
to ease working with them.
See the page on types for more information, links and examples.
For the differences between newtype and data, see
Newtype.
module keyword moduleQ taken from: http://www.haskell.org/tutorial/modules.html
Technically speaking, a module is really just one big declaration
which begins with the keyword module; here's an example for a module
whose name is Tree:
module Tree ( Tree(Leaf,Branch), fringe ) where
data Tree a = Leaf a | Branch (Tree a) (Tree a)
fringe :: Tree a -> [a]
fringe (Leaf x) = [x]
fringe (Branch left right) = fringe left ++ fringe right
mdo keyword mdo? < the recursive do keyword enabled by -fglasgow-exts
let keyword let Let expressions have the general form:
let { d1; ...; dn } in e
They introduce a nested, lexically-scoped, mutually-recursive list of
declarations (let is often called letrec in other languages). The
scope of the declarations is the expression e and the right hand side
of the declarations.
Within do-blocks or list comprehensions let { d1 ; ... ;
dn } without in serves to indroduce local bindings.
keyword package keyword # Haskell keywords, always available
instance keyword instance An instance declaration declares that a type is an instance of a
class and includes the definitions of the overloaded operations -
called class methods - instantiated on the named type.
instance Num Int where
x + y = addInt x y
negate x = negateInt x
infixr keyword infixr ? A fixity declaration gives the fixity and binding precedence of one
or more operators. The integer in a fixity declaration must be in the
range 0 to 9. A fixity declaration may appear anywhere that a type
signature appears and, like a type signature, declares a property of a
particular operator.
There are three kinds of fixity, non-, left- and right-associativity
(infix, infixl, and infixr, respectively), and ten precedence levels,
0 to 9 inclusive (level 0 binds least tightly, and level 9 binds most
tightly).
module Bar where
infixr 7 `op`
op = ...
infixl keyword infixl" ? A fixity declaration gives the fixity and binding precedence of one
or more operators. The integer in a fixity declaration must be in the
range 0 to 9. A fixity declaration may appear anywhere that a type
signature appears and, like a type signature, declares a property of a
particular operator.
There are three kinds of fixity, non-, left- and right-associativity
(infix, infixl, and infixr, respectively), and ten precedence levels,
0 to 9 inclusive (level 0 binds least tightly, and level 9 binds most
tightly).
module Bar where
infixr 7 `op`
op = ...
infix keyword infix$ ? A fixity declaration gives the fixity and binding precedence of one
or more operators. The integer in a fixity declaration must be in the
range 0 to 9. A fixity declaration may appear anywhere that a type
signature appears and, like a type signature, declares a property of a
particular operator.
There are three kinds of fixity, non-, left- and right-associativity
(infix, infixl, and infixr, respectively), and ten precedence levels,
0 to 9 inclusive (level 0 binds least tightly, and level 9 binds most
tightly).
module Bar where
infixr 7 `op`
op = ...
in keyword inT' Let expressions have the general form:
let { d1; ...; dn } in e
They introduce a nested, lexically-scoped, mutually-recursive list of
declarations (let is often called letrec in other languages). The
scope of the declarations is the expression e and the right hand side
of the declarations.
Within do-blocks or list comprehensions let { d1 ; ... ;
dn } without in serves to indroduce local bindings.
import keyword import<) t Modules may reference other modules via explicit import declarations,
each giving the name of a module to be imported and specifying its
entities to be imported.
For example:
module Main where
import A
import B
main = A.f >> B.f
module A where
f = ...
module B where
f = ...
See also as, hiding and qualified
if keyword if* A conditional expression has the form:
if e1 then e2 else e3
and returns the value of e2 if the value of e1 is True, e3 if e1 is
False, and _|_ otherwise.
max a b = if a > b then a else b
hiding keyword hiding+ h When importing modules, without introducing a name into scope,
entities can be excluded by using the form
hiding (import1 , ... , importn )
which specifies that all entities exported by the named module should
be imported except for those named in the list.
For example:
import Prelude hiding (lookup,filter,foldr,foldl,null,map)
foreign keyword foreignl- i A keyword for the foreign function interface that is enabled by -ffi,
-fffi or implied by -fglasgow-exts
forall keyword forall . This is a GHC/Hugs extension, and as such is not portable Haskell 98.
It is only a reserved word within types.
Type variables in a Haskell type expression are all assumed to be
universally quantified; there is no explicit syntax for universal
quantification, in standard Haskell 98. For example, the type
expressiona -> a denotes the type forall a. a ->a.
For clarity, however, we often write quantification explicitly when
discussing the types of Haskell programs. When we write an explicitly
quantified type, the scope of the forall extends as far to the right
as possible; for example,
forall a. a -> a
means
forall a. (a -> a)
GHC introduces a forall keyword, allowing explicit
quantification, for example, to encode existential types:
data Foo = forall a. MkFoo a (a -> Bool)
| Nil
MkFoo :: forall a. a -> (a -> Bool) -> Foo
Nil :: Foo
[MkFoo 3 even, MkFoo 'c' isUpper] :: [Foo]
else keyword else1 A conditional expression has the form:
if e1 then e2 else e3
and returns the value of e2 if the value of e1 is True, e3 if e1 is
False, and _|_ otherwise.
max a b = if a > b then a else b
do keyword do2 Syntactic sugar for use with monadic expressions. For example:
do { x; result <- y; foo result }
is shorthand for:
x >>
y >>= \result ->
foo result
deriving keyword deriving3 data and newtype declarations contain an optional deriving form. If
the form is included, then derived instance declarations are
automatically generated for the datatype in each of the named classes.
Derived instances provide convenient commonly-used operations for
user-defined datatypes. For example, derived instances for datatypes
in the class Eq define the operations == and /=, freeing the
programmer from the need to define them.
data T = A
| B
| C
deriving (Eq, Ord, Show)
default keyword default6 a Ambiguities in the class Num are most common, so Haskell provides a
way to resolve them---with a default declaration:
default (Int)
Only one default declaration is permitted per module, and its effect
is limited to that module. If no default declaration is given in a
module then it assumed to be:
default (Integer, Double)
data keyword data7 \ The data declaration is how one introduces new algebraic data types
into Haskell. For example:
data Set a = NilSet
| ConsSet a (Set a)
Another example, to create a datatype to hold an [[Abstract syntax
tree]] for an expression, one could use:
data Exp = Ebin Operator Exp Exp
| Eunary Operator Exp
| Efun FunctionIdentifier [Exp]
| Eid SimpleIdentifier
where the types Operator, FunctionIdentifier and
SimpleIdentifier are defined elsewhere.
See the page on types for more information, links and examples.
class keyword class: A class declaration introduces a new type class and the overloaded
operations that must be supported by any type that is an instance of
that class.
class Num a where
(+) :: a -> a -> a
negate :: a -> a
case keyword case; A case expression has the general form
case e of { p1 match1; ...; pn matchn }
where each match is of the general form
| g1 -> e1
...
| gm -> em
where decls
Each alternative consists of a pattern pi and its matches, matchi.
Each match in turn consists of a sequence of pairs of guards gj and
bodies ej (expressions), followed by optional bindings (decls) that
scope over all of the guards and expressions of the alternative. An
alternative of the form
pat -> exp where decls
is treated as shorthand for:
pat | True -> exp
where decls
A case expression must have at least one alternative and each
alternative must have at least one body. Each body must have the same
type, and the type of the whole expression is that type.
A case expression is evaluated by pattern matching the expression e
against the individual alternatives. The alternatives are tried
sequentially, from top to bottom. If e matches the pattern in the
alternative, the guards for that alternative are tried sequentially
from top to bottom, in the environment of the case expression extended
first by the bindings created during the matching of the pattern, and
then by the declsi in the where clause associated with that
alternative. If one of the guards evaluates to True, the corresponding
right-hand side is evaluated in the same environment as the guard. If
all the guards evaluate to False, matching continues with the next
alternative. If no match succeeds, the result is _|_.
as keyword as-A Renaming module imports. Like qualified and hiding,
as is not a reserved word but may be used as function or
variable name.
import qualified Data.Map as M
main = print (M.empty :: M.Map Int ())
_ keyword _;B j Patterns of the form _ are wildcards and are useful when some part of
a pattern is not referenced on the right-hand-side. It is as if an
identifier not used elsewhere were put in its place. For example,
case e of { [x,_,_] -> if x==0 then True else False }
is equivalent to:
case e of { [x,y,z] -> if x==0 then True else False }
@ keyword @C 8 Patterns of the form var@pat are called as-patterns, and allow one to
use var as a name for the value being matched by pat. For example:
case e of { xs@(x:rest) -> if x==0 then rest else xs }
is equivalent to:
let { xs = e } in
case xs of { (x:rest) -> if x==0 then rest else xs }
> keyword > E In a bird style Literate Haskell file, the > character is used to
introduce a code line.
comment line
> main = print "hello world"
<- keyword <-E In do-notation:
do x <- getChar
putChar x
In list comprehension generators:
[ (x,y) | x <- [1..10], y <- ['a'..'z'] ]
In pattern guards (a GHC extension):
f x y | Just z <- g x = True
| otherwise = False
:: keyword ::F ] Read as "has type":
length :: [a] -> Int
"Length has type list-of-'a' to Int"
-> keyword ->{G % The function type constructor:
length :: [a] -> Int
In lambdas:
\x -> x + 1
To denote alternatives in case statements:
case Just 3 of
Nothing -> False
Just x -> True
And on the kind level (GHC specific):
(->) ::?? ->? -> *
-- keyword --H Line comment character. Everything after -- on a line is
ignored.
main = print "hello world" -- comment here
The multiline variant of comments is {- comment -}.
! keyword !I Whenever a data constructor is applied, each argument to the
constructor is evaluated if and only if the corresponding type in the
algebraic datatype declaration has a strictness flag, denoted by an
exclamation point. For example:
data STList a
= STCons a !(STList a) -- the second argument to STCons will be
-- evaluated before STCons is applied
| STNil
to illustrate the difference between strict versus lazy constructor
application, consider the following:
stList = STCons 1 undefined
lzList = (:) 1 undefined
stHead (STCons h _) = h -- this evaluates to undefined when applied to stList
lzHead (h: _) = h -- this evaluates to 1 when applied to lzList
! is also used in the "bang patterns" (GHC extension), to indicate
strictness in patterns:
f!x!y = x + y
Finally, it is the array subscript operator:
let x = arr ! 10
hM keyword 'http://haskell.org/haskellwiki/Keywords