Table of Content
These are Haskell related articles.How Haskell Syntax can Make Your Code Cleaner
Loop in Haskell With Map, Overview
Loop in Haskell With Map, Part One
Loop in Haskell With Map, Part Two
Loop in Haskell With Map, Part Three
Explaining Monad: Overview
Explaining Monad: References
Examining Bind in Haskell: Hello World
Examining Bind in Haskell: Example using Number
Examining Bind in Haskell: Do Notation
Goal of Part One
Process Array Loop by Iterating on List
This is the basic of loop using iteration, with simple array like data structure, the list.
Example of Doing Loop in Haskell With Map
This tutorial/ guidance/ article is one of three parts. These three combined is going to be a long article. So I won’t speak too much. More on codes, than just words.
The first two parts discuss the most common loop, array in part one and hash in part two. Considering that combining map with function is tricky, This deserve this an article of its own in part three. Part three also contains comparation with other Languages, using Real World Function.
Haskell has a few Array implementation. One that is very common is List. It is actually a linked list that behaves like an Array.
Let’s consider a list construct, contain sequence number from 1 to 9.
list :: [Int] list = [1..9]
It is not mandatory to write function declaration. Sometime I put function declaration, just for clarity reason, Also for my personal exercise. It won’t harm anyone. Now we can omit any function declaration for this list.
list = [1..9]
list = [1..9] main = do print list putStrLn ""
This will show:
More about Printing
We can ignore
do is just a special syntax for sequencing monad.
The type of
IO is a monad, hence omitting do.
Relax, forget about Monad, and just go on.
do notatin is useful
when creating oneliner example.
Consider this example of the same code rewritten without do clause.
then >> operator.
putStrLn $ show.
$ is just an operator to avoid closing bracket.
Now we can decompose it as below.
main = putStrLn (show [1..9]) >> putStrLn ""
Or using reverse application operator
import Data.Function main = show [1..9] & putStrLn >> putStrLn ""
Let’s add other element to this list.
list :: [Int] list = [1..9] ++  main = do putStr "list : " putStrLn $ show list
Run this code, and this list will be interpreted as output below.
list : [1,2,3,4,5,6,7,8,9,0]
|| can be used to accessing element by index.
main = do print (list !! 3)
This will show 4, because it is a zero based index:
Since list is actually a linked list, it does not rely on indices. For convenience for coder come from other language, zero based indices can be done this way below.
list :: [Int] list = [1..9] ++  indices' :: [Int] -> [Int] indices' l = [0 .. (length l) - 1] main = do putStr "list : " print list putStr "indices : " putStrLn $ show $ indices' list putStrLn ""
Do not worry about the dollar
It is just a Haskell operator to avoid paranthese.
It could be written as
Note that I intentionally using,
indices’ punctuation mark,
to differ from
This will display:
list : [1,2,3,4,5,6,7,8,9,0] indices : [0,1,2,3,4,5,6,7,8,9]
Iterate with mapM_
Looping over array in Haskell is this simple.
mapM_ discard newly produced list,
and use side effect only, in this case print using IO.
main = do mapM_ print list
Wait….!!! This simple !!…. Yes! I also thought it was harder, but it turn out to be very short. This will map each element, and applied it to print function. Let’s see the output
1 2 3 4 5 6 7 8 9 0
Iterate with Map
If you care about tor produce new list,
map is for you.
main = do print $ map show list
This show will convert each element to string, and boxed it into new list of string.
If you come from other language,
and too confused about Haskell notation,
you may consider this perspective:
map is very useful
for transforming one list to another list.
However we still need
whenever we need side effect such as display each element using IO.
main = do mapM_ putStrLn (map show list) putStrLn ""
forM is just like a
with reverse aguments. It is available in
main = do forM_ (map show list) putStrLn putStrLn ""
Both codes have output as shown below.
They are using side effect of
(map show list).
1 2 3 4 5 6 7 8 9 0
It is just an example required in this tutorial,
not everything have to be printed out.
If you wish for another challenge you can make a complex one liner.
main = mapM_ (putStr . (": " ++) . show) ([1..9] ++ ) >> putStrLn ""
Or using reverse argument
to make it looks like regular loop.
With the same result.
main = forM_ ([1..9] ++ ) (putStr . (": " ++) . show) >> putStrLn ""
This will show.
: 1: 2: 3: 4: 5: 6: 7: 8: 9: 0
How does it works ?
What is this
(putStr . (”: “ ++) . show) anyway.
As our need grow, you might desire to use more than one function.
The issue is
mapM_ only accept one function.
The solution is to chain functions
with the dot
. infix operator.
This will accept the sequence of function
as a whole compound operation.
Alternative Loop Form
We can rewrite above loop, even better using
Also with the same result.
main = putStrLn $ concat $ map ((": " ++) . show) ([1..9] ++ )
Still with the same result.
main = putStrLn $ concatMap ((": " ++) . show) ([1..9] ++ )
If you do not like oneliner, you can decompose this complex line using let clause in do block, or where clause in function.
main = do let myFunctionComposition = (putStr . (": " ++) . show) myList = ([1..9] ++ ) in mapM_ myFunctionComposition myList putStrLn ""
putList :: [Int] -> IO () putList myList = mapM_ myFunctionComposition myList where myFunctionComposition = (putStr . (": " ++) . show) main = do putList ([1..9] ++ ) putStrLn ""
This will produce exactly the same result.
: 1: 2: 3: 4: 5: 6: 7: 8: 9: 0
View Source File:
In “Part Two” we will discuss about Hash (dictionary).