- Haskell - Haskell.org

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

Too Strict?
by Steinitz, Dominic J 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? By the way, the MD5 function which I use and is included as part of HSLIBS has the type String -> IO String. The MD5 algorithm really is a function and should have type String -> String. Do people agree and if so how do I get it changed? Dominic. -- Compile with ghc -o test test.hs -static -package util -- under Windows. module Main(main) where import IO(openFile, hPutStr, IOMode(ReadMode,WriteMode,AppendMode)) import MD5 import Char -- showHex and showHex' convert the hashed values to -- human-readable hexadecimal strings. showHex :: Integer -> String showHex = map hexDigit . map (fromInteger . (\x -> mod x 16)) . takeWhile (/=0) . iterate (\x -> div x 16) . toInteger hexDigit x | (0 <= x) && (x <= 9) = chr(ord '0' + x) | (10 <= x) && (x <=16) = chr(ord 'a' + (x-10)) | otherwise = error "Outside hexadecimal range" powersOf256 = 1 : map (*256) powersOf256 showHex' x = showHex $ sum (zipWith (*) (map ((\x -> (mod x 16)*16 + (div x 16)) . toInteger . ord) x) powersOf256) -- The type Anon and function anonymize hide the anonymisation -- process. In this case, it's a hash function -- digest :: String -> IO String which implements MD5. type Anon a = IO a class Anonymizable a where anonymize :: a -> Anon a -- MyString avoids overlapping instances of Strings -- with the [Char] data MyString = MyString String deriving Show instance Anonymizable MyString where anonymize (MyString x) = do s <- digest x return ((MyString . showHex') s) instance Anonymizable a => Anonymizable [a] where anonymize xs = mapM anonymize xs filename = "ldif1.txt" fileout = "ldif.out" readAndWriteAttrVals = do h <- openFile fileout WriteMode s <- readFile filename a <- anonymize((map MyString) (lines s)) hPutStr h (unlines (map (\(MyString x) -> x) a)) main = readAndWriteAttrVals ------------------------------------------------------------------------------------------------- 21st century air travel http://www.britishairways.com

1 0

Are fundeps the right model at all?
by qrczak＠knm.org.pl 14 Jan '01

14 Jan '01

Could somebody show an example which requires fundeps and cannot be expressed using a simpler model explained below - a model that I can even understand? Is the model self-consistent at all? Each class is associated with a set of subsets of type variables in its head. Let's call it the set of keys. The intuitive meaning of a key is that types corresponding to these variables are sufficient to determine which instance to choose. They correspond to lhss of some fundeps. Plain classes without explicitly written keys correspond to having a single key consisting of all type variables. Keys influence the typechecking thus: - A type is unambiguous if for every class constraint in it there exists its key such that types in the constraint corresponding to type variables from the key contain no type variables which are absent in the type itself. - All class methods must have unambiguous types, i.e. for each method there must be a key whose all type variables are present in the method's type. - For each key, there must be no pair of instances whose heads projected to the class parameters from the key overlap. - For each class constraint of an unambiguous type an each its key there must be an instance found basing on this key, or the type is incorrect because of missing instances. Moreover, instances found basing on all keys must be identical. - Perhaps something must be said about class contexts and instance contexts. I'm not sure what yet. Examples: class Collection c e | c where empty :: c insert :: c -> e -> c class Monad m => MonadState s m | m where get :: m s put :: s -> m () newtype State s a = State {runState :: s -> (a,s)} instance Monad (State s) instance MonadState s (State s) test1:: Int -> Int test1 x = snd (runState get x) -- Not ambiguous. class IOvsST io st | io, st where -- Two single-element keys. ioToST :: io -> st stToIO :: st -> io instance IOvsST (IORef a) (STRef s a) where ioToST = unsafeCoerce# stToIO = unsafeCoerce# test2:: IORef a -> IORef a test2 = ioToST . stToIO -- Not ambiguous. class Foo a b | a instance Foo Int [a] -- This is rejected by Hugs (with fundep a->b) but I would definitely -- accept it. -- __("< Marcin Kowalczyk * qrczak(a)knm.org.pl http://qrczak.ids.net.pl/ \__/ ^^ SYGNATURA ZASTÊPCZA QRCZAK

8 14

{-# LINE 100 "Foo.hs #-} vs. # 100 "Foo.hs"
by qrczak＠knm.org.pl 13 Jan '01

13 Jan '01

What should be the preferred way of marking correspondence to source positions after some preprocessing? Here is what is currently supported: | {-# LINE 100 "Foo.hs #-} | # 100 "Foo.hs" ------------------------+------------------------------+---------------- Released ghc, no -cpp | understand | error Released ghc, with -cpp | understand | understand Developed ghc | understand | understand hbc | understand (ignore filename) | understand (warning) Hugs | ignore | error Released nhc98 | error | understand Developed nhc98 | ignore | understand I would choose LINE pragma. In this case nhc98 should be taught about it. -- __("< Marcin Kowalczyk * qrczak(a)knm.org.pl http://qrczak.ids.net.pl/ \__/ ^^ SYGNATURA ZASTÊPCZA QRCZAK

1 0

IEEE Conference Software Maint. Italy,Florence, ICSM2001
by icsm2001 13 Jan '01

13 Jan '01

Dear Colleague I would like to invite you to propose papers, experiences, tutorials, tool expositions, dissertations at the IEEE International Conference on Software Maintenance, 2001, and workshops: SCAM, WESS, WSE and TABOO, etc., November 2001, Florence, Italy. ICSM is the major international conference in the field of software and systems maintenance, evolution, management, software metrics and quality, etc. Outstanding Keynotes such as: >->->Prof. David Lorge Parnas, Prof. Dieter Rombach, Prof. Ivar Jacobson<-<-<- Awards, workshops, panels, and other exciting activities have been planned. Please note in the following the new deadline that has been moved to satisfy the several requests recevied, next deadline >->->->-29 January 2001<-<-<-<-<-<- Please forward this remind to anybody who you think may be interested. Apologies if you have already seen this. If you would like to be removed from our list please send an email to icsm2001(a)dsi.unifi.it with REMOVE in the subject. ICSM2001 Paolo Nesi (General Chair) _=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_= >->->CALL---FOR---PAPERs<-<-< IEEE International Conference on Software Maintenance 2001 FLORENCE, ITALY, 6-10 November 2001 http://www.dsi.unifi.it/icsm2001 Theme: Systems and Software Evolution in the era of the Internet IMPORTANT DATES, DEADLINES Research Paper submission 29 January 2001 Dissertation submission 29 January 2001 Industrial Application submission 12 March 2001 Tools request and submission 12 March 2001 Tutorial submission 12 February 2001 _=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=_=

1 0