I am currently in need of a bit of brain training and I found this article on Haskell and Monads

I'm having trouble with exercise 7 re. Randomised function bind.

To make the problem even simpler to experiment, I replaced the StdGen type with an unspecified type. So instead of...

bind :: (a -> StdGen -> (b,StdGen)) -> (StdGen -> (a,StdGen)) -> (StdGen -> (b,StdGen))

I used...

bind :: (a -> c -> (b,c)) -> (c -> (a,c)) -> (c -> (b,c))

and for the actual function impelemtation (just straight from the exercise)

bind f x seed = let (x',seed') = x seed 
                 in f x' seed'

and also 2 randomised functions to trial with:

rndf1 :: (Num a, Num b) => a -> b -> (a,b)
rndf1 a s = (a+1,s+1)

rndf2 :: (Num a, Num b) => a -> b -> (a,b)
rndf2 a s = (a+8,s+2)

So with this in a Haskell compiler (ghci), I get...

:t bind rndf2
bind rndf2 :: (Num a, Num c) => (c -> (a, c)) -> c -> (a, c)

This matches the bind curried with rndf2 as the first parameter.

But the thing I don't understand is how...

:t bind rndf2 . rndf1

Suddenly gives

bind rndf2 . rndf1 :: (Num a, Num c) => a -> c -> (a, c)

This is the correct type of the composition that we are trying to produce because

bind rndf2 . rndf1

Is a function that:

1. takes the same parameter type(s) as rndf1
2. AND takes the return from rndf1 and pipes it as an input of rndf2 to return the same type as rndf2

rndf1 can take 2 parameters a -> c and rndf2 returns (a, c) so it matches that a composition of these function should have type:

bind rndf2 . rndf1 :: (Num a, Num c) => a -> c -> (a, c)

This does not match the naive type that I initially came up with for bind

bind f :: (a -> b -> (c, d)) -> (c, d) -> (e, f)

Here bind mythically takes a function that takes two parameters and produces a function that takes a tuple in order that the output from rndf1 can be fed into rndf2

1. why the bind function needs to be coded as it is
2. Why the bind function does not have the naive type