Hidden features of Haskell [closed]

Answer 1

Monads

They are not that hidden, but they are simply everywhere, even where you don't think of them (Lists, Maybe-Types) ...

Answer 2

User-defined control structures

Haskell has no shorthand ternary operator. The built-in if-then-else is always ternary, and is an expression (imperative languages tend to have ?:=expression, if=statement). If you want, though,

True ? x = const x
False ? _ = id

will define (?) to be the ternary operator:

(a ? b $ c)  ==  (if a then b else c)

You'd have to resort to macros in most other languages to define your own short-circuiting logical operators, but Haskell is a fully lazy language, so it just works.

-- prints "I'm alive! :)"
main = True ? putStrLn "I'm alive! :)" $ error "I'm dead :("

Answer 3

Readable function composition

Prelude defines (.) to be mathematical function composition; that is, g . f first applies f, then applies g to the result.

If you import Control.Arrow, the following are equivalent:

g . f
f >>> g

Control.Arrow provides an instance Arrow (->), and this is nice for people who don't like to read function application backwards.

Answer 4

My brain just exploded

If you try to compile this code:

{-# LANGUAGE ExistentialQuantification #-}
data Foo = forall a. Foo a
ignorefoo f = 1 where Foo a = f

You will get this error message:

$ ghc Foo.hs

Foo.hs:3:22:
    My brain just exploded.
    I can't handle pattern bindings for existentially-quantified constructors.
    Instead, use a case-expression, or do-notation, to unpack the constructor.
    In the binding group for
        Foo a
    In a pattern binding: Foo a = f
    In the definition of `ignorefoo':
        ignorefoo f = 1
                    where
                        Foo a = f

Answer 5

Nestable multiline comments.

{- inside a comment,
     {- inside another comment, -}
still commented! -}

Answer 6

let 5 = 6 in ... is valid Haskell.