Personal tools

A brief introduction to Haskell

From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
(start on translation of ocaml brief introduction)
 
(wibbles)
Line 1: Line 1:
 
Inspired by the [http://www.cs.jhu.edu/~scott/pl/lectures/caml-intro.html Introduction to OCaml].
 
   
 
[[Category:Tutorials]]
 
[[Category:Tutorials]]
  +
  +
Inspired by the [http://www.cs.jhu.edu/~scott/pl/lectures/caml-intro.html Introduction to OCaml].
   
 
== Background ==
 
== Background ==
Line 9: Line 9:
   
 
* A language [http://haskell.org/haskellwiki/History_of_Haskell developed] by the programming languages [http://haskell.org/haskellwiki/Research_papers research] community.
 
* A language [http://haskell.org/haskellwiki/History_of_Haskell developed] by the programming languages [http://haskell.org/haskellwiki/Research_papers research] community.
* Is a lazy, purely functional language (that also has imperative
+
* Is a lazy, purely functional language (that also has imperative features such as side effects and mutable state, as well strict evaluation)
features such as side effects and mutable state, as well strict evaluation)
 
 
* One of the youngest children of ML and Lisp
 
* One of the youngest children of ML and Lisp
 
* Particularly useful for manipulating data structures, (i.e. [http://haskell.org/ghc compilers] and [http://pugscode.org interpreters]), and parallel programming
 
* Particularly useful for manipulating data structures, (i.e. [http://haskell.org/ghc compilers] and [http://pugscode.org interpreters]), and parallel programming
Line 55: Line 55:
 
[http://haskell.org/haskellwiki/Books_and_tutorials see here[http://haskell.org/haskellwiki/Books_and_tutorials].
 
[http://haskell.org/haskellwiki/Books_and_tutorials see here[http://haskell.org/haskellwiki/Books_and_tutorials].
   
=== Interacting with the language ==
+
=== Interacting with the language ===
   
 
Interacting with Haskell via the GHCi interpreter:
 
Interacting with Haskell via the GHCi interpreter:

Revision as of 00:46, 27 October 2006


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