- Haskell-Cafe - Haskell.org

Modifying Running Programs
by S. Alexander Jacobson 02 Aug '04

02 Aug '04

eBay modifies 30k lines of code per week while maintaining 99.92% uptime. Is there a way to force ghc (or some other Haskell implementation) to load new implementations of functions without restarting the program? Alternatively, is there a way of restarting a program with new code without having to reconstruct all its in memory state? -Alex- ______________________________________________________________ S. Alexander Jacobson tel:917-770-6565 http://alexjacobson.com

2 1

Re: [Haskell-cafe] Modifying Running Programs
by MR K P SCHUPKE 01 Aug '04

01 Aug '04

>Is there a way to force ghc (or some other Haskell >implementation) to load new implementations of >functions without restarting the program? Yes, if you use the dynamic loading interface fron ghci. Code can be loaded and unloaded at runtime (however I believe the actual memory is never recovered) Keean.

1 0

Multiprocessor compiling.
by Matthew Roberts 01 Aug '04

01 Aug '04

It seems there is quite some interest in compiling code for multi-processor machines. As a research student, I am always looking for interesting projects to do. However, I am no haskell guru and have certainly never written a compiler. All the comments so far have been very interesting, but too many go over my head and I am not gettting a coherent view of what is going on. Let me try to tie this up. The basic computational model of functional languages seems inherantly parallilisable, but there are clearly many problems - and I don't really understand them. I just picked up the book on implementing the back end of a Haskell compiler and so I will eventually get there. For the meantime, and for all the others out there in my situation, could someone who knows tell us the fundamental reason it is hard to compile Haskell for multiple processor machines - in broad strokes. Cheers, Matt

3 2

Hello and help request
by enrico.santoemma＠tin.it 01 Aug '04

01 Aug '04

Hello to everyone :) My name is Enrico, 40, and I write software for the industry at Beta 80 Group. After this short introduction, here is the help request: I'm managing the rewrite of an application, to port it to the 'classic' Java three-tiers architecture. Before I begin to feed the team, I want to see a fully functional prototype of the problem. I mean the app's functions, not the graphic. What I imagine is a data base of types and groups of functions. The idea is to study the problem, inject new functions while checking their coerence with the existing type infrastructure, and so on. In plain Java, I'd have wrote the Business Idea in informal language, extracted the types from it, assigned methods to types and then glued things together in some way. In Haskell I (should) have the opportunity to stay on the problem, decomposing it into sub-problems until I come to the soil. What I ask to this list is if and where Haskell is different from the object oriented way to decompose the problem. I'm very fresh on Haskell. Exactly... chapter 13 of SOE :) Are type classes different from Java classes? I think so, but I guess this means that one should ask different things to type classes, respect to what is being asked to Java classes. It is this difference that's unclear to me. Any help would be very appreciated Enrico

5 5

Re: [Haskell-cafe] Multiprocessor compiling.
by MR K P SCHUPKE 01 Aug '04

01 Aug '04

>want to fork 3 threads to compute "a*b + c*d" of course this depends on what a b c and d are ... if they are 1000x1000 matricies then you may well want the '*' operations in separate threads... Keean.

1 0

Re: [Haskell-cafe] Re: humor
by Jon Cast 30 Jul '04

30 Jul '04

Sean Perry <sean.perry(a)intransa.com> wrote: > Gabriel Ebner wrote: > > enrico.santoemma(a)tin.it writes: > > > > > >>Well... more seriously, does someone have got links to applications with > >>visible source? > > > > > > The only one I know is darcs: http://abridgegame.org/darcs > > > > which is actually quite readable, even for a newbie. He does like the > '$' operator a bit much for my tastes though. Obviously you haven't realized the great beauty of $. You cannot like $ to much. foldr should be defined as follows: foldr f z [] = id $ z foldr f z (x:xn) = (f $ x) $ foldr f z xn etc. :) Jon Cast

2 1

humor
by enrico.santoemma＠tin.it 30 Jul '04

30 Jul '04

When I met Java some time ago, I said to myself: "Java is a great language to write IDEs for the Java language". Now that I'm looking for Haskell source code (perhpas that there is another way to learn a language than to spy on others?), I'm tempted to say: "Haskell is a great language to write libraries for the Haskell language" Well... more seriously, does someone have got links to applications with visible source? Enrico Santoemma

6 5

DiscreteMap
by Henning Thielemann 30 Jul '04

30 Jul '04

In addition to the former discussion: http://www.haskell.org/pipermail/haskell/2002-October/010629.html Has someone thought about a type class that provides a uniform interface to Array and FiniteMap? The difference to a general Function class is that a DiscreteMap could return its domain, that is the list of all of its keys/indices/arguments.

1 0

lhaskell.vim syntax highlighting script
by Andrew Pimlott 30 Jul '04

30 Jul '04

