- Haskell-Cafe - Haskell.org

Problems with high-level interface to LLVM
by Николай Кудасов 16 May '11

16 May '11

Hi there, I use llvm package for building compiler for a small C-like language and it have some problems with high-level interface that package provides. I use simple scheme: [parser] -> (untyped AST) -> [analyser] -> (typed AST) -> [LLVM] -> (object code). At first, as I want to use high-level interface, typed AST must satisfy all needed class constraints. For simple types and operations this can be solved by adding neccessary constraints to the corresponding definitions. But it's not very good solution, because in general typed AST can represent high-level data structures, that would have certain representation, known when generating code, but not checking logic. Problem becomes much more complex when I want to add function calls into my language. Type class CallArgs has an instance CallArgs (IO a) (CodeGenFunction r (Value a)), which can't be given as a constraint in typed AST because of free variable r. For a long time I have had no idea of how I can add function calls into my language. The only solution I see at the moment is to reject high-level llvm interface provided by llvm library and use directly FFI bindings to C. But I can't get rid of feeling that I'm missing something or doing all stuff totally wrong. It would be great if someone, who has experience in using high-level interface to LLVM for building a compiler, could help me. Thanks in advance, Nick

2 1

Impossible class instance?
by Emil Axelsson 16 May '11

16 May '11

Hello! At the end of this message is a program with a simple expression type, and a class `ToExpr` that generalizes expressions to arbitrary Haskell types. Every node in `Expr` is annotated with some abstract information. The program raises the following type error: test.hs:13:5: Couldn't match type `(,) a' with `(,) (a, a)' Inaccessible code in the instance declaration In the instance declaration for `ToExpr (a, b)' It seems that the mere existence of the constraint info (a,b) ~ (info a, info b) causes this error. I was hoping that this constraint would make it possible to construct the value (ia,ib) in the class instance, which is otherwise not allowed. Note: I don't want to make `info` an associated type. The idea is to make this work with any type function `info` that fulfills the above constraint. Is there any way to make this work? / Emil -------------------- {-# LANGUAGE UndecidableInstances #-} data Expr info a where Int :: info a -> Int -> Expr info a Pair :: info (a,b) -> Expr info a -> Expr info b -> Expr info (a,b) getInfo :: Expr info a -> info a getInfo (Int info _) = info getInfo (Pair info _ _) = info class ToExpr a where type Internal a toExpr :: a -> Expr info (Internal a) instance ( ToExpr a , ToExpr b , info (a,b) ~ (info a, info b) ) => ToExpr (a,b) where type Internal (a,b) = (Internal a, Internal b) toExpr (a,b) = Pair (ia,ib) (toExpr a) (toExpr b) where ia = getInfo a ib = getInfo b

1 1

flattenend multi-level programs, in diagram form
by Adam Megacz 16 May '11

16 May '11

A few people have mentioned that the flattening process is easier to understand from example diagrams. Now it's possible to generate those diagrams automatically: http://www.cs.berkeley.edu/~megacz/garrows/flattening.examples/ - a

1 0

Internship in Tokyo and Singapore reminder
by employment 16 May '11

16 May '11

Tsuru Capital has openings for three month interns in the offices in Tokyo and in Singapore. Positions are available immediately and for the summer. We are looking for people with moderate experience with Haskell or another functional programming language. Evidence of work written in Haskell is a big plus. More details can be found here. There is a small coding task on the site. Please send this code with your application. http://www.tsurucapital.com/en/jobs.html Any who have applied before but would like to be considered again, please feel free to send a reminder of your availability along with the code sample. Interested candidates please send resumes with code to jobs(a)tsurucapital.com . We will arrange flights and accommodation. Accommodation plus salary will be worth approximately USD18.5k for the three month period.

1 0

cannot install base-4.3.1.0 package
by Immanuel Normann 15 May '11

15 May '11

Hi, how can I install the base-4.3.1.0 package. I tried first > cabal install base that gives me this error: Resolving dependencies... cabal: Distribution/Client/Dependency/TopDown.hs:169:37-73: Non-exhaustive patterns in lambda I googled for this error and found nothing but the simple statement in the track system http://hackage.haskell.org/trac/hackage/ticket/605: "cabal install base is not expected to work, however the error message should be better, see #597. " (but the link to #547 doesn't solve the problem either) So I downloaded base-4.3.1.0 package from hackage and run: > runhaskell Setup configure which gives this error: Setup.hs:1:0: attempting to use module `Prelude' (./Prelude.hs) which is not loaded Then I noticed that there is configure script in the base-4.3.1.0 dir, so executed this which yields this error message: config.status: error: cannot find input file: `base.buildinfo.in' Why is it so complicated to install the base package? Thanks for any help!

3 2

how to generate source code from TH Exp?
by Stefan Kersten 15 May '11

15 May '11

hi, i was wondering if it's possible to directly generate Haskell source code from a Template Haskell `Q Exp', i.e. use TH as a kind of preprocessor? i am asking because currently the iOS port of ghc doesn't support TH and i need to generate some instances for the persistent package [1,2]. i've been toying with fmap ppr . runQ $ q but the result needs to be edited by hand quite a bit. any ideas where to start? thanks, <sk> [1] http://hackage.haskell.org/package/persistent [2] http://hackage.haskell.org/package/persistent-template

5 6

parMap doesn't work fine
by Grigory Sarnitskiy 14 May '11

14 May '11

Hello! I've just started using parallel computations in Haskell. parMap works fine, it is so easy to use. However, parMap fails with functions returning lazy structures, e.g. tuples. This code works as expected: (parMap rpar) bm tvalues bm :: Double -> Double is some heavy function. But if I want to return list of pairs (t, bm t) it doesn't use cpu cores fine (only one is in use): (parMap rpar) (\t -> (t, bm t)) tvalues The same is valid for functions returning lists. How do I use multiple cores with functions returning tuples?

3 2

Experimental GHC with GHCJS built in and Cabal support for JavaScript files
by Hamish Mackenzie 14 May '11

14 May '11

Blackh and I have been trying out some ideas on how to make it easier use GHCJS in your Cabal projects. We took Victor's GHCJS code and added it back into GHC (we could not easily accomplish what we wanted using the current GHC API). We set it up so that GHC outputs a .js file whenever it outputs an object file. We added code to Cabal to install the .js files (in the same place as the .hi files). At link time GHC copies all the .js files from the packages used into a .jsexe directory (with the same name and in the same location as the executable). Finally when the executable is installed we copy the .jsexe directory along with it. Only files with differing modified dates are copied to avoid slowing things down too much. I have updated my yesod-slides example to show how all this can be used. https://github.com/hamishmack/yesod-slides The README.mardown there has instructions for building GHC and Cabal with the GHCJS stuff in it. It is a bit painful to build, but the changes to yesod-slides were quite minor... * Added ghcjs-rts to the build depends * Published the yesod-slides.jsexe folder (using Yesod's staticFiles) * Added <script> tags to <head> for rts-common.js and rts-plain.js * Added Julius script to init the rts Currently GHC is hard coded to use the GHCJS Trampoline calling convention (in GHC's HscMain.hs). Hamish

2 1

Division: Is there a way to simultaneously find the quotient and remainder?
by caseyh＠istar.ca 14 May '11

14 May '11

:)

6 5

Sending messages up-and-down the iteratee-enumerator chain [Was: iterIO-0.1]
by oleg＠okmij.org 14 May '11

14 May '11

