- Haskell-Cafe - Haskell.org

Troubles with FFI
by Matthew Bromberg 19 May '06

19 May '06

I am a newcomer to Haskell and I'm offering my perspective on the troubles I endured trying to make Haskell interface to some simple C programs. It is my hope, that by documenting this, someone else will benefit from my mistakes and errors and climb the learning curve somewhat faster than me. I was attracted to Haskell, after playing around with OCAML, and realizing that functional programming offers some nice advantages to scientific programming. Mainly because the notation and thinking is very mathematical. But first, in order to evaluate the suitability of this language for my purposes, I had to verify that the foreign function interface (FFI) was suitable. There are a number of numerical libraries, all in imperative languages, that I want to link to. I quickly discovered that the documentation on Haskell's FFI is rather poor currently. This topic is simply not of interest to the academics I suppose. It took many hours of searching to find this document: http://www.cs.caltech.edu/courses/cs11/material/haskell/papers/tackling_the… This little tutorial was a goldmine of information about monads and an introduction to the FFI. (No template solutions for my problem sorry to say.) It was certainly dismaying to see that even the simplest IO requires at least a minimal understanding of monads, and adds a bunch of extra semantics to the problem. However none of the solutions offered, even the automated ones, seemed to handle the case of passing numerical arrays to C, and having them get updated and passed back. That is my primary interest in the FFI and yet no obvious solution or example could be found after days of internet searching and pouring over tutorials etc. My conclusion, after hours of studying the hierarchical libraries was that I needed to use the StorableArray type which led me to this site, http://www.haskell.org/haskellwiki/Arrays#StorableArray_.28module_Data.Arra… This site proposes the following curious piece of code: {-# OPTIONS_GHC -fglasgow-exts #-} import Data.Array.Storable import Foreign.Ptr import Foreign.C.Types main = do arr <- newArray (1,10) 37 :: IO (StorableArray Int Int) readArray arr 1 >>= print withStorableArray arr $ \ptr -> memset ptr 0 40 readArray arr 1 >>= print foreign import ccall unsafe "string.h" memset :: Ptr a -> CInt -> CSize -> IO () After having freshly read the tutorial on monads I thought I was ready for this, but I ran into some parsing problems. I don't have a full grasp of the precedence rules for the operators, >>= , $ and function evaluation are, and whether they group left to right or right to left. A little type parsing on the inputs and outputs allowed me to resolve all but the line withStorableArray arr $ \ptr -> memset ptr 0 40 Which should resolve to a monad if I understand the do notation correctly. My first assumption was that $ has lower precedence than function application, but a higher precendence than >> or >>=, so I assumed the grouping, (withStorableArray arr) $ (\ptr -> (memset ptr 0 40)) Now withStorableArray has the type specification StorableArray i e -> (Ptr e -> IO a) -> IO a , so it should be obvious how to use it (Not). At any rate it takes two arguments so I might assume that (withStorableArray arr) curries the first argument so that this expression is a function of type (Ptr e -> IO a) -> IO a . Because of the type of the array, it appears that a = Int. However (\ptr -> (memset ptr 0 40)) should be a function of type Ptr a -> IO(a) in order to qualify as the second argument of withStorableArray. This almost fits, but not quite. memset should return type IO(Int) for this to work correctly, however according to it's type declaration it returns IO (). Shouldn't the compiler complain about this? So after about 10 hours of wrestling with syntax, including messing up the initial capitalization of module names, indenting in do lists, forgetting to put commas in tuples and lists I finally got the following example to compile without error or warning Matrix.hs __________ import Foreign import Foreign.C import Foreign.C.Types (CInt, CDouble ) import Data.Array.Storable foreign import ccall "matrix_c.h sumarr" sumarr :: Ptr CDouble -> CDouble main = do arr <- newListArray (1 , 3) [3,2,1]:: IO (StorableArray Int CDouble) -- extract the pointer to arr dsum <- withStorableArray arr (\ptr -> return (sumarr ptr )) print dsum matrix_c.c ------------------ #include <math.h> double sumarr(double *in) { return(in[0] + in[1]) ; } This is how I compiled it using ghc 6.4.2 > ghc -c matrix_c.o matrix_c.c > ghc -O -o Matrix.exe -fglasgow-exts Matrix.hs matrix_c.o It runs correctly > Matrix > 5.0 Notes: ---------------------------------------------- Matrix.exe fails to work correctly if the header file matrix_c.h is not included in the foreign import statement The hack? where the second argument of withStorableArray is a -> IO() instead of a -> IO(a) allows the do clause to be simplified to main = do arr <- newListArray (1 , 3) [3,2,1]:: IO (StorableArray Int CDouble) withStorableArray arr $ print . sumarr If one changes the array in[] in the C code, e.g. double sumarr(double *in) { in[0] = -10.0 ; return(in[0] + in[1]) ; } The array is changed inside the haskell program as a side effect. main = do arr <- newListArray (1 , 3) [3,2,1]:: IO (StorableArray Int CDouble) -- extract the pointer to arr withStorableArray arr $ print . sumarr (readArray arr 1 ) >>= print I suppose this is one way to 'pass' arrays back to Haskell.

