May 2011 - Haskell-Cafe

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 13 May '11

13 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