在Haskell脚本中，如何以编程方式获取函数的类型签名？

Question

In Haskell (GHC), how can one obtain the type signature of the list of functions shown below?

[tail,init,reverse]

I unsuccessfully tried using the typeOf function of the Data.Typeable module. Specifically, I try to run the following Haskell script:

import Data.Typeable
import Test.HUnit
myTest = TestCase
          ( assertEqual "\n\nShould have been \"[[a] -> [a]]\""
            "[[a] -> [a]]"
            (show ( typeOf [tail,init,reverse] )) )
tests = TestList [ (TestLabel "myTest" myTest) ]

However, GHC responds with the following error:

C:\>ghci my_script.hs
GHCi, version 8.0.2: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling Main             ( my_script.hs, interpreted )
my_script.hs:7:21: error:
    * No instance for (Typeable a0) arising from a use of `typeOf'
    * In the first argument of `show', namely
        `(typeOf [tail, init, reverse])'
      In the third argument of `assertEqual', namely
        `(show (typeOf [tail, init, reverse]))'
      In the first argument of `TestCase', namely
        `(assertEqual
            "\n\
            \\n\
            \Should have been \"[[a] -> [a]]\""
            "[[a] -> [a]]"
            (show (typeOf [tail, init, reverse])))'
Failed, modules loaded: none.
Prelude>

---

Update: The following HUnit test case isn't quite what I wanted, but I did get it to pass (based on David Young's suggestion). This test case at least forces the compiler to confirm that [tail,init,reverse] is of type [ [a] -> [a] ] .

import Data.Typeable
import Test.HUnit
myTest = TestCase
          ( assertEqual "\n\nShould have been 3"
            3
            ( length ( [tail,init,reverse] :: [[a]->[a]] ) ) )
tests = TestList [ (TestLabel "myTest" myTest) ]

C:\>my_script.hs
GHCi, version 8.0.2: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling Main             ( my_script.hs, interpreted )
Ok, modules loaded: Main.
*Main> runTestTT tests
Cases: 1  Tried: 1  Errors: 0  Failures: 0

Answer 1

You don't need a unit test to check a function's type. A unit tests runs after the code has been compiled, it's a dynamic test. However, type checking is a static test: all types are tested during the compilation of your program. Therefore, we can use GHC as a minimal static type checker and reduce your program to:

main :: IO ()
main = return ()
  where
    tailInitReverseAreListFunctions :: [[a] -> [a]]
    tailInitReverseAreListFunctions = [tail, init, reverse]

You don't even need that test anymore the moment you actually test your functions with real data, because that application will (statically) test the function's type too.

Remember, Haskell is a statically typed language. The types are checked during compilation, before your code is run. Any type checking unit-test is therefore more or less a code-smell, because it can only pass.