- Haskell-Cafe - Haskell.org

Make a DSL serializable
by Corentin Dupont 26 Mar '13

26 Mar '13

Hi Café, I have a DSL like this: data Exp where OnEvent :: EventName -> (Int -> Exp) -> Exp (...) The "OnEvent" element carries a function (the handler to be called when the event happens), and that makes my DSL non showable/serializable. How could I fix that? This is a real handicap not to be able to serialize the state of my whole application because of that :) Thanks, Corentin

6 18

typed final-tagless HOAS interpreter for linear lambda calculus
by jeff p 26 Mar '13

26 Mar '13

{- This message presents a typed final-tagless HOAS interpreter for linear lambda calculus (LLC), which makes use of type families and datatype promotion. This code is inspired by Oleg's LLC interpreter using deBruijn indices (http://okmij.org/ftp/tagless-final/course/LinearLC.hs) The basic technique used here, and in Oleg's representation, comes from work on linear logic programming (see http://www.cs.cmu.edu/~fp/papers/erm97.pdf for details). An explicit presentation of LLC using these ideas can be found here http://www.cs.cmu.edu/~fp/courses/15816-f01/handouts/linfp.pdf [0]. While only the two arrow types and ints are included in this message; it is straightforward to extend this interpreter to cover all types of LLC. Attached to this message is an interpreter for full LLC (including additives and units) which is a direct transcription of the typing rules previously mentioned in [0]. The code for full LLC is written using MPTC and functional dependencies, instead of type families, but it is easily translatable to type families. -} {-# LANGUAGE DataKinds, KindSignatures, RankNTypes, TypeFamilies, TypeOperators, UndecidableInstances #-} {- The basic idea is to label each linear variable with a number and keep track of the linear context in the type of the representation. Thus our representation type looks like: repr :: Nat -> [Maybe Nat] -> [Maybe Nat] -> * -> * repr vid hi ho a where vid is the next variable label to use, hi is the input linear hypotheses, ho is the output linear hypotheses, and a is the type of the term. -} -- Type-level Nat -- data Nat = Z | S Nat -- Type-level equality for Nat -- type family EqNat (x::Nat) (y::Nat) :: Bool type instance EqNat Z Z = True type instance EqNat (S x) (S y) = EqNat x y type instance EqNat Z (S y) = False type instance EqNat (S x) Z = False {- The key to enforcing linearity, is to have the type system consume (mark as used) linear variables as they are used. We use promoted [Maybe Nat] to represent a linear context. -} -- Type-level function to consume a given resource (a Maybe Nat) form a list. -- type family Consume (vid::Nat) (i::[Maybe Nat]) :: [Maybe Nat] type family Consume1 (b::Bool) (vid::Nat) (v::Nat) (vs::[Maybe Nat]) :: [Maybe Nat] type instance Consume vid (Nothing ': vs) = (Nothing ': Consume vid vs) type instance Consume vid (Just v ': vs) = Consume1 (EqNat vid v) vid v vs type instance Consume1 True vid v vs = Nothing ': vs type instance Consume1 False vid v vs = Just v ': Consume vid vs {- HOAS boils down to having the obect langauge (LLC) directly use the meta language (Haskell) variable and substitution machinery. So a typical HOAS representation of an object level function looks something like: lam :: (repr a -> repr b) -> repr (a -> b) The key to making HOAS work with our representation, is to have our object level variables make use of the Consume function above. Toward this end, we can create a general linear variable type. -} type VarTp (repr :: Nat -> [Maybe Nat] -> [Maybe Nat] -> * -> *) vid a = forall v i o . repr v i (Consume vid i) a {- We can now write the representation of the LLC terms. Note that the type of each LLC term constructor (each member of class Lin) is a transcription of a typing rule for LLC. -} -- a type to distinguish linear functions from regular functions -- newtype a -<> b = Lolli {unLolli :: a -> b} -- the "Symantics" of LLC -- class Lin (repr :: Nat -> [Maybe Nat] -> [Maybe Nat] -> * -> *) where -- a base type int :: Int -> repr vid hi hi Int add :: repr vid hi h Int -> repr vid h ho Int -> repr vid hi ho Int -- linear lambda llam :: (VarTp repr vid a -> repr (S vid) (Just vid ': hi) (Nothing ': ho) b) -> repr vid hi ho (a -<> b) (<^>) :: repr vid hi h (a -<> b) -> repr vid h ho a -> repr vid hi ho b -- non-linear lambda lam :: ((forall v h . repr v h h a) -> repr vid hi ho b) -> repr vid hi ho (a -> b) (<$>) :: repr vid hi ho (a -> b) -> repr vid ho ho a -> repr vid hi ho b {- An evaluator which takes a LLC term of type a to a Haskell value of type a. -} newtype R (vid::Nat) (i::[Maybe Nat]) (o::[Maybe Nat]) a = R {unR :: a} instance Lin R where int = R add x y = R $ unR x + unR y llam f = R $ Lolli $ \x -> unR (f (R x)) f <^> x = R $ unLolli (unR f) (unR x) lam f = R $ \x -> unR (f (R x)) f <$> x = R $ unR f (unR x) eval :: R Z '[] '[] a -> a eval = unR {- Some examples: *Main> :t eval $ llam $ \x -> x eval $ llam $ \x -> x :: b -<> b *Main> :t eval $ llam $ \x -> add x (int 1) eval $ llam $ \x -> add x (int 1) :: Int -<> Int *Main> eval $ (llam $ \x -> add x (int 1)) <^> int 2 3 A non-linear uses of linear variables fail to type check: *Main> :t eval $ llam $ \x -> add x x <interactive>:1:27: Couldn't match type `Consume 'Z ('[] (Maybe Nat))' with '[] (Maybe Nat) Expected type: R ('S 'Z) ((':) (Maybe Nat) ('Nothing Nat) ('[] (Maybe Nat))) ((':) (Maybe Nat) ('Nothing Nat) ('[] (Maybe Nat))) Int Actual type: R ('S 'Z) ((':) (Maybe Nat) ('Nothing Nat) ('[] (Maybe Nat))) (Consume 'Z ((':) (Maybe Nat) ('Nothing Nat) ('[] (Maybe Nat)))) Int In the second argument of `add', namely `x' In the expression: add x x In the second argument of `($)', namely `\ x -> add x x' *Main> :t eval $ llam $ \x -> llam $ \y -> add x (int 1) <interactive>:1:38: Couldn't match type 'Just Nat ('S 'Z) with 'Nothing Nat Expected type: R ('S ('S 'Z)) ((':) (Maybe Nat) ('Just Nat ('S 'Z)) ((':) (Maybe Nat) ('Just Nat 'Z) ('[] (Maybe Nat)))) ((':) (Maybe Nat) ('Nothing Nat) ((':) (Maybe Nat) ('Nothing Nat) ('[] (Maybe Nat)))) Int Actual type: R ('S ('S 'Z)) ((':) (Maybe Nat) ('Just Nat ('S 'Z)) ((':) (Maybe Nat) ('Just Nat 'Z) ('[] (Maybe Nat)))) (Consume 'Z ((':) (Maybe Nat) ('Just Nat ('S 'Z)) ((':) (Maybe Nat) ('Just Nat 'Z) ('[] (Maybe Nat))))) Int In the first argument of `add', namely `x' In the expression: add x (int 1) In the second argument of `($)', namely `\ y -> add x (int 1)' But non-linear uses of regular variables are fine: *Main> :t eval $ lam $ \x -> add x x eval $ lam $ \x -> add x x :: Int -> Int *Main> eval $ (lam $ \x -> add x x) <$> int 1 2 *Main> :t eval $ lam $ \x -> lam $ \y -> add x (int 1) eval $ lam $ \x -> lam $ \y -> add x (int 1) :: Int -> a -> Int *Main> eval $ (lam $ \x -> lam $ \y -> add x (int 1)) <$> int 1 <$> int 2 2 -} {- We can also easily have an evaluator which produces a String. -} -- For convenience, we name linear variables x0, x1, ... and regular variables y0, y1, ... -- newtype Str (vid::Nat) (gi::[Maybe Nat]) (go::[Maybe Nat]) a = Str {unStr :: Int -> Int -> String} instance Lin Str where int x = Str $ \_ _ -> show x add x y = Str $ \uv lv -> "(" ++ unStr x uv lv ++ " + " ++ unStr y uv lv ++ ")" llam f = Str $ \uv lv -> let v = "x"++show lv in "\\" ++ v ++ " -<> " ++ unStr (f $ Str (\_ _ -> v)) uv (lv + 1) f <^> x = Str $ \uv lv -> "(" ++ unStr f uv lv ++ " ^ " ++ unStr x uv lv ++ ")" lam f = Str $ \uv lv -> let v = "y"++show uv in "\\" ++ v ++ " -> " ++ unStr (f $ Str (\_ _ -> v)) (uv + 1) lv f <$> x = Str $ \uv lv -> "(" ++ unStr f uv lv ++ " " ++ unStr x uv lv ++ ")" showLin :: Str Z '[] '[] a -> String showLin x = unStr x 0 0 {- An example: *Main> showLin $ (llam $ \x -> llam $ \y -> add x y) <^> int 1 "(\\x0 -<> \\x1 -<> (x0 + x1) ^ 1)" -}

1 0

Enumerating functions at runtime
by Luke Evans 26 Mar '13

26 Mar '13

I'm curious about using Haskell for metaprogramming. It looks like I can dynamically compile, load and run some Haskell with the plugins package. Actually I've briefly tried this and it seems to work for some simple cases at least. Now I would like to be able to enumerate precompiled public functions in modules that I might use as building blocks in such dynamic compilation. So far I'm not seeing anything that does this directly. Can anyone provide some pointers? If it's just not possible to introspect on compiled modules, then I suppose I could use external metadata of my own, or even perhaps haddock info if it exists, to attempt to generate this info. Clearly though, that's nowhere near as good as extracting the info from something the compiler built directly.

5 4

A Thought: Backus, FP, and Brute Force Learning
by OWP 25 Mar '13

25 Mar '13

This thought isn't really related to Haskell specifically but it's more towards FP ideal in general. I'm new to the FP world and to get me started, I began reading a few papers. One paper is by John Backus called "Can Programming Be Liberated from the von Neumann Style? A Functional Style and It's Algebra of Programs". While I like the premise which notes the limitation of the von Neumann Architecture, his solution to this problem makes me feel queasy when I read it. For me personally, one thing I enjoy about a typical procedural program is that it allows me to "Brute Force Learn". This means I stare at a particular section of the code for a while until I figure out what it does. I may not know the reasoning behind it but I can have a pretty decent idea of what it does. If I'm lucky, later on someone may tell me "oh, that just did a gradient of such and such matrix". In a way, I feel happy I learned something highly complex without knowing I learned something highly complex. Backus seems to throw that out the window. He introduces major new terms which require me to break out the math book which then requires me to break out a few other books to figure out which bases things using archaic symbols which then requires me to break out the pen and paper to mentally expand what in the world that does. It makes me feel CISCish except without a definition book nearby. It's nice if I already knew what a "gradient of such and such matrix" is but what happens if I don't? For the most part, I like the idea that I have the option of Brute Force Learning my way towards something. I also like the declarative aspect of languages such as SQL which let's me asks the computer of things once I know the meaning of what I'm asking. I like the ability to play and learn but I also like the ability to declare this or that once I do learn. From Backus paper, if his world comes to a reality, it seems like I should know what I'm doing before I even start. The ability to learn while coding seems to have disappeared. In a way, if the von Neumann bottleneck wasn't there, I'm not sure programming would be as popular as it is today. Unfortunately, I'm still very new and quite ignorant about Haskell so I do not know how much of Backus is incorporated in Haskell but so far, in the start of my FP learning adventure, this is how things seem to be seen. If I may generously ask, where am I wrong and where am I right with this thought? Thank you for any explanation P.S. If anyone knows of a better place I can ask this question, please feel free to show me the way.

5 8

Pattern matching with singletons
by Paul Brauner 25 Mar '13

25 Mar '13

Hello, the following programs seems to hit either some limitation of GHC or maybe I'm just missing something and it behaves the intended way. {-# LANGUAGE TemplateHaskell, TypeFamilies, DataKinds, GADTs #-} module Test where import Data.Singletons data TA = CA data TB = CB data TC = CC (Either TA TB) $(genSingletons [''TA, ''TB, ''TC]) type family Output (x :: TC) :: * type instance Output ('CC ('Left 'CA)) = Int type instance Output ('CC ('Right 'CB)) = String f :: Sing (a :: TC) -> Output a f (SCC (SLeft SCA)) = 1 g :: Sing (a :: TC) -> Output a g (SCC (SLeft _)) = 1 Function f typechecks as expected. Function g fails to typecheck with the following error. Could not deduce (Num (Output ('CC ('Left TA TB n0)))) arising from the literal `1' from the context (a ~ 'CC n, SingRep (Either TA TB) n) bound by a pattern with constructor SCC :: forall (a_a37R :: TC) (n_a37S :: Either TA TB). (a_a37R ~ 'CC n_a37S, SingRep (Either TA TB) n_a37S) => Sing (Either TA TB) n_a37S -> Sing TC a_a37R, in an equation for `g' at Test.hs:21:4-16 or from (n ~ 'Left TA TB n0, SingRep TA n0, SingKind TA ('KindParam TA)) bound by a pattern with constructor SLeft :: forall (a0 :: BOX) (b0 :: BOX) (a1 :: Either a0 b0) (n0 :: a0). (a1 ~ 'Left a0 b0 n0, SingRep a0 n0, SingKind a0 ('KindParam a0)) => Sing a0 n0 -> Sing (Either a0 b0) a1, in an equation for `g' at Test.hs:21:9-15 Possible fix: add an instance declaration for (Num (Output ('CC ('Left TA TB n0)))) In the expression: 1 In an equation for `g': g (SCC (SLeft _)) = 1 I would expect that a ~ ('CC ('Left 'CA)) in the right hand-side of g (SCC (SLeft _)) = 1 since SLeft's argument is necessarily of type STA, whose sole inhabitant is SA. Now I understand (looking at -ddump-slices, the singletons' library paper and the error message) that the definition of SCC and SLeft don't immediately imply what I just wrote above. So my question is: in the right hand-side of g (SCC (SLeft _)) = 1, - is a ~ ('CC ('Left 'CA)) a consequence of the definitions of SCC, SLeft, ... (in which case GHC could infer it but for some reason can't) - or are these pattern + definitions not sufficient to prove that a ~ ('CC ('Left 'CA)) no matter what? Cheers, Paul

1 0

Munich Haskell Meeting
by Heinrich Hördegen 25 Mar '13

25 Mar '13

Dear all, tomorrow, 25th of March, will be our monthly Haskell Meeting in Munich. If you want to join, please go to http://www.haskell-munich.de/dates and click the button. Sorry for the late announcement! I wish everyone of you a nice and successful week, Heinrich

1 1

Parsec community and up-to-date documentation
by Konstantine Rybnikov 25 Mar '13

25 Mar '13

Hi! I've been busy with (trying to) learning/using parsec lately and as a beginner had a lot of headache starting from outdated documentation in various places, lack of more tutorials, confusion between Text.Parsec and Text.ParseCombinator modules and so on. While I solved most of my problems via googling / reading stackoverflow / reading source code (of outdated version first, btw, the one I got from Daan's homepage :), I still had a feeling all the time that I'm doing something wrong and that I can't find place where "party is going on". So I wondered, what can I do to create a community around Parsec, to get issue tracking, pull-requests, up-to-date comprehensive documentation and tutorials etc.? Parsec seems like a perfect candidate for something like this. Thank you.

3 5

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 115, Issue 37
by Luc TAESCH 25 Mar '13

25 Mar '13

Le dimanche 24 mars 2013, a écrit : > Send Haskell-Cafe mailing list submissions to > haskell-cafe(a)haskell.org <javascript:;> > > To subscribe or unsubscribe via the World Wide Web, visit > http://www.haskell.org/mailman/listinfo/haskell-cafe > or, via email, send a message with subject or body 'help' to > haskell-cafe-request(a)haskell.org <javascript:;> > > You can reach the person managing the list at > haskell-cafe-owner(a)haskell.org <javascript:;> > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Haskell-Cafe digest..." >

1 0

Data.StorableVector vs Data.Vector.Storable
by Roman Cheplyaka 24 Mar '13

24 Mar '13

What is the relationship between these two modules? Do we really need both? (Data.Vector.Storable is part of vector, Data.StorableVector is from a separate package, storablevector.) Roman

2 1

Need some advice around lazy IO
by C K Kashyap 24 Mar '13

24 Mar '13

Hi, I am working on an automation that periodically fetches bug data from our bug tracking system and creates static HTML reports. Things worked fine when the bugs were in the order of 200 or so. Now I am trying to run it against 3000 bugs and suddenly I see things like - too many open handles, out of memory etc ... Here's the code snippet - http://hpaste.org/84197 It's a small snippet and I've put in the comments stating how I run into "out of file handles" or simply file not getting read due to lazy IO. I realize that putting ($!) using a trial/error approach is going to be futile. I'd appreciate some pointers into the tools I could use to get some idea of which expressions are building up huge thunks. Regards, Kashyap

9 17

hsc2hs fails?
by Henk-Jan van Tuyl 24 Mar '13

24 Mar '13

L.S., I am trying to install SDL-ttf: SDL-ttf-0.6.2>cabal install : : Preprocessing library SDL-ttf-0.6.2... dist\build\Graphics\UI\SDL\TTF\Version.hs:1:1: File name does not match module name: Saw: `Main' Expected: `Graphics.UI.SDL.TTF.Version' Failed to install SDL-ttf-0.6.2 : The error message is caused by the fact that Version.hs is empty; there is however a file dist\build\Graphics\UI\SDL\TTF\stdout.txt that contains the contents of Version.hs; there is also a file dist\build\Graphics\UI\SDL\TTF\Types.hs that is empty. These files are generated from Version.hsc and Types.hsc, in directory Graphics\UI\SDL\TTF How can this occur? Any way to debug this? Regards, Henk-Jan van Tuyl -- http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

1 0

Announcement - HGamer3D - 0.2.1 - featuring FRP based GUI and more
by Peter Althainz 24 Mar '13

24 Mar '13

Dear All, I'm happy to announce release 0.2.1 of HGamer3D, the game engine with Haskell API, featuring FRP based API and FRP based GUI. The new FRP API is based on the netwire package. Currently only available on Windows: http://www.hgamer3d.org. Peter

5 6

A question about data declaration
by C K Kashyap 23 Mar '13

23 Mar '13

Hi, I have a situation where I need to define a data type T such that data T = C1 Int | C2 Char | C3 T However, I want to enforce a constraint that C3 only allows (C2 Char) and not (C1 Int). That is x = C3 (C1 10) -- should not compile - but my above definition will let it compile I was thinking of this - data C1 = C1 Int data C2 = C2 Char data T = TC1 C1 | TC1 C2 | TC3 C2 Is there a better way to do it? Regards, Kashyap

5 5

ANN: pdf-toolbox
by Yuras Shumovich 23 Mar '13

23 Mar '13

Hello, I have uploaded the first release of my pdf toolbox, a collection of tools for processing PDF files. It supports both parsing and generating of pdf files. It consists of two libraries: - core ( http://hackage.haskell.org/package/pdf-toolbox-core ) contains low level tools. - document ( http://hackage.haskell.org/package/pdf-toolbox-document ) contains pretty limited set of middle level tools. (Also there is the 3d library, pdf-toolbox-content. It contains tools for processing pdf page content, e.g. text extraction. It is not released yet, but you can find it on github.) The initial plan was to create higher level tools before releasing on hackage, but I found it hard to design good high level API without wide rage on use cases. So I decided to release it earlier in order to receive feedback. You can find few examples here: https://github.com/Yuras/pdf-toolbox/tree/master/examples Thanks, Yuras

1 0

Ticking time bomb
by Edward Z. Yang 23 Mar '13

23 Mar '13

https://status.heroku.com/incidents/489 Unsigned Hackage packages are a ticking time bomb. Cheers, Edward

19 44

Compiled code
by MigMit 23 Mar '13

23 Mar '13

Suppose I compiled some module and kept it's .hi and .o files. Is it possible to use this module in my program if the source code was deleted for some reason? Seems like the answer is "yes" — by creating a fake .hs file (with no real content) and touch-in .hi and .o files I tricked ghc so that it didn't attempt to recompile the module, so the information in .hi and .o files is sufficient. But ghc insists on having the .hs file around, and I didn't find a way to turn it off. Is there any? Or there is a specific reason not to allow this?

3 4

question about PutM patterns
by Alexander V Vershilov 23 Mar '13

23 Mar '13

Hello, cafe. I have a big problem using builders, so currently I'm using own builder based on Nettle one [1]. It uses Strict bytestring to build into and unchecked writes, thus it's very unsafe, plus other builders/PutM, developed rapidly so I like to switch to another one. However I use some patterns that seems not implemented in other builders, so I'd like to hear advices how to implement it there or how I can write code without using them. All of the patterns is done in order to have more performance and gives a way to build complex data without additional allocations. 1). Delayed input: This unsafe pattern can be implemented in any PutM monad for any constant sized value, the idea is that we write a plaseholder and returns a funtion that will write correct value to the address when applied. This pattern is needed when we need to update length or CRC sum after content is written: > test1 put = delayedWord16be >>= \ph -> someOtherStuff >> undelay ph calculateCRC 2). LookAhead: Sometimes I need to know the length of the content to be written, possibly I can write content to ByteString, and calculate length and write it, however if resulting type is not LBS it leads to additional allocations and memory move. For PutM a special wrapper can be written withLength :: a {- length type -} -> PutM () -> PutM (). Or special data structure and delayed input can be used, special data structure is Marker, it marks a place in datastructure allowing to calculate distances, it works very efficiently with ByteString, but I have no idea how to implement it with LBS: > test1 put = delayedWord32be >>= \ph -> marker -> \m -> put >> distance m >>= undelay . fromIntegral 3). LookBehind Returning back to crc calculation I had to use additional pattern, it's a lookback: I need to inspect unfinished data, that I've already have written, I have not done correct wrappers so I've used markers and fromForeignPtr from ByteString.Internal: > test3 = do > m <- marker > somestuff > d <- distance marker > let crc = (unsafePerformIO $ BS.unsafePackAddressLen hlen' (toAddr m)) -- Alexander

1 0

Tutorials at Commercial Users of Functional Programming 2013
by Simon Thompson 22 Mar '13

22 Mar '13

There's still time to submit a tutorial proposal for Commercial Users of Functional Programming in Boston … http://cufp.org/cufp2013-call-tutorials Simon Thompson | Professor of Logic and Computation School of Computing | University of Kent | Canterbury, CT2 7NF, UK s.j.thompson(a)kent.ac.uk | M +44 7986 085754 | W www.cs.kent.ac.uk/~sjt

1 0

To seq or not to seq, that is the question
by Edward Z. Yang 22 Mar '13

22 Mar '13

Are these equivalent? If not, under what circumstances are they not equivalent? When should you use each? evaluate a >> return b a `seq` return b return (a `seq` b) Furthermore, consider: - Does the answer change when a = b? In such a case, is 'return $! b' permissible? - What about when b = () (e.g. unit)? - What about when 'return b' is some arbitrary monadic value? - Does the underlying monad (e.g. if it is IO) make a difference? - What if you use pseq instead of seq? In http://hackage.haskell.org/trac/ghc/ticket/5129 we a bug in 'evaluate' deriving precisely from this confusion. Unfortunately, the insights from this conversation were never distilled into a widely publicized set of guidelines... largely because we never really figured out was going on! The purpose of this thread is to figure out what is really going on here, and develop a concrete set of guidelines which we can disseminate widely. Here is one strawman answer (which is too complicated to use in practice): - Use 'evaluate' when you mean to say, "Evaluate this thunk to HNF before doing any other IO actions, please." Use it as much as possible in IO. - Use 'return (a `seq` b)' for strictness concerns that have no relation to the monad. It avoids unnecessary strictness when the value ends up never being used and is good hygiene if the space leak only occurs when 'b' is evaluated but not 'a'. - Use 'return $! a' when you mean to say, "Eventually evaluate this thunk to HNF, but if you have other thunks which you need to evaluate to HNF, it's OK to do those first." In particular, (return $! a) >> (return $! b) === a `seq` (return $! b) === a `seq` b `seq` return b === b `seq` a `seq` return b [1] This situation is similar for 'a `seq` return ()' and 'a `seq` m'. Avoid using this form in IO; empirically, you're far more likely to run into stupid interactions with the optimizer, and when later monadic values maybe bottoms, the optimizer will be justified in its choice. Prefer using this form when you don't care about ordering, or if you don't mind thunks not getting evaluated when bottoms show up. For non-IO monads, since everything is imprecise anyway, it doesn't matter. - Use 'pseq' only when 'par' is involved. Edward

3 4

Fwd: A Thought: Backus, FP, and Brute Force Learning
by Eli Frey 22 Mar '13

22 Mar '13

---------- Forwarded message ---------- From: Eli Frey <eli.lee.frey(a)gmail.com> Date: Wed, Mar 20, 2013 at 4:56 PM Subject: Re: [Haskell-cafe] A Thought: Backus, FP, and Brute Force Learning To: OWP <owpmailact(a)gmail.com> I have not read Bacchus' paper, so i might be off the mark here. Functional code is just as simple (if not more so) to puzzle apart and understand as imperative code. You might find that instead of "stepping through the process" of code, you end up "walking the call graph" more often. FPers tend to break their problem into ever smaller parts before re-assembling them back together, often building their own vocabulary as they go. Not to say this is not done in imperative languages, but it is not so heavily encouraged and embraced. One result of this is that you can easily understand a piece of code in isolation, without considering it's place in some "process". It sounds as though you are not yet comfortable with this yet. So yes, you might have to learn more vocabulary to understand a piece of functional code. This is not because the inner workings are obfuscated, but because there are so many more nodes in the call graph that are given names. You can still go and scrutinize each of those new pieces of vocabulary by themselves and understand them without asking for the author to come down from on high with his explanation. Let's take iteration for example. In some imperative languages, people spend an awful lot of time writing iteration in terms of language primitives. You see a for loop. "What is this for loop doing?" you say to yourself. So you step through the loop imagining how it behaves as it goes and you say "Oh, this guy is walking through the array until he finds an element that matches this predicate." In a functional style, you would reuse some iterating function and give it functions to use as it is iterating. The method of iteration is still there, it has just nested into the call graph and if you've never seen that function name before you've got to go look at it. Again I don't mean to suggest that this isn't happening in an imperative language, just not to the same degree. As well there is a bit of a learning curve in seeing what a function "does" when there is no state or "doing" to observe in it. Once you get used to it, I believe you will find it quite nice though. You have probably heard FPers extolling the virtues of "declarative" code. When there is no state or "process" to describe, you end up describing what a thing is. I for one think this greatly increases readability. Good Luck! Eli On Wed, Mar 20, 2013 at 3:59 PM, OWP <owpmailact(a)gmail.com> wrote: > I made an error. I meant FP to stand for Functional Programming, the > concept not the language. > > On Wed, Mar 20, 2013 at 6:54 PM, OWP <owpmailact(a)gmail.com> wrote: > >> This thought isn't really related to Haskell specifically but it's more >> towards FP ideal in general. >> >> I'm new to the FP world and to get me started, I began reading a few >> papers. One paper is by John Backus called "Can Programming Be Liberated >> from the von Neumann Style? A Functional Style and It's Algebra of >> Programs". >> >> While I like the premise which notes the limitation of the von Neumann >> Architecture, his solution to this problem makes me feel queasy when I read >> it. >> >> For me personally, one thing I enjoy about a typical procedural program >> is that it allows me to "Brute Force Learn". This means I stare at a >> particular section of the code for a while until I figure out what it >> does. I may not know the reasoning behind it but I can have a pretty >> decent idea of what it does. If I'm lucky, later on someone may tell me >> "oh, that just did a gradient of such and such matrix". In a way, I feel >> happy I learned something highly complex without knowing I learned >> something highly complex. >> >> Backus seems to throw that out the window. He introduces major new terms >> which require me to break out the math book which then requires me to break >> out a few other books to figure out which bases things using archaic >> symbols which then requires me to break out the pen and paper to mentally >> expand what in the world that does. It makes me feel CISCish except >> without a definition book nearby. It's nice if I already knew what a >> "gradient of such and such matrix" is but what happens if I don't? >> >> For the most part, I like the idea that I have the option of Brute Force >> Learning my way towards something. I also like the declarative aspect of >> languages such as SQL which let's me asks the computer of things once I >> know the meaning of what I'm asking. I like the ability to play and learn >> but I also like the ability to declare this or that once I do learn. From >> Backus paper, if his world comes to a reality, it seems like I should know >> what I'm doing before I even start. The ability to learn while coding >> seems to have disappeared. In a way, if the von Neumann bottleneck wasn't >> there, I'm not sure programming would be as popular as it is today. >> >> Unfortunately, I'm still very new and quite ignorant about Haskell so I >> do not know how much of Backus is incorporated in Haskell but so far, in >> the start of my FP learning adventure, this is how things seem to be seen. >> >> If I may generously ask, where am I wrong and where am I right with this >> thought? >> >> Thank you for any explanation >> >> P.S. If anyone knows of a better place I can ask this question, please >> feel free to show me the way. >> > > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > >

1 0

Fwd: A Thought: Backus, FP, and Brute Force Learning
by Eli Frey 22 Mar '13

22 Mar '13

I always forget to reply-all :( ---------- Forwarded message ---------- From: Eli Frey <eli.lee.frey(a)gmail.com> Date: Thu, Mar 21, 2013 at 5:04 PM Subject: Re: [Haskell-cafe] A Thought: Backus, FP, and Brute Force Learning To: OWP <owpmailact(a)gmail.com> Ah, ye old "point free programming" [1]. Yes when you first see this stile it's a bit alarming. I think it's valid to say you shouldn't take this too far, but IMHO it is a good thing. If it is any more enlightening, it is good to think of this style like building shell pipelines. Depending on your disposition, that might make you more dismayed though :). Personally I like this style because it allows me to very rapidly prototype my ideas. When I am fleshing some solution out I will write it nearly entirely in this style. As I am throwing code around and refactoring, I will reevaluate things and name my pipes and their inputs and outputs where it makes sense to increase legibility. I am sure that Bacchus is serious about this, but have no fear. Just because you can do this does not mean you have to. You are still free to name your inputs and outputs as much as you please. However, no-one is forcing you to. There is a parallel in languages that have syntactic support for OOP. obj.dothis.dothat.andthis.andthat.andanotherthing There is just as much debate about how far to go with method chaining, and when to name intermediate values. [1] https://en.wikipedia.org/wiki/Tacit_programming On Thu, Mar 21, 2013 at 4:21 PM, OWP <owpmailact(a)gmail.com> wrote: > Thank you for this reply. This thought is more about Backus (he is cited > quite a lot) and how much of his theory made it into Haskell and other > commonly used functional programming. > > In Backhu's paper ( > http://www.thocp.net/biographies/papers/backus_turingaward_lecture.pdf) > is his comparison between FP and Impertive as seen in 5.1 & 5.2 of > "Programs for Inner Product". > > When I start seeing that program described as: > > "Def Innerproduct = (Insert +) o (ApplyToAll x) o Transpose" > > I start getting queasy. When he later describes functional programming > main purpose is to expand on that, I get worried. When he later explains > how I don't need to use variables and just need to use "elementary > substitution rule" for everything, I'm wondering if he's really serious > about this. > > From what you say, it doesn't sound as bad and I hope it isn't as I learn > more. > > Thanks for the reply. > > On Wed, Mar 20, 2013 at 7:56 PM, Eli Frey <eli.lee.frey(a)gmail.com> wrote: > >> I have not read Bacchus' paper, so i might be off the mark here. >> >> Functional code is just as simple (if not more so) to puzzle apart and >> understand as imperative code. You might find that instead of "stepping >> through the process" of code, you end up "walking the call graph" more >> often. FPers tend to break their problem into ever smaller parts before >> re-assembling them back together, often building their own vocabulary as >> they go. Not to say this is not done in imperative languages, but it is >> not so heavily encouraged and embraced. One result of this is that you can >> easily understand a piece of code in isolation, without considering it's >> place in some "process". It sounds as though you are not yet comfortable >> with this yet. >> >> So yes, you might have to learn more vocabulary to understand a piece of >> functional code. This is not because the inner workings are obfuscated, >> but because there are so many more nodes in the call graph that are given >> names. You can still go and scrutinize each of those new pieces of >> vocabulary by themselves and understand them without asking for the author >> to come down from on high with his explanation. >> >> Let's take iteration for example. In some imperative languages, people >> spend an awful lot of time writing iteration in terms of language >> primitives. You see a for loop. "What is this for loop doing?" you say to >> yourself. So you step through the loop imagining how it behaves as it goes >> and you say "Oh, this guy is walking through the array until he finds an >> element that matches this predicate." In a functional style, you would >> reuse some iterating function and give it functions to use as it is >> iterating. The method of iteration is still there, it has just nested into >> the call graph and if you've never seen that function name before you've >> got to go look at it. Again I don't mean to suggest that this isn't >> happening in an imperative language, just not to the same degree. >> >> As well there is a bit of a learning curve in seeing what a function >> "does" when there is no state or "doing" to observe in it. Once you get >> used to it, I believe you will find it quite nice though. You have >> probably heard FPers extolling the virtues of "declarative" code. When >> there is no state or "process" to describe, you end up describing what a >> thing is. I for one think this greatly increases readability. >> >> Good Luck! >> Eli >> >> >> On Wed, Mar 20, 2013 at 3:59 PM, OWP <owpmailact(a)gmail.com> wrote: >> >>> I made an error. I meant FP to stand for Functional Programming, the >>> concept not the language. >>> >>> On Wed, Mar 20, 2013 at 6:54 PM, OWP <owpmailact(a)gmail.com> wrote: >>> >>>> This thought isn't really related to Haskell specifically but it's more >>>> towards FP ideal in general. >>>> >>>> I'm new to the FP world and to get me started, I began reading a few >>>> papers. One paper is by John Backus called "Can Programming Be Liberated >>>> from the von Neumann Style? A Functional Style and It's Algebra of >>>> Programs". >>>> >>>> While I like the premise which notes the limitation of the von Neumann >>>> Architecture, his solution to this problem makes me feel queasy when I read >>>> it. >>>> >>>> For me personally, one thing I enjoy about a typical procedural program >>>> is that it allows me to "Brute Force Learn". This means I stare at a >>>> particular section of the code for a while until I figure out what it >>>> does. I may not know the reasoning behind it but I can have a pretty >>>> decent idea of what it does. If I'm lucky, later on someone may tell me >>>> "oh, that just did a gradient of such and such matrix". In a way, I feel >>>> happy I learned something highly complex without knowing I learned >>>> something highly complex. >>>> >>>> Backus seems to throw that out the window. He introduces major new >>>> terms which require me to break out the math book which then requires me to >>>> break out a few other books to figure out which bases things using archaic >>>> symbols which then requires me to break out the pen and paper to mentally >>>> expand what in the world that does. It makes me feel CISCish except >>>> without a definition book nearby. It's nice if I already knew what a >>>> "gradient of such and such matrix" is but what happens if I don't? >>>> >>>> For the most part, I like the idea that I have the option of Brute >>>> Force Learning my way towards something. I also like the declarative >>>> aspect of languages such as SQL which let's me asks the computer of things >>>> once I know the meaning of what I'm asking. I like the ability to play and >>>> learn but I also like the ability to declare this or that once I do learn. >>>> From Backus paper, if his world comes to a reality, it seems like I should >>>> know what I'm doing before I even start. The ability to learn while coding >>>> seems to have disappeared. In a way, if the von Neumann bottleneck wasn't >>>> there, I'm not sure programming would be as popular as it is today. >>>> >>>> Unfortunately, I'm still very new and quite ignorant about Haskell so I >>>> do not know how much of Backus is incorporated in Haskell but so far, in >>>> the start of my FP learning adventure, this is how things seem to be seen. >>>> >>>> If I may generously ask, where am I wrong and where am I right with >>>> this thought? >>>> >>>> Thank you for any explanation >>>> >>>> P.S. If anyone knows of a better place I can ask this question, please >>>> feel free to show me the way. >>>> >>> >>> >>> _______________________________________________ >>> Haskell-Cafe mailing list >>> Haskell-Cafe(a)haskell.org >>> http://www.haskell.org/mailman/listinfo/haskell-cafe >>> >>> >> >

1 0

ANN: text-printer - abstract interface for text builders/printers
by Mikhail Vorozhtsov 22 Mar '13

22 Mar '13

Hello, I was writing a library for working with IP addresses when I found myself puzzled with the number of contexts in which the textual representation of an address could be used: plain strings, bytestring builders (ASCII/UTF8), text builders, pretty printers, etc. I could've just written an `addressToString :: Address -> String` function, but that would be suboptimal: (a) namespace pollution (that's a lot of *ToString's if you count IPv4/6, network addresses, socket addresses, etc) and (b) some contexts can take advantage of the fact that textual representations are ASCII (e.g. UTF8 bytestring builder). And so the text-printer[1] was born. It is mainly two type classes. One for injecting text into a monoid, with special methods for ASCII and UTF-8 characters/strings. The other provides the default injection for values of a type (think of the `Pretty` type class in pretty printing libraries), the textual representation is supposed to be simple (single-line). Plus some convenient combinators and number formatters. [1] http://hackage.haskell.org/package/text-printer

1 0

ANN: bytestring-lexing 0.4.3
by wren ng thornton 22 Mar '13

22 Mar '13

-------------------------------------------- -- bytestring-lexing 0.4.3 -------------------------------------------- The bytestring-lexing package offers efficient reading and packing of common types like Double and Integral types. -------------------------------------------- -- Changes (since 0.4.2) -------------------------------------------- * Fixed a segfault bug in packDecimal. Due to the optimizations introduced in 0.4.2, packDecimal could segfault when passed a value larger than (maxBound::Word64). This patch corrects the oversight, and is a recommended upgrade for all users. Unfortunately, the safety test results in a 1.19x slowdown over version 0.4.2; reducing the 1.28x speedup for 0.4.0-->0.4.2 to a mere 1.08x for 0.4.0-->0.4.3. Future versions will probably introduce a type class to remove the safety check for types where it must vacuously succeed. -------------------------------------------- -- Links -------------------------------------------- Homepage: http://code.haskell.org/~wren/ Hackage: http://hackage.haskell.org/package/bytestring-lexing Darcs: http://community.haskell.org/~wren/bytestring-lexing Haddock (Darcs version): http://community.haskell.org/~wren/bytestring-lexing/dist/doc/html/bytestri… -- Live well, ~wren

1 0

2nd CFP: SBLP 2013 (17th Brazilian Symposium on Programming Languages)
by Andre Rauber Du Bois 21 Mar '13

21 Mar '13

[Apologies if you receive multiple copies of this CFP] ======================================================= 2nd CALL FOR PAPERS 17th BRAZILIAN SYMPOSIUM ON PROGRAMMING LANGUAGES Brasília, Distrito Federal, Brazil September 29th to October 4th, 2013 http://cbsoft2013.cic.unb.br/sblp ======================================================== IMPORTANT DATES Paper abstract submission (15 lines): April 19th Full paper submission: April 26th, 2013 Notification of acceptance: May 31st, 2013 Final papers due: June 28th, 2013 INVITED SPEAKERS * Tim Harris, Oracle Labs * More TBA INTRODUCTION The 17th Brazilian Symposium on Programming Languages, SBLP 2013, will be held in Brasília, Brazil, on September 29th to October 4th, 2013. SBLP provides a venue for researchers and practitioners interested in the fundamental principles and innovations in the design and implementation of programming languages and systems. The symposium will be part of the 4th Brazilian Conference on Software: Theory and Practice, CBSoft 2013, http://cbsoft2013.cic.unb.br/, which will host four traditional, well-established symposia: * XXVII Brazilian Symposium on Software Engineering (SBES) * XVII Brazilian Symposium on Programming Languages (SBLP) * XVI Brazilian Symposium on Formal Methods (SBMF) * VII Brazilian Symposium on Components, Software Architecture and Software Reuse (SBCARS) SBLP 2013 invites authors to contribute with technical papers related (but not limited) to: * Program generation and transformation, including domain-specific languages and model-driven development in the context of programming languages. * Programming paradigms and styles, including functional, object-oriented, aspect-oriented, scripting languages, real-time, service-oriented, multithreaded, parallel, and distributed programming. * Formal semantics and theoretical foundations, including denotational, operational, algebraic and categorical. * Program analysis and verification, including type systems, static analysis and abstract interpretation. * Programming language design and implementation, including new programming models, programming language environments, compilation and interpretation techniques. SUBMISSIONS Contributions should be written in Portuguese or English. We solicit papers that should fall into one of two different categories: full papers, with at most 15 pages, or short papers, with at most 5 pages. Full papers submitted in English will be published in a volume of Lecture Notes in Computer Science (LNCS), by Springer (pending approval). For this reason, all papers must be prepared using the LNCS template, available at http://www.springer.com/computer/lncs?SGWID=0-164-6-793341-0. We encourage the submission of short papers reporting on partial results of on-going master dissertations or doctoral theses. All accepted papers will be published in the conference proceedings distributed in a digital media by the CBSOFT organizers. Submissions should be done using SBLP 2013 installation of the EasyChair conference mangement system at http://www.easychair.org/conferences/?conf=sblp2013. As in previous editions, a journal special issue, with selected papers from accepted contributions, is anticipated. Selected papers from 2003 to 2008 editions of SBLP were published in special issues of the Journal of Universal Computer Science, by Springer. The post-proceedings of SBLP from 2009 to 2012, also with selected papers from the conference proceedings, are being edited as special issues of Science of Computer Programming, published by Elsevier. CBSOFT CHAIRS Genaina Nunes Rodrigues, UnB Rodrigo Bonifácio, UnB Diego Aranha, UnB PROGRAMME CHAIRS André Rauber Du Bois, UFPel Phil Trinder, Glasgow University PROGRAMME COMMITTEE Alberto Pardo, Univ. de La Republica Alex Garcia, IME Alvaro Freitas Moreira, UFRGS André Rauber Du Bois, UFPel (co-chair) Andre Santos, UFPE Carlos Camarao, UFMG Christiano Braga, UFF Edwin Brady, University of St. Andrews Fernando Castor Filho, UFPE Fernando Quintão Pereira, UFMG Francisco Heron de Carvalho Junior, UFC Hans-Wofgang Loidl, Heriot-Watt University Jeremy Singer, Glasgow University Joao Saraiva, Universidade do Minho João F. Ferreira, Teesside University Lucilia Figueiredo, UFOP Luis Soares Barbosa, Univ. do Minho Manuel António Martins, Univ. de Aveiro Marcelo A. Maia, UFU Marcello Bonsangue, Leiden Univ/CWI Marcelo d'Amorim, UFPE Marco Tulio Valente, UFMG Mariza A. S. Bigonha, UFMG Martin A. Musicante, UFRN Noemi Rodriguez, PUC-Rio Peter Mosses, Swansea University Phil Trinder, Glasgow University (co-chair) Qiu Zongyang, Beijing University Rafael Dueire Lins, UFPE Renato Cerqueira, PUC-Rio Ricardo Massa, UFPE Roberto S. Bigonha, UFMG Roberto Ierusalimschy, PUC-Rio Sandro Rigo, UNICAMP Sergio Soares, UFPE Simon Thompson, Univ. of Kent Varmo Vene, Univ. de Tartu

1 0

Excercise on tagless final interpreters
by matteo vezzola 21 Mar '13

21 Mar '13

I'm playing with tagless final interpreters reading [1], using a very simple language: >>> class Ints repr where >>> int :: Integer -> repr Integer >>> (.+.) :: repr Integer -> repr Integer -> repr Integer >>> (.*.) :: repr Integer -> repr Integer -> repr Integer >>> (.-.) :: repr Integer -> repr Integer >>> (.<=.) :: repr Integer -> repr Integer -> repr Bool >>> newtype P repr t = P { unP :: Bool -> repr t } >>> instance Ints repr => Ints (P repr) where >>> int n = P $ \ s -> if s then int n else (.-.) (int n) >>> (.-.) n = P $ unP n . not >>> n .+. m = P $ \ s -> unP n s .+. unP m s >>> n .*. m = P $ \ s -> unP n s .*. unP m s >>> n .<=. m = P $ \ s -> unP n s .<=. unP m s After pushing down negations I'd like to distribute (.*.) over (.+.). [1] leaves it as an exercise, so it can't be that hard, but I don't get it... Anyone knows how I could do it? [1]: <http://okmij.org/ftp/tagless-final/course/lecture.pdf> thanks, -- matteo

3 2

Extracting exposed modules from an installed library
by Corentin Dupont 21 Mar '13

21 Mar '13

Hi Cafe! I'm looking for how to extract the exposed modules (as a list of strings) from an installed library, giving the library name. I can see some structures in Cabal (InstalledPackageInfo) and some functions in ghc-pkg.hs in GHC, but nothing readily useable... Thanks, Corenti

3 3

ANN: bytestring-lexing 0.4.2
by wren ng thornton 21 Mar '13

21 Mar '13

-------------------------------------------- -- bytestring-lexing 0.4.2 -------------------------------------------- The bytestring-lexing package offers efficient reading and packing of common types like Double and Integral types. -------------------------------------------- -- Changes (since 0.4.0) -------------------------------------------- * Faster implementation of packDecimal. Inspired by [1] I applied the same optimizations to the ByteString implementation of packDecimal. According to the benchmarks I have on hand the new version is about 1.3x faster than the old version. So the difference isn't nearly as impressive; but it's not trivial either. * Added buffer overflow check for asHexadecimal. This only matters if you try converting a ByteString longer than (maxBound `quot` 2 ::Int). I forget if the old version segfaulted or what; but now you get an error message about trying to allocate a buffer that's too large. [1] <http://www.serpentine.com/blog/2013/03/20/whats-good-for-c-is-good-for-hask…> -------------------------------------------- -- Links -------------------------------------------- Homepage: http://code.haskell.org/~wren/ Hackage: http://hackage.haskell.org/package/bytestring-lexing Darcs: http://community.haskell.org/~wren/bytestring-lexing Haddock (Darcs version): http://community.haskell.org/~wren/bytestring-lexing/dist/doc/html/bytestri… -- Live well, ~wren

1 0

Haskell Weekly News: Issue 263
by Daniel Santa Cruz 21 Mar '13

21 Mar '13

Welcome to issue 263 of the HWN, an issue covering crowd-sourced bits of information about Haskell from around the web. This issue covers the week of March 10 to 16, 2013. Quotes of the Week * shachaf: Did someone give edwardk a committee bit? Top Reddit Stories * Restored: the Haskell mailing list archives: 1990-2000. The lost books of Haskell Domain: code.haskell.org, Score: 71, Comments: 9 On Reddit: [1] http://goo.gl/wYs4E Original: [2] http://goo.gl/1Hw4G * Dependently Typed Functional Programming with Idris [video] Domain: vimeo.com, Score: 49, Comments: 20 On Reddit: [3] http://goo.gl/RDII5 Original: [4] http://goo.gl/AmmPJ * Snake game in Haskell Domain: self.haskell, Score: 48, Comments: 19 On Reddit: [5] http://goo.gl/HssiG Original: [6] http://goo.gl/HssiG * A simple graphical notation for lambda calculus Domain: binarylambda.blogspot.com, Score: 46, Comments: 35 On Reddit: [7] http://goo.gl/I3xqp Original: [8] http://goo.gl/sY6gl * Simon Peyton Jones on Adventures with types (Functional Programming eXchange 2013) Domain: skillsmatter.com, Score: 46, Comments: 27 On Reddit: [9] http://goo.gl/wUvon Original: [10] http://goo.gl/XCWsE * Guide to GHC Extensions (just some simple ones for now, will expand over time) - School of Haskell Domain: fpcomplete.com, Score: 42, Comments: 25 On Reddit: [11] http://goo.gl/XhFK5 Original: [12] http://goo.gl/Wa0K3 * layers-0.1: Modular type class machinery for monad transformer stacks. Domain: hackage.haskell.org, Score: 37, Comments: 30 On Reddit: [13] http://goo.gl/nkimL Original: [14] http://goo.gl/HFBxI * Type Families and Pokemon: School of Haskell Pick of the Week Domain: fpcomplete.com, Score: 35, Comments: 3 On Reddit: [15] http://goo.gl/mITH3 Original: [16] http://goo.gl/oymkn * Gale: an IDE for creating games in Haskell Domain: youtube.com, Score: 31, Comments: 4 On Reddit: [17] http://goo.gl/2k28x Original: [18] http://goo.gl/9SxFS * What is the best way to make a simple web service in Haskell? Domain: self.haskell, Score: 31, Comments: 34 On Reddit: [19] http://goo.gl/sVAe7 Original: [20] http://goo.gl/sVAe7 * Wadler's Blog: Informatics 1: Functional Programming Domain: wadler.blogspot.ro, Score: 25, Comments: 3 On Reddit: [21] http://goo.gl/70Ocg Original: [22] http://goo.gl/z4b38 * Constructions on Typeclasses, Part 1: F-Algebras Domain: lukepalmer.wordpress.com, Score: 24, Comments: 0 On Reddit: [23] http://goo.gl/qGsVj Original: [24] http://goo.gl/s947R * cabal-dev updated on hackage Domain: haskell.org, Score: 24, Comments: 37 On Reddit: [25] http://goo.gl/LUOQZ Original: [26] http://goo.gl/nMut4 * monoid-subclasses: ListLike-like, only built on sound theoretical foundations Domain: hackage.haskell.org, Score: 22, Comments: 24 On Reddit: [27] http://goo.gl/gA46h Original: [28] http://goo.gl/4QOKw * Introduction to Concurrent Haskell - Simon Marlow [FP Days Cambridge 2012] Domain: infoq.com, Score: 22, Comments: 1 On Reddit: [29] http://goo.gl/CS0xV Original: [30] http://goo.gl/TrVo9 Top StackOverflow Questions * Proposal for local data declarations / instances votes: 15, answers: 1 Read on SO: [31] http://goo.gl/VCd4K * What is the equivalent Haskell type for C99 bool when using FFI? votes: 14, answers: 2 Read on SO: [32] http://goo.gl/mm3hC * Disadvantages of using INLINABLE pragma votes: 13, answers: 1 Read on SO: [33] http://goo.gl/zxnBu * How to compare two lists in Haskell? votes: 11, answers: 4 Read on SO: [34] http://goo.gl/kTXqL * Haskell space usage compile time restrictions votes: 11, answers: 2 Read on SO: [35] http://goo.gl/vy7wO * haskell - Average floating point error using QuickCheck votes: 10, answers: 1 Read on SO: [36] http://goo.gl/MNsnL * Trying to understand function application operator in Haskell votes: 9, answers: 1 Read on SO: [37] http://goo.gl/ymFv4 * Haskell equivalent to Scala's groupBy votes: 9, answers: 4 Read on SO: [38] http://goo.gl/0uceW * (Num a) vs Integer type inference votes: 9, answers: 3 Read on SO: [39] http://goo.gl/N3CWn Until next time, +Daniel Santa Cruz References 1. http://code.haskell.org/~dons/haskell-1990-2000/ 2. http://www.reddit.com/r/haskell/comments/1aescj/restored_the_haskell_mailin… 3. http://vimeo.com/61576198 4. http://www.reddit.com/r/haskell/comments/1a7rbk/dependently_typed_functiona… 5. http://www.reddit.com/r/haskell/comments/1a12vg/snake_game_in_haskell/ 6. http://www.reddit.com/r/haskell/comments/1a12vg/snake_game_in_haskell/ 7. http://binarylambda.blogspot.com/2013/03/lambda-diagrams-lambda-diagrams-fe… 8. http://www.reddit.com/r/haskell/comments/1a47ox/a_simple_graphical_notation… 9. http://skillsmatter.com/podcast/java-jee/keynote-3842 10. http://www.reddit.com/r/haskell/comments/1aedqt/simon_peyton_jones_on_adven… 11. https://www.fpcomplete.com/user/PthariensFlame/guide-to-ghc-extensions ? 12. http://www.reddit.com/r/haskell/comments/1a3ye8/guide_to_ghc_extensions_jus… 13. http://hackage.haskell.org/package/layers 14. http://www.reddit.com/r/haskell/comments/1aazok/layers01_modular_type_class… 15. https://www.fpcomplete.com/user/nubis/type-families-and-pokemon 16. http://www.reddit.com/r/haskell/comments/1adukd/type_families_and_pokemon_s… 17. http://www.youtube.com/watch?v=dKBFJa9N3zY 18. http://www.reddit.com/r/haskell/comments/1a3k64/gale_an_ide_for_creating_ga… 19. http://www.reddit.com/r/haskell/comments/1acfbx/what_is_the_best_way_to_mak… 20. http://www.reddit.com/r/haskell/comments/1acfbx/what_is_the_best_way_to_mak… 21. http://wadler.blogspot.ro/2013/03/informatics-1-functional-programming.html 22. http://www.reddit.com/r/haskell/comments/1a5uio/wadlers_blog_informatics_1_… 23. http://lukepalmer.wordpress.com/2013/03/12/constructions-on-typeclasses-par… 24. http://www.reddit.com/r/haskell/comments/1a5dtt/constructions_on_typeclasse… 25. http://www.haskell.org/pipermail/haskell-cafe/2013-February/106719.html 26. http://www.reddit.com/r/haskell/comments/1a6t0j/cabaldev_updated_on_hackage/ 27. http://hackage.haskell.org/package/monoid-subclasses 28. http://www.reddit.com/r/haskell/comments/1a33sb/monoidsubclasses_listlikeli… 29. http://www.infoq.com/presentations/Concurrent-Haskell 30. http://www.reddit.com/r/haskell/comments/1a4pvi/introduction_to_concurrent_… 31. http://stackoverflow.com/questions/15320391/proposal-for-local-data-declara… 32. http://stackoverflow.com/questions/15368658/what-is-the-equivalent-haskell-… 33. http://stackoverflow.com/questions/15440804/disadvantages-of-using-inlinabl… 34. http://stackoverflow.com/questions/15319136/how-to-compare-two-lists-in-has… 35. http://stackoverflow.com/questions/15374829/haskell-space-usage-compile-tim… 36. http://stackoverflow.com/questions/15364518/haskell-average-floating-point-… 37. http://stackoverflow.com/questions/15362990/trying-to-understand-function-a… 38. http://stackoverflow.com/questions/15412027/haskell-equivalent-to-scalas-gr… 39. http://stackoverflow.com/questions/15448351/num-a-vs-integer-type-inference 40. https://plus.google.com/105107667630152149014/about

1 0

Maintaining lambdabot
by Jan Stolarek 21 Mar '13

21 Mar '13

Hi all, as some of you may have noticed Lambdabot doesn't build on GHC 7.6.1 due to OldException being removed (and a few other changes). I updated the code so that it builds on latest GHC release. The updated code is available here: https://github.com/killy9999/lambdabot/tree/upstream It builds on Linux, but I am not 100% certain that it will build on Windows. If it doesn't I will be grateful for reporting this (and any other) issues on the bug tracker: https://github.com/killy9999/lambdabot/issues The changes required to make the code run weren't as small as I initially thought they will be. In some places this resulted in a bit ugly code, but aside from that I think that everything should work correctly. Now I would like to do a bit of maintanance on the project, since the code is a bit of a mess and it could use some cleanup. My plans are: - clean up the package namespace by placing existing modules in Lambdabot module - integrate lambdabot-utils into lambdabot (already done) - reformat the code so that it's easier to read ans if time allows: - cleanup some messy code - update the package dependencies so that lambdabot relies on maintained libraries (e.g. I thought about replacing readline with haskeline). This changes would be quite invasive and code wouldn't be compatible with the lambdabot repo on haskell.org. So before I start making any of them I would like to hear from the community if such changes in the source code of lambdabot would be considered helpful and acceptable. Janek

7 29

package show needs QuickCheck<2.6?
by Johannes Waldmann 21 Mar '13

21 Mar '13

Hi, I noticed that compilation of mueval (recent: 0.8.2) breaks because show (0.5) cannot be built: it seems the type of Failure changed in QuickCheck (from 2.5 to 2.6). The build succeeds with --constraint 'QuickCheck<2.6' .

2 1

Does GHC 7.8 make targeting bare metal ARM any easier?
by Jeremy Shaw 20 Mar '13

20 Mar '13

There have been at least a couple projects, such as hOp and HaLVM which attempt to run GHC on the bare metal or something similar. Both these projects required a substantial set of patches against GHC to remove dependencies things like POSIX/libc. Due to the highly invasive nature, they are also highly prone to bitrot. With GHC 7.8, I believe we will be able to cross-compile to the Raspberry Pi platform. But, what really appeals to me is going that extra step and avoiding the OS entirely and running on the bare metal. Obviously, you give up a lot -- such as drivers, network stacks, etc. But, there is also a lot of potential to do neat things, and not have to worry about properly shutting down an embedded linux box. Also, since the raspberry pi is a very limited, uniform platform, (compared to general purpose PCs) it is feasible to create network drivers, etc, because only one chipset needs to be supported. (Ignoring issues regarding binary blobs, undocumented chipsets, usb WIFI, etc). I'm wondering if things are any easier with cross-compilation support improving. My thought is that less of GHC needs to be tweaked? - jeremy

4 3

ANN: LearnByHaking.org
by Deian Stefan 20 Mar '13

20 Mar '13

Hi cafe, I've been delaying the announcement of LearnByHacking.org as I wish to add more features, but some of you may be interested in it as is. The web app is inspired by and, to some degree, a lighter-weight clone of School of Haskell. I am currently using it as glorified blog that provides a means for collaborating with others on posts and include active code. For those unfamiliar with SoH, that is, code that users can execute with a single click and modify. There are lots of things on the TODO list, so if anybody wants to hack, please join in. Cheers, Deian

1 0

Streaming bytes and performance
by Konstantin Litvinenko 20 Mar '13

20 Mar '13

Hi All! I tune my toy project for performance and hit the wall on simple, in imperative world, task. Here is the code that model what I'm trying to achieve import qualified Data.ByteString.Lazy as L import Data.Word8(isSpace) import Data.Word import Control.Monad.State type Stream = State L.ByteString get_byte :: Stream (Maybe Word8) get_byte = do s <- get case L.uncons s of Nothing -> return Nothing Just (x, xs) -> put xs >> return (Just x) main = do f <- L.readFile "test.txt" let r = evalState count_spaces f print r where count_spaces = go 0 where go a = do x <- get_byte case x of Just x' -> if isSpace x' then go (a + 1) else go a Nothing -> return a It takes the file and count spaces, in imperative way, consuming bytes one by one. The problem is: How to rewrite this to get rid of constant allocation of state but still working with stream of bytes? I can rewrite this as one-liner L.foldl, but that doesn't help me in any way to optimize my toy project where all algorithms build upon consuming stream of bytes. PS. My main lang is C++ over 10 years and I only learn Haskell :)

7 20

Compiled program using OpenGL fails to trigger GPU switch on Mac, but works in GHCi
by Jesper Särnesjö 20 Mar '13

20 Mar '13

Hi everybody, This started out on haskell-beginners, as a question about poor performance for a Haskell program using OpenGL. Thanks to a few good suggestions there, I've managed to figure out more or less what the underlying problem is, but not its cause. In short, I have two programs, one written in Haskell [1] and one written in C [2], that consist of calls to the same functions, in the same order, to the same C library, but which do not exhibit the same behavior. Further, the Haskell program behaves differently when compiled using GHC, and when run in GHCi. I would like to know why this is, and how to fix it. A bit of background. My original program used the GLFW library to create an OpenGL rendering context, and rendered a 3D model using OpenGL. I noticed that this program had very high CPU usage, when I expected it to do most of its work on the GPU [3]. The reason for the high CPU usage turned out to be that the program was in fact using a software implementation of OpenGL [4]. My machine, a MacBook Pro running Mac OS X 10.8.2, has two GPUs, a discrete (more powerful) and an integrated one (more energy-efficient). The latter implements a larger part of OpenGL in software, and the OS is supposed to switch transparently between the two. In particular, it is supposed to switch to the discrete GPU when a program tries to use OpenGL features not supported by the integrated GPU [5]. I discovered that while this all worked as intended when running the C version of my program, it did not work quite so well for the Haskell program [6], which would get stuck with a rendering context on the integrated GPU, which in practice meant a software implementation and poor performance. I reduced both programs to fairly minimal test cases. Now, each program simply configures and creates a rendering context, checks if it is hardware-accelerated (for the configuration used, on my machine, this implies that the system has switched to the discrete GPU), and then terminates. This is all done using calls to the GLFW C library. The C program succeeds. The Haskell program fails if compiled (with GHC 7.4.2) and run, but succeeds if run in GHCi. Further, by monitoring which GPU is active, using gfxCardStatus [7] and the system console, I've established that the switch happens immediately following the execution of glfwOpenWindow, for the C program and the Haskell program when run in GHCi. For the compiled Haskell program, the switch is delayed by roughly a second. This delay appears to be what causes the program to get stuck on the integrated GPU. Now, there are a lot of moving parts involved, and many places where things could go wrong, making it tricky to even say where the problem is. Still, a Haskell program consisting entirely of foreign function calls in the IO monad, should surely behave the same as a C program consisting of the same calls? Is this caused by lazy evaluation, and if so, of what? Why does it work correctly in GHCi? I've bashed my head against this for some time now, and have run out of good ideas. I would really appreciate any input that lets me solve this, and get back to the fun parts of 3D programming. ;) To reproduce this, you'll need a Mac that has two GPUs (most of them does, these days). I run Mac OS X 10.8.2, and another user reproduced this on 10.7.5 [8]. You'll also need the GLFW library [9], which can be built from source or installed using Homebrew. Please let me know if I can provide any more information. -- Jesper Särnesjö http://jesper.sarnesjo.org/ [1] https://gist.github.com/sarnesjo/5151894#file-glfw_test-hs [2] https://gist.github.com/sarnesjo/5151894#file-glfw_test-c [3] http://www.haskell.org/pipermail/beginners/2013-March/011557.html [4] http://www.haskell.org/pipermail/beginners/2013-March/011560.html [5] http://developer.apple.com/library/mac/#qa/qa1734/_index.html%23//apple_ref… [6] http://www.haskell.org/pipermail/beginners/2013-March/011601.html [7] http://gfx.io [8] http://www.haskell.org/pipermail/beginners/2013-March/011563.html [9] http://www.glfw.org

6 11

Associated types for number coercion
by Christopher Done 20 Mar '13

20 Mar '13

>From the paper Fun with Type Funs, it's said: > One compelling use of such type functions is to make type > coercions implicit, especially in arithmetic. Suppose we want to be able to > write add a b to add two numeric values a and b even if one is an Integer > and the other is a Double (without writing fromIntegral explicitly). And then an Add class is defined which can dispatch at the type-level to appropriate functions which resolve two types into one, with a catch-all case for Num. Has anyone put this into a package, for all common arithmetic operations? I would use it. Doing arithmetic stuff in Haskell always feels labored because of having constantly convert between number types.

3 4

Fwd: Now Accepting Applications for Mentoring Organizations for GSoC 2013
by Johan Tibell 19 Mar '13

19 Mar '13

[bcc: haskell(a)haskell.org] We should make sure that we apply for Google Summer of Code this year as well. It's been very successful in the previous year, where we have gotten several projects funded every year. -- Johan ---------- Forwarded message ---------- From: Carol Smith <carols(a)google.com> Date: Mon, Mar 18, 2013 at 12:00 PM Subject: Now Accepting Applications for Mentoring Organizations for GSoC 2013 To: Google Summer of Code Announce < google-summer-of-code-announce(a)googlegroups.com> Hi all, We're pleased to announce that applications for mentoring organizations for Google Summer of Code 2013 are now being accepted [1]. If you'd like to apply to be a mentoring organization you can do so via Melange [2]. If you have questions about how to use Melange, please see our User's Guide [3]. Please note that the application period [4] closes on 29 March at 19:00 UTC [5]. We will not accept any late applications for any reason. [1] - http://google-opensource.blogspot.com/2013/03/mentoring-organization-applic… [2] - http://www.google-melange.com [3] - http://en.flossmanuals.net/melange/ [4] - http://www.google-melange.com/gsoc/events/google/gsoc2013 [5] - http://goo.gl/xmQMJ Cheers, Carol -- You received this message because you are subscribed to the Google Groups "Google Summer of Code Announce" group. To unsubscribe from this group and stop receiving emails from it, send an email to google-summer-of-code-announce+unsubscribe(a)googlegroups.com. To post to this group, send email to google-summer-of-code-announce(a)googlegroups.com. Visit this group at http://groups.google.com/group/google-summer-of-code-announce?hl=en. For more options, visit https://groups.google.com/groups/opt_out.

3 2

Re: [Haskell-cafe] attoparsec and backtracking
by oleg＠okmij.org 19 Mar '13

19 Mar '13

Wren Thornton wrote: > I had some similar issues recently. The trick is figuring out how to > convince attoparsec to commit to a particular alternative. For example, > consider the grammar: A (B A)* C; where if the B succeeds then we want to > commit to parsing an A (and if it fails then return A's error, not C's). Indeed. Consider the following (greatly simplified) fragment from the OCaml grammar | "let"; r = opt_rec; bi = binding; "in"; x = expr LEVEL ";" -> | "function"; a = match_case -> | "if"; e1 = SELF; "then"; e2 = expr LEVEL "top"; "else"; e3 = expr LEVEL "top" -> ... | "false" -> | "true" -> It would be bizarre if the parser -- upon seeing "if" but not finding "then" -- would've reported the error that `found "if" when "true" was expected'. Many people would think that when the parser comes across "if", it should commit to parsing the conditional. And if it fails later, it should report the error with the conditional, rather than trying to test how else the conditional cannot be parsed. This is exactly the intuition of pattern matching. For example, given > foo ("if":t) = case t of > (e:"then":_) -> e > foo _ = "" we expect that foo ["if","false","false"] will throw an exception rather than return the empty string. If the pattern has matched, we are committed to the corresponding branch. Such an intuition ought to apply to parsing -- and indeed it does. The OCaml grammar above was taken from the camlp4 code. Camlp4 parsers http://caml.inria.fr/pub/docs/tutorial-camlp4/tutorial002.html#toc6 do pattern-matching on a stream, for example # let rec expr = parser [< 'If; x = expr; 'Then; y = expr; 'Else; z = expr >] -> "if" | [< 'Let; 'Ident x; 'Equal; x = expr; 'In; y = expr >] -> "let" and raise two different sort of exceptions. A parser raises Stream.Failure if it failed on the first element of the stream (in the above case, if the stream contains neither If nor Let). If the parser successfully consumed the first element but failed later, a different Stream.Error is thrown. Although Camlp4 has many detractors, even they admit that the parsing technology by itself is surprisingly powerful, and produces error messages that are oftentimes better than those by the yacc-like, native OCaml parser. Camlp4 parsers are used extensively in Coq. The idea of two different failures may help in the case of attoparsec or parsec. Regular parser failure initiates backtracking. If we wish to terminate the parser, we should raise the exception (and cut the rest of the choice points). Perhaps the could be a combinator `commit' that converts a failure to the exception. In the original example A (B A)* C we would use it as A (B (commit A))* C.

1 0

ANNOUNCE: HaTeX-3.5 - New version of the LaTeX library
by Daniel Díaz Casanueva 19 Mar '13

19 Mar '13

Hi readers! A new version of HaTeX has just been released. More math symbols and utilities and a new attoparsec-based parser. This new version also includes a new matrix renderer. A summary of the changes: http://deltadiaz.blogspot.com/2013/03/hatex-35.html The package in Hackage: http://hackage.haskell.org/package/HaTeX-3.5 For those who don't know, HaTeX is a combinator library for LaTeX code. Read more in the manual: https://github.com/downloads/Daniel-Diaz/HaTeX-Guide/HaTeX-Guide.pdf I recommend to HaTeX users to upgrade to this new version. Good luck, Daniel Díaz. -- E-mail sent by Daniel Díaz Casanueva let f x = x in x

2 1

Workshop on Generic Programming
by Jacques Carette 18 Mar '13

18 Mar '13

Dear list subscribers, apologies if you receive multiple copies of this CFP. ====================================================================== CALL FOR PAPERS WGP 2013 9th ACM SIGPLAN Workshop on Generic Programming Boston, Massachusetts, USA Saturday, September 29th, 2013 http://www.wgp-sigplan.org/2013 Co-located with the International Conference on Functional Programming (ICFP 2013) ====================================================================== Goals of the workshop --------------------- Generic programming is about making programs more adaptable by making them more general. Generic programs often embody non-traditional kinds of polymorphism; ordinary programs are obtained from them by suitably instantiating their parameters. In contrast with normal programs, the parameters of a generic program are often quite rich in structure; for example they may be other programs, types or type constructors, class hierarchies, or even programming paradigms. Generic programming techniques have always been of interest, both to practitioners and to theoreticians, and, for at least 20 years, generic programming techniques have been a specific focus of research in the functional and object-oriented programming communities. Generic programming has gradually spread to more and more mainstream languages, and today is widely used in industry. This workshop brings together leading researchers and practitioners in generic programming from around the world, and features papers capturing the state of the art in this important area. We welcome contributions on all aspects, theoretical as well as practical, of * generic programming, * programming with (C++) concepts, * meta-programming, * programming with type classes, * programming with modules, * programming with dependent types, * type systems for generic programming, * polytypic programming, * adaptive object-oriented programming, * component-based programming, * strategic programming, * aspect-oriented programming, * family polymorphism, * object-oriented generic programming, * implementation of generic programming languages, * static and dynamic analyses of generic programs, * and so on. Program Committee ----------------- Jeremiah Willcock (co-chair), Indiana University Jacques Carette (co-chair), McMaster University Florian Rabe, Jacobs University Bremen Emilie Balland, INRIA Bordeaux Jeremy Siek, University of Colorado, Boulder Gabriel Dos Reis, Texas A&M University Christophe Raffalli, Savoie University Anya Helene Bagge, Universitetet i Bergen Tiark Rompf, Ecole Polytechnique Federale de Lausanne Andreas Abel, Ludwig-Maximilians-Universitat Munchen Edward Kmett, S&P Capital IQ William Cook, University of Texas, Austin Proceedings and Copyright ------------------------- We plan to have formal proceedings, published by the ACM. Authors must transfer copyright to ACM upon acceptance (for government work, to the extent transferable), but retain various rights (http://www.acm.org/publications/policies/copyright_policy) Authors are encouraged to publish auxiliary material with their paper (source code, test data, etc.); they retain copyright of auxiliary material. Submission details ------------------ Deadline for submission: Friday 2013-06-14 Notification of acceptance: Wednesday 2013-07-11 Final submission due: Tuesday 2013-07-25 Workshop: Sunday 2013-09-28 Papers should be submitted via EasyChair at https://www.easychair.org/conferences/?conf=wgp2013 Submitted papers should be in portable document format (PDF), formatted using the ACM SIGPLAN style guidelines (two-column, 9pt). The length is restricted to 12 pages. Travel Support -------------- Student attendees with accepted papers can apply for a SIGPLAN PAC grant to help cover travel expenses. PAC also offers other support, such as for child-care expenses during the meeting or for travel costs for companions of SIGPLAN members with physical disabilities, as well as for travel from locations outside of North America and Europe. For details on the PAC program, see its web page (http://www.sigplan.org/PAC.htm) History of the Workshop on Generic Programming ---------------------------------------------- Earlier Workshops on Generic Programming have been held in * Copenhagen, Denmark 2012 (affiliated with ICFP12), * Tokyo, Japan 2011 (affiliated with ICFP11), * Baltimore, Maryland, US 2010 (affiliated with ICFP10), * Edinburgh, UK 2009 (affiliated with ICFP09), * Victoria, BC, Canada 2008 (affiliated with ICFP), * Portland 2006 (affiliated with ICFP), * Ponte de Lima 2000 (affiliated with MPC), * Marstrand 1998 (affiliated with MPC). Furthermore, there were a few informal workshops * Utrecht 2005 (informal workshop), * Dagstuhl 2002 (IFIP WG2.1 Working Conference), * Nottingham 2001 (informal workshop). There were also (closely related) DGP workshops in Oxford (June 3-4 2004), and a Spring School on DGP in Nottingham (April 24-27 2006, which had a half-day workshop attached). WGP Steering Committee ---------------------- Marcin Zalewski (chair) Bruno Oliveira Jaako Järvi Shin-Cheng Mu Andres Löh Ronald Garcia Magne Haveraaen Tim Sheard Stephanie Weirich

1 0

Improving my implementation of "The Lady Tasting Tea"
by Mark Fredrickson 18 Mar '13

18 Mar '13

Hello, For my first project in Haskell, I thought I would re-implement a statistical problem that I have previously done in R. In his 1925 book, Fisher tells of an experiment in which a lady claims she can tell the difference in cups of tea that have the milk or the tea/water added first (I'm a coffee drinker, so I'm unclear on the actual physical interpretation). To test this claim, Fisher proposes an experiment in which 8 cups are created, with 4 having milk first and 4 having tea first. If the lady can properly label 3 of the 4 milk first cups correctly, should we be suprised? What is the probability that she would get 3 or 4 of the milk first cups correct just due to chance (that is, independently of the actual allocation of milk and tea first)? Fisher shows that these questions can be answered by writing out all the possible ways the 4 milk cups could be allocated (there are 70 such possibilities) and then counting the subset that have 3 or 4 correct according to the lady's guess (there are 17). Therefore the probability of getting 3 or 4 correct just by guessing would occur about 24% of the time. I've implemented this algorithm for problems of arbitrary size, and I'd like some feedback on improving the efficiency of my code: https://gist.github.com/markmfredrickson/5190212 The problem is basically a map-reduce: 1. Create the C(N,K) possible ways the cups could be set up (where N is the total number of cups, and K is the number with milk first) 2. Map a function across them that scores the lady's guess 3. Reduce the set of scores to a p-value (a value between 0 and 1) that indicates what percentage of all possible allocations of milk first would have a score equal to or greater than the lady's guess. My first attempt at profiling indicates that most time is spent in the scoring function, unsurprising as this is in the inner most loop of the algorithm. The generation of all possible combinations is also time consuming. From what I can tell, this implementation is not very efficient from a space perspective. In the long term, I'm interested in using this same basic procedure to solve more interesting statistical problems, so I'm particulary interested in getting feed back on: 1. A good data type for storing the list of treatment allocations (i.e. milk first cups). The current problem calls for binary treatment with no extra data. In the future, my N units may be partitioned into K groups (here K=2), and the score function will require additional data (e.g. each unit will have an outcome measure on a continuous or ordinal scale). In a sense, I'd like to use tuples to hold index values from 1 to N, but I wouldn't necessarily know the tuple size at compile time. The index values would point to an array or similar structure holding the additional data. Some other properties of allocations: - They are always the same size - Order is not important - All values are unique Any standard types fit this description? 2. A better algorithm and perhaps data type for the combinations. The current implementation uses a tree recursion to get the set of all possible combinations. In the future, this set will be too large to enumerate entirely, so I'll need to sample from it. It would be desirable to be able to write `take samples (permute $ combinations total treated)` where the `permute` function (perhaps with a random seed) properly re-orders the combinations. If these goals are supported by a data structure better than a list, I'm very open to using other types to hold the combinations. I would also appreciate any suggestions on making the code more idiomatic or readable. Thanks, -Mark

1 0

How to use the nice test output spit out by test-framework with "cabal test"?
by Alfredo Di Napoli 18 Mar '13

18 Mar '13

Hi guys, I've been wondering for a long time about how to use the nice terminal-base report spit out from test-framework when I type "cabal test". Atm this is my run-of-the-mill cabal setting: test-suite test-all type: exitcode-stdio-1.0 main-is: Main.hs ghc-options: -w -threaded -rtsopts -with-rtsopts=-N hs-source-dirs: tests [...] but this runs tests using the default cabal interface: Linking dist/build/test-all/test-all ... Running 1 test suites... Test suite test-all: RUNNING... Test suite test-all: PASS Test suite logged to: dist/test/opencv-simple-0.1.0.0-test-all.log 1 of 1 test suites (1 of 1 test cases) passed. This is, instead, what I wanted when I type "cabal test" and "cabal install --enable-tests": http://batterseapower.github.com/test-framework/images/example.png is it possible? Thanks in advance, A.

2 1

Some aggregation of Haskell content
by Christopher Done 18 Mar '13

18 Mar '13

Is there a page somewhere that aggregates all of Haskell's community output into one place? As a consumer of Haskell content I neither have the time nor inclination to follow haskell-cafe and other various mailing lists, the reddits, the google+ community, planet haskell, hackage releases, twitter, youtube and whatever other submission places I haven't heard of. I made this page for the Lojban community some years ago: http://jbotcan.org/hub/ Lojban doesn't have much community activity (tho this doesn't include mailing list posts), but Haskell's community is much larger and more active, it would be far more useful. I may write such a page for Haskell content, if not for the community then at least for myself, as I keep missing out on cool things because I didn't happen to check out that particular medium of exchange. For example, even this message will be lost on a thousand people who doesn't follow the mailing list but maybe follows G+ or reddit. Kind of like a Haskell Weekly news, except more like "Haskell news right now or in some adjustable time frame." And the option to toggle between chronological order or categorized. Ciao!

3 3

haskell infrastruture poll
by Alexander V Vershilov 18 Mar '13

18 Mar '13

Ladies and gentlemen! If you happen to be involved in using/developing haskell-powered software you might like to answer our poll on that matter [1]. Thanks in advance! [1] https://docs.google.com/forms/d/1y5WtrCB7O9-jb-2Mzo1MtkToh4O6oY2oBXGkc_Q-cy… -- Alexander

1 0

MVar which can not be null ?
by s9gf4ult 18 Mar '13

18 Mar '13

Hello, I am looking for MVar which can not be null. I need some kind of thread save atomic IO operation like I can do with modifyMVar, but I want this variable always contain some value and never be null. Thanks.

5 5

Optimization flag changing result of code execution
by Azeem -ul-Hasan 18 Mar '13

18 Mar '13

I was trying to solve a computational problem form James P Sethna's book Statistical Mechanics: Entropy, Order Parameters, and Complexity[1]. The problem is on page 19 of the pdf linked and is titled Six degrees of separation. For it I came up with this code: http://hpaste.org/84114 It runs fine when compiled with -O0 and consistently yields an answer around 10, but with -O1 and -O2 it consistently gives an answer around 25. Can somebody explain what is happening here? [1] http://pages.physics.cornell.edu/~sethna/StatMech/EntropyOrderParametersCom… Azeem

5 7

attoparsec and backtracking
by Evan Laforge 17 Mar '13

17 Mar '13

I have a couple of problems with attoparsec which I think are related to its always backtrack nature, but maybe there's some other way to solve the same problems. The first is that it's hard to get the right error msg out. For instance, I have a parser that tries to parse a number with an optional type suffix. It's an error if the suffix is unrecognized: p_num :: A.Parser Score.TypedVal p_num = do num <- p_untyped_num suffix <- A.option "" ((:"") <$> A.letter_ascii) case Score.code_to_type suffix of Nothing -> fail $ "p_num expected suffix in [cdsr]: " ++ show suffix Just typ -> return $ Score.Typed typ num However, which error msg shows up depends on the order of the (<|>) alternatives, and in general the global structure of the entire parser, because I think it just backtracks and then picks the last failing backtrack. Even after carefully rearranging all the parsers it seems impossible to get this particular error to bubble up to the top. The thing is, as soon as I see an unexpected suffix I know I can fail entirely right there, with exactly that error msg, but since there's no way to turn off backtracking I think there's no way to do that. The second thing is that I want to lex a single token. I thought I could just parse a term and then see how far I got and then use that index to splitAt the input. But attoparsec doesn't keep track of the current index, so I wrote ((,) <$> p_term <*> A.takeByteString), and then I can use the length of the left over bytestring. But due to backtracking, that changes what p_term will parse. Since takeByteString always succeeds, it will cause p_term to backtrack until it finds some prefix that will match. The result is that instead of failing to parse, "1." will lex as ("1", "."). Since I integrate lexing and parsing (as is common with combinator parsers), and since it seems I can't keep track of byte position with attoparsec, I think I'm out of luck trying to do this the easy way. I think I have to write a separate lexer that tries to have the same behaviour as the parser, but is all separate code. I know attoparsec was designed for speed, and error reporting and source positions are secondary. Am I simply asking too much of it? I originally used parsec, but parsing speed is my main bottleneck, so I don't want to give ground there. Is there a clever way to get attoparsec to do what I want? Or a ByteString or Text parser out there which is fast, but can not backtrack, or keep track of input position? I've heard some good things about traditional alex+happy... of course it would mean a complete rewrite but might be interesting. Has anyone compared the performance of attoparsec vs. alex+happy?

5 7

ANNOUNCE: Ajhc 0.8.0.2 Release
by Kiwamu Okabe 17 Mar '13

17 Mar '13

We are happy to announce Ajhc 0.8.0.2. It's first release announce for Ajhc. Major change on this release is ability to compile Haskell code for tiny CPU. There is demo on tiny CPU at https://github.com/ajhc/demo-cortex-m3. And you can watch demo movie at http://www.youtube.com/watch?v=bKp-FC0aeFE. Perhaps changes on the announce will be merged to jhc. Ajhc's project web site is found at http://ajhc.masterq.net/. You can get Ajhc 0.8.0.2 source code from https://github.com/ajhc/ajhc/tags. ## Changes * Fix warning messages on compiling. * Ready to compile with GHC 7.6.2. * New RTS for tiny CPU. How to use: https://github.com/ajhc/demo-cortex-m3#porting-the-demo-to-a-new-platform - - - Metasepi team

3 3

ICFP 2013: Second Call for Papers
by David Van Horn 16 Mar '13

16 Mar '13

===================================================================== 18th ACM SIGPLAN International Conference on Functional Programming ICFP 2013 Boston, MA, USA, 25-27 September 2013 http://www.icfpconference.org/icfp2013 ===================================================================== Important Dates ~~~~~~~~~~~~~~~ Submissions due: Thursday, 28 March 2013 23:59 UTC-11 (Pago Pago, American Samoa, time) Author response: Wednesday, 22 May 0:00 UTC-11 Friday, 24 May 2013 23:59 UTC-11 Notification: Friday, 7 June 2013 Final copy due: Friday, 5 July 2013 Scope ~~~~~ ICFP 2013 seeks original papers on the art and science of functional programming. Submissions are invited on all topics from principles to practice, from foundations to features, and from abstraction to application. The scope includes all languages that encourage functional programming, including both purely applicative and imperative languages, as well as languages with objects, concurrency, or parallelism. Topics of interest include (but are not limited to): * Language Design: concurrency and distribution; modules; components and composition; metaprogramming; interoperability; type systems; relations to imperative, object-oriented, or logic programming * Implementation: abstract machines; virtual machines; interpretation; compilation; compile-time and run-time optimization; memory management; multi-threading; exploiting parallel hardware; interfaces to foreign functions, services, components, or low-level machine resources * Software-Development Techniques: algorithms and data structures; design patterns; specification; verification; validation; proof assistants; debugging; testing; tracing; profiling * Foundations: formal semantics; lambda calculus; rewriting; type theory; monads; continuations; control; state; effects; program verification; dependent types * Analysis and Transformation: control-flow; data-flow; abstract interpretation; partial evaluation; program calculation * Applications and Domain-Specific Languages: symbolic computing; formal-methods tools; artificial intelligence; systems programming; distributed-systems and web programming; hardware design; databases; XML processing; scientific and numerical computing; graphical user interfaces; multimedia programming; scripting; system administration; security * Education: teaching introductory programming; parallel programming; mathematical proof; algebra * Functional Pearls: elegant, instructive, and fun essays on functional programming * Experience Reports: short papers that provide evidence that functional programming really works or describe obstacles that have kept it from working If you are concerned about the appropriateness of some topic, do not hesitate to contact the program chair. Abbreviated instructions for authors ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * By Thursday, 28 March 2013, 23:59 UTC-11 (American Samoa time), submit a full paper of at most 12 pages (6 pages for an Experience Report), including bibliography and figures. The deadlines will be strictly enforced and papers exceeding the page limits will be summarily rejected. * Authors have the option to attach supplementary material to a submission, on the understanding that reviewers may choose not to look at it. * Each submission must adhere to SIGPLAN's republication policy, as explained on the web at http://www.sigplan.org/Resources/Policies/Republication * Authors of resubmitted (but previously rejected) papers have the option to attach an annotated copy of the reviews of their previous submission(s), explaining how they have addressed these previous reviews in the present submission. If a reviewer identifies him/herself as a reviewer of this previous submission and wishes to see how his/her comments have been addressed, the program chair will communicate to this reviewer the annotated copy of his/her previous review. Otherwise, no reviewer will read the annotated copies of the previous reviews. Overall, a submission will be evaluated according to its relevance, correctness, significance, originality, and clarity. It should explain its contributions in both general and technical terms, clearly identifying what has been accomplished, explaining why it is significant, and comparing it with previous work. The technical content should be accessible to a broad audience. Functional Pearls and Experience Reports are separate categories of papers that need not report original research results and must be marked as such at the time of submission. Detailed guidelines on both categories are on the conference web site. Proceedings will be published by ACM Press. Authors of accepted submissions are expected to transfer the copyright to the ACM. Presentations will be videotaped and released online if the presenter consents. Formatting: Submissions must be in PDF format printable in black and white on US Letter sized paper and interpretable by Ghostscript. Papers must adhere to the standard ACM conference format: two columns, nine-point font on a ten-point baseline, with columns 20pc (3.33in) wide and 54pc (9in) tall, with a column gutter of 2pc (0.33in). A suitable document template for LaTeX is available:http://www.acm.org/sigs/sigplan/authorInformation.htm Submission: Submissions will be accepted on the web athttps://www.easychair.org/conferences/?conf=icfp2013 . Improved versions of a paper may be submitted at any point before the submission deadline using the same web interface. Author response: Authors will have a 72-hour period, starting at 0:00 UTC-11 on Wednesday, 22 May 2013, to read reviews and respond to them. Special Journal Issue: There will be a special issue of the Journal of Functional Programming with papers from ICFP 2013. The program committee will invite the authors of select accepted papers to submit a journal version to this issue. General Chair: Greg Morrisett, Harvard University Program Chair: Tarmo Uustalu, Institute of Cybernetics, Tallinn Program Committee: Thorsten Altenkirch, University of Nottingham Olaf Chitil, University of Kent Silvia Ghilezan, University of Novi Sad Michael Hanus, Christian-Albrechts-Universität zu Kiel Fritz Henglein, University of Copenhagen Mauro Jaskelioff, Universidad Nacional de Rosario Alan Jeffrey, Alcatel-Lucent Bell Labs Shin-ya Katsumata, Kyoto University Shriram Krishnamurthi, Brown University John Launchbury, Galois Ryan Newton, Indiana University Sungwoo Park, Pohang University of Science and Technology Sam Staton, University of Cambridge Nikhil Swamy, Microsoft Research, Redmond, WA Dimitrios Vytiniotis, Microsoft Research, Cambridge

1 0

ANNOUNCE: Win32-services
by Michael Steele 16 Mar '13

16 Mar '13

I uploaded a new packaged named Win32-services. This library is a partial binding to the Win32 System Services API. It's now easier to write Windows service applications in Haskell. The hackage page <http://hackage.haskell.org/package/Win32-services> [1] demonstrates simple usage. There are also 2 examples included with the sources. One is a translation of Microsoft's official example. [1]: http://hackage.haskell.org/package/Win32-services -- Michael Steele

2 1

ANN: Monad.Reader Issue 21
by Edward Z. Yang 16 Mar '13

16 Mar '13

I am pleased to announce that Issue 21 of the Monad Reader is now available. http://themonadreader.files.wordpress.com/2013/03/issue21.pdf Issue 21 consists of the following two articles: * "A Functional Approach to Neural Networks" by Amy de Buitléir, Michael Russell, Mark Daly * "Haskell ab initio: the Hartree-Fock Method in Haskell" by Felipe Zapata, Angel J. Alvarez Feel free to browse the source files. You can check out the entire repository using Git: git clone https://github.com/ezyang/tmr-issue21.git If you’d like to write something for Issue 22, please get in touch! Cheers, Edward

1 0