This presentation describes a variety of ways to write parallel and concurrent programs in the lazy functional language Haskell. We start off by introducing par/pseq annotations which provide guidance to the run-time about how work can be performed speculatively which provides a basic mechanism for writing implicitly parallel programs. We then describe how a library of strategies can be used to force specific evaluation orders which are necessary to exploit parallelism. We then go on to describe the basic mechanism for writing explicitly parallel programs using Haskell's lightweight threads and then we describe how Haskell's STM implementation can help to write programs that share state between threads through the use of a special monads and as an example we describe the implementation of a multi-way rendezvous library. We then describe some work with Tim Harris on feedback directed implicit parallelism which provides yet another way to write implicitly parallel programs without resorting to par/pseq annotations. Finally, we report on the progress of a nested data parallel library for Haskell inspired by the NESL language. Throughout the talk we shall emphasizes how Haskell's pure nature (with side effecting operations clearly indicated by the type system) facilitates the exploitation of parallelism.