This is a functional dependency. You can probably find informationin the GHC docs. It's a way of telling the compiler how to derive type information on multiparameter classes. For example, if I have a class: class C a b where f :: a -> b the type of f is (C a b) => a -> b The problem here is that you may have multiple instances of C with the same a: instance C Int Bool ... instance C Int Char ... so when you use f, it doesn't know which instance to use. Writing 'a -> b' means "a uniquely determines b" and makes it so for any given a, you can only have one instance of C, so the two above instances would be rejected: you could only have one. This means that when you write 'f (5::Int)' it knows which instance to choose, since there can only be one. - Hal -- Hal Daume III "Computer science is no more about computers | hdaume@isi.edu than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume On Wed, 21 Aug 2002, Guest, Simon wrote:
Hello all,
Please could someone explain the meaning of | in this class declaration (from Andrew's example):
class (Ord k) => Map m k v | m -> k v where lookupM :: m -> k -> Maybe v
I couldn't find reference to this in any of my standard Haskell tutorials, nor the Haskell 98 report. Any references?
cheers, Simon
-----Original Message----- From: Andrew J Bromage [mailto:ajb@spamcop.net] Sent: 21 August 2002 04:19 To: haskell-cafe@haskell.org Subject: Re: Question about sets
G'day all.
On Tue, Aug 20, 2002 at 10:57:36AM -0700, Hal Daume III wrote:
Lists with arbitrary elements are possible, but not very useful. After all, what could you do with them?
It's often useful to have containers of arbitrary _constrained_ types, because then you can do something with them. For example, given the class of partial mappings on orderable keys:
class (Ord k) => Map m k v | m -> k v where lookupM :: m -> k -> Maybe v
instance (Ord k) => Map (FiniteMap k v) k v where lookupM = lookupFM
instance (Ord k) => Map [(k,v)] k v where lookupM m k = case [ v | (k',v) <- m, k == k' ] of [] -> Nothing (v:_) -> Just v
instance (Ord k) => Map (k -> Maybe v) k v where lookupM = id
You can make a list of elements, which can be any type so long as they are a member of that class:
data MAP k v = forall m. (Map m k v) => MAP m
type ListOfMap k v = [MAP k v]
Then you can do things with it:
lookupLom :: (Ord k) => ListOfMap k v -> k -> [ Maybe v ] lookupLom xs k = [ lookupM a k | MAP a <- xs ]
test :: [Maybe Int] test = lookupLom maps 1 where maps = [ MAP finiteMap, MAP assocListMap, MAP functionMap ] finiteMap = listToFM [(1,2)] assocListMap = [(1,3)] functionMap = \k -> if k == 1 then Just 4 else Nothing
It's a little unfortunate that you have to introduce the MAP type here. You can in fact construct a list of this type:
type ListOfMap k v = [ forall m. (Map m k v) => m ]
But then you can't use the elements in the list because the Haskell type checker can't find the (Map m k v) constraint.
Cheers, Andrew Bromage _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe