- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] A function for Maybes (RESOLVED)
by John Ky 26 Jan '07

26 Jan '07

Thanks -John On 1/26/07, Brandon S. Allbery KF8NH <allbery(a)ece.cmu.edu> wrote: > > > On Jan 25, 2007, at 9:15 , John Ky wrote: > > > Is there a built-in function that already does this? > > > > foo :: (a -> b) -> Maybe a -> Maybe b > > foo f m > > | isNothing m = Nothing > > | otherwise = Just (f (fromJust m)) > > Nothing specific to Maybe, because the more general liftM (over > monads) or fmap (over functors) already does it. > > -- > brandon s. allbery [linux,solaris,freebsd,perl] allbery(a)kf8nh.com > system administrator [openafs,heimdal,too many hats] allbery(a)ece.cmu.edu > electrical and computer engineering, carnegie mellon university KF8NH > > > >

1 0

Re: [Haskell-cafe] No Derived Read for Unboxed Arrays
by dons＠cse.unsw.edu.au 26 Jan '07

26 Jan '07

ndmitchell: > HI Don > > >> (But of course, having Read/Show defined for UArray may well be > >> useful, and sounds a good idea) > > > >There's also an instance Binary for UArray. That might be useful? > > Is there an instance Binary in a released library? If in doubt, look on hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/binary/0.2 -- Don

1 0

A function for Maybes
by John Ky 26 Jan '07

26 Jan '07

Is there a built-in function that already does this? foo :: (a -> b) -> Maybe a -> Maybe b foo f m | isNothing m = Nothing | otherwise = Just (f (fromJust m)) *Main> foo (+2) (Just 3) Just 5 *Main> foo (+2) Nothing Nothing If so what is it? If not, what should I call it? Thanks -John

6 5

Monomorphism restriction
by Marco Túlio Gontijo e Silva 25 Jan '07

25 Jan '07

Hello, I talked for a while with bd_ about this on #haskell, and I think maybe I'm just being silly. But I can't get why: > lambda = \x -> length (show x) or > dot = length . show is different from > pre x = length $ show x I read about monomorphism restriction on the haskell 98 report, but I couldn't find where it explains the reason why these different versions influence on type infer. Thanks for any help. -- malebria Marco Túlio Gontijo e Silva Correio (MSN): malebria(a)riseup.net Jabber (GTalk): malebria(a)jabber.org Ekiga: malebria(a)ekiga.net IRC: malebria(a)irc.freenode.net malebria(a)irc.oftc.org Skype: marcotmarcot Telefone: 33346720 Celular: 98116720 Endereço: Rua Paula Cândido, 257/201 Gutierrez 30430-260 Belo Horizonte/MG Brasil

4 5

Re: [Haskell-cafe] IO is not a monad
by Yitzchak Gale 25 Jan '07

25 Jan '07

Scott Turner wrote: > Paul B. Levy's studies of "call-by-push-value" model strictness/laziness using > a category theoretic approach. That sounds interesting. Do you have a reference for that? Thanks, Yitz

2 1

basic field questions
by jamin1001 25 Jan '07

25 Jan '07

Hi, I am new at Haskell and have some basic questions. Is there any way to do this more effectively? This causes the GHC compile error "Multiple declarations of Main.test": data A = A {test :: Int} data B = B {test :: Int} The Haskell 98 report in 4.2.1 under Labelled Fields says "A label cannot be shared by more than one type in scope. Field names share the top level namespace with ordinary variables and class methods and must not conflict with other top level names in scope." So then how should this be done? What if I want to do something like data Chair = Chair {pos:: Int, color :: Int} data Table = Table {pos:: Int, color :: Int} Also, could someone tell me why this doesn't compile in GHC: data Test = A {a::Int} | B {a::Int, b::Int} data Test2 = C {c::A} (Test2 line): Not in scope: type constructor or class 'A' Is there a way to qualify identical field names? What are some standard practices for dealing with this? Thanks, Jamin Ohmoto-Frederick -- View this message in context: http://www.nabble.com/basic-field-questions-tf3080392.html#a8558522 Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

7 10

class question
by Hans van Thiel 25 Jan '07

25 Jan '07

Hello, I'm trying to understand classes and defined: class Monoid a where e :: a add :: a -> a -> a add a e = a add e a = a instance Monoid a Int where e = 0 add x y = x + y This works just fine, also for instance definitions of Char, Bool and lists. But defining: class (Num a, Monoid a) => NumMon a where e = 0 add x y = x + y reults in error messages. -- Hugs: ERROR "Chap12.hs":57 - No member "e" in class "NumMon" -- GHCi: Chap12.hs:58:3: `add' is not a (visible) method of class NumMon' I've also tried instance definitions of NumMon (leaving out 'where' and what's next in the class declaration) and get similar messages. The definition of NumMon by itself, just the first line, is accepted by Hugs and GHCi both. What am I doing wrong? Many thanks in advance. Hans van Thiel

3 5

Re: [Haskell-cafe] Strings in Haskell
by Bryan Donlan 24 Jan '07

24 Jan '07

Neil Mitchell wrote: > Hi Alexy, > >> Now I'm reading a >> Haskell book which states the same. Is there a more efficient Haskell >> string-handling method? Which functional language is the most >> suitable for text processing? > > There are the Data.ByteString things, which are great, and have much > less overhead. > > But remember that Haskell is lazy. If you are thinking "well I have to > process a 50Mb file", remember that Haskell will lazily read and > process this file, which substantially reduces the memory requirements > so only a small portion will ever be in memory at a time. Or you can get the best of both worlds by using Data.ByteString.Lazy :) Even with laziness, all the indirections that String causes hurts performance.

3 2

small step evaluation as an unfold?
by Steve Downey 24 Jan '07

24 Jan '07

(overall context - working through TaPL on my own, reimplemnting typecheckers in haskell) the type checkers all follow the same pattern, in ocaml they throw an exception when the small step fails, which may mean taking another branch in the eval, but that that sub expression has hit bottom. it is self admittedly not good ocaml, and it seems to be even worse haskell, as i try to extend the simple evaluator i have to deal with managing reporting errors. having the single small step evaluator return a Maybe is fairly close. then the evaluator above it just bottoms out when eval1 expr returns Nothing, by passing expr back up as the result. but it occurs to me that it might be better to express it as an unfold, where the result is a list with the last element as the irresucible expression. or am i insane / intoxicated ?

2 2

Re: small step evaluation as an unfold?
by Steve Downey 24 Jan '07

24 Jan '07

good, it felt like something that might have occurred to someone before. On 1/23/07, Nicolas Frisby <nicolas.frisby(a)gmail.com> wrote: > Jeremy Gibbons thought of it; that's good company ;) > > http://portal.acm.org/citation.cfm?id=289457 > > > > On 1/23/07, Steve Downey <sdowney(a)gmail.com> wrote: > > (overall context - working through TaPL on my own, reimplemnting > > typecheckers in haskell) > > the type checkers all follow the same pattern, in ocaml they throw an > > exception when the small step fails, which may mean taking another > > branch in the eval, but that that sub expression has hit bottom. > > > > it is self admittedly not good ocaml, and it seems to be even worse > > haskell, as i try to extend the simple evaluator i have to deal with > > managing reporting errors. > > > > having the single small step evaluator return a Maybe is fairly close. > > then the evaluator above it just bottoms out when eval1 expr returns > > Nothing, by passing expr back up as the result. > > > > but it occurs to me that it might be better to express it as an > > unfold, where the result is a list with the last element as the > > irresucible expression. > > > > or am i insane / intoxicated ? > > _______________________________________________ > > Haskell-Cafe mailing list > > Haskell-Cafe(a)haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-cafe > > >

1 0

PDF library?
by Clifford Beshers 24 Jan '07

24 Jan '07

I don't suppose anyone has any Haskell code that understands the PDF format, do they?

4 3

embedding haskell into html
by Forest Liu 24 Jan '07

24 Jan '07

I am new to haskell, and now working on embedding haskell into html. Thus we will write webapp using haskell as server-side language like php. Here I explain my plan and ask some questions, looking for experienced ones to discuss with. It is not proper embedding lines of haskell code into html (like php). Because we would not know what to output, as it is not a procedural language as php. I think the proper way is using a single tag containing a haskell expression (usually a function name) each time of needing haskell. I call it "hasp" standing for "HASkell Page" :). It should look like: <html> <head><title><?hasp genTitle?></title></head> <body> ...some html... <?hasp getDataFromDB?> ...some html... </body> </html> And the functions ("genTitle", "getDataFromDB") should be implemented in "/same_dir_to_hasps/hs/same_name_to_each_hasp.hs" . It just like the templates in php. There are two possible ways to implementing the mechanism: compiled-CGI, and interpreting(or Just-In-Time Compilation) 1. Complied-CGI: use a preprocessor to combine the hasp templates and hs implementations, then compiled by ghc to generate cgi-bins. That should be easy for me to implement. 2.Interpreting (or JIT-Compilation) I prefer this method because modern web-scripting programmers should be familiar with it. The browser request for somepage.hasp, and Apache knows giving it to hasp interpreter to handle. I am facing to the dilemma between interpreting or JIT-Compilation. The best situation is a perfect haskell interpreting procedure written in haskell. I am trying hs-plugins, and I hope it will help me a lot. Or any other "haskell interpreting procedure written in haskell" you can tell me? The trouble about JIT-Compilation is that hasp-handler must call ghc through OS shell commandline using System.Cmd, and that is not proper in Apache cgi handler(lots of stuff to configure). BTW, if the "haskell interpreting procedure written in haskell" does not work well, I could use cmdline "ghc -e some_expr file.hs" to evaluate the expr, though an ugly way. And in that case, we would face to the problem of "external cmd of CGI" again. -- Sincerely, Forest Liu(��S)

