how to write numbers in lambda using ghci

Question

I am new to Haskell, using Ghci.

I have a function, called three, that I want to write as

let three =  \x->(\y->(x(x(x y))))

OK, this works, but when I try

three (2+) 4

It does not work. Instead, I get some "cannot construct infinite type" error.

Please help me.

You should post the exact error message. I can't reproduce it in GHC 6.10.4, it works there. — sth, Oct 28 '09 at 18:10
Can't reproduce either. What version GHC/post the full transcript. — Edward Z. Yang, Oct 28 '09 at 19:40
Prelude> let three = \x->(\y->(x(x(x y)))) Prelude> :type three three :: (t -> t) -> t -> t Prelude> three (2+) 4 10 — Paul Johnson, Oct 28 '09 at 21:34
Or `three = foldr (.) id . replicate 3`, if you want to be pointless, err, point-free. — ephemient, Oct 28 '09 at 21:52
This should work just fine given `three :: (a -> a) -> a -> a`, and will fail if you pass it a function `a -> b`. — AJF, Dec 03 '14 at 17:01

score 6 · Answer 1 · answered Oct 28 '09 at 22:16

ghci> let three = \x->(\y->(x(x(x y))))
ghci> three (2+) 4
10
ghci> three return "deconstructivist"

<interactive>:1:6:
    Occurs check: cannot construct the infinite type: t = m t
      Expected type: t
      Inferred type: m t
    In the first argument of 'three', namely 'return'
    In the expression: three return "deconstructivist"
ghci> :t three
three :: (t -> t) -> t -> t
ghci> :t return
return :: (Monad m) => a -> m a

The example you supplied of three (2+) 4, works! Better check that the examples you provide actually reproduce your problem.
As for with a different example, like the one above with return, the thing is that return results in a different type than the one given. If the type was the same, it would be infinite (and of kind * -> * -> * -> ...), which Haskell does not support.

score 0 · Answer 2 · answered Dec 03 '14 at 17:10

The example you give does work. Let's explain why:

three f = f . f . f
-- so...
three :: (a -> a) -> a -> a

The function needs to have type a -> a because it will receive it's own argument, which requires a type. (2+) has type Num a => a -> a, so three (2+) 4 will work just fine.

However, when you pass a function like return of type Monad m => a -> m a, which returns a different type, it will not match the (a -> a) requirement we set out. This is where and when your function will fail.

While you're at it, try making a function like doTimes with type Integer -> (a -> a) -> a -> a which does the given function the given number of times - it's a good next step after making this function.

how to write numbers in lambda using ghci

2 Answers2