Personal tools

A brief introduction to Haskell

From HaskellWiki

Revision as of 00:46, 27 October 2006 by DonStewart (Talk | contribs)

Jump to: navigation, search


Inspired by the Introduction to OCaml.

Contents

1 Background

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

History:

  • 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

2 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

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

3.1 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
7

A variable evaluates to its value.

Prelude> x + 4
11
The variable
x
is in scope, so we can reuse it in later

expressions.

Prelude> let x = 4 in x + 3
7
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
16
 
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.

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

7
12312412412412321
3.1415
'x'
"haskell"
()
True, False
[1,2,3,4,5]
('x', 42)
Left True, Right "string"
Nothing, Just True

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

5 Functions (including Patterns and Higher-Order Functions)

6 Declaring our own types

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

8 Type classes