2 1

catch the stdout when execute a shell cmd
by Forest Liu 24 Jan '07

24 Jan '07

I use "system" in System.Cmd to execute a shell cmd, then how can I catch its stdout? -- Sincerely, Forest Liu(��S)

2 1

GADTs are expressive
by Jim Apple 24 Jan '07

24 Jan '07

To show how expressive GADTs are, the datatype Terminating can hold any term in the untyped lambda calculus that terminates, and none that don't. I don't think that an encoding of this is too surprising, but I thought it might be a good demonstration of the power that GADTs bring. {-# OPTIONS -fglasgow-exts #-} {- Using GADTs to encode normalizable and non-normalizable terms in the lambda calculus. For definitions of normalizable and de Bruin indices, I used: Christian Urban and Stefan Berghofer - A Head-to-Head Comparison of de Bruijn Indices and Names. In Proceedings of the International Workshop on Logical Frameworks and Meta-Languages: Theory and Practice (LFMTP 2006). Seattle, USA. ENTCS. Pages 46-59 http://www4.in.tum.de/~urbanc/Publications/lfmtp-06.ps @incollection{ pierce97foundational, author = "Benjamin Pierce", title = "Foundational Calculi for Programming Languages", booktitle = "The Computer Science and Engineering Handbook", publisher = "CRC Press", address = "Boca Raton, FL", editor = "Allen B. Tucker", year = "1997", url = "citeseer.ist.psu.edu/pierce95foundational.html" } -} module Terminating where -- Terms in the untyped lambda-calculus with the de Bruijn representation data Term t where Var :: Nat n -> Term (Var n) Lambda :: Term t -> Term (Lambda t) Apply :: Term t1 -> Term t2 -> Term (Apply t1 t2) -- Natural numbers data Nat n where Zero :: Nat Z Succ :: Nat n -> Nat (S n) data Z data S n data Var t data Lambda t data Apply t1 t2 data Less n m where LessZero :: Less Z (S n) LessSucc :: Less n m -> Less (S n) (S m) data Equal a b where Equal :: Equal a a data Plus a b c where PlusZero :: Plus Z b b PlusSucc :: Plus a b c -> Plus (S a) b (S c) {- We can reduce a term by function application, reduction under the lambda, or reduction of either side of an application. We don't need this full power, since we could get by with normal-order evaluation, but that required a more complicated datatype for Reduce. -} data Reduce t1 t2 where ReduceSimple :: Replace Z t1 t2 t3 -> Reduce (Apply (Lambda t1) t2) t3 ReduceLambda :: Reduce t1 t2 -> Reduce (Lambda t1) (Lambda t2) ReduceApplyLeft :: Reduce t1 t2 -> Reduce (Apply t1 t3) (Apply t2 t3) ReduceApplyRight :: Reduce t1 t2 -> Reduce (Apply t3 t1) (Apply t3 t2) {- Lift and Replace use the de Bruijn operations as expressed in the Urban and Berghofer paper. -} data Lift n k t1 t2 where LiftVarLess :: Less i k -> Lift n k (Var i) (Var i) LiftVarGTE :: Either (Equal i k) (Less k i) -> Plus i n r -> Lift n k (Var i) (Var r) LiftApply :: Lift n k t1 t1' -> Lift n k t2 t2' -> Lift n k (Apply t1 t2) (Apply t1' t2') LiftLambda :: Lift n (S k) t1 t2 -> Lift n k (Lambda t1) (Lambda t2) data Replace k t n r where ReplaceVarLess :: Less i k -> Replace k (Var i) n (Var i) ReplaceVarEq :: Equal i k -> Lift k Z n r -> Replace k (Var i) n r ReplaceVarMore :: Less k (S i) -> Replace k (Var (S i)) n (Var i) ReplaceApply :: Replace k t1 n r1 -> Replace k t2 n r2 -> Replace k (Apply t1 t2) n (Apply r1 r2) ReplaceLambda :: Replace (S k) t n r -> Replace k (Lambda t) n (Lambda r) {- Reflexive transitive closure of the reduction relation. -} data ReduceEventually t1 t2 where ReduceZero :: ReduceEventually t1 t1 ReduceSucc :: Reduce t1 t2 -> ReduceEventually t2 t3 -> ReduceEventually t1 t3 -- Definition of normal form: nothing with a lambda term applied to anything. data Normal t where NormalVar :: Normal (Var n) NormalLambda :: Normal t -> Normal (Lambda t) NormalApplyVar :: Normal t -> Normal (Apply (Var i) t) NormalApplyApply :: Normal (Apply t1 t2) -> Normal t3 -> Normal (Apply (Apply t1 t2) t3) -- Something is terminating when it reduces to something normal data Terminating where Terminating :: Term t -> ReduceEventually t t' -> Normal t' -> Terminating {- We can encode terms that are non-terminating, even though this set is only co-recursively enumerable, so we can't actually prove all of the non-normalizable terms of the lambda calculus are non-normalizable. -} data Reducible t1 where Reducible :: Reduce t1 t2 -> Reducible t1 -- A term is non-normalizable if, no matter how many reductions you have applied, -- you can still apply one more. type Infinite t1 = forall t2 . ReduceEventually t1 t2 -> Reducible t2 data NonTerminating where NonTerminating :: Term t -> Infinite t -> NonTerminating -- x test1 :: Terminating test1 = Terminating (Var Zero) ReduceZero NormalVar -- (\x . x)@y test2 :: Terminating test2 = Terminating (Apply (Lambda (Var Zero))(Var Zero)) (ReduceSucc (ReduceSimple (ReplaceVarEq Equal (LiftVarGTE (Left Equal) PlusZero))) ReduceZero) NormalVar -- omega = \x.x@x type Omega = Lambda (Apply (Var Z) (Var Z)) omega = Lambda (Apply (Var Zero) (Var Zero)) -- (\x . \y . y)@(\z.z@z) test3 :: Terminating test3 = Terminating (Apply (Lambda (Lambda (Var Zero))) omega) (ReduceSucc (ReduceSimple (ReplaceLambda (ReplaceVarLess LessZero))) ReduceZero) (NormalLambda NormalVar) -- (\x.x@x)(\x.x@x) test4 :: NonTerminating test4 = NonTerminating (Apply omega omega) help3 help1 :: Reducible (Apply Omega Omega) help1 = Reducible (ReduceSimple (ReplaceApply (ReplaceVarEq Equal (LiftLambda (LiftApply (LiftVarLess LessZero) (LiftVarLess LessZero)))) (ReplaceVarEq Equal (LiftLambda (LiftApply (LiftVarLess LessZero) (LiftVarLess LessZero)))))) help2 :: ReduceEventually (Apply Omega Omega) t -> Equal (Apply Omega Omega) t help2 ReduceZero = Equal help2 (ReduceSucc (ReduceSimple (ReplaceApply (ReplaceVarEq _ (LiftLambda (LiftApply (LiftVarLess _) (LiftVarLess _)))) (ReplaceVarEq _ (LiftLambda (LiftApply (LiftVarLess _) (LiftVarLess _)))))) y) = case help2 y of Equal -> Equal help3 :: Infinite (Apply Omega Omega) help3 x = case help2 x of Equal -> help1

6 9

Announce: Package rdtsc for reading IA-32 time stamp counters
by Martin Grabmueller 24 Jan '07

24 Jan '07

Hallo all, version 1.0 of package rdtsc has just been released. This small package contains one module called 'Rdtsc.Rdtsc'. This module provides the function 'rdtsc' for accessing the 'rdtsc' machine register on modern IA-32 processors. This is a 64-bit counter which counts the number of processor cycles since the machine has been powered up. Using this instruction, you can make very precise time measurements which are independent of the actual CPU frequency. But note that you can get strange results sometimes on a superscalar processor. A small program using this library looks like this: module Main where import Rdtsc.Rdtsc main = do t1 <- rdtsc t2 <- rdtsc putStrLn ("Cost of rdtsc (ffi call): " ++ show (t2 - t1)) Note that the Haskell foreign function interface imposes some additional overheads. On my machine, it takes about 950 cycles to call this function twice and to compute the difference, whereas in C the overhead is only about 84 cycles. The documentation for the package is available here: http://uebb.cs.tu-berlin.de/~magr/projects/rdtsc/ Download the source using darcs: darcs get http://uebb.cs.tu-berlin.de/~magr/darcs/rdtsc/ I would really like to get feedback on this little package, which already has been quite useful for me. Have fun and Happy Haskell Hacking in th New Year, Martin

6 7

Re: [Haskell-cafe] Strings in Haskell
by Alexy Khrabrov 24 Jan '07

24 Jan '07

I wonder if that's another reason OCaml is used in a(t least one) hedge fund -- why Jane St. preferred OCaml to Haskell, I wonder? Was it the state of affairs then that OCaml was more efficient (? -- WAGuess), and would they prefer Haskell now? I'm trying to make sense out of OCaml objects out of that already infamously annoying "Practical OCaml" book, and class object <blah>... doesn't look like much, not to say that "class object" sounds about as bad as most English in that book. (Written by an English major... What a decline in US education! :) I come from ML background, so Haskell laziness and OCaml objects are all new to me. But my Haskell book, Haskell School of Expression, is so much better written, that I'm reading it much faster. I'm CC'ing Yaron as his e-mail comes up in my Gmail context adwords on the word "Haskell." :) I'm interested in financial data mining and market modeling -- are there any good application of FP there, say in Lisp? Cheers, Alexy P.S. Somebody with an old-fashioned mail client please feel free to change the subject to "Financial Engineering with FP," gmail seems to etch its subjects in stone. :) On 1/23/07, Martin Jambon <martin_jambon(a)emailuser.net> wrote: > On Mon, 22 Jan 2007, Alexy Khrabrov wrote: > > > Greetings -- I'm looking at several FP languages for data mining, and > > was annoyed to learn that Erlang represents each character as 8 BYTES > > in a string which is just a list of characters. Now I'm reading a > > Haskell book which states the same. Is there a more efficient Haskell > > string-handling method? Which functional language is the most > > suitable for text processing? > > In OCaml, strings are compact sequences of bytes. And you can pass them > as-is to C functions: > > http://caml.inria.fr/pub/ml-archives/caml-list/2002/08/e109df224ff0150b3020… > > > Martin > > -- > Martin Jambon > http://martin.jambon.free.fr >

