# Keywords

### From HaskellWiki

NeilMitchell (Talk | contribs) (→case, of) |
m (Added let without in, marked unreserved keywords: qualified, as, hiding, forall) |
||

Line 158: | Line 158: | ||

== as == | == as == | ||

− | Renaming module imports. | + | Renaming module imports. Like <hask>qualified</hask> and <hask>hiding</hask>, <hask>as</hask> is not a reserved word but may be used as function or variable name. |

<haskell> | <haskell> | ||

Line 305: | Line 305: | ||

== forall == | == forall == | ||

− | This is a GHC/Hugs extension, and as such is not portable Haskell 98. | + | 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 | Type variables in a Haskell type expression are all assumed to be | ||

Line 337: | Line 338: | ||

== hiding == | == hiding == | ||

− | When importing modules, | + | When importing modules, without introducing a name into scope, entities can be excluded by using the form |

<haskell> | <haskell> | ||

hiding (import1 , ... , importn ) | hiding (import1 , ... , importn ) | ||

Line 421: | Line 422: | ||

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. | 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 <hask>do</hask>-blocks or list comprehensions <hask>let { d1 ; ... ; dn }</hask> without <hask>in</hask> serves to indroduce local bindings. | ||

== module == | == module == |

## Revision as of 13:08, 9 October 2006

This page lists all Haskell keywords, feel free to edit. Hoogle searches will return results from this page. Please respect the Anchor macros.

For additional information you might want to look at the Haskell 98 report.

## Contents |

## 1 |

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

## 2 ->

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):

(->) :: ?? -> ? -> *

## 3 <-

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

## 4 @

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 }

## 5 !

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

## 6 ::

Read as "has type":

length :: [a] -> Int

"Length has type list-of-'a' to Int"

## 7 _

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 }

## 8 ~

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)

## 9 as

Renaming module imports. Likeimport qualified Data.Map as M main = print (M.empty :: M.Map Int ())

## 10 case, of

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 _|_.

## 11 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

## 12 data

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.

## 13 default

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)

## 14 deriving

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)

## 15 do

Syntactic sugar for use with monadic expressions. For example:

do { x ; result <- y ; foo result }

is shorthand for:

x >> y >>= \result -> foo result

## 16 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 expression

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)

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]

## 17 hiding

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)

## 18 if, then, else

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

## 19 import

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 = ...

## 20 infix, infixl, 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 = ...

## 21 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

## 22 let, in

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## 23 module

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

## 24 newtype

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 `Identifier`

s 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.

## 25 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

## 26 type

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

## 27 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