Hidden features of Haskell [closed]

Answer 1

Optional Layout

You can use explicit braces and semicolons instead of whitespace (aka layout) to delimit blocks.

let {
      x = 40;
      y = 2
     } in
 x + y

... or equivalently...

let { x = 40; y = 2 } in x + y

... instead of ...

let x = 40
    y = 2
 in x + y

Because layout is not required, Haskell programs can be straightforwardly produced by other programs.

Answer 2

Equational Reasoning

Haskell, being purely functional allows you to read an equal sign as a real equal sign (in the absence of non-overlapping patterns).

This allows you to substitute definitions directly into code, and in terms of optimization gives a lot of leeway to the compiler about when stuff happens.

A good example of this form of reasoning can be found here:

http://www.haskell.org/pipermail/haskell-cafe/2009-March/058603.html

This also manifests itself nicely in the form of laws or RULES pragmas expected for valid members of an instance, for instance the Monad laws:

1. returrn a >>= f == f a
2. m >>= return == m
3. (m >>= f) >>= g == m >>= (\x -> f x >>= g)

can often be used to simplify monadic code.

Answer 3

Laziness

Ubiquitous laziness means you can do things like define

fibs = 1 : 1 : zipWith (+) fibs (tail fibs)

But it also provides us with a lot of more subtle benefits in terms of syntax and reasoning.

For instance, due to strictness ML has to deal with the value restriction, and is very careful to track circular let bindings, but in Haskell, we can let every let be recursive and have no need to distinguish between val and fun. This removes a major syntactic wart from the language.

This indirectly gives rise to our lovely where clause, because we can safely move computations that may or may not be used out of the main control flow and let laziness deal with sharing the results.

We can replace (almost) all of those ML style functions that need to take () and return a value, with just a lazy computation of the value. There are reasons to avoid doing so from time to time to avoid leaking space with CAFs, but such cases are rare.

Finally, it permits unrestricted eta-reduction (\x -> f x can be replaced with f). This makes combinator oriented programming for things like parser combinators much more pleasant than working with similar constructs in a strict language.

This helps you when reasoning about programs in point-free style, or about rewriting them into point-free style and reduces argument noise.

Answer 4

Avoiding parentheses

The (.) and ($) functions in Prelude have very convenient fixities, letting you avoid parentheses in many places. The following are equivalent:

f (g (h x))
f $ g $ h x
f . g $ h x
f . g . h $ x

flip helps too, the following are equivalent:

map (\a -> {- some long expression -}) list
flip map list $ \a ->
    {- some long expression -}

Answer 5

Enumerations

Any type which is an instance of Enum can be used in an arithmetic sequence, not just numbers:

alphabet :: String
alphabet = ['A' .. 'Z']

Including your own datatypes, just derive from Enum to get a default implementation:

data MyEnum = A | B | C deriving(Eq, Show, Enum)

main = do
    print $ [A ..]                 -- prints "[A,B,C]"
    print $ map fromEnum [A ..]    -- prints "[0,1,2]"

Answer 6

Generalized algebraic data types. Here's an example interpreter where the type system lets you cover all the cases:

{-# LANGUAGE GADTs #-}
module Exp
where

data Exp a where
  Num  :: (Num a) => a -> Exp a
  Bool :: Bool -> Exp Bool
  Plus :: (Num a) => Exp a -> Exp a -> Exp a
  If   :: Exp Bool -> Exp a -> Exp a -> Exp a 
  Lt   :: (Num a, Ord a) => Exp a -> Exp a -> Exp Bool
  Lam  :: (a -> Exp b) -> Exp (a -> b)   -- higher order abstract syntax
  App  :: Exp (a -> b) -> Exp a -> Exp b
 -- deriving (Show) -- failse

eval :: Exp a -> a
eval (Num n)      = n
eval (Bool b)     = b
eval (Plus e1 e2) = eval e1 + eval e2
eval (If p t f)   = eval $ if eval p then t else f
eval (Lt e1 e2)   = eval e1 < eval e2
eval (Lam body)   = \x -> eval $ body x
eval (App f a)    = eval f $ eval a

instance Eq a => Eq (Exp a) where
  e1 == e2 = eval e1 == eval e2

instance Show (Exp a) where
  show e = "<exp>" -- very weak show instance

instance (Num a) => Num (Exp a) where
  fromInteger = Num
  (+) = Plus