On May 20, 2010, at 3:18 AM, Brent Yorgey wrote:
On Wed, May 19, 2010 at 04:27:14AM +0000, R J wrote:
What are some simple functions that would naturally have the following type signatures: f :: (Integer -> Integer) -> Integer
Well, this means f is given a function from Integer to Integer, and it has to somehow return an Integer, (possibly) using the function it is given. For example, f could just ignore its argument:
f _ = 6
That would NOT give f the right type. The type would be f :: Num r => a -> r
Or it could apply it to a particular input value:
f g = g 0
That would NOT give f the right type. The type would be f :: Num a => (a -> b) -> b
I'll let you think of some other possibilities.
The key point is the 'that would NATURALLY have', which I take to mean "as a result of type inference without any forcibly imposed type signatures". What kind of definition of f, *not* including "::" anywhere, would result in Haskell inferring the desired signature? The key thing is that the types *must* be fully constrained to Integer. The simplest way to get something that is guaranteed to be the specific type Integer, as far as I can see, is to use something like "toInteger 0". If we have identityForA :: A -> A identityForB :: B -> B then we can constrain a variable x to A using identityForA $ x and we can constrain a variable g to A->B using identityForB . g . identityForA. This is, in a sense, equivalent to providing a type signature, but it meets the formal requirements of these questions. identityForInteger = (+ toInteger 0) is an example. f g = g z + z where z = toInteger 0 does the trick here. m% ghci Prelude> let f g = g z + z where z = toInteger 0 Prelude> :type f f :: (Integer -> Integer) -> Integer