haskell-cafe, you are listed as the maintainer of the vim haskell syntax highlighting script. :-) lhaskell.vim uses the tex.vim syntax script, which does "set iskeyword-=_". This makes editing haskell rather uncomfortable (eg, the '*' command doesn't work right). I don't know what breaks if you "set iskeyword+=_", but getting tex highlighting right is less important than haskell editing, so I suggest this patch. Andrew --- lhaskell.vim.orig 2004-07-29 16:48:39.000000000 -0700 +++ lhaskell.vim 2004-07-29 16:50:16.000000000 -0700 @@ -86,6 +86,8 @@ runtime! syntax/tex.vim unlet b:current_syntax endif + " This messes up tex a bit, but is better for Haskell. + set isk+=_ endif " Literate Haskell is Haskell in between text, so at least read Haskell

1 0

Re: [Haskell-cafe] optimising for vector units
by MR K P SCHUPKE 29 Jul '04

29 Jul '04

Well I have to say the dataflow style of lazy programming made me think Haskell would be ideal for multi-processor use (and now HyperThreading is common most PCs have more than one processor from the code's point of view)... I was disappointed to find GHC only uses one thread, and therefore will only use one CPU. Vectorisation is much more limited than hyperthreading - as the instructions on each vector unit must be the same... The easiest implementation would be to add primitive vector types that map directly to the underlying SIMD operations. This is probably a good starting point - it would be nice to vectorise normal expressions, but that requires an optimisation search to find instructions that can be grouped together ... this becomes a lot easier if the primitives are supported as you just need to transform the code rather than dealing with non-portable assembly instructions. The problem is that different platforms support different SIMD style instructions... What would be really needed is a IEEE/ISO standard for vector instructions much like the current one for floating point. In the absence of such a standard, the best that can be done is to abstract vectorisation by word size and number of words, and supply a software implementation of all vector ops to use if the hardware does not support certain primitives. A futher point is that for the compiler to know the vector size, you would have to resort to type level naturals... something like: data Nil data Suc x = Suc x type Four = Suc (Suc (Suc (Suc Nil))) myFn :: Vector Four Word16 Of course this would need to be integrated with the compiler. As an interim measure a C-library providing primitive operations on vectors could be written and used via the FFI. Keean.

5 8

Re: [Haskell-cafe] why is Prelude.^ so convoluted?
by blaetterrascheln＠web.de 29 Jul '04

29 Jul '04

> x ^ n = if even n then y*y else y*y*x where y = x ^ (n `quot` 2) x ^ n | n>0 = if even n then y*y else y*y*x where y = x ^ (n `quot` 2) ________________________________________________________________ Verschicken Sie romantische, coole und witzige Bilder per SMS! Jetzt neu bei WEB.DE FreeMail: http://freemail.web.de/?mc=021193

3 2

Typeclass problem
by Mark T.B. Carroll 29 Jul '04

29 Jul '04

I have a little programme that doesn't compile: module Example where class (Show c, Ord c, Bounded c) => MyClass c showThings :: MyClass c => c -> (String, String) showThings x = let foo = maxBound :: c in (show x, show foo) If I change that second-to-last line to, let foo = max x maxBound then it compiles. However, it's clearly silly to use "max" just to make the type of the maxBound be the same type as the x. (I'm assuming that the Ord and the Bounded instances of the type are sensibly consistent.) What should I be writing if I want foo to be the maxBound applied to the type that x is? -- Mark

2 2

why is Prelude.^ so convoluted?
by blaetterrascheln＠web.de 29 Jul '04

29 Jul '04

{- (^) :: (Num a, Integral b) => a -> b -> a x ^ 0 = 1 x ^ n | n > 0 = f x (n-1) x where f _ 0 y = y f x n y = g x n where g x n | even n = g (x*x) (n`quot`2) | otherwise = f x (n-1) (x*y) _ ^ _ = error "Prelude.^: negative exponent" -} -- Is (^) :: (Num a, Integral b) => a -> b -> a x ^ 0 = 1 x ^ n = if even n then y*y else y*y*x where y = x ^ (n `quot` 2) _ ^ _ = error "negative exponent" -- not good enough? ________________________________________________________________ Verschicken Sie romantische, coole und witzige Bilder per SMS! Jetzt neu bei WEB.DE FreeMail: http://freemail.web.de/?mc=021193

1 0

not getting most general type - is this a bug in hugs?
by blaetterrascheln＠web.de 29 Jul '04

29 Jul '04

$ cat x.hs rep0 :: Num a => [a] rep0 = repeat 0 rep0' = repeat 0 $ hugs x.hs ... Main> :t rep0 rep0 :: Num a => [a] Main> :t repeat 0 repeat 0 :: Num a => [a] Main> :t rep0' rep0' :: [Integer] -- WHAT?? Main> :version -- Hugs Version Nov 2002 ________________________________________________________________ Verschicken Sie romantische, coole und witzige Bilder per SMS! Jetzt neu bei WEB.DE FreeMail: http://freemail.web.de/?mc=021193

2 1

What versions do I need to compile the fptools?
by Ron de Bruijn 29 Jul '04

29 Jul '04

I want to compile all of the fptools. This is what I did: I got all files via CVS. And I did autoreconf ./configure make But with the make step gcc crashes with an internal error on Syntax.hi. I already filled in a bug report (not the most clear of them). I especially installed an "old" version of gcc (3.3.3)(I had gcc 3.4.1-2) to be able to compile the C Macro's correctly. For the Haskell compilation I used ghc-6.2.1. I think there is somewhere somebody that can compile it, but I need the *exact* versions of the software needed to do it. Is there anyone that *can* compile all of the fptools successfully? Regards, Ron __________________________________ Do you Yahoo!? New and Improved Yahoo! Mail - Send 10MB messages! http://promotions.yahoo.com/new_mail

1 0

Re: [Haskell-cafe] optimising for vector units
by MR K P SCHUPKE 28 Jul '04

28 Jul '04

Erm, when I said no overhead I meant there is no overhead to choosing an instruction from a different thread compared to choosing an instruction from the same thread... Obviously the overall scheduling overhead will increase. >The real killer, of course, is memory latency. The cache resources >required to hold pending work can't be used to hold heap data I would have thought cache thrashing caused by two CPUs accessing the same address repeatedly would be the real killer... Of course this is not so much of a problem with hyper-threading where both 'virtual' CPUs access the same cache. >* All your functions must be strict in their arguments, I don't see that I am making that assumption. Obviously parts of the program that are in the IO monad are strict, so we start with the demand for a value required strictly by an IO function. This value will be the result of a function, so we take the graph representing the function, and carry on as suggested. This is definitely lazy as parameters not affecting the result will never be evaluated. I appreciate there are some unanswered hard questions, but most of these are to do with efficiency - not whether it is possible... Having an inefiicient implementation now rather than nothing might just be what is needed to get people looking at the efficiency issues. Thanks for the references by the way - although I am quite familiar with the Monsoon architecture - and the Pentium architecture (which since PPro has been internaly dataflow... SuperScalar is really a dataflow computer emulating a traditional processor, and interpreting its instructions) Keean./

1 0

Re: [Haskell-cafe] optimising for vector units
by MR K P SCHUPKE 28 Jul '04

28 Jul '04

>That was me. I think you're underestimating the cost of starting >threads even in this very lightweight world. Maybe... Perhaps haskell could be made to resemble dataflow instructions more... If when a computation completes we insert the result directly into the data structure which represents function, we can infact pick any function for execution with _no_ overhead. (In a true dataflow system any instruction from any thread can be executed with no overhead) The point it at any time we have N functions ready for execution (a function is ready for execution when all its arguments are ready)... we can pick and execute any (or all of these if enough execution units are ready) of these. The suggestion I guess is to only use instructions that get their arguments from main memory. This way any instruction can be sequenced with no overhead on any CPU. With modern on-die core-speed caches this can be almost as fast a registers (with good cache access patterns) ... Note that I am only suggesting interleaving instructions at the function level, so registers can be used within functions... of course as things get more and more parallel we may see hardware with no registers, just pipelined high speed cache access. (The hardware may well use registers to pre-fetch cache values, but that can be made transparent to the software)... Hardware manufacturers have hit the limit for pure sequential execution speed, so more parallelism is the only way forward (see Intels revised roadmap, they abandoned the pentium 4 and 5 and have focused on an updated _low_power_ pentium 3M, and are planning multi core versions for more speed). C and other imperitive languages focus toom much on the how and not the what to be easy to use in such multi-cpu environments... A language with abstracts and hides the parallelism could well take off in a big way. Keean.

2 1

Another STG optimization
by 7253146＠informatica.alumnos.uma.es 27 Jul '04

27 Jul '04

Hi. Thanks for the very useful replies to my recent question! I am still exploring some updating techniques for my pet STG machine. This time I am turning over an idea about closures returning primitive (unboxed) values. These ones, regardless other updating considerations, obviously cannot be updated directly, because the results are not closures. However, I think we could use a special closure for updating in these cases, with a single field holding the primitive result, which, when entered, should simply return its stored primitive value. operationals of my trick: -"someclosure", a zero-arg-closure which eventually returns a primitive value, is entered. -Before starting its evaluation, an update frame is pushed on the stack. -eventually, evaluation is done and a primitive value is returned. -a continuation is popped from the stack and entered, which turns to be actually the previously pushed update frame. -the update frame overwrites the closure to be updated with the a special closure, which holds the result value and, when entered, returns it. I think the same effects can be achieved using boxed values wherever commoning up the evaluation is required, but I think it may be slower (and it may use more heap space). And, of course, this trick only makes sense if the compiler front-end builds lots of zero-arg-closures which returns primitive values as result of large computations involving not many boxed values (which could capture, when updated, many intermediate steps of the computation). does someone knows if some similar trick has been implemented? (I have tried to read the GHC RTS (and some others), but it is too hard to understand!). Perhaps this trick is not useful? Or not possible due to some reason? Thanks in advance, Jose David --------------------------------------------- Este mensaje lo ha enviado un Alumno de la Universidad de Malaga. http://www.alumnos.uma.es/

1 0

Another STG optimization
by 7253146＠informatica.alumnos.uma.es 27 Jul '04

27 Jul '04

Hi. Thanks for the very useful replies to my recent question! I am still exploring some updating techniques for my pet STG machine. This time I am turning over an idea about closures returning primitive (unboxed) values. These ones, regardless other updating considerations, obviously cannot be updated directly, because the results are not closures. However, I think we could use a special closure for updating in these cases, with a single field holding the primitive result, which, when entered, should simply return its stored primitive value. operationals of my trick: -"someclosure", a zero-arg-closure which eventually returns a primitive value, is entered. -Before starting its evaluation, an update frame is pushed on the stack. -eventually, evaluation is done and a primitive value is returned. -a continuation is popped from the stack and entered, which turns to be actually the previously pushed update frame. -the update frame overwrites the closure to be updated with the a special closure, which holds the result value and, when entered, returns it. I think the same effects can be achieved using boxed values wherever commoning up the evaluation is required, but I think it may be slower (and it may use more heap space). And, of course, this trick only makes sense if the compiler front-end builds lots of zero-arg-closures which returns primitive values as result of large computations involving not many boxed values (which could capture, when updated, many intermediate steps of the computation). does someone knows if some similar trick has been implemented? (I have tried to read the GHC RTS (and some others), but it is too hard to understand!). Perhaps this trick is not useful? Or not possible due to some reason? Thanks in advance, Jose David --------------------------------------------- Este mensaje lo ha enviado un Alumno de la Universidad de Malaga. http://www.alumnos.uma.es/

1 0

Existential type within a record ... bad?
by Scott West 27 Jul '04

27 Jul '04

Hello all, Just got an interesting error, which I can't really understand (but that DOES happen a lot...). Trying to work with existention types, record types, and wrapping the whole thing up in a nice IORef for my uses: data ETable = forall a. EditableTable a => ETable a data GuiRecord = GuiRecord {gtable :: ETable, moz :: MozEmbed, pos :: Position, ent :: Entry} type GuiState = IORef (GuiRecord) Generates the following error: Couldn't match `* -> Type bx' against `*' In the type synonym declaration for `GuiState' Anyone have any ideas?? Thanks in advance! Regards, Scott

1 0

Re: [Haskell-cafe] optimising for vector units
by Jon Cast 27 Jul '04

27 Jul '04

MR K P SCHUPKE <k.schupke(a)imperial.ac.uk> wrote: > As far as I understand it haskells lazy evaluation resembles dataflow > computation - IE values are computed on demand. > > This problem has already been solved for hardware, you end up with > what is termed a super-scalar architecture. > > Instructions read from memory fill a re-order buffer. As computations > complete value slots in the reorder buffer are filled with the result > values. When an instruction has all its values it can be executed, and > will be assigned to the next available execution unit. > > I am not too sure of the internal architecture of GHC, but I can > imagine that funtions waiting to be run will have slots for arguments, > that will be filled in when values become available. No. A function may not use all of its arguments, so there's no point in evaluating all arguments---you have to find out which ones are actually needed. Terminology note: GHC uses the STG language internally. In STG, evaluation is always triggered by a case expression, which evaluates precisely one expression (not necessarily an argument of anything, either!). > The whole point is that a function with three parameters can spark > three threads This is actually a bad idea: the point of non-strict languages and lazy evaluation is to allow lots of values which are (a) unused and (b) expensive to evaluate. If you evaluate everything (even in parallel), there's a lot of wasted work if the programmer is making optimal use of the non-strictness of the language. Furthermore, if de-forestation fails anywhere, you've likely got another problem. Consider the following program: > n `choose` m = product $ take m $ [n, n-1..] Which translates (after some optimisation) to STG equivalent to: > downFrom n = let n1 = (-) n 1 > in let xn1 = downFrom n1 > in let xn2 = n:xn1 > in xn2 > choose n m = let xn1 = downFrom n > in let xn2 = take m xn1 > in product xn2 Now, (:) cannot `spark' a thread to evaluate xn1 in downFrom, because that would end up sparking infinitely many threads---which may be possible, but nothing you've said suggests that it is. > to calculate each parameter without worrying about the side affects of > each function. No locking is necessary because you only spark one > thread for each argument. This is true for tree reduction, but not for graph reduction. Consider, e.g., the fact that the call to product in choose and the recursive call to downFrom walk down (and hence evaluate) the same list. Since the cons cells making up this list are evaluated by two different functions, some sort of locking is indeed necessary to ensure that you don't end up with two threads for each of the (infinitely many) cons cells in the list. > I suspect I haven't fully understood the difficaulty in doing this, > care to enlighten me? Certainly. See above. Jon Cast

3 2

Beginner problems with 'triple' code
by Stu White 27 Jul '04

27 Jul '04

Hi I'm not especially experienced in using haskell, and I could use some help. As part of a project, I'm trying to construct a data type that can represent three values as a 'triple' (as opposed to a 'tuple'), and then make a function so that I can sort these values into ascending order. I'm having a few problems with the code that I have at the minute (I suspect its riddled with errors!) type Triple = Triple { entry 1 :: a; entry 2 :: a; entry 3 :: a; sortTriple :: Triple a -> Triple a; } deriving (Show, Eq) where sortTriple t@(Triple x y z) | (y<x) = sortTriple (Triple y x z) | (z<y) = sortTriple (Triple x z y) | otherwise = t Hope you guys can help me, sorry if this seems trivial - but I'm only a beginner! If you could explain/correct any errors I'd appreciate it, as I am trying to learn what to do and what not to do, not just arrive at a working program. Thanks S. Midley --------------------------------- ALL-NEW Yahoo! Messenger - all new features - even more fun!

4 3

Parsec Problem
by haskell＠alias.spaceandtime.org 27 Jul '04

27 Jul '04

Hello, I copied this example exactly from the page http://www.cs.uu.nl/people/daan/download/parsec/parsec.html -----begin----- module Parser where import Data.Char import Text.ParserCombinators.Parsec import Text.ParserCombinators.Parsec.Char import Text.ParserCombinators.Parsec.Token price = lexeme (do{ ds1 <- many1 digit ; char '.' ; ds2 <- count 2 digit ; return (convert 0 (ds1 ++ ds2)) }) <?> "price" where convert n [] = n convert n (d:ds) = convert (10*n + digitToInt d) ds -----end----- However attempting to compile it gives the error message Test.hs:8: Couldn't match `GenParser tok st a' against `CharParser st1 a1 -> CharParser st1 a1' Expected type: GenParser tok st a Inferred type: CharParser st1 a1 -> CharParser st1 a1 Probable cause: `lexeme' is applied to too few arguments in the call (lexeme (do ds1 <- many1 digit char '.' ds2 <- count 2 digit return (convert 0 (ds1 ++ ds2)))) In the first argument of `(<?>)', namely `lexeme (do ds1 <- many1 digit char '.' ds2 <- count 2 digit return (convert 0 (ds1 ++ ds2)))' I wish I knew what that meant. If someone could explain it and tell me what's wrong, I'd appreciate it. Thanks.

2 1

Ambiguous type variable
by Arjun Guha 27 Jul '04

27 Jul '04

Hi, I'm new to Haskell and am getting this error: AlphaBeta.hs:1: Ambiguous type variable `v' in the top-level constraint: `Ord v' arising from use of `maxValue' at AlphaBeta.hs:12 in the following code: module AlphaBeta where -- Game states are instances of MinimaxState class MinimaxState st where successors:: st -> [(action,st)] terminal:: st -> Bool utility:: (Ord v) => st -> v minimaxDecision state = filter (\(_,st) -> utility st == v) (successors state) where v = maxValue state maxValue:: (MinimaxState state, Ord v) => state -> v maxValue state = if terminal state then utility state else (foldl max x xs) where (x:xs) = map (minValue.snd) (successors state) minValue:: (MinimaxState state, Ord v) => state -> v minValue state = if terminal state then utility state else (foldl min x xs) where (x:xs) = map (maxValue.snd) (successors state) Any hints would be appreciated. -Arjun

4 4

RE: [Haskell-cafe] Parsec Problem
by Bayley, Alistair 27 Jul '04

27 Jul '04

> I copied this example exactly from the page > http://www.cs.uu.nl/people/daan/download/parsec/parsec.html > > price = lexeme (do{ ds1 <- many1 digit > ... > However attempting to compile it gives the error message > ... > I wish I knew what that meant. If someone could explain it > and tell me what's wrong, I'd appreciate it. The documentation for Parsec is a bit out-of-date; some things still work as described, and some things have changed. You'll have to browse the current libraries at the same time as reading the Parsec documentation to determine if a particular feature is still working as described, or if there's a newer (better?) way of doing the same thing. If you want to learn how to use the libraries, I recommend writing some very simple character/string parsers first, to see how the combinators work. Back to your parser... A lexeme parser (as described in the Parsec document) is one that consumes any trailing whitespace after the token has been read, so as to leave the next non-whitespace token ready on the input stream. The easiest way to fix the price parser is simply to add Text.ParserCombinators.Parsec.Char.spaces after the last digits have been read. price = do { ds1 <- many1 digit ; char '.' ; ds2 <- count 2 digit ; spaces -- eat trailing whitespace ; return (convert 0 (ds1 ++ ds2)) } <?> "price" where convert n [] = n convert n (d:ds) = convert (10*n + digitToInt d) ds (The lexeme function is now a record field accessor in Text.ParserCombinators.Parsec.Token. There is a data type called TokenParser, of which lexeme is one field. There's probably a way to write the price parser using TokenParser and the lexeme function/field, but I haven't figured this out yet.) Alistair. ----------------------------------------- ***************************************************************** 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. *****************************************************************

1 0

Re: [Haskell-cafe] Parsec Problem
by J.Garrett.Morris＠Dartmouth.EDU 27 Jul '04

27 Jul '04

--- haskell(a)alias.spaceandtime.org wrote: I wish I knew what that meant. If someone could explain it and tell me what's wrong, I'd appreciate it. --- end of quote --- Lexeme is actually a selector function over the TokenParser record. In the previous section (also on lexical analysis), he included the code: module Main where import Parsec import qualified ParsecToken as P import ParsecLanguage( haskellStyle ) lexer :: TokenParser () lexer = makeTokenParser (haskellDef { reservedOpNames = ["*","/","+","-"] }) whiteSpace= P.whiteSpace lexer lexeme = P.lexeme lexer -- <-- here's lexeme symbol = P.symbol lexer natural = P.natural lexer parens = P.parens lexer semi = P.semi lexer identifier= P.identifier lexer reserved = P.reserved lexer reservedOp= P.reservedOp lexer Once you've done that, the sample code should work fine. /gXm

1 0

Type Theory? Relations
by haskell＠alias.spaceandtime.org 26 Jul '04

26 Jul '04

Hello, I have a question that may pertain to type theory. According to Enderton, one of the ways to define an ordered pair (a,b) is {{a},{a,b}}. A relation is defined as a set of ordered-pairs. A map, of course, is a single-valued relation. Given all that, suppose I have a "FiniteMap Int String" in Haskell. This is, according to the definitions above, a "Set (Int,String)". An element of that has type (Int,String), which contains {Int,String}. But that can't exist because a Set contains only elements of one type. What I'm getting at is that it seems that a Relation should be defined type Relation a = Set (a,a) rather than type Relation a b = Set (a,b) so that we don't have this problem. Thanks.

2 1

Re: [Haskell-cafe] optimising for vector units
by MR K P SCHUPKE 26 Jul '04

26 Jul '04

As far as I understand it haskells lazy evaluation resembles dataflow computation - IE values are computed on demand. This problem has already been solved for hardware, you end up with what is termed a super-scalar architecture. Instructions read from memory fill a re-order buffer. As computations complete value slots in the reorder buffer are filled with the result values. When an instruction has all its values it can be executed, and will be assigned to the next available execution unit. I am not too sure of the internal architecture of GHC, but I can imagine that funtions waiting to be run will have slots for arguments, that will be filled in when values become available. The whole point is that a function with three parameters can spark three threads to calculate each parameter without worrying about the side affects of each function. No locking is necessary because you only spark one thread for each argument. I suspect I haven't fully understood the difficaulty in doing this, care to enlighten me? Keean.

1 0

Re: [Haskell-cafe] optimising for vector units
by Jon Cast 26 Jul '04

26 Jul '04

Ketil Malde <ketil+haskell(a)ii.uib.no> wrote: > MR K P SCHUPKE <k.schupke(a)imperial.ac.uk> writes: <snip> > One would expect a lazy and pure language Not lazy! See below. > to be excellent for parallelization, since the programmer is generally > removed from the actual flow of execution anyway. At some point (for > some n), being able to spawn n threads will gain you more than a > factor c constant overhead, ^^^^^^^^^^^^^^^^^^^^^^^^^^ What makes you think the overhead is constant? Without Optimistic Evaluation, Haskell programs mutate /heavily/, and even with Optimistic Evaluation I'm sure there is some mutation going on. With a truly parallel system, every mutation has to be locked in some way; reducing the number of locking operations to merely constant overhead is an interesting (as in extremely difficult) research problem. > and Haskell programs, with a run-time system that can evaluate > expressions in paralllel, will outperform single threaded C code. > > (But it probably isn't that simple, or we would have it already :-) Nope. Jon Cast

2 1

Re: [Haskell-cafe] optimising for vector units
by MR K P SCHUPKE 26 Jul '04

26 Jul '04

>Correct me if I'm wrong but I thought that there was some overhead to >making FFI (even safe/unsafe) You are not wrong... so it would only be worth it if you could execute a whole bunch of C at the same time. But it is possible... Consider: Use a monad to sequence vector operations on the Vector class. The monad instead of directly executing vector instructions compiles a syntax tree, or a list of instructions. This list of instructions is passed to the C code, which sequences the primitive vector ops into a block of code, and returns a function pointer via the FFI. You just call the whole block with the right parameters. This is probably getting to be more work than integrating stuff into GHC though. It is also doing stuff dynamically that could be done statically at compile time. If GCC is providing vector abstractions then it would seem a lot less work for GHC to incorporate 'vector' types directly... Anyone like to comment more specifically on what would be involved in plumbing a new datatype into GHC that handles vectors? Assuming we wanted an interface like: myFn :: Vector Word8 Four -> Vector Word8 Four. Also vector is not a good name, as with vectors: "a * b" would be the cross-product, but with SIMD we get 4 scalar multiplies... Keean.

1 0

optimising for vector units
by Matthew Roberts 26 Jul '04

26 Jul '04

Hi, Does anybody know if any of the Haskell compilers are able to optimise for vector units (like MMX, SSE(2), 3D_Now! and AltiVec)? My investigations have revealed that c requires special programming constructs to make the most of these processor capabilites (i.e. the compiler is not able to work it out for itself). Is there any work on getting haskell compilers to work this kind of thing out? Cheers, Matt

3 2

Trouble with types
by Kari Pahula 23 Jul '04

23 Jul '04

I'm new to Haskell, as you can probably tell... I have the following data types: data Real a => Energy a = Energy a deriving (Eq, Ord, Show) data Real a => HeatC a = HeatC a deriving (Eq, Ord, Show) data Object h c = Object {energy :: (Energy h), heatc :: (HeatC c)} deriving (Eq, Show) data Real a => Temp a = Temp a deriving (Eq, Ord, Show) I'd like to make a function to calculate the temperature of an object. Physically this is the total heat times the heat capacity. I tried this with the following: temp :: (Real a) => Object (Energy a) (HeatC a) -> Temp a temp Object (Energy e) (HeatC c) = Temp e*c But this fails in hugs with: ERROR "temp.hs":22 - Constructor "Object" must have exactly 2 arguments in pattern What's the syntax to use here? Should I do this in some other way? Should I use newtype here instead of data?

4 4

Re: generalised algebraic data types, existential types, and phantom types
by Jim Apple 23 Jul '04

23 Jul '04

I tried to post this to gmane.comp.lang.haskell.general, but it never got there - it may belong here anyway. Abraham Egnor wrote: > Is there any closer approximation [of GADTs] possible? {-# OPTIONS -fglasgow-exts #-} {-# OPTIONS -fallow-undecidable-instances #-} data Term a = forall b . (EqType a b, EqType b Int) => Lit Int | forall b . (EqType a b, EqType b Int) => Inc (Term Int) | forall b . (EqType a b, EqType b Bool) => IsZ (Term Int) | If (Term Bool) (Term a) (Term a) | forall b . Fst (Term (a,b)) | forall b . Snd (Term (b,a)) | forall b c . (EqType a (b,c))=> Pair (Term b) (Term c) class EqType a b | a->b, b->a instance EqType a a Unfortunately, I can't seem to write an eval function: eval (Lit a) = a gives Inferred type is less polymorphic than expected Quantified type variable `b' is unified with `Int' When checking an existential match that binds The pattern(s) have type(s): Term Int The body has type: Int In the definition of `eval': eval (Lit x) = x Any ideas? Jim

2 1

Data.Set subset function?
by Graham Klyne 22 Jul '04

22 Jul '04

I don't see a subset function in Data.Set. What is the preferred way to define this? I currently have: a `subset` b = isEmptySet (a `minusSet` b) (Hmmm... does library style prefer `subset`, `subsetOf`, `isSubset`, `isSubsetOf` ?) #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

2 1

RE: [Haskell-cafe] STG optimization
by Simon Marlow 21 Jul '04

21 Jul '04

On 20 July 2004 22:58, 7253146(a)informatica.alumnos.uma.es wrote: > So far so good. Nonetheless, some doubts have arisen when I have > started to try to add updating. In the paper, implementation for > "update in place" is extensively discussed, although it is said it > could greatly increase the memory space usage. ¿Has this risk been > measured? I think deforestation can minimize the risk; however, as > far as I know, deforestation is only applied to lists. Nowadays GHC doesn't do update-in-place. We removed update-in-place when we re-implemented the code generator and RTS back in version 4.00. There were two reasons: - update-in-place (and its friend, return-in-registers) turned out to be hugely complex when combined with all the other optimisations that GHC does. - we achieve much of the same benefit by adding unboxed tuples to the language and using the "Constructed Product Result" optimisation. CPR is now done by the strictness analyser. Nevertheless, for a while we still did update-in-place when the code genreator could statically determine that there was an update frame on the top of the stack when building a constructor application. But this could only be done when the constructor application contained no pointers - because otherwise the update-in-place code has to deal with the complexities of mutation in a generational garbage collector. But when combined with concurrency, even this kind of update-in-place is difficult, because it might be that another thread is waiting on the result of the thunk being evaluated, and the update code has to wake up that thread. So now, all updates go through one carefully optimised piece of code in the runtime. > But the STG paper ignores an optimization readyly available to me: > whenever a constructor is allocated (constructor's register > allocation aside, since the push/enter - eval/apply paper says GHC no > longer supports it), the STG machine (the one described by the paper) > takes heap space for it, although an update (indirection or copying) > is going to be done most of times. This leads to potentially bad heap > space usage and more garbage collections. > > I think update frames may be detected by the constructor allocation > code, so it could determine whether to allocate a new constructor or > build it over the closure to be updated. This could be achieved by > marking continuations and update frames in the stack, so constructor > allocation code could distinguish between them. This is inconvenient > because common continuations should remove the mark too, so I do not > like it. Yes you could do this. Don't forget to take into account the complications I mentioned above, though (much easier if you don't have generational collection and concurrency). Also you have to know whether the thunk is big enough to be updated with the constructor application. Cheers, Simon

1 0

Sets and Monads and comprehensions
by Graham Klyne 21 Jul '04

21 Jul '04

A few months ago, there was a discussion here about defining Set to be a Monad, starting with: [1] http://www.haskell.org/pipermail/haskell-cafe/2004-March/005988.html in response to which, SPJ pointed out that a Set cannot be a Monad: [2] http://www.haskell.org/pipermail/haskell-cafe/2004-March/005995.html I found myself treading a path which led me to asking the same question as [1]. Given the answer [2], I'd like to stand back a little and ask if there's another way to tackle my niggle: what I'm interested in is a set comprehension expression that is analogous to a list comprehension expression; e.g. in: [[ > import Data.Set > > type AtomicConcept = String -- named atomic concept > type AtomicRole = String -- named atomic role > > type AtomicConcepts a :: AtomicConcept -> (Set a) > type AtomicRoles a :: AtomicRole -> (Set (a,a)) > > type Interpretation a :: (Set a,AtomicConcepts a,AtomicRoles a) ... > iAL (idom,ic,ir) (ALAll r c) = mkSet [ a | (a,b) <- setToList (ir r) > , b `elementOf` ir c ] ]] is there a common or similar idiom to achieve the same effect without converting the set to a list and back? I did also find myself wondering if there was a role for unfold (or similar) here. #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

2 1

STG optimization
by 7253146＠informatica.alumnos.uma.es 21 Jul '04

21 Jul '04

Hi. I have been reading recently the STG machine paper by Simon Peyton-Jones. It is relatively easy to follow the explanation, though the formal description of operational semantics is hard to understand. In order to fully understand it, I have started to implement a C-based mini STG machine, implementing the obvious compilation schemes according to the STG paper. Of course, I have not implemented most of optimizations: environment management is very rudimentary, it has three stacks (pointer args, primitive args and continuations) for simplicity, etc. At the moment I have a beatiful tree-reduction STG machine. So far so good. Nonetheless, some doubts have arisen when I have started to try to add updating. In the paper, implementation for "update in place" is extensively discussed, although it is said it could greatly increase the memory space usage. ¿Has this risk been measured? I think deforestation can minimize the risk; however, as far as I know, deforestation is only applied to lists. But the STG paper ignores an optimization readyly available to me: whenever a constructor is allocated (constructor's register allocation aside, since the push/enter - eval/apply paper says GHC no longer supports it), the STG machine (the one described by the paper) takes heap space for it, although an update (indirection or copying) is going to be done most of times. This leads to potentially bad heap space usage and more garbage collections. I think update frames may be detected by the constructor allocation code, so it could determine whether to allocate a new constructor or build it over the closure to be updated. This could be achieved by marking continuations and update frames in the stack, so constructor allocation code could distinguish between them. This is inconvenient because common continuations should remove the mark too, so I do not like it. Another (my favourite) similar solution should be introduce a new stack only for update frames, but still pushing code labels for updating in the continuation stack (which could still be merged with the primitive args stack): this way, constructor's code can still simply jump to the next "continuation" (the update code should be responsible of popping the update stack), and constructor allocation code can simply test if the "continuation" on top of the stack is a real continuation, so it can safely take newly allocated heap space for the constructor, or it is an update (perhaps by testing for equality with the top of the update stack), so the code should test if the constructor closure can be overwritten over the closure to be updated. To ilustrate my thoughts: \begin{code} some_func <some_args> = let b = <some_expression> in SomeConstructor { b, some_stuff } some_other_func <some_other_args> = let a = some_func { some_other_stuff } in case a of <some_alternatives> \end{code} In the above piece of core STG language, when the "a" closure is entered and finally "SomeConstructor" must be allocated, the code of "some_func" should check if the continuation leads to an update (in this case, an update of "a") or an continuation. In this case it leads to an update, so then the code should check if the update closure ("a") is large enough, and, in that case, build the constructor closure over it. Maybe this technique is irrelevant for performance, too expensive to implement, or having a separated update stack is too inconvenient, or these effects are achieved by other ways? Thanks in advance Jose David --------------------------------------------- Este mensaje lo ha enviado un Alumno de la Universidad de Malaga. http://www.alumnos.uma.es/

2 1

Re: [Haskell-cafe] How do I include polymorphic function type signatures in a data element ?
by Crypt Master 20 Jul '04

20 Jul '04

*grin* its so obvious once you know the answer :-) Thx ----Original Message Follows---- On Tue, 20 Jul 2004, Crypt Master wrote: > Exmaple: > > <CODE> > type Fitness = Integer > data Population a = Population [(Fitness, a)] > deriving (Show) > > data GAParams = GAParams { randomNums :: [Integer] , > someFunc :: (Int->Int->(Population a))} > </CODE> Like for 'Population a' you have to specify a type parameter for 'GAParams', i.e. | v data GAParams a = GAParams { randomNums :: [Integer] , someFunc :: (Int->Int->(Population a))} _________________________________________________________________ Protect your PC - get McAfee.com VirusScan Online http://clinic.mcafee.com/clinic/ibuy/campaign.asp?cid=3963

1 0

How do I include polymorphic function type signatures in a data element ?
by Crypt Master 20 Jul '04

20 Jul '04

Hi How do I include polymorphic function type signatures in a data element ? Exmaple: <CODE> type Fitness = Integer data Population a = Population [(Fitness, a)] deriving (Show) data GAParams = GAParams { randomNums :: [Integer] , someFunc :: (Int->Int->(Population a))} </CODE> This errors with parse input error on '}'. However something like this works fine: <CODE> data GAParams = GAParams { randomNums :: [Integer] , someFunc :: (Int->Int->GAParams) } /<CODE> I am just having issues with polymorphic types. Any ideas ? The context is included below in case it helps: <CODE> import Random type Fitness = Integer data Population a = Population [(Fitness, a)] deriving (Show) data GAParams = GAParams { randomNums :: [Integer] , someFunc :: (Int->Int->GAParams) } gaSolutionSpaceFrom :: Population a -> GAParams -> [Population a] gaSolutionSpaceFrom p gaParams = (evolvePopulation p gaParams) : gaSolutionSpaceFrom p newGAParams where (r,rs) = splitAt (length pl) (randomNums gaParams) Population pl = p newGAParams = (gaParams{randomNums=rs}) evolvePopulation :: Population a -> GAParams -> Population a evolvePopulation p gaParams = (mutate (cross (select p))) selectMatingPoolByRouletteWheel :: Population a -> GAParams -> Population a selectMatingPoolByRouletteWheel (Population popList) gaParams = (Population [ (rwSelect rw rnd) | rnd <- rndNums ]) where rw = createRW (Population popList) rndNums = (randomNums gaParams) rwSelect :: [(Fitness, a)] -> Fitness -> (Fitness, a) rwSelect [] _ = error "rwSelect random number outside roullete wheel range or list empty" rwSelect ((x,a):xs) z = if x <= z then rwSelect xs z else (x,a) createRW :: Population a -> [(Fitness, a)] createRW (Population xs) = (scanl1 f xs) where f (n,a) (m,b) = (n + m, a) select p = p cross p = p mutate p = p _________________________________________________________________ MSN 8 with e-mail virus protection service: 2 months FREE* http://join.msn.com/?page=features/virus

2 1

migrating from python
by paolo veronelli 14 Jul '04

14 Jul '04

I'm working on semantics and triples (RDF & co) Python code for inference in based totally on dictionaries (associative arrays ??),nested three or four times. The result is astonishing me:compact beautiful modular and extremely readable. I imagine that haskell way should be different but I'm in the dark. As the stream of triples coming from outside estabilishes the actions to be done for inference,the searching through keys (the words that form any triple) is the main job:every time I pick up a triple I have to enlarge the knowledge more or less "near" the resources represented by the words. And after I have produced (possibly) some new inferred triples surely I have to reswitch on some already read triples, matching a pattern. All these are very natural with dictionaries, so I'd like to figure out the haskell view. Thanks for your quiteness and answers Paolino -- ....lotta dura per la verdura

3 2

Process properties as global values
by Volker Wysk 12 Jul '04

12 Jul '04

Hi I'm just wondering, why haven't process properties (such as the command line arguments, or the parent process id), which are inherently global, been made global values in the Haskell standard? You could avoid needlessly carrying around these values, you wouldn't need to lift some functions into the IO monad... For instance, command line argument parsing could look something like this: import qualified System data ParsedArgs = ParsedArgs { pa_myflag :: Bool; ... } | Failure parsed_args :: ParsedArgs parsed_args = (... using System.argv ...) myflag = pa_myflag parsed_args main = do when (parsed_args == Failure) $ ... ... You can get the same effect by using unsafePerformIO. It would still be nice having this in the standard. Greetings, V.W. -- Volker Wysk <post(a)volker-wysk.de> http://www.volker-wysk.de

6 7

Giving up imperative habits....
by paolo veronelli 10 Jul '04

10 Jul '04

Usually I tend not to give much information to a subroutine intending to restrict its liberty of touching the calling information..... So if I have an instance Inst which should be changed by an outside-Inst computation Sub and I'm calling Sub with Sub(I'),I try to build the story so that Sub can only read Inst or a part of it (I') and return some specially structured information which then I use "inside" Inst to change Inst's state (horribble speech). The feeling I get with Haskell, is that S should have the freedom of changing I and return just I (changed). Is it any right ?? grazie Paolino -- ....lotta dura per la verdura

1 0

so how does one convert an IO a into an a ?
by Crypt Master 10 Jul '04

10 Jul '04

Hi Thanks for all the usefull responses, from theory to practical :-). I am busy digesting it all. I have more questions, but more and more I can answer them myself :-) Till the next misunderstanding ;-) C _________________________________________________________________ Add photos to your e-mail with MSN 8. Get 2 months FREE*. http://join.msn.com/?page=features/featuredemail

