A brief introduction to Haskell

From HaskellWiki
Revision as of 00:44, 27 October 2006 by DonStewart (talk | contribs) (start on translation of ocaml brief introduction)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

Inspired by the Introduction to OCaml.


Haskell is:

  • A language developed by the programming languages research community.
  • Is a lazy, purely functional language (that also has imperative

features such as side effects and mutable state, as well strict evaluation)

  • One of the youngest children of ML and Lisp
  • Particularly useful for manipulating data structures, (i.e. compilers and interpreters), and parallel programming


  • 1990. Haskell 1.0
  • 1991. Haskell 1.1
  • 1993. Haskell 1.2
  • 1996. Haskell 1.3
  • 1997. Haskell 1.4
  • 1998. Haskell 98
  • ~2007. Haskell Prime

Haskell Novelties

Has some novel features relative to Java (and C++).

  • Immutable variables by default (mutable state programmed via monads)
  • Pure by default (side effects are programmed via monads)
  • Lazy evaluation: results are only computed if they're required (strictness optional)
  • Everything is an expression
  • Completely higher-order functions: functions can be defined anywhere in the code, passed as arguments, and returned as values.
  • Both compiled and interpreted implementations available
  • Full type inference -- type declarations optional
  • Pattern matching on data structures -- data structures are first class!
  • Parametric polymorphism
  • Bounded polymorphism (based on type classes)

These are all conceptually more advanced ideas, for the average imperative language.

Compared to similar functional languages, GHC Haskell contains several newer language features:

  • Monads
  • Type classes
  • Generalised algebraic data types
  • Impredicative type system
  • Software transactional memory
  • Parallel, SMP runtime system

The Basics

Read the language definition section of the manual to supplement these notes. For more depth and examples see here[http://haskell.org/haskellwiki/Books_and_tutorials.

= Interacting with the language

Interacting with Haskell via the GHCi interpreter:

  • expressions are entered at the prompt
  • newline signals end of input

Here is a GHCi sessoin, starting from a UNIX prompt.

   $ ghci
      ___         ___ _
     / _ \ /\  /\/ __(_)
    / /_\// /_/ / /  | |      GHC Interactive, version 6.4.2, for Haskell 98.
   / /_\\/ __  / /___| |      http://www.haskell.org/ghc/
   \____/\/ /_/\____/|_|      Type :? for help.
   Loading package base-1.0 ... linking ... done.
    Prelude> let x = 3 + 4
  • Here the incredibly simple Haskell program let x = 3+4 is

compiled, loaded, and bound to the variable x.

Prelude> :t x
x :: Integer

We can ask the system what type it automaticaly inferred for our variable. x :: Integer means that the variable x "has type" Integer, the type of unbounded integer values.

Prelude> x

A variable evaluates to its value.

Prelude> x + 4

The variable x is in scope, so we can reuse it in later expressions.

Prelude> let x = 4 in x + 3

Local variables may be bound using let, which declares a new binding for a variable with local scope.

Alternatively, declarations typed in at the top level are like an open-ended let:

Prelude> let x = 4
Prelude> let y = x + 3
Prelude> x * x

Prelude> :t x
x :: Integer
Prelude> :t y
y :: Integer
Prelude> :t x * x
x * x :: Integer

Notice that type inference infers the correct type for all the expressions, without us having to ever specify the type explicitly.

Basic types

There is a range of basic types, defined in the language Prelude

Int         -- bounded, word-sized integers
Integer     -- unbounded integers
Double      -- floating point values
Char        -- characters
String      -- strings
()          -- the unit type
Bool        -- booleans
[a]         -- lists
(a,b)       -- tuples / product types
Either a b  -- sum types
Maybe a     -- optional values

For example:

True, False
('x', 42)
Left True, Right "string"
Nothing, Just True

These types have all the usual operations on them, in the standard libraries.

Functions (including Patterns and Higher-Order Functions)

Declaring our own types

Imperative features: monadic IO, references, mutable arrays, exceptions

Type classes