Identity Monad - Haskell 中的行为差异？

Question

I have recently been playing around with Monads in Haskell (still a relative beginner with all this). I came across some interesting behaviour (or at least interesting to me) with the Identity Monad .

---

If I write the following function:

let f = \\x -> Identity 2 >>= \\y -> x * y

and then do :t I get f :: Num b => Identity b -> Identity b . It is inferring that x is an Identity (Num b) . I am able to call the function with 6 and I get the result 12 .

However if I try the same with Maybe like so:

let g = \\x -> Just 2 >>= \\y -> x * y

<interactive>:2096:5: error:
    • Non type-variable argument in the constraint: Num (Maybe b)
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        g :: forall b. Num (Maybe b) => Maybe b -> Maybe b

I therefore need to explicitly return Maybe or use return . So I do: let g = \\x -> Just 2 >>= \\y -> return $ x * y .

Everything works fine. However then I got to wondering what is happening with the Identity monad.

Firstly I tried adding the explicit return type like so:

let f = \\x -> Identity 2 >>= \\y -> Identity $ x * y

and then did :t again and I got f :: Num b => b -> Identity b . Which is what I was expecting the first time around.

---

Which made me wonder about how it was able to handle x + y without Identity $ if it was inferring x and y to be wrapped inside an Identity . So I tried the following:

Identity 5 + Identity 6 with the result being 11

Identity 5 + 6 with the result being 11 again

However it I try the same with Maybe like so

Just 5 + Just 6

Just 5 + 6

I get the following error:

<interactive>:2116:1: error:
    • Non type-variable argument in the constraint: Num (Maybe a)
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        it :: forall a. (Num (Maybe a), Num a) => Maybe a

I have tried FlexibleContexts but I just got the following error:

<interactive>:2134:1: error:
    • No instance for (Num (Maybe a0)) arising from a use of ‘it’
    • In the first argument of ‘print’, namely ‘it’
      In a stmt of an interactive GHCi command: print it

---

I was wondering if someone could shed a little light on why the Identity monad behaviour is different to Maybe ?

Also is it possible to use FlexibleContexts to get the same behaviour with the Maybe monad? I haven't been able to get it to work as of yet.

Answer 1

This is because Identity has a Num instance and Maybe does not (you can see the instances of a type by using :i in GHCi or looking in the Hackage documentation ).

So, when you have \\x -> Identity 2 >>= \\y -> x * y , that * is actually the * from the Num instance for Identity a (where a is itself a Num instance, like Int or Double , etc).

Additionally, numeric literals in Haskell are polymorphic: 5 :: Num a => a , so they can behave as any Num instance rather than being restricted to a specific one (like Int or Double ). That is what's happening when you try something like Identity 5 + 6 . The 6 is inferred to have type Num a => Identity a , since (+) :: Num a => a -> a -> a .

You can see this more explicitly:

ghci> :t 5
5 :: Num p => p
ghci> 5 :: Identity Int
Identity 5
ghci> 5 :: Maybe Int

<interactive>:12:1: error:
    • No instance for (Num (Maybe Int)) arising from the literal ‘5’
    • In the expression: 5 :: Maybe Int
      In an equation for ‘it’: it = 5 :: Maybe Int