Table of Content

These are Haskell related articles.

How Haskell Syntax can Make Your Code CleanerLoop 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

Before you read. You can examine a neat `$`

coding style in my old screenshot. It is somehow weird, and it is probably, not something avaliable in other programming language.

**Source**:

* gitlab.com/epsi-rns/dotfiles/…/MyLayoutHook.hs

If you love math. You are going to love Haskell.

I still don’t understand Math. Nor Haskell.

Let’s consider simple Mathematical function.

y = f(x)

Parantheses is not mandatory in Haskell. Haskell is a Functional Programming. It has different paradigm.

You can write the representation either

`y = f(x)`

or

`y = f x`

Space in haskell is left associative function application

Let’s consider this chained Mathematical function.

y = i( h( g( f(x) ) ) )

You can write this function in your haskell code with common notation. The result is the same representation as above.

`y = i( h( g( f(x) ) ) ) `

This is error prone and you’ll get lost in parentheses easily.

Let’s see how space as left associative function application works by consider this representation.

`z = i h g f x`

After translating it back, with parentheses. It is actually, not something you are expecting.

`z = ((((i (h) ) g) f) x)`

Now we are facing problem of how to represent chained functions without parentheses.

So how do we solve the problem ? Off course with another function application.

Dollar to avoid parentheses.

$ is right associative function application

Let’s again, consider this chained Mathematical function.

y = i( h( g( f(x) ) ) )

Yes, you can write this down again using $ infix notation for avoiding parantheses.

`y = i $ h $ g $ f x`

Function Composition.

Dot to chain function.

In math you can write this

(i . h . g . f )(x) = i( h( g( f(x) ) ) )

With haskell yo can simplified into this

```
j = i . h . g . f
y = j x
```

Although

`y = i $ h $ g $ f x`

and

`y = i . h . g . f x`

looks similar.

They are not always interchangeable.

Enough with math. How about real life coding ?

Yes, you can simplify doing those cumbersome parantheses by replacing it with `$`

infix operator as shown in my old screenshot below.

That’s my XMonad Configuration in Haskell that I’ve been using since 2014.

Remember. Dollar can make your life easier. After all, it is never to late to learn Math.

Happy Coding.