- Haskell-Cafe - Haskell.org

head as a total function
by oleg＠pobox.com 07 Sep '06

07 Sep '06

Jo'n Fairbairn wrote in response to Neil Mitchell: > > And as you go on to say, if you apply it to the infinite > > list, who cares if you used head. Head is only unsafe on > > an empty list. So the problem then becomes can you detect > > unsafe calls to head and let the programmer know. > No, that's the wrong approach because it relies on detecting > something that (a) the programmer probably knows already and > (b) is undecidable in general. It would be far better for > the programmer to express this knowledge in the > programme. It is indeed possible -- and quite easy -- to write programs where head and tail are total functions. That issue was discussed, for example, at the end of an old message: Exceptions in types and exception-free programming http://www.haskell.org/pipermail/haskell/2004-June/014271.html The first two thirds of the message showed how to make exceptions apparent in the signature of a function, so we can see if a function could potentially raise the `head of an empty list' exception just by looking at its (inferred) type. The exception-free programming is far more rewarding, and practical as well. We don't actually need to introduce subtyping; explicit injection/projections don't seem to be as much of (syntactic) overhead. There is absolutely no runtime overhead! The non-empty lists have exactly the same run-time representation as the regular lists. The technique generalizes to arrays, even numbers, sorted lists (and, seemingly, to strings that are safe to include into HTML/SQL documents). That technique has been mentioned several times recently (perhaps not on this forum). Quite complex algorithms like Knuth-Morris-Pratt string search (with mutable arrays, packed strings, general recursion and creative index expressions) can be handled. Again, without introducing any runtime overhead: http://pobox.com/~oleg/ftp/Haskell/KMP-deptype.hs The approach is formalizable; the recent PLPV talk by Chung-chieh Shan presented the types systems and the proof techniques. Some of the proofs have been formalized in Twelf: http://pobox.com/~oleg/ftp/Computation/lightweight-dependent-typing.html#Fo… In short, the safety property (absence of `head of an empty list' exception) is a corollary to the Progress theorem, for a type system with dependent-type flavor. The type system doesn't actually have dependent types. Furthermore, whatever dependent-type flavor there is, it can be erased while maintaining the safety guarantees, given some precisely stated conditions on the safety kernel. P.S. Algol68 was my favorite language too.

5 5

Hello Monads
by Hans van Thiel 07 Sep '06

07 Sep '06

Hello All, Being at the "Hello Monads" level, and having spent many hours on understanding the following code from YAHT, maybe this will be helpful to others. {-cross ls1 ls2 = do x <- ls1 y <- ls2 return (x,y) -} In the List Monad the value of cross is a list of pairs from the two lists. Rewriting to: {-cross ls1 ls2 = ls1 >>= \x -> ls2 >>= \y -> return (x, y) -} The actual function which gives an ordered pair is: --hf1 = (\x y -> (x,y)) In the list Monad >>= is defined as the infix of bind, and return is the same as make. bind = flip concatMap make x = [x] So now cross can be written as: --cross ls1 ls2 = ls1 `bind` (\x -> ls2 `bind` (\y -> make (x,y))) With the prefix version of bind this becomes: cross ls1 ls2 = bind ls1 (\x -> bind ls2 (\y -> make(x,y))) Bind takes a list and a function. That function still looks complicated (to me), because of the lambda abstraction, but the format is that the second bind takes the list ls2 and another function, make, which has a list of tuples as its value. The point I want to make is, that the monadic computation is just another function. The only difference is that the >== and return functions have been defined centrally in the List Monad. Moreover, the same notation has been defined in all other monads, but with different meanings, appropriate to that monad. But you can use them. Cross ls1 ls2, for example, also works in the Maybe Monad, without any change at all. So the Monad class is, in essence, no different from the Num class (or any other) where you also use predefined functions. These also will be different for the different subordinate types. Surely this is an oversimplification but, in for a dime, in for a dollar: An input procedure like getLine cannot be a function, because it will return a different value each time it is called. Putting getLine inside an IO Monad does not change this. What you can state, however, is that a certain occurrence of getLine will return a certain value. So, if you have a chain of IO actions, the first getLine will get this, the fifth that, and so on. The value of these occurrences cannot change, simply because they are uniquely identified. But this is what the monadic sequence of actions achieves, it puts all IO into a well defined chain where each action becomes unique, even though names (like getLine) on the different positions are the same. But again, the monadic computation is still a function. I'd appreciate your comments. Regards, Hans van Thiel -- Don't worry, be happy, learn Haskell.

1 0

how do you debug programs?
by Tamas K Papp 07 Sep '06

07 Sep '06

Hi, I would like to learn a reasonable way (ie how others do it) to debug programs in Haskell. Is it possible to "see" what's going on when a function is evaluated? Eg in f a b = let c = a+b d = a*b in c+d evaluating f 1 2 would output something like f called with values 1 2 c is now (+) a b => (+) 1 2 => 3 d is now (*) a b => (*) 1 2 => 2 ... Or maybe I am thinking the wrong way, and functional programming has its own debugging style... Thanks, Tamas

15 32

Re: [Haskell-cafe] does the compiler optimize repeated calls?
by John Hughes 06 Sep '06

06 Sep '06

On 9/6/06, Tamas K Papp <tpapp(a)princeton.edu> wrote: >> or does the compiler perform this optimization? More generally, if a >> function is invoked with the same parameters again (and it doesn't >> involve anything like monads), does does it makes sense >> (performancewise) to "store" the result somewhere? > > I was wondering something like this too, and then I found this email: http://www.haskell.org/pipermail/glasgow-haskell-bugs/2004-December/004530.… So I guess it is as Stephane said: theoretically possible but not actually done? --eric the perpetual newbie The trouble is that this isn't always an optimisation. Try these two programs: powerset [] = [[]] powerset (x:xs) = powerset xs++map (x:) (powerset xs) and powerset [] = [[]] powerset (x:xs) = pxs++map (x:) pxs where pxs = powerset xs Try computing length (powerset [1..n]) with each definition. For small n, the second is faster. As n gets larger, the second gets slower and slower, but the first keeps chugging along. The problem is that the second has exponentially higher peak memory requirements than the first. Round about n=25, on my machine, all other programs stop responding while the second one runs. You don't really want a compiler to make that kind of "pessimisation" to your program, which is why it's a deliberate decision to leave most CSE to the programmer. You can still write the second version, and suffer the consequences, but at least you know it's your own fault! John

2 2

getContents and lazy evaluation
by Tamas K Papp 06 Sep '06

06 Sep '06

Hi, I am newbie, reading the Gentle Introduction. Chapter 7 (Input/Output) says Pragmatically, it may seem that getContents must immediately read an entire file or channel, resulting in poor space and time performance under certain conditions. However, this is not the case. The key point is that getContents returns a "lazy" (i.e. non-strict) list of characters (recall that strings are just lists of characters in Haskell), whose elements are read "by demand" just like any other list. An implementation can be expected to implement this demand-driven behavior by reading one character at a time from the file as they are required by the computation. So what happens if I do contents <- getContents handle putStr (take 5 contents) -- assume that the implementation -- only reads a few chars -- delete the file in some way putStr (take 500 contents) -- but the file is not there now If an IO function is lazy, doesn't that break sequentiality? Sorry if the question is stupid. Thanks, Tamas

7 9

Re: how do you debug programs?
by Johan Tibell 06 Sep '06

06 Sep '06

Note: I meant to send this to the whole list a couple of messages ago but accidentally I only sent it to Lennart, sorry Lennart! I know that Linus Torvalds doesn't find debuggers all that useful either and he hacks C [1]. 1. http://linuxmafia.com/faq/Kernel/linus-im-a-bastard-speech.html On 9/6/06, Lennart Augustsson <lennart(a)augustsson.net> wrote: > I've also used Visual Studio, and I wouldn't mind having something > like that for Haskell. But I have to agree with Jon, I think the > best way of debugging is to understand your code. I think people who > come from imperative programming come with a mind set that you > understand your code by stepping through it in the debugger. But I > find this paradigm much less useful for functional code. > > -- Lennart > > On Sep 6, 2006, at 06:22 , Neil Mitchell wrote: > > > Hi > > > >> But why should c and d exist at runtime? They're only used > >> once each, so the compiler is free to replace f with > >> > >> \a b -> (a+b)+ a*b > > > > Yes, and if the compiler is this clever, it should also be free to > > replace them back at debug time. > > > > > >> I've said this before, but I think it's worth repeating: in > >> most cases, if you need to debug your programme it's because > >> it's too complicated for you to understand, so the correct > >> thing to do is to simplify it and try again. > > > > That makes it impossible to ever improve - initially all programs are > > beyond you, and only by pushing the boundary do you get anywhere. As > > for me, I always write programs I can't understand, and that no one > > else can. Perhaps I understood it when I originally wrote it, perhaps > > not, but that was maybe over a year ago. > > > > It's been my experience that debugging is a serious weakness of > > Haskell - where even the poor mans printf debugging changes the > > semantics! And everyone comes up with arguments why there is no need > > to debug a functional language - that sounds more like excuses about > > why we can't build a good lazy debugger :) > > > > [Sorry for the slight rant, but I've used Visual Studio C++ so I know > > what a good debugger looks like, and how indispensable they are] > > > > Thanks > > > > Neil > > _______________________________________________ > > Haskell-Cafe mailing list > > Haskell-Cafe(a)haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-cafe > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

1 0

does the compiler optimize repeated calls?
by Tamas K Papp 06 Sep '06

06 Sep '06