10 19

Space leak when returning pairs?
by Shin-Cheng Mu 19 May '06

19 May '06

Dear members, I am experiencing a space leak, which I suspect to be an instance of the problem addressed by Wadler before. I'd appreciate if someone here would take a look. Given the following datatype: data XMLEvent = StartEvent String | EndEvent String | TextEvent String deriving Show where the three constructors represent the start tag (<a> where a is a string), end tag (</a>), and text data, respectively, of an XML stream. (They are actually from the library HXML). The following function simply returns the same stream while doing a minimal amount of validation (ignoring the closing tag). idX :: [XMLEvent] -> ([XMLEvent], [XMLEvent]) idX [] = ([], []) idX (StartEvent a : strm) = let (ts, strm') = idX strm (us, strm'') = idX strm' in (StartEvent a [] : ts ++ EndEvent a : us, strm'') idX (EndEvent _: strm) = ([], strm) idX (TextEvent s : strm) = let (ts, strm') = idX strm in (TextEvent s : ts, strm') The function idX returns a pair, where the first component is the processed stream, while the second component is the rest of the input. The intention is to thread the input and release processed events. If the function is used in a pipelined manner: print . fst . idX . parseInstance $ input where parseInstance :: String -> [XMLEvent] is a lexical analyser, I would expect that the input stream will be consumed one by one as the output is produced, and the program would use a constant amount of heap space (while keeping a program stack proportional to the depth of the XML tree). This was not the case, however. For some reason the heap grew linearly. The GHC profiler showed that most of the thunks are created by parseInstance, which implies that the entire input stream somehow still resides in memory. I was wondering where the space leak came from and suspected that it's the leak described in one of Philip Wadler's early paper Fixing Some Space Leaks With a Garbage Collector (1987). Consider idX (StartEvent a : strm) = let (ts, strm') = idX strm (us, strm'') = idX strm' in (StartEvent a [] : ts ++ EndEvent a : us, strm'') The body of the let clause might have actually been treated as (StartEvent a [] : ts ++ EndEvent a : fst (idX (snd strm)), snd (idX (snd strm))) Therefore strm will not be freed until the whole evaluation finishes. But since Wadler has addressed this problem a long time ago, I think the fix he proposed should have been implemented in GHC already. Was that really the source of the space leak? If so is there a way to fix it? Or is there another reason for the leak? * * * The function idX above actually resulted from fusing two functions: buildF parses a stream into a forest, while idF flattens the tree. data ETree = Element String [ETree] | Text String buildF :: [XMLEvent] -> ([ETree], [XMLEvent]) buildF [] = ([],[]) buildF (StartEvent a : strm) = let (ts, strm') = buildF strm (us, strm'') = buildF strm' in (Element a ts : us, strm'') buildF (EndEvent _ : strm) = ([], strm) buildF (TextEvent s : strm) = let (ts, strm') = buildF strm in (Text s : ts, strm') idF :: [ETree] -> [XMLEvent] idF [] = [] idF (Element a ts : us) = StartEvent a : idF ts ++ EndEvent a : idF us idF (Text s : ts) = TextEvent s : idF ts My original program was like print . idF . fst . buildF . parseInstance $ input and it had the same space leak. By accident (assuming that the input is always a single tree), I discovered that if I added a "wrap . head" into the pipe: print . idF . wrap . head . fst . buildF . parseInstance $ input where wrap a = [a], the heap residency would reduce by half! The output remains the same. My explanation is that applying a "head" means that (in the definition of buildF): buildF (StartEvent a : strm) = let (ts, strm') = buildF strm (us, strm'') = buildF strm' in (Element a ts : us, strm'') the "us" part , which contains a reference to strm, need not be kept. Thus the reduced heap residency. This seems to support that the space leak resulted from the same problem Wadler addressed before. But isn't that solved already in GHC? * * * I'd appreciate if someone could look into it. The actual program is available at http://www.psdlab.org/~scm/hx.tar.gz It actually uses HXML, a library by Joe (Joe English?) to do the parsing. The main program is hxpc.hs. There is a 1 MB sized sample input file size1m.xml. There are two simple scripts "recompile" and "runhxpc" for compiling and running the program. Thank you! sincerely, Shin-Cheng Mu

