- Haskell-Cafe - Haskell.org

Haskell beginner
by arnuld 16 Mar '07

16 Mar '07

i want to start learning Haskell and willing to master it :-) i have done some Common Lisp from http://www.gigamonkeys.com/book/. so i know what are functions, variables, etc. BUT i have never done any real life programmming or any kind of software development. in my country no Haskell books are available :-( , hence i can only use online Tutorials. my main purpose is to learn real-life programming by contributing some "Haskell coding" to a GPLed Software written using Haskell. i have found "Yet Another Haskell Tutorial" after searching the archives. is it really a good idea to learn Haskell using only Online material ? (when one does not have any offline resources) -- http://arnuld.blogspot.com/

8 7

How do I avoid stack overflows?
by DavidA 16 Mar '07

16 Mar '07

Hi. I'm trying to write some code which involves lots of matrix multiplications, but whenever I do too many, I get stack overflows (in both GHCi 6.4.2, and Hugs May 2006). The following code exhibits the problem. import List (transpose) u <.> v = sum $ zipWith (*) u v a <<*>> b = multMx a (transpose b) where multMx [] _ = [] multMx (u:us) bT = map (u <.>) bT : multMx us bT id3 = [[1,0,0],[0,1,0],[0,0,1]] test = iterate (<<*>> id3) id3 !! 1000000 I tried to fix the problem using seq, as follows: iterate' f x = x : seq x' (iterate' f x') where x' = f x test' = iterate' (<<*>> id3) id3 !! 1000000 However, in both cases, the code causes stack overflows in both interpreters. (It sometimes kills GHCi, which I guess is a bug.) Any ideas? Thanks.

2 1

Foralls in records
by Adde 15 Mar '07

15 Mar '07

Hi. I'm experimenting with implementing database transactions as monads but I'm getting stuck on how to store a generic connection (only constrained by a typeclass) inside the transaction. The reason I'm doing it this way is that the connection could be a different kind of structure depending on what database the transaction is using. The goal is to enable all functions using the monad to extract the connection using getConnection. I realise I could probably get it running by adding a type parameter for the connection type to TransactionT and Transaction but I feel I shouldn't have to. All the compiler needs to know is that the contained value conforms to the interface of Connection. <code> data TransactionT = forall c. (Connection c) => TransactionT c data Transaction a = Transaction (TransactionT -> (a, TransactionT)) instance Monad Transaction where ... getConnection :: Transaction c getConnection = Transaction (\t@(TransactionT c) -> (c, t)) class Connection c where connectionExecute :: c -> String -> Transaction () execute :: String -> Transaction () execute s = connectionExecute getConnection s </code> I'm getting the following error: Couldn't match expected type `c' (a rigid variable) against inferred type `c1' (a rigid variable) `c' is bound by the type signature for `getConnection' at Database.hs:19:29 `c1' is bound by the pattern for `TransactionT' at Database.hs:20:33-46 In the expression: c In the expression: (c, t) In a lambda abstraction: \ (t@(TransactionT c)) -> (c, t)

5 11

Make strict (IO String) lazy
by Henning Thielemann 15 Mar '07

15 Mar '07

On the one hand, in the standard libraries there are functions like readFile, getContents, hGetContents which read a file lazily. This is often a nice feature, but sometimes lead to unexpected results, say when reading a file and overwriting it with modified contents. Unfortunately the standard libraries provide no functions for strict reading, and one has to do this manually. On the other hand, when I write some IO function that returns a String, I easily end up with a function which produces the String in a strict way. (Say I call some shell commands and concatenate their outputs.) What is the preferred way to turn a strict (IO String) into a lazy one? forkIO? forkOS? How would one derive readFile from a hypothetical strictReadFile?

3 2

SYB vs HList (again)
by S. Alexander Jacobson 15 Mar '07

15 Mar '07

Right now I am looking at using either SYB (Scrap Your Boilerplate) or HList Records to eliminate boilerplate for: * parsing URLEncoded strings into application data structures * generating XML/JSON from application data structures * handling adding new fields to serialized data structures * creating indexed collections of application data structures I am looking for insights from people here on which approach they think is better and why. Here are my current thoughts on the issue == Both HList and SYB require data structures redesign == HLists require you to define Labels and basically only use label values that are themselves either scalar or HLists. SYB basically requires the same thing except that you use data/newtype to define labels instead of HLists more cumbersome label constructions. == Defaults: HList gives you compile time errors, SYB only runtime errors == SYB does not seem to provide a way of having the compiler tell you that you are accessing a field that is unavailable in the type. HList will give you a type error if you do that. I don't know exactly how HList handles default values but I assume you can restrict use of those values to explicit deserialization contexts. Is that correct? == HList allows more informality == With HList you can specify the type of a record ad hoc using obj::(Record Foo .*. Bar .*.Baz). SYB requires that you define data structures in separate data declarations. It would be really nice if there was some way to tell Haskell that HLists have no more fields than the ones you happen to be getting and setting in your code. Effectively that would mean you get data structure inference not just function type inference which would be really cool! That is probably not possible but it couldn't hurt to ask (Oleg?). == SYB doesn't require template haskell to make it usable == With SYB you create field labels using newtype (or data) declarations e.g. data Salary = S {salary::Float} With HList, label declarations are really verbose e.g. data SalaryLabel deriving(Typeable) type Salary = Field (Proxy SalaryLabel) Int salary = proxy :: Proxy FooLabel You can make this more concise using TemplateHaskell but TH looks alien and adds fear to the use of any code. == Performance issues == SYB requires a linear traversal of all field elements using dynamic to get or transform a value. HList traverses an HCons list. I don't how bad this is as compared with traditional data structure access using pattern matching or field labels. My current bias is towards using HList because if we are going to force a conversion to a new data structure convention I'd rather have the typesystem on my side. With SYB it is too easy to let haskell field labels creep in to your data definitions and end up with subtle errors to correct. Any opinions on these issues would be very appreciated. -Alex-

2 1

Takusen and strictness, and perils of getContents
by oleg＠pobox.com 15 Mar '07

15 Mar '07

Takusen permits on-demand processing on three different levels. It is specifically designed for database processing in bounded memory with predictable resource utilization and no resource leaks. But first, about getContents. It has been mentioned a while ago that getContents should be renamed to unsafeGetContents. I strongly support that suggestion. I believe getContents should be used sparingly (I personally never used it), and I believe it cannot give precise resource guarantees and is a wrong model for database interfaces. I will not dwell on the fact that getContents permits IO to occur while evaluating pure code -- which is just wrong. There is a practical consequence of this supposedly theoretical impurity: error handling. As the manual states ``A semi-closed handle becomes closed: ... if an I/O error occurs when reading an item from the handle; or once the entire contents of the handle has been read.'' That is, it is not possible to tell if all the data from the channel have been read or an I/O error has interfered. It is not possible to find out any details about that I/O error. That alone disqualifies getContents from any serious use. Even more egregious is resource handling and that business with semi-closed handles, which is a resource leak. Interfacing with a database requires managing lots of resources: database connection, prepared statement handle, statement handle, result set, database cursor, transaction, input buffers. Takusen was specifically designed to be able to tell exactly when a resource is no longer needed and can be _safely_ disposed of. That guarantee is not available with getContents -- the resources associated with the handle are disposed when the consumer of getContents is finished with it. Since the consumer may be pure code, it is impossible to tell when the evaluation finishes. It may be in a totally different part of the code. To get more predictability, we have to add seq and deepSeq -- thus defeating the laziness we supposedly have gained with getContents, and hoping that two wrongs somehow make it right. Regarding Takusen: it is designed for incremental processing of database data, on three levels: -- unless the programmer said that the query will yield small amount of data, we don't ask the database for all of the result set at the same time. We ask to deliver data in increments of 10 or 100 rows (the programmer may tune the amount). The retrieved chunk is placed into pre-allocated buffers. -- the retrieved chunk is given to an iteratee one row at a time. The iteratee may at each point specify that it has had enough. The processing immediately stops, no further chunks are retrieved and all resources of the query are disposed of. -- Alternatively, Takusen offers the cursor-based interface, with getNext and getCurrent methods. The rows are retrieved on-demand in chunks. The interface is designed to restrict operations on a cursor to a region of code. Once the region is exited (normally or by exception), all associated resources are disposed of because they are statically guaranteed to be unavailable outside the region. Because the moments of resource allocation and deallocation are so well known, Takusen can take care of all of it. The programmer will never have to worry about resource leaks, deallocations, etc. A bit of experience: I have implemented a Web application server in Haskell, using Takusen as a back end. The server runs as a FastCGI dynamic server, retrieving a chunk of rows from the database, formatting the rows (e.g., in XML), sending them up the FastCGI interface and ultimately to the client, coming back for the next chunk. The advantage of that stream-wise processing is low latency, low memory consumption, and client limiting the database retrieval rate. Typical requests routinely ask for thousands of database rows; the server runs continuously serving hundred of requests, in constant memory. The executable is 2.6 MB in size (GHC 6.4.2); the running process takes VmSize of 6608 kB, including VmRSS of 3596 kB and VmData of 1412 kB. The code has not a single unsafePerformIO (and aside from an S-expression parsing code I inherited) I used not a single strictness annotation. The line count (including comments) is 7500 lines in 30 files.

3 6

Jaskell, has anybody tried it?
by Lars Johansson 15 Mar '07

15 Mar '07

Hello, I have installed the Jaskell libraries for java under Eclipse, but I can't get it running and the documentation on installing is really sparse. So any help I will apprreciate. Or any ideas! Sincerely Lars Johansson _________________________________________________________ Flyger tiden iväg? Fånga dagen med Yahoo! Mails inbyggda kalender. Dessutom 250 MB gratis, virusscanning och antispam. Få den på: http://se.mail.yahoo.com

1 0

principle types
by Vikrant 15 Mar '07

15 Mar '07

Hi, I can understand why principle type of map is map :: (a -> b) -> [a] -> [b] , I would interpret this as "map takes a function of type a->b and a list of type [a] as arguments and returns a list of type [b]" but it is going somewhat beyond my imagination why principle type of map map is (map map)::[a -> b] -> [[a] -> [b]] I am able to interpret the expressions "[a -> b] -> [[a] -> [b]]" vaguely... does this mean that 'map map' takes list of functions of type (a->b) and returns list of functions of type ([a]->[b]) if yes ..how do I derive it from basic type declaration of map? Thanks in advance Vikrant

4 4

Re: [Haskell] small boys performance
by Dan Piponi 15 Mar '07

15 Mar '07

On 3/14/07, Andrzej Jaworski <himself(a)poczta.nom.pl> wrote: > I am glad you are interested Dan. > ... > I do not intend to bore anybody with differential geometry but as I was > pushed that far let me add that if Haskell was made to handle Riemannian > geometry it could be useful in next generation machine learning research > where logic, probability and geometry meet. I believe that you can probably handle (pseudo-)Riemannian geometry in the framework sketched here: http://sigfpe.blogspot.com/2006/09/practical-synthetic-differential.html That only goes as far as playing with vector fields and Lie derivatives but I think that forms and tensors should fit just fine into that framework. There's a simple way to use types to represent tensor products, and that's sketched here: http://sigfpe.blogspot.com/2006/08/geometric-algebra-for-free_30.html (Forget that that's about geometric algebra, the thing I'm interested in is the tensor products.) So I'm guessing there's a way of combining these to give a framework for (pseudo-)Riemannian geometry. But it'd only be a good framework for answering certain types of questions - in particular for things like numerical simulation. The important thing is that you'd be able to read off accurate numerical values of quantities like curvatures without any need for symbolic algebra. -- Dan

2 1

Read Instance for UArray won't port to linux
by SevenThunders 15 Mar '07

15 Mar '07

I have the pleasure of porting a good sized Haskell application to linux. So far the Haskell code has compiled without incident, however some code that I hacked to implement a Read instance for Unboxed Arrays does not compile on linux even though it compiles just fine on Windows XP in Haskell 6.6. The code reads as, instance Read (UArray Int Double) where readsPrec p = readParen (p > 9) (\r -> [(array b as :: UArray Int Double, u) | ("array",s) <- lex r, (b,t) <- reads s, (as,u) <- reads t ]) The error in linux is: Illegal instance declaration for `Read (UArray Int Double)' (The instance type must be of form (T a b c) where T is not a synonym, and a,b,c are distinct type variables) In the instance declaration for `Read (UArray Int Double)' Why does it want three parameters for the instance type? I am baffled by this. -- View this message in context: http://www.nabble.com/Read-Instance-for-UArray-won%27t-port-to-linux-tf3400… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

8 10

How to convert Num a => a to Int
by Sergey Perminov 15 Mar '07

15 Mar '07

As a beginner I want to implement such fuction: plusSecs :: Num a => a -> ClockTime -> ClockTime plusSecs n = addToClockTime ( secTimeDiff (n) ) where secTimeDiff n = TimeDiff { tdYear = 0, tdMonth = 0, tdDay = 0, tdHour = 0, tdMin = 0, tdSec = n, tdPicosec = 0 } The problem here that it's type signature is illegal because tdSec of System.Time.TimeDeff must be Int type only, but I wish to apply plusSecs to any Num or (at least) any Integral type number. The reason for this - to have less compilation errors (that are mostly about error types) and more abstractedness (generality) of this function. So, the question is: Is it possible somehow to convert any Num (or at least Integral) to Int. Please, tell me if I don't get smth in Haskell type system.

3 2

Re: small boys performance
by apfelmus＠quantentunnel.de 15 Mar '07

15 Mar '07

-- redirected from haskell.general Andrzej Jaworski wrote: > As I regretfully pointed out earlier in [Fwd: Re: Computer Language > Shootout] > large search and simulations are not for Haskell. This is equally true with > GHC 6.5 http://eric_rollins.home.mindspring.com/haskellAnt.html. Indeed, directly translated ML code is not for Haskell. Or did you really expect Array (Int,Int) Double, ubiquitous tail recursion and accumulating nodes at the end of a list (nextPath = path ++ [nextCity]) to give you simulation wonders? Btw, there are a lot of opportunities for abstraction, separation of concerns and reuse in the code. There are much to many to list them all, but here are few: - Most importantly, iterations are best separated into generation and selection: bestPath = last . iterate (evolve) There is really no need (and it hurts performance, you know) to have this parameter hell. - By grouping paths with their total scores like in data Path = Path { nodes :: [Node], score :: Int } you can define a very convenient best :: Path -> Path -> Path that chooses the one with the greater score. More general, you can define maxBy :: (a -> Double) -> a -> a -> a maxBy f x y if f x >= f y then x else y - Considering a minor stylistic point, incrs = [ (fromIntegral boost) | n <- pairs ] pairsWithInc = zip pairs incrs is best known as pairsWithInc = zip pairs $ repeat (fromIntegral boost) - Abstraction from the concrete graph implementation enables switching from Array (Int,Int) Double to a sparse representation if demanded, namely a nested IntMap (IntMap Double). - etc. > calculating a tensors with symbolic indices (without components) > so that one could have components calculated for specific cases on the end > of general calculation. http://www.nt.ntnu.no/users/haugwarb/Programming/haskell_automatic_differen… Regards, apfelmus

1 0

Parallelism on concurrent?
by Dusan Kolar 14 Mar '07

14 Mar '07

Hello all, I'm googling around haskell.org to get some deeper knowledge about Control.Parallel.Strategies than it is presented on http://www.haskell.org/ghc/docs/latest/html/libraries/base/Control-Parallel… BTW, could someone point me to some more deeper doc. about it? During googling I've discovered that since GHC 6.6, par, forkIO, and forkOS should make the stuff run in parallel if I have more than one CPU core. Is that right? I think not, because on my machine only par makes the things run in parallel and only during the computation (GC runs in a single thread). If it should work, how can I verify that my installation is correct? If it should not work, will it be working someday? Thanks for your patience, responses, and tips Dusan

6 8

c2hs and pthreadtypes.h
by Magnus Therning 14 Mar '07

14 Mar '07

I'm trying to use c2hs but get stuck when including sys/types.h (though the problem really resides in pthreadtypes.h): % ./Setup.hs build -v Preprocessing executables for kowasu-0.1... /usr/bin/c2hs -C -D__GLASGOW_HASKELL__=606 -C -Icsrc -o src/Kowasu/PTrace.hs src/Kowasu/PTrace.chs c2hs: Error in C header file. /usr/include/bits/pthreadtypes.h:69: (column 6) [FATAL] >>> Syntax error! The symbol `;' does not fit here. The part of pthreadtypes.h where it chokes seems to be 65 __extension__ union 66 { 67 int __spins; 68 __pthread_slist_t __list; 69 }; 70 } __data; 71 char __size[__SIZEOF_PTHREAD_MUTEX_T]; 72 long int __align; 73 } pthread_mutex_t; Any pointers on how to solve this? (Besides manually resolving all defined types down to the C builtins.) /M -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus(a)therning.org Jabber: magnus.therning(a)gmail.com http://therning.org/magnus

4 4

Defining types (newbie)
by John Fouhy 14 Mar '07

14 Mar '07

Hi all, I studied Haskell a few years ago at uni, but I haven't used it since, so I'm a bit rusty. But I've been inspired by this paper: http://citeseer.ist.psu.edu/585421.html which talks about building a combinator language for financial contracts, and which uses Haskell as the implementation language. ...anyway. Say I have a data type: data Thing = Thing { field_one :: String, field_two :: String, field_three :: Integer } I'd like to build a datatype that represents comparison rules on Things. A comparison rule would be something like "thing1.field_two == thing2.field_two" or "thing1.field_three > thing2.field_three". If I was writing python, I might do this as: class ThingCompare: def __init__(self, op, field, thing1, thing2): self.op = op self.field = field I could evaluate instances of ThingCompare as: def evalThingCompare(tc, thing1, thing2): return tc.op(getattr(thing1, tc.field), getattr(thing2, tc.field)) In Haskell, I envisage writing something like: data ThingCompare = TC Op Field So that if I had: eq x y = x == y then I could create a ThingCompare by saying: tc = eq field_two And I could evaluate my ThingCompares by defining: evaltc :: ThingCompare -> Thing -> Thing -> Bool evaltc (TC o f) t1 t2 = o (f t1) (f t2) But I can't figure out what types "Op" and "Field" should be. Any suggestions? Am I on the wrong track? (have I been corrupted by python's dynamic typing? :-) ) -- John.

4 7

Re: Maybe and partial functions
by oleg＠pobox.com 14 Mar '07

14 Mar '07

Neil Mitchell wrote: > newtype N1 = N1 Int > (put that in a module and don't export N1) > > define the constant 2, define the increment operator, change div and mod. That is precisely what I would have done. > Now we've mainly got a proof in the type checker, but we still don't > actually have a proof for our core N1 definition - but I think that is > probably ok, provided it is a common core which can be reused and is > minimal. Any proof of totality of the original digits-of-e code must first prove or postulate that incrementing a positive number gives the positive number. So, one must prove/verify/assume the basic properties one way or another. In the lightweight static capabilities approach, these basic lemmas/properties/axioms are collected in modules, which can be verified once and for all and then used in various parts of the program. Accommodating the security kernel in those parts of the program does not seem to be a burden. In return, we get assurances of the simple kernel in those parts of the program without the need to run the verification algorithm all over again (on the possibly complex pieces of code). The idea that data type abstraction can enforce complex invariants was advocated back in 1973 by James H. Morris (the father of the guy who released the `Morris worm'), in the CACM paper "Protection in Programming Languages". http://www.erights.org/history/morris73.pdf

1 0

Re: [Haskell] Haskell Weekly News: March 12, 2007
by Conrad Parker 14 Mar '07

14 Mar '07