6 7

strange behavior in Text.Regex.Posix
by John MacFarlane 23 Jan '07

23 Jan '07

Can anyone help me understand this odd behavior in Text.Regex.Posix (GHC 6.6)? Prelude Text.Regex.Posix Text.Regex> subRegex (mkRegex "\\^") "he\350llo" "@" "he@llo" Why does /\^/ match \350 here? Generally Text.Regex.Posix seems to work fine with unicode characters. For example, \350 is treated as a single character here: Prelude Text.Regex.Posix Text.Regex> subRegex (mkRegex "e.l") "he\350llo" "@" "h@lo" The problem is specific to \350 and doesn't happen with, say, \351: Prelude Text.Regex> subRegex (mkRegex "\\^") "he\351llo" "@" "he\351llo" Is this a bug, or just something I'm not understanding? John

2 1

Re: [Haskell] Hyperlinking source code formatter?
by Simon Marlow 23 Jan '07

23 Jan '07

Conal Elliott wrote: > I'd like to turn source code (mine and others') into a fully hyperlinked > form, in which every name reference links to the name's definition. > Syntax-coloring would be great also. I see Programmatica. Is it in > use, supported, and reasonably easy to install and use? Are there other > options? Thanks, If anyone is thinking of writing such a tool, the GHC API would be a great place to start, incedentally. Cheers, Simon

1 0

Announce: hpaste
by Eric Mertens 23 Jan '07

23 Jan '07

Hello, I am pleased to announce "hpaste", the Haskell Paste-bin. Over the course of this week many of the active #haskell members and I have been developing this application to provide #haskell with a reliable paste bot whose features are tuned to the needs of the channel. Everyone is invited to see hpaste for themselves at http://hpaste.ath.cx:8000 hpaste.org has been registered, and in a few days time will be the permanent home of hpaste. An example of how hpaste was recently used to teach can be seen at http://hpaste.ath.cx:8000/43 A paste-bin is a place for IRC users to paste and annotate code snippets in a stable environment. This keep users from flooding the channel and saves users from having to scroll back constantly to review a paste. hpaste uses haskell syntax coloring (provided by hscolour) and is able to generate a color-coded diff of two pastes to give users an additional tool to share and teach. This project was a wonderful way for me to learn both the old and new HAppS APIs which have both proven to be quite powerful. In addition to providing a web-interface, hpaste is able to announce new pastes to the IRC channel via a bot based on Don Stewart's IRC bot tutorial. darcs has been instrumental in this colaborative effort, and the hpaste source is available with: darcs get --partial http://www.scannedinavian.com/~eric/hpaste Feedback is both encouraged and welcomed! -- Eric Mertens emertens(a)gmail.com

1 0

Strings in Haskell
by Alexy Khrabrov 23 Jan '07

23 Jan '07

Greetings -- I'm looking at several FP languages for data mining, and was annoyed to learn that Erlang represents each character as 8 BYTES in a string which is just a list of characters. Now I'm reading a Haskell book which states the same. Is there a more efficient Haskell string-handling method? Which functional language is the most suitable for text processing? Cheers, Alexy

4 3

Resolution of time for threadDelay / registerDelay
by Neil Davies 23 Jan '07

23 Jan '07

The GHC concurrency run time currently forces all delays to be resolved to 1/50th of second - independent of any of the run time settings (e.g. -V flag) - with rounding to the next 1/50th of second. This means that, in practice, the "jitter" in the time that a thread wakes as compared with can be rather large - 20ms to 30ms; 20ms from the GHC base library rounding along with a "jiffy" from the operating system. As far as I can see there is no reason why there should be any quantization of delay times - the implementation creates an ordered list of times which could be at any resolution (say microseconds) - this would reduce the "jitter" to that of an operating system jiffy. Thoughts? Neil

1 0

ANN: regex-* updates and regex-tdfa 0.20 first release
by Chris Kuklewicz 23 Jan '07

23 Jan '07

