February 2009 - Haskell-Cafe

a newbies confusion with repositories - darcs or git
by Gü?nther Schmidt 17 Mar '09

17 Mar '09

Hi, now that I'm finished with my haskell app I take the opportunity to follow up on some things I hadn't quite understood in my so far short venture into the haskell world. Means: Prepare for a number of naive posts to follow. I had the impression that darcs was the preferred repository for haskellers, but there also is git. So far I've just been using the goodol' svn. But since I have the ambition to become a real haskeller I was gonna make myself acquainted with darcs. Should I skip that and head straight for git? Günther

11 10

Re: Left fold enumerator - a real pearl overlooked?
by John Lato 04 Mar '09

04 Mar '09

Hello Günther, I think the largest reason Haskellers don't use left-fold enumerators is that there isn't a ready-to-use package on Hackage. Oleg's code is extremely well commented and easy to follow, but it's not cabalized. In addition to Takusen, Johan Tibbe's hyena application server uses enumerators for IO: http://github.com/tibbe/hyena/tree/master There is a darcs repo of a cabalized iteratee package available at http://inmachina.net/~jwlato/haskell/iteratee/ This is essentially Oleg's code, slightly modified and reorganized. If anyone is interested in using left-fold enumerators for IO, please give it a look and let me know what you think. I'd like to put this on hackage in about a week or so, if possible. I would especially appreciate build reports. There are a few iteratee/enumerator design questions that remain, which Oleg and others would like to explore more fully. The results of that research will likely find there way into this library. Sincerely, John Lato > Hi all, > > in the last few months I was looking for haskell database library, > eventually settling for HDBC (thanks John btw). > > Takusen also caught my eye although I even failed installing it. > > Nevertheless a particular property of takusen, left-fold-enumerator, > also sparked my interest and I tried to follow it up. > > I had the impression this is something of relevance but something that > is not mentioned or made use of often. There are actually only a few > references on the net and most of those by one person only, Oleg. > > There was one post from John Goerzen about Haskell HTTP libraries in > which he hinted using left-fold enumerators. > > Anyway what I'm saying is that the whole topic is somewhat off the radar > of the larger haskell community, how come, or am I merely overestimating > its relevance and usefulness? > > Günther

12 19

Stacking State on State.....
by Phil 04 Mar '09

04 Mar '09