1 0

so how does one convert an IO a into an a ?
by Crypt Master 09 Jul '04

09 Jul '04

Hi Thanks for your help so far, but I am still not getting this IO stuff. After reading your previous help and reading several articles on it I still cant phathom how you convert the IO Int into an Int. One person mentioned how random just returns an interative program which when eveluated returns the Int. Also from the school of expression book he says " The right way to think of (>>=) above is simply this: It "Executes" e1 ..." in relation to "do pat <- e1 ...". so I have this: <code> rollDice :: IO Int rollDice = getStdRandom (randomR (1,6)) rl :: [Int] rl = [ (getRndNum x) | x <- [1..] ] getRndNum :: Int -> Int getRndNum x = do n <- rollDice return n </code> *PS Pretend return is correctly aligned under n. dont what ahppens in copy and paste* now my understanding therefore is that "do n <- rollDice" should execute the the itererative program returned by rollDice. So now n should be my Int since IO Int was a program which when evaluted returns an Int ? However this is what haskell thinks of my thoery: *** Term : getRndNum *** Type : Int -> IO (Maybe Int) *** Does not match : Int -> Int So I am still in IO Int land despite having used the >>= in the do syntax. Worse Still I am in IO (Maybe Int) land. Monads within Monads. In yours, and many other examples I found online, the results are always passed to print which seems to know how to deal with an IO Int. Is this specially coded or overloaded or something ? There are plenty of examples which use return like so: do k <- getKey w return k which is what I tried above to no avail. It seems awefully complicated just to get hold a simple Int, but naturally complicity is directly related to ones understanding. Mine is sumewhat lacking ... any help would be appreciated. Thanks, S _________________________________________________________________ Tired of spam? Get advanced junk mail protection with MSN 8. http://join.msn.com/?page=features/junkmail