Greetings. I have several bits of news about regex-* packages. First: I have fixed a small bug in one instance of RegexContext, defined in Text.Regex.Contex in the regex-base class (included in GHC). The new version of regex-base is 0.80 and is available at http://darcs.haskell.org/packages/regex-unstable/regex-base/. The instance fixed was > instance (RegexLike a b) => RegexContext a b (MatchResult b) where and I doubt this affects anyone at the moment. Second: There is also a new version of regex-tre at http://darcs.haskell.org/packages/regex-unstable/regex-tre/ (version 0.81) that exposes the 'compRightAssoc' option when making a Regex (see Text.Regex.TRE.Wrap for all the options). Third: I wish to note that that the libtre backend (up to the current version 0.7.5) that regex-tre uses is buggy and that regex-tre / libtre should only be used where testing shows that no bugs are being trigged. (Why go to that much trouble? Because the libtre backend is very very fast). Fourth: The fabulous new all Haskell POSIX compatible backend! This is a first announcement of regex-tdfa, my "tagged" DFA regular expression backend. It is an implementation of regular expressions in Haskell; it does not hand off the data to a library written in c. The ultimate goal of regex-tdfa is to replace regex-posix as the default engine that come with GHC. Why go to the trouble of replacing regex-posix? Because regex-posix is very very slow (and not quite POSIX, as seen at the end of this message). The new regex-tdfa does not use the slow backtracking method like my pure Haskell backend regex-posix. It uses a deterministic finite automata, similar in spirit to one I derived from CTKlight for use in the pure Haskell regex-dfa backend (which is LGPL -- the rest are BSD-3 license). But regex-dfa is fast at a cost of not returning any parenthesized subexpression captures (i.e only \0 and not \1 \2 \3 ...). The regex-tre backend (BSD3) that uses the libtre c library (LGPL) employs a special "tagged" dfa technique to get subexpression captures while still using an efficient DFA. The regex-posix engine that comes with GHC is impossibly slow but regex-tre is very very fast and (claims to also be) a POSIX engine. I was thus inspired to create regex-tdfa which aims to create a pure Haskell variant of this tagged-DFA algorithm under a simple BSD3 license. The 0.20 version of regex-tdfa that I am announcing is available at http://darcs.haskell.org/packages/regex-unstable/regex-tdfa/ and requires the updated regex-base (version 0.80 or greater) and is setup to compile for GHC 6.6. These could be back-ported to GHC 6.4 by adding the fps package to GHC 6.4 to get Data.ByteString and removing references to Data.Sequence in the new regex-base and regex-tdfa packages. As of now, my first untuned version of the regex-tdfa backend performs about 2-3 times slower than regex-tre and the libtre c library. This also means regex-tdfa performs 3+ times faster than the regex-parsec engine. So the goal of a fast replacement for regex-posix is close to hand. The bad news: libtre has two problems, the first is that it is buggy. I have found patterns that the libtre engine does not handle correctly: the wrong match for the whole expression and/or subexpressions is returned (or it will fail to match when it should have succeeded). The second problem is that it does not always follow the POSIX standard policy in determining which possible parenthesized subexpession captures to return when there are several possibilities. My regex-tdfa engine does not have the bugs that I have found in libtre. But since it uses the same design concepts as libtre it had the same problem with not following the POSIX standard policy for capturing subexpressions. To fix this I have exteneded the tagging technique to keep enough information to follow the POSIX spec. So of all the regex-* backends, the regex-tdfa is the only one that passes all the tests that I have for POSIX compatibility. End note: The regex-posix engine, despite its name, does not follow the POSIX standard policy for capturing subexpressions. Example 1 of 2: "ab" =~ "((a?)((ab)?))(b?)" This should capture the sub ranges (0,2)(0,2)(0,0)(0,2)(0,2)(2,2) But it does capture the sub ranges (0,2)(0,1)(0,1)(1,1)(-1,-1)(1,2) The first group is (0,2) means the whole match was \0=="ab" The second group (0,2) or (0,1) means the first group "((a?)((ab)?))" should match \1=="ab" but it returns \1=="a". This first group should have been chosen for maximum length and the failure to do so is a policy violation. Example 2 of 2: "x" =~ "(.?)*" This should capture: (0,1)(0,1) But it does capture: (0,1)(1,1) The first group of (0,1) means the regex did match the whole \0=="x". But the regex-posix engine matched an extra iteration of the "(.?)" under the "*" operator against the empty string after the "x" and returned the empty capture of (1,1). This highly non-useful behavior violates POSIX policy. My regex-parsec engine follows a non-POSIX policy, in which it maximizes the length of just the captured subexpressions instead of all the subpatterns of the regular expression. This is useful and was easy to write and is easy to explain and agrees with the policy of other libraries such as Boost.Regex for C++ ( as in the third FAQ at http://www.boost.org/libs/regex/doc/faq.html ) But to replace regex-posix I need a fast POSIX policy engine, which is what regex-tnfa has now achieved. I will submit regex-tdfa to replace regex-posix once I have a stable version that has been further cleaned up and tuned. Anyone who wishes a useful performance time/spacce tuning challenge is free to help. If you have any evil or stressful examples of regular expressions, then I welcome adding them to my tests. -- Chris Kuklewicz

1 0

Haskell -> Tk
by Peter Padawitz 23 Jan '07

23 Jan '07

Does anybody know O'Haskell or Timber and its interface Tk.hs to Tcl/Tk (see here <http://fldit-www.cs.uni-dortmund.de/%7Epeter/tk.html>)? I have the following problem: Tk.hs <http://fldit-www.cs.uni-dortmund.de/%7Epeter/Tk.hs> contains a record (structure) /Canvas/ with selectors line :: [(Int,Int)] -> [LineOpt] -> Request Line polygon :: [(Int,Int)] -> [PolygonOpt] -> Request Polygon that are compiled into synonymous Tk widgets for lines and polygons, respectively. Unfortunately, Tk.hs crashes if the point list parameter of line or polygon contains more than 100 points. Why??? Of course, one may split a point list into smaller ones that are compiled correctly. But this may not produce the same picture, for instance, if the entire list represents a polygon to be filled or a line to be smoothened. Peter

1 0

Problems using Storable.poke* from separate OS thread.
by Corey O'Connor 23 Jan '07

23 Jan '07

The short version: If a haskell routine exported to C is called from a CoreAudio IO Proc, which is on a separate thread than the main thread, the Haskell routine seams to exit early without notice. If the same routine is called from the main thread the routine produces correct output. Any ideas on why Storeable.poke* would cause problems in this situation? The long version: I'm attempting to generate audio using Haskell and CoreAudio.* For a start I tried converting Noel Cragg's HAL sinewave demo to process the audio frames in Haskell. The original is here: http://www.red-bean.com/~noel/audio/hal-demo.c How CoreAudio HAL output works is like this: - A audio callback is registered with the audio device - Audio playback is started - A separate thread, dedicated to audio processing, will then call the audio callback with pre-allocated buffers to be filled out with audio samples. The test program has "main" in C and the audio callback in C. The C callback forwards to a Haskell routine exported by the FFI system. This routine should behave identically to the C implementation that already exists. However, the routine does not work correctly if called from the audio thread. The test program also calls the routine from the main thread in a manner that should be identical to how it's called from the thread. This is used to verify the Haskell callback does actually produce the same audio as the original C callback. So I know the code should work, but just fails for some inexplicable reason on the threaded callback. Other notes: - The program is compiled with -threaded and linked against the threaded RTS. - If I structure the routine like this: ... print "Before the audio is written to the buffer." process_frames print "After the audio is written to the buffer." The first print succeeds but the second print never occurs. No IO error is reported to try_. - If I take that same structure and remove "pokeElemAt" from process_frames. The second print occurs. I've uploaded the test program here: http://www.tothepowerofdisco.com/downloads/TestAudioOutput.zip Some notes on if you actually try to build it: - You have to build 3 times; There is a bug in XCode's custom build rule handling or the projects custom build rule. - The executable is wrapped in a app bundle but is actually a command line app. - It's a hack and I'm a beginner so comments are scarce and some code may be strange. ;-) - Assumes ghc 6.6 is installed to /usr/local Any ideas? -- -Corey O'Connor

2 2

Re: [Haskell-cafe] Fractional sqrt
by Henning Thielemann 22 Jan '07

22 Jan '07

On Mon, 22 Jan 2007, Yitzchak Gale wrote: > Henning Thielemann wrote: > > > > there is already an implementation of continued > > > > fractions for approximation of roots and transcendent functions by Jan > > > > Skibinski: > > > > http://darcs.haskell.org/numeric-quest/Fraction.hs > > I wrote: > > > Wow, nice. Now - how was I supposed to have found that? > > Simon Peyton-Jones wrote: > > Perhaps one of you can add this to the libraries-and-tools page? > http://www.haskell.org/haskellwiki/Libraries_and_tools/ > > I added a new page for the Numeric Quest library, > and added it to the Mathematics category. > (Should it be in any other category?) > I also updated the references to Numeric Quest > on the Mathematics and Physics page. Great work! However I would not throw away the links to the Internet archive because the pages stored there link to the original HTML pages which are lost. It's cumbersome to navigate through the archived pages. The Darcs repository at cvs.haskell.org is no official update by Jan Skibinski - I set up that repository to simplify further development. I added the keyword "continued fractions" to the Wiki page so the module can be discovered by other people.

