Understanding type of `5 1`

Question

I used this Haskell interpreter right here: https://tryhaskell.org/

When I provided the input 5 1 it tells me - I assume it is the type - that the expression is of type (Num a, Num (a -> t)) => t:

λ 5 1
:: (Num a, Num (a -> t)) => t

Now I have tried to understand how to interpret this and this is what I came up with.

a is any Num type and so is a -> t. The expression results in some type t that is produced by theoretically applying 1 (type a) to 5 (type a -> t).

This really disturbs me because I don't see how the constraint Num (a -> t) makes sense. Theoretically it looks to be the correct interpretation but I can't find prove for that.

The interpretation is correct

It makes sense because Num is a polymorphic type - which can be a function.

This appears to be a bug in the interpreter, this code should not parse. — crockeea, Mar 27 '15 at 02:27
@Eric This is not a bug in the interpreter, this code can actually be used for practical purposes. Probably not a good idea, but it can be done. — bheklilr, Mar 27 '15 at 02:27
See also https://stackoverflow.com/questions/26515102/making-numeric-functions-an-instance-of-num — dfeuer, Mar 27 '15 at 03:12

score 10 · Accepted Answer · answered Mar 27 '15 at 02:42

Numerals are polymorphic in Haskell. When you write something like

The compiler turns this into fromInteger (5 :: Integer) :: Num a => a. The compiler doesn't know beforehand what instance to use, so it'll do it's best to guess from context. If you have 5 1, then the first numeral is a polymorphic Num type, that also must be a function. The second numeral is just seen as a Num, so this is quite normal.

But you may ask "How can a number be a function?" If everything in the world made sense, then numbers wouldn't be functions, but you can actually write an instance for them that behaves, more or less:

{-# LANGUAGE FlexibleInstances #-}

instance Num a => Num (a -> a) where
    fromInteger a = const (fromInteger a)
    a + b = \c -> a c + b c
    a * b = \c -> a c * b c
    abs a = \c -> abs (a c)
    signum a = \c -> signum (a c)
    negate a = \c -> negate (a c)

This satisfies the definition, but it probably wouldn't be very useful. For example:

> let x = 1 :: Int -> Int; y = 2 :: Int -> Int
> x + y $ 0
3
> x + y $ 102089
3
> x + y $ undefined
3

So here, the argument does not matter to the expression, it's not even evaluated. How about a more interesting one:

> let x = (+10); y = (*10)
> x + y $ 0    -- x 0 + y 0 = 0 + 10 + 0 * 10
10
> x + y $ 1    -- x 1 + y 1 = 1 + 10 + 1 * 10
21
> x + y $ 2
32

And so forth. I'm sure someone can find an interesting use case for it, but I wouldn't recommend it, it's quite clearly not very intuitive.

Defining a `Num` instance directly on function types is indeed confusing and poor practice, but such an instance can be useful on a `newtype` wrapper over them. I was once prototyping a system for defining business calculations, that allowed you to say stuff like `monthlyGoal = (shift (monthDuration (-1)) monthlySales) * 1.05`, where the prototype of `montlyGoal, monthlySales :: Metric (Year, Month) Decimal` was a newtype wrapper around `(Year, Month) -> Decimal`. In this case `1.05 :: Metric (Year, Month) Decimal` is the metric whose value is 1.05 at all year/month combinations. — Luis Casillas, Mar 27 '15 at 04:59
It doesn't make sense when you indeed only deal with const function and evaluate them directly, but it's nice to be able to add constant ex : `let x = (*10) :: Int -> Int` then `let y = x+1`, and finaly `y 3 => 31` — mb14, Mar 27 '15 at 09:28
If you make the instance for `b -> a` it's more general and requires no language extensions. — augustss, Mar 27 '15 at 10:53

score 2 · Answer 2 · answered Mar 27 '15 at 02:49

2

In Haskell, numbers are polymorphic:

λ> :t 5
5 :: Num a => a

The important thing to note here is that function application in Haskell is whitespace. So to make something like 5 2 typecheck, all you have to do is create an instance for (a -> a) type.

answered Mar 27 '15 at 02:49

Sibi

47,472
16
95
163

score 1 · Answer 3 · answered Mar 27 '15 at 02:32

Your interpretation is correct.

I don't see how the constraint Num (a -> t) makes sense.

The key here is that anything can be a Num type, as long as somewhere in your code you have an instance declaration for it. So if for some a and t (with a being a Num type), you wrote instance Num (a -> t) where ..., then a -> t would be a Num type and 5 1 could actually be evaluated to a value.

Understanding type of `5 1`

The interpretation is correct

3 Answers3