David Mazie'res wrote: > What you really want is the ability to send both upstream and > downstream control messages. Right now, I'd say iterIO has better > support for upstream control messages, while iteratee has better > support for downstream messages, since iteratee can just embed an > Exception in a Stream. (I'm assuming you could have something like a > 'Flush' exception to cause output to be flushed by an Iteratee that > was for some reason buffering some.) > Can you explain how iteratee could keep track of the stream position? > I'm not saying it's impossible, just that it's a challenging puzzle to > make the types come out and I'd love to see the solution. The code described in this message does exactly that. We illustrate enumerator's telling something to iteratees in the middle of the stream (to Flush their buffers) as well as iteratee's asking an enumerator of something (the stream position). The chunk of a stream and EOF are themselves `control' messages that an enumerator may send; the request for a new chunk, just like the request for a stream position, is just one of the requests an iteratee may ask. The set of messages an enumerator may send and the set of requests an iteratee may ask are both treated as open unions. We illustrate the explicit coding of open unions, to let the type checker ensure that what an iteratee may ask an enumerator can answer, and what an enumerator may tell an iteratee can understand. In process calculus lingo, we implement external (to iteratee) choice, internal choice, and a form of session types. For clarity, we implement a greatly simplified version of iteratees. We assume a single-character chunk, which an iteratee always consumes. Chunking of a stream and look-ahead are orthogonal concerns and have been discussed already. The stream represents the external, producer choice: > data Stream ie = > Chunk Char -- the current character > | SExc ie -- A message from the enumerator The chunk is an ever-present option; other choices include EOF and Flush: > data EOF = EOF > data Flush = Flush The iteratee represents the internal, consumer choice: > data Iter ee ie a = > Done a > | Cont (Stream ie -> Iter ee ie a) > | IExc (ee (Iter ee ie) a) -- other requests Cont is a typical request from an iteratee. It is so typical that we wire it in (we could've treated it as other requests, like Tell). The iteratee is parametrised by what messages it understands and what requests it may ask. Iteratees compose as a monad: > instance Bindable ee => Monad (Iter ee ie) where > return = Done > Done a >>= f = f a > Cont k >>= f = Cont (\x -> k x >>= f) > IExc ee >>= f = IExc (comp ee f) All requests must be bindable, so they can percolate > class Bindable ee where > comp :: Monad m => ee m a -> (a -> m b) -> ee m b An exception is a sort of request (especially if the exception is resumable) > data Err m a = Err (() -> m a) > instance Bindable Err where > comp (Err k) f = Err (\x -> k x >>= f) Another sort of request is to tell the position > data Tell m a = Tell (Int -> m a) > instance Bindable Tell where > comp (Tell k) f = Tell (\x -> k x >>= f) We use Either (or higher-kinded E2) to build unions: > class Sum e c where > inj :: e -> c > prj :: c -> Maybe e > class Sum2 (e :: (* -> *) -> * -> *) (c :: (* -> *) -> * -> *) where > inj2 :: e m a -> c m a > prj2 :: c m a -> Maybe (e m a) Iteratees are explicit in what they receive on the stream, the external choices they may handle. But they leave the requests polymorphic to ease composing with other iteratees which may asks more requests. Here is the simplest iteratee, which doesn't do anything but asks for trouble > ierr :: Sum2 Err c => Iter c ie a > ierr = IExc . inj2 $ Err (\_ -> ierr) A typical iteratee, like the head below, asks for little and accepts little: > iehead :: Sum2 Err c => Iter c EOF Char > iehead = Cont step > where > step (Chunk a) = Done a > step (SExc EOF) = ierr We can ask for the current position: > itell :: Sum2 Tell c => Iter c ie Int > itell = IExc . inj2 $ Tell Done Enumerators, in contrast, are explicit in what requests they may satisfy, but implicit in what they may send on the stream. A typical, small enumerator requires that an iteratee understand at least EOF, and answers no requests beyond errors. > en_str :: Sum EOF ie => String -> Iter Err ie x -> Iter Err ie x > en_str _ i@Done{} = i > en_str _ (IExc x) | Just (Err _) <- prj2 x = ierr > en_str "" (Cont k) = k eof > en_str (h:t) (Cont k) = en_str t $ k (Chunk h) A typical enumeratee, like the following keeper of positions, is explicit in requests it accepts: only Tell and Err. The Tell requests are satisfied and not propagated. The stream messages are relayed from the outer to the inner stream: > en_pos :: Int -> Iter (E2 Err Tell) ie x -> Iter Err ie x > en_pos _ (Done x) = return x > en_pos n (Cont k) = Cont (\s -> en_pos (n+1) (k s)) > en_pos _ (IExc x) | Just (Err _) <- prj2 x = ierr > en_pos n (IExc x) | Just (Tell k) <- prj2 x = en_pos n (k n) Here are some of the examples: > t1 = irun $ en_str "x" iehead > -- Type error! en_str doesn't know how to handle Tell > -- tb2 = irun $ en_str "x" itell We interpose en_pos enumeratee to deal with positional requests, so we can run the whole example: > t5 = irun $ en_str "xab" $ en_pos 0 $ iter > where > iter = do > x <- iehead > y <- ietell > return (x,y) The complete code is available at http://okmij.org/ftp/Haskell/Iteratee/UpDown.hs

2 2

Manatee-0.2.2 release!
by Lazycat Manatee 14 May '11

14 May '11

Hi all, Manatee-0.2.2 release! New features in Manatee-0.2.2: * Build new package "manatee-all", now you just need command "cabal install manatee-all" to upgrade new version. * Make keymap window and completion window will show correctly in Gnome3. * Fixed webkit-0.12.2 depend problem, because webkit-0.12.2 need some APIs just exist in gtk2hs darcs, so manatee-0.2.2 use webkit-0.12.1 * Fixed curl compile problem, at least curl-1.3.7, curl-1.3.6 have compile problem with GHC-0.7.3 Please let me know if you have problem about Manatee. :) Cheers, -- Andy

1 0

Fwd: Work on Collections Processing Arrows?
by David Barbour 14 May '11

14 May '11

[Apparently I forgot to hit reply-all.] Thanks for your response, Adam. On Tue, May 10, 2011 at 1:25 PM, Adam Megacz <megacz(a)cs.berkeley.edu> wrote: > > class (GArrowMap a (**) u c) => GArrowJoin a (**) u c where > > join :: a d (c r) -> a (c d) (c r) > > I like these; I think you're on the right track. The last one reminds > me of concatMap. > That might be a better name for it. I was thinking in terms of a relational join. > > Perhaps what you want is > > gac_drop :: a (c u) u > > ... which is a bit like ga_cancell and ga_cancelr, but for a whole > collection rather than one input at a time. > That sounds reasonable, but also looks like users would need mapA to ever leverage it. I was imagining that some models might provide mapA_ without mapA, i.e. only allowing further composition through side-effects similar to a 'for' loop in a C-family language. This is not very composition friendly, of course, but it might be easier to implement and sufficient for the job. -- | process each element in a collection, then cancel it. class (GArrow a (**) u) => GArrowMap_ a (**) u c where ga_map_ :: a d u -> a (c d) u -- | process each element in a collection; the result is subject to -- further composition. class (GArrowMap_ a (**) u c) => GArrowMap a (**) u c where ga_map :: a d r -> a (c d) (c r) > By the way, I've started [2] using type families for the "aggregate" > GArrow classes like GArrowSTLC. This greatly reduces the syntactic > noise in the types -- you only have one type parameter instead of four. > The price is that a single type can't be an instance of these classes in > more than one way (see Section 3.6.1 of [3] for why this is important). > Sounds good. I look forward to seeing where that goes. I use type and data families quite heavily in my own models - they're much friendlier for inference. > > In my own case, 'c' might be representing an asynchronous or > > distributed, reactive collection, so the ability to restrict > > expressiveness is important for performance. > > Certainly. The multiplicative disjunction [4] of linear logic is the > "binary" version of this: (A \bindnasrepma B) is sort of like an A and a > B in geographically distant locations; if you have a (Int \bindnasrepma > Int) you have two Int's, but in order to (for example) add them together > you must use some sort of communication primitive to get them both to > the same place. > I must admit to some confusion that you likened asynchronous/distributed products used in 'synch' to 'additive conjunction' in the earlier message (help for asynchronous arrows) and the same concept to multiplicative disjunction here. Elements in such a product may exist at different times (i.e. production latencies from some initial event) as well as different locations. > It sounds like you want a sort of "collection version" of multiplicative > disjunction. I bet Data Paralell Haskell's parallel array type-former > (([::]) :: * -> *) would be an instance of this class. > Data Parallel Haskell is all about performance, doesn't really admit to parallel semantics or asynchronous side-effects as a result of mapping arrows across the collection. To the extent it qualifies, I suspect so would a normal list. Dave

2 1

Work on Collections Processing Arrows?
by David Barbour 14 May '11

14 May '11

Has anyone developed a typeclass model for (Control.Monad.mapM) and related functions for arrows? I've a preliminary model, using Adam Megacz's Generalized Arrows, of the form: class (GArrowDrop a (**) u) => GArrowMap_ a (**) u c where mapA_ :: a d u -> a (c d) u class (GArrow a (**) u c) => GArrowMap a (**) u c where mapA :: a d r -> a (c d) (c r) class (GArrowMap a (**) u c) => GArrowJoin a (**) u c where join :: a d (c r) -> a (c d) (c r) class (GArrow a (**) u) => GArrowUnion a (**) u c where union :: a ((c r) ** (c r)) (c r) class (GArrowMap a (**) u c, GArrow a (++) v) => GArrowPartition a (**) u (++) v c where partition :: a d (q ++ r) -> a (c d) ((c q) ** (c r)) Motivations: regular arrows (including GArrows) expose simple products for behavior, but those have a static 'width' and don't seem suitable for processing large values. ArrowApply would give me a dynamic amount of processing, but seems excessively expressive. In my own case, 'c' might be representing an asynchronous or distributed, reactive collection, so the ability to restrict expressiveness is important for performance. I'm wondering if you know of any other work along the same lines. Thank you, Dave

2 3

Re: [Haskell-cafe] cabal-latest
by Jason Dagit 13 May '11

13 May '11

On Thu, May 12, 2011 at 7:24 AM, Guy <guytsalmaves-h(a)yahoo.com> wrote: > http://www.haskell.org/cabal/release/cabal-latest/ points to version > 1.8.0.4. Is this correct? > Replying to this on Haskell-Cafe and cabal-dev lists. The latest version is 1.10.x and ships with the HP. I bet that link is just needs to be updated. Jason

1 0

old versions of cabal install
by Evan Laforge 13 May '11

13 May '11

If you search for "cabal install", the first link is http://hackage.haskell.org/trac/hackage/wiki/CabalInstall, which in turn leads to http://haskell.org/cabal/download.html. It looks very official and canonical and all that, but that page has an old version of cabal install that will no longer compile with ghc7 because it requires old libraries. Of course it won't tell you that right off, first it will install a whole bunch of old stuff, charge you a fiver, and then emit some "constraint can't be satisfied" msgs which if you have some experience with haskell and cabal already should eventually tip you off that something's wrong. Is there someone out there who has permissions to either take that page down, or replace it with a link to the new version at http://hackage.haskell.org/package/cabal-install? I updated http://hackage.haskell.org/trac/hackage/wiki/CabalInstall to point to the platform and to the hackage page, but the cabal page at http://haskell.org/haskellwiki/Cabal-Install still links to http://haskell.org/cabal/download.html. Should I just replace the haskellwiki page with a link to the hackagewiki one? I would try to port over any up to date info of course.

1 0

ANN: AERN-Real-Double-2011.1
by Michal Konečný 13 May '11

13 May '11

Dear all, I am pleased to announce the first release of (a large part of) a newly designed AERN. AERN (approximating exact real numbers) is a set of Haskell libraries providing arbitrary precision interval arithmetic, polynomial arithmetic and distributed lazy exact real computation. Anyone is welcome to join in the development of AERN via http://code.google.com/p/aern/ . This release contains the following features: * Type classes for rounded arithmetic and rounded interval arithmetic with explicit control of rounding direction and the possibility to increase the rounding precision arbitrarily for types that support it. For example, type classes for types with rounded addition, multiplication, exponentiation etc. * Over 150 QuickCheck properties for these type classes, such as associativity of multiplication modulo rounding. * Interval arithmetic using Double endpoints, rounded outwards or inwards. Outwards rounding allows to safely approximate exact real arithmetic while a combination of both outwards and inwards rounding allows one to safely approximate exact interval arithmetic. Inverted intervals with Kaucher arithmetic are also supported. * For most of the type classes there are also in-place versions that act in the ST monad on mutable variables containing numbers or intervals. This facilitates some explicit memory allocation optimisation, especially for data on the C heap. The best starting point for experimenting with these features are the demo programs included in the bundle and the documentation for the AERN-Real-Double package: http://www-users.aston.ac.uk/~konecnym/aern/AERN-Real-Double (The HackageDB page does not have Haddock documentation because AERN fails to build with ghc 7.0.* due to a compiler bug.) The following features are planned for future releases: * Interval arithmetic with MPFR arbitrary precision endpoints. * Polynomial interval arithmetic with an optimised C core * Distributed exact real and geometric computation with lazy query-driven communication. For those familiar with the old AERN design, the main changes in the new design are: * use of many smaller type classes instead of few large ones * use of associated types instead of multi-parameter type classes * a much more systematic approach to representing the numerical order on real numbers and the information refinement (ie the inverse set inclusion) order on intervals * ability to specify different effort indicator types for each type of operation and each numerical type instead of Int. (For example, Double has () as its effort indicator for almost all operations while MPFR will have Precision as the effort indicator type.) * a more systematic approach to specifying QuickCheck properties and applying them to form test suites * a unified implementation of interval elementary operations (only sqrt and exp at the moment) that is efficient when applied to Double intervals as well as polynomial intervals * new support for in-place rounded numerical operations The current development team will be grateful for any feedback and suggestions. Best regards, Michal -- |o| Michal Konecny <mikkonecny(a)gmail.com> |o| http://www-users.aston.ac.uk/~konecnym/ |o| office: (+42) (0)121 204 3462 |o| PGP key http://www-users.aston.ac.uk/~konecnym/ki.aston

1 0

how to force hackage to use ghc 6.12.3
by Michal Konečný 13 May '11

13 May '11

Hi, I have been releasing packages on hackage that do not build with ghc 7.0.* due to a bug that will be fixed in ghc 7.2.1. (One of the packages is http://hackage.haskell.org/package/AERN-Basics) I was hoping hackage will try also ghc 6.12.3 but it does not. Is there some way I can change the cabal file to help hackage to compile it with 6.12.3 and generate haddock? The package requires base >= 4 so I cannot try base < 4. Michal -- |-| Dr. Michal Konecny, Computer Science, Aston University |-| Room MB212D | Tel +44 121 204 3462 | Fax +44 121 204 3681 |-| http://www.aston.ac.uk/~konecnym |-| OpenPGP key http://www.aston.ac.uk/~konecnym/ki.aston -- |o| Michal Konecny <mikkonecny(a)gmail.com> |o| http://www-users.aston.ac.uk/~konecnym/ |o| office: (+42) (0)121 204 3462 |o| PGP key http://www-users.aston.ac.uk/~konecnym/ki.aston

3 3

ANN: Newt - command-line template instantiation tool & library
by Rogan Creswick 13 May '11

13 May '11

I'm happy to announce Newt: a trivial tool for creating boilerplate. I frequently need to create projects with slight customizations -- I have a particular layout for cabal projects, and make files for LaTeX papers, etc... However, there are often fields that need to be updated in many places. (At times, even file or directory names need changed.) Newt makes this trivial. My objective was to provide a tool that allows you to very quickly take a project, mark the portions that must change with angle brackets, and use that as a source for myriad derivations of that project, or share the project for others to create their own instances. Newt scans the input (either a file, directory or stdin) for tags marked with "<<<tagName>>>" [1], then replaces those entries with values specified on the command line, producing either a new file, modifying the input template in place (--inplace), writing to stdout, or writing to a directory. A newt template for a cabal project is available on github: - http://github.com/creswick/Newt/tree/master/tests/testFiles/dirTemplates/ca… Newt is available on hackage[2], and the source is hosted on github[3]. The readme provides more details and examples: - http://github.com/creswick/Newt/blob/master/README.md --Rogan [1] The tag syntax can be changed with command-line flags, or by creating an instance of the Tag typeclass. See --help. [2] http://hackage.haskell.org/package/newt [3] http://github.com/creswick/Newt/

3 4

Hash table constructors return table in IO Monad. Why?
by michael rice 13 May '11

13 May '11

Is there some reason why ALL the ways to create a hash table return one in the IO Monad, but all the functions for retrieving a value from a hash table take as an argument a hash table NOT in the IO Monad? Michael ================= Prelude Data.HashTable> let ht = fromList id [(5,'a'),(6,'b')]Prelude Data.HashTable> fmap ((flip Data.HashTable.lookup) 6) htPrelude Data.HashTable> Prelude Data.HashTable> :t fmap ((flip Data.HashTable.lookup) 6) htfmap ((flip Data.HashTable.lookup) 6) ht :: IO (IO (Maybe Char))

4 6

ANNOUNCE: iterIO-0.1 - iteratee-based IO with pipe operators
by David Mazieres 12 May '11

12 May '11

Hi, everyone. I'm pleased to announce the release of a new iteratee implementation, iterIO: http://hackage.haskell.org/package/iterIO IterIO is an attempt to make iteratees easier to use through an interface based on pipeline stages reminiscent of Unix command pipelines. Particularly if you've looked at iteratees before and been intimidated, please have a look at iterIO to see if it makes them more accessible. Some aspects of iterIO that should simplify learning and using iteratees are: * Every aspect of the library is thoroughly document in haddock including numerous examples of use. * Enumerators are easy to build out of iteratees. * There is no difference between enumerators and "enumeratees" (i.e., inner pipeline stages). The former is just a type-restricted version of the latter. * Parsing combinators provide detailed error reporting and support LL(*) rather than LL(1) parsing, leading to fewer non-intuitive parsing failures. A couple of tricks avoid consuming excessive memory for backtracking. * Super-fast LL(1) parsing is also available through seamless integration with attoparsec. * A universal exception mechanism works across invocations of mtl monad transformers, thereby unifying error handling. * All pipe operators have uniform semantics, eliminating corner cases. In particular, if the writing end of a pipe fails, the reading end always gets EOF, allowing it to clean up resources. * One can catch exceptions thrown by any contiguous subset of stages in a pipeline. Moreover, enumerator exception handlers can resume downstream stages that haven't failed. * The package is full of useful iteratees and enumerators, including basic file and socket processing, parsec-like combinators, string search, zlib/gzip compression, SSL, HTTP, and "loopback" enumerator/iteratee pairs for testing a protocol implementation against itself. Please enjoy. I'd love to hear feedback. David

16 32

parsing currency amounts with parsec
by Eric Rasmussen 12 May '11

12 May '11

Hi everyone, I am relatively new to Haskell and Parsec, and I couldn't find any articles on parsing numbers in the following format: Positive: $115.33 Negative: ($1,323.42) I'm working on the parser for practical purposes (to convert a 3rd-party generated, most unhelpful format into one I can use), and I'd really appreciate any insight into a better way to do this, or if there are any built-in functions/established libraries that would be better suited to the task. My code below works, but doesn't seem terribly efficient. Thanks! Eric ------------------------------------------------- {- parses positive and negative dollar amounts -} integer :: CharParser st Integer integer = PT.integer lexer float :: CharParser st Double float = PT.float lexer currencyAmount = try negAmount <|> posAmount negAmount = do char '(' char '$' a <- currency char ')' return (negate a) posAmount = do char '$' a <- currency return a currency = do parts <- many floatOrSep let result = combine orderedParts where combine = sumWithFactor 1 orderedParts = reverse parts return result floatOrSep = try float <|> beforeSep beforeSep = do a <- integer char ',' return (fromIntegral a :: Double) sumWithFactor n [] = 0 sumWithFactor n (x:xs) = n * x + next where next = sumWithFactor (n*1000) xs

5 6

Haskell Weekly News: Issue 181
by Daniel Santa Cruz 12 May '11

12 May '11

Welcome to issue 181 of the HWN, a newsletter covering developments in the Haskell community. This release covers the week of May 1 to 7, 2011. Announcements Last week I failed to note the announcement [http://goo.gl/ApClU] of a new version of Leksah (0.10.0). If you haven't yet, give Leksha a test run and send some feedback! Ketil Malde started a thread [http://goo.gl/Prlu2] about Robert Harper's thoughts on monads and laziness. Hakim Cassimally extended an invitation [http://goo.gl/QIjcF] to anyone living in the Northwest UK for Tuesday May 31st to Geekup's first ever "Functional Programming Night". Andy announced [http://goo.gl/uCEn1] a new release of Manatee (0.2.1). Quotes of the Week * hpc: [SPOILER] You can check wikipedia for the definition of fibonacci sequences if you get stuck after half an hour * pmetzger: it is always possible to make an algorithm slower. just give it to a CS freshman to code up. * kmc: ghc -XMixfixOperators -XDependentTypes -XMakeMeASandwich * pmetzger: I have my password tattooed to my forehead. that way when I forget it others can tell me what it is. * alexbagel: i find that my first 26 variables are always easy to name. after that it becomes a bit harder. * Eric Kow: Haskell is a good fit for me because I tend to practise Doh!-oriented programming Top Reddit Stories * More points for lazy evaluation Domain: augustss.blogspot.com, score: 56, comments: 24 On Reddit: http://goo.gl/qecQ1 Original: http://goo.gl/OnJXx * iterIO: iteratee-based IO with pipe operators, courtesy David Mazieres Domain: haskell.org, score: 43, comments: 15 On Reddit: http://goo.gl/YzPJn Original: http://goo.gl/6WQAk * Monad comprehensions are finally in GHC Domain: self.haskell, score: 37, comments: 32 On Reddit: http://goo.gl/1Rjnw * Horner's Rule Domain: patternsinfp.wordpress.com, score: 34, Comments: 2 On Reddit: http://goo.gl/A1wYo Original: http://goo.gl/zeC1f * Patent 5,893,120 reduced to mathematical formulae (via Haskell) Domain: paulspontifications.blogspot.com, score: 31, comments: 13 On Reddit: http://goo.gl/PmB4K Original: http://goo.gl/QknmV * Custom Haskell mug! Domain: imgur.com, score: 31, comments: 6 On Reddit: http://goo.gl/lD388 Original: http://goo.gl/bzZR8 * Differences between 'data' and 'newtype' ... in pictures Domain: stackoverflow.com, score: 31, comments: 2 On Reddit: http://goo.gl/5YaSo Original: http://goo.gl/KQiJv * Haskell: not pure enough? Domain: blog.ezyang.com, score: 30, comments: 19 On Reddit: http://goo.gl/6v28x Original: http://goo.gl/zsfSq * Galois is hiring computer scientists Domain: corp.galois.com,score: 27, comments: 28 On Reddit: http://goo.gl/ToeJ0 Original: http://goo.gl/osjJY * Fancy comparison of Data values Domain: pnyf.inf.elte.hu, score: 26, comments: 18 On Reddit: http://goo.gl/BlFVl Original: http://goo.gl/RuMKT Top StackOverflow Questions * Ordering of parameters to make use of currying votes: 43, answers: 3 Read on SO: http://goo.gl/7LnBJ * Difference between 'data' and 'newtype' in Haskell votes: 29, answers: 2 Read on SO: http://goo.gl/KQiJv * Haskell: why the convention to name a helper function "go"? votes: 24, answers: 3 Read on SO: http://goo.gl/CE1O7 * How do you design programs in Haskell or other functional programming languages? [migrated] votes: 24, answers: 0 Read on SO: http://goo.gl/IW7Z5 * Haskell Graphics Library that works in GHCi on MacOS X votes: 19, answers: 3 Read on SO: http://goo.gl/VZGAK About the Haskell Weekly News To help create new editions of this newsletter, please send stories to dstcruz(a)gmail.com. Until next time, Daniel Santa Cruz

1 0

request for example code referenced in "All About Monads"
by Michael Litchard 12 May '11

12 May '11

The html version of All About Monads has dissapeared, so I am making due with the pdf version. As a consequence I don't have access to the example code files referenced. I know someone out there has them. Could you make them available please?

1 0

Parallel Haskell Digest 2
by Eric Y. Kow 11 May '11

11 May '11

Parallel Haskell Digest ======================= Edition 2 2011-05-11 Hello Haskellers! Welcome to the second edition of the Parallel Haskell Digest, bringing you news, discussions and tasters of parallelism and concurrency in Haskell. The digest is made possible by the Parallel GHC project. More news about how we're doing below. Note that this edition of the digest may be best viewed in blog form at http://www.well-typed.com/blog/52 (there's an inline picture). News ---------------------------------------------------------------------- * Workshop of the 2nd SICSA MultiCore Challenge (27 May, Glasgow; registration deadline 18 May) The goal of the SICSA MultiCore challenge is to bring together researchers in the area of parallel programming, by implementing one or more challenge applications on (networks of) multi-core machines. The goal is to learn about the strengths and weaknesses of current systems for parallel programming by comparing them on a common application. The final workshop will feature presentations of the individual implementations, assessing both raw performance as well as ease of parallelisation and other aspects in the development of this parallel application. https://groups.google.com/d/topic/parallel-haskell/K-IJ2roA59I/discussion * Parallel Haskell Portal One of things I've been working on at Well-Typed is to help clean up the Haskell wiki documentation on parallelism and concurrency. There's still a bit of gardening to do, but we're ready to unveil what we have now. The Parallel Haskell portal is targeted primarily at people getting started with parallelism and concurrency in Haskell. It places a lot of emphasis on steering readers towards mature technologies, while still offering a path for more advanced users to dig deeper into current research. http://www.haskell.org/haskellwiki/Parallel Word of the Month ---------------------------------------------------------------------- This edition of the digest is brought to you by threads, threads and more threads. In the last digest, we took a look at Haskell sparks and particularly at how they differ from threads. Now let's delve a little bit deeper into threads. A "thread of execution" is a programming abstraction that helps the programmer separate concerns within a program. Consider a web server serving many documents to many clients simultaneously. The programmer may wish to use threads, using one thread per client making it easier to manage concurrent action. [1] In the Haskell world, this programming abstraction is provided by Haskell threads. To implement Haskell threads, the GHC runtime system uses what is known as a M:N threading model, where many Haskell threads are scheduled across a much smaller number of operating system threads. This model has two key benefits: * it can make use of multiple CPU cores * it allows Haskell threads to be very cheap Don Stewart illustrated this on StackOverflow with the following diagram, citing 2011 figures of a handful of CPUs, a dozen or so OS threads and tens of thousands of Haskell threads (plus for those of us interested in pure parallelism, millions of sparks). http://i.imgur.com/u53Uk.png If you want to try generating some figures for yourself, have a look at the benchmark utility at http://darcs.haskell.org/nofib/smp/threads005/Main.hs The benchmark tool creates a large "pipeline" of simultaneous Haskell threads, and tries to send a message through the pipeline, passing it from one thread to the next. On my laptop, I can create 10000 Haskell threads in 0.074 seconds and pump "Hello World" through them in 0.07 seconds. That works out to 7.4 microseconds per thread (0.7 microseconds for pumping). How about giving it a shot on your computer? Haskell threads are very lightweight. For most concurrency needs, you can generally forget that operating system threads exist. Indeed, when the documentation for modules like Control.Concurrent refers to "threads", or when Haskell hackers discuss threads in Haskell code it's a good bet that they're referring to Haskell threads rather than OS threads. That said, there are a few occasions where you may want to be aware about OS threads, in order of importance, if you * want your Haskell threads to be running in parallel on multiple cores (for better performance) instead of just being interleaved on a single core, or * need to make foreign calls concurrently with doing other things (eg. running Haskell code or making other foreign calls) Doing any of these things requires that you use GHC's multi-threaded runtime system. GHC currently uses a single-threaded runtime system by default, but until this changes, you will have to explicitly enable the multi-threaded one by linking your program with the flag `-threaded`. With the multi-threaded runtime system all Haskell threads are scheduled across multiple OS threads as opposed to being interleaved on a single one. This allows for parallelism in the first case, for concurrent foreign code in the second case. For the first case, you may want to note that on top of enabling the multi-threaded RTS, you will also need to tell the runtime system to let some of those run some of those OS threads simultaneously (which in run requires that you have multiple cores). You can do this by passing `+RTS -N` to your program during runtime (with GHC 6.12.1 and higher, the bare -N flag will cause the RTS to use a sensible default based on the number of CPU cores on your machine). This is only if you are specifically interested in parallelism. If you are only concerned about making foreign calls, just enabling the multi-threaded RTS is enough. The issue with the single-threaded runtime system is that Haskell threads that make foreign calls to the operating system or C libraries will block all other Haskell threads. This means that if a foreign call should take a long time, or worse, if it should block in its own right, all other Haskell threads will be stuck. With the multi-threaded runtime system, Haskell that make foreign calls do not block other Haskell threads, because they can be handed over to another OS thread while the one making the foreign call is churning away. But be careful! Concurrency with foreign calls can be a tricky business. If you are only using one OS thread at a time, you are effectively shielded from having to worry about concurrency issues in foreign code (by not being able to run foreign code concurrently). Enabling multi-threaded mode comes with extra responsibility of making sure any foreign libraries you use are thread-safe, or that you have adequate mechanisms to deal with the ones that are not. Thread-safety isn't an issue with Haskell-only code because shared state is always managed with locks or atomicity. But when concurrency and foreign calls mix, you will need to take care. There's another issue to watch out for when mixing foreign calls with multiple OS threads. The nice thing thing about the M:N threading model in Haskell is that the GHC RTS scheduler will automatically move Haskell threads between OS thread to achieve a good balance of work. But this introduces a new problem for foreign libraries that use thread-local state: the Haskell thread may calling the library from any number of OS threads, so if the foreign library uses OS-thread-local state then this state could be different from one call to the next... what a mess! To solve this problem we have to use a feature called "bound threads". Bound threads are Haskell threads that are bound to a single OS thread; they are not moved around by the scheduler. Bound threads are more expensive than unbound ones because they tie up a whole OS thread, but they are necessary for working with certain foreign libraries like OpenGL that make essential use of thread local state. Summing up threads in Haskell: * When writing concurrent programs in Haskell, we deal primarily with Haskell threads, paying attention only to OS threads when we have to. * Haskell threads run on one or more OS threads, but you get concurrency either way. It is likely that in the future, GHC will use multiple OS threads by default but for now you have to explicitly enable it by linking your program using `-threaded`. * Foreign calls are potentially tricky! Make sure you either use thread-safe libraries or know how to manage non thread-safe ones. * If you are using foreign libraries that use thread-local state, use bound threads, that is, Haskell threads tied to an OS thread. [1] Thanks to Paul Bone for this paragraph https://groups.google.com/d/topic/parallel-haskell/fd6B9zbOvwM/discussion and also to Andres and Duncan from Well-Typed for extensive help revising this word of the month! Parallel GHC project news ---------------------------------------------------------------------- The Parallel GHC Project is an MSR-funded project to push the real-world use of parallel Haskell. Part of this project involves effort by Well-Typed to provide tools for use by the general community: We have begun work on making the "Modified Additive Lagged Fibonacci" and perhaps other random number generators from the SPRNG library available in Haskell. As a first step to the Haskell SPRNG reimplementation, we have developed a [binding](https://github.com/bjpop/haskell-sprng) to the existing C++ library. The binding will serve as a refernence implementation to test against, but it also ready to be used now. To complement our work on extending GHC eventlog and Threadscope to support multi-process or distributed Haskell systems, we have begun work on developing new visualisations for ThreadScope, including the rate of parallel spark creation, and the distribution of spark evaluation times. Meanwhile, work continues on our project partners' side. We hope to be say more about it in the next edition of the digest :-) For more information on the Parallel GHC project, see http://www.haskell.org/haskellwiki/Parallel_GHC_Project Talks ---------------------------------------------------------------------- 1. High-Performance Web Applications in Haskell Gregory Collins gave a talk at QCon London (11 March). Greg delivered this message to an an enterprise software development crowd: "Haskell is a really good choice for web programming". Check out his slides to see how Haskell can help you to write scalable web applications http://qconlondon.com/dl/qcon-london-2011/slides/GregoryCollins_HighPerform… 1. Parallel = functional: the way of future. Simon Peyton-Jones gave the keynote talk at the London FP Exchange (18 March), with a whirlwind overview of what's going on in the world of parallel Haskell. You can watch the [video](http://skillsmatter.com/podcast/scala/talk-by-haskell-expert-simon-p… and follow along on the [slides](http://research.microsoft.com/%7Esimonpj/papers/parallel/Parallel-H…. Blogs, papers and packages ---------------------------------------------------------------------- 1. Mstate - a concurrent state monad (5 April). Nils Schweinsberg released a small library called mstate which offers a threadsafe equivalent to the State monad (and transformer). The library makes it easy to start stateful threads, grab their results when they finish and handle any exceptions along the way. http://blog.n-sch.de/2011/04/05/mstate-a-concurrent-state-monad/ 1. monad-par - This library offers an alternative parallel programming API to that provided by the parallel package. The Par monad allows the simple description of parallel computations, and can be used to add parallelism to pure Haskell code. The basic API is straightforward: the monad supports forking and simple communication in terms of IVars. The library comes with an efficient work-stealing implementation, but the internals are also exposed so that you can build your own scheduler if necessary. http://hackage.haskell.org/package/monad-par 1. Real-time edge detection with the latest release of the parallel array library Repa. The folks at UNSW have released version 2.0.0.1 of the Repa high performance parallel array library, with along with an example use case doing edge detection in real time with the Canny algorithm. http://pls.posterous.com/real-time-edge-detection-with-the-latest-rele 1. Haskell for the Cloud (Jeff Epstein, Andrew Black and Simon Peyton Jones) Erlang style distributed programming in Haskell "We present Cloud Haskell, a domain-specific language for developing programs for a distributed-memory computing environment. Implemented as a shallow embedding in Haskell, it provides a message-passing communication model, inspired by Erlang, without introducing incompatibility with Haskell's established shared-memory concurrency. A key contribution is a method for serializing function closures for transmission across the network. Cloud Haskell has been implemented; we present example code and some preliminary performance measurements'" * http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel/remot… * http://www.reddit.com/r/haskell/comments/gjb52/haskell_for_the_cloud_new_pa… * http://hackage.haskell.org/trac/ghc/wiki/ErlangInHaskell Parallel-Haskell and Haskell Cafe ---------------------------------------------------------------------- * How to daemonize a threaded Haskell program? (5 March). Bas van Dijk would like to turn his Haskell program into a Unix daemon. This is made complicated by the fact that his program needs to run simultaneous threads, and that forkProcess is not supported in GHC when running on multiple processors. Bas wrote a C wrapper to do the forking and call his Haskell main function, and asked about the practicalities of combining the two pieces with Cabal. Further discussion converged on doing the daemonization outside the program, in particular with the help of Upstart on Ubuntu. * http://www.haskell.org/ghc/docs/latest/html/libraries/unix-2.4.2.0/System-P… * http://www.haskell.org/pipermail/haskell-cafe/2011-March/089891.html * Parallel Haskell stories (9 March). Simon Peyton Jones was looking for stories about using parallel or concurrent Haskell to use in his keynote talk (see above). Stories so far: basic concurrency in the IRC Hulk (see PH Digest 1), STM in a vending machine simulator, and the BitTorrent client Combinatorrent, and parallelism in the Cryptographic Protocol Shapes Analyzer http://www.haskell.org/pipermail/haskell-cafe/2011-March/090028.html * Light and fast HTTP server (11 March) Victor Oliveira needed help choosing among all the HTTP servers on Hackage. He wanted something light, fast and basic along the lines of nginx. Responses so far point mainly to Snap and Warp. http://www.haskell.org/pipermail/haskell-cafe/2011-March/090114.html * Simple STM question (15 March) qld3303 noticed a bit of STM code seemed to stop working when he upgrade to GHC 7.0.2. The issue turns out to have been a mistaken use of "pure" to run an IO action, which is a no-op as pure for IO is the same as return. http://www.haskell.org/pipermail/haskell-cafe/2011-March/090182.html * STM, newArray, and a stack overflow? (23 March) Ketil Malde got a stack overflow creating a large array in STM. The equivalent code works fine in the ST monad, or in GHCi. After some digging around, Bas van Dijk tracked it down to a bug in the newArray method of TArray. His fix has been pushed and should appear in GHC 7.2. * http://www.haskell.org/pipermail/haskell-cafe/2011-March/090419.html * http://hackage.haskell.org/trac/ghc/ticket/5042 * Writing to a FIFO when the reader stops reading (13 March) Brian D had some simple code that continuously writes to a FIFO and gets a "Broken pipe" error when the reader goes away. He wanted to check that this was expected behaviour (it was) and that he wasn't missing something on the Haskell side (he wasn't). The advice was to use a Unix file socket instead. http://www.haskell.org/pipermail/haskell-cafe/2011-March/090142.html * BlockedIndefinitelyOnMVar exception (31 March) Mitar wanted to know if there was any way to disable throwing BlockedIndefinitelyOnMVar exceptions. Such exceptions are thrown during a particular known deadlock, "when a thread is blocked on an MVar but there are no other references to the MVar so it can't ever continue." This lead to more discussion about what to do during cases where it would be desirable to just keep the thread around (eg. until it's explicitly killed). Some options are to catch and ignore the exception; or to contrive to keep some other references to the MVar (eg. putting it in a StablePtr), or otherwise prevent the thread from being garbage collected. * http://www.haskell.org/pipermail/haskell-cafe/2011-March/090624.html * http://www.haskell.org/ghc/docs/latest/html/libraries/base-4.3.1.0/Control-… * Parallelism and concurrency revisited and diagrammed. To help me come to grips with how people talk about "parallelism" and "concurrency" in Haskell, I tried making a diagram how our language about the two interleave. https://groups.google.com/d/topic/parallel-haskell/j85VZvRujyg/discussion Stack Overflow ---------------------------------------------------------------------- * How to choose between parList and parBuffer ? http://stackoverflow.com/questions/5352683/how-to-choose-between-parlist-an… * How to exploit any parallelism in my haskell parallel code ? (17 March) http://stackoverflow.com/questions/5345981/how-to-exploit-any-parallelism-i… * Performance considerations of Haskell FFI / C? (14 April) http://stackoverflow.com/questions/5665209/performance-considerations-of-ha… * Reentrant caching of “referentially transparent” IO calls http://stackoverflow.com/questions/5484847/reentrant-caching-of-referential… (30 March) Help and feedback ---------------------------------------------------------------------- Got something for the digest? Send me an email at eric(a)well-typed.com. I'm particularly interested in short parallelism/concurrency puzzles, cool projects for featured code. Other comments and feedback (criticism and corrections especially!) would be welcome too. -- Eric Kow <http://erickow.com>

1 0

Markov chain algorithm (from "The Practice of Programming", Kernighan/Pike)
by michael rice 11 May '11

11 May '11

It's hard to improve on a 20 line Awk program for generating text but I thought it would be fun to investigate a Haskell solution. Why can't I cons an element onto an existing list? Michael Prelude Data.List Data.Map> insertWith (:) ("Moby", "Dick") "will" (fromList [(("Joe", "Blow"),["is"]), (("Moby", "Dick"),["may"])]) <interactive>:1:11: Occurs check: cannot construct the infinite type: a = [a] Expected type: a Inferred type: [a] In the first argument of `insertWith', namely `(:)' In the expression: insertWith (:) ("Moby", "Dick") "will" (fromList [(("Joe", "Blow"), ["is"]), (("Moby", "Dick"), ["may"])])Prelude Data.List Data.Map>

3 2

need help on building a huge graph
by Bin Jin 11 May '11

11 May '11

Hi, cafe I'm recently solving some algorithm puzzles from previous Google Code Jam rounds, and today I met some problem I can't solve now. It's a problem (Round 3 2010, B) that the solution require to find a shortest path in a graph with about 100,000 vertices and 50 edges from each vertex. Apart from find shortest path, I find that building graph also takes a lot of time. Yes, I know it's unnecessary to dump the entire graph to the memory, but I want to know if it's possible to build such graph in some reasonable time. following is a snippet of code building the graph, runs about 15 mins on Core 2 Duo 2.40GHz without any RTS flags > > > import Data.Array > > > > main = graph `seq` putStrLn "Finished" > > > > n = 100000 > > bnds = (0, n-1) > > > > buildGraph bnds edges = accumArray (flip (:)) [] bnds edges > > > > graph = buildGraph bnds edges > > > > edges = [ (i, (y, 1 - x::Int)) > > | i <- range bnds > > , j <- [2..50] > > , let (x, y) = if i + j >= n then (1, i + j - n) else (0, i + j) > > ] > > > Regards, Bin Jin

2 2

Calculating the accuracy of bloom filters
by Ketil Malde 11 May '11

11 May '11

Hi, I'm using Bryan's bloomfilter package, and I would like to calculate the false positive rate after constructing the bloom filter. Two reasons: 1. Bloom filters have a power-of-two size, which means that the FP rate you ask for becomes an approximation (upper bound), and the real FP rate might be much smaller (down to the square of the requested value?) 2. When constructing the filters (inserting elements), I expect many duplicate elements. Since the FP rate only increases with insertion of unique elements, the a priori estimate is likely an overestimation. If I understand correctly, this is a simple matter of counting 1-bits in the array, and then taking the proportion of set bits ('b', say) to the power of (number of hash functions - 'h', say). Calculating b is easily done, but I don't know how to get at the number of hash functions. The Bloom filter data structure contains data Bloom a = B { hashB :: !(a -> [Hash]) , shiftB :: !Int , maskB :: !Int , bitArrayB :: !(UArray Int Hash) } I'm not sure how shiftB/maskB work, but I do have a function hashB that for any a will generate the list of hashes, i.e., I want the length of this list (which is constant for any a). But I need an 'a' to feed to it, and I don't see exactly how to do that. I notice that Neil's cmdargs have a value 'def', which seems to produce a "default" value, probably using some Typeable or Dynamic magic. Is that something I could leverage for my purposes? -k -- If I haven't seen further, it is by standing in the footprints of giants

1 0

Re: [Haskell-cafe] ANNOUNCE: iterIO-0.1 - iteratee-based IO with pipe operators
by John Lato 11 May '11

11 May '11

> > From: dm-list-haskell-cafe(a)scs.stanford.edu > > At Fri, 6 May 2011 10:10:26 -0300, > Felipe Almeida Lessa wrote: > > > So, in the enumerator vs. iterIO challenge, the only big differences I > see are: > > > > a) iterIO has a different exception handling mechanism. > > b) iterIO can have pure iteratees that don't touch the monad. > > c) iterIO's iteratees can send control messages to ther enumerators. > > d) iterIO's enumerators are enumeratees, but enumerator's enumerators > > are simpler. > > e) enumerator has fewer dependencies. > > f) enumerator uses conventional nomenclature. > > g) enumerator is Haskell 98, while iterIO needs many extensions (e.g. > > MPTC and functional dependencies). > > > > Anything that I missed? > > > > The bottomline: the biggest advantage I see right now in favor of > > iterIO is c), > > I basically agree with this list, but think you are underestimating > the value of a. I would rank a as the most important difference > between the packages. (a also is the reason for d.) > 'a' is important, but I think a lot of people underestimate the value of 'c', which is why a control system was implemented in 'iteratee'. I would argue that iteratee's control system is more powerful than you say. For example, the only reason iteratee can't implement tell is because it doesn't keep track of the position in the stream, it's relatively simple for an enumerator to return data to an iteratee using an IORef for example. And adding support to keep track of the stream position would be a pretty simple (and possibly desirable) change. But it's definitely not as sophisticated as IterIO, and probably won't become so unless I have need of those features. I like the MonadTrans implementation a lot. The vast majority of iteratees are pure, and GHC typically produces more efficient code for pure functions, so this is possibly a performance win. Although it makes something like the mutable-iter package very difficult to implement... John Lato