Hi, I have a question about coding and compilers. Suppose that a function is invoked with the same parameters inside another function declaration, eg -- this example does nothing particularly meaningless g a b c = let something1 = f a b something2 = externalsomething (f a b) 42 something3 = externalsomething2 (137 * (f a b)) in ... Does it help (performancewise) to have g a b c = let resultoff = f a b something2 = externalsomething resultoff 42 something3 = externalsomething2 (137 * resultoff) in ... or does the compiler perform this optimization? More generally, if a function is invoked with the same parameters again (and it doesn't involve anything like monads), does does it makes sense (performancewise) to "store" the result somewhere? Thank you, Tamas PS: I realize that I am asking a lot of newbie questions, and I would like to thank everybody for their patience and elucidating replies.

11 15

installing modules
by Tamas K Papp 06 Sep '06

06 Sep '06

Hi, This is a newbie question. I found some modules on the internet that I would like to try (eg the Tim Docker's chart library [1], etc). Most of the code I see is in darcs repositories, I figured out how to get them, but I don't know how to install it _cleanly_. Cleanly means that it ends up in the "right" directory. How do people usually do that? I am using ghc6 on debian testing. Am I supposed to use the thing called "cabal"? Is it perhaps possible to create a debian package from sources that were packaged with this tool? Thank you, Tamas [1] http://dockerz.net/software/chart.html

2 1

[Parsec] No identEnd in ParsecToken?
by Stephane Bortzmeyer 06 Sep '06

06 Sep '06

I'm trying to use Parsec for a language which have identifiers where the '-' character is allowed only inside identifiers, not at the start or the end. ParsecToken has identStart to tell that the '-' is not allowed at the start but I find no equivalent identEnd? I tried also to express the same rule with ordinary combinators, without ParsecToken but this fails: identifier = do start <- letter rest <- many (alphaNum <|> char '-') end <- letter return ([start] ++ rest ++ [end]) <?> "characters authorized for identifiers" because the parser created by "many" is greedy: it consumes everything, including the final letter. Any idea?

5 6

Exercise in point free-style
by Julien Oster 06 Sep '06

06 Sep '06

Hello, I was just doing Exercise 7.1 of Hal Daumé's very good "Yet Another Haskell Tutorial". It consists of 5 short functions which are to be converted into point-free style (if possible). It's insightful and after some thinking I've been able to come up with solutions that make me understand things better. But I'm having problems with one of the functions: func3 f l = l ++ map f l Looks pretty clear and simple. However, I can't come up with a solution. Is it even possible to remove one of the variables, f or l? If so, how? Thanks, Julien

9 16

User data type with operator contructors only
by Dušan Kolář 05 Sep '06

05 Sep '06

Hello all, my question probably comes from not reading manual properly. But, why is it not possible to have something like: infixr 5 :> data Stack a = a :> (Stack a) | :|| And if yes, how can I do that? I know that lists are a hack in Haskell, but anyway. Having: infixr 5 :> data Stack a = a :> (Stack a) | Bottom is not what I would like to have. :-( Thanks for any reference to/or explanation, Dusan

2 2

practice problems?
by Tamas K Papp 05 Sep '06

05 Sep '06

Hi, I am a Haskell newbie. Having read some tutorials (Yet Another, Gentle Introduction) and some papers/tutorials on monads, I would like to spend some time practicing what I have learned before embarking on more abstract/obscure things and/or using Haskell for everyday tasks. I am looking for small to medium sized practice problems, preferably with solutions. Hal Daume's tutorial had some good one-liners (eg rewrite something point-free) but I am looking for something which would take 1-3 hours for a newbie, and then I could look at a solution by a Haskell expert and discover what I could have done better/more elegantly. Online references (or even book suggestions) would be appreciated. If you are teaching Haskell and have problems with confidential solution sets (some instructors like it that way), I can promise not to disclose the latter ;-) Thanks, Tamas

9 12

BSPHlib-0.1 Release
by Frederico Franzosi 05 Sep '06

05 Sep '06

Is with happiness that I announce my first project release. I announced it as an idea to the summer of code and as Paolo Martini said to me that it was a "good idea" I decided to publish it. The link to the summer of code proposal follows: http://hackage.haskell.org/trac/summer-of-code/ticket/80 That link briefly explains what BSPHlib is. To download the source: http://www.inf.ufes.br/~ffranzosi/BSPHlib-0.1.tar.gz I know that many mistakes are likely to appear and I am counting on the community to help me as I am trying to help the community with my still poor coding hability. I have tested that code and it has done some good job, hope I can hear the same from you. In a few weeks the code will be in a darcs repository in order to make code management more organized. Any questions, corrections, patches or suggestions please mail me. Cheers, Frederico Franzosi

1 0

Advantages of using qualified names and a uniform naming convention
by Brian Hulley 04 Sep '06

04 Sep '06

Hi - There's lots of great Haskell libraries available, but little standardization regarding naming conventions or code organization. In this post I try to illustrate some dimensions of the question of how to form names for things and offer my opinion on specific examples knowing that this of course only represents my own personal view but may nevertheless be of objective interest as an *example* of a view and a possible starting point for discussion/ unification of naming conventions in Haskell code if such a thing is even desired/desireable at all. It would be helpful to build up a more rigorous algorithm for determining names, but I think the first step is to try and isolate aspects of the problem thus the following is an initial attempt in this direction... Firstly, I found the following advice by Henning Thielemann very useful in my own code [1]: In the style of Modula-3 I define one data type or one type class per module. The module is named after the implemented type or class. Then a type is named T, and a type class C. I use them qualified, e.g. Music.T or Collection.C. Similarly, if a type has only one constructor then I call it Cons and use it qualified MidiFile.Cons [I don't agree with this last suggestion]. This style also answers the annoying question whether the module name should be in singular or plural form: Always choose singular form! where the only thing I change is that the name of the value constructor for a type with only one value constructor should be the same as the name of the type constructor eg newtype T a = T (a->Int) which seems to be the normal convention anyway and seems better imho than introducing a different identifier for the value constructor when the namespaces for values and types/classes are already distinct. The advantage of such a strict rule is that code becomes deliciously uniform and neat, even if you just follow the part of it that deals with types and modules and use some different convention for classes. It's also particularly nice if you're used to object oriented languages, since it preserves the intuition that you can deal with one thing at a time just as you would put each object into its own separate file or C++ unit. Of course, not all modules can have just one type but I find that most only need to export one type and in any case the (main) exported type can be called "T". The exception is when the types are mutually recursive, so that different types which should really have their own module have to be put into the same module due to limitations of the compiler being used (eg GHC does not yet support mutually recursive modules involving types declared using newtype deriving and also requires hs-boot files which is imho a horrible mess as bad as the need to write separate header files in C and keep decls in sync therefore I avoid them at all costs). Consider the following: import Data.IORef main = do x <- newIORef (0::Int) writeIORef x 3 compared to: import qualified Prime.Data.IORef as Ref main = do x <- Ref.new (0::Int) Ref.write x 3 To my mind the latter is infinitely cleaner looking, because the names of the functions just specify their purpose and nothing else, and it is immediately clear which module they have come from, and there is also the advantage that a shorter prefix could be used if required eg "R". In contrast, the first code example is polluted with mutiple repetitions of "IORef" - we already know we're in the IO monad so why keep stressing the point that we're using IORefs as opposed to STRefs etc? - and there is not even any certainty that the functions so named even come from that module (unless we're already familiar with the contents of the other modules of course). Not only does the latter code look startlingly beautiful, but there is a significant advantage when using an editor which is sophisticated enough to make use of it: after typing the dot in "Ref.", it should be possible for an editor to then display a pop-up list of the visible contents of the module (various possible patent issues aside :-( ) ie the programmer just needs to know the module alias name rather than the names of each individual function/value/type/class when coding. Furthermore (see there's almost no end to the advantages of this convention! ;-)) if the implementation of IORef's was improved later, the whole module can be instantly ported to use the improved implementation just by changing the one import line rather than a painful search and replace of "newIORef" by "newBetterIORef" etc. I think the current presence of names like "newIORef" in the base library is perhaps a result of historical development - qualified names or aliases may not yet have been invented so there was probably a need to follow a convention of appending the type to the purpose when creating a function/value name, but now that we have the ability to use qualified names it would seem to be a lot better if everything could be changed to use them ie Data.Set should export T not Set so you would use foo :: Set.T -> Int foo = Set.size instead of import Data.Set as Set and trusting to luck that there is no other data type in scope with the name Set, or having to use Set.Set which looks wierd. It probably goes without saying that with the use of qualified imports, symbols are absolutely gross and should be avoided at all costs. They're totally unreadable, not just because they're a squiggly unpronouncable mess, but because you need to simulate an operator parser in your head to discover what's being applied to what. Someone could even define <+> to bind tighter than <*>, so it's not even safe to rely on normal conventions, and different modules in a program could use the same symbol in totally different ways with different precedences, leading to a real headache and unnecessary bugs when jumping between code in an editor. For readable code, plenty of descriptive words and parentheses are surely preferable. The only exception I'd make is the use of >>=, >> (which is so fundamental the alternative do notation is built into the language), ($), ($!), (.), and common arithmetic ops. Returning to Data.Set, let's now consider some of the names that are used: null :: Set a -> Bool empty :: Set a (null) tests to see whether or not a set is empty, and (empty) is the empty set. The relationship between the words "null" and "empty" can only be found by looking in an English dictionary. I propose that linguistic relationships should never feature in names used in programming. Instead the relationships should always be expressed as far as possible in the forms of the identifiers as sequences of characters. Having a clear unified framework to create names would also help not only the library author but also library users. Thus I propose that (null) should actually have been called "isEmpty", so that the relationship with the use of (empty) to denote the empty set is immediately apparent, and the use of the word "is" would immediately tell you that the function is a predicate. It might even be advantageous to reserve more characters for use in identifiers (since the infamous ASCII symbols are so abhorrent anyway ;-) ) so we could have a similar rule to Scheme, that predicates would end with a question mark thus relieving us of the need to decide between "is" and "has" (to try and eliminate as much of the messiness and indecision caused by natural language as possible), though of course this would be a more long term idea eg: -- So related things appear alphabetically together... empty? :: Set a -> Bool empty :: Set a It could be argued that it would be more in keeping with left-to-right thinking to put the '?' first but then we'd lose the "related things should be together in any alphabetical list of functions/values", though such a compromise is already necessary when using "isEmpty" rather than "emptyIs" which would perhaps just sound too unnatural ;-) Moving on to Data.List, we find a confusion of different spatial, temporal, and historical viewpoints jostling valiantly for supremacy in the programmer's mind: head tail -- funny cartoon-like image of a list last init -- temporal foldl foldr -- spatial (left to right) Despite the fact that (last, init) is somehow the dual of (head, tail), we have to switch from a temporal conception of a list to a historical "cartoon" conception to move between them. Then we come to foldl, foldr where we think in terms of left and right. Also, with foldl, foldr, it is just lucky that we already know there is a word called "fold" so that we know the trailing "r" or "l" is intended to be a suffix - it's not nearly so clear in cases like "reducer" and "reducel" where "reducer" is also a single word in English. Therefore I propose that for a list there should only be one underlying concept, that of a spatial sequence going from left to right, and that all functions should be named in accordance with this alone ie: atL atLs -- similar to (x:xs) atR atRs foldL foldR thus there would only be one concept (the spatial sequence) to grasp which the programmer could then map internally onto another concept such as time if required, without being forced by the names in Data.List to jump confusingly between them. A discussion of naming in Data.List would certainly be incomplete without a mention of (nub). It must surely rank as one of the most peculiar identifiers in the whole history of programming. The documentation thankfully explains that it means "essence", but then goes on to say that it is in fact just a function for removing duplicates from a list. The mind can only convulse in the most tortuous configurations to try and reverse engineer this strange correspondence. Would the simple name (removeDuplicates) or even (asSet) not be much easier all round? Related to lists, we of course have sequences and there, instead of cons and snoc, we could just have pushL and pushR which are nice logical names that don't conjure up images of candles and devils crawling out of mirrors etc like the use of reversed spelling in "snoc". In case the above seems overly critical of other people's hard work and good intent, I'd like to confess that I myself am often tempted off the path when it comes to the creation of identifiers involving adjectives eg: type BlueCar = ... type RedCar = ... The problem here is that these names, presumably both to do with "Car", are not going to appear next to each other in any alphabetical listing (if there are other names too), whereas: type CarBlue = ... type CarRed = ... will. Thus the position of the adjective in natural language (in this case English) has to be ignored if you want a programming environment to display related things together. Finally, as a piece de resistance :-), consider the following two definitions of (>>=) for the continuation monad: newtype Cont r a = Cont { runCont :: (a -> r) -> r } m >>= k = Cont $ \c -> runCont m $ \a -> runCont (k a) c -- (1) Cont a_r_r >>= a_C_b_r_r = Cont $ \ b_r -> a_r_r (\a -> runCont (a_C_b_r_r a) b_r) -- (2) In (1), we have to know what the associativity of ($) is (and this is a real fire bed of controversy!) and the variable names, apart from (a), don't give us the faintest clue what's going on, and in fact are doubly confusing because (m) is used to represent a value of type (m a) so there is a kind of kind error in the value name. In contrast, (2) uses the simple convention that the type is reflected more or less directly in the name so that a_r_r means a value of type (a->r)->r (there is unfortunately no way to indicate bracketing in the name). Thus by reading the definition we can understand what's going on just by cancelling out components of the name thus: a_C_b_r_r a gives us C_b_r_r and runCont (C_b_r_r) gives us b_r_r and (b_r_r b_r) gives us (r) so it's obvious that we're supplying an argument of type a->r to a_r_r as required. A great thing about Haskell is that it's quite simple to start renaming things already without having to change existing modules. In my own code I've simply just created new modules for IORef and Unique that re-export the original module contents but with the unsuffixed names, then I import from a hierarchy optimistically called "Prime" instead of the normal hierarchy :-) Having said all this, it's nevertheless an open question to me, regarding the meeting between human psychology and the desire for consistent logical naming conventions, if perhaps the rapid jumping between different viewpoints encountered in the functions in Data.List etc has a stimulating effect on the imagination in terms of encouraging mobility of thought and a danger with fully rationalised names could be that they may make one dry and brittle - though at least there would be no danger of a headless fire breathing dragon emerging from a mirror because you've just typed "cons" backwards.... :-) Regards, Brian. [1] http://haskell.org/hawiki/UsingQualifiedNames (bottom of the page) -- Logic empowers us and Love gives us purpose. Yet still phantoms restless for eras long past, congealed in the present in unthought forms, strive mightily unseen to destroy us. http://www.metamilk.com

