January 2001 - Haskell

Re: O'Haskell OOP Polymorphic Functions
by Johan Nordlander 16 Jan '01

16 Jan '01

Ashley Yakeley wrote: > > At 2001-01-16 14:04, Tom Pledger wrote: > > >The subtyping (struct Derived < Base ...) makes the two instances > >overlap, with 'instance TheValue Derived' being strictly more specific > >than 'instance TheValue Base'. If the system preferred the less > >specific one, the more specific one would never be used. > > > >This is quite similar to the way overlapping instances are handled > >when they occur via substitutions for type variables (e.g. 'instance C > >[Char]' is strictly more specific than 'instance C [a]') in > >implementations which support than language extension. > > Subtyping-overlapping is quite different from type-substitution > overlapping. > > Consider: > > struct B > > struct D1 < Base = > a1 :: Int > > struct D2 < Base = > a2 :: Int > > class TheValue a where theValue :: a -> Int > instance TheValue B where theValue _ = 0 > instance TheValue D1 where theValue _ = 1 > instance TheValue D2 where theValue _ = 2 > > struct M < D1,D2 > > m = struct > a1 = 0 > a2 = 0 > > f = theValue m > > What's the value of f? This program is rejected on the grounds that it lacks an instance delaration for TheValue M. Declare one and you will be fine. Or (when the upcoming release becomes available) remove the instance decl for either D1 or D2 and the remaining one will be chosen. -- Johan

1 0

Re: O'Haskell OOP Polymorphic Functions
by Ashley Yakeley 16 Jan '01

16 Jan '01

At 2001-01-16 13:18, Magnus Carlsson wrote: >f1 = Just 3 >f2 = f3 = f4 = Nothing So I've declared b = d, but 'theValue b' and 'theValue d' are different because theValue is looking at the static type of its argument? What's to stop 'instance TheValue Base' applying in 'theValue d'? -- Ashley Yakeley, Seattle WA

1 0

Re: O'Haskell OOP Polymorphic Functions
by Ashley Yakeley 16 Jan '01

16 Jan '01

At 2001-01-16 10:23, Magnus Carlsson wrote: >You can use overloading for the definition of theValue instead: > > class TheValue a where theValue :: a -> Maybe Int > > instance TheValue Base where theValue _ = Nothing > instance TheValue Derived where theValue x = Just (x.value) Doesn't this imply that run-time type information is kept with the structs? Consider: d :: Derived d = struct value = 3 b :: Base b = d idb :: Base -> Base idb x = x f1 = theValue d f2 = theValue b f3 = theValue (idb d) f4 = theValue (idb b) What are the values of f1, f2, f3 & f4? -- Ashley Yakeley, Seattle WA

2 1

ANNOUNCE: GHood (updated pre-release)
by C.Reinke 16 Jan '01

16 Jan '01

Ever wanted to see what your Haskell program is doing?-) ----------------------------------------------------------------- GHood (pre-release, 11 January 2001) "Graphical Hood" -- a Java-based graphical observation event viewer, as a back-end for Andy Gill's Hood (Haskell Object Observation Debugger). Currently, GHood comes in two files: a drop-in replacement for the Hugs98 variant of Hood (only minimal changes, same interface) and a Java class file archive for the graphical viewer itself. To find the two files, please visit my Haskell corner at: http://www.cs.ukc.ac.uk/people/staff/cr3/toolbox/haskell/#GHood ----------------------------------------------------------------- The GHood pre-release has been updated. The main change (apart from single-stepping through the observation event stream, which you might have been missing in the previous version): GHood can now be used as an applet (requires Java 2/Swing-capable browser or a suitable Java plug-in). This means that GHood animations can now be used to enrich webpages. If you ever wanted to discuss the behaviour of Haskell programs on your webpages, you can now add applets to those pages that visualise and animate the issues you describe. If you never dared to write about program behaviour for lack of illustrations, you might now consider adding such discussions to your webpages. Potential uses: - educators: as part of your functional programming course webpages, - programmers: as part of the description of a clever functional algorithm, or to document problems in a misbehaving functional program - GHood implementors (me;-): show examples of GHood animations online. I would be interested to learn about example problems from practice for which GHood has been found helpful. Please let me know, too, if you create websites that use GHood as an applet. Enjoy, Claus -- Claus Reinke, http://www.cs.ukc.ac.uk/people/staff/cr3/ Computing Lab, University of Kent at Canterbury

1 0

O'Haskell OOP Polymorphic Functions
by Ashley Yakeley 16 Jan '01

16 Jan '01

