具有类限制的Haskell返回类型多态

Question

Is there a way to achieve something like this without wrapping types in some kind of helper container?

class TestClass a where
    returnInt :: a -> Int

data TestData0 = TestData0
data TestData1 = TestData1

instance TestClass TestData0 where
    returnInt _ = 0

instance TestClass TestData1 where
    returnInt _ = 1

testisFunction :: (TestClass a) => Int -> a
testisFunction 0 = TestData0
testisFunction 1 = TestData1

Answer 1

As has been answered in other questions before, you can use an existential wrapper:

{-# LANGUAGE ExistentialTypes #-}

data SomeTest = forall a. TestClass a => SomeTest a

instance TestClass SomeTest where
  returnInt (SomeTest t) = returnInt t

testFunction :: Int -> SomeTest
testFunction 0 = SomeTest TestData0
testFunction 1 = SomeTest TestData1

Then the usage is:

returnInt (testFunction 0) == 0

However, in answer to your specific question, it is possible to avoid this wrapper by turning your code “inside out” with continuation-passing style , converting the (rank-1) existential type into a (rank-2) universal type:

{-# LANGUAGE RankNTypes #-}

testFunction :: Int -> (forall a. TestClass a => a -> r) -> r
testFunction 0 k = k TestData0
testFunction 1 k = k TestData1

Then instead of consuming the result of testFunction , we pass a function that will accept its result. Crucially, this function must work forall a. TestClass a forall a. TestClass a , so it doesn't know anything about the type a other than that it's an instance of TestClass . The usage changes to:

testFunction 0 returnInt == 0

Remember, top-level forall is implicit in type signatures, so this says that the caller of testFunction decides what a is:

testFunction ::           TestClass a => Int -> a
testFunction :: forall a. TestClass a => Int -> a

And that type is equivalent to this:

testFunction ::           Int -> (forall a. TestClass a => a)

Moving the forall one level inward, so it applies to the continuation k , means that testFunction , the caller of k , now decides what a is. The caller of testFunction now decides what r (the result type) is by passing in a particular k .

testFunction :: forall r. Int -> (forall a. TestClass a => a -> r) -> r

Answer 2

不，您需要某种包装纸。