2 1

Modeling the performance of a non-trivial software app
by C K Kashyap 11 May '11

11 May '11

Hi, I was wondering if it would be a good idea to model a software app's performance using Haskell. The idea is a little abstract in my mind right now. I'll try and illustrate it with an example - Let's say, I want to model a web app - to, model it, I could think of the following entities - 1. One or more clients and as many connections (essentially bandwidth of each connection) 2. A Load balancer ( and bandwidths to the webservers) 3. Bunch of webservers (and bandwidths to the database server) 4. A database server Using the model, I could generate performance characteristics and figure out if database is the bottleneck or not ... if so, what level of sharding would be useful etc Is there already a wheel I am trying to re-invent? Has anyone attempted this? Regards, kashyap

2 2

Cairo package broken on Windows, or am I cooking it wrong?
by Eugene Kirpichov 10 May '11

10 May '11

Hello, After a moderate struggle with getting gtk2hs to install on Windows, I tried to install Chart and got a linker message saying "_cairo_image_surface_get_data" was missing. After another struggle I figured that if I launch ghci -lcairo-2 then everything works fine. I tried patching cairo.cabal by adding this line: extra-libraries: cairo-2 and reinstalling cairo. This helped, I could install Chart without problems. My question is: Should this line be added to cairo.cabal, or should everything have worked fine in some other magical way, but did not, because of some other error? How can I diagnose what's wrong? How is "cabal install" generally supposed to find that a dll is needed, if I don't write it down in the extra-libraries field? -- Eugene Kirpichov Principal Engineer, Mirantis Inc. http://www.mirantis.com/ Editor, http://fprog.ru/