10 11

state in the continuation monad...
by MR K P SCHUPKE 09 Jul '04

09 Jul '04

I am trying to model state in the continuation monad, such that each continuation recieves the current state as one of its arguments. The state must vary in type, which is why I am trying to use the continuation monad, but things don't seem to be going too well. To clarify... imagine the following sequence: do cont1 cont2 cont3 we may want the implicit parameter for cont1 to be an Int, but for it to pass a String to cont2 which passes (String,Int) to cont3 which finally returns something else. so: is it possible to write cont1 etc... ? can anybody tell me what its type would be? Keean.

3 2

Of types and constructors; a question of programming style
by Graham Klyne 08 Jul '04

08 Jul '04

When I'm designing datatypes for a Haskell program, I sometimes seem to end up with a slightly incoherent mixture of algebraic types and constructors. I'm wondering if anyone has worked out a principled way to decide when to introduce a new data type. Here's an example from something I'm working on: [[ data Event = Document DocURI Element | Element Name BaseURI Language Children Attributes LiIndex Subject | EndElement | Attribute Name AttributeVal | Text TextVal ]] (abbreviated from the original for discussion, and using arbitrary type names for the field types) Using this formulation, I have no access to the type of the different alternatives of the Union type thus defined. A different way of describing the type overcomes this limitation: [[ data Event = EVDocument Document | EVElement Element | EVEndElement EndElement | EVAttribute Attribute | EVText Text data Document = Document DocURI Element data Element = Element Name BaseURI Language Children Attributes LiIndex Subject data EndElement = EndElement data Attribute = Attribute Name AttributeVal data Text = Text TextVal ]] which seems to be rather repetitious. And I haven't even started to use the named field syntax here. Yet another alternative, if I'm not interested in field names, might be to use tuples and type synonyms for the alternative values: [[ data Event = Document EVDocument | Element EVElement | EndElement EVEndElement | Attribute EVAttribute | Text EVText type EVDocument = (DocURI,Element) type EVElement = (Name,BaseURI,Language,Children,Attributes,LiIndex,Subject) type EVEndElement = () type EVAttribute = (Name,AttributeVal) type EVText = TextVal ]] Is there any community consensus concerning what constitutes good style in such circumstances? #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

