This operator token is magic/irregular in the sense that <haskell>(- 1)</haskell> is parsed as the negative integer -1, rather than as an operator Section of an infix operator | section, as it would be for any other operator: <haskell>(* 1) :: Num a ⇒ a → a</haskell> <haskell>(++ “foo”) :: String → String</haskell>

It is syntactic sugar for the <hask>negate</hask> function in Prelude. See unary operator. If you want the section, you can use the <hask>subtract</hask> function or <hask>(+(-1))</hask>.

Starts a single-line comment, unless immediately followed by an operator character other than <hask>-</hask>:

<haskell> main = print “hello world” – this is a comment –this is a comment as well —this too foobar –+ this_is_the_second_argument_of_the_dash_dash_plus_operator </haskell>

The multi-line variant for comments is <hask>{- comment -}</hask>.

Arrow notation

Arrow notation

• The function type constructor:

<haskell> length :: [a] → Int </haskell>

• In lambda functions:

<haskell> \x → x + 1 </haskell>

• To denote alternatives in case statements:

<haskell> case Just 3 of

   Nothing -> False
   Just x  -> True

or with LambdaCase: <haskell> (\ case 1 → 0

     ; _ -> 1 )

or with MultiWayIf: <haskell> if ]] | 1 == 0 -> 1 | 1 == 2 -> 2 | * -> * -> * </haskell> * [[Functional dependencies <haskell> – This examples assumes that each type 'c' can “contain” only one type – i.e. type 'c' uniquely determines type 'elt' class Contains c elt ]] | c -> elt where ... </haskell> * [[View patterns

Read as “has type”:

<haskell> length :: [a] → Int </haskell>

“Length has type list-of-'a' to Int”

Or “has kind” (GHC specific):

<haskell> Either :: * →

• → *

</haskell>

• Statement separator in an explicit block (see layout)

• In do-notation, “draw from”:

<haskell> do x ← getChar

  putChar x

• In list comprehension generators, “in”:

<haskell> [ (x,y) ]] | x <- [1..10], y <- ['a'..'z'] ] </haskell> * In [[pattern guards, “matches”: <haskell> f x y ]] | Just z <- g x = True | otherwise = False </haskell> == , == Separator in lists, tuples, records. <haskell> [1,2,3] (1,2,3) Point {x = 1, y = 2} </haskell> In list comprehensions before generators, "and" (the first comma after <code> | <haskell> [ (x,y) | x <- [1..10], y <- ['a'..'z'], x > 42 ] </haskell> In list comprehensions before Boolean tests, "when" (the second comma after <code> | <haskell> [ (x,y) | <haskell> case [1,3,9] of xs | Ord a => [a] -> [a] </haskell> == > == In a Bird's style [[Literate_programming | Literate Haskell file, the > character is used to introduce a code line.

<haskell> comment line

main = print “hello world”

</haskell>

<haskell> ghci> :t ?foo ++ “bar” ?foo ++ “bar” :: (?foo::[Char]) ⇒ [Char] </haskell>

• MagicHash

• Is an ordinary operator name on the value level

• On the kind level: The kind of boxed types (GHC-specific)

<haskell> ghci> :kind Int Int :: * </haskell>

• Patterns of the form <hask>var@pat</hask> are called as-patterns, and allow one to use <hask>var</hask> as a name for the value being matched by <hask>pat</hask>. 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 }
   

• Visible type applications

• Template Haskell
  • Expression quotation: <hask> []] | print 1 | <hask> [d | main = print 1 | <hask> [t | Either Int () | <hask> [p | (x,y) | ] </hask> ** [[Quasiquotation: <hask> [nameOfQuasiQuoter]] | ... | <haskell> case e of { [x,y,z] -> if x==0 then True else False } </haskell> == ` == A function enclosed in back ticks "`" can be used as an infix operator. <haskell>2 `subtract` 10</haskell> is the same as <haskell>subtract 2 10</haskell> == {, } == * Explicit block (disable [[layout), possibly with “;” .

• Record update notation

<haskell> changePrice :: Thing → Price → Thing changePrice x new = x { price = new } </haskell>

• Comments (see below)

Everything between “{-” followed by a space and “-}” is a block comment.

<haskell> {- hello world -} </haskell>

The “pipe” is used in several places

• Data type definitions, “or”

<haskell> data Maybe a = Just a ]] | Nothing </haskell> * List comprehensions, "for" (as in, "list of <code>a*a</code> for <code>a</code> in <code>[1..]</code>) <haskell> squares = [a*a | a <- [1.. </haskell>

• Guards, “when”

<haskell> safeTail x ]] | null x = [] | otherwise = tail x </haskell> * [[Functional dependencies, “where” <haskell> class Contains c elt ]] | Lazy_pattern_matching the Haskell Wikibook]. * Equality constraints. Assert that two types in a context must be the same: <haskell> example :: F a ~ b => a -> b </haskell> Here the type "F a" must be the same as the type "b", which allows one to constrain polymorphism (especially where type families are involved), but to a lesser extent than functional dependencies. See [[Type_families#Equality_constraints | Type Families.

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> import qualified Data.Map as M

main = print (M.empty :: M.Map Int ()) </haskell>

A case expression has the general form

<haskell>

case e of { p1 match1 ; ... ; pn matchn }

where each

match

_i is of the general form

<haskell> ]] | g1 -> e1 ... | <haskell> pat | in the <code>where</code> clause associated with that alternative. If one of the guards evaluates to <code>True</code>, the corresponding right-hand side is evaluated in the same environment as the guard. If all the guards evaluate to <code>False</code>, matching continues with the next alternative. If no match succeeds, the result is _ | class-decls 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. <haskell> class Num a where (+) :: a -> a -> a negate :: a -> a </haskell> == data == The [http://haskell.org/onlinereport/decls.html#user-defined-datatypes data] declaration is how one introduces new algebraic data [[types into Haskell. For example: <haskell> data Set a = NilSet

          ]] | [[ ConsSet a (Set a)

Another example, to create a datatype to hold an Abstract_syntax_tree | abstract syntax tree for an expression, one could use: <haskell>

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.

Declares a datatype family (see type families). GHC language extension.

Declares a datatype family instance (see type families). GHC language extension.

Ambiguities in the class Num are most common, so Haskell provides a way to resolve them—with a default declaration:

<haskell> default (Int) </haskell>

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:

<haskell>

 default (Integer, Double)

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.

<haskell> data T = A

      ]] | [[ B
      ]] | [[ C
      deriving (Eq, Ord, Show)

In the case of newtypes, GHC extends this mechanism to Cunning Newtype Deriving.

Standalone deriving (GHC language extension).

<haskell> {-# LANGUAGE StandaloneDeriving #-} data A = A

deriving instance Show A </haskell>

Syntactic sugar for use with monadic expressions. For example:

<haskell>

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

is shorthand for:

<haskell>

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

This is a GHC/Hugs extension, and as such is not portable Haskell 98/2010. 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/2010. For example, the type expression <hask>a → a</hask> denotes the type <hask>forall a. a →a</hask>. 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, <haskell> forall a. a → a </haskell> means <haskell> forall a. (a → a) </haskell>

GHC introduces a <hask>forall</hask> keyword, allowing explicit quantification, for example, to encode existential types: <haskell> 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] </haskell>

A keyword for the Foreign Function Interface (commonly called the FFI) that introduces either a <hask>foreign import</hask> declaration, which makes a function from a non-Haskell library available in a Haskell program, or a <hask>foreign export</hask> declaration, which allows a function from a Haskell module to be called in non-Haskell contexts.

When importing modules, without introducing a name into scope, entities can be excluded by using the form <haskell> hiding (import1 , … , importn ) </haskell> which specifies that all entities exported by the named module should be imported except for those named in the list.

For example: <haskell> import Prelude hiding (lookup,filter,foldr,foldl,null,map) </haskell>

A conditional expression has the form:

<haskell>

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 _]] | as | as, hiding | hiding , qualified | qualified and the page Import

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