Hi, I¹ve been teaching myself Monads recently with some success, but I¹ve hit a snag when I tried to look at transformers. I¹m not sure if the problem is my understanding of transformer use at a theoretical level or if I¹m just getting the syntax wrong. If I stick a (hopefully) fairly simple example below, I was wondering if people could comment: Bit of background I have no problem using the State Monad and find it very useful for holding the state or say a homemade random number generator. I written several little bits of code like this: VanDerCorput :: Int-> ( Double, Int ) VanDerCorput state = ( output, state+1 ) where output = reflect state getVanDC :: State Int Double getVanFC = State VanDerCorput This is just holding an incremental state and each time it is evaluated the next number in the Van Der Corput sequence in generated this is just a quasi random sequence the implementation details of the sequence are irrelevant safe to say that the sequence is generated from N=1,2,3,4.....Infinity. The above example is so trivial it can of course be implemented easily in purely functional code by threading the state as a parameter to a pure function and then mapping that function to an ³iterate (+1) 1² statement, but that is not the point of the exercise! The next step of the program is to wrap the above example up in another function which takes the Van Der Corput sequence as input and provides output depending on*it¹s own* state. I¹m passing it to a Box-Muller transform. Very quickly the Box-Muller transform requires TWO inputs from VanDerCourput to produce TWO outputs itself, however we only ever need one at a time, so the Box-Muller transform itself must hold state saying weather it has already saved the 2nd output from a previous call, and thus doesn¹t need to call Van Der Corput this time to produce output it just returns its own state. (P.S. If you know what I¹m doing from a maths point of view please ignore the fact using a 1D Van Der Corput with Box Muller is a very bad idea I know this; I¹m keeping the example simple and Haskell orientated!) In C-like imperative code you¹d could do something like the below not that this is massively elegant, but it shows the case-in-point: Boxmuller() { // The ³outer² states of Box Muller static bool myState = False; static double storedNormal = 0.; // Local copy of current state bool currentState = myState; // State always flips each run myState = not myState; // If we don¹t have a stored value from a previous run if currentState == False { // Generate two new Van Der Corputs this would increment a state in getNextVanDerCorput() twice producing different output each time double rand1 = getNextVanDerCorput(); double rand2 = getNextVanDerCorput(); // Store one result for the NEXT run of Boxmuller() storedNormal = SOME_TRANSFORM(rand2); // Return the other return SOME_TRANSFORM(rand1); } // We have a leftover value from a previous run get a local copy double currentNormal = storedNormal; // Reset the stored value to zero storedNormal = 0.; // Return the local copy of the stored value return currentNormal; } getNextVanDerCorput() { // Starting state state int n = 1; int currentState = n; // Incremented each time we call the function ++n; // Value computed on the internal state of this function return SOME_OTHER_TRANSFORM(currentState); } Right, hopefully that explains explicitly what I¹m trying to do apologies for dropping into C, it¹s easier to explain in code than in words. It struck me that this could be done using a plain and simple State Monad in Haskell carrying ALL states for both functions around in a tuple. This is pretty ugly tho, and I figure both BoxMuller and VanDerCorput should have their own internal states so they can be used as building blocks in other functionality too so one big ugly Monad is bad code design, even if it would work for this specific example. Let¹s not go there. The VanDerCorput building block is just the Monad at the start of this post. The problem is HOW DO I WRAP ANOTHER INDEPENDENT STATE AROUND THIS? After some googling it looked like the answer may be Monad Transformers. Specifically we could add a StateT transform for our Box Muller state to our VanDerCorput State Monad. Google didn¹t yield a direct answer here so I¹m not even sure if my thinking is correct, people describe the process of using a transform as wrapping one monad in another¹ or threading one monad into another¹. What we want to do is have some internal state controlled by an independent outer state - this sounds about right to me? So I started playing around with the code, and got the below to compile. test :: StateT (Bool,Double) (State Int) Double test = do (isStored,normal) <- get let (retNorm,storeNorm) = if isStored then (normal,0) else (n1,n2) where n1 = 2 n2 = 3 put (not isStored, storeNorm) return retNorm Now this is incomplete and may be even wrong! I¹ll Explain my thinking: (Bool,Double) is equivalent to myState and storedNormal in the C example The last Double is the return value of the BoxMuller Monad The (State Int) is supposed to represent the VanDerCorput monad but the compiler (GHC 6.10) will only let me specify one parameter with it so I¹ve put the state and left the return type to the gods!!.... As I said this isn¹t quite right any ideas how to specify the type? The next few lines get and test the BoxMuller state, this seems to work OK to me, the problem is when I try to look at the STATE OF THE INTERNAL monad. n1 and n2 should evaluate and increment the state of VanDerCorput monad but I can¹t get anything to compile here. 2 and 3 are just dummy values to make the thing compile so I could debug. My last gripe is how to actually call this from a pure function do I need to use both evalStateT and evalState I can¹t see how to initialize both the inner and outer state ? OK I think that¹s more than enough typing, apologies for the war&peace sized post. Any help muchly muchly appreciated, Many Thanks, Phil.

4 17

Status of Haskell under OsX
by Cristiano Paris 03 Mar '09

03 Mar '09

Hi, I'm planning to purchase a MacBookPro so I'm wondering how well Haskell is supported under this platform. Thanks, Cristiano

10 16

Hidden module?
by Cristiano Paris 02 Mar '09

02 Mar '09

Cabalising hsc2hc I get (this is actually from manually building the package): --- [paris@bagend hsc2hs-0.67.20061107]$ runghc Setup.hs build Preprocessing executables for hsc2hs-0.67.20061107... Building hsc2hs-0.67.20061107... Main.hs:32:7: Could not find module `System.Process': it is a member of package process-1.0.1.0, which is hidden [paris@bagend hsc2hs-0.67.20061107]$ which I cannot understand. Please help! --- Cristiano

5 7

ANNOUNCE: text and text-icu, fast and comprehensive Unicode support using stream fusion
by Bryan O'Sullivan 02 Mar '09

02 Mar '09

On behalf of the Data.Text team, I am delighted to announce the release of preview versions of two new packages: text 0.1 Fast, packed Unicode text support, using a modern stream fusion framework. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/text text-icu 0.1 Augments text with comprehensive character set conversion support and normalization (and soon more), via bindings to the ICU library. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/text-icu These packages fill out critical pieces of functionality for the Haskell platform, without compromising on either performance or safety. We are referring to these as *preview* releases because although the text package in particular has been quite heavily tested, it has not been thoroughly tuned, and we have not yet implemented a chunked lazy text representation suitable for streaming gigabytes of data. The APIs are pretty conventional, but are still subject to change. If you want to contribute, please get copies of the source trees from here: darcs get http://code.haskell.org/text darcs get http://darcs.serpentine.com/text-icu Please send bug reports and patches to your friendly Data.Text team: Tom Harper <rtharper(a)aftereternity.co.uk> Duncan Coutts <duncan.coutts(a)worc.ox.ac.uk> Bryan O'Sullivan <bos(a)serpentine.com>

4 9

Left fold enumerator - a real pearl overlooked?
by Gü?nther Schmidt 02 Mar '09

02 Mar '09

Hi all, in the last few months I was looking for haskell database library, eventually settling for HDBC (thanks John btw). Takusen also caught my eye although I even failed installing it. Nevertheless a particular property of takusen, left-fold-enumerator, also sparked my interest and I tried to follow it up. I had the impression this is something of relevance but something that is not mentioned or made use of often. There are actually only a few references on the net and most of those by one person only, Oleg. There was one post from John Goerzen about Haskell HTTP libraries in which he hinted using left-fold enumerators. Anyway what I'm saying is that the whole topic is somewhat off the radar of the larger haskell community, how come, or am I merely overestimating its relevance and usefulness? Günther

4 4

A foray into type-level programming, and getting stuck
by George Pollard 02 Mar '09

02 Mar '09

Okay, so I've written a small library to generalize 'fst' and 'snd' to arbitrary tuples, but I'd like to extend it a bit. I'm using the type-level library to do the thinking :) Imports and defines first: > {-# LANGUAGE UnicodeSyntax, MultiParamTypeClasses, > FunctionalDependencies, FlexibleInstances, FlexibleContexts, > UndecidableInstances, DeriveDataTypeable, OverlappingInstances, > ScopedTypeVariables #-} > import Prelude hiding ((-),Eq) > import qualified Prelude as P > import Data.TypeLevel.Num.Sets > import Data.TypeLevel.Num.Reps > import Data.TypeLevel.Num.Aliases > import Data.TypeLevel.Bool > import Data.TypeLevel.Num.Ops > import Data.Typeable I start by requiring that if you can access element 'n', you should be able to access element 'n-1'. > class (ImplementsPrev t n a) ⇒ Nthable t n a | t n → a where > nth ∷ n → t → a > > class (Pos n) ⇒ ImplementsPrev t n a > instance (Pred n n', Nthable t n' a') ⇒ ImplementsPrev t n a > instance ImplementsPrev t D1 a So, this is a simple induction. Testing it with the nthable instances confirms that it works; removing either of the first two lines stops the code from compiling, hurrah! > instance Nthable (a,b,c) D1 a where nth _ (a,_,_) = a > instance Nthable (a,b,c) D2 b where nth _ (_,b,_) = b > instance Nthable (a,b,c) D3 c where nth _ (_,_,c) = c Now, I have heard talk/suggestions of revamping tuples in Haskell to a more flexible system. Perhaps we would like to do it like this (modulo strictness annotations): > data (Nat n) ⇒ Tuple n a b = Tuple a b > deriving (Show,Read,Typeable,P.Eq,Ord) > infixr 0 `comma` > -- comma :: a -> (b ~> c) -> (a ~> (b ~> c)) -- to investigate > comma ∷ (Succ n n') ⇒ a → Tuple n b c → Tuple n' a (Tuple n b c) > x `comma` y = Tuple x y > empty ∷ Tuple D0 () undefined > empty = Tuple () undefined Thus, we can create, e.g. (1 `comma` 2 `comma` empty). Now, I'd like to be able to write Nthable instances, so I start with the base case: > instance (n :>=: D1) ⇒ Nthable (Tuple n a b) D1 a where > nth _ (Tuple a _) = a This works well. However, I am really stuck on the instance for the inductive case. My first idea was this: > instance (Pred x x', Nthable b x' r) ⇒ Nthable (Tuple n a b) x r where > nth _ (Tuple _ b) = nth (undefined ∷ x') b But this doesn't work, muttering about IncoherentInstances and hidden datatypes from the type-level library. So, I turn to Haskell café for help :)

3 3

Take a break: write an essay for Onward! Essays
by Simon Peyton-Jones 02 Mar '09

02 Mar '09

Friends Writing papers is fun, we mostly only get to write one *kind* of paper. Here is an opportunity to write something in a totally different style: Submit an essay to Onward! Essays Deadline: 20 April 2009 http://onward-conference.org/calls/foressays An Onward! essay is a thoughtful reflection upon software-related technology. Its goal is to help the reader to share a new insight, engage with an argument, or wrestle with a dilemma. A successful essay is a clear and compelling piece of writing that explores a topic important to the software community. The subject area should be interpreted broadly, including the relationship of software to human endeavours, or its philosophical, sociological, psychological, historical, or anthropological underpinnings. An essay can be an exploration of its topic, its impact, or the circumstances of its creation; it can present a personal view of what is, explore a terrain, or lead the reader in an act of discovery; it can be a philosophical digression or a deep analysis. It can describe a personal journey, perhaps that by which the author reached an understanding of such a topic. I'm the program chair, and I'd love to get submissions from the POPL/ICFP/types community. Reflections on programming languages, types, testing, verification, software engineering, compilers, society, ... you name it. Anything to do with software. NB: Onward! is co-located with OOPSLA, but they are otherwise unrelated. OO is fine, but not required. Don't forget: 20th April. Simon PS: To get your imagination going, here are a couple of (strongly-contrasting) past essays: * Dan Grossman "The transactional memory / garbage collection analogy" http://www.cs.washington.edu/homes/djg/papers/analogy_oopsla07.pdf * Dick Gabriel "Designed as designer" http://dreamsongs.org/DesignedAsDesigner.html

2 1

Supplying a default implementation for a typeclass based on another class
by Svein Ove Aas 02 Mar '09

02 Mar '09

I'm in the process of writing a distributed filesystem (in haskell, yay), which of course means I'm using Binary for de/serialization. Now, that's fine enough, but for simplicity (and for wireshark), I'd like to be able to have Binary fall back on an instance based on Show/Read for any type that lacks any other Binary instance.. Well, I understand why this would be somewhere between extremely hard and impossible in haskell '98, but I'm not entirely up on all the extensions, so I thought I'd ask - given every extension implemented in ghc 6.10.1, is there any reasonable way to do this?

6 7