4 6

Parsec memory behavior
by Juan Carlos Arevalo Baeza 19 May '06

19 May '06

Try this simple program: import Text.ParserCombinators.Parsec ppAny = tokenPrim show (\p _ _ -> p) (\t -> Just t) ppTest = many ppAny p s = case runParser ppTest True "" s of Left error -> show error Right result -> result main = do let fname = "C:/main.i" f <- readFile fname let tokens = p f putStrLn . show $ head tokens This is the simplest expression of using Parsec, it just returns the input unchanged. But it already seems to have a big memory leak. When parsing a 2 MB file, I'm seeing the program grow in size up to about 160 MB before it ends. I assume this is known behavior. I believe it's because of the way Parsec deals with errors: when you chain two parsers in sequence, the result of the first one (in this case the head of the list) is not available until it knows if the second one failed or not. Is there any known alternative that doesn't exhibit this behavior? It would have to somehow return errors inline or on a "side channel". I'll be toying with this sort of thing for a while. Thanx! JCAB

4 5

shared local definitions
by Alberto Ruiz 19 May '06

19 May '06

Hi all, I have a question about optimization of shared values in local definitions. I frequently use this scheme: fun a b c d x = r where q = costly computation depending only on a, b, c, and d r = depends only on q and x g1 = fun 1 2 3 4 g2 = fun 5 4 2 7 (etc.) When I compute (using ghc -O) things like map g1 [1 .. 1000] the common q is evaluated only once, which is very nice. But the problem is that in some strange cases this kind of optimization is not applied, and the same q is evaluated 1000 times. Curiously, this happens if I add just: module Main where to one of my programs. Optimization is also lost if in the same program I use two partially applied functions: map g1 [1 .. 1000] map g2 [1 .. 1000] And in some cases optimization is only applied if the local definition is "easy" enough. For example: --------------------------------------------------- fun1 :: Int -> Int -> Int fun1 a x = q*x where q = {-# SCC "easy" #-} a+1+a^2 -- OK fun2 :: Int -> Int -> Int fun2 a x = q*x where q = {-# SCC "hard" #-} a+1+a^2 +a^3+(2*a) -- NO fun3 :: Int -> Int -> Int fun3 a x = r where q = local a r = q*x local u = {-# SCC "local easy" #-} u+1 -- OK fun4 :: Int -> Int -> Int fun4 a x = r where q = local a r = q*x local u = {-# SCC "local hard" #-} u+1+u^2 -- NO test h = print $ sum $ map h [1 .. 100] main = do test (fun1 3) test (fun2 3) test (fun3 3) test (fun4 3) -------------------------------------------------- COST CENTRE MODULE no. entries MAIN MAIN 1 0 main Main 154 101 fun4 Main 166 300 local hard Main 167 100 NO fun3 Main 163 100 fun2 Main 161 100 hard Main 162 100 NO fun1 Main 157 100 test Main 155 4 CAF Main 148 6 fun4 Main 168 0 main Main 158 0 fun3 Main 164 1 local easy Main 165 1 OK fun1 Main 159 0 easy Main 160 1 OK test Main 156 0 CAF System.IO 103 1 CAF GHC.Handle 101 3 ------------------------------------------------------------ Where can I find information about this topic? I have made some searches but probably using wrong keywords. Should I use some individual optimization flags? Thanks, Alberto

4 3

Controlling scope using monadic classes
by oleg＠pobox.com 18 May '06

18 May '06

Daniel McAllansmith wrote: > I'm trying to control the scope within which functions can be used by > putting them in a type class. Unfortunately I can't seem to figure > out how to get it done. Any advice would be much appreciated. Hopefully the following is close to what you wanted. The idea is to describe each appropriate function (like getInfo) with a label and to identify each monadic scope with a label, and then define the relationship which tells which labeled functions can be used within which scopes. If we attempt to obtain InfoC within the scope B, we get an error ``no instance (LabelOK ScopeC ScopeB)'' -- which seems clear. The more elaborate version of similar example can be found here: http://pobox.com/~oleg/ftp/Haskell/types.html#monadic-regions Using labels to enforce well-formedness term constraints (content model constraints for HTML/XML terms) can be found here: http://www.haskell.org/pipermail/haskell/2006-March/017656.html http://www.haskell.org/pipermail/haskell/2006-March/017684.html {-# OPTIONS -fglasgow-exts #-} module Scopes where import Control.Monad.Trans -- Our scopes newtype ScopeA m a = ScopeA{runScopeA :: m a} deriving (Monad, MonadIO) newtype ScopeB m a = ScopeB{runScopeB :: m a} deriving (Monad, MonadIO) newtype ScopeC m a = ScopeC{runScopeC :: m a} deriving (Monad, MonadIO) runScopeBA (ScopeB x) = ScopeA x runScopeCB (ScopeC x) = ScopeB x -- The deriving Show part is just to make the example better instance Show (ScopeA m a) where show _ = "ScopeA" instance Show (ScopeB m a) where show _ = "ScopeB" instance Show (ScopeC m a) where show _ = "ScopeC" -- Here we define the relationship that tells which labeled functions -- (identified by label') can appear within which scope (identified by label) class LabelOK (label' :: ( * -> * ) -> * -> * ) (label :: ( * -> * ) -> * -> * ) -- If we use overlapping isntances extension, the number of instances -- below can be significantly reduced. instance LabelOK ScopeA ScopeA instance LabelOK ScopeA ScopeB instance LabelOK ScopeA ScopeC instance LabelOK ScopeB ScopeB instance LabelOK ScopeB ScopeC instance LabelOK ScopeC ScopeC -- The function getInfo is labeled. The constraint LabelOK tells -- the the function can be used within any (monadic) scope where -- it is OK... getInfo :: (Monad m, Monad (label m), Show (label' [] ()), LabelOK label' label) => label' [] () -> label m String getInfo l = return (show l) -- The latter functions are to be defined analogously -- putInfo :: LabelOK label' label => label' -> String -> m () -- updateInfo :: UpdateOK label' label => label' -> Int -> m () main = runScopeA aScoped >>= print aScoped = do bResult <- runScopeBA bScoped -- updateAInfo bResult return "done" -- Inferred type: bScoped :: ScopeB IO Int bScoped = do i1 <- b1 i2 <- b2 return (i1 + i2) b1 :: (Monad m, MonadIO m) => ScopeB m Int b1 = do -- Within B scope, we can request AInfo and BInfo getInfo (ScopeA [()]) >>= liftIO . print getInfo (ScopeB [()]) >>= liftIO . print -- But we can't request CInfo -- If we uncomment the following, we get -- no instance (LabelOK ScopeC ScopeB) -- I think the error message is quite clear -- getInfo (ScopeC [()]) >>= liftIO . print return 2 b2 :: (Monad m, MonadIO m) => ScopeB m Int b2 = runScopeCB cScoped >>= return . fromEnum cScoped :: (Monad m, MonadIO m) => ScopeC m Char cScoped = do -- Within C scope, we can request AInfo and BInfo and CInfo getInfo (ScopeA [()]) >>= liftIO . print getInfo (ScopeB [()]) >>= liftIO . print getInfo (ScopeC [()]) >>= liftIO . print return '('

2 1

Haskell DB and XML libs: one user's experience
by Robert Dockins 18 May '06

18 May '06

Hello all, I recently found myself needing to do some data manipulation; I needed to take some data from a database and generate a series of XML files from it. In the past I've done most of this sort of work in Java, but this time I decided I'd take the opportunity to explore the state of the art of Haskell DB and XML libraries. As to DB, I tried using HDBC first. I was actually a little surprised how straightforward it was. My database (PostgreSQL) is directly supported, and the compile/install went smoothly. My first test connection program that typechecked worked as expected (!) and I was soon executing queries doing useful work with the results. I'd just like to take a moment to congratulate John Goerzen for creating a product with a low barrier of entry for using databases in Haskell. As I didn't really do anything beyond simple queries, can't comment on more advanced features. For XML, I wavered between HaXml and HXT (the Haskell XML Tookbox). I initially decided to use HXT because it has support for xml namespaces, which I was going to need, and because it just seems to be the most complete and advanced package available. The HXT install suffers a little bit from transitive-closureitis, but, overall wasn't too bad. However, I had a really hard time using it! The API is _really_ intimidating, and I couldn't find any basic tutorial-style documentation. The API docs are a little hard to use because related definitions are spread out over a bunch of modules, and the links don't always work. Also, the theses are nice, but they read like theses ;-) That's not what I want when I have a job to complete. Long story made short; I couldn't figure out how to create and XML document and serialize it to disk. I was reasonably motivated and I'm a pretty experienced Haskell programmer, but I had to call it quits after about 3 hours of struggling with it. Most of my programs would mysteriously fail to produce output OR errors! It was really frustrating. I ended up using HaXml instead and shoehorning in the namespaces by using attributes named "xmlns:xyz" etc. on the document root element (which is OK, but not ideal). The HaXml API was also tough to work with but was less mystifying than HXT's, and I eventually got it to work. I was a little disappointed by the results, because the pretty printer does some fairly bizarre things to ensure that it doesn't introduce extra whitespace into the DOM. I also had to do some futzing to make HaXml correctly escape literal text. Finally, the using the HaXml API to generate XML results in verbose code that's hard to read. I was hoping that I'd get results comparable to using xmlenc (http://xmlenc.sourceforge.net/) in Java, but I was disappointed by fairly low signal-to-noise ratio (although in all fairness, its probably comparable to using the DOM or SAX Java APIs). Overall, HaXml works, but feels a bit awkward, at least for this use case. Now taking a slightly closer look at HXML, I see that it may be the best choice for what I was attempting to do (although it also doesn't support namespaces). The simplified representation looks particularly nice for building XML from scratch. I may try rewriting with HXML and see how that goes. So that's it. I don't have any deep conclusions, but I thought I'd share my experiences in the hopes that they will be helpful to somebody. Rob Dockins Speak softly and drive a Sherman tank. Laugh hard; it's a long way to the bank. -- TMBG

