So I have this class:
class Collection c where
empty :: c key value
singleton :: key -> value -> c key value
insert :: Ord key => key -> value -> c key value -> c key value
looKup :: Ord key => key -> c key value -> Maybe value
delete :: Ord key => key -> c key value -> c key value
keys :: c key value -> [key]
keys x = map fst $ toList x
values :: c key value -> [value]
values c = map snd $ toList c
toList :: c key value -> [(key, value)]
fromList :: Ord key => [(key,value)] -> c key value
fromList [] = empty
fromList ((k, v):xs) = insert k v (fromList xs)
Why is this
instance Collection (PairList k v) where
a bad instantion of the class and this:
instance Collection PairList where
is a good one? I know that when making maybe an instance of Eq
, this is how haskell does it:
instance Eq (Maybe m) where
Just x == Just y = x == y
Nothing == Nothing = True
_ == _ = False
So instantiations accept parameters... So why is the first one like so?
Based on how c
is used, Collection
requires something of kind * -> * -> *
.
> :k Collection
Collection :: (* -> * -> *) -> Constraint
PairList kv
, though, has kind *
.
Eq
, on the other hand, expects something of kind *
, which is exactly what Maybe m
is.
> :k Eq
Eq :: * -> Constraint
( Maybe
itself has kind * -> *
, but applying it to a type variable produces something of kind *
.)
The thing you put in the instance head will be substituted for the class variable everywhere. So, if we combine
class Collection c where
empty :: c key value
-- and other stuff, too, of course
and
instance Collection (PairList k v)
we get the type
empty :: (PairList k v) key value
which doesn't make a lot of sense. But if we combine the class declaration with
instance Collection PairList
then we get the type
empty :: PairList key value
which makes sense just fine.
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.