Hidden features of Haskell [closed]

Answer 1

Operator Fixity

You can use the infix, infixl or infixr keywords to define operators associativity and precedence. Example taken from the reference:

main = print (1 +++ 2 *** 3)

infixr  6 +++
infixr  7 ***,///

(+++) :: Int -> Int -> Int
a +++ b = a + 2*b

(***) :: Int -> Int -> Int
a *** b = a - 4*b

(///) :: Int -> Int -> Int
a /// b = 2*a - 3*b
Output: -19

The number (0 to 9) after the infix allows you to define the precedence of the operator, being 9 the strongest. Infix means no associativity, whereas infixl associates left and infixr associates right.

This allows you to define complex operators to do high level operations written as simple expressions.

Note that you can also use binary functions as operators if you place them between backticks:

main = print (a `foo` b)

foo :: Int -> Int -> Int
foo a b = a + b

And as such, you can also define precedence for them:

infixr 4 `foo`

Answer 2

seq and ($!) only evaluate enough to check that something is not bottom.

The following program will only print "there".

main = print "hi " `seq` print "there"

For those unfamiliar with Haskell, Haskell is non-strict in general, meaning that an argument to a function is only evaluated if it is needed.

For example, the following prints "ignored" and terminates with success.

main = foo (error "explode!")
  where foo _ = print "ignored"

seq is known to change that behavior by evaluating to bottom if its first argument is bottom.

For example:

main = error "first" `seq` print "impossible to print"

... or equivalently, without infix ...

main = seq (error "first") (print "impossible to print")

... will blow up with an error on "first". It will never print "impossible to print".

So it might be a little surprising that even though seq is strict, it won't evaluate something the way eager languages evaluate. In particular, it won't try to force all the positive integers in the following program. Instead, it will check that [1..] isn't bottom (which can be found immediately), print "done", and exit.

main = [1..] `seq` print "done"

Answer 3

Flexible specification of module imports and exports

Importing and exporting is nice.

module Foo (module Bar, blah)  -- this is module Foo, export everything that Bar expored, plus blah

import qualified Some.Long.Name as Short
import Some.Long.Name (name)  -- can import multiple times, with different options

import Baz hiding (blah)  -- import everything from Baz, except something named 'blah'

Answer 4

C-Style Enumerations

Combining top-level pattern matching and arithmetic sequences gives us a handy way to define consecutive values:

foo : bar : baz : _ = [100 ..]    -- foo = 100, bar = 101, baz = 102

Answer 5

If you're looking for a list or higher-order function, it's already there

There's sooo many convenience and higher-order functions in the standard library.

-- factorial can be written, using the strict HOF foldl':
fac n = Data.List.foldl' (*) 1 [1..n]
-- there's a shortcut for that:
fac n = product [1..n]
-- and it can even be written pointfree:
fac = product . enumFromTo 1

Answer 6

Hoogle

Hoogle is your friend. I admit, it's not part of the "core", so cabal install hoogle

Now you know how "if you're looking for a higher-order function, it's already there" (ephemient's comment). But how do you find that function? With hoogle!

$ hoogle "Num a => [a] -> a"
Prelude product :: Num a => [a] -> a
Prelude sum :: Num a => [a] -> a

$ hoogle "[Maybe a] -> [a]"
Data.Maybe catMaybes :: [Maybe a] -> [a]

$ hoogle "Monad m => [m a] -> m [a]"
Prelude sequence :: Monad m => [m a] -> m [a]

$ hoogle "[a] -> [b] -> (a -> b -> c) -> [c]"
Prelude zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

The hoogle-google programmer is not able to write his programs on paper by himself the same way he does with the help of the computer. But he and the machine together are a forced not* to be reckoned with.

Btw, if you liked hoogle be sure to check out hlint!