<haskell>

 module Bar where
   infixr 7 `op`
   op = ...

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.

<haskell>

 instance Num Int  where
   x + y       =  addInt x y
   negate x    =  negateInt x

Let expressions have the general form:

<haskell>let { d1 ; … ; dn } in e</haskell>

They introduce a nested, lexically-scoped, mutually-recursive list of declarations (let is often called let rec 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 introduce local bindings.

The recursive <hask>do</hask> keyword enabled by -fglasgow-exts.

Taken from: A Gentle Introduction to Haskell, Version 98

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:

<haskell> module Tree ( Tree(Leaf,Branch), fringe ) where

data Tree a = Leaf a ]] | Tree a -> [a] fringe (Leaf x) = [x] fringe (Branch left right) = fringe left ++ fringe right </haskell> == newtype == The <code>newtype</code> 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 smart destructors | 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.

proc (arrow abstraction) is a kind of lambda, except that it constructs an arrow instead of a function.

Arrow notation

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:

<haskell> import qualified Data.Map

f x = lookup x – use the Prelude version g x = Data.Map.lookup x – use the Data.Map version </haskell>

Of course, Data.Map is a bit of a mouthful, so qualified also allows the use of as.

<haskell> import qualified Data.Map as M

f x = lookup x – use Prelude version g x = M.lookup x – use Data.Map version </haskell>

The rec keyword can be used when the

-XDoRec

flag is given; it allows recursive bindings in a do-block.

<haskell> {-# LANGUAGE DoRec #-} justOnes = do { rec { xs ← Just (1:xs) }

             ; return (map negate xs) }

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:

<haskell> type Identifier = String </haskell>

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:

<haskell> type FilePath = String type String = [Char] type Rational = Ratio Integer type ReadS a = String → [(a,String)] type ShowS = String → String </haskell>

Declares a type synonym family (see type families). GHC language extension.

Declares a type synonym family instance (see type families). GHC language extension.

Used to introduce a module, instance, class or GADT: <haskell> module Main where

class Num a where

   ...

instance Num Int where

   ...

data Something a where

  ...

And to bind local variables: <haskell> f x = y

   where y = x * 2

g z ]] | //wiki.haskell.org/Keywords ==Research More== [[Haskell Research:

• Haskell Reserved Words on O'Reilly
• Haskell Reserved Words on DuckDuckGo
• Haskell Reserved Words on javatpoint.com
• Haskell Reserved Words on w3schools.com
• Haskell Reserved Words on tutorialspoint.com
• Haskell Reserved Words on FreeCodeCamp.org
• Haskell Reserved Words on developers.redhat.com
• Haskell Reserved Words on IBM.com
• Haskell Reserved Words on docs.microsoft.com
• Haskell Reserved Words on whatis.techtarget.com
• Haskell Reserved Words on YouTube
• Haskell Reserved Words on GitHub
• Haskell Reserved Words on Reddit
• Haskell Reserved Words on scholar.google.com
• Haskell Reserved Words on Quora
• Haskell Reserved Words on DZone
• Haskell Reserved Words on Hacker Noon
• Haskell Reserved Words on StackOverflow

Fair Use Sources:

• Haskell Reserved Words on DuckDuckGo
• Haskell keywords on DuckDuckGo