2 1

Partial Application
by Philippe de Rochambeau 22 Jan '07

22 Jan '07

Hello, my original query concerning partial application was triggered by the following statement from Thomson's "The Craft of Functional Programming", p. 185: " multiplyUC :: (Int, Int) -> Int multiplyUC (x,y) = x * y multiply :: Int -> Int -> Int multiply x y = x * y .... In the case of multiplications we can write expression like multiply 2". When I read this, I thought that you could partially apply "multiply" by typing "multiply 2" at the ghci prompt. However, this generated an error: <interactive>:1:0: No instance for (Show (Int -> Int)) arising from use of `print' at <interactive>:1:0-9 Possible fix: add an instance declaration for (Show (Int -> Int)) In the expression: print it In a 'do' expression: print it After reading http://www.haskell.org/hawiki/PartialApplication, I figured out that you can only partially apply declared functions, in source files, not at the prompt: multiplyBy2 = multiply 2 Now "multiplyBy2 50" yields "100" On page 22 of "Programming in Haskell", Howard says that you can do the following partial application of the curried function add': add' 1 :: Int -> Int, where add and add' are declared as add :: (Int,Int) -> Int add (x,y) = x + y add' :: Int -> (Int -> Int) add' x y = x + y However, typing "add' 1" at the prompt generates an error. If I add the following to my source file addOne = add' 1 typing addOne 5" at the prompt yields "6", which is the right answer. Cheers, phiroc

11 15

mtl tweaks
by Nicolas Frisby 22 Jan '07

22 Jan '07

There have been some discussions of augmentations of the monad transformer library. I at least know there was a discussion regarding strictness of state/value components in the state monad transformer (I must admit I didn't track the conclusion of that one). I have another small mtl complaint: ReaderT, for example, requires the base type to be a Monad in order to make it a Functor. So it's Monad m => Functor (ReaderT r m) instead of Functor f => Functor (ReaderT r f), which is what's actually necessary for the instance. Remember, I did say _small_ complaint. I realize this has a bit to do with the class heirarchy and that's a sensitive issue. Regarding backwards compatibility and interface changes, note that the Monad m => Monad (ReaderT r m) instance would be unaffected by this... it's only the Functor => Functor instance. If someone wants to treat a transformed monad as a functor, then they're probably savvy enough to specify the base monad as a functor (especially with the @fmap f = (>>= return . f)@ recipe). They won't even see a difference unless they are rolling their own monad, since all mtl monads are also functors. 1) Is there a collection of these suggestions specifically for mtl? On the wiki? On the bug tracker? 2) Any chance we could make this change to the library? Thanks, Nick

2 1

Re: [Haskell-cafe] Article review: Category Theory
by Yitzchak Gale 21 Jan '07

21 Jan '07

I wrote: >> Will (id :: A -> A $!) do the trick? Ulf Norell wrote: > The problem is not with id, it's with composition. For any f and g we > have > > f . g = \x -> f (g x) > > So _|_ . g = \x -> _|_ for any g. OK, so then how about f .! g = ((.) $! f) $! g -Yitz

4 7

Article review: Category Theory
by David House 21 Jan '07

21 Jan '07

Hey all, I've written a chapter for the Wikibook that attempts to teach some basic Category Theory in a Haskell hacker-friendly fashion. http://en.wikibooks.org/wiki/Haskell/Category_theory >From the article's introduction: "This article attempts to give an overview of category theory, insofar as it applies to Haskell. To this end, Haskell code will be given alongside the mathematical definitions. Absolute rigour is not followed; in its place, we seek to give the reader an intuitive feel for what the concepts of category theory are and how they relate to Haskell." I'd love comments from newcomers and experts alike regarding my approach, the content, improvements and so on. Of course, it's on the wikibook, so if you have anything to add (that's not _too_ substantial otherwise I'd recommend discussion first) then go ahead. Thanks in advance. -- -David House, dmhouse(a)gmail.com

15 36

File locked unnecessarily (the file)
by Arie Peterson 20 Jan '07

20 Jan '07

Except that the example was not attached. Sorry. Greetings, Arie

1 0

File locked unnecessarily (the continuation)
by Arie Peterson 20 Jan '07

20 Jan '07

Hi all, Some time ago I reported a strange file locking problem. I have reduced my offending program to a relatively small size. This reduction process was quite entertaining. At one point, I could reliably turn the locking off and on by removing and reintroducing a certain unused import :s. I was happy to see this go away on cutting out all concurrency. The example is attached. Open the tarball and run "ghc --make Main -O && ./a.out" in the resulting directory. On my system (amd64 Gentoo linux, ghc 6.4.2), this gives the following output. ###### Chasing modules from: Main Compiling Interface ( ./Interface.hs, ./Interface.o ) Compiling Main ( Main.hs, Main.o ) Linking ... Compiling plugin P b a.out: a.txt: openFile: resource busy (file is locked) ###### There is no reason for the file "a.txt" to be locked. The problem is somewhat brittle: any one of the following changes makes it disappear: - in "Main.hs:main", replacing the 'c' argument of 'cat' (the one dynamically loaded from the plugin 'P') by 'Interface.c'; - in "Main.hs:main", removing one of the two 'cat c' calls; - in "Interface.hs:c", removing one of the two 'a' calls. Because of the first of these, it seems that the problem is partly caused by the dynamic linking, but I'm not sure about that (the "unused import" experience made me a bit paranoid ;-) ). Can someone comment on the cause of this locking issue, or maybe further simplify the example? Thanks and greetings, Arie

1 0

Final Call for Papers: TFP 2007, New York, USA
by TFP 2007 20 Jan '07

20 Jan '07

CALL FOR PAPERS Trends in Functional Programming 2007 New York, USA April 2-4, 2007 http://cs.shu.edu/tfp2007/ NEW: Abstract submission is now open! Link: http://cs.shu.edu/tfp2007/submissions.html NEW: Invited Talk: John McCarthy, Standford University The symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming languages, focusing on providing a broad view of current and future trends in Functional Programming. It aspires to be a lively environment for presenting the latest research results through acceptance by extended abstracts. A formal post-symposium refereeing process then selects the best articles presented at the symposium for publication in a high-profile volume. TFP 2007 is co-hosted by Seton Hall University and The City College of New York (CCNY) and will be held in New York, USA, April 2-4, 2007 at the CCNY campus. SCOPE OF THE SYMPOSIUM The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: Research Articles leading-edge, previously unpublished research work Position Articles on what new trends should or should not be Project Articles descriptions of recently started new projects Evaluation Articles what lessons can be drawn from a finished project Overview Articles summarizing work with respect to a trendy subject Articles must be original and not submitted for simultaneous publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or more experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Articles on the following subject areas are particularly welcomed: o Dependently Typed Functional Programming o Validation and Verification of Functional Programs o Debugging for Functional Languages o Functional Programming and Security o Functional Programming and Mobility o Functional Programming to Animate/Prototype/Implement Systems from Formal or Semi-Formal Specifications o Functional Languages for Telecommunications Applications o Functional Languages for Embedded Systems o Functional Programming Applied to Global Computing o Functional GRIDs o Functional Programming Ideas in Imperative or Object-Oriented Settings (and the converse) o Interoperability with Imperative Programming Languages o Novel Memory Management Techniques o Parallel/Concurrent Functional Languages o Program Transformation Techniques o Empirical Performance Studies o Abstract/Virtual Machines and Compilers for Functional Languages o New Implementation Strategies o any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2007 program chair, Marco T. Morazan, at tfp2007(a)shu.edu. SUBMISSION AND DRAFT PROCEEDINGS Acceptance of articles for presentation at the symposium is based on the review of extended abstracts (6 to 10 pages in length) by the program committee. Accepted abstracts are to be completed to full papers before the symposium for publication in the draft proceedings and on-line. Further details can be found at the TFP 2007 website. POST-SYMPOSIUM REFEREEING AND PUBLICATION In addition to the draft symposium proceedings, we intend to continue the TFP tradition of publishing a high-quality subset of contributions in the Intellect series on Trends in Functional Programming. IMPORTANT DATES Abstract Submission: February 1, 2007 Notification of Acceptance: February 20, 2007 Registration Deadline: March 2, 2007 Camera Ready Full Paper Due: March 9, 2007 TFP Symposium: April 2-4, 2007 PROGRAMME COMMITTEE John Clements California Polytechnic State University, USA Marko van Eekelen Radboud Universiteit Nijmegen, The Netherlands Benjamin Goldberg New York University, USA Kevin Hammond University of St. Andrews, UK Patricia Johann Rutgers University, USA Hans-Wolfgang Loidl Ludwig-Maximilians Universität München, Germany Rita Loogen Philipps-Universität Marburg, Germany Greg Michaelson Heriot-Watt University, UK Marco T. Morazán (Chair) Seton Hall University, USA Henrik Nilsson University of Nottingham, UK Chris Okasaki United States Military Academy at West Point, USA Rex Page University of Oklahoma, USA Ricardo Pena Universidad Complutense de Madrid, Spain Benjamin C. Pierce University of Pennsylvania, USA John Reppy University of Chicago, USA Ulrik P. Schultz University of Southern Denmark, Denmark Clara Segura Universidad Complutense de Madrid, Spain Jocelyn Sérot Université Blaise Pascal, France Zhong Shao Yale University, USA Olin Shivers Georgia Institute of Technology, USA Phil Trinder Heriot-Watt University, UK David Walker Princeton University, USA ORGANIZATION Symposium Chair: Henrik Nilsson, University of Nottingham, UK Programme Chair: Marco T. Morazan, Seton Hall University, USA Treasurer: Greg Michaelson, Heriot-Watt University, UK Local Arrangements: Marco T. Morazan, Seton Hall University, USA ************************************************************************************ Dr. Marco T. Morazan TFP 2007 Program Committee Chair http://cs.shu.edu/tfp2007/

1 0

Re: [Haskell-cafe] Fractional sqrt
by Novák Zoltán 19 Jan '07

19 Jan '07

Hi, Thanks for the answers. The best solution would be a general purpose arbitrary precision math library for Haskell. I found two: http://medialab.freaknet.org/bignum/ http://r6.ca/FewDigits/ I think both uses power series and have trigonometric functions too. (I only need sqrt, so probably I will not use them, just the simple Newton alg.) It would be great, if a fast implementation of arbitrary precision real arithmetic Class would be part of the Standard libraries. Because Haskell is so great for numerical computations already (functions, composing functions, higher order f. with typechecking), a good math library would make Matlab obsolete. :) Zoltan Novak ps. Call me Zoltan (that is my first name), just we write it in different order in Hungary. (Names are in hungarian notation here: the type description precedes the actual name)

3 2

for loops and 2d arrays in haskell
by Fernan Bolando 19 Jan '07

19 Jan '07

hi all Since I am very new to haskell and still learning, I hope I will not annoy poeple by asking the following question. what is the simplest way to implement the following code in haskell? it's just printing the contents of 2D array. for(i = 0; i < imax; i++){ for(n = 0; n < nmax; n++){ printf("%i:%i = %f\n", array[i][n]); } } ,Fernan -- Public PGP/GnuPG key (http://www.fernski.com) pub 1024D/3576CA71 2006-02-02 Fernan Bolando Key fingerprint = FDFE C9A8 FFED C1A5 2F5C EFEB D595 AF1C 3576 CA71

4 5

hs-plugins on ghc6.6?
by Adam Megacz 19 Jan '07

19 Jan '07

Has anybody been able to get hs-plugins to work with ghc6.6? http://www.nabble.com/Re%3A-hs-plugins-runtime-error-with-GHC-6.6%3A-index-… - a -- PGP/GPG: 5C9F F366 C9CF 2145 E770 B1B8 EFB1 462D A146 C380

3 2

X11
by Philippe de Rochambeau 19 Jan '07

19 Jan '07

Hello, does anyone know where I can find examples that use the Graphics.X11.Xlib.Window module. Thanks. phiroc

1 0

Tracing a list comprehension
by Philippe de Rochambeau 19 Jan '07

19 Jan '07

Hello, is there a way to trace a list comprehension such as concat1 :: [[a]] -> [a] concat1 xss = [ x | xs <- xss, x <- xs ] I would like to see what gets stored in xs. Cheers, phiroc

2 1

New (simple) Lazy Evaluation tutorial
by Andrew Wagner 19 Jan '07

19 Jan '07

Hi all, An interesting question came up in #haskell the other day, and I took the resulting discussion and wrapped it up into a simple tutorial for the wiki. Since I'm quite a newbie to haskell myself, I'd appreciate any double-checking of my logic and, of course, any other comments/suggestions. Thanks to Cale for his efforts on this problem, and to the original asker, whose name I can't recall. http://www.haskell.org/haskellwiki/Haskell/Lazy_Evaluation

2 1

Re: [Haskell-cafe] Article review: Category Theory
by David House 19 Jan '07

19 Jan '07

On 18/01/07, Daniel Fischer <daniel.is.fischer(a)web.de> wrote: > Since I don't know whether I would have to register to modify the wiki or > something (and don't know what markup to use either), I just send you a few > corrections by e-mail. Thanks; I've corrected them all, with the exceptions of the ones shown below. http://en.wikibooks.org/w/index.php?title=Haskell/Category_theory&diff=7231… > perhaps index join/unit with the appropriate objects, e.g. > join_X . M(join_X) = join_X . join_M(X), to aid the newcomers? > the picture's left is the text's right. -- -David House, dmhouse(a)gmail.com