1 0

Crypto-api performance
by Johan Brinch 10 May '11

10 May '11

Does anyone have experience with the crypto-api package? It seems to define a nice common API for block ciphers, hash functions and prng's. However, I get very low performance using it. I ran its benchmark on a NOP block cipher, where encryptBlock k = id, and it's still very slow. After expanded the included block cipher benchmark (which uses ECB) to include CBC and CTR I got the following: ECB: 30 MB/s -- somewhat slow CBC: 12 MB/s -- very slow CTR: 4 MB/s -- why is adding a counter so bad? Have anyone else benchmarked this and if so with what results? Are there any other high level crypto API? Here's my benchmark code for CTR (easily modified to use ECB/CBC): https://gist.github.com/954093 And here's my patched Benchmark/Crypto.hs: https://gist.github.com/954099 Package in question: http://hackage.haskell.org/package/crypto-api -- Johan Brinch, Dept. of Computer Science, University of Copenhagen

6 9

Those damned parentheses
by Eitan Goldshtrom 10 May '11

10 May '11

Hi. I am kind of tired of all of the parentheses I have to put in places and I'm trying to figure out what is the correct way to write code such that I can leave out parentheses. For example, I have the following: data Message = ... --leaving this out because it's not important data Plane = Plane { id :: Int, position :: (Int,Int,Int), direction :: Int, path :: [Int], messagebuf :: Chan Message } main = do c <- newChan :: Chan Message p <- Plane 0 (0,0,0) 0 [] c f p f p = putStrLn $ (show Main.id p) ++ " - message received" This causes an error "The function `show' is applied to two arguments". If I put instead: f p = putStrLn $ (show . Main.id p) ++ " - message received" I get the error "Couldn't match expected type `[Char]' with actual type `a0 -> c0'". The only way it seems to work is f p = putStrLn $ (show (Main.id p)) ++ " - message received" This seems to be the same for many other situations where I try to use function composition of some sort. It's just getting kind of annoying. -Eitan