2 3

Problems trying to understand the BSD license
by Brian Hulley 04 Sep '06

04 Sep '06

Hi - I'm not sure if this is the right place to ask this question but since a lot of Haskell code is under the BSD license I think the answer could be useful for other people as well. The question I have is if I want to redistribute a binary executable under my own proprietary license that uses code from various BSD libraries, what exact text do I need to add to my license to satisfy the BSD licenses that came with the libraries? Is the code that is part of the executable considered to be a redistribution of the library in binary form? Also consider this apparent contradiction: Copyright (c) 1988 XYZ ... 1) Redistributions of source code... 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3) Neither the name of XYZ nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. In order to comply with 2), it suggests I'd need to insert something along the lines of: Portions of this software are copyrighted by XYZ, PQR, STU, ... Portions of this software are provided by XYZ, ..., "as is" and any express or implied warranties ... but does this infringe on 3), which states that the name of XYZ should not be used to endorse the product? Ie is the mention of XYZ's name in the license considered to *not* be an endorsement? And what about "this list of conditions"? Does that also include the first condition ("Redistributions of source code ...") even though only a binary executable is being supplied to the licensee? I also don't want the licensee to get confused and think the whole executable is being distributed under BSD. Also what about the application's "about" dialog or help pages? Would an acknowledgement of libraries used in the code and their authors be considered to be using them to endorse my product or would it be regarded as a welcome acknowledgement for their hard work in making the libraries available? Is this required or prohibited by the BSD license? Surprisingly, although I have looked at several websites which discuss the BSD license, none of them actually say what the practical down to earth text of a proprietary license of a binary executable using BSD licensed components is supposed to look like. Any ideas? Thanks, Brian. -- Logic empowers us and Love gives us purpose. Yet still phantoms restless for eras long past, congealed in the present in unthought forms, strive mightily unseen to destroy us. http://www.metamilk.com

2 2

A free monad theorem?
by Benjamin Franksen 04 Sep '06

04 Sep '06

I'd like to know if the following reasoning can be made more precise: As we all know, the monadic bind operation has type: bind :: Monad m => m a -> (a -> m b) -> m b My intuition says that in order to apply the second argument to some non-trivial (i.e. non-bottom) value of type a, the bind operator needs to be able to somehow 'extract' a value (of type a) from the first argument (of type m a). I would like to argue that this is because bind is polymorphic in a, which makes it impossible to construct values of type a 'out of thin air' (besides bottom). Thus, however bind is defined, the only place where it can obtain a 'real' value of type a is from its first argument. Although one might think that this implies the existence of some function extract :: Monad m => m a -> a it is obvious that this is too limiting, as the IO monad plainly shows. Even monads that can be implemented in Haskell itself (the vast majority, it seems) usually need some additional (monad-specific) argument to their 'extract' (or 'run') function. However, even a value of type IO a /does/ produce a value of type a, only the 'value producing computation' is not a (pure) function. But how can all this be made more precise with less handwaiving? The background for my question is an argument I had some time ago with someone about what the 'real nature' of monads is. He argued that monads are mainly about 'chaining' (somehow wrapped up) values in an associative way, refering to the monad laws. I argued that monadic values get 'chained' in a very specific way and that in order to get an intuition about what this monadic chaining really means on the most general level, the standard model of 'computation that returns a value of type a' is the appropriate one. I tried to use the above (handwaving) argument to convince him (and myself) that this model is indeed 'the right one'. Furthermore, if it really is, then one might conjecture that for /every/ monad there must be some natural interpretation as the representation of some kind of computation (effectful or not). So my second question is: Are there known 'counter-examples' where this intuition breaks down, i.e. monads for which a computational interpretation is unknown or at least obscure enough not to qalify as 'natural'? Cheers, Ben

12 27

Re: [Haskell-cafe] practice problems?
by Paul Johnson 03 Sep '06

03 Sep '06

"Brian Hulley" <brianh(a)metamilk.com> wrote: What about a library for interval arithmetic [1]? I'd imagine it could start something like: data Interval a = Interval !a !a deriving (Eq, Show) instance Num a => Num (Interval a) where Interval llow lhigh + Interval rlow rhigh = Interval (min llow rlow) (max lhigh rhigh) The Interval type would probably need to explicitly represent several kinds of intervals eg (-infinity, x] etc and there are some tricky issues about what to do with the operations whose result sometimes needs to be represented by more than one interval to be useful such as division by an interval containing zero eg you might want to use a list of intervals to deal with these cases: instance Num a => [Interval a] where ... ie [Interval 5 5] / [Interval -1 1] = [FromNegInfinityTo -5, ToPosInfinityFrom 5] Take a look at my Ranged Sets library at http://sourceforge.net/projects/ranged-sets Paul.

2 1

beginner's problam with a monad
by Julien Oster 03 Sep '06

03 Sep '06