1 0

re: Simple HTTP lib for Windows?
by brad clawsie 19 Jan '07

19 Jan '07

there is a Network.HTTP module, but it is not easy to use what you want is the equivalent of perl's LWP::Simple, which provides get() and head() functions i have heard that this is being worked on, in the meantime i personally use this wrapper: http://www.b7j0c.org/content/haskell-http.html that i wrote myself to provide simple get and head functionality with some trivial redirect support i use this module routinely so it should work, although i have only tested it on freebsd and linux no one else has ever looked at this so feel free to send critiques, it is mostly a hack of the get() example script distributed with the Network.HTTP module

1 1

Announce: piggybackGHC 0.1
by Martin Grabmueller 18 Jan '07

18 Jan '07

Hello fellow Haskell Hackers, I announce release 0.1 of piggybackGHC, a small utility package for using GHC for lexing and parsing Haskell source code. Description: The modules in this package provide several functions for conveniently lexing and parsing Haskell modules. The library uses the GHC library for all the hard stuff, so all supported GHC extensions are available. Homepage: http://uebb.cs.tu-berlin.de/~magr/projects/piggybackGHC/doc/ Darcs: darcs get --partial http://uebb.cs.tu-berlin.de/~magr/projects/piggybackGHC/ Feedback appreciated! Have fun, Martin

1 0

Currying
by phiroc＠free.fr 18 Jan '07

18 Jan '07

Hello, what is so great about "currying"? What are its uses, apart from letting one define functions with less parentheses? Many thanks. Phiroc

6 5

mtl vs monads
by Conal Elliott 18 Jan '07

18 Jan '07

Are the mtl and monads (monadLib) packages both in active use? Is one being phased out? - Conal

2 1

GHC performance of 64-bit
by Pedro Baltazar Vasconcelos 18 Jan '07

18 Jan '07

Hello all, I noticed that GHC generates slower code on an Linux amd64 bit platform than the 32-bit version on a cheaper 32-bit machine. CPUTime for running sieve of Erathostenes to generate 10,000 primes: Athlon XP 2800 (32-bit): 7.98 secs Athlon 64 3800 (64-bit): 10.29 secs This is using GHC 6.6 on the 64-bit machine and 6.4.1 on the 32-bit one. I googled around and could not find any information regarding degraded performance of ghc/haskell on 64-bit machines. Any ideas? Regards, Pedro

5 4

What does the withProcessHandle_ function do?
by John Ky 18 Jan '07