On 13/03/07, Wolfgang Jeltsch <g9ks157k(a)acme.softbase.org> wrote: > Am Montag, 12. März 2007 03:52 schrieb Donald Bruce Stewart: > > * [41]Why Publish CS Papers Without Code? > > 41. http://billmill.org/why_no_code > > Interesting! > > This leads me to the question how copyright of code fragments included in > conference papers is handled. Say, I submit a paper containing some code > fragments to the ICFP. I have to assign the copyright of the paper to the > ACM. Does this mean that the ACM will hold the copyright of the code > fragments? Does this mean that I'm not allowed to publish the source code > containing these code fragments as open source software somewhere? (I am not a lawyer, etc) If your paper simply cites, and quotes from, code that you have already published elsewhere (eg. on your own web site), then I think that would simply count as a citation. If on the other hand your paper contains your code verbatim and doesn't cite it (ie. the code is previously unpublished) then perhaps you are assigning the copyright of it. So it may be a good idea to always make available open source projects before publishing about them in academic papers, and to always include a citation to the open source project web site or tech report. Besides, <tshirt>If it's not open source, it's not computer science</tshirt>. Science demands repeatable results, computer science demands literate programming. The solution is not to shy away from including code, or else the IP lawyers have won, science is banned and we get plunged into another Dark Age. cheers, Conrad.

4 3

Maybe and partial functions
by Dougal Stanton 14 Mar '07

14 Mar '07

The Maybe construction is very useful for explicitly handling circumstances where the function cannot produce a sensible answer. But how far should this notion be taken? When you're writing a function which you realise may not produce what you want, in what circumstances would you use a Maybe, and when would you just throw an error? I'm wondering both in terms of good engineering practise and also for correctness. Should elementary partial functions like > 5 `div` 0 or > head [] return Nothing? I guess it's a bit of a silly suggestion, but it helps to highlight why we use Maybe in the first place. So --- where's the cutoff point in your code? Cheers, D. -- Dougal Stanton

5 4

Mixed-type arithmetic, or type coercion
by Dave Hinton 14 Mar '07

14 Mar '07