9 11

Hackage build failure
by Jonas Almström Duregård 10 May '11

10 May '11

Hi, Is there something wrong with the Hackage build system? It fails to build BNFC-meta: http://hackage.haskell.org/package/BNFC-meta It complains about a missing dep even though it (the dependency) has been built successfully. Also the dependencies are exactly the same as in the previous version (which configures fine but fails to build because of some bug in HsColor). Regards Jonas

2 1

Re: [Haskell-cafe] [Haskell] ANN: syntactic-0.1
by Emil Axelsson 10 May '11

10 May '11

2011-05-10 15:31, Heinrich Apfelmus skrev: >>> I'm also unhappy about some of the boilerplate. For instance, have a >>> look at the function goE in compileAccumB (line 210), it's just a >>> generic applicative traversal through the data type. >> >> Most likely, this boilerplate could be simplified using syntactic. > > Hm, does the boilerplate get removed or only simplified? I was hoping > that one could use a completely generic traversal; but is that actually > the case? I was using careful wording :) I think the traversal can be completely generic. But syntactic brings its own (constant) overhead, so I felt the word "remove" might be too strong. > On closer inspection, I'm discovering another issue, namely the need for > the Typeable class. This is quite unfortunate, because it would mean > that I won't be able to make an API built on type classes like Functor > or Applicative. Some discussion on that can be found at the end of > > http://apfelmus.nfshost.com/blog/2011/04/24-frp-push-driven-sharing.html Hm... The only reason (afair) for having Typeable constraints in the tree was that my code motion transform (not yet released) needs to move around nodes in a way that the type checker is not happy with. But as long as my algorithm is correct, the type casts will actually always succeed. So it might be possible to use unsafeCoerce directly and get rid of Typeable. There might also be ways to make Typeable optional... I will look into this. > So, it looks like I can't make use of syntactic at the moment. Then > again, my library is probably one of the strongest tests of expressivity > for endeavors like syntactic , so that's fine. Another example of > similar difficulty would be D. Swierstra's recent parser/grammar > combinators that can handle left-recursive grammars. Once syntactic > can deal with those, you're the king! :) Thanks for the tip! It would be interesting to try out these libraries for real, if only for the sake of getting to know the practical limits of syntactic. But my focus is currently on the Feldspar implementation, so I probably won't have time for things like this in a (long) while. / Emil

