May 2005 - Haskell-Cafe

Re: explicit signatures and default for integer literals
by Daniel Fischer 27 May '05

27 May '05

Am Freitag, 27. Mai 2005 15:00 schrieb Mirko Rahn: > Hi all, > > an explicit given signature causes ghc to choose the right types for > integer literals as in > > {-# OPTIONS -fglasgow-exts #-} > > import Data.Map > > f :: Ord a => [a] -> Map a Int > f xs = fromList $ zip xs [0..] > > Here the Literal 0 is threated as (0::Int). > > But the setting > > {-# OPTIONS -fglasgow-exts #-} > > import Data.Map > > class New a b where new :: a -> b > > instance Ord a => New [(a,b)] (Map a b) where new = fromList > > g :: Ord a => [a] -> Map a Int > g xs = new $ zip xs [0..] > > causes the error message > > Could not deduce (New [(a, b)] (Map a Int)) from the context (Ord a) > arising from use of `new' at Why.hs:10:7-9 > > ghc seems to be unable to threat the Literal 0 as (0::Int) this time but > I do not understand why :-( > > Can anyone explain it? > > Thanks, The problem is that ghc can't know that 0 ought to be Int, as it is, nothing prevents you declaring an instance Ord a => New [(a, Double)] (Map a Int) where new = ? and then it's clear that ghc wouldn't know which instance to choose. To solve the problem, I have three suggestions - write [0 :: Int .. ], so ghc knows that New [(a,Int)] (Map a Int) is the required instance - add a fundep: class New a b | [a -> b,] b -> a where ..., and ghc can again deduce the instance - add an expression type signature in 'g' g xs = (new :: Ord a => [(a,Int)] -> Map a Int) $ zip xs [0 .. ] any of these will do, depending on what you want,I recommend one of the first two. Cheers, Daniel

1 0

ghc 6.4 import problem
by Shiqi Cao 27 May '05

27 May '05

Hi, I tried to port some code from ghc 6.2 to ghc 6.4, but I got the following error PrelExts.lhs:41:25: Ambiguous occurrence `map' It could refer to either `GHC.Base.map', imported from Data.List at PrelExts.lhs:11:0-15 or `Data.Set.map', imported from Data.Set at PrelExts.lhs:10:0-14 The following is the first part of the code module PrelExts where import Data.FiniteMap import Data.Set import Data.List import IO There is no problem under ghc 6.2. What should I do? Shiqi Cao

1 0

Re: working Edison, a couple of collection modules, and typing troubles
by oleg＠pobox.com 26 May '05

26 May '05

Samuel Bronson wrote: > I was trying my hand at writing some collection classes myself and I > can't figure out a good typing for map that will let me make Map an > instance of my Collection class... > I don't much like the head of Mapping. How about the following: > class Collection (d k e) (k, e) => Mapping d k e where > -- * Query > lookup :: (Monad m) => k -> d k e -> m e > > instance Ord k => Collection (M.Map k e) (k, e) where > null = M.null > empty = M.empty > <elided> > > instance Ord k => Mapping M.Map k e where > lookup = M.lookup A higher-ranked type constructor gets rid of functional dependencies. The drawback of course is trying to use something like Integer as a mapping from Int to Bool. We have to declare a wrapper > -- Integer as a collection of bits > newtype BitMap k e = BitMap Integer deriving Show > instance Collection (BitMap Int Bool) (Int, Bool) where > empty = BitMap 0 > fromList [] = empty > fromList ((b,v):r) = let BitMap br = (fromList r):: BitMap Int Bool > in BitMap ((if v then setBit else clearBit) br b) > > instance Mapping BitMap Int Bool where > lookup k (BitMap bm) = return $ testBit bm k This actually works (and efficiently: BitMap is a newtype, so no tagging is involved at run-time), but leaves the sense of dissatisfaction. The type BitMap k e appears polymorphic, yet the only permissible values for `k' is Int, and for `e' is Bool. Alas, this facts isn't expressed anywhere. We can add explicit constraints, or better, use GADT: > data BitMap k e where > BitMap :: Integer -> BitMap Int Bool the rest of the code is unchanged.

2 2

working Edison, a couple of collection modules, and typing troubles
by Samuel Bronson 26 May '05

26 May '05

Whatever happened to Edison? I want to play with it and the one in the HFL cvs repository won't build for me (and uses flat names). I was trying my hand at writing some collection classes myself and I can't figure out a good typing for map that will let me make Map an instance of my Collection class... I'm attaching what I have so far. I don't much like the head of Mapping. I expect oleg will have some crazy type-system trick up his sleeve. -- Thankful-in-advance-ly yrs, Sam

2 3

RE: [Haskell-cafe] RFE: Extensible algebraic user-defined data types?
by Simon Peyton-Jones 26 May '05

26 May '05

| Regarding reusing constructor names across several datatypes: is it | possible to qualify them with their enclosing datatype name, like | Maybe.Nothing where there is a name conflict? Then I might reuse | Nothing in my hypothetical data type, and it would be NEither.Nothing | if conflicting with Maybe.Nothing Yes, this'd occasionally be useful regardless of extensible data types, particularly constructor fields too. E.g. "T.x" could mean "field x from type T". There's a difficulty about parsing the name though. Does Neither.Nothing mean the constructor imported from module Neither or the constructor Nothing from type Neither In these days of lazy ambiguity resolution, though, it's not so bad. We could just say that "Neither.Nothing" names *both* of those things, and if both exist in the current scope, you need to disambiguate by adding further module qualifiers. This is one of those features that's hard to evaluate: modest gain in expressiveness, and modest increase in complexity. Simon

3 2

Compiling GHC 6.2.2 without ghci
by Jesper Louis Andersen 25 May '05

25 May '05

Hi Cafe. How do you compile GHC 6.2.2 without compiling the ghci (ghc interactive)? I only need this as a stepping stone to GHC 6.4, so it is really not needed, however great it might be. No ./configure options seem to address the problem.

1 0

Composition of Type Constructors
by Jan Christiansen 25 May '05

25 May '05

Hi! I would like to define a type class for a data structure that supports a lookup and an update function like the following one. class Mapping map key where lookup :: key -> map v -> v update :: key -> (v -> v) -> map v -> map v Now I want to lift this to a class instance for tuples of keys. This should be done by just using a map that contains another map as values. The problem is that I don't know how to express the composition of type constructors like the function (.) for ordinary functions. I know that (map1 . map2) is wrong but it states what I want to express, namely the composition of two type constructors. With this I would like to define an instance definition like the following. instance (Mapping map1 key1, Mapping map2 key2) => Mapping (map1 . map2) (key1, key2) where lookup (key1, key2) = lookup key2 . lookup key1 update (key1, key2) f = update key1 (update key2 f) I am not sure about the practical pertinence of this example cause I will probably only use one instance where the type of the keys is Int but I am curious if this is possible at all. thanks in advance, Jan

2 1

RE: [Haskell-cafe] Question about classes from a Haskell newbie.
by Simon Peyton-Jones 25 May '05

25 May '05

http://research.microsoft.com/%7Esimonpj/Papers/type-class-design-space will fix manual Simon | -----Original Message----- | From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of | Scott J. | Sent: 25 May 2005 13:29 | To: haskell-cafe | Subject: Re: [Haskell-cafe] Question about classes from a Haskell newbie. | | Hello, | | the web page http://research.microsoft.com/~simonpj/multi.ps.gz mentioned | in | | http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions. html#multi-param-type- | classes | | is not reachable or does not exist anymore. | | Any hints how I can get my hands on this paper are welcome | | Jan | | | ----- Original Message ----- | From: "robert dockins" <robdockins(a)fastmail.fm> | To: <Jeff.Harper(a)handheld.com> | Cc: <haskell-cafe(a)haskell.org> | Sent: Tuesday, May 24, 2005 10:07 PM | Subject: Re: [Haskell-cafe] Question about classes from a Haskell newbie. | | | > | >> However, I didn't understand the syntax of the class declaration. | >> | >> Lemmih wrote: | >> > import Complex | >> > | >> > class ConvertibleToComplex a b | a -> b where | >> > toComplex :: RealFloat b => a -> Complex b | >> | >> I've looked at several sources to try to understand this declaration. I | >> can't find any examples where a class declaration takes two type | >> variables or uses the pipe symbol. One of the sources I used was | >> _Haskell 98 Language and Libraries The Revised Report_. I'm not an | >> expert at BNF notation, but the definitions for topdecl, tycls, and tyvar | >> in the grammar seems to exclude Lemmih's declaration. | >> | >> If someone could point me to some sources that explain this notation, I'd | >> be very grateful. | > | > This is a multi-parameter typeclass (with functional dependencies), which | > is not a part of Haskell 98, so its no surprise that you didn't find it in | > the Report. The Muli-parameter part is pretty easy to understand: the | > type class simply introduces more than one type variable. Functional | > dependencies let you say which types should determine which other types. | > Here are some pages on these ideas: | > | > http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions. html#multi-param-type- | classes | > http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions. html#functional- | dependencies | > http://haskell.org/hawiki/FunDeps | > | > In this particular instance, what the class definition means is that | > 'ConvertaibleToComplex' is a class which relates two types 'a' and 'b' AND | > the type 'a' uniquely determines the type 'b'. | > | > | > Hope that helps, | > Robert Dockins | > | > _______________________________________________ | > Haskell-Cafe mailing list | > Haskell-Cafe(a)haskell.org | > http://www.haskell.org/mailman/listinfo/haskell-cafe | > | | | _______________________________________________ | Haskell-Cafe mailing list | Haskell-Cafe(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

Question about classes from a Haskell newbie.
by Jeff.Harper＠handheld.com 25 May '05

25 May '05

Thank you Pierre and Lemmih for answering my question about how to implement the toComplex function. Both of your answers were insightful. I understood Pierre's solution. Pierre wrote: > I think you misunderstand the meaning of the constraint ! > > toComplex :: (RealFloat b) => a -> Complex b > > means the type of "b" needs to be a "RealFloat" and that it will be > inferred from the context where the function "toComplex" is called ! "Inferring the type of a function based on the context where the function is called." is an idea that I'm going to have to wrap my mind around. Lemmih's solution is interesting too. I tried it. It seems to work well under Hugs. I'm under the impression that the return type of toComplex is inferred based on the argument passed to toComplex. However, I didn't understand the syntax of the class declaration. Lemmih wrote: > import Complex > > class ConvertibleToComplex a b | a -> b where > toComplex :: RealFloat b => a -> Complex b I've looked at several sources to try to understand this declaration. I can't find any examples where a class declaration takes two type variables or uses the pipe symbol. One of the sources I used was _Haskell 98 Language and Libraries The Revised Report_. I'm not an expert at BNF notation, but the definitions for topdecl, tycls, and tyvar in the grammar seems to exclude Lemmih's declaration. If someone could point me to some sources that explain this notation, I'd be very grateful. Thanks, Jeff

3 2

Re: [Haskell] Beyond ASCII only editors for Haskell
by Scott Turner 24 May '05

24 May '05

[moved from haskell to haskell-cafe] On May 23 Monday, Mads Lindstrøm wrote: > This also means that I do think we should invent some symbols. > Like the (->) used in function signatures. And we can live with > the new notation, even though it is not intuitive, as it is used > very, very often. Programs are logical, and from that point of view the -> symbol is an excellent match with mathematical logic. I'd like to see more support for logical symbols in the type systems of programming languages. The Curry-Howard correspondence matches function types with logical implication, and provides a source for many more symbols.

1 0