18 Jan '07

I want to learn how to use FFI with Win32, so I'm looking through the GHC source code. I encountered the function terminateProcess :: ProcessHandle -> IO () terminateProcess ph = do withProcessHandle_ ph $ \p_ -> case p_ of ClosedHandle _ -> return p_ OpenHandle h -> do throwErrnoIfMinus1_ "terminateProcess" $ c_terminateProcess h return p_ which uses withProcessHandle_. What does it do? Thanks -John

2 1

Partial application
by phiroc＠free.fr 18 Jan '07

18 Jan '07

Hello, could someone please give me an example of the "partial application" of the following curried function: add' :: Int -> Int -> Int add' a b = a + b Normally, add' 1 should work, but it doesn't. Many thanks. phiroc

4 3

ICFP07 Call for Papers
by Matthew Fluet (ICFP Publicity Chair) 18 Jan '07

18 Jan '07

Call for Papers ICFP 2007: International Conference on Functional Programming Freiburg, Germany, 1-3 October 2007 ICFP 2007 seeks original papers on the art and science of functional programming. Submissions are invited on all topics from principles to practice, from foundations to features, from abstraction to application. The scope includes all languages that encourage functional programming, including both purely applicative and imperative languages, as well as languages with objects and concurrency. Particular topics of interest include * Applications and domain-specific languages: systems programming; scientific and numerical computing; symbolic computing; artificial intelligence; databases; graphical user interfaces; multimedia programming; scripting; system administration; distributed-systems and web programming; XML processing; security * Foundations: formal semantics; lambda calculus; type theory; monads; continuations; control; state; effects * Design: algorithms and data structures; modules; type systems; concurrency and distribution; components and composition; relations to object-oriented or logic programming * Implementation: abstract machines; compile-time and run-time optimization; just-in-time compilers; memory management; parallel hardware; interfaces to foreign functions, services, components or low-level machine resources * Transformation and analysis: abstract interpretation; partial evaluation; program transformation * Software-development techniques: design patterns; specification; verification; validation; debugging; test generation; tracing; profiling * Practice and experience: novel results drawn from experience in education or industry * Functional pearls: elegant, instructive examples of functional programming A functional pearl need not report original research results, but it must be instructive, elegant, and fun. ICFP 2007 also seeks Experience Reports. An Experience Report is a short paper (2-4 pages) which need not present novel results, but which should provide evidence that functional programming really works or should describe obstacles that prevented it from working. Detailed guidelines appear below. What's new this year? ~~~~~~~~~~~~~~~~~~~~~ Experienced ICFP authors may want to pay special attention to the points below, which are new this year. * Double-blind review * Author-date citations * Supplemental material in a separate document, not appended to the main text * Morning deadline (but equivalent to late afternoon or early evening in many time zones of interest) * Experience Reports Instructions for authors ~~~~~~~~~~~~~~~~~~~~~~~~ By 11:00 AM Friday, 6 April 2007, Samoan time, submit an abstract of at most 300 words and a full paper of at most 12 pages or an Experience Report of at most 4 pages. Submissions will be accepted electronically, at a URL to be named later. The deadline is set at Samoan time, so if your submission is in by 11:00 AM Friday according to your local time, wherever you are, the submission will be on time. The world clock at http://www.timeanddate.com/worldclock/fixedtime.html?month=4&day=6&year=200… can give you the equivalent in your local time, e.g., 3:00 PM Friday in Portland, 6:00 PM Friday in Boston, and midnight Friday in Freiburg. The deadline is firm. Your submission should explain its contributions in both general and technical terms, clearly identifying what has been accomplished, explaining why it is significant, and comparing it with previous work. Make the technical content understandable to a broad audience. Each submission must adhere to SIGPLAN's republication policy, which appears in full at http://www.acm.org/sigplan/republicationpolicy.htm. The policy means in part that your paper may not have already appeared in a journal, conference, or workshop with published proceedings; that you may not submit substantially the same work simultaneously to ICFP and to another venue; and that your submission must discuss any closely related material, including your own, that was previously accepted at a journal, conference, or workshop with or without published proceedings. Full details of the policy are available at the SIGPLAN site. If you are in any doubt about whether this policy applies to your paper, either consult the program chair in advance or notify the chair when you submit. To do otherwise risks summary rejection of your submission. If your submission is accepted, you must assign copyright to ACM. Proceedings will be published by the ACM Press. Double-blind review ~~~~~~~~~~~~~~~~~~~ To increase confidence in the fairness and objectivity of the reviewing process, reviewing will be double blind. Make it possible for reviewers to evaluate your paper without having to know who you are. It should suffice to omit your names from your submission and to avoid revealing your identity through citation; detailed guidelines are available at http://icfp07.eecs.harvard.edu/blind.html. Formatting ~~~~~~~~~~ Your submission must be printable on US Letter sized paper and be either PDF or PostScript that is interpretable by Ghostscript. If this requirement is a hardship, make contact with the program chair at least one week before the deadline. Your submission must be at most 12 pages (4 pages for an Experience Report), including bibliography and figures, in the standard ACM conference format: two columns, nine-point font on a ten-point baseline, with pages 20pc (3.33in) wide and 54pc (9in) tall, with a column gutter of 2pc (0.33in). (A suitable LaTeX class file is available from SIGPLAN; see http://www.acm.org/sigs/sigplan/authorInformation.htm. Categories, keywords, and so on are optional.) If you wish to supply material beyond the 12-page limit, up to and including a full technical report, you may attach a separate document to your submission, on the understanding that reviewers are not expected to read it. (As a particular example, if you feel that your submission should be supported by a lengthy technical report, do not cite such a technical report on the web, since doing so would reveal your identity. Please instead attach that report to your submission.) Detailed instructions for attaching supplementary documents will be available on the submission web site. The length limit is firm; submissions that do not meet these guidelines will not be considered. Citation ~~~~~~~~ We recommend (but do not require) that you put your citations into author-date form. This procedure makes your paper easier to review. For example, if you cite a result on testing as ``(Claessen and Hughes 2000)'', many reviewers will recognize the result instantly. On the other hand, if you cite it as ``[4]'', even the best-informed reviewer has to page through your paper to find the reference. By using author-date form, you enable a knowledgeable reviewer to focus on content, not arbitrary numbering of references. LaTeX users can simply use the natbib package along with the plainnat bibliography style. Author response ~~~~~~~~~~~~~~~ You will have a 48-hour period (11:00 23 May to 11:00 25 May 2007 Samoa time) to read and respond to reviews. Details of the author-response process will be available as it approaches. Special categories of papers ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In addition to research papers, ICFP solicits two kinds of papers that do not require original research contributions: functional pearls, which are full papers, and Experience Reports, which are limited to four pages. Authors submitting such papers may wish to consider the following advice. Functional pearls ~~~~~~~~~~~~~~~~~ To paraphrase both Jon Bentley and Richard Bird, the ideal pearl goes beyond solid engineering into the realm of insight and creativity. Just as a natural pearl grows from a grain of sand that has irritated an oyster, a topnotch functional pearl should grow from a real problem that has irritated a programmer. A pearl should be polished, elegant, instructive, and entertaining. Ideally it should teach important programming techniques and fundamental design principles. Past pearls have included instructive examples of program calculation or proof, nifty presentations of old or new data structures, and interesting applications and programming techniques. Papers submitted to ICFP as pearls often miss the mark, by being too trivial, too complicated, or somehow not quite the elegant solution one hopes for. The key to an accepted pearl is polishing. Your pearl is likely to be rejected if your readers get bored, if the material gets too complicated, if too much specialized knowledge is needed, or if the writing is distasteful. Richard Bird advises: * Throw away the rule book for writing research papers. * Get in quick; get out quick. * Be self-contained; don't go deep into related work, with lengthy references. * You are telling a story, so some element of surprise is welcome. * Above all, be engaging. * Give a talk on the pearl to non-specialists, your students, or your department. If you changed the order of presentation for the talk, consider using the new order in the next draft. * Put the pearl away for a while, then take it out and polish it again. Experience reports ~~~~~~~~~~~~~~~~~~ ICFP has long solicited submissions on the practice and experience of functional programming. But reports of experience are inherently different from research papers, and when judged by the criteria of scientific merit, novelty, or research contribution, they have not competed well against traditional ICFP submissions. Yet we believe that the functional- programming community would benefit from being able to draw on and cite the experience of others. For this reason, we have introduced the ICFP Experience Report. Unlike a normal ICFP paper, the purpose of an Experience Report is not to add to the body of knowledge of the functional-programming community. Rather, the purpose of an Experience Report is to help create a body of published, refereed, citable *evidence* that functional programming really works---or to describe obstacles that prevented it from working. An Experience Report is distinguished from a normal ICFP paper by its title, by its length, and by the criteria used to evaluate it. * Both in the proceedings and in any citations, the title of each accepted Experience Report must begin with the words "Experience Report", followed by a colon. * Experience Reports are limited in length: the suggested length is 2 pages and the maximum length is 4 pages. Each accepted Experience Report will be presented at the conference, but depending on the number of Experience Reports and regular papers accepted, authors of Experience Reports may be asked to give shorter talks. * Because the purpose of Experience Reports is to enable our community to accumulate a published, citable body of evidence about the efficacy of functional programming, an acceptable Experience Report need not present novel results or conclusions. It is sufficient if the Report states a clear thesis and provides supporting evidence. The thesis must be relevant to ICFP, but it need not be novel. The program committee will accept or reject Experience Reports based on whether they judge the evidence to be convincing. Anecdotal evidence will be acceptable provided it is well argued and the author explains what efforts were made to gather as much evidence as possible. The committee will be especially convinced by evidence that includes *comparisons* of situations before and after the introduction or discontinuation of functional programming. Evidence drawn from a single person's experience may be sufficient, but more weight will be given to evidence drawn from the experience of groups of people. Possible topics for an Experience Report include, but are not limited to * Insights gained from real-world projects using functional programming * Comparison of functional programming with conventional programming in the context of an industrial project or a university curriculum * Project-management, business, or legal issues encountered when using functional programming in a real-world project * Curricular issues encountered when using functional programming in education * Real-world constraints that created special challenges for an implementation of a functional language or for functional programming in general An Experience Report should be short and to the point: if functional programming worked for you in the same ways it has worked for others, you need only to summarize the results---the main part of your paper should discuss how well it worked and in what context. Most readers will not want to know all the details of your project and its implementation, but please characterize your project and its context well enough so that readers can judge to what degree your experience is relevant to their own projects. Be especially careful to highlight any unusual aspects of your project. Also keep in mind that specifics about your project are more valuable than generalities about functional programming; for example, it is more valuable to say that your team delivered its software a month ahead of schedule than it is to say that functional programming made your team more productive. If your paper not only describes experience but also presents new technical results, or if your experience refutes cherished beliefs of the functional-programming community, you may be better off submitting it as a full paper, which will be judged by the usual criteria of novelty, originality, and relevance. If you unsure in which category to submit, the program chair will be happy to help you decide. Other information ~~~~~~~~~~~~~~~~~ Conference Chair ~~~~~~~~~~~~~~~~ Ralf Hinze (Universität Bonn) Program Chair ~~~~~~~~~~~~~ Norman Ramsey Harvard University Cambridge, MA, 02148 USA Email: icfp07(a)eecs.harvard.edu Phone: +1 617 496 8615 Mail sent to the address above is filtered for spam. If you send mail and do not receive a prompt response, particularly if the deadline is looming, feel free to telephone and reverse the charges. Program Committee ~~~~~~~~~~~~~~~~~ Nick Benton (Microsoft Research) Matthew Fluet (Toyota Technological Institute) Jeremy Gibbons (University of Oxford) Kevin Hammond (University of St Andrews) Bastiaan Heeren (Utrecht University) Graham Hutton (University of Nottingham) Mark P. Jones (Portland State University) Gabriele Keller (University of New South Wales) Fabrice Le Fessant (INRIA/LIX, France) Todd Millstein (UCLA) Mike Sperber (DeinProgramm) Christopher A. Stone (Harvey Mudd College) Andrew Tolmach (Portland State University and INRIA Rocquencourt) Janis Voigtländer (Technische Universität Dresden) Stephanie Weirich (University of Pennsylvania) 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 ICFP 2007 Web Site ~~~~~~~~~~~~~~~~~~ http://www.informatik.uni-bonn.de/~ralf/icfp07.html Special Issue of JFP ~~~~~~~~~~~~~~~~~~~~ Authors of the best final papers, as determined by the program committee, will be invited to submit journal versions for a special issue of the Journal of Functional Programming.