4 4

List find-and-remove
by Graham Klyne 08 Jul '04

08 Jul '04

Once again, I find myself making code that I think may exist somewhere in the libraries: [[ -- list find and remove extract0 :: (a->Bool) -> [a] -> Maybe (a,[a]) extract0 p as = ex [] as where ex seen (a:more) | p a = Just (a,revcat seen more) | otherwise = ex (a:seen) more ex _ [] = Nothing extract :: (a->Bool) -> [a] -> Maybe (a,[a]) extract _ [] = Nothing extract p (a:as) | p a = Just (a,as) | otherwise = pref a (extract p as) where pref a1 (Just (a,as)) = Just (a,a1:as) pref _ Nothing = Nothing -- make list from reversed initial sublist and given trailing sublist revcat :: [a] -> [a] -> [a] revcat [] more = more revcat (a:as) more = revcat as (a:more) t1 = extract (==2) [1,2,3,4] == Just (2,[1,3,4]) t2 = extract (>2) [1,2,3,4] == Just (3,[1,2,4]) t3 = extract (>5) [1,2,3,4] == Nothing ts = and [t1,t2,t3] ]] (1) is there a function like 'extract'/'extract0' in the standard libraries? (2) if not, is there any significant difference in the efficiency of the above implementations? I think they both use linear time and space, but the 'extract0' performs a second traversal of (part of) the list to construct the result, where 'extract' has to pick apart and test the result from each recursive call. To my eye, the 'extract0' version looks better. #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