How do you do OOP-style polymorphic functions in O'Haskell? My first attempt looked something like this: struct Base struct Derived < Base = value :: Int theValue :: Base -> Maybe Int theValue x = Just (x.value) -- problem line theValue _ = Nothing In the problem line, x is considered to be of type Base, so x.value gives an error. I tried replacing it with theValue (x :: Derived) = Just (x.value) ...but that doesn't work either. -- Ashley Yakeley, Seattle WA

3 3

Re: Too Strict?
by Steinitz, Dominic J 16 Jan '01

16 Jan '01

Claus, Thanks for this. I think I can see what the problem was: mapM has to process the whole input before making a value available for hPutStr. Also I can see how to fix the problem. What I can't see at the moment is how to keep what I was doing modular. I had a module Anonymize, the implementation of which I wanted to change without the user of it having to change their code. The initial implementation was a state monad which generated a new string every time it needed one but if it was a string it had already anonymized then it looked it up in the state. I initially used a list but with 100,000+ strings it took a long time. The next implementation used FiniteMap which improved things considerably. I only had to make three changes in Anonymize and none in Main. Using MD5 is quicker still but isn't so good from the program maintenance point of view. Dominic. C.Reinke(a)ukc.ac.uk on 15/01/2001 15:02:00 To: Dominic Steinitz cc: haskell glasgow-haskell-users bcc: Subject: Re: Too Strict? > Can someone help? The program below works fine with small files but when I > try to use it on the one I need to (about 3 million lines of data) it > produces no output. The hard disk is hammered - I assume this is the run time > system paging. My suspicion is that the program is trying to read in the > whole file before processing it. Is this correct? If so, how do I make the > program lazy so that it processes a line at time? I was about to apply GHood to your program to see whether such a tool could help to find the problem, so I started to cut down your code. However, in the simplified version of the program, one can see what is going on without any graphical tool.. (nevertheless, observation of the simplified code with GHood confirms your suspicion immediately, and it points out the spine of the list as the problem, too, so the tool is useful!-) (*) In effect, your anonymize comes down to a "mapM" over a list of actions applied to input lines, and all of the resulting IO-actions are placed before the single "hPutStr". So, even if the results of the individual actions in the list may not be needed until later, the whole spine of the list of lines has to be traversed before "hPutStr" can be executed, meaning that all input is read before any output is produced (and thus before any computation results are requested, blowing up memory usage). For the problem at hand, you could simply output each line as it is processed instead of just returning it into a list for later use (see variant _1 below). If you would want to keep both the modular program structure and the explicit line-by-line IO-style, you would need to interleave the input and output commands somehow (perhaps similar to variant _2 below?). Hth, Claus (*) Please note that our web-server is being upgraded today.. (web-pages and GHood download will not be available until tomorrow, hence no URL here :-( PS The simplified code (+ variations) with observations: module Main(main) where import Observe import IO(openFile, hPutStr, IOMode(ReadMode,WriteMode,AppendMode)) filename = "ldif1.txt" fileout = "ldif.out" readAndWriteAttrVals = do h <- openFile fileout WriteMode s <- readFile filename let action l = return (':':l) a <- mapM action (observe "input" (lines s)) hPutStr h (unlines (observe "output" a)) main = runO readAndWriteAttrVals readAndWriteAttrVals_1 = do h <- openFile fileout WriteMode s <- readFile filename let action_and_output l = hPutStr h (':':l) mapM_ (observe "output" action_and_output) (observe "input" (lines s)) main_1 = runO readAndWriteAttrVals_1 readAndWriteAttrVals_2 = do h <- openFile fileout WriteMode s <- readFile filename let { action l = return (':':l) ; as = map action (observe "input" (lines s)) ; os = repeat (hPutStr h) } mapM id (observe "output" (zipWith (>>=) as os)) main_2 = runO readAndWriteAttrVals_2 _______________________________________________ Haskell mailing list Haskell(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell ------------------------------------------------------------------------------------------------- 21st century air travel http://www.britishairways.com

1 0

Re: O'Haskell OOP Polymorphic Functions
by Ashley Yakeley 16 Jan '01

16 Jan '01

At 2001-01-16 00:03, Johan Nordlander wrote: >Ashley Yakeley wrote: >> >> How do you do OOP-style polymorphic functions in O'Haskell? My first >> attempt looked something like this: >> >> struct Base >> >> struct Derived < Base = >> value :: Int >> >> theValue :: Base -> Maybe Int >> theValue x = Just (x.value) -- problem line >> theValue _ = Nothing >> >> In the problem line, x is considered to be of type Base, so x.value >> gives an error. > >I'm not sure what OOP-style you're referring to. This is like trying >to access the "color" field of an ordinary, uncolored "point". Right, but returning 'Nothing' for uncolored points and (Just) the color for colored points. > How would you program your function in Java? Library code: public class Base { } public class Derived extends Base { public int value; public Derived(int v) { value = v; } } Application code: public static MaybeInt theValue(Base x) { if (x instanceof Derived) return new MaybeInt(((Derived) x).value); else return MaybeInt.NOTHING; } >> I tried replacing it with >> >> theValue (x :: Derived) = Just (x.value) >> >> ...but that doesn't work either. > >But that's just because O'Haskell doesn't support type annotated >variables in patterns (yet). Change the type signature of your function >to > > theValue :: Derived -> Maybe Int > >instead, and it should typecheck (it still wouldn't make much sense, though). I want a function of type 'Base -> Maybe Int' that returns the value of a Derived and Nothing for any other Base. Is it possible to construct such a function? >However, as a general remark, I'd like to point out that record terms in >O'Haskell don't carry their type with them at run-time. Like in C++, >the type of a record term is a purely static notion that only exists at >compile time. Hence it's not possible to define a function that returns >a value that depends on the dynamic type of its argument (a big win when >one wants to enforce information hiding). > >The solution is instead to use an ordinary datatype for values that one >would like to scrutinize at run-time by pattern-matching (the FP way), This requires knowing the entire type structure before defining any such functions. >or to internalize the function in question into the record type itself >(the OOP way). This requires knowing all such functions before defining the type structure. It also makes multiple dispatch difficult. I'm not sure this can even be done by adding a dynamic-type field, since you still need to cast to the Derived type to get the value. -- Ashley Yakeley, Seattle WA

1 0

bootstrapping GHC
by William Lee Irwin III 15 Jan '01

15 Jan '01

I've recently acquired access to SPARC and PPC Linux boxen. GHC 4.04 is presently bootstrapping on the SPARC, and I was wondering if there were PPC hc files floating about anywhere, or documentation on how to generate them. Thanks, Bill

1 1

Yet more on functional dependencies
by George Russell 15 Jan '01

15 Jan '01

I am finding functional dependencies confusing. (I suspect I am not alone.) Should the following code work? class HasConverter a b | a -> b where convert :: a -> b instance (HasConverter a b,Show b) => Show a where show value = show (convert value)

4 3

Re: Too Strict?
by C.Reinke 15 Jan '01

15 Jan '01

> Can someone help? The program below works fine with small files but when I > try to use it on the one I need to (about 3 million lines of data) it > produces no output. The hard disk is hammered - I assume this is the run time > system paging. My suspicion is that the program is trying to read in the > whole file before processing it. Is this correct? If so, how do I make the > program lazy so that it processes a line at time? I was about to apply GHood to your program to see whether such a tool could help to find the problem, so I started to cut down your code. However, in the simplified version of the program, one can see what is going on without any graphical tool.. (nevertheless, observation of the simplified code with GHood confirms your suspicion immediately, and it points out the spine of the list as the problem, too, so the tool is useful!-) (*) In effect, your anonymize comes down to a "mapM" over a list of actions applied to input lines, and all of the resulting IO-actions are placed before the single "hPutStr". So, even if the results of the individual actions in the list may not be needed until later, the whole spine of the list of lines has to be traversed before "hPutStr" can be executed, meaning that all input is read before any output is produced (and thus before any computation results are requested, blowing up memory usage). For the problem at hand, you could simply output each line as it is processed instead of just returning it into a list for later use (see variant _1 below). If you would want to keep both the modular program structure and the explicit line-by-line IO-style, you would need to interleave the input and output commands somehow (perhaps similar to variant _2 below?). Hth, Claus (*) Please note that our web-server is being upgraded today.. (web-pages and GHood download will not be available until tomorrow, hence no URL here :-( PS The simplified code (+ variations) with observations: module Main(main) where import Observe import IO(openFile, hPutStr, IOMode(ReadMode,WriteMode,AppendMode)) filename = "ldif1.txt" fileout = "ldif.out" readAndWriteAttrVals = do h <- openFile fileout WriteMode s <- readFile filename let action l = return (':':l) a <- mapM action (observe "input" (lines s)) hPutStr h (unlines (observe "output" a)) main = runO readAndWriteAttrVals readAndWriteAttrVals_1 = do h <- openFile fileout WriteMode s <- readFile filename let action_and_output l = hPutStr h (':':l) mapM_ (observe "output" action_and_output) (observe "input" (lines s)) main_1 = runO readAndWriteAttrVals_1 readAndWriteAttrVals_2 = do h <- openFile fileout WriteMode s <- readFile filename let { action l = return (':':l) ; as = map action (observe "input" (lines s)) ; os = repeat (hPutStr h) } mapM id (observe "output" (zipWith (>>=) as os)) main_2 = runO readAndWriteAttrVals_2

1 0