1 0

An update on ICFP'11 in Tokyo (September 18-24, 2011)
by Wouter Swierstra 10 May '11

10 May '11

Given the fairly recent severe earthquake and tsunami in Japan, you may wonder how this affects the preparations for ICFP'11 in Tokyo. Luckily, Tokyo was significantly less affected by these saddening events than the regions further north. In fact, the situation in Tokyo is almost back to normal, after only two months, with another four months until ICFP. Moreover, all major embassies have in the meantime lifted their travel advisories for the Tokyo metropolitan region (while they still maintain active advisories for some other regions.) Our local organisational team has completed major parts of the preparations and recently summarised the most important facts on a local information page for ICFP'11: http://www.biglab.org/icfp11local/index.html The main conference site is at http://www.icfpconference.org/icfp2011/ We are looking forward to seeing you in Tokyo in September! Manuel Chakravarty Zhenjiang Hu (General Chairs of ICFP'11)

1 0

Template Haskell reified type.
by Serguey Zefirov 10 May '11

10 May '11

Language.Haskell.TH.Type contains, among others, two constructors: TupleT Int and ListT. I can safely construct types using them, but reification returns ConT "GHC.Tuple.(,)" and ConT "GHC.Types.[]" respectively. This is not fair asymmetry, I think. Also, it took purity from one of my functions while I debugged that problem. I had to make it into Q monad. ;)

2 2

Locking, unsafePerformIO and bolt-on thread safety.
by Jason Dusek 10 May '11

10 May '11

A friend is making bindings to a C library that offers some fast math operations. The normal way to use the library is like this: int a = ...; int b = ...; int c = ...; int d = ...; int x = ...; int m, n; create_lookup_table(x); m = perform_math(a, b, x); n = perform_math(c, d, x); We see that the lookup table for x must be created before we can perform math in the field/ring/what-have-you defined by x. Once we have created the table, though, we're done. My friend would like to create a pure interface to this library. One thought was to write an interface to perform_math that checked if the table was created, created it if not, and did all this while locking an MVar so that no other instance could be called at the same time, trashing the table. Doing this behind unsafePerformIO would seem to be the ticket. We end up with an implementation like this: module FastMath where import Control.Concurrent import Foreign import Foreign.C foreign import ccall create_lookup_table :: CInt -> IO () foreign import ccall perform_math :: CInt -> CInt -> CInt -> IO CInt masterLock = unsafePeformIO (newMVar [CInt]) safe_perform_math a b x = do list <- takeMVar masterLock toPut <- if not (x `elem` list) then do create_lookup_table x return (x:list) else return list result <- perform_math a b x putMVar masterLock toPut return result performMath a b x = unsafePerformIO (safe_perform_math a b x) This does not compile but I think it gets the point across. Is this approach safe? The unsafePerformIO in conjunction with locking has me worried. -- Jason Dusek () ascii ribbon campaign - against html e-mail /\ www.asciiribbon.org - against proprietary attachments

2 1

Re: [Haskell-cafe] Asynchronous Arrows need Type Specialization - Help!
by Paul L 10 May '11

10 May '11

I now understand where you are coming from, but I don't quite get your motivation to develop new classes for arrows. Tupling is Haskell is of course very lazy, it does not evaluate any of its element. As for the spatial and logical concepts, don't you think they are over-specifying what is really necessary for your system model? So I guess what I'm having trouble with is your arr f example. If f is sufficiently lazy, it does not evaluate the elements in its input tuple at all. Most pure functions we use to wire up arrows are like this: arr fst, arr snd, arr swap, arr (\x -> (x, x)), etc. I also don't quite follow your example of passing a time stamp together with value. Do you intend to keep the time stamp always updated? If you are getting unwanted results, it is perhaps due to wrong computation, rather than the composition to a pure functions. Maybe you want to give a specific example of "f". Regards, Paul Liu On Fri, Apr 1, 2011 at 1:55 PM, David Barbour <dmbarbour(a)gmail.com> wrote: > On Fri, Apr 1, 2011 at 11:47 AM, Paul L <ninegua(a)gmail.com> wrote: >> On Sun, Mar 20, 2011 at 10:18 PM, David Barbour <dmbarbour(a)gmail.com> wrote: >> >>> The (***) and (&&&) operations, as specified in Control.Arrow, are >>> inherently synchronization points. >>> >>> Ideally one could do something like: >>> >>> (a1 *** a2) >>> first a3 >>> >>> and the output from a1 would be piped directly as input to a3, without >>> touching a2. However, arrows also allow: >>> >>> (a1 *** a2) >>> arr f >>> >>> And, in this case, the current state of a1 and a2 must be combined >>> into a stream of pairs so that f may be mapped over the stream. >>> Obtaining both streams at a single place (a single vat) and time is a >>> synchronizing operation. The synchronization operations are severely >>> undermining the intended scalability and performance of this agent >>> abstraction. >> >> If what you mean by "synchronization" is that for every output of a1 >> there must be an output of a2, then YES. >> >> But if you mean that both the outputs of a1 and a2 have to be >> available (fully evaluated) due to the tupling, then NO, at least not >> in Haskell where things are evaluated lazily. > > What I mean by synchronization is that the outputs from a1 and a2 must > occur at the same logical or physical space and time. > > Assume 'a1' and 'a2' represent external, asynchronous resources. > * 'a1' loads a file, with latency 40 milliseconds. (input is filename) > * 'a2' is a database query, with a latency of 100 milliseconds. (input is query) > > (a1 *** a2) both loads a file and performs a query, then tuples the > results as (r1,r2). > > (a1 *** a2 >>> first a3) further processes the file state r1, > generating (r3,r2). > > Logically, a pair is a spatial-temporal concept: if you have a pair, > you have access to a fst and a snd value at the same place and the > same time. This synchronization is obvious if you pass values into an > 'arr' arrow. The 'physical' synchronization issue is that the naive > way to implement (a1 *** a2) is to wait for both resources to be > available (time) in the same thread (space), then generate a tuple > that couples the responses. > > For my programming model, however, I must avoid both forms of > synchronization. The 'logical' synchronization is minimized. You might > model this, roughly, by pairing the responses with their latencies: > ((40,r1),(100,r2)). This would essentially be a 'futures' passing > style. The idea is that '(a1 *** a2) >>> first a3' might generate > something like ((80,r3),(100,r2)). Explicit synchronization might > bring this to ((100,r3),(100,r2)). > > Futures passing might work well enough for the problem as I've > explained it to you. My programming model is operating under several > additional constraints to support reactivity, concurrency, > parallelism, scalability, distribution, and open systems. Under the > more stringent requirements, I've been unable to make futures fit the > problem. However, in the time since my last Haskell-cafe post, I have > found a way to leverage GADTs to at least keep elements of a product > distinct under-the-hood and minimize physical synchronization. > > data A a d r where > Aprim :: a d r -> A a d r > Aid :: A a r r > Acomp :: A a d' r -> A a d d' -> A a d r > Aarr :: (d -> r) -> A a d r > Aprod :: A a d r -> A a d' r' -> A (a,a') (d,d') > Adup :: A a (a,a) > Afst :: A a (b,c) b > Asnd :: A a (b,c) c > ... > >> >> BTW, according to arrow laws, (a1 *** a2) >>> first a3 is equivalent >> to (a1 >>> a3) *** a2, does the latter look more appealing to you? If >> yes, I don't see where is the problem, unless you intentionally want >> to make them different, and then it is no longer arrow. > > While both expressions should have equivalent observable properties, > neither Haskell nor Arrow laws assure they will possess the same > operational characteristics. In a naive implementation, the latter > will generally be the more efficient option. > > For efficiency reasons, I have also abandoned Ross's Control.Arrow. > The main problem with it is Ross's use of pragmas: > > {-# RULES > "first/arr" forall f . first (arr f) = arr (first f) > "second/arr" forall f . second (arr f) = arr (second f) > "product/arr" forall f g . arr f *** arr g = arr (f *** g) > "fanout/arr" forall f g . arr f &&& arr g = arr (f &&& g) > #-} > > These rules go the wrong direction, making the program more opaque to > the runArrow operation, and actually change both the physical and > logical synchronization characteristics for the worse. I.e. if I pass > ((80,r3),(100,r2)) to 'arr f', the output becomes available at logical > time 100 rather than time 80. > > Peter Gammie suggested use of Adam Megacz's Generalized Arrows, which > would avoid this problem by use of an opaque product type that can > only be converted to a pair by an explicit operation (i.e. 'synch :: a > (b**c) (b,c)' for opaque product type (**)). I'm still debating > whether to take this approach. > -- Regards, Paul Liu