Hello, after succeeding in implementing my first monad (Counter, it increments a counter every time a computation is performed) I though I'd try another one and went on to implement "Tracker". "Tracker" is a monad where a list consisting of the result of every computation is kept alongside the final value, kind of a computation history. It really just serves me as an exercise to implement monads. However, the following source code fails: {-------------------------------------------------} data Tracker a b = Tracker [a] b deriving Show instance Monad (Tracker a) where m >>= f = let Tracker l x = m in let Tracker l' x' = f x in Tracker (x':l) x' return x = Tracker [] x bar = do x <- Tracker [] 12 y <- return (x*2) z <- return (y*3) return (z+3) {-------------------------------------------------} Of course, style recommendations and the like are always appreciated. (by the way, I don't really understand why I have to type instance Monad (Tracker a) instead of instance Monad Tracker which may very well be the problem. If it's not, can someone tell me anyway?) Trying to load this piece of code leads to the following error message: Hugs.Base> :load Test.hs ERROR "Test.hs":30 - Inferred type is not general enough *** Expression : (>>=) *** Expected type : Monad (Tracker a) => Tracker a b -> (b -> Tracker a c) -> Tracker a c *** Inferred type : Monad (Tracker a) => Tracker a b -> (b -> Tracker a a) -> Tracker a a Why does the interpreter infer Tracker a a instead of the more general Tracker a c? Thanks, Julien

4 5

[JOKE] Foozles: anatomy of a programming language fad
by Stephane Bortzmeyer 02 Sep '06

02 Sep '06

http://hope.cs.rice.edu/twiki/pub/WG211/M3Schedule/foozles.pdf I hope many Haskellers will have laugh here :-)

1 0

Re: [Haskell-cafe] state and exception or types again...
by Andrea Rossato 02 Sep '06

02 Sep '06

Il Wed, Aug 30, 2006 at 11:24:45AM +0100, Brian Hulley ebbe a scrivere: > Thanks, glad to be of help. I met Haskell a couple of months ago, when I switched my window manager to Ion. Tuomo Valkonen, its developer, uses darcs. Moreover he develops a small PIM, riot, written in Haskell. I wanted to play around with it but the source code was literally unreadable, for me. I could not understand a single line. I do some php. Lately I discovered Javascript and Lua, and I fell in love with their object-oriented capabilities. I'm not a real coder (though I develop a wiki in php), but I like getting to know new programming practices. I've been intrigue with functional programming for quite sometime but I just knew a bit of Scheme, because it's used as a scripting language in LilyPond (a package for writing music sheets). So I decided to spend my August holidays to study Haskell. I started reading some tutorial but could not understand what was going on. I then thought to take the long way: I watched the Abelson and Sussman's lectures and used ghci to (sort of) follow what they were doing. Coming from dynamic typed languages (I know very little C) the type system was horrible. Monads seemed mysterious objects. I've read in the "Yet Another..." that the Haskell community is very supportive. With your help I have now a different perspective. Playing with Haskell is like completing a puzzle, whose pieces' shapes are made up with rules that, at first, you seem not be able to grasp. You keep pushing the last piece, and it just doesn't fit in. Then you realize that shapes are actually types. And when you start understanding the rules of type construction and type matching, now you can recognize the shapes of the pieces you are playing with. And start making rational guesses on where they should go. Now, when I see "Compiling ... Ok, modules loaded: " I feel like I ended up solving the puzzle. It's an amazing pleasure... Haskell and functional programming. Without you I couldn't do it. Thank you so much! The tutorial will have this outline: first we build a monad adding output, exception, and state. Then we use monad transformer to take out state and output and add debug, doing lifting, put(ing) and get(ing) by hand, to understand the central role of type matching/construction. We end up with the following code, that should clearly show all the previous (hand made) steps should lead. No lambda calculus inhere! Once again, thanks! Andrea -----The Final Evaluator---- module MyStateT where import Control.Monad.State hiding (State) data Term = Con Int | Add Term Term deriving (Show) type IOStack = [Output] type Output = String type Debug = [String] data EvalST = State {getIOS :: IOStack, getDebug :: Debug, getCount:: Int} deriving(Show) type Exception = String data MT a = Fail Exception | Done {unpackDone :: a } deriving (Show) type Eval s a = StateT s MT a instance Monad MT where return a = Done a m >>= f = case m of Fail e -> Fail e Done a -> f a instance Functor MT where fmap _ (Fail a) = Fail a fmap f (Done a) = Done (f a) emptyState = State [] [] 0 stopExecT exc = lift $ Fail exc catchT e = do st <- get let s = getCount st let es = getDebug st let o = getIOS st let exc = "Debug msg at Iteration " ++ show s ++ ": " ++ e put $ State o (exc:es) s printT :: Output -> Eval EvalST () printT o = do st <- get let s = getCount st let e = getDebug st let os = getIOS st let out = show s ++ " - " ++ o put $ State (out:os) e s incTcounter :: Eval EvalST () incTcounter = do st <- get let s = getCount st let e = getDebug st let o = getIOS st put $ State o e (s+1) evalT :: Term -> Eval EvalST Int evalT (Con a) = do incTcounter printT (formatLine (Con a) a) return a evalT (Add t u) = do a <- evalT t b <- evalT u incTcounter let out = formatLine (Add t u) (a + b) printT out case (a+b) of 42 -> do catchT "The Ultimate Answer Has Been Computed!! Now I'm tired!" return (a+b) 11 -> stopExecT "11.... I do not like this number!" otherwise -> return (a + b) formatLine :: Term -> Int -> Output formatLine t a = "eval (" ++ show t ++ ") <= " ++ show a printAll :: [String] -> IO () printAll [] = return () printAll (a:xs) = do print a printAll xs eval :: Term -> IO () eval exp = case execStateT (evalT exp) emptyState of Fail e -> print e Done (State a b c ) -> do printAll $ reverse a print $ show $ unpackDone $ evalStateT (evalT exp) emptyState case b of [] -> print $ "Iterations: " ++ show c _ -> do printAll $ reverse b print $ "Iterations: " ++ show c {- Some runs: *MyStateT> eval (Add (Add (Add (Add (Con 40) (Con 2)) (Add (Con 12) (Con 3))) (Con 3)) (Con 10)) "1 - eval (Con 40) <= 40" "2 - eval (Con 2) <= 2" "3 - eval (Add (Con 40) (Con 2)) <= 42" "4 - eval (Con 12) <= 12" "5 - eval (Con 3) <= 3" "6 - eval (Add (Con 12) (Con 3)) <= 15" "7 - eval (Add (Add (Con 40) (Con 2)) (Add (Con 12) (Con 3))) <= 57" "8 - eval (Con 3) <= 3" "9 - eval (Add (Add (Add (Con 40) (Con 2)) (Add (Con 12) (Con 3))) (Con 3)) <= 60" "10 - eval (Con 10) <= 10" "11 - eval (Add (Add (Add (Add (Con 40) (Con 2)) (Add (Con 12) (Con 3))) (Con 3)) (Con 10)) <= 70" "70" "Debug msg at Iteration 3: The Ultimate Answer Has Been Computed!! Now I'm tired!" "Iterations: 11" *MyStateT> *MyStateT> eval (Add (Add (Add (Add (Con 10) (Con 2)) (Add (Con 12) (Con 3))) (Add (Con 5) (Con 2))) (Con 2)) "1 - eval (Con 10) <= 10" "2 - eval (Con 2) <= 2" "3 - eval (Add (Con 10) (Con 2)) <= 12" "4 - eval (Con 12) <= 12" "5 - eval (Con 3) <= 3" "6 - eval (Add (Con 12) (Con 3)) <= 15" "7 - eval (Add (Add (Con 10) (Con 2)) (Add (Con 12) (Con 3))) <= 27" "8 - eval (Con 5) <= 5" "9 - eval (Con 2) <= 2" "10 - eval (Add (Con 5) (Con 2)) <= 7" "11 - eval (Add (Add (Add (Con 10) (Con 2)) (Add (Con 12) (Con 3))) (Add (Con 5) (Con 2))) <= 34" "12 - eval (Con 2) <= 2" "13 - eval (Add (Add (Add (Add (Con 10) (Con 2)) (Add (Con 12) (Con 3))) (Add (Con 5) (Con 2))) (Con 2)) <= 36" "36" "Iterations: 13" *MyStateT> *MyStateT> eval (Add (Con 5) (Con 6)) "11.... I do not like this number!" *MyStateT> -}

2 3

Rewriting a Python application to Haskell
by basvandijk＠home.nl 02 Sep '06

02 Sep '06

Hello, The company I work for [1] develops highly sensitive trace gas detectors. We also develop software that is used to control these detectors from a PC or laptop. With this software a user can setup an experiment, execute it and analyse and visualise the data in real-time. While executing, the application gives commands to the detector and gets concentrations from the detector which it plots. See [5] for a screenshot. The application is written in Python and uses wxPython for its GUI. The software is highly threaded; The experiment executor, the analyzer, the communication system and the GUI all have their own threads. In order to synchronise these threads we make extensive use of locks [2]. This thread synchronisation mechanism worked fine in the beginning. However, as the application becomes more complex, it is increasingly difficult not to introduce bugs that are caused by forgetting to release or acquire locks. Also the use of locks makes the code hard to understand. Finally it's hard to compose functions that use locks. I've long been interested in Haskell and played around with it for some time. Recently I became aware of the Haskell STM implementation [3]. I think STM can solve my thread synchronisation problems. Because of this and because I would like to know how suitable Haskell is for developing real-world GUI applications, I would like to rewrite our application in Haskell (in my free time of course ;-) ). I think I need to use wxHaskell for the GUI because it's runs on a lot of platforms and we are currently using wxPython which should make the transition easier. 1) I would like to know if its difficult to use wxHaskell and STM side by side and if there are any issues I need to know about. 2) Also, we use pySerial [4] for serial communication with the detector. Is there something like that for Haskell or is it easy to make it yourself? 3) How portable is Haskell? We like to run our application on Mac, Windows and Linux. Greetings, Bas van Dijk [1] http://www.sensor-sense.nl [2] http://docs.python.org/lib/lock-objects.html [3] http://haskell.org/ghc/docs/latest/html/libraries/stm/Control-Concurrent-ST… [4] http://pyserial.sourceforge.net [5] http://members.home.nl/basvandijk/vc-screenshot.png

