const function in Haskell

Question

The function const is defined in Prelude as:

const x _ = x

In GHCi, when I tried

Prelude> const 6 5  -> Gives 6

But when I tried

Prelude> const id 6 5 -> Gives 5

Even after making changes like

Prelude> (const id 6) 5 -> Gives 5

Shouldn't this function give 6 as the output of function id has type id :: a -> a which should bind like

Prelude> (const 6) 5 -> Gives 6

Why does function const behave differently?

Answer 1

You seem to be thinking that this is equivalent to const (id 6) 5, where id 6 evaluates to 6, but it isn't. Without those parentheses, you're passing the id function as the first argument to const. So look at the definition of const again:

const x _ = x

This means that const id 6 = id. Therefore, const id 6 5 is equivalent to id 5, which is indeed 5.

Answer 2

Functions can also be parameters to other functions. id becomes a parameter of const.

What the expression (const id 6) 5 really does is:

(const id 6) 5

(const id _) 5 -- grab the first parameter id

id 5

5

For more detail about what operators really do:

1. Anything in a pair of brackets would be treated as a whole expression (but it doesn't mean it will be calculated first). For example: (map (1+) ), (\x -> (-) x )

2. Prefix operators bind stronger than infix operators

3. The left-most prefix operator in an expression would be treated as a function which grabs parameters (including other prefix operators) in an expression from left to right until facing infix operators or the end of line. For example, if you type map (+) id 3 const + 2 in GHCi, you will get an error that says "The function `map' is applied to four arguments..." because map grabs (+), id, 3 and const as parameters before the infix operator +.

Answer 3

Chuck is right, function application in Haskell is left associative, meaning that a function invocation like f a b c is equivalent to (((f a) b) c). Remember, in Haskell you should always practice looking at types of functions and trying to infer what a function can and can't do based on its type. At first you might fail to deduce anything from a function type, but with more experience type information will become indispensable.

What is the type of const? Enter :t const in GHCi. It will return const :: a -> b -> a. a and b are type variables, meaning that const will accept an argument of any type. As 1^st and 2^nd arguments have different types, you can pass practically everything to the function:

const 1 2 -- returns 1
const 'a' 1 -- returns 'a'
const [1,2,3] "a" -- returns [1,2,3]

There might've been specific typeclass constraints on type variables of const that would prevent passing functions, like Num or Ord, because a function isn't an instance of these typeclasses. In other words, a function doesn't behave as a number or an ordered thing, so f + g or f < g don't make sense. But const has no typeclass constraints that would stop us from passing functions as arguments. Remember that Haskell supports higher-order functions? This means that Haskell's functions can accept and return other functions. Therefore:

const (+) (*) -- returns (+)
const head tail -- returns head
const id 2 -- returns id

const just ignores the 2^nd argument and returns whatever was passed as a 1^st argument, be it a Char, String, Integer, Maybe, [], some very complex algebraic data type, or even a function.

If the type of const is a -> b -> a, can you guess the type of const 'a' without finding it out without typing :t const 'a' in GHCi? To find out a type of const 'a', substitute the type of the 1^st argument in place of all same type variables, then remove the first argument from the type.

1. a -> b -> a: original type
2. Char -> b -> Char: substitute new type in type variables a
3. b -> Char: the type of a new function by removing the 1st argument from type declaration

What is the type of const id then?

1. a -> b -> a: original type
2. (a -> a) -> b -> (a -> a): substitution
3. b -> (a -> a): resulting type (first argument removed)
4. b -> a -> a: same as above, -> operator is right-associative

Exercise:

1. Try to figure out mentally or with pen and paper, without using GHCi, what are the types of: const (+), const head, const tail, const (++), const map
2. Try to find out what arguments would you pass to the above functions to get a concrete value.