1 0

Default (or empty) values
by Max Vasin 18 Jan '07

18 Jan '07

Hello all! Let > data Book = Book { > authors :: [String], > title :: String, > editor :: Maybe String, > edition :: Maybe String, > volume :: Maybe (Int, Int), -- e.g. volume 1 of 3 > publisher :: String, > year :: Int, > pages :: Int > } and > convertBook :: Map String String -- a map from field names to values (string representation) > -> Maybe Book convertBook takes info about book from some external source (e.g. a BibTeX database) and returns Just book value or Nothing (if convertion failed). Fields of the Book datatype which are not (Maybe a) are required to be present. convertBook looks like > convertBook = (rq "title" (\b v -> b { title = v }) <.> > rq "publisher" (\b v -> b { publisher = v }) <.> > ... ) (Just $ Book [] "" Nothing Nothing Nothing "" 0 0) I don't like the `(Just $ Book [] "" Nothing Nothing Nothing "" 0 0)' part, I would prefer instead someting like `empty :: Book'. So I define > class Empty e where > empty :: e But still I have to emplement instances by hand. There are a number of approaches to automatically derive instances (TH, generic classes in GHC, drift). What would you recommend using in this case? Or may be it would be better to drop out Empty and use something else? TIA -- WBR, Max Vasin.

4 8

Re: [Haskell-cafe] Re: Newbie: Project: Missionary and Cannibal [Contd].
by thapaps＠gmail.com 17 Jan '07

17 Jan '07

thank you very much for all your Help. I am finally able to do something (O: I watched the video presentation from Edsge W. Dijkstra. It is very helpful. thank you once again for providing me the link. I am trying to call a function and print a message. moveLoadR :: Int -> Int -> (IO ()-> a) moveLoadR m c | m==0 && c==0 = moveEndR $ putStrLn "END" | otherwise = moveLoadR (m-1) (c-1) $ putStrLn "Starting Missionary and Cannibal Game.\nLeft Bank: Missionary=3:Cannibal=3: Moving From: Left ===> Right: Missionary=1 Cannibal=1 \n" moveEndR :: (IO ()->a) moveEndR = putStrLn"END OF Solution" <<< === THIS IS INCORRECT. I tried doing this . but it will take me to the infinite Loop. moveEndR :: (IO ()->a) moveEndR = moveEndR $ putStrLn"END OF GAME" Any help in this would be greatly appreciated. . On 1/16/07, Paul Johnson <paul(a)cogito.org.uk> wrote: > > This is presumably your homework. See > http://www.haskell.org/haskellwiki/Homework_help > > This kind of problem is often solved by using the List monad, so try > looking at that first. > > Failing that, have a list of moves to make a sequence. Then make a list > of all possible sequences. Then filter out the ones that break the > rules. Whatever is left is the answer you want. > > Paul. > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

2 1

Haskell category (was: Article review: Category Theory)
by Peter Berry 17 Jan '07

17 Jan '07

On 16/01/07, David House <dmhouse(a)gmail.com> wrote: > I'd love comments from newcomers and experts alike regarding my > approach, the content, improvements and so on. Of course, it's on the > wikibook, so if you have anything to add (that's not _too_ substantial > otherwise I'd recommend discussion first) then go ahead. Interesting timing for me :) I was going to post about category theory as well, but my motivation is the opposite - I'd like to ask about it. (I've changed the subject since this ought to be a separate thread.) My final year undergraduate project involves defining the semantics of a memoization function in Haskell using category theory, so of course I've been trying to figure out exactly what the Haskell category consists of. I've put a summary of my thoughts at http://sucs.org/~pwb/cats.txt . I'd appreciate comments, criticism, etc. -- Peter Berry <pwberry(a)gmail.com> Please avoid sending me Word or PowerPoint attachments. See http://www.gnu.org/philosophy/no-word-attachments.html

1 0