2 1

Type-class conditional behavior
by Nicholas Tung 10 May '11

10 May '11

Dear all, I'd like to write a function "maybeShow :: a -> Maybe String", which runs "show" if its argument is of class Show. The context and motivation for this are as follows. I have a GADT type which encapsulates abstract-value computation (or constants or error codes), a snippet of which is below. data AV t where AVLeft :: AV a -> AV (Either a b) This is used to implement an arrow transformer, and due to Arrows mapping all Haskell functions, I cannot put some kind of qualification on the constructor, like "AVLeft :: Show a => ...". Of course any replies are welcome, but I do need something implemented and stable. If there are GHC-compatible hacks, even an "unsafeShow :: a -> String", that'd be great. I'd also prefer not to branch on all types which could possibly be maybeShow's argument. (Concretely, if I have "newtype AVFunctor a b c = AVF (a (AV b) (AV c))", then the Arrow class declaration forces all types, c.f. variable b, to be potential variables of type AV), class (Category a) => Arrow a where arr :: (b -> c) -> a b c Thanks very much, Nicholas — https://ntung.com — CS major @ UC Berkeley p.s. I posted this question on StackOverflow if you care to get brownie points there, http://goo.gl/PrmYW p.s. 2 -- if there is a general "dump var" function in ghci, which does more than ":info", I'd love to know :)

6 6

Using Haskell to describe computer hardware.
by Serguey Zefirov 09 May '11

09 May '11

http://thesz.mskhug.ru/svn/hhdl/ - main repository and http://thesz.mskhug.ru/svn/hhdl/examples/Simple.hs - three simple examples and http://thesz.mskhug.ru/svn/hhdl/MIPS-example/ - an attempt to describe MIPS-alike CPU using Haskell. Not yet done, it passes only simplest of tests (it fetches commands), but if you take a look at it you'll get an idea of what is going on. The goal is to create something along the lines of Bluespec, but as a DSeL in Haskell. Right now I concentrate on single-clock circuits, as they comprise most of hardware logic. I hacked together transformation of not-so-complex Haskell function definition into Haskell functions that operate on infinite streams. Of course, I tried my best to support calling other functions, conditional operators, pattern matching, etc, because that's what makes Haskell great and Bluespec has them too. Below is little explanation of three simple examples. First comes very simple function: $(transform [d| f1 :: (ToWires a, Num a) => (a,a) -> a f1 (a,b) = a + b |]) After $(transform ...) you will have two functions: f1 and f1_S, the second one operates on streams. ToWires class in the context ensure that input and output values can be converted into arrays of bits when we'll get that part ready. The type of f1_S is: *Simple> :t f1_S f1_S :: (ToWires a[a9GC], Num a[a9GC]) => (S a[a9GC], S a[a9GC]) -> (S a[a9GC], S [String]) or put simply: *Simple> :t f1_S f1_S :: (ToWires a, Num a) => (S a, S a) -> (S a, S [String]) It accepts two streams and return two streams - value and logs. We could add messages into logs: $(transform [d| f2 :: (ToWires a, Num a) => (a,a) -> a f2 (a,b) = s where s = a + b _display_a = a _display_b = b _display_s = s |]) f2 is just like f1, but when ran, it will produce logs about execution along the values. f2 used by runningSum, which compute a sum of values seen before current cycle: $(transform [d| runningSum :: (ToWires a, Num a) => a -> a runningSum x = currentSum where nextSum = f2 (x,currentSum) currentSum = register 0 nextSum _display_currentSum = currentSum _display_x = x _display_nextSum = nextSum |]) runningSum uses latches. It latches nextSum to pass the value to the next cycle using "register" function. "register" accepts default value and a value to latch (stream of values to delay) . When the time will come for synthesizing circuits, our register's will become actual latches with reset and clk wires. This is how we test our runningSum_S with simple data: runningSumLogs :: IO () runningSumLogs = do mapM putStrLn $ map unlines $ take 5 $ toList_S $ snd $ runningSum_S (fromList_S [1::Int ..]) return () The output will be like the following: currentSum: 0 x: 1 nextSum: 1 nextSum_0 = Simple.f2 (x_1, currentSum_2): a: 1 b: 0 s: 1 currentSum: 1 x: 2 nextSum: 3 nextSum_0 = Simple.f2 (x_1, currentSum_2): a: 2 b: 1 s: 3 currentSum: 3 x: 3 nextSum: 6 nextSum_0 = Simple.f2 (x_1, currentSum_2): a: 3 b: 3 s: 6 Logs are nested and after label "nextSum_0 = Simple.f2 (x_1, currentSum_2):" we see logs from f2_S function. The code is in QUITE EXPERIMENTAL stage, but feel free to play and comment.

1 0

A long day with HXT
by nadine.and.henry＠pobox.com 09 May '11

09 May '11