1 0

Inferred type is not general enough
by Ivan Tihonov 08 Jul '04

08 Jul '04

I start some ip networks related work in haskell and wrote two basic classes Location and Packet. Before writing IpLocation and IpPacket instances i have written simple TestLocation and TestPacket instances just to compile this and check for errors in class definitions. But looks like i misunderstand some haskell principles... ====================================================== class Location a where point :: a -> String class Packet a where source, destination :: Location b => a -> b size :: Num b => a -> b ------------------------------------------------------ data TestLocation = TestSource | TestDestination data TestPacket = TestPacket ------------------------------------------------------ instance Location TestLocation where point a = "location" instance Packet TestPacket where source p = TestSource destination p = TestDestination size p = 99 $ hugs Test.hs ERROR Test.hs:20 - Inferred type is not general enough *** Expression : source *** Expected type : (Packet TestPacket, Location a) => TestPacket -> a *** Inferred type : (Packet TestPacket, Location TestLocation) => TestPacket -> TestLocation ====================================================== But if i remove source and destination from class and instance definitions alone "size" compiles well. How write this in a haskell way?

4 5

RE: infered type does not typecheck
by Simon Peyton-Jones 08 Jul '04

08 Jul '04

Duncan Oleg's recent message to Haskell-Café tackles your real problem, but I thought I'd just say what is going on with your apparent bug below. Here's a much simpler example: class Foo a b where to :: a -> b fro :: b -> a -- foo :: forall b1 b a. (Foo a b, Foo a b1) => b -> b1 foo x = to (fro x) Without the type signature, the program typechecks "fine", and GHCi reports the type in the comment. But if you uncomment the type signature, typechecking fails. Why? It's because the type is really ambiguous. 'fro' converts from b to a, and 'to' converts back... but the 'a' is entirely lost in the process. It's very like the classic (show (read x)) example. So the type foo :: forall b1 b a. (Foo a b, Foo a b1) => b -> b1 is really unusable, because there is nothing to constrain 'a'. When you add the type signature, GHC can't establish the connection between the 'a' needed as the intermediate type in the (to (fro x)) composition and the 'a' in the type signature. You might argue that GHC should reject foo in the first place, and you'd be right, really. But it's hard in general to reject exactly and only the ambiguous cases (given functional dependencies and all that jazz), and I have not worked hard on that. But I grant that it's rather counter-intuitive that adding a type signature that GHC itself deduces goes wrong! You're right to count it a bug. Simon | This was posted to the Haskell list earlier, | http://www.haskell.org//pipermail/haskell/2004-June/014286.html | but just to record what appears to be a typechecker bug. | | I have a function with this type: | buildUArray' :: (Ix i, MArray (array s) a (ST s)) => | (i,i) -> (i -> a) -> ST s (array s i a) | | Then I ask ghci (6.2.1 and 6.3 recent cvs) the type of the following | function: | | buildUArray bounds f = do arr <- buildUArray' bounds f | unsafeFreeze arr | | ghci says: | buildUArray :: forall a i b s array. | (MArray (array s) a (ST s), Ix i, IArray b a) => | (i, i) -> (i -> a) -> ST s (b i a) | | However if I add this annotation back in the script, ghc complains: | | Could not deduce (MArray (array1 s) a (ST s)) | from the context (MArray (array s) a (ST s), Ix i, IArray b a) | arising from use of `unsafeFreeze' at BuildArray.hs:25 | Probable fix: | Add (MArray (array1 s) a (ST s)) | to the type signature(s) for `buildUArray' | Or add an instance declaration for (MArray (array1 s) a (ST s)) | In the result of a 'do' expression: unsafeFreeze arr | In the definition of `buildUArray': | buildUArray bounds f | = do | arr <- buildUArray' bounds f | unsafeFreeze arr

1 0

Re: [Haskell-cafe] Inferred type is not general enough
by Ivan Tihonov 08 Jul '04

08 Jul '04

Stefan Holdermans wrote: Huh. I'm really get stuck. Can someone write me working implementation of my crap?

2 1