4 4

Re: [Haskell-cafe] getContents and lazy evaluation
by Donn Cave 02 Sep '06

02 Sep '06

Quoth Julien Oster <haskell(a)lists.julien-oster.de>: ... | But what happens when two processes use the same file and one process is | writing into it using lazy IO which didn't happen yet? The other process | wouldn't see its changes yet. That's actually a much more general problem, one that I imagine applies to hPutStr et al. too. Application level writes are ordinarily buffered in process space by the I/O library, so output from an ordinary C program may not appear on disk (or in kernel space disk I/O buffer) until just before the program exits. | As for two processes writing to the same file at the same time, very bad | things may happen anyway. Sure, lazy IO prevents doing communication | between running processes using plain files, but why would you do | something like that? Quite a few reasons, depending on how you define communication. You might even be tempted to use hGetContents in such cases. For example, one common way to share a file is to interlock around some resource, and when you acquire the lock, you read the file (get its contents) and release the lock. Donn Cave, donn(a)drizzle.com

1 0

Re: Exercise in point free-style
by John Hughes 02 Sep '06

02 Sep '06

> From: Julien Oster <haskell(a)lists.julien-oster.de> > Subject: [Haskell-cafe] Exercise in point free-style > > I was just doing Exercise 7.1 of Hal Daumé's very good "Yet Another > Haskell Tutorial". It consists of 5 short functions which are to be > converted into point-free style (if possible). > > It's insightful and after some thinking I've been able to come up with > solutions that make me understand things better. > > But I'm having problems with one of the functions: > > func3 f l = l ++ map f l > > Looks pretty clear and simple. However, I can't come up with a solution. > Is it even possible to remove one of the variables, f or l? If so, how? > > Thanks, > Julien Oh, YES!! Two ways to remove l: func3a f = uncurry ((.map f).(++)) . pair func3b f = uncurry (flip (++).map f) . pair And just to make sure they're right: propab new f l = func3 f l == new f l where types = f :: Int->Int quickCheck (propab func3a) quickCheck (propab func3b) If you don't mind swapping the arguments, then propc f l = func3 f l == func3c l f where types = f :: Int->Int func3c l = (l++) . (`map` l) With the arguments swapped, you can even remove both! propd f l = func3 f l == func3d l f where types = f :: Int -> Int func3d = uncurry ((.(flip map)) . (.) . (++)) . pair MUCH clearer! The trick is to observe that l is duplicated, so you need to use a combinator that duplicates something. The only one available here is pair, which you then have to combine with uncurry. It would be nicer to have (f &&& g) x = (f x,g x) available. (&&& is one of the arrow combinators). Then you could remove l by func3e f = uncurry (++) . (id &&& map f) which is sort of readable, and remove both by func3f = (uncurry (++).) . (id &&&) . map John

3 2

data structures question
by Tamas K Papp 01 Sep '06

01 Sep '06

