使用Data.Vector的“推断类型不明确”错误

Question

The following code fails to compile, with the error message given below. f should simply be a state monad which when run creates a vector of length one with a single int "42". I suspect some ambiguity is happening between run and unstream much like show . read show . read , but I can't figure out how to resolve it:

{-# LANGUAGE NoMonomorphismRestriction #-}

import Data.Vector.Generic.New (run, unstream)
import Data.Vector.Fusion.Stream (singleton)

f = run . unstream . singleton $ (42 :: Int)

main = return ()

Error:

main.hs:6:1:

Could not deduce (Data.Vector.Generic.Base.Vector v0 Int)
  arising from the ambiguity check for `f'
from the context (Data.Vector.Generic.Base.Vector v Int)
  bound by the inferred type for `f':
             Data.Vector.Generic.Base.Vector v Int =>
             GHC.ST.ST s (Data.Vector.Generic.Base.Mutable v s Int)
  at sort.hs:6:1-44
Possible fix:
  add an instance declaration for
  (Data.Vector.Generic.Base.Vector v0 Int)
When checking that `f'
  has the inferred type `forall (v :: * -> *) s.
                         Data.Vector.Generic.Base.Vector v Int =>
                         GHC.ST.ST s (Data.Vector.Generic.Base.Mutable v s Int)'
Probable cause: the inferred type is ambiguous

main.hs:6:1:

Could not deduce (Data.Vector.Generic.Base.Mutable v0
                  ~ Data.Vector.Generic.Base.Mutable v)
from the context (Data.Vector.Generic.Base.Vector v Int)
  bound by the inferred type for `f':
             Data.Vector.Generic.Base.Vector v Int =>
             GHC.ST.ST s (Data.Vector.Generic.Base.Mutable v s Int)
  at sort.hs:6:1-44
NB: `Data.Vector.Generic.Base.Mutable' is a type function, and may not be injective
Expected type: Data.Vector.Generic.Base.Mutable v s Int
  Actual type: Data.Vector.Generic.Base.Mutable v0 s Int
Expected type: GHC.ST.ST
                 s (Data.Vector.Generic.Base.Mutable v s Int)
  Actual type: GHC.ST.ST
                 s (Data.Vector.Generic.Base.Mutable v0 s Int)
When checking that `f'
  has the inferred type `forall (v1 :: * -> *) s1.
                         Data.Vector.Generic.Base.Vector v1 Int =>
                         GHC.ST.ST s1 (Data.Vector.Generic.Base.Mutable v1 s1 Int)'
Probable cause: the inferred type is ambiguous

Answer 1

You can generally resolve ambiguities like these by attaching a type annotation. In this case, the question is, "Which instance of Vector va should I use when unstream creates a New va ?". This can be resolved either by putting an annotation on run or unstream , but it looks as though an annotation on unstream would be less (finger) typing. Something like this:

f = run . (unstream :: Stream Int -> New {- put something concrete here -} Int) . singleton $ 42

Answer 2

It is the show . read show . read problem, but with a twist.

The two functions we are composing here are

unstream :: forall s v a. (Vector v) => Stream a -> New v a
run :: forall s v' a'. New v' a' -> ST s (Mutable v' s a')

Composing them yields New va ~ New v' a' , and since New is a datatype, it is injective; thus we have v ~ v' and a ~ a' , for:

run . unstream :: forall s v a. (Vector v) => Stream a -> ST s (Mutable v s a)

However, the choice of v is unspecified by the type Stream a -> ST s (Mutable vsa) , since Mutable is a type family, and is thus not injective. This is where it becomes like show . read :: forall a. (Show a, Read a) => String -> String show . read :: forall a. (Show a, Read a) => String -> String show . read :: forall a. (Show a, Read a) => String -> String ; it is just harder to see because v seems to occur in the type.

Think about what happens when you use it at a more concrete type, eg

run . unstream :: forall s. Stream Int -> ST s (MVector s a)

there is no possible way to know what v is supposed to be just from Mutable v ~ MVector .

All this suggests a way to type run . unstream . singleton run . unstream . singleton run . unstream . singleton polymorphically, without pre-committing to a choice of v , by just requiring it to be passed at call sites:

{- LANGUAGE ScopedTypeVariables #-}

f :: forall s v a. (Vector v a) => Proxy v -> a -> ST s (Mutable v s a)
f _ = run . (unstream :: Stream a -> New v a) . singleton