Arithmetic operators in haskell appear to require their operands to have the same type. How can I do arithmetic between operands of different types? Alternatively, how do I coerce a value from being an Int to being a Double? I am new to haskell. I have read a few tutorials but they do not mention this issue. I have read the haddock documentation for Prelude and Numeric, but cannot find anything that helps here. (I saw a couple of numeric conversion functions, but they won't turn an Int into a Double.) Toy example: $ cat eg.hs calc :: Int -> Double -> Double calc count weight = count * weight $ ghc eg.hs eg.hs:2: Couldn't match `Int' against `Double' Expected type: Int Inferred type: Double In the second argument of `(*)', namely `weight' In the definition of `calc': calc count weight = count * weight

4 3

Maybe and partial functions
by oleg＠pobox.com 14 Mar '07

14 Mar '07

Neil Mitchell wrote: > I suggest you try rewriting this program to be complete: > > http://darcs.haskell.org/nofib/imaginary/digits-of-e2/Main.lhs > > (if you do, please post the result to the list) As Gen Zhang noted, the problem seems to be quite straightforward: just express in types the fact that we deal with infinite streams and so Nil just cannot happen. One way of doing this as follows. Showing totality (that is, termination of recursion in carry propagate) is harder. But re-writing the program so to avoid head/tail on the empty list is easy: module E where import Prelude hiding (head, tail, map, iterate, take) data I a = C a (I a) deriving Show -- these are total functions: they give WHNF in one step provided non-bottom -- arguments head (C a _) = a tail (C _ l) = l map f (C a l) = C (f a) (map f l) rept a = C a (rept a) take n (C a l) | n > 0 = a:take (n-1) l take _ _ = [] iterate f z = C z (iterate f (f z)) -- There are no pattern-matching failures here. -- The totality is harder to see: all digits are roughly of the same range, -- but each recursive call increments base. Eventually, base becomes bigger -- than d+9 and so the first alternative will be selected, which is in the -- WHNF and so recursion terminates. carryPropagate base (C d ds) | carryguess == (d+9) `div` base = C carryguess (C (remainder+nextcarry) fraction) | otherwise = (C (dCorrected `div` base) (C (dCorrected `mod` base) fraction)) where carryguess = d `div` base remainder = d `mod` base C nextcarry fraction = carryPropagate (base+1) ds dCorrected = d + nextcarry e = map (show.head) $ iterate (carryPropagate 2 . map (10*) . tail) $ C 2 (rept 1) en n = "2." ++ concat (take n (tail e))

4 5

Consequences of newtype deriving implementation w.r.t. base classes
by Twan van Laarhoven 14 Mar '07

14 Mar '07

I just noticed some unexpected consequences of the way newtype deriving is implemented in GHC. Because the dictionary of the underlying type is reused, so are base classes. This message is a literate Haskell program illustrating the problem. > {-# OPTIONS_GHC -fglasgow-exts #-} This problem comes up when an instance method calls a method of a base class. Consider the following useless example: > class Show a => Show2 a where > show2 :: a -> String > show2 = show > > instance Show2 Int Now consider a type deriving Show2, but having a different implementation of Show (also derived). > newtype Meter = Meter Int > deriving (Eq, Show, Show2) Now, for show2 the derived Show instance (which also shows the constructor name) is *not* used, instead the Show Int instance is used: ] > show2 (Meter 1) ] "1" ] > show (Meter 1) ] "Meter 1" This is quite unexpected, unless you consider what is going on behind the scenes. Even more confusingly, GHC requires that there is a Show instance for Meters, even if it will not be used! ] No instance for (Show Meter) ] arising from the superclasses of an instance declaration at ... ] Probable fix: add an instance declaration for (Show Meter) ] In the instance declaration for `Show2 Meter' This problem can come up whenever a class instance uses a function from a base class. Right now this not likely happen, but it will become more common if the standard classes are split up: > class Additive a where > add :: a -> a -> a > class Additive a => Subtractive a where > neg :: a -> a > sub :: a -> a -> a > sub x y = add x (neg y) -- calls base class function add > class Functor m => Monad' m where > return' :: a -> m a > join' :: m (m a) -> m a > join' x = bind' x id > bind' :: m a -> (a -> m b) -> m b > bind' ma k = join' (fmap k ma) -- calls base class function fmap As a solution I would suggest that newtype deriving a class instance is only allowed if all base classes instances are also derived using newtype deriving. This presents problems for Show and Read, because they cannot be derived in that way. It will, however, catch problems with most other classes. Twan van Laarhoven

2 1

ICFP07 Final CFP & Note from the Program Chair
by Matthew Fluet (ICFP Publicity Chair) 14 Mar '07

14 Mar '07

Call for Papers ICFP 2007: International Conference on Functional Programming Freiburg, Germany, 1-3 October 2007 Important Dates ~~~~~~~~~~~~~~~ Submission: 11:00 6 April 2007, Samoa time (AST) Author response: 11:00 23 May to 11:00 25 May 2007 (AST) Notification: 8 June 2007 Final papers due: 20 July 2007 Note from the ICFP07 Program Chair As the April 6 deadline for ICFP approaches, we thought it might be useful to call potential authors' attention to several significant points in the Call for Papers, the full text of which can be found at http://icfp07.eecs.harvard.edu/cfp.html Experience Reports ~~~~~~~~~~~~~~~~~~ This year ICFP is soliciting a new category of paper: the Experience Report. An Experience Report is a short paper of 2--4 pages. Unlike a normal ICFP paper, it is not intended to add to the body of *knowledge* of the functional-programming community. Rather, each Experience Report will add to a body of published, refereed, citable *evidence* that functional programming really works--or will describe obstacles that prevented it from working. Double-blind review ~~~~~~~~~~~~~~~~~~~ A reviewer's attitude toward a submission may be affected, even unconsciously, by the identity of the author. Our reviewers want to be able to approach each submission without such involuntary reactions as ``Peyton Jones; he writes a good paper'' or ``Who are these people? I have never heard of them.'' We especially want to ensure that work submitted by newcomers to our community gets the same careful consideration and scrutiny as the work of our best-known people. We are therefore requesting that authors make it possible for their submissions to be reviewed without forcing the reviewers to know who the authors are. Once all reviews are written, identities will be revealed at the PC meeting. For authors, this process should be simple: * Omit authors' names from your title page (or list them as ``omitted for submission''), and when you cite your own work, please make it difficult to figure out exactly who you are, even if a reviewer might be able to make a good guess. * If your submission is supported by other material, such as a technical report containing lengthy proofs, please do not cite this material on the web---instead, submit a zip file including both your paper and the technical report. Detailed guidelines can be found at http://icfp07.eecs.harvard.edu/blind.html Firm length limit; no appendices ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The 12-page limit (for full papers) and 4-page limit (for Experience Reports) are *firm*. Papers exceeding these limits will be rejected summarily by the program chair. If an author wishes to include an appendix which would put the main submission over the limit, the appendix must be submitted as a separate document, in a zip file with the main submission. It is understood that the reviewers' only obligation is to read the main submission; material beyond the 12-page limit may well go unread. Other details ~~~~~~~~~~~~~ We are encouraging author-date citations (Peyton Jones and Wadler 1993) rather than the default numbered citations [27]. LaTeX users can \usepackage{natbib} and \bibliographystyle{plainnat}. The submission deadline is late morning Samoan time, but in many times zones of interest, this is equivalent to late afternoon or early evening.

1 0

haskell and webapplications + a WASH and a WebFunction question
by Marc Weber 13 Mar '07

13 Mar '07

Hello, I've noticed that the summer of code tickets contain one item: "lightweight web framework". I've dropped out university one year ago. So I can't participate, right? Do you want to explore with me how this might be done propably using HAppS or fastcgi ? I just need another person to talk to to. (mailinglist will do as well ;) I think webfunction is a very good starting point. Would it be worth adding a page like haskellIDE http://haskell.org/haskellwiki/HIDE to collect ideas ? There are still some question I could not answer yet eg: WASH: How is askContinuously used? did anyone use WASH with FastCGI ? I've tried looking at the apis. FastCGI (mantained by Bringert) seems to need the HTTP response as plain text (either ByteString or lazy String) whereas WASH wants to write to a handle (see function start wehere initEnv stdin stdout) is called and sets cgiHandle which seems to be the handle to be written to. Did I get this right? Is there an easier way then rewriting WASH? WebFunctions: When using dog http:localhost:8080.. dog prints the html page and waits still 10s because the WebFunction webserver waits for another request. This is caused by b <- myHWaitForInput h 10 in file LLWebServer.hs which makes it impossible to use benchmarking tools such as ab2 from apache. Do you know wether this is bug? Marc

1 0

Re: Type and State Confusion
by Hans van Thiel 13 Mar '07

13 Mar '07

Albert, Thanks very much for your explanation. I see now that I confused the state function with the f, but it's still not quite clear. data MyState a b = MyStateC ([a] -> ([a], b)) This defines an algebraic data type (...why is it called algebraic?) with two type variables and a unary constructor. instance Monad (MyState a) where return x = MyStateC (\tb -> (tb, x)) (MyStateC st) >>= f = MyStateC (\tb -> let (newtb, y) = st tb (MyStateC trans) = f y in trans newtb ) Now, if the instantiated a has type String, Int or whatever, I would understand, but the type of the Monad seems to be built up from two types. You write: ...y has type String. In more detail: in order for foo >>= toMyState to make sense, these must be the types: foo :: MyState String String st :: [String] -> ([String], String) y is forced to have type String for the sake of toMyState. But how do the two occurrences of String in the foo type, in general a and b, match to the single a in the instance declaration? In particular when I have: toMyState :: String -> MyState String Int toMyState x = MyStateC (f x) This is mapped onto a list of strings, on which the Prelude sequence is applied. sequence :: Monad m => [m a] -> m [a] You write: The >>= used by sequence is the same >>= in the MyState monad, since you instantiate m to MyState String. Therefore, sequence performs all the state transformations correctly, since >>= is correct. So the m becomes MyState String, and therefore the list elements have type (MyState String Int), or the other way around. I understand, from your explanation, how this works from there on, but I'm still confused about what the Monad is. Is it MyState which takes two types, or (MyState String) which takes one type? Or neither? Does it involve some 'sort of currying' of type parameters? Thanks again, Hans

2 2

GHC optimization changes evaluation strategy?
by Dusan Kolar 13 Mar '07

13 Mar '07

Hello all, the following program changes behavior if translated using different options for ghc compiler. Is this correct or not? I used The Glorious Glasgow Haskell Compilation System, version 6.6. And I would expect in both cases behavior 1. But I may be wrong... Thanks for any resolution. Dusan *Program:* $ cat Test.hs import System.IO.Unsafe import System.IO main = do putStr "Start...\n" putStr $ show $ falling' falling10000 putStr "\n" putStr $ show $ sorted' rising10000 putStr "Stop...\n" sorted' [] = True sorted' [_] = True sorted' l = sx l 1 where sx [] _ = True sx [_] _ = True sx (x:l@(y:ys)) n = if n==1000 then unsafePerformIO (putChar '.' >> hFlush stdout) `seq` x<=y && sx l 1 else x<=y && (sx l $! n+1) falling' [] = True falling' [_] = True falling' l = sx l 1 where sx [] _ = True sx [_] _ = True sx (x:l@(y:ys)) n = if n==1000 then unsafePerformIO (putChar '.' >> hFlush stdout) `seq` x>=y && sx l 1 else x>=y && (sx l $! n+1) rising10000 = [0..100000] falling10000 = [100000,99999..0] -- EOF *Behavior 1:* $ ghc Test.hs -o test $ ./test Start... ....................................................................................................True ....................................................................................................TrueStop... *Behavior 2:* $ rm test Test.o Test.hi $ ghc -O2 Test.hs -o test $ ./test Start... .True .TrueStop... -- Dusan Kolar tel: +420 54 114 1238 UIFS FIT VUT Brno fax: +420 54 114 1270 Bozetechova 2 e-mail: kolar(a)fit.vutbr.cz Brno 612 66 Czech Republic --

2 1

Ann: regex-base-0.91
by Chris Kuklewicz 13 Mar '07

13 Mar '07

I have updated the darcs repository and the hackage repository to have regex-base-0.91 Changes: GHC uses late instance overlap detection, whereas Hugs demands no potential overlap. Thus Hugs rejected some of the polymorphic results for matching given by RegexContext instances. The solution in version 0.91 of regex-base is to use newtypes. To this end there are 4 newtypes which are used to disambiguate some of the more complicated return types of match/matchM/=~/=~~. The new haddock documentation for Text.Regex.Base.Context has more details and lists all the instances. The 4 newtypes are: > newtype AllSubmatches f b = AllSubmatches {getAllSubmatches :: (f b)} > newtype AllTextSubmatches f b = AllTextSubmatches {getAllTextSubmatches :: (f b)} > newtype AllMatches f b = AllMatches {getAllMatches :: (f b)} > newtype AllTextMatches f b = AllTextMatches {getAllTextMatches :: (f b) } The 'f' parameters are containers types, such as [] or (Array Int). The two *Submatches types report all the captured (i.e. parenthesized) groups of the first match found. The two *Matches types report on the all the non-overlapping matches found. This clarifies the desires of the programmer and allows choice of either result to be made. The two *Text* version have the type of the searched text included in the type of the result 'b', unlike the other two types. This avoids overlapping. These newtypes are not used for all the instances, but only where they are needed to either avoid overlapping or remove possible confusion. Using this newtype schema has allowed a few new instances to be added. In particular all the instances should have a [] or (Array Int) option for the returned container. -- Chris Kuklewicz

1 0

idea for avoiding temporaries
by David Roundy 13 Mar '07

13 Mar '07

Hi all, I was just teaching a class on minimization methods, with a focus on conjugate gradient minimization in particular, and one of my main points was that with conjugate gradient minimization we only need three or four arrays of size N (depending on whether we use the Fletcher-Reeves or Polak-Ribiere variant), that this was a huge win, and I was explaining that in my code we use Fletcher-Reeves even though it's generally got less stable convergence behavior, because avoiding one extra copy is well worth it, when each copy is on the order of a gigabyte (which is not unusual in my line of work). This got me thinking about one of the largest problems with writing serious numerical code in Haskell, which is that of memory consumption and avoiding temporary variables. The count of three arrays requires assumes that we do in-place updates, which presupposes an imperative model. But the main reason I'd like to switch to Haskell is so that I can write pure functional code, which is easier to read, easier to reason with, and easier to get right. So I started wondering whether there's a solution that would allow us to write pretty high-level pure functional code, while the RTS can realize at run-time that we have the only reference to the input argument and that it is therefore safe to consume it destructively. My thought is to move some of the amazing rewriting streams stuff that's going on with Data.ByteStream and Manuel's array fusion work onto the memory management level. If we can rewrite high-level array manipulations into a form in which the compiler can fuse the loops and write good low-level code, why not also allow automatic in-place updates (when possible)? My thought is to create a function like the following: copy :: ForeignPtr a -> IO (ForeignPtr a) This function ordinarily copies its input into a new chunk of memory, and then calls the initialization function to update that memory. So we could call it with something like a `plus` b = do a' <- copy a a' `plusEqual` b return a' Of course, in practice I imagine this whole business being encapsulated in a module where it's called with unsafePerformIO (but it's really perfectly safe, a la Data.ByteString). The key is that copy will ask the GC to check whether there is more than one reference to its input, and if there isn't, then it'll return its input without making a copy. Obviously, we'd want to be careful in making calls to copy (since the GC overhead could overwhelm the potential (transient) memory savings. And I've got no idea how hard it would be to find out if there are no other references, or how effective this would be... that is, whether the compiler might generate "false" references to the input that would prevent the savings from ever being realized. There are also other questions. My copy above is simple, but probably we'd be better off with a more general: copy :: a -> (a -> IO a) -> IO a which could be used in the base libraries for other sorts of objects, such as Array, which might not have a ForeignPtr at their back end. We might also want a more general copy that would handle the case where we would like to copy either one variable or another, and we don't care which. i.e. we in my `plus` example above, if "a" can't be discarded, but "b" can, we'll be out of luck. Perhaps we want something like reuseOrNot :: a -> (a -> IO b) -> (a -> IO b) -> IO b which would call one function or the other, depending on whether the input is deemed expendible by the GC, so we could write a `plus` b = reuseOrNot a (\a' -> do { a' `plusEqual` b; return a' }) (\a' -> reuseOrNot b (\b' -> do { b' `plusEqual` a'; return b' }) (\b' -> a' `boringAdd` b')) where boringAdd is an addition that doesn't reuse either array. Anyhow, all this would be predicated on the possibility of asking the GC whether anyone else has a reference to a given object, and I've no idea how tough (or slow) this would be. It'd also be effectively predicated on someone like dons having the time and interest to write good fusion code which would allow one to make use of this in referentially transparent high-level pure functional code. I think it'd be pretty cool, and would certainly (not immediately, but as my research group ramps up) be interested in being a guinea pig user of this stuff. Any thoughts? Am I crazy? Is this infeasible for some reason? Should I have patented this idea before mentioning it on the list? Has someone else already patented it? -- David Roundy Department of Physics Oregon State University

18 50

Random/StdGen/read: there is something unclear (or misunderstood!)
by Zara 13 Mar '07

13 Mar '07

Sorry if this question is too basic, but I am trying to learn Haskell and from tiem to time I get stuck. (And forgive me, I haev a heavy procedural background, so functional programming is hard for me) I am trying to use 'read' to create a random generator, applying it on some text. As the Report, says: # In addition, 'read' may be used to map an arbitrary string (not # necessarily one produced by 'show') onto a value of type 'StdGen'. # In general, the 'read' instance of 'StdGen' has the following # properties: # # * It guarantees to succeed on any string. # # * It guarantees to consume only a finite portion of the string. # # * Different argument strings are likely to result in different # results. But it does not succeed on "any string". Code follows \begin{code} module Pepe where import Random pepin :: StdGen pepin = read "cosita" pepe :: StdGen pepe = read "cositaLinda" \end{code} If I evaluate pepin, results are: Hugs> pepin 38273 1 :: StdGen (360 reductions, 554 cells) But if I evaluate pepe, all changes: Hugs> pepe Program error: Prelude.read: no parse (380 reductions, 694 cells) Am I misunderstanding something, or is StdGen -> read buggy? As you can see, I am using Hugs, version Sep 2006 to test. TIA, best regards, Zara

2 1

Church Encoding Function
by Joachim Breitner 13 Mar '07

13 Mar '07

Hi, some more ideas following from the last post. I noticed how the function Data.Maybe.maybe converts a Haskell Maybe into a Church encoded Maybe. Also, the if construct, interpreted as a function, converts a Bool into a church encoded Bool. If lists are encoded as forall b. (a -> b -> b) -> b -> b, then foldr, with the right order of arguments, converts a haskell [] to a Church encoded List. Is there a name for these functions? “Characteristic Church Encoding Functions” maybe? Are there more than these: Maybe -- maybe Bool -- ifthenelse List -- foldr (,) -- uncurry Just a short idea while waiting at the airport... Greetings, Joachim -- Joachim "nomeata" Breitner mail: mail(a)joachim-breitner.de | ICQ# 74513189 | GPG-Key: 4743206C JID: joachimbreitner(a)amessage.de | http://www.joachim-breitner.de/ Debian Developer: nomeata(a)debian.org

9 9

Haskell for Accessibility
by Tom Hawkins 13 Mar '07

13 Mar '07

I love programming in Haskell, yet even its concise expressions have not saved my tendons from chronic RSI. Has anyone put any thought into building an accessible Haskell development interface for those who may not be able to use a keyboard? One inspirational program is Dasher (http://www.inference.phy.cam.ac.uk/dasher/) Not only is it godsend for people with a wide range of disabilities, Dasher is also a lot of fun to use. Though Dasher is good at general text entry, it's not well suited for programming. However, combining Dasher's statistical inference with Haskell's type inference might yield a graphical, cursor driven interface even more efficient than the conventional keyboard. Is there interested in such a project? I don't have the expertise or typing strength (pun intended) to go it alone, but I could lend a hand. Here are a few random ideas: - A tree viewer to navigate and manage directories, modules, module declarations, and expressions. Similar to a directory explorer, nodes in the tree can be collapsed and expanded. Collapsed module definitions would display the type annotation, while hiding the definition. - Another interface for composing expressions. This interface could be similar to Dasher, but use both statistical inference and type inference to weight and prune the decision tree. The expression composer interface could directly assemble the abstract syntax tree, thus eliminating the need for whitespace and ()s. Of course, the tree viewer would pretty print all expressions in the familiar Haskell layout. - The development environment could be hosted as a web server, delivering SVG and minimal JavaScript for the client-side interface, allowing Haskell program development from any web browser with a 2 button mouse -- head mounted or eye tracked, of course. The client-server architecture would allow developers to concurrently work from the same source code. - >From the tree viewer, click any expression to view the compiler's inferred type, with the ability to turn any inferred type into a concrete type annotation. And the ability to compare inferred types to type annotations. Type violations highlighted in red. - Variable references would not have to be explicitly spelled out. Instead, variables could be selected from either the tree viewer or expression composer, forming a hard link. When a variable's name changes, all references could be automatically updated. When an expression is either moved or copied into a new lexical scope, the variable references could be automatically rebound to variable definitions in the new scope. Unmatched referenced names and ambiguous names would be highlighted in red. -Tom

3 2

CFP: Prog. Lang for Mechanized Mathematics Workshop
by Jacques Carette 13 Mar '07

13 Mar '07

Programming Languages for Mechanized Mathematics Workshop As part of Calculemus 2007 <http://www.risc.uni-linz.ac.at/about/conferences/Calculemus2007/> Hagenberg, Austria [http://www.cas.mcmaster.ca/plmms07/] The intent of this workshop is to examine more closely the intersection between programming languages and mechanized mathematics systems (MMS). By MMS, we understand computer algebra systems (CAS), [automated] theorem provers (TP/ATP), all heading towards the development of fully unified systems (the MMS), sometimes also called universal mathematical assistant systems (MAS) (see Calculemus 2007 <http://www.risc.uni-linz.ac.at/about/conferences/Calculemus2007/>). There are various ways in which these two subjects of /programming languages/ and /systems for mathematics/ meet: * Many systems for mathematics contain a dedicated programming language. For instance, most computer algebra systems contain a dedicated language (and are frequently built in that same language); some proof assistants (like the Ltac language for Coq) also have an embedded programming language. Note that in many instances this language captures only algorithmic content, and /declarative/ or /representational/ issues are avoided. * The /mathematical languages/ of many systems for mathematics are very close to a functional programming language. For instance the language of ACL2 is just Lisp, and the language of Coq is very close to Haskell. But even the mathematical language of the HOL system can be used as a functional programming language that is very close to ML and Haskell. On the other hand, these languages also contain very rich specification capabilities, which are rarely available in most computation-oriented programming languages. And even then, many specification languages ((B, Z, Maude, OBJ3, CASL, etc) can still teach MMSes a trick or two regarding representational power. * Conversely, functional programming languages have been getting "more mathematical" all the time. For instance, they seem to have discovered the value of dependent types rather recently. But they are still not quite ready to 'host' mathematics (the non-success of docon <http://www.haskell.org/docon/> being typical). There are some promising languages on the horizon (Epigram <http://www.e-pig.org/>, Omega <http://web.cecs.pdx.edu/%7Esheard/Omega/index.html>) as well as some hybrid systems (Agda <http://agda.sourceforge.net/>, Focal <http://focal.inria.fr/site/index.php>), although it is unclear if they are truly capable of expressing the full range of ideas present in mathematics. * Systems for mathematics are used to prove programs correct. (One method is to generate "correctness conditions" from a program that has been annotated in the style of Hoare logic and then prove those conditions in a proof assistant.) An interesting question is what improvements are needed for this both on the side of the mathematical systems and on the side of the programming languages. We are interested in all these issues. We hope that a certain synergy will develop between those issues by having them explored in parallel. These issues have a very colourful history. Many programming language innovations first appeared in either CASes or Proof Assistants, before migrating towards more mainstream languages. One can cite (in no particular order) type inference, dependent types, generics, term-rewriting, first-class types, first-class expressions, first-class modules, code extraction, and so on. However, a number of these innovations were never aggressively pursued by system builders, letting them instead be developped (slowly) by programming language researchers. Some, like type inference and generics have flourished. Others, like first-class types and first-class expressions, are not seemingly being researched by anyone. We want to critically examine what has worked, and what has not. Why are all the current ``popular'' computer algebra systems untyped? Why are the (strongly typed) proof assistants so much harder to use than a typical CAS? But also look at question like what forms of polymorphism exists in mathematics? What forms of dependent types exist in mathematics? How can MMS regain the upper hand on issues of 'genericity'? What are the biggest barriers to using a more mainstream language as a host language for a CAS or an ATP? This workshop will accept two kinds of submissions: full research papers as well as position papers. Research papers should be nore more than 15 pages in length, and positions papers no more than 3 pages. Submission will be through _EasyChair_. An informal version of the proceedings will be available at the workshop, with a more formal version to appear later. We are looking into having the best papers completed into full papers and published as a special issue of a Journal (details to follow). Important Dates April 25, 2007: Submission Deadline June 29-30, 2007: Workshop Program Committee Lennart Augustsson <http://www.cs.chalmers.se/%7Eaugustss> [Credit Suisse] Wieb Bosma <http://www.math.ru.nl/%7Ebosma/>[Radboud University Nijmegen, Netherlands] Jacques Carette <http://www.cas.mcmaster.ca/%7Ecarette> (co-Chair) [McMaster University, Canada] David Delahaye <http://cedric.cnam.fr/%7Edelahaye/> [CNAM, France] Jean-Christophe Filliâtre <http://www.lri.fr/%7Efilliatr/> [CNRS and Université de Paris-Sud, France] John Harrison <http://www.cl.cam.ac.uk/%7Ejrh13/> [Intel Corporation, USA] Markus (Makarius) Wenzel <http://www4.in.tum.de/%7Ewenzelm/> [Technische Universität München, Germany] Freek Wiedijk <http://www.cs.ru.nl/%7Efreek/> (co-Chair) [Radboud University Nijmegen, Netherlands] Wolfgang Windsteiger <http://www.risc.uni-linz.ac.at/people/wwindste/> [University of Linz, Austria] Location and Registration Location and registration information can be found on the Calculemus <http://www.risc.uni-linz.ac.at/about/conferences/Calculemus2007/> web site.

1 0

A valuable new combinator for Parsec?
by Maxime Henrion 13 Mar '07

13 Mar '07

Hello all, While using the very nice "option" combinator of Parsec recently, it seemed to me that it would be useful to have a more specific kind of combinator for optional tokens that wraps the token into a Maybe type. So, that gives: pmaybe :: GenParser tok st a -> GenParser tok st (Maybe a) pmaybe p = option Nothing (p >>= return . Just) I've been using it happily with some code of mine. Do people think that it would be generally useful to have in Parsec? Cheers, Maxime

3 2

Haskell Weekly News: March 12, 2007
by dons＠cse.unsw.edu.au 12 Mar '07

12 Mar '07

--------------------------------------------------------------------------- Haskell Weekly News http://sequence.complete.org/hwn/20070312 Issue 59 - March 12, 2007 --------------------------------------------------------------------------- Welcome to issue 59 of HWN, a weekly newsletter covering developments in the [1]Haskell community. This week we see the 2007 Haskell Workshop announcement, Haskell.org's participation in the Google Summer of Code gets underway, and of course, new libraries! 1. http://haskell.org/ Announcements Google Summer of Code and Haskell.org. Malcolm Wallace [2]announced that Haskell.org has once again applied to be a mentoring organisation for the Google Summer of Code. If you are a student who would like to earn money hacking in Haskell, or you are a non-student who has a cool idea for a coding project but no time to do it yourself, then visit the [3]SoC wiki to gather ideas, and add yourself to the list of interested people! Add new ideas for projects! 2. http://article.gmane.org/gmane.comp.lang.haskell.cafe/20232 3. http://hackage.haskell.org/trac/summer-of-code Haskell Workshop Call for Papers. Gabriele Keller [4]announced the initial call for papers for the Haskell Workshop 2007, part of the 2007 International Conference on Functional Programming (ICFP). The purpose of the Haskell Workshop is to discuss experience with Haskell, and possible future developments for the language. The scope of the workshop includes all aspects of the design, semantics, theory, application, implementation, and teaching of Haskell. 4. http://article.gmane.org/gmane.comp.lang.haskell.general/14977 Data.CompactString 0.3: Unicode ByteString. Twan van Laarhoven [5]announced version 0.3 of the Data.CompactString library. Data.CompactString is a wrapper around Data.ByteString supporting Unicode strings. 5. http://article.gmane.org/gmane.comp.lang.haskell.general/14973 harchive-0.2: backup and restore software in Haskell. David Brown [6]announced release 0.2 of [7]harchive, a program for backing up and restoring data. The package is available [8]from Hackage. 6. http://article.gmane.org/gmane.comp.lang.haskell.general/14972 7. http://www.davidb.org/darcs/harchive/ 8. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/harchive-0.2 New release of regex packages. Chris Kuklewicz [9]announced new versions of the regex-* packages (base,compat,dfa,parsec,pcre,posix,tdfa,tre). There is a new [10]wiki page with documentation relating to these packages. All packages are available from [11]Hackage, under the [12]Text Category. 9. http://article.gmane.org/gmane.comp.lang.haskell.cafe/20189 10. http://haskell.org/haskellwiki/Regular_expressions 11. http://hackage.haskell.org/packages/hackage.html 12. http://hackage.haskell.org/packages/archive/pkg-list.html#cat:Text StaticDTD: type safe markup combinators from DTDs. Marcel Manthe [13]announced a tool that transforms a Document Type Definition to a library. The resulting library contains combinators that assure proper nesting of elements. The plan is to add more constraints that will also take care of the order of occurrence of children. The parsing of the DTD is done with HaXml. The code is [14]available via darcs. 13. http://article.gmane.org/gmane.comp.lang.haskell.cafe/20218 14. http://m13s07.vlinux.de/darcs/StaticDTD/ IPv6 support for network package. Bryan O'Sullivan [15]announced that he'd added IPv6 support to the network package. 15. http://thread.gmane.org/gmane.comp.lang.haskell.libraries/6363 Type-level binary arithmetic library. Oleg Kiselyov and Chung-chieh Shan [16]announced a [17]new library for arbitrary precision binary arithmetic over natural kinds. The library supports addition/subtraction, predecessor/successor, multiplication/division, exp2, full comparisons, GCD, and the maximum. At the core of the library are multi-mode ternary relations Add and Mul where any two arguments determine the third. Such relations are especially suitable for specifying static arithmetic constraints on computations. The type-level numerals have no run-time representation; correspondingly, all arithmetic operations are done at compile time and have no effect on run-time. 16. http://article.gmane.org/gmane.comp.lang.haskell.general/14961 17. http://pobox.com/~oleg/ftp/Computation/resource-aware-prog/BinaryNumber.hs Haskell' This section covers the [18]Haskell' standardisation process. * [19]Deriving Functor 18. http://hackage.haskell.org/trac/haskell-prime 19. http://thread.gmane.org/gmane.comp.lang.haskell.prime/2135 Libraries This week's proposals and extensions to the [20]standard libraries. * [21]Add IPv6 support to network library * [22]Error handling conventions 20. http://haskell.org/haskellwiki/Library_submissions 21. http://thread.gmane.org/gmane.comp.lang.haskell.libraries/6377 22. http://thread.gmane.org/gmane.comp.lang.haskell.libraries/6382 Discussion Avoiding intermediate data structures. David Roundy [23]opened discussion on techniques for avoiding intermediate data structures in Haskell code 23. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/20319 Maybe a different Maybe. Joachim Breitner [24]wondered about avoiding intermediate Maybe constructs 24. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/20300 Blog noise [25]Haskell news from the blogosphere. * [26]STM, IO, and a Simple Persistence Model * [27]Dynamic programming in Haskell * [28]Collected 'good math/bad math' Haskell articles * [29]3 open questions about monads * [30]Documentation, libraries and speed matter * [31]Why monads matter * [32]Design Patterns in Haskell: bracket * [33]Practical Haskell: shell scripting with error handling and privilege separation * [34]Simple socket programming * [35]'interact' for TCP sockets * [36]Monads in C, part 3 * [37]Directory tree printing in Haskell. Part 2 * [38]Monads through Pictures * [39]Notes on hacking Haskell * [40]Wanted: Haskell Programmer * [41]Why Publish CS Papers Without Code? * [42]The 8 ways to report errors in Haskell 25. http://planet.haskell.org/ 26. http://mult.ifario.us/articles/2007/03/04/stm-and-io 27. http://sequence.complete.org/node/263 28. http://scienceblogs.com/goodmath/goodmath/programming/haskell/ 29. http://www.randomhacks.net/articles/2007/03/05/three-things-i-dont-understa… 30. http://kawagner.blogspot.com/2007/03/why-do-most-people-seem-to-use-inferio… 31. http://www.rfc1149.net/blog/2007/03/06/why-monads-matter/ 32. http://notes-on-haskell.blogspot.com/2007/03/design-patterns-in-haskell-bra… 33. http://cgi.cse.unsw.edu.au/~dons/blog/2007/03/06#programmable-semicolons 34. http://metavar.blogspot.com/2007/03/simple-socket-programming.html 35. http://stephan.walter.name/blog/computers/programming/haskell/interacttcp.h… 36. http://sigfpe.blogspot.com/2007/03/monads-in-c-pt-iii.html 37. http://blog.moertel.com/articles/2007/03/07/directory-tree-printing-in-hask… 38. http://www.bolour.com/papers/monads-through-pictures.html 39. http://metavar.blogspot.com/2007/03/haskell-hacking-notes-or-prelude-to.html 40. http://blogs.teamb.com/craigstuntz/archive/2007/03/09/WantedHaskellDevelope… 41. http://billmill.org/why_no_code 42. http://www.randomhacks.net/articles/2007/03/10/haskell-8-ways-to-report-err… Quotes of the Week * fishkandy: The problem with comparing apples to apples is that haskell has 'mango daiquiri' as a basic fruit * fax--: I wake up with a headache because of you, Haskell * norpan: I use functions, but i don't use them as arrows: I prefer silver bullets * ray: Some people claim everything is lisp. One time I was eating some spaghetti and someone came by and said: 'Hey, nice lisp dialect you're hacking in there' * roconnor: Damn it! Haskell pseudo code is indistinguishable from actual code * shapr: Today's nifty error message: *Main> thread blotttchhhkrrreeeedaaa dddinbbbdllleooofcccikkkneeeidddt eiiilnnnydddeeefffiiinnniiittteeelllyyy * stepcut: C? isn't that some low-level language that compilers output to? * wkh: Why does the haskell webpage link to 'research papers' under the 'getting started' section? Code Watch Tue Mar 6 06:31:12 PST 2007. Simon Marlow. [43]add noDuplicate#. This primop ensures that the current computation is not being duplicated, by calling threadPaused(). The idea is to use it inside unsafePerformIO/unsafeInterleaveIO (see #986). 43. http://article.gmane.org/gmane.comp.lang.haskell.cvs.ghc/19536 About the Haskell Weekly News Each week, new editions are posted to [44]the Haskell mailing list as well as to [45]the Haskell Sequence and [46]Planet Haskell. [47]RSS is also available, and headlines appear on [48]haskell.org. Headlines are available as [49]PDF. To help create new editions of this newsletter, please see the [50]contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get [51]http://www.cse.unsw.edu.au/~dons/code/hwn 44. http://www.haskell.org/mailman/listinfo/haskell 45. http://sequence.complete.org/ 46. http://planet.haskell.org/ 47. http://sequence.complete.org/node/feed 48. http://haskell.org/ 49. http://www.cse.unsw.edu.au/~dons/code/hwn/archives/20070312.pdf 50. http://haskell.org/haskellwiki/HWN 51. http://www.cse.unsw.edu.au/~dons/code/hwn

1 0

State of Ignorance
by Hans van Thiel 12 Mar '07

12 Mar '07

Hello All, I have the following functions, based on Thompson's CFP example (also in Control.Monad.State documentation) of using a state monad on a tree. My functions (on a list) work, but I don't understand why. Main> getInds ["house","tree","cat","house","cat","dog","tree"] [0,1,2,0,2,3,1] Main> getTb ["house","tree","cat","house","cat","dog","tree"] ["house","tree","cat","dog"] This, from CFP, is clear enough. repl1 :: String -> [String] -> ([String], Int) repl1 x tb | elem x tb = (tb, fromJust (elemIndex x tb)) | otherwise = (tb ++ [x], length tb) then, turn this into a function to a state monad type: toMyState :: String -> MyState String Int toMyState x = MyStateC (repl1 x) where the monad is defined as: data MyState a b = MyStateC ([a] -> ([a], b)) instance Monad (MyState a) where return x = MyStateC (\tb -> (tb, x)) (MyStateC st) >>= f = MyStateC (\tb -> let (newtb, y) = st tb (MyStateC trans) = f y in trans newtb ) Now I understand this (barely) in the sense that >>= works through defining how f takes its values from st. So, f would be the function: toMystate and trans would be: (repl1 x). But then y would have to be of type String, whereas the y in the tuple would have type Int, since it is generated by st. I just don't get it. Next the book explains how to extract values from a state and again that's pretty clear: extr1 :: MyState a b -> b extr1 (MyStateC st) = snd (st []) extr2 :: MyState a b -> [a] extr2 (MyStateC st) = fst (st []) I have a list instead of a tree, so I tried: strtoMS :: [String] -> [MyState String Int] strtoMS ls = map toMyState ls and the final functions are: getInds :: [String] -> [Int] getInds = extr1 . sequence . strtoMS getTb :: [String] -> [String] getTb = extr2 . sequence . strtoMS They work, but now I don't understand sequence, defined in the Prelude. From: a Tour of the Haskell Monad Functions http://members.chello.nl/hjgtuyl/tourdemonad.html sequence :: Monad m => [m a] -> m [a] sequence = foldr mcons (return []) where mcons p q = p >>= \x -> q >>= \y -> return (x : y) This has a different bind (>>=) from the one in the MyState monad, yet is appears to perform all the state transformations. The documentation says: "sequence xs evaluates all monadic values in the list xs, from left to right, and returns a list of the "contents" of these monads, placing this list in a monad of the same type. Note, that "evaluating" can be interpreted as "performing an action", for example in the case of print." It looks to me as if sequence works here because values of MyState are themselves functions, but how? Many thanks for any pointers and clarification! Hans van Thiel

2 1

Simple benchmark of list operations?
by Bulat Ziganshin 11 Mar '07

11 Mar '07

Hello haskell-cafe, Page http://community.livejournal.com/ru_lambda/44716.html contains three very simple but long-working benchmark functions: dummy :: [Int] -> [Int] dummy [] = [] dummy (x:xs) = x:dummy (dummy xs) dummy2 :: [Int] -> [Int] dummy2 = dum [] where dum w [] = w dum w (x:xs) = dum (w++[x]) (dummy2 xs) dummy3 :: [Int] -> [Int] dummy3 = dum [] where dum w [] = reverse w dum w (x:xs) = dum (x:w) (dummy3 xs) *Main> dummy [1..21] [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21] (16.97 secs, 157120860 bytes) *Main> dummy2 [1..21] [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21] (2.42 secs, 151470452 bytes) *Main> dummy3 [1..21] [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21] (1.78 secs, 84642856 bytes) *Main> Is it interesting for testing haskell compilers? -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

2 1

Program Command Line Arguments
by unknown＠example.com 11 Mar '07

11 Mar '07

My apologies if this is a question with a trivial answer. Command line args in C are accessed via argc and argv[] defined as arguments to main();. How are command line arguments to a ghc-compiled program accessed in Haskell? Or is that even possible? Thanks.

3 2

literate Haskell newbie question
by Immanuel Normann 11 Mar '07

11 Mar '07

I am a newbie to literate Haskell and these are my two simple questions: How do I compile a literate haskell file foo.lhs (using ghc-6.6)? Is there a tool that translates foo.lhs to foo.hs? Surprisingly I don't find the answer in http://haskell.org/haskellwiki/Literate_programming whereas a lot about translation into tex-files can be found. Thanks, Immanuel

4 3

Implementation of "Dynamic" datatype
by Isaac Dupree 10 Mar '07

10 Mar '07

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 Currently we have data Dynamic = Dynamic TypeRep Obj where Obj is {-in GHC up to 6.6-} type Obj = forall a . a {-in GHC 6.7.something-} type Obj = Any -- Use GHC's primitive 'Any' type to hold the dynamically typed value. {-in some other compilers (like Hugs)-} data Obj = Obj ( According to this comment, it is not data Obj = Obj in GHC now because: -- In GHC's new eval/apply execution model this type must not -- look like a data type. If it did, GHC would use the -- constructor convention when evaluating it, and this will go -- wrong if the object is really a function. Using Any [or, -- earlier comments said, a polymorphic type] forces GHC to use -- a fallback convention for evaluating it that works for all -- types. ) So, my question is: why doesn't it just use an existential? : data Dynamic = forall a. Dynamic TypeRep a According to http://hackage.haskell.org/trac/haskell-prime/wiki/HaskellExtensions , all important implementations support existentials (and it will probably go into Haskell'). It seems semantically the most accurate, doesn't require an unsafeCoerce when _constructing_ a Dynamic, and doesn't require unsafeCoercing between unequal types (which had caused problems in GHC as noted above), so it seems like it could be a portable implementation. A quick copy of Dynamic.hs with these modifications seemed to work fine in ghc6.4.2, ghc6.6, and hugs20050308 (which is all haskell implementations that are working for me at the moment (nhc98 is broken for me) and that have Data.Typeable (not yhc currently, it seems)). ( Also I wonder about the performance implications of changing it to data Dynamic = forall a. Typeable a => Dynamic a or making the TypeRep be a strict field (which shouldn't have any semantic impact since typeOf always succeeds(assuming no-one defines a horrible instance of Typeable) and typeOf's result is always what is put into that field. (Separately, should seq'ing a Dynamic seq the encapsulated object, or should Dynamic act as a box as it does now?)). ) Anyway, how would I go about seriously testing this in ghc, hugs... to see if it breaks anything (and also see how it affects Dynamic's performance)? (Since I am interested in the refactoring of the base/core libraries, a little something like this seems like a good place to start learning how to test what I have.) Isaac - - Was this a good mailing list to choose for this question? (And was it a good question? what about all the little question-ideas branching off of it? I can never be sure...) -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.3 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org iD8DBQFF6LVSHgcxvIWYTTURAoeTAKCP8XIn4pVXnJsimEX8aAgIcXLb1ACbBOw2 elKn59TdPKiAJq8VA4MOd0o= =NF4R -----END PGP SIGNATURE-----

5 10

Google summer of code
by Malcolm Wallace 10 Mar '07

10 Mar '07

Google Summer of Code As many of you will already know, Google is running its "Summer of Code" project again this year, and haskell.org is once again going to apply to be a mentoring organisation. Are you a student who would like to earn money for hacking in Haskell? Or are you a non-student who has a cool idea for a coding project but no time to do it yourself? Well, our wiki to gather ideas is now up-and-running again: http://hackage.haskell.org/trac/summer-of-code Add yourself to the list of interested people! There are some ideas still there from last year. Add new ones! Google will start accepting student applications in just over a week's time, but now is the time to start using our own wiki to match up interesting ideas with interested people. The official timeline is as follows: March 12: Mentoring organization application deadline March 14: List of accepted mentoring organizations published March 14: Student application period opens March 24: Student application deadline Interim Period: we review and rank student proposals April 9: List of accepted student applications published Interim Period: Students learn more about their project communities May 28: Students begin coding; Google begins issuing initial payments July 9: Students upload code to code.google.com/hosting; July 16: Google begins issuing mid-term payments August 20: Students upload code to code.google.com/hosting; August 31: Final evaluation deadline; Google begins issuing final payments Regards, Malcolm

6 6

auto-completion for Vim 7
by Stephan Walter 10 Mar '07

10 Mar '07

Hi, I started to write a Vim script for the new omni-completion feature of Vim 7. If you use Vim you might want to check it out: * download http://stephan.walter.name/files/haskellcomplete.vim and put it in ~/.vim/plugin * :set omnifunc=haskellcomplete#CompleteHaskell * press <c-x><c-o> to complete (The advantage of omni-completion over normal completion using <c-n> and <c-p> is that you can write you own function which does some smart guessing to offer good completions) So far the functionality is *very* limited. It will autocomplete a few functions from the prelude as well as functions in the current file that have a type declaration. If you look through the source code of the script, you'll see that I have included some function names and types from the standard libraries. Before I continue this (rather tedious) work, I wanted to know what the cafe patrons think about it. If someone knows of a simple way to generate a function/type list of the standard modules, I'd love to hear about it. Generating such a list on the fly each time is probably not an option, as it would be too slow. -Stephan

5 9

library for generating HTML and LaTeX
by Henning Thielemann 10 Mar '07

10 Mar '07

We have Text.Html in the standard libraries for generating HTML code. Is there also a library for generating LaTeX code? Or even better: Is there a library which can emit the same document with markup in HTML, LaTeX or a different markup language? Frequently I like to present results of some computations and then I start hacking output for LaTeX and I wonder if there is a simpler solution.

2 2

Fwd: [Haskell-cafe] Re: Haskell spacing problem.
by Mark Goldman 09 Mar '07

09 Mar '07

Oops, think I didn't send this to cafe, forgive any duplicates please. -mdg ---------- Forwarded message ---------- From: Mark Goldman <bitshifter(a)gmail.com> Date: Mar 9, 2007 8:37 AM Subject: Re: [Haskell-cafe] Re: Haskell spacing problem. To: Frozz <dj_frozz(a)hotmail.com> >From a different angle, are you looking at the text file with a proportional font instead of a fixed width font? With a proportional font each letter takes up a different amount of horizontal space which mucks up most ASCII based formating. -mdg On 3/9/07, Frozz <dj_frozz(a)hotmail.com> wrote: > prettyPrint seems complicated.. > > Dan Mead <d.w.mead <at> gmail.com> writes: > > > > > > > that seems like the "wrong" waycheck out prettyprint in the standard library > > > > On 3/9/07, Frozz < > > dj_frozz <at> hotmail.com> wrote:Hi Haskell ppl,I'm trying to solve a > problem that had been bothering me for a long time. I'm > > trying to create index and display the index in Hugs as well as an output > textfile.Below is my code. In Hugs, the index managed to get displayed well > with nicealignments. However, for the text file, the alignment is off. The > bracket with > > the numbers are messy. I really don't know why this would happen.Desired > output:Anna [1]Ben[2]Shane[3]dispTable :: [([Int], Word)] -> > StringdispTable = unlines . map (\ (num,word) -> word ++ > > take (25 - (length word)) (repeat ' ')++ show num)Did i do sth > wrong? Thanks in > advance._______________________________________________Haskell-Cafe mailing > list > > Haskell-Cafe <at> haskell.orghttp://www.haskell.org/mailman/listinfo/haskell- > cafe > > > > > > > > > > > > _______________________________________________ > > Haskell-Cafe mailing list > > Haskell-Cafe <at> 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 > -- Our problems are mostly behind us, now all we have to do is fight the solutions. -- Our problems are mostly behind us, now all we have to do is fight the solutions.

1 0

Haskell spacing problem.
by Frozz 09 Mar '07

09 Mar '07

Hi Haskell ppl, I'm trying to solve a problem that had been bothering me for a long time. I'm trying to create index and display the index in Hugs as well as an output text file. Below is my code. In Hugs, the index managed to get displayed well with nice alignments. However, for the text file, the alignment is off. The bracket with the numbers are messy. I really don't know why this would happen. Desired output: Anna [1] Ben [2] Shane [3] dispTable :: [([Int], Word)] -> String dispTable = unlines . map (\ (num,word) -> word ++ take (25 - (length word)) (repeat ' ') ++ show num) Did i do sth wrong? Thanks in advance.

3 3

Distributing a GHC-compiled binary for Macs (x86)
by Arjun Guha 09 Mar '07

09 Mar '07

Hi, I compiled a binary using GHC 6.6 on my Mac (specifically, using ghc --make). This binary seems to depend on the GNU MP framework--I imagine GHC uses it to implement its numeric tower. However, Macs that don't have GHC installed don't seem to have GMP, so I'll guess that it was installed along with the GHC binary. Is there any way to get around this GMP dependency? I expect the binary to be used on Macs that don't have GHC installed. It would be acceptable if I instructed Mac-users to download a binary installer for GMP, but I haven't been able to find one. Any hints or suggestions would be appreciated. Thanks. Arjun

3 3

A different Maybe maybe
by Joachim Breitner 09 Mar '07

09 Mar '07

[Also on http://www.joachim-breitner.de/blog/archives/229-A-different-Maybe-maybe.ht…] Hi, For a while I have been thinking: Isn’t there a way to get rid of the intermediate Maybe construct in a common expression like “fromMaybe default . lookup”. It seems that a way to do that would be to pass more information to the Maybe-generating function: What to do with a Just-Value, and what to return in case of Nothing. This leads to a new definion of the Maybe data type as a function. Later I discovered that this seems to work for any algebraic data type. This is probably nothing new, but was offline at the time of writing, so I didn’t check. This means that this might also be total rubbish. Enjoy. * “Algebraic Data Type Done Differently” (PDF-File) at http://www.joachim-breitner.de/various/FunctionalMaybe.pdf * “Algebraic Data Type Done Differently” (Literate Haskell Source) at http://www.joachim-breitner.de/various/FunctionalMaybe.lhs Comments are appreciated. Greetings from my holidays, Joachim -- Joachim "nomeata" Breitner mail: mail(a)joachim-breitner.de | ICQ# 74513189 | GPG-Key: 4743206C JID: joachimbreitner(a)amessage.de | http://www.joachim-breitner.de/ Debian Developer: nomeata(a)debian.org

10 12

Re: [Haskell] Summer of Code questions
by Malcolm Wallace 09 Mar '07

09 Mar '07

Wolfgang Jeltsch <g9ks157k(a)acme.softbase.org> writes: > First, what organization is Haskell.org? That would be us, right here. Anyone who is interested enough in Haskell to be involved in mailing lists, IRC, distributing library code and tools, whatever. > Is this a real organization, i.e., a legal entity? No. (Unlike e.g. the Apache Foundation.) > Does Haskell.org get the $ 500 for each successful project? > If yes, what does Haskell.org do with this money? Yes, we get the money. Last year, Galois kindly served as the account holder that received the cheque. The mentors involved get to decide what happens to it. I think we are planning to spend last year's on machine/bandwidth for hosting hackage.haskell.org. > Furthermore, the Google Summer of Code FAQ talks about *the* project of a > organization which seems to indicate that each organization has only > one SoC project. The model is that an open-source organisation does indeed usually have one focus, e.g. apache, Linux kernel, GTK, Gnome, Python. But of course there can be smaller tools and focuses within each overarching theme. > What is the project of the Haskell.org organization then? Is this > the general project "The Haskell language plus associated libraries and > tools"? Exactly so. > The FAQ says "Mentor organizations must be organizations or individuals > running an active and viable open source or free software project". Does > this mean that the above-mentioned general project has to be active and > viable (which it is) or that each concrete idea has to be part of an active > and viable project? The former. Decisions about concrete ideas are made collectively by the organisation, and we could certainly decide to go for a relatively immature concrete idea, if it looks both viable and of sufficient value to the community as a whole. > That is, is it allowed to start a new concrete project > by letting a student code for it as part of the SoC or wouldnât this be > possible since a new project isnât yet active and viable? Yes, you can do. It will have to compete with other ideas for top ranking. > Who decides which ideas will be worked on and who decides which student > works on which? Each organisation (in practice, this means a group of people prepared to be mentors) reads and ranks student proposals. After a certain date, Google tell us how many projects they will fund, and the top N are given the money. > What are the obligations of a mentor? (a) To carefully read and vote on quite a lot of student proposals. (b) If chosen to mentor a funded project, to guide the student throughout the project time, primarily by email (and/or IRC). Also to write two reports on progress (mid-term and final), that directly determine whether the student gets paid. > Is it okay to create an idea, become the mentor for this idea > and propose a concrete student for it? Sure. But your idea and student will need to compete for ranking. > What do I have to do to become a mentor? Start by adding yourself to the wiki. > What are Haskell.org's criteria for selecting mentors? According to the > above-mentioned FAQ, Google wants to know these criteria as specifically as > possible. I'm not sure we have definite criteria. I guess that the community generally recognises your name as a contributor to the Haskell language, libraries, tools, or whatever. Regular and visible engagement with the community would count for a lot. > Finally, should the ideas be chosen so that they are solvable by a student > working full time on them during the three months of the SoC? Exactly so. This year, Google have set things up with a greater time period between notification of acceptance, and the official beginning of coding, so that students have more preparation time before full-time work starts. > The problem is that at many German universities lectures go until > July. At our university, for example, lecture time ends in mid of July > and is followed by two weeks for exams. So a faithful student would > only have the last month for working full time on the SoC. Google have indeed set up the timetable largely with US universities in mind. So yes, it is certainly a disadvantage to a German student that they cannot work full-time for the three months. Regards, Malcolm

1 0

open a browser from the command line, wait a few seconds, and shut it. (ie, translate forking from bash to haskell)
by Thomas Hartman 09 Mar '07

09 Mar '07

I have a bash script that opens a browser for a few seconds, and then closes it. Could someone point me up the equivelant(s) in haskell, h4sh, hsh, etc,0 and friends? I reckon this amounts to, what's the process for translating forking from bash to haskell. ******** #!/bin/bash konqueror http://www.google.com & pid=$! # give the page some time to load sleep 5 kill $pid ******** By the way, this isn't an academic question -- I'm using this simple script to verify various html downloads by checking the konqueror html cache for text strings I'm interested in, for pages that can't be easily downloaded with wget/web mechanize because of javascript and redirect nastiness. Also, for those interested in shell-equivelance strategies, I posted essentially the same question to perlmonks at http://perlmonks.org/?node_id=603868

2 1

Re: [Haskell-cafe] TVars & throw
by Thomas Conway 09 Mar '07

09 Mar '07

On 3/8/07, Chris Kuklewicz <haskell(a)list.mightyreason.com> wrote: > What happens in your throw/catch case if I have > stm1 = do some_stm_code_that_throws_your_exception > stm2 = return Foo > and I run "atomically (stm1 `orElse` stm2)" ? > Answer: The exception will prevent running stm2. In the *specific* case of the external dictionary code, there is no orElse case to worry about since the algorithms are deterministic in this sense. For a more general case, it is an interesting problem to consider. You might want something like throwIfNothingElseSeemsLikeAGoodIdea, so that you can attempt any alternatives, and if none succeed then throw (and I guess choose the first if more than one alternative wants to throw - I like determinism). > > Um, is > > unsafeIOToSTM $ atomically trans > > going to run you into problems? > > YES! My point is that onRetry really wants to be not "IO t" but "IO_execpt_STM t", but there's no way of ensuring that, which unfortunately antagonizes modularity in the same kind of way that locks do. It requires you to know how the implementation of the IO actions you use work, in case they use STM inside. Since the actions may come out of a library somewhere, you need to know how the library is implemented. <sigh> Why are tricky problems tricky? I thought Haskell was supposed to make everything easy. ;-) T. -- Dr Thomas Conway You are beautiful; but learn to work, drtomc(a)gmail.com for you cannot eat your beauty. -- Congo proverb

1 0

EnumSet and EnumMap
by Chris Kuklewicz 09 Mar '07

09 Mar '07

I could not quickly find anyone else writing this boiler plate, so I have posted this useful wrapper on the Haskell wiki at http://haskell.org/haskellwiki/EnumSet_EnumMap This uses a cheap newtype to wrap IntSet and IntMap so that you can store any Enum in them. It saves either writing many toEnum/fromEnum functions or using the slower and more generic Data.Set and Data.Map. The original motivation was to go from Map Char to IntMap. And as a bonus, the type signature of the newtype is the same kind as Data.Set and Data.Map (which matters when declaring instances...) > newtype EnumSet e = EnumSet {unEnumSet :: S.IntSet} > deriving (Monoid,Eq,Read,Show,Ord) > newtype EnumMap k a = EnumMap {unEnumMap :: M.IntMap a} > deriving (Eq,Read,Show,Ord,Monoid,Foldable,Functor) This has been quickly tested with GHC 6.6 and may contain typographical errors I have not caught yet. -- Chris

2 1

Re: [Haskell-cafe] Usage of . and $
by David House 09 Mar '07

09 Mar '07

On 07/03/07, Thomas Conway <drtomc(a)gmail.com> wrote: > Of course, what really gets me, is when I start trying to use $ in > type signatures and declarations: > ... Map ByteString $ foo (bar baz) qux .... It's almost possible! GHC gives us infix type synonyms: type a $ b = a b (Probably needs -fglasgow-exts.) Sadly we don't have a fixity system for type operators :( -- -David House, dmhouse(a)gmail.com

2 2