基本类型的模式匹配

Question

Here is what I want:

f n = case n of
  String -> "string"
  _ -> "other"

Or something. I want f to map to the literal "string" if called with a string, "other" otherwise. This cannot be as hard as I am making it.

Answer 1

If you're coming from JS and Python it's understandable you think that something that this should be possible – after all, in those languages a type is essentially a particular property of a value. But that's not at all how the Haskell type system works! In fact, types and values belong to completely separate “universes”: types only exist at compile time, values only at runtime. It's still true that every value belongs to a type, but this information is already completely resolved at compile-time. At runtime it is generally not necessary to dispatch on types, because the compiler has already done that earlier, and it can never be possible that a value of type other than the valid one is ever passed in. So this would always be redundant. In fact the type information is removed before the program is run.
So in the direct sense, what you're trying to accomplish is indeed impossible. Or, cynically speaking, it's trivial :

f :: String -> String
f _ = "string"

Generally, if you find yourself wanting to runtime-dispatch on types it's a sign that you should probably have started out with a variant type in the first place:

data StringOrInt = It'sAString String | It'sAnInt Int

f :: StringOrInt -> String
f (It'sAString _) = "string"
f (It'sAnInt _) = "int"

...ideally with more descriptive, application-specific names.

That said, it is actually possible to have “dynamically typed” values in Haskell, like in Python. You just need to request the wrapper that contains the type information which the compiler would otherwise erase before the runtime:

{-# LANGUAGE TypeFamilies #-}

import Data.Dynamic
import Type.Reflection

f :: Dynamic -> String
f (Dynamic t _)
   = case eqTypeRep t (typeOf "string") of
       Just HRefl -> "string"
       _          -> "other"

Example usage:

main = do
   putStrLn . f $ toDyn "bla"
   putStrLn . f $ toDyn True
   putStrLn . f $ toDyn 'y'

yielding

string
other
other

A more elegant way of writing f than with the awkward eqTypeRep construct would be

f :: Dynamic -> String
f s = case fromDynamic s :: Maybe String of
       Just _ -> "string"
       _      -> "other"

Answer 2

In general, ad-hoc polymorphism and type introspection like this in Haskell is frowned upon. It's possible anyway, but a little bit fragile:

{-# LANGUAGE FlexibleInstances #-}

class F a where
  f :: a -> String

instance F String where
  f n = "string"

instance {-# OVERLAPPABLE #-} F other where
  f n = "other"

Alternatively, you can use Typeable , which is less fragile, at the expense of needing an instance from the caller:

import Data.Typeable

f :: Typeable a => a -> String
f n = if typeOf n == typeOf "" then "string" else "other"