Dear Group, I have just spent many hours staring at code and losing some hair. My hope is to save you the same experience someday. Here was my goal: Take some XML, like <photo url="somewhere" align="left" alt=""/> and replace the align attribute with a class attribute, but only if the value of the align attribute was not null. This led to to followed (hugely condensed) attempts: ------------------------------------------------------------------------ > {-# LANGUAGE Arrows #-} > import Text.XML.HXT.Core > > -- <photo url="somewhere" align="left" alt=""/> > testString = "<photo url=\"somewhere\" align=\"left\" alt=\"\"/>" > toClass :: b -> QName > toClass = const (mkName "class") > > > try f = runLA (xread >>> processTopDown f) testString > > test1 = try $ > hasAttrValue "align" (not.null) >>> > processAttrl (changeAttrName toClass `when` hasName "align" ) > test2 = try $ processAttrl > (changeAttrName toClass `when` hasAttrValue "align" (not.null)) > test3 = try $ processAttrl > (changeAttrName toClass `when` hasName "align") > `when` hasAttrValue "align" (not.null) > > run = do > print test1 > print test2 > print test3 > result of run: [NTree (XTag "photo" [NTree (XAttr "url") [NTree (XText "somewhere") []],NTree (XAttr "class") [NTree (XText "left") []],NTree (XAttr "alt") []]) []] [NTree (XTag "photo" [NTree (XAttr "url") [NTree (XText "somewhere") []],NTree (XAttr "align") [NTree (XText "left") []],NTree (XAttr "alt") []]) []] [NTree (XTag "photo" [NTree (XAttr "url") [NTree (XText "somewhere") []],NTree (XAttr "class") [NTree (XText "left") []],NTree (XAttr "alt") []]) []] test1 and test3 performed as desired, needless to say I started out with something similar to test2 and was almost crying because the align attribute didn't change. Why? In test1, I run through the tree and select the elements which have a non-null align attribute. (hasAttrValue "align" (not.null)) Then for each of these elements I process their attributes. (processAttrl) where I change the attribute name to "class" (changeAttrName toClass) WHEN the attribute name is "align" (`when` hasName "align") Result: Joy In test2, I run through the tree and process every attribute list (processAttrl) I change the name of the attribute to "class" (changeAttrName toClass) WHEN the align attribute is not null (`when` hasAttrValue "align" (not.null))) Result: Nothing changes, - No Joy In test3, I run through the tree process every attribute list (processAttrl) WHEN the align attribute is not null (`when` hasAttrValue "align" (not.null)) and in that case I change the attribute name to "class" (changeAttrName toClass) WHEN the attribute is named "align" (`when` hasName "align") Result: Joy After staring at test2 for more time that I would like to acknowledge, I (think) I realized the following. In test2 I thought the (hasAttrValue "align" (not.null)) was referring to the tree that was coming into the test, but actually it is referring to the list of attributes that is generated by processAttrl. This list of attributes does not itself have any attributes, thus the (hasAttrValue "align" (not.null)) code never succeeds, and thus the (changeAttrName toClass) is never executed. Lessons learned: I'm not really sure, but it is these kind of subtleties that make me sometimes long for my old friend Perl. Best wishes, Henry Laxen -- Nadine & Henry Laxen Belle, Venus, Aphrodite 10580 N. McCarran Blvd. Adonis, Miss Parker & Jarod Suite 115-396 Via Alta # 6 Reno, Nevada Chapala, Jalisco, Mexico 89503-1896 CP 45900 The rest is silence. (Hamlet)

2 1

Re: [Haskell-cafe] [Haskell] ANN: syntactic-0.1
by Emil Axelsson 09 May '11

09 May '11

2011-05-07 09:52, Heinrich Apfelmus skrev: > Emil Axelsson wrote: >> I'm happy to announce the first release of syntactic: >> >> http://hackage.haskell.org/package/syntactic >> >> providing generic abstract syntax and utilities for embedded >> languages. >> >> To get an idea of what it's about, check out the tiny(!) >> implementation of (simplified) Feldspar in the Examples directory: >> >> http://projects.haskell.org/syntactic/Examples/MuFeldspar >> >> The library is intended to provide a growing set of utilities for >> embedded languages. In particular, I hope to be able to provide safe >> interfaces to various unsafe techniques for speeding things up. >> >> Comments, patches and clients are welcome! > > Looks very interesting! > > I'm currently working on a functional reactive programming DSL. Source code: > > http://tinyurl.com/reactive-banana-0-2-pushio > > The EventD type represents the abstract syntax tree (line 150), which > is then compiled in three phases (line 313) > > compile e ~= map compilePath =<< compileUnion =<< compileAccumB e > > If you look at the EventD type, you can see it contains a lot of > "internal constructors" (line 158) that are created in destroyed in > certain compilation phases. Ideally, I would make a new EventD type > for each compilation phase that doesn't have any superfluous > constructors. For instance, compileUnion removes the Union constructor. Hello Heinrich! Thanks for your interest! In principle, this is exactly the kind of thing you can do with syntactic -- if you can make your data type fit into the framework, that is. A compilation phase would then look something like this: phase :: AST (C1 :+: TheRest) -> AST (C2 :+: C3 :+: TheRest) This phase destroys the constructor C1 and introduces C2 and C3. Now, the question is whether your data type can be made to fit into the framework. The only problem I can see (but there may be more!) is that you'd have to treat EventD and BehaviorD as parts of the same data structure. I've pasted an example of how to do that here: http://hpaste.org/46525/ Here, the difference between Event and Behavior is denoted by the type constructors E and B respectively: type Event a = ASTF (Never :+: B2E :+: Pure :+: E2B) (E a) type Behavior a = ASTF (Never :+: B2E :+: Pure :+: E2B) (B a) You decide if this seems like an acceptable solution... > I'm also unhappy about some of the boilerplate. For instance, have a > look at the function goE in compileAccumB (line 210), it's just a > generic applicative traversal through the data type. Most likely, this boilerplate could be simplified using syntactic. > Would your library make me happier? Note that I have an additional > complication: I need to observe sharing and I need to support recursive AST. I plan to add observable sharing soon. Once that's is in place, it should -- I think/hope -- be easy to support cycles. This is not something we need in Feldspar, so it might take a while before I get around to supporting cycles, though. I'd be happy to give more assistance should you choose to try out syntactic for your library! Best regards / Emil

1 0

Apache license, any drawbacks for Haskell packages?
by Magnus Therning 09 May '11

09 May '11

Are there any drawbacks to using the Apache license for Haskell packages? /M -- Magnus Therning OpenPGP: 0xAB4DFBA4 email: magnus(a)therning.org jabber: magnus(a)therning.org twitter: magthe http://therning.org/magnus I invented the term Object-Oriented, and I can tell you I did not have C++ in mind. -- Alan Kay

4 4

repa Shape help
by briand＠aracnet.com 09 May '11

09 May '11

Howdy, as usual, the haskell type system complete defeats me in the simplest of applications: import Data.Array.Repa as A import Data.Array.Repa.Index import Data.Array.Repa.Shape as AS main = do let x = A.fromList (AS.shapeOfList [2, 2]) ([1.0, 2.0, 3.0, 4.0]::[Double]) putStrLn $ show x test_repa.hs:10:13: Ambiguous type variable `sh' in the constraint: `Shape sh' arising from a use of `show' at test_repa.hs:10:13-18 Probable fix: add a type signature that fixes these type variable(s) Failed, modules loaded: none. After much staring at the type signatures I finally figured out that adding a type annotation to x of : :: Array DIM2 Double would fix the problem, but I'm not completely clear as to why. after all fromList is typed: (Shape sh, Elt a) => sh -> [a] -> Array sh a Since it knows [a] is [Double] and sh must be - well I'm not really clear on what sh is supposed to be. therein lies my problem. Although it does seem that sh can be darn near anything, which is probably why it was ambiguous. At one point I had tried something like (2 :. 2) and got a whole host of errors for that too, except that DIM2 is defined in exactly that way, so it's not at all obvious why that didn't work. I was hoping someone could clarify on what's going on. Thanks, Brian

2 1

trying to cabal install lambdabot, failure on 'random' package
by Sean Perry 09 May '11

09 May '11

/usr/bin/ghc --make -package-name show-0.4.1.1 -hide-all-packages -fbuilding-cabal-package -i -idist/build -i. -idist/build/autogen -Idist/build/autogen -Idist/build -optP-include -optPdist/build/autogen/cabal_macros.h -odir dist/build -hidir dist/build -stubdir dist/build -package-id QuickCheck-2.4.0.1-5898cfb0116fc1d6ecef04b3f053c323 -package-id base-4.3.1.0-167743fc0dd86f7f2a24843a933b9dce -package-id random-1.0.0.3-749b78c54a8a99991b32dbb45d98a91b -package-id smallcheck-0.4-008eb21a2943dfdde26401dbc145c45b -package-id syb-0.3-8db7bc4339a1cb8a6f2a46c40447ef0b -O -Wall -XHaskell98 ShowQ ShowFun SimpleReflect <command line>: cannot satisfy -package-id random-1.0.0.3-749b78c54a8a99991b32dbb45d98a91b: random-1.0.0.3-749b78c54a8a99991b32dbb45d98a91b is shadowed by package random-1.0.0.3-57524486875e0c4c260dd22788921013 (use -v for more information) World file is already up to date. cabal: Error: some packages failed to install: lambdabot-4.2.3.2 depends on show-0.4.1.1 which failed to install. lambdabot-utils-4.2.1 failed during the building phase. The exception was: ExitFailure 1 readline-1.0.1.0 failed during the configure step. The exception was: ExitFailure 1 show-0.4.1.1 failed during the building phase. The exception was: ExitFailure 1 I have ghc 7.0.,3 and cabal $ cabal --version cabal-install version 0.10.2 using version 1.10.1.0 of the Cabal library From the recent Haskell Platform for OS X. Ideas?

4 6

Re: [Haskell-cafe] For Project Euler #24 you don't need to generate all the lexicographic permutations <Spoiler>
by KC 09 May '11

09 May '11

I see from the solutions on Project Euler others did think of this way but at least on my last IQ test I did get an 'A'; 95. I am a jenius. :D -- -- Regards, KC

1 0

For Project Euler #24 you don't need to generate all the lexicographic permutations <Spoiler>
by caseyh＠istar.ca 08 May '11

08 May '11

For Project Euler #24 you don't need to generate all the lexicographic permutations by Knuth's method or any other. You're only looking for the millionth lexicographic permutation of "0123456789" Problem 24 A permutation is an ordered arrangement of objects. For example, 3124 is one possible permutation of the digits 1, 2, 3 and 4. If all of the permutations are listed numerically or alphabetically, we call it lexicographic order. The lexicographic permutations of 0, 1 and 2 are: 012 021 102 120 201 210 What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9? <Spoiler> <Spoiler> <Spoiler> Plan of attack: -- The "x"s are different numbers -- 0xxxxxxxxx represents 9! = 362880 permutations/numbers -- 1xxxxxxxxx represents 9! = 362880 permutations/numbers -- 2xxxxxxxxx represents 9! = 362880 permutations/numbers -- 20xxxxxxxx represents 8! = 40320 -- 21xxxxxxxx represents 8! = 40320 -- 23xxxxxxxx represents 8! = 40320 -- 24xxxxxxxx represents 8! = 40320 -- 25xxxxxxxx represents 8! = 40320 -- 26xxxxxxxx represents 8! = 40320 -- 27xxxxxxxx represents 8! = 40320 etc. <Spoiler> <Spoiler> -- lexOrder "0123456789" 1000000 "" lexOrder digits left s | len == 0 = s ++ digits | quot > 0 && rem == 0 = lexOrder (digits\\(show (digits!!(quot-1)))) rem (s ++ [(digits!!(quot-1))]) | quot == 0 && rem == 0 = lexOrder (digits\\(show (digits!!len))) rem (s ++ [(digits!!len)]) | rem == 0 = lexOrder (digits\\(show (digits!!(quot+1)))) rem (s ++ [(digits!!(quot+1))]) | otherwise = lexOrder (digits\\(show (digits!!(quot)))) rem (s ++ [(digits!!(quot))]) where len = (length digits) - 1 facLen = factorial len (quot,rem) = quotRem left facLen

2 1

no time profiling on my MacBookPro8,1
by Nicolas Frisby 08 May '11

08 May '11

For this vanilla program > module Main where > > main = print $ fib 40 > > fib 0 = 1 > fib 1 = 1 > fib n = fib (n - 1) + fib (n - 2) with these commands $ ghc -prof -auto-all -rtsopts -O --make Main.hs -o Main $ ./Main +RTS -p all of the %time cells in the generated Main.prof file are 0.0, as is the total time count (0.00 secs and 0 ticks). The %alloc cells seem normal. Andy Gill noticed that if you compile with -threaded, the %time cells seem normal. I scanned the GHC Trac tickets specific to Mac OS X, but saw no titles that looked similar. Is this a known issue? Thanks.

2 2

For Project Euler #1 isn't it more efficient to generate just the numbers you need? <Spoiler>
by caseyh＠istar.ca 07 May '11

07 May '11

-- Instead of this -- sumMultiples3or5 s = sum [x | x <- [3..s-1], x `mod` 3 == 0 || x `mod` 5 == 0] -- Isn't this faster sumMultiples3or5 s = sum ([x | x <- [3,6..s-1]] `merge` [x | x <- [5,10..s-1]]) merge xs [] = xs merge [] ys = ys merge txs@(x:xs) tys@(y:ys) | x < y = x : xs `merge` tys | x > y = y : txs `merge` ys | otherwise = x : xs `merge` ys

4 4

Server hosting
by Andrew Coppin 07 May '11

07 May '11

OK, so strictly this is unrelated to Haskell as such. However, there's enough people doing webby stuff with Haskell that some of you must have wanted to run your code on a real, Internet-accessible web server. So does anybody have any suggestions on which companies offer the most favourable tools / pricing? I currently have a website, but it supports only CGI *scripts* (i.e., Perl or PHP). It does not support arbitrary CGI *binaries*, which is what I'd want for Haskell. In fact, I don't have control over the web server at all; I just put content on there. The same provider can offer me a virtual server, but at 3x the price I'm currently paying. I simply cannot afford that kind of money just for silly toy projects. What does everybody else use?

14 18