- Haskell - Haskell.org

Re: Extensible Algebraic Data Types
by cwitty＠newtonlabs.com 05 Mar '01

05 Mar '01

Ashley Yakeley <ashley(a)semantic.org> writes: > I think it would be useful to extend Haskell so that one could create > algebraic data types in one module that could be union-extended in > another. Something like this: > > data Thing = CharThing Char | IntThing Int | _ > > ...later... > > data Thing |= StringThing String You might be able to use the Gaster and Jones extensible variants from "A Polymorphic Type System for Extensible Records and Variants" (http://www.cse.ogi.edu/~mpj/pubs/polyrec.html) As far as I know, the extensible variants described in this paper have never been implemented (although the extensible records are implemented in Hugs). I've often thought that extensible variants would be at least as useful, if not more useful, than extensible records. Carl Witty

1 0

Disjoint type classes
by Jose Emilio Labra Gayo 05 Mar '01

05 Mar '01

I have a large program where I would like to include disjoint type classes into a new type class. My problem can be reduced to the following example (taken from [1]): > class Num a => Dividable a > where dividedBy :: a -> a -> a > instance Fractional a => Dividable a where > dividedBy = (/) > instance Integral a => Dividable a where > dividedBy = div Which doesn't work because Haskell doesn't detect that "Integral" and "Fractional" are disjoint. Is there a way to implement these type classes with current Haskell implementations? [1] K. Glynn, M. Sulzmann, P.J. Stuckey Type Classes and Constraint Handling Rules http://www.cs.mu.oz.au/tr_submit/test/cover_db/mu_TR_2000_7.html Best regards, Jose Labra

2 1

Rewrite rules
by Simon Peyton-Jones 05 Mar '01

05 Mar '01

Folks Andrew Tolmach, Tony Hoare, and I are writing a paper about rewrite rules in GHC -- the {-# RULES #-} stuff. We'd like to report on practical experience of using rewrite rules. Has anyone use them in practice? What's your experience? Pls reply to me, to avoid clogging the list with your cries of rapture. Simon

1 0

RE: question re hugs and func dependencies
by Simon Peyton-Jones 05 Mar '01

05 Mar '01

I replied last week: -----Original Message----- From: Simon Peyton-Jones Sent: 28 February 2001 16:51 To: 'Dominic Duggan'; hugs-bugs(a)haskell.org Subject: RE: please confirm that this is a feature GHC infers the type g :: (Foo [[a]] [b], Foo [[b]] [a]) => [a] -> [b] -> Int As you imply, if GHC used the instance decl to simplify the first constraint to Foo [a] b, for example, then the functional dependency would kick in, and there would be an infinite loop. But GHC's constraint simplification is (now) lazy, unless forced to be eager by supplying a type signature. I think Hugs is the same, and I think that's probably why it terminates. Interesting example! Simon | -----Original Message----- | From: Dominic Duggan [mailto:dduggan@cs.stevens-tech.edu] | Sent: 02 March 2001 21:55 | To: haskell(a)haskell.org | Subject: question re hugs and func dependencies | | | Dear all, I haven't got a reply from hugs-bugs, | so I'll see if anyone here can answer the question. | | class foo a b | a |-> b where foo :: a -> b -> Int | instance foo Int Float where foo x y = 0 | instance foo [a] [b] where foo [x] [y] = foo x y | g x y = (foo [x] y) + (foo [y] x) | | It is my conjecture that Hugs terminates on type-checking | g because of a depth bound in the type-checker | (although there is no indication from the type-checker | that this is what is going on). | | Can anyone confirm or refute this conjecture? | | FWIW this is as part of the related work section | for a paper that has been accepted to JFP: | "Type-Checking Multi-Parameter Type Classes," | by D. Duggan and J. Ophel. | | I'd appreciate cc-ing any replies to me, I'm not | sure that I'm still on this mailing list. | | Cheers | --dd |

2 1

PLI 2001: submission deadline is approaching
by Rosario Pugliese 05 Mar '01

05 Mar '01

[Apologies for multiple copies] ---------------------------------------------------------------- PLI 2001 Principles, Logics, and Implementations of high-level programming languages (Sponsored by ACM) Firenze, ITALY September 2 - 8, 2001 http://music.dsi.unifi.it/pli01/ The colloquium on Principles, Logics, and Implementations of high- level programming languages is a collection of conferences and workshops aimed at the advancement of high-level programming languages. The events composing PLI will cover a spectrum of topics important to language development and use, including issues such as semantics, design, analysis, implementation, and application. Theoretical issues relevant to language design and programming will be represented. Implementation questions will provide an emphasis on compilation methods, distributed computation and static debugging techniques. There will also be a focus on industrial and educational applications. Conferences: ICFP (September 3-5) Int. Conf. on Functional Programming General chair: Benjamin Pierce (Univ. Pennsylvania) Program chair: Xavier Leroy (INRIA Rocquencourt) PPDP (September 5-7) Int. Conf. on Principles and Practice of Declarative Programming Conference chair: Rocco De Nicola (Univ. Firenze) Program chair: Harald Søndergaard (Univ. Melbourne) Workshops: · Multilanguage Infrastructure and Interoperability (BABEL) · ERLANG Workshop · Fixed Points in Computer Science (FICS) · HASKELL Workshop · Quantitative Aspects of Programming Languages (QAPL) · Rule-Based Programming (RULE) · Semantics, Applications, and Implementation of Program Generation (SAIG) · Scheme and Functional Programming (SCHEME) · Verification and Computational Logic (VCL) Submission deadline for ICFP and PPDP: March 15, 2001 Workshops chair: Betti Venneri (Univ. Firenze) Publicity chair: Rosario Pugliese (Univ. Firenze) Organizing Committee: Gianni Aguzzi (Univ. Firenze, co-chair), Giorgio Ghelli (Univ. Pisa, co-chair), Lorenzo Bettini (Univ. Firenze), Michele Loreti (Univ. Firenze), Dario Colazzo (Univ. Pisa) Contact Information: pli-inf(a)gdn.dsi.unifi.it Conference Venue: Auditorium Banca Toscana, Via Panciatichi, 87 (Firenze Nova), Firenze, ITALY

1 0

Circular Data Types - a directory tree abstraction
by Shlomi Fish 04 Mar '01

04 Mar '01

I want to implement a directory data type where each directory may contain other directories, as well as end documents. I declared the following file for managing it: ------------------------------ module Contents_Abs where data Contents_Image url mime = MakeContents_Image url mime get_image_url (MakeContents_Image url mime) = url get_image_mime_type (MakeContents_Image url mime) = mime make_image url mime = (MakeContents_Image url mime) data Contents_Node url title subs images is_dir = MakeContents_Node url title subs images is_dir get_url (MakeContents_Node url title subs images is_dir) = url get_title (MakeContents_Node url title subs images is_dir) = title get_subs (MakeContents_Node url title subs images is_dir) = subs get_is_dir (MakeContents_Node url title subs images is_dir) = is_dir make_contents_doc url title = (MakeContents_Node url title [] [] False) make_contents_dir url title subs = (MakeContents_Node url title subs [] True) make_contents_dir_with_images url title subs images = (MakeContents_Node url title subs images True) -------------------------------------------- Now, I have the following example file: -------------------------------------------- module Contents where import Contents_Abs contents = (make_contents_dir_with_images "" "Contents" [ (make_contents_doc "intro.html" "Introduction"), (make_contents_doc "properties.html" "Properties"), (make_contents_dir "recursion" "Recursion" [ (make_contents_doc "fib1.html" "Fibonnaci (Take 1)"), (make_contents_doc "qsort.html" "Quick Sort") ] ), (make_contents_dir "lazy_eval" "Lazy Evaluation" [ (make_contents_doc "primes1.html" "Primes (Take 1)"), (make_contents_doc "fib2.html" "Fibonnaci (Take 2)") ] ) ] [ (make_image "style.css" "text/css") ] ) ------------------------------------------- I would like to be able to traverse this tree, so I defined the following script: --------------------- import Contents_Abs import Contents mytraverse contents = trav contents where trav branch = (get_url branch) ++ (trav_subs (get_subs branch)) where trav_subs [] = "" trav_subs (a:as) = (trav a) ++ (trav_subs as) result = mytraverse contents ----------------------- However, when trying to load it hugs reports the following error: Reading file "Z:\Download\unpack\hugs98\lib\Prelude.hs": Reading file "print_cont.hs": Reading file "Contents_Abs.hs": Reading file "Contents.hs": Reading file "print_cont.hs": Type checking ERROR "print_cont.hs" (line 5): Type error in function binding *** Term : trav *** Type : Contents_Node [Char] b [a] c d -> [Char] *** Does not match : a -> [Char] *** Because : unification would give infinite type Contents> I would like to know how I can define a data structure that will contain a list of references to its own types (I don't need circular data structures). I would also like to know how I can define such an abstraction inside a type. Regards, Shlomi Fish ---------------------------------------------------------------------- Shlomi Fish shlomif(a)vipe.technion.ac.il Home Page: http://t2.technion.ac.il/~shlomif/ Home E-mail: shlomif(a)techie.com The prefix "God Said" has the extraordinary logical property of converting any statement that follows it into a true one.

2 1

Extensible Algebraic Data Types
by Ashley Yakeley 03 Mar '01

03 Mar '01

I think it would be useful to extend Haskell so that one could create algebraic data types in one module that could be union-extended in another. Something like this: data Thing = CharThing Char | IntThing Int | _ ...later... data Thing |= StringThing String This would be useful for two reasons: 1. You could do something akin to dynamic typing without unreasonably stressing the ideas behind the Haskell type system: data BaseExtension = _ data Base = MkBase (Char,Int,BaseExtension) ...later... data Derived = MkDerived (Char,Int,Int,Int) data BaseExtension |= MkDerivedExtension (Int,Int) upcast :: Derived -> Base upcast (MkDerived (a,b,c,d)) = MkBase (a,b,MkDerivedExtension(c,d)) downcast :: Base -> Maybe Derived downcast MkBase (a,b,MkDerivedExtension(c,d)) = Just (MkDerived (a,b,c,d)) downcast MkBase (a,b,_) = Nothing 2. You'd have a way of autogenerating values similar to LISP's gensym: data Token = _ deriving Eq ...later... data Token |= ThisToken data Token |= ThatToken data Token |= BunchOfTokens Int Of course this extension to Haskell begs another, virtual or generic functions. I'm not sure how to do this properly while maintaining the principle that an expression has the same value regardless of other modules loaded. data Thing = CharThing Char | IntThing Int | _ f1 :: Thing -> Int f1 (CharThing c) = ord c f1 (IntThing i) = i -- somehow allow cases to be inserted later here f1 _ = 0 -- multiple dispatch f2 :: Thing -> Thing -> Int f2 (IntThing i) (IntThing j) = i + j -- might want cases inserted here, -- provided they don't cause trouble f2 (IntThing i) _ = i -- or here f2 _ (IntThing i) = i + 1 -- or here f2 _ _ = 0 Are these ideas something worth thinking about? Or would such extensions compromise important principles behind Haskell? -- Ashley Yakeley, Seattle WA

1 0

Announce: Mysql-HS 0.10.0
by Volker Wysk 02 Mar '01

02 Mar '01

MySQL-HS is an interface to the MySQL database. This is a maintaince release. Changes: - Ported to GHC 4.08 and H/Direct 0.17 - Inproved documentation - General polishment This version is considered to be stable. If there don't show any bugs, the next version will be 1.0.0 and probably the conclusive one. (Except for support of new versions of GHC, H/Direct, MySQL). The homepage is at http://www.volker-wysk.de/mysql-hs

1 0

question re hugs and func dependencies
by Dominic Duggan 02 Mar '01

02 Mar '01

Dear all, I haven't got a reply from hugs-bugs, so I'll see if anyone here can answer the question. class foo a b | a |-> b where foo :: a -> b -> Int instance foo Int Float where foo x y = 0 instance foo [a] [b] where foo [x] [y] = foo x y g x y = (foo [x] y) + (foo [y] x) It is my conjecture that Hugs terminates on type-checking g because of a depth bound in the type-checker (although there is no indication from the type-checker that this is what is going on). Can anyone confirm or refute this conjecture? FWIW this is as part of the related work section for a paper that has been accepted to JFP: "Type-Checking Multi-Parameter Type Classes," by D. Duggan and J. Ophel. I'd appreciate cc-ing any replies to me, I'm not sure that I'm still on this mailing list. Cheers --dd

1 0

strictness question
by S. Doaitse Swierstra 02 Mar '01

02 Mar '01

I ran into a difference between GHC and Hugs. The following code: f (P p) ~(P q) = P (\ k -> \inp -> let (((pv, (qv, r)), m), st) = p (q k) inp in (((pv qv , r ), m), st)) runs fine with Hugs but blows up with GHC, whereas: f (P p) ~(P q) = P (\ k -> \inp -> let ~(~(~(pv, ~(qv, r)), m), st) = p (q k) inp in (((pv qv , r ), m), st)) runs fine with GHC too. From the Haskell manual I understand that pattern matching in "let"'s should be done lazily, so the addition of a collection of ~'s should not make a difference. Am I right with this interpretation? A possible source of this problem may be origination from the smarter GHC optimiser, but in that case the optimiser is not doing its work well. Doaitse Swierstra -- __________________________________________________________________________ S. Doaitse Swierstra, Department of Computer Science, Utrecht University P.O.Box 80.089, 3508 TB UTRECHT, the Netherlands Mail: mailto:doaitse@cs.uu.nl WWW: http://www.cs.uu.nl/ PGP Public Key: http://www.cs.uu.nl/people/doaitse/ tel: +31 (30) 253 3962, fax: +31 (30) 2513791 __________________________________________________________________________

3 2