- Haskell-Cafe - Haskell.org

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

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

23 May '05

Hi, I'm new to Haskell and even newer to this list. I have over 20 years of experience in C or C++. For fun, I decided to write a Fourier transform in Haskell. It would be convenient if I had a function that converts any real or complex number into a complex number. My attempt at doing this is below. Hugs produces errors when I try to load this code. Essentially, I'm trying to define a class called ConvertibleToComplex. There is a function in this class called toComplex. toComplex has the type: class ConvertibleToComplex a where toComplex :: RealFloat b => a -> Complex b I'd like some instances of toComplex to return a Complex Double while other instances return a Complex Float. Doing this sort of thing in C++ is fairly easy. However, I get the feeling that I'm pushing the Haskell type system to do something it isn't designed to do. Is there a way to define ConvertibleToComplex so that toComplex's return type is generic and a particular instance of ConvertibleToComplex decides what the return type is? Here is my attempt at doing this. If someone can give me some pointers on how to make this work, I'd appreciate it. module Main where import Complex -------------------------------------------------------------------------------- -- toComplex should convert a real or complex number to a complex number. -- -- Here's my goal for the type of toComplex. Given: -- f :: Float -- d :: Double -- cf :: Complex Float -- cd :: Complex Double -- -- When toComplex is applied to these, I'd like it to evaluate to the -- following types: -- -- toComplex f :: Complex Float -- toComplex d :: Complex Double -- toComplex cf :: Complex Float -- toComplex cd :: Complex Double class ConvertibleToComplex a where toComplex :: RealFloat b => a -> Complex b -- If I uncomment the following code, Hugs produces errors: -- ERROR "c:\tmp\test2.hs":29 - Inferred type is not general enough -- *** Expression : toComplex -- *** Expected type : (ConvertibleToComplex Float, RealFloat a) => Float -> Complex a -- *** Inferred type : (ConvertibleToComplex Float, RealFloat Float) => Float -> Complex Float {- instance ConvertibleToComplex Float where toComplex f = f :+ 0 instance ConvertibleToComplex Double where toComplex d = d :+ 0 instance ConvertibleToComplex (Complex a) where toComplex c = c -}

3 2

Open mutable records
by Einar Karttunen 23 May '05

23 May '05

Hello I recently ended up hacking a quite concise implementation of mutable open (extensible) records in Haskell. Most of the ideas came from the HList-paper, but this seems like a very simple way of doing things. Run with ghci -fglasgow-exts -fallow-overlapping-instances. Import some stuff we are going to need later: > import Control.Monad.Reader > import Data.IORef > import System Monad for mutable record calculations - to get implisit this/self in the OO sense. > newtype OO t r = OO (ReaderT t IO r) deriving(Monad, MonadReader t, MonadIO) > > with :: s -> OO s a -> OO b a > with this (OO c) = liftIO (runReaderT c this) > > ooToIO :: OO s a -> IO a > ooToIO (OO c) = runReaderT c undefined Records First the record constructor - followed by the terminator. > data a :.: r = RC !a !r > infixr :.: > data END = END Next we define a field access method. > class Select r f t | r f -> t where (!) :: r -> f -> Ref t > instance Select (Field f t :.: r) f t where (!) (RC (F x) _) _ = x > instance Select r f t => Select (a :.: r) f t where (!) (RC _ t) = (!) t And finally the type of mutable fields. > type Ref a = IORef a > newtype Field name rtype = F (Ref rtype) Next we define a way to construct record values. > infixr ## > (##) :: v -> OO s r -> OO s ((Field f v) :.: r) > (##) v r = do { h <- liftIO (newIORef v); t <- r; return (RC (F h) t) } > end = return END :: OO s END Get the value of a field. > value :: Select s f t => f -> OO s t > value a = do x <- asks (\s -> s!a) > liftIO (readIORef x) Or set the value of a field. > (<-:) :: Select s f t => f -> t -> OO s () > a <-: b = do x <- asks (\s -> s!a) > liftIO (writeIORef x b) And as a convenience add value to an int field. > (+=) :: Select s f Int => f -> Int -> OO s Int > a += b = do x <- asks (\s -> s!a) > val <- liftIO (readIORef x) > let z = val+b > z `seq` liftIO (writeIORef x z) > return z Now implement the classic ocaml OO tutorial: > data X = X > type Point = Field X Int :.: END > > newPoint :: OO s Point > newPoint = 0 ## end > > getX :: Select s X t => OO s t > getX = value X > > move d = X += d > data Color = Color > type ColoredPoint = Field Color String :.: Point > > newColoredPoint :: String -> OO s ColoredPoint > newColoredPoint c = c ## 0 ## end > > color :: Select s Color t => OO s t > color = value Color The code looks in more complex examples like this: ((~=) is prepending into list fields.) newArrival :: Patient -> OO Hospital () newArrival patient = do with patient (HospitalVisits += 1) staff <- value FreeStaff if staff > 0 then do FreeStaff += (-1) Examination ~= patient with patient (do HospitalTime += 3 RemainingTime <-: 3) else do Triage ~= patient > main = ooToIO (do c1 <- newPoint > c2 <- newColoredPoint "green" > with c1 $ move 7 > with c2 $ move 4 > let p x = liftIO (print x) > p =<< with c1 getX > p =<< with c2 getX) - Einar Karttunen

2 1

terrible Haskell pun
by Michael Vanier 23 May '05

23 May '05

I came up with a terrible Haskell pun that I had to share with this list: Haskell provides special syntactic support for monads in terms of the "do notation". There is a straightforward translation between this notation and the core language, which constitutes its "do-notational semantics", as it were. Sorry, Mike

1 0