On Thursday 13 May 2010 23:26:31, Philip Scott wrote:
Hey ho,
This should be a quick one, I hope! I am mucking about with the moadic initialisers for vectors, and am experiencing all kinds of fun. For example, I think I should be able to make a new vector of, say, 3 thingies* long:
Prelude Data.Vector.Generic.Mutable> new 3
Now of course, poor old haskell does not know what sort of thing I am going to put in it yet, so it gets a bit cross:
<interactive>:1:0: Ambiguous type variable `m' in the constraint: `Control.Monad.Primitive.PrimMonad m' arising from a use of `new' at <interactive>:1:0-4 Probable fix: add a type signature that fixes these type variable(s)
<interactive>:1:0: Ambiguous type variables `v', `a' in the constraint: `MVector v a' arising from a use of `new' at <interactive>:1:0-4 Probable fix: add a type signature that fixes these type variable(s)
Now I have paid very close attention to this 'Probable Fix', but have not been able to find out precisely how to specify what sort of vector I would like (I guess this is v..) and am even more boggled by 'm'.. I guess this is asking what sort of Monad I am going to use to fill it up?
Yes, 'm' is the Monad. All known (by me) instances of PrimMonad are IO and (ST s) 'v' is the type of vector you want (very likely MVector [the datatype, not the class]), 'a' is the type of elements (Int, Char, ...). But if you give a type signature, e.g. Prelude Data.Vector.Generic.Mutable> new 3 :: IO (MVector (PrimState IO) Char) you'll very likely meet "cannot find Show instance for ..."
An example would be greatly appreciated.
I find the type of 'new' quite interesting:
new
:: forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, Data.Vector.Generic.Mutable.MVector v a) => Int -> m (v (PrimState m) a)
So I did a bit of reading up on exstential types,
However, this is not an existential type, just an explicitly universally quantified type.
and I (just about) get what 'forall' does, however I don't know what the (m :: * -> *) and (v
:: * -> * -> *) bits mean. Just telling me what they are called would
probably be enough to get me googling!
Those are kind signatures. m :: * -> * means that the type variable m stands for a type constructor which takes one type and produces a type from that. Well known examples are [], Maybe, IO, (State Int). v :: * -> * -> * means that v stands for a type constructor taking two types and producing a type. Examples: Either, State. * is the kind of types (Int, Char, Bool, [Double], Maybe (), ...) If k1 and k2 are kinds, k1 -> k2 is the kind of type-expressions that take a type-expression of kind k1 to produce one of kind k2. For example, the kind of StateT is StateT :: * -> (* -> *) -> * -> * , that means StateT takes - one type (the state) - one type constructor producing a type from a type (like IO, Maybe, []) - another type (the result type) and produces a type (e.g. StateT Int [] Bool).
I get the feeling I am a bit out of my depth here, but hey ho, I guess that's how you learn to swim!
All the best,
Phil
* thingies == things of some type, which doesn't really matter at the momant.