2 1

RE: [Haskell-cafe] develop new Haskell shell?
by Bayley, Alistair 17 May '06

17 May '06

> From: haskell-cafe-bounces(a)haskell.org > [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of Graham Klyne > > Did you see [http://nellardo.com/lang/haskell/hash/] ? > > Google also finds some links to code. > > #g > -- > > Marc Weber wrote: > > Hi. > > > > Who wants to try devloping a new shell with me? Also: http://www.cse.unsw.edu.au/~dons/h4sh.html ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

14 24

Controlling scope using monadic classes
by Daniel McAllansmith 17 May '06

17 May '06

Hi. I'm trying to control the scope within which functions can be used by putting them in a type class. Unfortunately I can't seem to figure out how to get it done. Any advice would be much appreciated. What I want is to start out in a certain scope, which restricts me to using functions in that scope or opening up a subsidiary scope at which point I'm restricted to functions in that scope or opening up an even deeper scope. Hopefully a failed attempt will help explain what I'm trying to achieve... the following has trouble with the inScope{B,C} functions. type AInfo = String type BInfo = String type CInfo = String type BResult = Int type CResult = Char class (Monad m) => WithinA m where askAInfo :: m AInfo class (WithinA m) => WithinB m where askBInfo :: m BInfo class (WithinB m) => WithinC m where askCInfo :: m CInfo class (WithinA m) => ScopeA m where getAInfo :: m AInfo putAInfo :: AInfo -> m () updateAInfo :: BResult -> m () inScopeB :: (ScopeB m2) => m2 BResult -> m BResult class (WithinB m) => ScopeB m where getBInfo :: m BInfo putBInfo :: BInfo -> m () inScopeC :: (ScopeC m2) => m2 CResult -> m CResult class (WithinC m) => ScopeC m where getCInfo :: m CInfo putCInfo :: CInfo -> m () aScoped :: (ScopeA m) => m String aScoped = do bResult <- inScopeB bScoped updateAInfo bResult return "done" bScoped :: (ScopeB m) => m BResult bScoped = do i1 <- b1 i2 <- b2 return (i1 + i2) b1 :: (ScopeB m) => m Int b1 = return 2 b2 :: (ScopeB m) => m Int b2 = inScopeC cScoped >>= return . fromEnum cScoped :: (ScopeC m) => m Char cScoped = return '(' Thanks Daniel

1 0

transactional cache
by Alberto G. Corona 16 May '06

16 May '06

Finally i did it. The transactional cache uses STM, no blocking MVars. I created has a simple interface, the transactional "plumbing" is hidden in the TransactCacheSTM module. The usage is simple: withResources [object1, object2,..] process where process[maybeObject1,maybeObject2.....]= [newObject1,newObect2...] newObject1=..... newObject2=.... "process" run atomically, object1,object2.. are partially defined, just with the fields neccesary to retrieve them. newObjects are the resulting objects that replace the previous content in the cache. Non existing objects are created. the objects must implement "IResource" type class procedures for reading, writing and obtaining a unique key so that the objects can be read to, write from and do search from the cache. No other asumptions are made about the object types or storages. In the following example, client Alberto buy a computer. the total amount due by Alberto is increased with the computer price. The quantity of the item "computer" in stock is decreased. withResources[Client{name="Alberto"}, Item{iname="computer"} buy where buy[Nothing,_]= error "Client does not exist" buy[_,Nothing]= error "Item does not exist" buy[Just client, Just item]= [client{total client=total client+ price item}, item{quantity=quantity-1}] The resulting code is transactional and clean. The object is read if not already in the cache using the user defined procedure for that object (either a sql query or read from a file). The write is delayed depending on object usage in the cache and the cache size. I also defined ordinary, non transactional object retrieval (getResources :: [Resource]->IO[Resource] ) To have real ACID transactions, I also defined a procedure for atomic write of the entire cache to disk, in order to have coherent content in permanent storage, (I´m using it on a portal 100% coded in Haskell (I love Haskell since i knew it five months ago). this trhansactional cache makes the data handling in my portal a lot easier. I use XML files, no boring database tables are necessary. I will put online the transactional cache sometime later, but by now I will send te code by mail to anyone interested. Message: 8 Date: Sat, 13 May 2006 12:26:42 +0900 From: "Evan Martin" <martine(a)danga.com> Subject: Re: [Haskell-cafe] RE: transactional cache To: "Alberto G. Corona" <agocorona(a)gmail.com> Cc: haskell-cafe(a)haskell.org Message-ID: <3a6f89fc0605122026y6727d55cl61e60a101c73e93e(a)mail.gmail.com> Content-Type: text/plain; charset=ISO-8859-1; format=flowed On 5/13/06, Alberto G. Corona <agocorona(a)gmail.com> wrote: > > notglobal = newIORef True > > main = do a <- notglobal > > b <- notglobal > > Thanks. I got the poit more or less; Each invocation creates a new > IORef instance. Another way of looking at this, that might be more instructive, is that notglobal is defined to be the action of creating a new IO ref. You can see that in its type: > :t newIORef True newIORef True :: IO (IORef Bool) I read that type as "an IO operation that produces an IORef Bool when executed". Then the code in main "executes" notglobal twice. Another way of looking at this is that you can always substitute the right side of an equals sign in for the left side. If you do that on this code this makes it plain that a and b will be different. (unsafePerformIO breaks this substitution rule.)

1 0

Newbie:Debugging and Overgeneralization
by Aditya Siram 15 May '06

15 May '06

I have been working with a Haskell text for the past couple of months or so and I have some general problem solving questions. 1. Is there a way to output intermediate values of a calculation? As an imperative programmer I have become used to using "System.out"'s or 'cout's to check that my function works as intended. I can see no easy way to do that in Haskell. The only solution I could come up with was to avoid using nested functions except for the most trivial expressions and test all expressions in the interpreter. This approach seems to make my code ugly and less readable. 2. Haskell is great because it makes abstracting from problem very easy. For example, if the problem asks for the area of a square, why not write a function to compute the area of all polygons? find myself falling into the trap of generalizing to the point that a simple problem becomes quite a bit harder . From a general design perspective should I concentrate on abstracting away just enough to solve the problem or solve the harder problem in the hoping of reusing that code to make life easier in the future? Thanks.... Deech

3 2