Tukukkk

I'm trying to find my way in functional programming with haskell.
I saw this nice video https://www.youtube.com/watch?v=vDe-4o8Uwl8 by Scott Wlaschin.
I'm tryng to implement his ThinkOfNumber example using haskell.

The only solution I found is this one:

thinkOfANumber  numberYouThoughtOf =  (x -> x - numberYouThoughtOf) 

                                      . (x -> x / numberYouThoughtOf) 

                                      . (x -> x - 1) 

                                      . (x -> x * x) 

                                      . (x -> x + 1)

So I have to invoke the function in this way, using 2 parameters

thinkOfANumber 13 13

in order to memorize the numberYouThoughtOf in the call chain.

I there a way to simplify the code, using a pipe like operator such as the "|>" operator in F# ?

Maybe I'm surely missing something :)
Regards.
Ivan

Operator & from Data.Function is the exact analog of the F# pipe:

thinkOfANumber numberYonThoughOf = 

    let addOne x = x + 1

        squareIt x = x * x

        subtractOne x = x - 1

        divideByTheNumberYouThoughtOf x = x / numberYonThoughOf

    in  numberYonThoughOf 

        & addOne

        & squareIt

        & subtractOne

        & divideByTheNumberYouThoughtOf

Of course, if you like the pipe (I personally do), you can always define it in Haskell:

infixl 5 |>

x |> f = f x



thinkOfANumber numberYonThoughOf = 

    let addOne x = x + 1

        squareIt x = x * x

        subtractOne x = x - 1

        divideByTheNumberYouThoughtOf x = x / numberYonThoughOf

    in  numberYonThoughOf 

        |> addOne

        |> squareIt

        |> subtractOne

        |> divideByTheNumberYouThoughtOf

Operator (>>=) from Control.Monad package may be able to imitate |> operator in F# with using Identity from Control.Monad.Identity like:

import Control.Monad.Identity;



thinkOfANumber numberYonThoughOf = 

    let addOne      x = x + 1

        squareIt    x = x * x

        subtractOne x = x - 1

        divideByTheNumberYouThoughtOf x = x / numberYonThoughOf

    in  runIdentity 

        $   pure numberYonThoughOf 

        >>= pure . addOne

        >>= pure . squareIt

        >>= pure . subtractOne

        >>= pure . divideByTheNumberYouThoughtOf

Fyodor Soikin is correct that & corresponds to F#'s |>, but my impression from reading Haskell code is that it's considered more idiomatic to use the $ operator and compose from right to left, like in mathematics:

thinkOfANumber numberYouThoughOf = 

  let addOne x = x + 1

      squareIt x = x * x

      subtractOne x = x - 1

      divideByTheNumberYouThoughtOf x = x / numberYouThoughOf

  in divideByTheNumberYouThoughtOf $ subtractOne $ squareIt $ addOne numberYouThoughOf