Hi, Having read some tutorials, I would like to start using Haskell "for real", but I have some questions about data structures. The mathematical description of the problem is the following: assume there is a function V(a,b,theta), where a and b can have two values, High or Low, and theta is a number between zero and n (n is given). The range of V is the real numbers. Then there is an algorithm (called value iteration, but that's not important) that takes V and produces a function of the same type, called V'. The algorithm uses a mapping that is not elementwise, ie more than the corresponding values of V are needed to compute a particular V'(a,b,theta) -- things like V(other a,b,theta) and V(a,b,theta+1), where data State = Low | High other :: State -> State other High = Low other Low = High Question 1: V can be represented as a 3-dimensional array, where the first two indices are of type State, the third is Int (<= n). What data structure do you suggest in Haskell to store V? Is there a multidimensional array or something like this? Let's call this structure TypeV. Question 2: I would like to write valueit :: TypeV -> TypeV valueit V = mapondescartesproduct [Low,High] [Low,High] [0..n] mapV where -- mapV would calculate the new V' using V -- mapV :: State -> State -> Int -> Double to fill the new data structure. How to do this sensibly? Thanks, Tamas

6 12

HaXml question
by Tim Newsham 01 Sep '06

01 Sep '06

I thought this one would be easy but I'm starting to think its not. I am playing with HaXml and I want to transform an XML tree into another tree. The transforms are simple enough, but the kicker is that I want them to be "stateful." In this example, the state is a random number generator. So the transformation depends on the current node and the random number generator state. I want to transform every node in the tree. My feeble attempt at this is given in: http://www.thenewsh.com/~newsham/x/tweaker.hs What I see when I run it is that the value of "p" in the "tweak" function is identical each time. Indeed, it seems "g" itself is the same each time "tweak" is invoked (I wrote a variant of the program that used sequential integers instead of generators to verify this). So here's what I think is going on. You can probably skip this section because I am probably off base anyway... I guess "keep" is being applied to one node, and returning a list of 1 node, and this is zipped with my infinite list of generators and as a result I get the same generator each time. If this is the case I guess foldXml is not the right tool for this job. Perhaps I want a newly-written foldXml that works with LabelFilters rather than CFilters? Ok.. so what's really going on here. Can I do what I want to do? Whats the right tool to transform every node in the tree? Is there a more general approach to doing stateful transformations? Thanks in advance for letting me waste your time. P.S. any stylistic advice, or alternate approaches also welcome. The objective here is to learn... Tim Newsham http://www.thenewsh.com/~newsham/

2 1

[Parsec] A combinator to match between M and N times?
by Stephane Bortzmeyer 31 Aug '06

31 Aug '06

Parsec provides "count n p" to run the parser p exactly n times. I'm looking for a combinator "countBetween m n p" which will run the parser between m and n times. It does not exist in Parsec. Much to my surprise, it seems quite difficult to write it myself and, until now, I failed (the best result I had was with the "option" combinator, which unfortunately requires a dummy value, returned when the parser fails). Does anyone has a solution? Preferrably one I can understand, which means not yet with liftM :-)

7 16

Re: [Haskell-cafe] monads once again: a newbie perspective
by Andrea Rossato 31 Aug '06

31 Aug '06

Il Thu, Aug 31, 2006 at 02:39:59PM +0100, Simon Peyton-Jones ebbe a scrivere: > Andrea > > Don't forget to link to it from here! > http://haskell.org/haskellwiki/Books_and_tutorials#Using_monads Simon, I'll do. But now the text is far from being complete: there's only the code... (the most difficult part, for me at least!). Thanks for your kind attention. Andrea

1 0

Haskell for hp-ux (ia64)
by Green Bryan - bgreen 31 Aug '06

31 Aug '06

Does anyone know of a binary for hp-ux (ia64)? I have permission from my company to try and go forward with using Haskell for development with my team. But, we are running hp-ux on a 16 processor(ia64) box and I can't find a build for it. B Green ************************************************************************* The information contained in this communication is confidential, is intended only for the use of the recipient named above, and may be legally privileged. If the reader of this message is not the intended recipient, you are hereby notified that any dissemination, distribution or copying of this communication is strictly prohibited. If you have received this communication in error, please resend this communication to the sender and delete the original message or any copy of it from your computer system. Thank you. *************************************************************************

1 0

Galois Connections seeking a developer
by Isaac Jones 31 Aug '06

31 Aug '06

Galois is seeking a full-time candidate for software development and systems integration in the field of high assurance computing. A successful candidate should have a good understanding of the inner workings of databases, good development skills in a number of languages, including at least one functional language (preferably Haskell), and web development. The candidate should have excellent Linux and Unix skills. If the candidate does not know Haskell, they should be good at learning new programming languages, and can reasonably expect to be fluent in Haskell within a few months. Tasks: * Database analysis * Python and PHP web development * Learning and adapting Linux-related technologies including Xen, SELinux, and Knoppix * Creating or modifying Debian packages * Haskell development Knowledge: * Databases implementation internals * Web development, Services-Oriented Architectures * Fluent in Haskell or other functional languages * Grounding in computer security * XML * Linux and Unix Nice-to-have: * Extreme Programming (XP) development experience * Experience deploying software products * Open source software development experience * Ability to get US security clearance Education: * Masters degree or equivilent experience Please respond with a resume and a cover letter explaining your fit to jobs(a)galois.com. Feel free to forward to interested parties. peace, isaac

1 0

haskell -> fpga
by Matthew Pocock 30 Aug '06

30 Aug '06

Hi, Does anybody know of any compilers that can compile portions of a haskell program to an FPGA? I have found a few domain-specific languages implemented in haskell for FPGAs, but so far no back-ends for compilers like ghc. Thanks, Matthew

2 1

monadplus as monoid, safe?
by Nicolas Frisby 30 Aug '06

30 Aug '06

I'm using the following code in some of my projects: > newtype MonadPlusAsMonoid a = MPM { unMPM :: a } > instance MonadPlus m => Monoid (MonadPlusAsMonoid (m a)) where > mempty = MPM mzero > MPM l `mappend` MPM r = MPM (l `mplus` r) Is there some sort of pitfall I'm not considering? It seems fine to me, but I ask because I couldn't find this instance in the darcs repo for the next base library package. I expected to find it there because it has similar instances for numbers as monoids (e.g. Sum and Product from Data.Monoid). Thanks, Nick

1 1

How to force HTML (rather than XML) output from Haskell XML Toolbox?
by Dimitry Golubovsky 30 Aug '06

30 Aug '06

Hi, I am developing a code that reads a HTML page (template), modifies it (adds some stuff) and then writes the output file which is to be HTML, not XML. I use hxt-5.3 (but I may upgrade if necessary). It is desired to preserve the original HTML template pieces maximally close to the original. But output appears to be closer to XML rather than HTML. The code I use: ==================== let attrs = [(a_parse_html, "1"), (a_output_xml, "0"), (a_encoding, utf8)] (res, err, rc) <- getXmlDocument attrs (fromJust $ tmplPath dopt) putXmlDocument attrs (fromJust $ outPath dopt) res ===================== for this input HTML file: ===================== <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <title>Empty Page Template for Haskell Applications</title> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> </head> <body> </body> </html> ===================== outputs: ===================== <html> <head> <title>Empty Page Template for Haskell Applications</title> <meta http-equiv="content-type" content="text/html; charset=UTF-8"/> </head> <body> </body> </html> ===================== which is close but not exactly as wanted. The <meta> (and I expect other tags like <br> will have the same) tag has closing slash as it would have in XML (XHTML), but not in HTML. Also the DOCTYPE has been lost. Is this something hxt is not able to provide, or just a bug fixed since 5.3? Or should I write my own output code (because I am guessing, hxt functionality regarding manipulation over XML trees is sufficient for what I need)? Or should I use another package? -- Dimitry Golubovsky Anywhere on the Web

3 3

state and exception or types again...
by Andrea Rossato 30 Aug '06

30 Aug '06

Hello! Sorry if I keep bothering, but I'm still trying to understand types and monads. Now I'm trying to create a statefull evaluator, with output and exception, but I'm facing a problem I seem not to be able to conceptually solve. Take the code below. Now, in order to get it run (and try to debug) the Eval_SOI type has a Raise constructor that produces the same type of SOIE. Suppose instead it should be constructing something like Raise "something". Moreover, I wrote a second version of >>=, commented out. This is just to help me illustrate to problem I'm facing. Now, >>= is suppose to return Raise if "m" is matched against Raise (second version commented out). If "m" matches SOIE it must return a SOIE only if "f a" does not returns a Raise (output must be concatenated). I seem not to be able to find a way out. Moreover, I cannot understand if a way out can be possibly found. Something suggests me it could be related to that Raise "something". But my feeling is that functional programming could be something out of the reach of my mind... by the way, I teach Law, so perhaps you'll forgive me...;-) If you can help me to understand this problem all I can promise is that I'll mention your help in the tutorial I'm trying to write on "the monadic way"... that seems to lead me nowhere. Thanks for your kind attention. Andrea the code: data Eval_SOI a = Raise { unPackMSOIandRun :: State -> (a, State, Output) } | SOIE { unPackMSOIandRun :: State -> (a, State, Output) } instance Monad Eval_SOI where return a = SOIE (\s -> (a, s, "")) m >>= f = SOIE (\x -> let (a, y, s1) = unPackMSOIandRun m x in case f a of SOIE nextRun -> let (b, z, s2) = nextRun y in (b, z, s1 ++ s2) Raise e1 -> e1 y --Is it right? ) -- (>>=) m f = case m of -- Raise e -> error "ciao" -- why this is not going to happen? -- SOIE a -> SOIE (\x -> -- let (a, y, s1) = unPackMSOIandRun m x in -- let (b, z, s2) = unPackMSOIandRun (f a) y in -- (b, z, s1 ++ s2)) incSOIstate :: Eval_SOI () incSOIstate = SOIE (\s -> ((), s + 1, "")) print_SOI :: Output -> Eval_SOI () print_SOI x = SOIE (\s -> ((),s, x)) raise x e = Raise (\s -> (x,s,e)) eval_SOI :: Term -> Eval_SOI Int eval_SOI (Con a) = do incSOIstate print_SOI (formatLine (Con a) a) return a eval_SOI (Add t u) = do a <- eval_SOI t b <- eval_SOI u incSOIstate print_SOI (formatLine (Add t u) (a + b)) if (a + b) == 42 then raise (a+b) " = The Ultimate Answer!!" else return (a + b) runEval exp = case eval_SOI exp of Raise a -> a 0 SOIE p -> let (result, state, output) = p 0 in (result,state,output) --"Result = " ++ show result ++ " Recursions = " ++ show state ++ " Output = " ++ output --runEval (Add (Con 10) (Add (Con 28) (Add (Con 40) (Con 2))))

3 10

'Compiling' expression graph into Arrows
by Daniel McAllansmith 30 Aug '06

30 Aug '06

Hello, I have a graph of function applications which I would like to 'compile' into an Arrow, specifically the SF Arrow from Yampa. I'd appreciate any advice on how I might go about this. The graphs, of which there will be many, will be constructed at runtime and will be executed for extended periods of time so execution time will dominate compilation time. The graphs might also need to be passed around and executed 'elsewhere', where 'elsewhere' will almost certainly be the same GHC version but maybe on different architectures. The hand-written 'compilation' in the attached file gives a rough idea of what I start with and what I need to end up with. I could just automate the hand-written process by generating the SFs and arrow-syntax blocks, write them into a file then call GHC... seems a bit cowboyish. Or, write the graph into a template file that has Template Haskell to generate the SFs and arrow-syntax blocks then call GHC... almost as cowboyish? Or, fold the graph up using loop and arr... probably the simplest, once I get rid of my sugar dependency and figure out how to use loop that is ;). Or, maybe I can actually get the expression graph into a GHC api representation somehow and let it work marvels of optimisation on the expression before turning it into an arrow. Any idea on the relative merits of these, or other ideas? Can GHC optimise arrow code much during compilation, or will code folded up at runtime using loop/arr be just as efficient? Could GHC condense the functions of multiple graph nodes into a single function for conversion to an SF arrow? Will the necessity of introducing delays rule out using GHC to simplify the raw expression? Thanks Daniel

1 0

state and exception or types again...
by tpledger＠ihug.co.nz 29 Aug '06

29 Aug '06

Andrea Rossato wrote: > > Now I'm trying to create a statefull evaluator, with output and > exception, but I'm facing a problem I seem not to be able to > conceptually solve. If a computation fails in your monad, do you still want to return a value of the result type? I'd expect not, and hence remove the 'a' from the 'Raise' constructor. data Eval_SOI a = Raise (State -> (State, Output)) | SOIE (State -> (a, State, Output)) The above is very similar to using the monad foundation classes: import Control.Monad.Error import Control.Monad.State hiding (State) import Control.Monad.Writer type Eval_SOI = ErrorT String (StateT State (Writer Output)) ...assuming that you're happy to send back a descriptive String when a computation fails. Have a look at the Control.Monad.Error source code, to see how 'instance Error a => Monad (Either a)' is defined. It's the sort of thing you were trying to do in your 'instance Monad Eval_SOI'. Regards, Tom

1 0

Win32-package and Windows error codes in exceptions
by Esa Ilari Vuokko 28 Aug '06

28 Aug '06

Hi, Recently, I've been annoyed how Win32-package throws user errors, ie String, on failures. The System.Win32-being rather low level, it often makes sense for caller to catch some specific errors. I don't really understand how, or if, I could extend System.IO.Error. unix- package uses it via Foreign.C.Error, which makes me wonder if the underlying functionality in there should be extended. Is the only or best choice to go for Dynamic exceptions? That introduces a subtle difference for (already existing) programs that rely on exceptions to be presentable via Show and default handler. Best regards, --Esa Ilari Vuokko

1 0

Re: [Haskell] Exists any null instruction in Haskell?
by Neil Mitchell 26 Aug '06

26 Aug '06

[Moving to haskell-cafe] Hi, > I want to know if it exists a null instruction (a instruction > that do anything Not really, since instructions don't "do anything" anyway - they only compute values. If you are in the IO monad then "return ()" is the do nothing. In the function world, "id" is the do nothing. In recursive list processing, then something like [] is probably the "base case" in a recursive function, so stops the recursivity. If you give a more concrete example, then maybe we can give you a better answer. Thanks Neil

1 0

OOP vs type classes: Everything is object?
by Bulat Ziganshin 26 Aug '06

26 Aug '06

Hello haskell-cafe, i've added section http://haskell.org/haskellwiki/OOP_vs_type_classes#Everything_is_object.3F which lists cases when we DON'T use type classes to emulate OOP classes features -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

1 0

Re: [Haskell-cafe] monads once again: a newbie perspective
by Andrea Rossato 26 Aug '06

26 Aug '06

Il Fri, Aug 25, 2006 at 01:13:58PM -0400, Cale Gibbard ebbe a scrivere: > Hey cool, a new monad tutorial! :) > > Just out of interest, have you seen my Monads as Containers article? > http://www.haskell.org/haskellwiki/Monads_as_Containers > > Let me know what you think of it. I find that often newcomers to > monads will find the container perspective easier to grasp before > moving on to treating monads as an abstraction of computation, but > that side of things needs coverage too. :) Sure I've read it! I must confess I find it difficult, though. I mean, the exemplification part is very interesting but, for me, it was too difficult to connect it to the code I was looking at. This is way I decided this approach: let's start building a monad and see what it is by actually looking it at work. The evaluator is a very simple piece of code, you can clearly see what it does. And then you start building up your knowledge by expanding it. Take into account that, for me, *writing* that tutorial is *the* way to get to grasp all the concepts behind the type system (and monads). As you can see in a thread below, I'm studying hard in order to find out the proper continuation of the tutorial, and for my learning. So far I'll be able to describe the code of a statefull evaluator that produces output. Then I'd like to add exception handling. Let's see if I'll be able to get that far... By the way, I'll soon add links to the other important tutorials on monads: yours, IO Inside, All about monads. At the I'd like to be able to link A Gentle introduction, the Haskell 98 Report and, why not, "Write yourself a Scheme in 48 hours". That will be it. Thanks for your kind attention. Andrea

2 1

difference between type and newtype
by Andrea Rossato 26 Aug '06

26 Aug '06

Hello! I cannot understand this piece of code: type Z = Int type T a = Z -> (a, Z) newtype T1 a = T1 (Z -> (a,Z)) mkT :: a -> T a mkT a = \x -> (a, x) mkT1 :: a -> b -> (a,b) mkT1 a = \x -> (a, x) why mkT is a type constructor and mkT1 seems not to be? thanks for your kind attention. Andrea

6 18

Space leak whilst implementing streams
by ephemeral.elusive＠gmail.com 26 Aug '06

26 Aug '06

Hello, I have been using arrows to implement stream processors. At first, I tried using the implementation presented in John Hughes' AFP arrows lectures. However, this appeared to have a space leak in its implementation of the left operator for ArrowChoice. I found a way to remove this space leak, however, I do not really understand why there was a space leak in the first place. I would really appreciate any light that could be shed on this. Below I include the AFP implementation (SF) and a modified implementation that no longer has the space leak (SF'). I am using ghc 6.4.2. Many thanks. import Control.Arrow import Data.Maybe main = test test = print (runSF p (repeat 1)) test' = print (runSF' p (repeat (Just 1))) -- heap profile appears to grow linearly for test, but not test' p :: ArrowChoice a => a Int (Either Int Int) p = arr Right >>> left (arr id) newtype SF a b = SF {runSF :: [a] -> [b]} instance Arrow SF where arr f = SF (map f) SF f >>> SF g = SF (f >>> g) first (SF f) = SF (unzip >>> first f >>> uncurry zip) instance ArrowChoice SF where left (SF f) = SF (\xs -> combine xs (f [y | Left y <- xs])) where combine (Left _:xs) (z:zs) = Left z :combine xs zs combine (Right r:xs) zs = Right r:combine xs zs combine [] _ = [] -- SF' does not exhibit the space leak newtype SF' a b = SF' {runSF' :: [Maybe a] -> [Maybe b]} instance Arrow SF' where arr f = SF' (map (maybe Nothing (Just . f))) SF' f >>> SF' g = SF' (f >>> g) first (SF' f) = SF' (maybe_unzip >>> first f >>> uncurry maybe_zip) where maybe_unzip = foldr mu ([],[]) where mu Nothing ~(xs,ys) = (Nothing:xs, Nothing: ys) mu (Just (x,y)) ~(xs,ys) = (Just x:xs, Just y: ys) maybe_zip = zipWith mz where mz (Just x) (Just y) = Just (x,y) mz Nothing Nothing = Nothing instance ArrowChoice SF' where left (SF' f) = SF' (\xs -> xs `combined` f (map drop_right xs)) where combined = zipWith merge_left drop_right Nothing = Nothing drop_right (Just (Left l)) = Just l drop_right (Just (Right _)) = Nothing merge_left Nothing Nothing = Nothing merge_left (Just (Left _)) (Just x) = Just (Left x) merge_left (Just (Right r)) Nothing = Just (Right r)

2 1

ghc profiling
by Jeff Polakow 25 Aug '06

25 Aug '06

Hello, When I compile my program without profiling: bash-3.1$ ghc --make -auto-all -prof -O -o analysis analysis.hs Chasing modules from: analysis.hs Compiling Main ( analysis.hs, analysis.o ) Linking ... everything works fine. However when I compile with profiling: bash-3.1$ ghc --make -auto-all -prof -O -o analysis analysis.hs Chasing modules from: analysis.hs Could not find module `Data.ByteString.Lazy.Char8': use -v to see a list of the files searched for (imported from analysis.hs) ghc complains about not finding the ByteString library. Is this supposed to hapen, and if so, is there a way to get profiling to work? thanks, Jeff -- This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.

2 1

USB Drivers in Haskell
by Jason Dagit 25 Aug '06

25 Aug '06

Hello, I recently became the owner a USB gadget that tracks movement via GPS and also tracks heart rate (it's a training device for athletes). This device comes with software that is windows only and...doesn't like up to it's potential (to put it politely). Being a programmer type and someone that prefers to use either linux or osx I quickly realized I should write my own software to use the gadget. Fortunately, the company that makes the device provides documentation to write drivers for the device (including a minimal example USB driver for win32). So then I looked around the net for a few open source things, such as open source drivers for the device or a Haskell library to help me start writing drivers for the gadget. I didn't see anything relevant after a few minutes of searching so I figure that means there isn't much. Did I miss a Haskell library for writing device drivers, specifically USB drivers? Would this be hard to write? I would prefer to support osx and linux at a minimum and I think it would be ideal to shoot for cross platform (win32, osx, linux and *bsd). I have this feeling that it could be done by writing platform specific wrappers using hsc2hs on each platform then bringing them together through a unified 'low' level Haskell api. The Haskell api would then be exposed as a module for application developers. Any thoughts? For the interested, the documentation I spoke of can be found here: http://www.garmin.com/support/commProtocol.html Thanks, Jason

2 2

A possible use for HSFFIG (FFIPKG) was USB Drivers in Haskell
by Dimitry Golubovsky 25 Aug '06

25 Aug '06

Bjorn Bringert wrote: >For cross-platform USB drivers, you may want to have a look at libusb >[1]. I have only used it under Linux, but it seems to support Linux, >*BSD and OS X. There also seems to be a win32 port [2]. A Haskell >binding to libusb would be very welcome. I'm just wondering, would FFIPKG or HSFFIG help out? I just looked at usb.h, and it does not seem to contain anything that would break HSFFIG (mainly C functions that take/return structures rather than pointers to structures, do). I am not very much interested personally in interfacing USB, but if anybody is, feel free to try FFIPKG out and ask questions. PS Sorry for such "self-advertising", but I believe that this tool could be helpful at least for prototyping bindings, so I'd appreciate any feedback. -- Dimitry Golubovsky Anywhere on the Web

1 0

a novice Alex question
by Xiong Yingfei 25 Aug '06

25 Aug '06

Hi, I am trying out Alex. I copied the calculator specification file from Alex's official document and changed the wrapper type from "basic" to "monad". However, after I generated the ".hs" file from the lexical specification and compiled the ".hs" file, I got the message "Variable not in scope: `alexEOF'". I cannot find explanation about this 'alexEOF' function in the document. Can any body be kindly enough to tell me what this function is? Should I write it myself or not? My lexical code is listed as the below. Thanks a lot. { module Lex where } %wrapper "monad" $digit = 0-9 -- digits $alpha = [a-zA-Z] -- alphabetic characters tokens :- $white+ ; "--".* ; let { \s -> Let } in { \s -> In } $digit+ { \s -> Int (read s) } [\=\+\-\*\/] { \s -> Sym (head s) } $alpha [$alpha $digit \_ \']* { \s -> Var s } { -- Each action has type :: String -> Token -- The token type: data Token = Let | In | Sym Char | Var String | Int Int deriving (Eq,Show) } -- Xiong, Yingfei (熊英飞) Ph.D. Student Institute of Software School of Electronics Engineering and Computer Science Peking University Beijing, 100871, PRC. Web: http://xiong.yingfei.googlepages.com

3 2

style question: Writer monad or unsafeIOToST?
by Gregory Wright 25 Aug '06

25 Aug '06

Hi, Thanks to the responses earlier from the list, the core of my simulator now happy processes tens of millions of state updates without running out of stack. The goal of the simulator is to produce a log of tag states, which can be analyzed to find statistics of how often the sensor tags in a particular state. (In the toy model below there is no external signal, so the log isn't very interesting yet.) For the moment, I am using the "big stick" approach of unsafeIOToST to write log messages. Since the only outputs of the program are the log messages, and invocations of "step" are ordered by the ST monad, it seems that unsafeIOToST is safe in this case, in the sense that the outputs will all be ordered the same as the actual state updates. I've tested the program test1.hs below and it quite fast (runs in just under 10 s, or about 10^6 state updates per second). I've considered using a WriterT monad to wrap the ST monad to produce a log. The problem with this seems to be ensuring that the log output is generated lazily so it can be incrementally output. A somewhat broken sketch is the program test2.hs below. I used a function from [String] -> [String] as the monoid to avoid the O(n^2) inefficiency of appending to a list, but my implementation of this may well be faulty. To my eye, the Writer monad should be a better way, since it encapsulates the logging process, separating it from other I/O that the program may do. On the other hand, I don't see an easy way to ensure that the log output is generated lazily so that it can be output incrementally. I think that the main issue is that until_ is building up a list of log strings, but that these aren't passed to the putStrLn until after the completion of the whole runTag function. ATM, running test2 gives a stack overflow. Could someone point out how the Writer monad could be adapted to this, or tell me that, "Real programmers just use unsafe* and get on with it" ? Best, greg ------------------------------------------------------------------------ ------------------------------ test1.hs, the big stick (unsafeIOToST): -- -- test1.hs, state updating with logging via unsafeIOToST. -- module Main where import Control.Monad.ST import Data.STRef import Maybe data TagState = Syncing | Listening | Sleeping deriving (Eq, Show) -- A structure with internal state: -- data Tag s = Tag { tagID :: ! Int, state :: ! (STRef s TagState), count :: ! (STRef s Integer) } data FrozenTag = FrozenTag { ft_tagID :: Int, ft_state :: TagState, ft_count :: Integer } deriving Show -- Repeat a computation until it returns Nothing: -- until_ :: Monad m => m (Maybe a) -> m () until_ action = do result <- action if isNothing result then return () else until_ action -- Here is a toy stateful computation: -- runTag :: ST s (FrozenTag) runTag = do tag <- initialize until_ (step tag) freezeTag tag initialize :: ST s (Tag s) initialize = do init_count <- newSTRef 1000000 init_state <- newSTRef Syncing return (Tag { tagID = 1, state = init_state, count = init_count }) step :: Tag s -> ST s (Maybe Integer) step t = do c <- readSTRef (count t) s <- readSTRef (state t) writeSTRef (count t) $! (c - 1) writeSTRef (state t) $! (nextState s) unsafeIOToST $! putStrLn ("next state is " ++ show s) if (c <= 0) then return Nothing else return (Just c) nextState :: TagState -> TagState nextState s = case s of Syncing -> Listening Listening -> Sleeping Sleeping -> Syncing freezeTag :: Tag s -> ST s (FrozenTag) freezeTag t = do frozen_count <- readSTRef (count t) frozen_state <- readSTRef (state t) return (FrozenTag { ft_tagID = tagID t, ft_count = frozen_count, ft_state = frozen_state }) main :: IO () main = do print $ runST (runTag) ------------------------------------------------------------------------ ----------------------------------------- test2.hs: stacked WriterT and ST monads: -- -- test2.hs, state updating with logging via the WriterT monad. -- module Main where import Control.Monad.ST import Control.Monad.Writer import Data.STRef import Maybe data TagState = Syncing | Listening | Sleeping deriving (Eq, Show) -- A type for combined logging and state transformation: -- type LogMonoid = [String] -> [String] type LogST s a = WriterT LogMonoid (ST s) a -- A structure with internal state: -- data Tag s = Tag { tagID :: ! Int, state :: ! (STRef s TagState), count :: ! (STRef s Integer) } data FrozenTag = FrozenTag { ft_tagID :: Int, ft_state :: TagState, ft_count :: Integer } deriving Show -- Repeat a computation until it returns Nothing: -- until_ :: Monad m => m (Maybe a) -> m () until_ action = do result <- action if isNothing result then return () else until_ action -- Here is a toy stateful computation: -- runTag :: LogST s (FrozenTag) runTag = do tag <- initialize until_ (step tag) freezeTag tag initialize :: LogST s (Tag s) initialize = do init_count <- lift $ newSTRef 1000000 init_state <- lift $ newSTRef Syncing return (Tag { tagID = 1, state = init_state, count = init_count }) step :: Tag s -> LogST s (Maybe Integer) step t = do c <- lift $ readSTRef (count t) s <- lift $ readSTRef (state t) lift $ writeSTRef (count t) $! (c - 1) lift $ writeSTRef (state t) $! (nextState s) tell (("next state is " ++ show s) : ) if (c <= 0) then return Nothing else return (Just c) nextState :: TagState -> TagState nextState s = case s of Syncing -> Listening Listening -> Sleeping Sleeping -> Syncing freezeTag :: Tag s -> LogST s (FrozenTag) freezeTag t = do frozen_count <- lift $ readSTRef (count t) frozen_state <- lift $ readSTRef (state t) return (FrozenTag { ft_tagID = tagID t, ft_count = frozen_count, ft_state = frozen_state }) main :: IO () main = do let (t, l) = runST (runWriterT runTag) putStrLn (show t) putStrLn (unlines (l []))

3 10

monads once again: a newbie perspective
by Andrea Rossato 25 Aug '06

25 Aug '06

Hello! I' m new to Haskell and try to find my way through types and monads. I tried the yet Another Haskell Tutorial, very useful for types, but almost unreadable for monads (that's my perspective!). Then I discovered that wonderful paper by Wadler (Monads for functional programming). So I started "translating it" for someone who can be scared of something with an abstract and footnotes coming from a professor. I started writing it in order to clarify to myself this difficult topic. I think I'm now grasping the concept of monads. I thought that someone else could find my writings useful. It could become a page on the wiki. But before posting there I would like to have your opinion. Perhaps this is just something unreadable. Let me know. Andrea

3 3

stack overflow when using ST monad
by Gregory Wright 24 Aug '06

24 Aug '06

Hi, I have a program, abstracted from a larger application that I am writing for a customer, that persistently overflows its stack. The program is a simulation of the communication protocol of a sensor tag. The code is below. The program mimics a hardware state machine. In the example below, the internal state is just a counter and a another register that holds what is called the tag's "state": Syncing, Listening or Sleeping. The simulation just advances the tags internal state until the counter reaches zero. (In the real application, there are external inputs that can change the state, but that's not needed to see the problem.) The simulation crashes, running out of stack space after only about 400000 cycles on my machine (OS X 10.4.7 ppc). Both hugs and ghci show it: hugs -98 Test2.hs Hugs mode: Restart with command line option +98 for Haskell 98 mode Type :? for help Main> main ERROR - Garbage collection fails to reclaim sufficient space Main> and ghci: Prelude> :load "/Users/gwright/src/haskell/simulator/test2.hs" Compiling Main ( /Users/gwright/src/haskell/simulator/ test2.hs, interpreted ) Ok, modules loaded: Main. *Main> main FrozenTag {ft_tagID = 1, ft_state = *** Exception: stack overflow *Main> Searches through old mailing lists warn me that it can be hard to tell if evaluation is truly tail recursive, and I saw a discussion of this in the context of "monadic loops", but I never saw a solution. Perhaps in my sleep deprived condition I am missing the obvious, but any help would be appreciated. Best, Greg -- -- Test the state transformer calculation. -- -- 21 August 2006 -- module Main where import Control.Monad.ST import Control.Monad.Writer import Data.STRef import Maybe data TagState = Syncing | Listening | Sleeping deriving (Eq, Show) -- A structure with internal state: -- data Tag s = Tag { tagID :: Int, state :: STRef s TagState, count :: STRef s Integer } data FrozenTag = FrozenTag { ft_tagID :: Int, ft_state :: TagState, ft_count :: Integer } deriving Show -- Repeat a computation until it returns Nothing: -- until_ :: Monad m => m (Maybe a) -> m () until_ action = do result <- action if isNothing result then return () else until_ action -- Here is a toy stateful computation: -- runTag :: ST s (FrozenTag) runTag = do tag <- initialize until_ (step tag) freezeTag tag initialize :: ST s (Tag s) initialize = do init_count <- newSTRef 1000000 init_state <- newSTRef Syncing return (Tag { tagID = 1, state = init_state, count = init_count }) step :: Tag s -> ST s (Maybe Integer) step t = do c <- readSTRef (count t) s <- readSTRef (state t) writeSTRef (count t) (c - 1) writeSTRef (state t) (nextState s) if (c <= 0) then return Nothing else return (Just c) nextState :: TagState -> TagState nextState s = case s of Syncing -> Listening Listening -> Sleeping Sleeping -> Syncing freezeTag :: Tag s -> ST s (FrozenTag) freezeTag t = do frozen_count <- readSTRef (count t) frozen_state <- readSTRef (state t) return (FrozenTag { ft_tagID = tagID t, ft_count = frozen_count, ft_state = frozen_state }) main :: IO () main = do putStrLn (show (runST runTag))

5 9

Fran - Functional Reactive Animation
by HIGGINS Neil (ENERGEX) 24 Aug '06

24 Aug '06

> Fran is a Haskell library (or "embedded language") for interactive > animations with 2D and 3D graphics and sound. See > <http://www.conal.net/fran/ <http://www.conal.net/fran/> > and > <http://research.microsoft.com/research/downloads/download.aspx?FUID=c9eff > 407-ce59-4a2a-90cb-de099a9bacbd > <http://research.microsoft.com/research/downloads/download.aspx?FUID=c9eff > 407-ce59-4a2a-90cb-de099a9bacbd> > > > I would like to use Fran as a rapid prototyping environment for > animations, but it appears to be broken under WinHugs. > > I'm looking for someone with much better Haskell prowess than myself who > might be able resurrect Fran under WinHugs. Unfortunately I can only offer > my gratitude in return. > > It's a long shot, I know. > Kind regards, > Neil Higgins > Snr Strategic Planning Engineer > ENERGEX > Em: neilhiggins(a)energex.com.au > Ph: 3407 4800 > Fx: 3407 4832 > ************************************************************************* This email message (including any file attachments transmitted with it) is for the sole use of the intended recipient(s) and may contain confidential and legally privileged information. Any unauthorised review, use, alteration, disclosure or distribution of this email (including any attachments) by an unintended recipient is prohibited. If you have received this email in error, please notify the sender by return email and destroy all copies of the original message. Any confidential or legal professional privilege is not waived or lost by any mistaken delivery of the email. ENERGEX accepts no responsibility for the content of any email which is sent by an employee which is of a personal nature. Sender Details: ENERGEX GPO Box 1461 Brisbane QLD Australia 4001 +61 7 3407 4000 http://www.energex.com.au ENERGEX policy is to not send unsolicited electronic messages. Suspected breaches of this policy can be reported by replying to this message including the original message and the word "UNSUBSCRIBE" in the subject. *************************************************************************

3 2

wiki page Arrays updated
by Bulat Ziganshin 24 Aug '06

24 Aug '06

Hello Haskell-Cafe, i've added a lot of low-level information to the Arrays wiki page. new material starts from note about GHC 6.6 in http://haskell.org/haskellwiki/Modern_array_libraries#StorableArray_.28modu… there are several details, however, which makes it imperfect. first, as usual, is my awkward English. please correct my language misuse. in particular, i don't know how to better name the page itself, meaning "modern library which implements many array types" second is that it will be great to add examples demonstrating each discussed concept: casting, freezing, unsafe indexing, [::]. we also still don't have examples for unboxed and diff arrays third is that i'm not 100% sure that information about GHC internals i provided is correct. can someone with a good knowledge of RTS internals check it, including http://haskell.org/haskellwiki/Modern_array_libraries#Welcome_to_machine:_A… and next section plus abovementioned link with information about StorableArray in GHC 6.6? -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

1 0