Объясните мне ограничение мономорфизма, пожалуйста?

Я начал решать 99 задач на Haskell, и у меня была задача 7 , и мои юнит-тесты взрывались.

Видимо, из-за этого:http://www.haskell.org/haskellwiki/Monomorphism_restriction

Я просто хотел убедиться, что понял это правильно, потому что я немного сбит с толку.

Ситуация 1 :func aопределена без определения типа или с не -строгим определением типа, а затем используется один раз, компилятор не имеет проблем с определением типа во время компиляции.

ситуация 2 :одна и та же функция aиспользуется в программе много раз, компилятор не может быть на 100% уверенным в том, что это за тип, если только он не вычисляет функцию заново для заданных аргументов.

Чтобы избежать потери вычислений, ghc жалуется программисту, что ему нужно строгое определение типа a. работать правильно.

Я думаю, что в моей ситуации assertEqualимеет тип определения

 assertEqual :: (Eq a, Show a) => String -> a -> a -> Assertion

Я получил сообщение об ошибке, когда test3был определен, что я интерпретировал как сообщение о том, что у него есть 2 возможных типа для возвратаtestcase3(Show and Eq )и не знал, как продолжить.

Это звучит правильно или я совсем не в себе?

проблема7.hs:

-- # Problem 7
-- Flatten a nested list structure.

import Test.HUnit

-- Solution

data NestedList a = Elem a | List [NestedList a]

flatten :: NestedList a -> [a]
flatten (Elem x) = [x]
flatten (List x) = concatMap flatten x

-- Tests

testcase1 = flatten (Elem 5)
assertion1 = [5]

testcase2 = flatten (List [Elem 1, List [Elem 2, List [Elem 3, Elem 4], Elem 5]])
assertion2 = [1,2,3,4,5]

-- This explodes
-- testcase3 = flatten (List [])

-- so does this:
-- testcase3' = flatten (List []) :: Eq a => [a]

-- this does not
testcase3'' = flatten (List []) :: Num a => [a]

-- type def based off `:t assertEqual`
assertEmptyList :: (Eq a, Show a) => String -> [a] -> Assertion
assertEmptyList str xs = assertEqual str xs []

test1 = TestCase $ assertEqual "" testcase1 assertion1
test2 = TestCase $ assertEqual "" testcase2 assertion2
test3 = TestCase $ assertEmptyList "" testcase3''

tests = TestList [test1, test2, test3]

-- Main
main = runTestTT tests

1-я ситуация:testcase3 = flatten (List [])

GHCi, version 7.4.2: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim... linking... done.
Loading package integer-gmp... linking... done.
Loading package base... linking... done.
[1 of 1] Compiling Main             ( problem7.hs, interpreted )

problem7.hs:29:20:
    Ambiguous type variable `a0' in the constraints:
      (Eq a0)
        arising from a use of `assertEmptyList' at problem7.hs:29:20-34
      (Show a0)
        arising from a use of `assertEmptyList' at problem7.hs:29:20-34
    Probable fix: add a type signature that fixes these type variable(s)
    In the second argument of `($)', namely
      `assertEmptyList "" testcase3'
    In the expression: TestCase $ assertEmptyList "" testcase3
    In an equation for `test3':
        test3 = TestCase $ assertEmptyList "" testcase3
Failed, modules loaded: none.
Prelude> 

2-я ситуация:testcase3 = flatten (List []) :: Eq a => [a]

GHCi, version 7.4.2: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim... linking... done.
Loading package integer-gmp... linking... done.
Loading package base... linking... done.
[1 of 1] Compiling Main             ( problem7.hs, interpreted )

problem7.hs:22:13:
    Ambiguous type variable `a0' in the constraints:
      (Eq a0)
        arising from an expression type signature at problem7.hs:22:13-44
      (Show a0)
        arising from a use of `assertEmptyList' at problem7.hs:29:20-34
    Possible cause: the monomorphism restriction applied to the following:
      testcase3 :: [a0] (bound at problem7.hs:22:1)
    Probable fix: give these definition(s) an explicit type signature
                  or use -XNoMonomorphismRestriction
    In the expression: flatten (List []) :: Eq a => [a]
    In an equation for `testcase3':
        testcase3 = flatten (List []) :: Eq a => [a]
Failed, modules loaded: none.