Haskell：如何设置参数的多态类型和返回类型

Question

I want to define a set of functions in polymorphic type of arguments and return types, just as below.

class Poly a b where
  poly :: a -> b

instance Poly Int Int where
  poly :: Int -> Int
  poly a = a

When I test it in ghci, using poly 3 :: Int and then it gives me errors:

*Poly> poly 3 :: Int

<interactive>:486:1: error:
    • Ambiguous type variable ‘a0’ arising from a use of ‘poly’
      prevents the constraint ‘(Poly a0 Int)’ from being solved.
      Probable fix: use a type annotation to specify what ‘a0’ should be.
      These potential instance exist:
        instance Poly Int Int
          -- Defined at OneFunctionManyArguments.hs:10:10
    • In the expression: poly 3 :: Int
      In an equation for ‘it’: it = poly 3 :: Int

<interactive>:486:6: error:
    • Ambiguous type variable ‘a0’ arising from the literal ‘3’
      prevents the constraint ‘(Num a0)’ from being solved.
      Probable fix: use a type annotation to specify what ‘a0’ should be.
      These potential instances exist:
        instance Num Integer -- Defined in ‘GHC.Num’
        instance Num Double -- Defined in ‘GHC.Float’
        instance Num Float -- Defined in ‘GHC.Float’
        ...plus two others
        ...plus 46 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the first argument of ‘poly’, namely ‘3’
      In the expression: poly 3 :: Int
      In an equation for ‘it’: it = poly 3 :: Int

When I use poly (3 :: Int) :: Int , it returns me the right value 3 ... I would like to know how to get rid of the tedious :: Int declaration?

Answer 1

Change the type of poly ? Right now nothing keeps you (or some random library) from adding eg a Poly Double Int instance, which is why the type of 3 in poly 3 is ambiguous.

You could do

instance Poly a where
    poly :: a -> a

That would nail down the type of poly 3 :: Int , but it would make poly less general.

You could enable FunctionalDependencies and do

instance Poly a b | b -> a where
    poly :: a -> b

Then poly 3 :: Int would be OK, because b is declared as uniquely determining a .

You could also enable TypeFamilies and use an associated type:

class Poly b where
    type Arg b :: *
    poly :: Arg b -> b

instance Poly Int where
    type Arg Int = Int
    poly x = x

Again, this lets ghc derive the argument type from the result type, so poly 3 :: Int typechecks.