- Haskell-Cafe - Haskell.org

Stack traces in GHC
by Mihai Maruseac 15 Sep '10

15 Sep '10

Hi, Just did a preview of bug #3693 [1] and saw that there are a few patches issued there. Does this mean that the problem is solved and there would be stack traces in a future version of GHC? I'll test the patches in 24 hours, when I'll be back at home. -- Mihai [1]: http://www.khronos.org/webgl/wiki/Tutorial

2 2

CAL experience
by Karel Gardas 15 Sep '10

15 Sep '10

Hello, as this is really friendly forum, I'd like to ask to perhaps solve my wonder. From time to time I'm seeing people here recommending Scala as a kind of replacement for non-existent Haskell on Java/JVM platform. My wonder is: why the people here do not recommend CAL, which at least to me, looks much more closer to Haskell than Scala is. Are there any bad experiences with this language and OpenQuark platform? I'm asking since I'm currently playing with it and plan to use it for java objects data processing. Thanks, Karel

3 2

copy of boost graph library
by Thomas Bereknyei 15 Sep '10

15 Sep '10

I was looking around and liked some of the ways that Boost organizes its libraries. So it got me thinking that it might be easy to use the same for a Haskell graph library. This IS NOT FGL, but does include some elements of it at the end (InductiveGraph). Mostly what I like, is that it presents a (somewhat) logical sequence of operations for a graph writer to implement, getting a few freebies along the way. There aren't too many extensions or complications. The most odd thing is the way I arranged the types. A quick look at some typesigs should clear up confusion, but: Node g is the entire node, eg (Int,a) NodeIndex is just the index eg Int NodeLabel is just the label eg. a the same for edge. I'm just fishing for ideas and opinions, and whether or not this seems simpler to use. http://codepad.org/UXUL7LZv {-# LANGUAGE TypeFamilies ,FlexibleContexts #-} --TODO: Visitors? DFF searches import qualified Data.IntMap as I import Data.List (find,unfoldr,foldl') import Data.Maybe (fromJust) import Control.Arrow (second) class Graph g where type NodeIndex g type EdgeIndex g type Node g --The entire node, including index, any labels and/or data. type Edge g --ditto node_index :: g -> Node g -> NodeIndex g edge_index :: g -> Edge g -> EdgeIndex g empty :: g isEmpty :: g -> Bool mkGraph :: [Node g] -> [Edge g] -> g class Graph g => DirectionalGraph g where edges_out :: g -> NodeIndex g -> [Edge g] source , target :: g -> EdgeIndex g -> Node g degree_out :: g -> NodeIndex g -> Int degree_out = length ... edges_out class DirectionalGraph g => BidirectionalGraph g where edges_in :: g -> NodeIndex g -> [Edge g] edges_both :: g -> NodeIndex g -> [Edge g] edges_both g n = edges_out g n ++ edges_in g n degree_in :: g -> NodeIndex g -> Int degree_in = length ... edges_in degree :: g -> NodeIndex g -> Int degree g n = degree_out g n + degree_in g n class Graph g => AdjacencyGraph g where nodes_out,nodes_in,nodes_both :: g -> NodeIndex g -> [NodeIndex g] class Graph g => VertexGraph g where nodes :: g -> [Node g] node :: g -> NodeIndex g -> Maybe (Node g) hasNode :: g -> NodeIndex g -> Bool hasNode g n = maybe False (const True) (node g n) order :: g -> Int order = length . nodes class Graph g => EdgeGraph g where edges :: g -> [Edge g] edge :: g -> EdgeIndex g -> Maybe (Edge g) hasEdge :: g -> EdgeIndex g -> Bool hasEdge g e = maybe False (const True) (edge g e) size :: g -> Int size = length . edges class Graph g => MutableGraph g where insert_node :: Node g -> g -> g --if preexists, update remove_node :: NodeIndex g -> g -> g insert_edge :: Edge g -> g -> g --if preexists, update remove_edge :: EdgeIndex g -> g -> g class Graph g => PropertyGraph g where type NodeLabel g type EdgeLabel g node_label :: Node g -> NodeLabel g edge_label :: Edge g -> EdgeLabel g node_labelize :: NodeIndex g -> NodeLabel g -> Node g edge_labelize :: EdgeIndex g -> EdgeLabel g -> Edge g get_node_label :: g -> NodeIndex g -> NodeLabel g get_edge_label :: g -> EdgeIndex g -> EdgeLabel g class (VertexGraph g,BidirectionalGraph g,MutableGraph g) => InductiveGraph g where data Context g edgesInC :: Context g -> [Edge g] nodeC :: Context g -> Node g edgesOutC :: Context g -> [Edge g] make_context :: [Edge g] -> Node g -> [Edge g] -> Context g --minimum definition is match or context, but default works too context :: g -> NodeIndex g -> Maybe (Context g) --context = fmap fst ... match context g n = do foundNode <- node g n return $ make_context (edges_in g n) foundNode (edges_out g n) match :: g -> NodeIndex g -> Maybe (Context g,g) match g n = fmap (flip (,) $ remove_node n g) $ context g n insert :: Context g -> g -> g insert c g = foldr insert_edge g'' (edgesOutC c) where g' = insert_node (nodeC c) g g'' = foldr insert_edge g' (edgesInC c) toContexts :: g -> [Context g] toContexts g = unfoldr matchIt (g, map (node_index g) $ nodes g) where matchIt (_, []) = Nothing matchIt (g', (n:ns)) = fmap (second (flip (,) ns)) $ match g n fromContexts :: [Context g] -> g fromContexts = foldr insert empty adjust :: (Context g -> Context g) -> NodeIndex g -> g -> g adjust f n g = maybe g (uncurry (insert . f)) $ match g n gfoldr :: (Context g -> b -> b) -> b -> g -> b gfoldr f i = foldr f i . toContexts gfoldl' :: (b -> Context g -> b) -> b -> g -> b gfoldl' f i = foldl' f i . toContexts gfilter :: (Context g -> Bool) -> g -> g gfilter f = fromContexts . filter f . toContexts class (InductiveGraph g) => MappableGraph g where gmap :: InductiveGraph g' => (Context g -> Context g') -> g -> g' gmap f = fromContexts . map f . toContexts nmap :: (InductiveGraph g,Edge g ~ Edge g) => (Node g -> Node g) -> g -> g nmap f = gmap f' where f' c = make_context (edgesInC c) (f $ nodeC c) (edgesOutC c) emap :: ( InductiveGraph g', Node g ~ Node g') => (Edge g -> Edge g') -> g -> g' emap f = gmap f' where f' c = make_context (map f $ edgesInC c) (nodeC c) (map f $ edgesOutC c)

2 1

Question on concurrency
by Arnaud Bailly 14 Sep '10

14 Sep '10

Hello Haskellers, Having been pretty much impressed by Don Stewart's "Practical Haskell" (http://donsbot.wordpress.com/2010/08/17/practical-haskell/) I started to write a Haskell script to run maven jobs (yes, I know...). In the course of undertaking this fantastic endeavour, I started to use the System.Process.readProcessWithExitCode function, but following the advice in the comment for this function, I rolled my own stuff and ended up writing the following: > doRunMvnInIO pom args filters e > = do (Just inh, Just outh, Just errh, pid) <- > createProcess (proc (maven e) (["-f", pom] ++ args)) { std_in = CreatePipe, > std_out = CreatePipe, > std_err = CreatePipe } > waitQ <- newEmptyMVar > > mapM (printAndWait waitQ) [outh, errh] > > hClose inh > -- wait on the process > waitForProcess pid > where > printAndWait waitQ hdl = do out <- hGetContents hdl > forkIO (mapM (putStrLn) (filter filters $ lines out) >> putMVar waitQ ()) > takeMVar waitQ > hClose hdl This is actually a rewrite of the following function: > doRunMvnInIO' pom args filters e > = do (Just inh, Just outh, Just errh, pid) <- > createProcess (proc (maven e) (["-f", pom] ++ args)) { std_in = CreatePipe, > std_out = CreatePipe, > std_err = CreatePipe } > waitQ <- newEmptyMVar > > mapM (printAndWait waitQ) [outh, errh] >>= mapM (\_ -> takeMVar waitQ) > > hClose inh > hClose outh > hClose errh > -- wait on the process > waitForProcess pid > where > printAndWait waitQ hdl = do out <- hGetContents hdl > forkIO (mapM (putStrLn) (filter filters $ lines out) >> putMVar waitQ ()) What surprised me is that I would expect the behaviour of the two functions to be different: - in doRunMvnInIO, I would expect stdout's content to be printed before stderr, ie. the 2 threads are ordered because I call takeMVar in between calls to forkIO - in doRunMvnInIO', this is not true and both theads run concurrently. but actually there does not seem to be a difference: printing is still interleaved in both functions, AFAICT. I would welcome any help on this. Best regards, Arnaud

2 2

Differences with Hayoo and Hoogle: Searching For Monoids
by aditya siram 14 Sep '10

14 Sep '10

Hi all, I was trying to read the documentation on monoids and the Sum type. When I searched Hayoo for "Monoid" or "Data.Monoid", the Data.Monoid module in "base" did not show up - Hoogle found it without a problem. The same goes for the "Sum" type, Hayoo does not seem to find it but Hoogle does. -deech

2 1

Haddock again
by Andrew Coppin 14 Sep '10

14 Sep '10

Some time ago (I can't find the thread now), I wrote about the fun and games I had with Haddock. After much experimentation, I have discovered that if you have a sufficiently new version of cabal-install, the configuration file has a field entitled "document-index:" or similar. If you uncomment this and use its default value, you get a documentation index generated for you. But ONLY if you do a user-install, not a global-install, for reasons beyond my comprehension. (I swear to God I got it to work with global installs one time...) Also, I commented that the links generated were broken, but it appears that if you have a sufficiently new version of Haddock, the links work just fine. (In other words, this particular bug is already fixed.) Finally, I notice that the master index links to the packages, but the packages do not link back. So it is impossible to navigate back to the master index other than using the browser's "back" button. This particular limitation seems to be present even in the shiny new release of Haddock. Really finally: It seems that all of Hackage has been redone using the new Haddock. Wow, that was quick...

1 2

Fwd: Type families - how to resolve ambiguities?
by Paolo Giarrusso 13 Sep '10

13 Sep '10

On Aug 25, 11:22 pm, Dan Doel <dan.d...(a)gmail.com> wrote: > On Wednesday 25 August 2010 5:05:11 pm DavidA wrote: > > The code below defines a type synonym family: > > > {-# LANGUAGE MultiParamTypeClasses, TypeFamilies #-} > > {-# LANGUAGE FlexibleInstances, TypeSynonymInstances #-} [snip] > The problem with mult is that k is not specified unambiguously. You either > need v to determine k (which is probably not what you want, at a guess), mult > to take a dummy argument that determines what k is: [...] > or, to make Tensor a data family instead of a type family. What is the difference making it work? However, it would make more sense to have it be a type family, without the overhead of data (both in space and in typing). Is there a non- hacky approach, without dummies and without making Tensor a data family without a semantic need? I am having a similar problem with the vector package, with the Data.Vector.Generic.Mutable module, because of the PrimState type family. How am I expected to best solve this? This function is easy to write: fillVector n elems = do arr <- VectorGM.new n VectorG.copy arr $ VectorG.fromList elems return arr However, what I have below is not easy to write for me - some specific type annotations are needed. Interestingly, I needed to annotate a statement rather than the return value, because unifying PrimState IO and PrimState m fails, rather than producing m = IO. While I managed to make them work, it looks like type inference is not helping much - the code seems more complicated to properly type-annotate than it would be in a language with just typechecking. V1, not generic - it works for arrays of integers: fillSortVector n elems = do arr <- VectorGM.new n :: IO (VectorU.MVector (PrimState IO) Int) -- I can't annotate just arr, I need to annotate the IO action! -- arr :: (VectorU.MVector (PrimState IO) Int) <- VectorGM.new n -- doesn't compile! let arrI :: VectorU.Vector Int = VectorG.fromList elems VectorG.copy arr arrI (timing, _) <- timed $ VectorI.sort arr return timing V2, almost fully generic - but not in the array types (that was even more complicated IIRC): fillSortVector :: forall a. (Ord a, VectorG.Vector VectorU.Vector a, VectorGM.MVector VectorU.MVector a) => Int -> [a] -> IO Double fillSortVector n elems = do arr <- VectorGM.new n :: IO (VectorU.MVector (PrimState IO) a) -- I can't annotate just arr, I need to annotate the IO action! -- arr :: (VectorU.MVector (PrimState IO) a) <- VectorGM.new n -- doesn't compile! let arrI :: VectorU.Vector a = VectorG.fromList elems VectorG.copy arr arrI (timing, _) <- timed $ VectorI.sort arr return timing Best regards Paolo G. Giarrusso -- PhD student

3 2

Data.Text performance problem
by Petr Prokhorenkov 13 Sep '10

13 Sep '10

I experienced a following problem while dealing with some text processing. I have a text and want to get the same text with parts enclosed into {} or [] stripped away. Substituting them with a ' ' would also work. Here is the code I wrote (T is Data.Text): stripBrackets :: T.Text -> T.Text stripBrackets text = snd $ T.mapAccumL f 0 text where f depth c = let depth' = depth + d' c c' | depth > 0 || depth' > 0 = ' ' | otherwise = c in (depth', c') d' '{' = 1 d' '[' = 1 d' '}' = -1 d' ']' = -1 d' _ = 0 The only problem is that it takes about a minute to complete on 3GHz+ processor when text is a 30k chars long. Any ideas how to improve this code? -- Regards, Petr

4 5

Interruptable event loop
by Mitar 13 Sep '10

13 Sep '10

Hi! I have X11 code which looks something like the following. The problem is that TimerInterrupt gets sometimes thrown in a way that it kills the whole main thread. Probably it gets thrown in the middle of some nested function which unblocked exceptions. I found: http://hackage.haskell.org/trac/ghc/ticket/1036#comment:4 but this is not yet in GHC stable version. Is there some workaround for this? Because I have problems compiling current Haskell platform with GHC head. currentThread <- myThreadId _ <- forkIO $ timer currentThread block $ run display run display = do ... allocaXEvent $ \event -> do interrupted <- catch (unblock $ nextEvent' display event >> return False) (\(_ :: TimerInterrupt) -> return True) ... run display -- A version of nextEvent that does not block in foreign calls nextEvent' :: Display -> XEventPtr -> IO () nextEvent' d p = do pend <- pending d if pend /= 0 then nextEvent d p else do threadWaitRead (fromIntegral . connectionNumber $ d) nextEvent' d p data TimerInterrupt = TimerInterrupt deriving (Show, Typeable) instance Exception TimerInterrupt timer :: ThreadId -> IO () timer t = do threadDelay redrawInterval throwTo t TimerInterrupt timer t Mitar

1 1

ANN: ecu-0.0.0
by Tom Hawkins 13 Sep '10

13 Sep '10

This package is a collection of programs that we use at Eaton to interact with, debug, and analyze data from vehicle ECUs (Electronic Control Unit: automotive speak for an embedded computer). The motivation to put this stuff on hackage is to encourage the use of Haskell in automotive electronics and to help standardize open data formats and protocols -- the most common formats and protocols in this industry are proprietary. (The other motivation for hackage is it makes it easy for us to distribute tool updates to our engineers and technicians in the field. :-) ) Most of these programs in this package read or write data on a CAN bus. At work we use Kvaser CAN cables, so these tools link in Kvaser's open source CAN driver library, canlib. However, we anticipate adding several tools that have nothing to do with CAN -- they could be general data analysis programs that could be applicable to other fields, not just automotive. My question is, is it possible for a user to select which programs to install within a given package? I could see where someone would want to install a data analysis tool, but not want to bother with separately installing Kvaser canlib. I had considered different packages for the individual tools, but that would get messy pretty quick, especially since many tools share a lot of common code. Another question: Can we get a Hackage category specifically for the use of Haskell in embedded systems? I didn't see anything that stood out. And one last question: The Kvaser canlib library has a different name depending on if the machine is Linux or Windows. What is the best way to configure the build based on the platform? Current I have the library name hard coded in the extra-libraries field in the cabal file. -Tom http://hackage.haskell.org/package/ecu http://github.com/tomahawkins/ecu

5 6

Disable LINE Pragma handling in GHC
by JP Moresmau 13 Sep '10

13 Sep '10

Hello fellow Haskellers, In EclipseFP we use the GHC API for IDE related stuff like syntax highlighting and code outlines. However, I ran into something funny yesterday: when a source file contains LINE pragmas ( http://www.haskell.org/ghc/docs/6.12.2/html/users_guide/pragmas.html#line-p…) all the locations for tokens are changed to reflect the pragmas information. While this is great in the "normal' GHC usage, this is not so great for us, because we're interested in that source code, not in original code. I haven't seen any flag to turn that behavior off in the docs, nor in the Lexer code, but have I missed something? Can I tell GHC to just ignore these pragmas? I suppose even using GHC for building and something else (haskell-src-exts?) for code handling would leave us with compilation messages at the wrong place. Thanks, -- JP Moresmau http://jpmoresmau.blogspot.com/

5 7

Subcategories in Hackage
by Daniel Díaz 13 Sep '10

13 Sep '10

Hi, all! Now, with the approaching new Hackage server, I thought that to organize packages into subcategories would be useful. Categories like "System" or "Text", with almost 200 packages, make more difficult to find what you want. "Data" category has currently 326 packages, many of them with very different roles. Perhaps, this is madness, but I wanted to read other opinions on this topic. -- Daniel Díaz

3 3

darcs in 2010: talk/video online
by Eric Kow 12 Sep '10

12 Sep '10

Dear Haskellers, Derek asked me if I could give a 5 minute talk at AngloHaskell last Friday about the Darcs project. It took an hour and a half. I've redone the talk on YouTube, basically just stepping through the slides and talking over them. It's about an hour long and you can watch it here: http://www.youtube.com/watch?v=iUytayyTGTU You may also prefer to just zoom through the slides yourself (about 10 minutes): http://prezi.com/is5nzudw8jxq/darcs-in-2010/ Many thanks to Derek for organising the AngloHaskell event and for thinking hard about how to make it work better! Thanks also to the Darcs hackers who did the actual work behind this talk, and to the user community for all your support and feedback. Eric PS: the talk segments are: 1. http://www.youtube.com/watch?v=iUytayyTGTU 2. http://www.youtube.com/watch?v=ZXjTmWD81JA 3. http://www.youtube.com/watch?v=1lXOD3fLwU8 4. http://www.youtube.com/watch?v=aueSoZShobo 5. http://www.youtube.com/watch?v=-JxJKMSRmBY 6. http://www.youtube.com/watch?v=zdImEqRmw7I -- Eric Kow <http://www.nltg.brighton.ac.uk/home/Eric.Kow> For a faster response, try +44 (0)1273 64 2905 or xmpp:kowey@jabber.fr (Jabber or Google Talk only)

1 1

ANNOUNCE: GotoT-transformers version 1.0
by Gregory Crosswhite 12 Sep '10

12 Sep '10

People want to believe that Haskell is a better language than C, but how could this possibly be true when Haskell lacks the very basic "goto" feature??? If the world is going to take Haskell seriously, then this serious blight needs to be addressed immediately! Thus I proud to present to you the "GotoT-transformers" package which provides this missing functionality and so finally makes Haskell a serious contender with C. On a more serious note, there are times when it can be useful to not only abort a computation in the middle, but to then transfer the flow of execution to another computation: do [...stuff...] when condition1 $ goto x [...more stuff...] when condition2 $ goto y [...more stuff...] when condition3 $ goto z Towards this end, I developed this package which provides a GotoT monad transformer and a "goto" function that takes a monadic computation and returns a monadic value that has the effect of transferring control to the new computation. Obviously this functionality can be abused, but when it is the natural fit I believe that it is much better to use it directly then to go through all sorts of contortions resulting in uglier code just to avoid it on principle. The best implementation I could think of was to use a "trampoline" approach. The GotoT monadic transformer is represented by a type which contains (wrapped inside the inner monad) either a pure value or a monadic computation. The runGotoT function operates by returning the value if it is pure, and evaluating the monadic computation and feeding the result back into itself otherwise. The "trampoline" term refers to the fact that the flow of execution bounces back to the runGotoT function as long as the computation keeps calling the "goto" function. I hope that the community not only finds this functionality useful, but also that does not kill me for committing the egregious act of bringing "goto" into the Haskell world. Cheers, Greg

4 13

Cost: (:) vs head
by michael rice 12 Sep '10

12 Sep '10

Which of these would be more costly for a long list? f :: [Int] -> [Int] f [x] = [x] f (x:xs) = x + (head xs) : f xs f :: [Int] -> [Int] f [x] = [x] f (x:y:xs) = x + y : f (y:xs) Michael

6 10

Small question on concurrency
by Arnaud Bailly 12 Sep '10

12 Sep '10

Hello Haskellers, Having been pretty much impressed by Don Stewart's "Practical Haskell" (http://donsbot.wordpress.com/2010/08/17/practical-haskell/) I started to write a Haskell script to run maven jobs (yes, I know...). In the course of undertaking this fantastic endeavour, I started to use the System.Process.readProcessWithExitCode function, but following the advice in the comment for this function, I rolled my own stuff and ended up writing the following: > doRunMvnInIO pom args filters e > = do (Just inh, Just outh, Just errh, pid) <- > createProcess (proc (maven e) (["-f", pom] ++ args)) { std_in = CreatePipe, > std_out = CreatePipe, > std_err = CreatePipe } > waitQ <- newEmptyMVar > > mapM (printAndWait waitQ) [outh, errh] > > hClose inh > -- wait on the process > waitForProcess pid > where > printAndWait waitQ hdl = do out <- hGetContents hdl > forkIO (mapM (putStrLn) (filter filters $ lines out) >> putMVar waitQ ()) > takeMVar waitQ > hClose hdl This is actually a rewrite of the following function: > doRunMvnInIO' pom args filters e > = do (Just inh, Just outh, Just errh, pid) <- > createProcess (proc (maven e) (["-f", pom] ++ args)) { std_in = CreatePipe, > std_out = CreatePipe, > std_err = CreatePipe } > waitQ <- newEmptyMVar > > mapM (printAndWait waitQ) [outh, errh] >>= mapM (\_ -> takeMVar waitQ) > > hClose inh > hClose outh > hClose errh > -- wait on the process > waitForProcess pid > where > printAndWait waitQ hdl = do out <- hGetContents hdl > forkIO (mapM (putStrLn) (filter filters $ lines out) >> putMVar waitQ ()) What surprised me is that I would expect the behaviour of the two functions to be different: - in doRunMvnInIO, I would expect stdout's content to be printed before stderr, ie. the 2 threads are ordered because I call takeMVar in between calls to forkIO - in doRunMvnInIO', this is not true and both theads run concurrently. but actually there does not seem to be a difference: printing is still interleaved in both functions, AFAICT. I would welcome any help on this. Best regards, Arnaud

1 0

Re: Haskell web developer position at CREATE-NET
by Chris Done 12 Sep '10

12 Sep '10

Here at CREATE-NET, a research center located in Trento, Italy, we have a position open for a web developer. The following are essential: 1. Experience writing standard-compliant, semantic and accessible web documents with (X)HTML/CSS2. 2. Strong JavaScript experience. 3. Experience with cross-browser (IE7-8/Firefox/Chrome/Safari/Opera) development, and dealing with or avoiding the inevitable IE quirks -- we do not maintain for IE6. 4. Strong Haskell and/or Common Lisp development experience (preferably both). 5. English language fluency (spoken and written) is essential, as are good writing and oral communication skill. 6. Qualified to work in Europe. PostgreSQL experience advantageous. Must be willing to re-locate in order to work in the Trento CREATE-NET buildings. We offer competitive compensation and a stimulating work environment in the research and innovation sector. Please provide examples of your web development work and Haskell/Common Lisp projects with a brief explanation for each or link for it. Submit your application to: itjobs(a)create-net.org Skiing and snowboarding is popular here in the winter. ;-) Cheers, Chris Done CREATE-NET P.S. Note that although we are a research center, this opening is for a developer position, not research. You are welcome to write papers but this cannot be your main activity.

1 0

Trying to compile Glade Gtk2Hs demo / cabal install glade problem
by Peter Schmitz 12 Sep '10

12 Sep '10

(I am posting this to Cafe and Gtk2Hs Users; if you subscribe to both, please reply to Cafe; but I will see your replies either place; thanks much.) I am trying to compile the Gtk2Hs demo program GladeTest.hs (located in the ...\demo\glade dir), under MS Windows XP. The error I get is: H:\proc\tools\Gtk2Hs\demo\glade>ghc --make GladeTest.hs GladeTest.hs:4:7: Could not find module `Graphics.UI.Gtk.Glade': (--Note:-- I am using H: instead of C: for reasons described later.) I did these okay: cabal install cabal-install cabal update cabal install gtk2hs-buildtools cabal install gtk and I can compile and run some other Gtk2Hs demos (that do not use Glade) okay. In general, I am assuming that I need to "cabal install foo" when Haskell module foo cannot be found during compile. (Please correct me if I am wrong.) I get an error during the glade install: H:\proc\dev\cmd>cabal install glade ... Configuring glade-0.11.1... setup.exe: The pkg-config package libglade-2.0 version >=2.0.0 is required but it could not be found. ... (the full output is listed below) I think I have package libglade-2.0 installed, because I installed the GTK+ and Glade bundle from: http://ftp.gnome.org/pub/GNOME/binaries/win32/glade3/3.6/glade3-3.6.7-with-… at: http://ftp.gnome.org/pub/GNOME/binaries/win32/glade3/3.6/ at: http://glade.gnome.org/ That install created tree: H:\proc\tools\Gtk+\ which includes these: H:\proc\tools\Gtk+\include\libglade-2.0\ and H:\proc\tools\Gtk+\glade-3.exe H:\proc\tools\Gtk+\bin\libglade-2.0-0.dll H:\proc\tools\Gtk+\lib\libglade-2.0.a H:\proc\tools\Gtk+\lib\pkgconfig\libglade-2.0.pc So, I'm thinking maybe my install of Gtk+ (just running glade3-3.6.7-with-GTK+.exe) was lacking somehow, or cabal somehow doesn't see my Gtk+ dir (during "cabal install glade") ? So, I tried editing my cabal config so it would see my Gtk+ tree. I uncommented and edited these lines in the main, un-indented section: extra-include-dirs: H:\proc\tools\Gtk+\include extra-lib-dirs: H:\proc\tools\Gtk+\lib but it doesn't seem to help. (my full cabal config listing is below) Regarding my use of H: instead of C:, I have a non-standard configuration of the Haskell Platform and cabal. I need to develop (Haskell code that uses Gtk2Hs, Glade, etc.) in a MS Windows network, from any of several PCs (one at a time), each of which uses a common tools tree. So, instead of installing the Haskell Platform, cabal, Gtk+, etc. to C:, I have installed them to a network drive (H:). So, I have: H:\proc\tools\Haskell Platform H:\proc\tools\Gtk+ H:\proc\tools\cabal etc. Any help or pointers would be appreciated. Thanks very much, -- Peter --- Following is various config and output info --- My PATH is: ++++++++++++++ SET P_TOOLS=H:\proc\tools SET HASK_PLAT=%P_TOOLS%\Haskell Platform\2010.1.0.0 PATH %HASK_PLAT%\bin; %P_TOOLS%\cabal\bin; %P_TOOLS%\gtk\bin; %HASK_PLAT%\lib\extralibs\bin; %HASK_PLAT%\mingw\bin ++++++++++++++ Some of my environment vars are: ============== REM This is so Cabal will get its config from the Haskell Platform, REM rather than C:\Documents and Settings\pschmitz\Application Data\cabal SET CABAL_CONFIG=%P_TOOLS%\cabal\config CABAL_CONFIG=H:\proc\tools\cabal\config PKG_CONFIG_PATH=H:\proc\tools\Gtk+\lib\pkgconfig GTK_HOME=\\fbpxfile01\users$\pschmitz\proc\tools\Gtk+ HASK_PLAT=H:\proc\tools\Haskell Platform\2010.1.0.0 INCLUDE=\\fbpxfile01\users$\pschmitz\proc\tools\Gtk+\include LIB=\\fbpxfile01\users$\pschmitz\proc\tools\Gtk+\lib Path=H:\proc\tools\Haskell Platform\2010.1.0.0\bin;H:\proc\tools\cabal\bin;H:\proc\tools\Gtk+\bin; H:\proc\tools\Haskell Platform\2010.1.0.0\lib\extralibs\bin;H:\proc\tools\Haskell Platform\2010.1. 0.0\mingw\bin; ============== The full output from "cabal install glade" is: ----------------------------- H:\proc\dev\cmd>cabal --version cabal-install version 0.8.2 using version 1.8.0.2 of the Cabal library H:\proc\dev\cmd>cabal list glade * glade Synopsis: Binding to the glade library. Latest version available: 0.11.1 Latest version installed: [ Not installed ] Homepage: http://www.haskell.org/gtk2hs/ License: LGPL-2.1 ... H:\proc\dev\cmd>cabal info glade * glade (library) Synopsis: Binding to the glade library. Latest version available: 0.11.1 Latest version installed: [ Not installed ] Homepage: http://www.haskell.org/gtk2hs/ Bug reports: http://hackage.haskell.org/trac/gtk2hs/ Description: This library allows to load externally stored user interfaces into programs. This allows alteration of the interface without recompilation of the program. Category: Graphics License: LGPL-2.1 Author: Manuel M T Chakravarty Maintainer: gtk2hs-users(a)sourceforge.net Source repo: http://code.haskell.org/glade/ Dependencies: base >=4 && <5, array -any, containers -any, haskell98 -any, mtl -any, glib >=0.11 && <0.12, pango >=0.11 && <0.12, cairo >=0.11 && <0.12, gtk >=0.11 && <0.12 Cached: Yes Modules: Graphics.UI.Gtk.Glade H:\proc\dev\cmd>cabal install glade Resolving dependencies... C:\DOCUME~1\pschmitz\LOCALS~1\Temp\glade-0.11.13100\glade-0.11.1\Gtk2HsSetup.hs:25: warning: #warning Setup.hs is guessing the version of Cabal. If compilation of Setup.hs fails use -DCABAL_VERSION_MINOR=x for Cabal version 1.x.0 when building (prefixed by --ghc-option= when using the 'cabal' command) [1 of 2] Compiling Gtk2HsSetup ( C:\DOCUME~1\pschmitz\LOCALS~1\Temp\glade-0.11.13100\glade-0.11.1\Gtk2HsSetup.hs, C:\DOCUME~1\pschmitz\LOCALS~1\Temp\glade-0.11.13100\glade-0.11.1\dist\setup\Gtk2HsSetup.o ) [2 of 2] Compiling Main ( C:\DOCUME~1\pschmitz\LOCALS~1\Temp\glade-0.11.13100\glade-0.11.1\Setup.hs, C:\DOCUME~1\pschmitz\LOCALS~1\Temp\glade-0.11.13100\glade-0.11.1\dist\setup\Main.o ) Linking C:\DOCUME~1\pschmitz\LOCALS~1\Temp\glade-0.11.13100\glade-0.11.1\dist\setup\setup.exe ... Configuring glade-0.11.1... setup.exe: The pkg-config package libglade-2.0 version >=2.0.0 is required but it could not be found. cabal: Error: some packages failed to install: glade-0.11.1 failed during the configure step. The exception was: ExitFailure 1 ----------------------------- My complete Cabal config follows. The email may alter the indentation, but I was careful to maintain the original indentation when editing. -- ---------------------------------------------------------------------------------------------- -- This is the configuration file for the 'cabal' command line tool. -- The available configuration options are listed below. -- Some of them have default values listed. -- Lines (like this one) beginning with '--' are comments. -- Be careful with spaces and indentation because they are -- used to indicate layout for nested sections. remote-repo: hackage.haskell.org:http://hackage.haskell.org/packages/archive remote-repo-cache: H:\proc\tools\cabal\packages -- local-repo: -- verbose: 1 -- compiler: ghc -- with-compiler: -- with-hc-pkg: -- scratchdir: -- program-prefix: -- program-suffix: -- library-vanilla: True -- library-profiling: False -- shared: False -- executable-profiling: False -- optimization: True -- library-for-ghci: True -- split-objs: False -- executable-stripping: True -- user-install: True -- package-db: -- flags: -- -- -------------------------------- -- extra-include-dirs: -- extra-lib-dirs: extra-include-dirs: H:\proc\tools\Gtk+\include extra-lib-dirs: H:\proc\tools\Gtk+\lib -- -------------------------------- -- -- constraint: -- cabal-lib-version: -- preference: -- documentation: False -- doc-index-file: $datadir\doc\index.html -- root-cmd: -- symlink-bindir: build-summary: H:\proc\tools\cabal\logs\build.log -- build-log: remote-build-reporting: anonymous -- username: -- password: install-dirs user prefix: "H:\\proc\\tools\\cabal" -- bindir: $prefix\bin -- libdir: $prefix -- libsubdir: $pkgid\$compiler -- libexecdir: $prefix\$pkgid datadir: "H:\\proc\\tools\\Haskell Platform\\2010.1.0.0" -- datasubdir: $pkgid -- docdir: $prefix\doc\$pkgid -- htmldir: $docdir\html -- haddockdir: $htmldir install-dirs global prefix: "H:\\proc\\tools\\Haskell Platform\\2010.1.0.0" -- bindir: $prefix\bin -- libdir: $prefix -- libsubdir: $pkgid\$compiler -- libexecdir: $prefix\$pkgid datadir: "H:\\proc\\tools\\Haskell Platform\\2010.1.0.0" -- datasubdir: $pkgid -- docdir: $prefix\doc\$pkgid -- htmldir: $docdir\html -- haddockdir: $htmldir -- ---------------------------------------------------------------------------------------------- -- end of post: Trying to compile Glade Gtk2Hs demo / cabal install glade problem --

2 3

Fwd: Announcement: Pearls of Functional Algorithm Design
by Don Stewart 11 Sep '10

11 Sep '10

----- Forwarded message from Richard <richard(a)normab.freeserve.co.uk> ----- To: haskell(a)haskell.org Subject: [Haskell] Announcement My book "Pearls of Functional Algorithm Design" will be published by CUP this month. See http://www.comlab.ox.ac.uk/news/237-full.html Richard Bird ----- End forwarded message ----- For those not familiar with the functional pearl series, I list some of Richard Bird's here. http://www.reddit.com/r/programming/comments/dcimd/prof_richard_birds_pearl… The essence of elegant functional programming. -- Don

1 0

Relative files paths
by Andrew Coppin 11 Sep '10

11 Sep '10

Suppose that I'm in foo/bar/box1/top and I want to access a file in foo/bar/box2/side. How do I construct the shortest possible relative path from one to the other? The filepath package doesn't seem to provide a function to do this. (The correct answer is obviously "../../box2/side" in this instance, but how do I compute that in general?)

2 1

ANNOUNCE: AbortT-transformers version 1.0
by Gregory Crosswhite 11 Sep '10

11 Sep '10

For whatever reason, nobody seems to have gotten around to implementing an Abort monad transformer (outside the monadLib package), so I decided to write one myself since I wanted the functionality but I use "transformers" rather than "monadLib". An abortable monadic computation runs until either it is finished or it is aborted by calling the "abort" function. All steps in the computation after "abort" has been called are ignored, which means that abort can be assigned an arbitrary type for its value within the computation. My implementation uses an Either type which is Left if the computation has been prematurely terminated and Right of the computation is continuing to proceed as normal. I could have implemented the functionality using the Continuation monad, but that seemed to be overkill in cases where the user only wants a simple abort monad. Cheers, Greg

6 8

re: Oracle stored procedures
by Leonel Fonseca 11 Sep '10

11 Sep '10

Hi Peter, Yes, from Takusen you can call Oracle stored procedures, functions, packaged stored procedures or functions, or execute an arbitrary pl/sql block. In the Takusen software release there is a directory called "Database\Oracle\Test". There, Enumerator.lhs, among other code has these helpers you may want to use: >wrapPLSQLFunc funcname parms = > let sqltext = "begin " ++ (head args) ++ " := " ++ funcname > ++ "(" ++ placeholders ++ "); end;" > placeholders = concat (intersperse "," (tail args)) > args = take (length parms) (map (\n -> ":x" ++ show n) [1..]) > in cmdbind sqltext parms >wrapPLSQLProc procname parms = > let sqltext = "begin " ++ procname > ++ "(" ++ placeholders ++ "); end;" > placeholders = concat (intersperse "," args) > args = take (length parms) (map (\n -> ":x" ++ show n) [1..]) > in cmdbind sqltext parms Please, be aware of the following points: 1) If the pl/sql code doesn't need parameters and has no results, you can use "execDDL". (execDML returns a counter of affected rows). 2) If the procedure/function receives parameter, you'll need to use "cmdbind" (or similar to "cmdbind") to pass the parameters. 3) If the pl/sql code returns values, you have this options: 3.a) The returned value is a reference (cursor): Takusen supports this very fine. Use "doQuery" or similar. 3.b) The return value is an scalar value: You can collect the result with an iteratee, even if it is a single value. 3.c) The return value is a complex oracle object: As of Takusen 0.8.5 there is no support for table of records of ... 3.d) The return value is Boolean. You'll get an error. Little examples: For case #1: > -- Example 1.a: We set nls_language to american english. > set_NlsLang_Eng :: DBM mark Session () > set_NlsLang_Eng = execDDL $ sql > "alter session set nls_language='AMERICAN'" > -- Example #1.b: Now we set session language parameter to spanish. > set_NlsLang_Esp :: DBM mark Session () > set_NlsLang_Esp = execDDL $ sql > "alter session set nls_language='LATIN AMERICAN SPANISH'" For case #2: > -- Example 2.a: We use database string "concat" function >concat' :: String -> String -> DBM mark Session String >concat' a b = do > let ite :: Monad m => String -> IterAct m String > ite v _ = return $ Left v > sqlcmd = wrapPLSQLFunc "concat" > [bindP $ Out (""::String), bindP a, bindP b] > doQuery sqlcmd ite undefined > > -- later on the program, you'd have... > some_string <- concat' "a" "b" For case #3: > -- Case 3.b: We collect a single scalar value. > qNlsLang :: DBM mark Session [String] > qNlsLang = doQuery s ite [] > where > s = "select value from nls_session_parameters \ > \ where parameter = 'NLS_LANGUAGE'" > ite :: (Monad m) => String -> IterAct m [String] > ite a acc = result' ( a:acc ) > mostrar_NlsLang :: DBM mark Session () > mostrar_NlsLang = qNlsLang >>= liftIO . print . head > -- Another example for Case 3.b > -- This time we don't use a list to accumulate results. > s1 = sql "select systimestamp from dual" > > sysTSasCTQ :: DBM mark Session CalendarTime > sysTSasCTQ = do > > let ite :: (Monad m) => CalendarTime -> IterAct m CalendarTime > ite x _ = result' x > > t <- liftIO ( getClockTime >>= toCalendarTime) > doQuery s1 ite t -- Leonel Fonseca.

2 2

Dependent types
by Mitar 11 Sep '10

11 Sep '10

Hi! I believe dependent types is the right term for my problem. I was trying to solve it with GADTs but I was not successful so I am turning to infinite (lazy) wisdom of Haskell Cafe. I am attaching example code where I had to define MaybePacket data type which combines different types of Packets I would like to allow over Line. The problem is that there is a correlation between Line type and MaybePacket type and I would like to tell Haskell about that. But I am not sure how. Because now compiler, for example, warns me of a non-exhaustive pattern even if some MaybePacket value is not possible for given Line. Somehow I would like to have a getFromFirstLine function which would based on type of given Line return Maybe (Packet i) (for Line) or Maybe AnyPacket (for LineAny). So that this would be enforced and type checked. Best regards and thanks for any help Mitar

2 3

Google AI Challenge: Planet Wars - Accepting Haskell Submissions
by Jake McArthur 11 Sep '10

11 Sep '10

Just wanted to let everybody know that there is an AI contest [1] that started today. Everybody has about two months to create bots that compete against each other 1-on-1 in a game based on Galcon [2]. A couple issues to mention for full disclosure: There is some sponsorship by Google, but unfortunately they aren't running the hardware, so the site is getting pretty hammered right now. We (it's all open source and open for contributions) are working to get it optimized to better handle the load. Also, the version of GHC on the server is very old (6.8.2) and isn't likely to get updated. I'm working to allow binary submissions though. If that goes through, you guys will be able to submit 64-bit Linux binaries rather than Haskell code to be compiled on the server. Just letting everybody know so the Haskell community can represent! - Jake [1] http://ai-contest.com [2] http://galcon.com

2 1

Re: [Haskell-cafe] Restricted type classes
by John Lato 11 Sep '10

11 Sep '10

> > From: Ivan Lazar Miljenovic <ivan.miljenovic(a)gmail.com> > > When I released the first version of container-classes (which I hacked > on during AusHac), some people said I should split out the various > folding, etc. into duplicates of the current Foldable class, etc. > rather than having large monolithic classes. > > I've been working on this (see my more recent email with the subject > along the lines of "fighting the type system"), and I think I've > worked out how to do this: > > * Have one version of the class (when this makes sense) for values of kind > * > > * Have another version that's closer to the original class for kind * > -> * but allowing restrictions (e.g. allowing Set to be an instance > of Functor). This is based upon Ganesh Sittampalam's rmonad package > (http://hackage.haskell.org/package/rmonad) > > Rather than my original goal of forcing all kind * -> * values to be > instances of the kind * classes, my new approach is to write instances > that automatically make all instances of a * -> * class to also be an > instance of the kind * class, and to use a newtype wrapper with a > phantom type value to allow lifting/promotion of a kind * value to a > kind * -> * value (e.g. "foo :: (Word8 -> Word8) -> ByteString -> > ByteString; foo f = unpromote . fmap f . Promote" is a valid usage, > rather than using the kind * function of rigidMap). > > My goal with this is that if I have duplicated a class Foo to allow > restricted values, then it should be a drop-in replacement for the > original in terms of _usage_ (i.e. the class and method/function names > are the same, but the type signatures are not). However, I would > appreciate the communities advice on a few matters: > > 1) How should I name the kind * versions? For example, the kind * > version of Functor is currently called Mappable with a class method of > rigidMap. What should I call the kind * version of Foldable and its > corresponding methods? Is there a valid system I can use for these? > You could prefix (or postfix) classes with an 'R' similar to RMonad, but that would conflict with the rmonad package. For just Foldable, maybe Reduceable? Do you have a kind * implementation of Foldable? I'd be interested in seeing it, because I was unable to create a usable implementation (based upon the RMonad scheme) on my last attempt. > > 2) How far should I go? Should I restrict myself to the > "data-oriented" classes such as Functor, Traversable, etc. or should I > try to make restricted versions of Applicative and Monad? Assuming I > should: > I don't have a strong opinion either way, but could you re-use RMonad and RFunctor from the rmonad package? > 2c) Should I keep the classes as-is, or should I explicitly put in the > constraints mentioned in the Typeclassopedia (e.g. make Applicative an > explicit superclass of Monad, and define return = pure for > compatability reasons)? If so, should I bring over Pointed, etc. from > category-extras to round out the set or just stick with classes that > are already in base? > +1 for using the proper constraints, and especially for bringing over Pointed (and anything else that applies). > > 3) Am I wasting my time with this? > I would find it useful, and I appreciate all the care you're putting into the design. Cheers, John

10 37

gathering position information lazily using traverse
by Jan Christiansen 11 Sep '10

11 Sep '10

Dear Applicative experts, I am seeking advice on Applicative instances and their use in traverse. Consider the following Applicative instance. newtype Proj a = Proj { unProj :: [Bool] -> a } instance Functor Proj where fmap g (Proj f) = Proj (g . f) instance Applicative Proj where pure = Proj . const Proj f <*> Proj x = Proj (\p -> f (False:p) (x (True:p))) In fact, this is not an Applicative instance as it does not satisfy the laws. On basis of this "instance" I have defined the following function. gshape :: Traversable t => t a -> t [Bool] gshape x = unProj (traverse (const (Proj reverse)) x) [] The idea is simply to replace every polymorphic component by an identifier that identifies the position of the component in the data structure. That is, provided with the identifier I want to be able to project to the corresponding component. In this case this identifier is a path in the "idiomatic term" from the root to the component. I can define a correct Applicative instance if I add an additional constructor, which represents pure. I did not prove that it satisfies all laws but I think it does. data Proj a = Pure a | Proj ([Bool] -> a) instance Functor Proj where fmap g (Pure x) = Pure (g x) fmap g (Proj f) = Proj (g . f) instance Applicative Proj where pure x = Pure x Pure f <*> Pure x = Pure (f x) Pure f <*> Proj x = Proj (\p -> f (x p)) Proj f <*> Pure x = Proj (\p -> f p x) Proj f <*> Proj x = Proj (\p -> f (False:p) (x (True:p))) My problem is that this correct instance is too strict for my purpose. It is important that gshape operates correctly on partial data, that is, even if its argument is partial all the components should be replaced correctly. For example, we have gshape (Node _|_ 0 (Leaf 1))) = Node _|_ [False,True] (Leaf [True]) If the applicative instance performs pattern matching, like the latter instance, then gshape is too strict. Therefore I suspect that there is no correct Applicative instance that satisfies my needs but I am not at all certain. Thanks, Jan

2 2

Haddock comments for GADT constructors?
by Conal Elliott 10 Sep '10

10 Sep '10

I'm updating a library (TV) and getting haddock parse errors for the doc strings attached to GADT constructors. Is there a way to haddock-document GADT constructors? I've tried both "-- | ..." before and "-- ^ ... " after. Both give parse errors. Thanks, - Conal

2 2

ANNOUNCE: text-icu 0.4.0.0
by Bryan O'Sullivan 10 Sep '10

10 Sep '10

The text-icu library is the more practical cousin to the text library, implementing a myriad of Unicode-related functionality that is not yet otherwise available in Haskell. It is implemented as bindings to the widely used ICU library. http://hackage.haskell.org/package/text-icu Features: - Locale sensitive case mapping. - Text normalization. (What is normalization? http://unicode.org/faq/normalization.html) - [NEW] Locale sensitive string collation. - Conversion to and from a huge number of native encodings. - [NEW] Efficient comparison of ByteString and Text. The library is thoroughly documented, and most interfaces are pure and easy to use. Look for further releases over the coming weeks as I complete the ICU integration.

1 0

ANNOUNCE: DSTM 0.1.1
by Frank Kupke 10 Sep '10

10 Sep '10

Hi, DSTM is an implementation of a robust distributed Software Transactional Memory (STM) library for Haskell. Many real-life applications are distributed by nature. Concurrent applications may profit from robustness added by re-implementation as distributed applications. DSTM extends the STM abstraction to distributed systems and presents an implementation efficient enough to be used in soft real-time applications. Further, the implemented library is robust in itself, offering the application developer a high abstraction level to realize robustness, hence, significantly simplifying this, in general, complex task. The DSTM package consists of the DSTM library, a name server application, and three sample distributed programs using the library. Provided are a simple Dining Philosophers, a Chat, and a soft real-time Bomberman game application. Distributed communication is transparent to the application programmer. The application designer uses a very simple name server mechanism to set up the system. The DSTM library includes the management of unavailable process nodes and provides the application with abstract error information thus facilitating the implementation of robust distributed application programs. For usage please look into the documentation file: DSTMManual.pdf. The package including the documentation can be found on: http://hackage.haskell.org/package/DSTM-0.1.1 Best regards, Frank Kupke

12 26

Style and a problem
by Wanas 10 Sep '10

10 Sep '10

Hey all, So I have a two part question (I'm new to haskell, so you can throw all your mugs at me). a) I want to write a function that generates lists of lists of size $n$. All having the property that sum lst = sum [1..n]. a-1) After that, I want to remove all permutations. My idea of doing this is to get all lists from the first function and create a new list with the property that "if sorted list A is not in the list, add it." b-2) I think that's too much questions, but I want to get the hang of this quickly (it was kickass for the few things I've tried out). Thanks, \/\/

6 8

FFI and concurrency
by Johannes Waldmann 10 Sep '10

10 Sep '10

What's the story with FFI calls and concurrency? I have an expensive calculation performed by some C function, which I call from Haskell land. (This works like a charm.) I have several cores available. How could I run several of these calculations in parallel? Thanks, Johannes.

2 1

Combining applicative with arrows?
by Nils Schweinsberg 10 Sep '10

10 Sep '10

Hey, I just wondered if you can define Applicative instances for arrows? Basicly what I thought of is: I have a type for my arrow which is "CollectA" (using HXT here): type CollectA a = SomeArrow XmlTree a And my datatype which I want to construct: data Test = Test { testString :: String , testInt :: Int } With the functions: collectString :: CollectA String collectInt :: CollectA Int Now, what I currently do is something like: collectTest :: CollectA Test collectTest = getChildren >>> someOtherArrow -- etc... >>> proc foo -> do s <- collectString -< foo i <- collectInt -< foo returnA -< Test s i With Applicatives that proc-do-part would become: collectTest' :: CollectA Test collectTest' = ... -- arrow stuff >>> Test <$> collectString <*> collectInt Is something like this possible? I don't understand that "proc" part good enough to see what it's actually doing there, maybe someone with a better understanding for this could help out? :) Thx, - Nils

2 1

Will GHC 6.14 with LLVM use LLVM C compiler to compile external C Libraries
by Mathew de Detrich 10 Sep '10

10 Sep '10

Since GHC 6.14 will (hopefully) be use LLVM as a default backend, an idea has occured to me Should GHC also use the clang (C/C++->LLVM compiler) on external C library sources which are used with certain Haskell packages (such as gtk) when LLVM does become a default backend for GHC. The consensus is that since Clang will also produce LLVM 'assembler', it can be very easily linked with the LLVM 'assembler' produced by GHC's LLVM backend, making the process of using external C sources a lot easier. Parts of Clang required could even be integrated into GHC (although this may be tricky since its coded in C++). It should also hopefully make using Haskell packages on windows that use C sources less painful Clang could also make using FFI with C++ much easier (for reasons stated above) Thoughts?

6 7

Handling platform- or configuration-specific code (or, my CPP complaints)
by Ben Millwood 10 Sep '10

10 Sep '10

Good evening, cafe, Having recently taken on maintenance of a package that depends on template-haskell, I've been in some discussion with users and dependencies of my package about how best to write a library that works with multiple incompatible versions of a dependency. The two main approaches that I'm aware of are: 1. Use CPP and the macros defined by Cabal to conditionally include or exclude code for each version. 2. Use Cabal file conditionals to select hs-source-dirs containing those parts of the code (or even TH to help generate those parts of the code) that are specific to each configuration. In my discussion with others and examination of existing libraries, it seems to me that 1. is the preferred option, but I personally can think of a number of reasons to prefer the second option: * CPP was not designed for Haskell, and even cpphs still shows symptoms of it, so we have to worry about things like its handling of string gaps or single quotes. * CPP is primarily a textual manipulation tool, rather than a symbolic one, which makes it even more easy to produce malformed code with it than with TH or similar. * On that note, it's difficult to statically analyse a file using CPP: parser tools like haskell-src-exts don't support it and it's not at all obvious how or if they ever could. With Cabal choosing source files based on configuration, all the source is valid, normal Haskell and is easy for computers and humans to understand. * It may require some significant digging into each source file to establish what configurations must be tested, or to add a new supported configuration or remove an old one, if they are chosen based on CPP conditional compilation. When Cabal chooses what is compiled it is fairly explicit what is chosen and what could be, and adding a new configuration is - at least in theory - as simple as adding a new file and conditional. * It's just not very pretty! Haskell code has a sort of aesthetic that I don't think CPP macros share - different function application syntax, for example. Of course the trouble is that when your conditional compilation is on the module level there are some things which just can't be done without code duplication, and there's a tendency for small and often quite incidental bits of a function definition to suddenly be in another module instead of where they're used. So I wonder what people think of the use of CPP in Haskell code, what alternatives people can propose, or what people hope to see in future to make conditional compilation of Haskell code more elegant and simple? I once pondered whether it would be a good idea to somehow make available to TH splices information from Cabal or GHC's configuration, so that one could do something like this: myFunctionDecl = if packageVersion "template-haskell" >= Version [2, 4] [] then [d| unTyVarBndr (PlainTV n) = n; unTyVarBndr (KindedTV n _) = n |] else [d| unTyVarBndr = id |] This exactly wouldn't make sense because KindedTV wouldn't exist in the earlier version so the quotation would object, but one could imagine something similar being useful.

5 4

installing GHC/Haskell Platform in Linux without root permission
by Ali Razavi 09 Sep '10

09 Sep '10

Is it possible to install either of these (preferably the latter) somewhere in my home directory without having root permission? I tried the unknown linux package with configure --prefix set to a subdir in my home, to no avail. The problem seems to be due to some library registration which fails. thanks Ali

3 3

Haskell, arrows and signal processing
by Anthony LODI 09 Sep '10

09 Sep '10

> The input and output are infinite streams. I have a few questions: > > 1) Is it possible to change it to use arrows? How would it look like? > 2) How would one implement an continuous time version? Yampa can do *exactly* what you're asking for. Unfortunately the code seems to be a little rough and there are many space leaks (some of which are alluded to in the source code comments). Definitely make sure to profile memory usage as you code.

1 0

Hackage package download count
by Tony Hannan 09 Sep '10

09 Sep '10

Is there anywhere we can see the number of download for a particular package, especially ones you maintain yourself? Thanks, Tony

3 3

Haskell, arrows and signal processing
by Rafael Gustavo da Cunha Pereira Pinto 09 Sep '10

09 Sep '10

Hi folks from the cafe!! Last weekend, I was wondering on how hard it would be to use Haskell for mixed-signal processing. Here is an example of an digital integrator: summation=zipWith (+) delay xs=(fromIntegral 0):xs integrator xs=let ws=summation (integrator xs) xs in delay ws The input and output are infinite streams. I have a few questions: 1) Is it possible to change it to use arrows? How would it look like? 2) How would one implement an continuous time version? For 2) I would like to implement something like that digital integrator, so I could create filters based on integrator loops like this one: x(t) ----(+)----> Integrator --|---> y(t) ^ | |--------------------| Note that x(t) would be a function, and I would expect to create a function y, based on this flow! Rafael Gustavo da Cunha Pereira Pinto -- Rafael Gustavo da Cunha Pereira Pinto

3 3

BPMN and BPEL
by Hector Guilarte 09 Sep '10

09 Sep '10

Hello, Does anybody knows if there is some work related to BPMN and/or BPEL done in Haskell? Maybe some research or some papers? I'm about to begin a mapper from BPMN to BPEL and Haskell is my first option for doing it, but since my company is somehow married to .NET and nobody else knows anything about Functional Programming or Haskell, using it might be a problem for maintenance and scalability. If somebody can point out really good reasons on why I should use Haskell to do my work, please let me know them, they might help me convincing my bosses. On the other hand, if you believe Haskell is a bad language for this kind of task, and why C# or any other .NET language would be better, I'm welcome to hear your reasons, they might convince me. I know about F#, but the "problem" is not that Haskell is not .NET, the "problem" is that it is functional programming and as I said before, nobody here knows a bit about it. If I were to do it using FP, I would use Haskell for sure, not F#. Thank you very much, Héctor Guilarte

2 2

Haskell Weekly News
by Malcolm Wallace 09 Sep '10

09 Sep '10

I miss the Haskell Weekly News. The most recent issue was published on 8th March 2010. The volunteer who produces it claimed on 27th April that he would be back in action "soon", implying that once a couple of weeks' worth of university classes were finished, HWN would return. So in the absence of any visible movement, and it now being Sept, can I appeal for a new volunteer to take over? There is more info here: http://www.haskell.org/haskellwiki/HWN Regards, Malcolm

3 2

Unwrapping newtypes
by Kevin Jardine 09 Sep '10

09 Sep '10

I have a generic object that I want to wrap in various newtypes to better facilitate type checking. For example, newtype Blog = Blog Obj newtype Comment = Comment Obj newtype User = User Obj Unlike Obj itself, whose internal structure is hidden in a library module, the newtype wrappings are purely to facilitate type checking. It is no secret that each is just a wrapper around Obj. It is obvious how to construct the various wrapper objects. It is not so obvious how to extract the Obj they contain in a reasonably generic way however. What I want is a getObj function that works on all of them. Of course this could work if someone using the library wrote an instance for each wrapper object: instance GetObject Blog where getObj (Blog obj) = obj but this is a pain in the neck to write for each newtype. I discovered that Foldable defines a handy toList function that extracts content from generic Foldable structures. So that I could write: toObj :: Foldable thing => thing Obj -> Obj toObj w = head $ toList w Slightly kludgy but it works. Even better, recent versions of GHC will allow you to automatically derive Foldable. Unfortunately, newtype Blog = Blog Obj deriving Foldable returns a kind error. What does work is: newtype BlogF a = Blog a deriving Foldable type Blog = BlogF Obj After having spent close to a day on this, I am a bit baffled that such a seemingly trivial problem seems so hard to do. I am wondering if I am missing something really, really obvious. Any suggestions? Or is there perhaps a more Haskelly way to place type constraints on a more generic type? Kevin

6 13

recommendations for reading list?
by David Leimbach 09 Sep '10

09 Sep '10

In my amazon shopping cart I currently have: *Conceptual Mathematics: A First Introduction to Categories<http://www.amazon.com/gp/product/052171916X/ref=ord_cart_shr?ie=UTF8&m=ATVP…> *- F. William Lawvere *Categories for the Working Mathematician (Graduate Texts in Mathematics)<http://www.amazon.com/gp/product/0387984038/ref=ord_cart_shr?ie=UTF8&m=ATVP…> *- Saunders Mac Lane *Categories and Computer Science (Cambridge Computer Science Texts)<http://www.amazon.com/gp/product/0521422264/ref=ord_cart_shr?ie=UTF8&m=ATVP…> *- R. F. C. Walters Are all 3 of these worthwhile? Any of them? I'm just trying to get a grasp on enough Category Theory to be able think more deeply about programming in general, and maybe grasp more Haskell terminology beyond the seemingly superficial meanings I understand today. Thanks! Dave

5 6

Re: ANNOUNCE: GotoT-transformers version 1.0
by oleg＠okmij.org 09 Sep '10

09 Sep '10

Antoine Latter wrote: > To recover from my overly complex previous post, here is a much simply > goto based on existing monad transformers: > > goto :: Monad m => ContT r m r -> ContT r m a > > goto (ContT m) = ContT $ \_ -> > > m return That is precisely how continuations were discovered (as John Reynolds documents, continuations have been discovered and rediscovered multiple times). The paper Continuations: A Mathematical Semantics for Handling Full Jumps Christopher Strachey and Christopher P. Wadsworth http://www.ling.ohio-state.edu/research/groups/commies/past/autumn2009/stra… first published in 1974 and republished in Higher-Order and Symbolic Computation, 13, 135-152, 2000 starts with the following sentence: The purpose of this paper is to explain a method of giving the mathematical semantics of a programming language which includes a very general form of jump (goto statement). The cited goto expression above appears, in mathematical notation, as the second equation on p. 143 of the paper. Labels are considered next. The paper is still a good read. One can literally implement the language of the paper, by reading domain equations as the implementation of a monad. Incidentally, Note 1 of the paper anticipated delimited continuations.

1 0

ANNOUNCE: secure-sockets version 1.0
by David Anderson 09 Sep '10

09 Sep '10

Hi, I'm happy to announce the first release of secure-sockets, a library which aims to simplify the task of communicating securely between two authenticated peers. -------------------------------------------- -- What it is -------------------------------------------- The API mimicks that of Network.Socket, and introduces the additional notion of peer identity, which is distinct from the endpoint address (host and port). Connections can only be established between two peers who know and expect to be communicating with each other. Transport security is implicitly taken care of: an established Network.Secure.Connection implies that each end of the connection successfully authenticated to the other, and that they have setup strong encryption for your data. -------------------------------------------- -- What it isn't -------------------------------------------- The library leans towards the "zero configuration" end of the spectrum, and basically Just Works. This means that if you know exactly what you want and need for the cipher, authentication algorithm, key type and length, key exchange protocol, HMAC algorithm, rekeying intervals, random number source... Then secure-sockets is not for you. If on the other hand you just want to replace your current cleartext "cipher" and faith-based "authentication" code with something that gives you a good chance of being secure (see caveats in docs), without diving into the rich madness that is full blown SSL, then you might want to take a look. This library assumes that both ends of a connection are using it. The goal of secure-sockets is not to allow you to connect to any SSL-enabled server, or to speak a particular standard flavor of authentication protocol. Internally, secure-sockets uses SSL to achieve its goals, so you might get lucky if you do it just right, but that is an implementation detail. The library is designed to help you easily secure communications between two programs whose implementation you control, not between you and anything out there. -------------------------------------------- -- Links -------------------------------------------- Homepage: http://secure-hs.googlecode.com/ Hackage page: http://hackage.haskell.org/package/secure-sockets Bug tracker: http://code.google.com/p/secure-hs/issues/list Code repository: https://secure-hs.googlecode.com/hg -------------------------------------------- -- Thanks -------------------------------------------- I'd like to thank my employer, Google. Not only did they not get mad at the idea that I might want to hack on Haskell during working hours (as my "20% project"), they also made it very painless for me to open source this code when the time came. -------------------------------------------- -- Questions? -------------------------------------------- Questions, comments, suggestions and patches can be filed in the issue tracker, emailed directly to me, or thrown out on haskell-cafe. Hope you find this code useful! - Dave

3 9

interesting type families problem
by Gábor Lehel 08 Sep '10

08 Sep '10

I'm bad at expositions so I'll just lead with the code: {-# LANGUAGE EmptyDataDecls, TypeFamilies #-} data True :: * data False :: * class TypeValue a where type ValueTypeOf a :: * value :: ValueTypeOf a instance TypeValue True where type ValueTypeOf True = Bool value = True instance TypeValue False where type ValueTypeOf False = Bool value = False main = print (value :: ValueTypeOf True) (In case this is initially confusing, there are entirely distinct type-level and value-level True and False involved which merely share a name. The idea is to take type-level 'values' and reflect them down to the corresponding value-level, er, values.) Which results in the following error message: Couldn't match expected type `Bool' against inferred type `ValueTypeOf a' NB: `ValueTypeOf' is a type function, and may not be injective In the first argument of `print', namely `(value :: ValueTypeOf True)' In the expression: print (value :: ValueTypeOf True) In the definition of `main': main = print (value :: ValueTypeOf True) This is strange and vaguely amusing to me. I get that type functions are not injective, but I can't figure out how it applies to this situation. Obviously if I had written `print (value :: Bool)` it would rightly complain that there could be any number of instances which map to Bool, and how in the world should it know which one I meant. But it seems like in this case the compiler knows everything it needs to know. And it even manages to deduce, from the exact same expression (`print` isn't giving it any extra information), that it's simultaneously a Bool and not necessarily a Bool. Is this "supposed" to work? If not, why not? -- Work is punishment for failing to procrastinate effectively.

3 4

ANNOUNCE: text 0.8.0.0, fast Unicode text support
by Bryan O'Sullivan 08 Sep '10

08 Sep '10

New in this release: - Substantial performance improvements. - Bug fixes, and better quality assurance via automated QuickCheck and HPC tests and coverage. - An even nicer API than before. The text library provides an efficient packed, immutable Unicode text type (both strict and lazy), with a powerful loop fusion optimization framework. The 'Text' type represents Unicode character strings, in a time and space-efficient manner. This package provides text processing capabilities that are optimized for performance critical use, both in terms of large data quantities and high speed. The text package provides character-encoding, type-safe case conversion via whole-string case conversion functions. It also provides a range of functions for converting Text values to and from ByteStrings, using several standard encodings (see the text-icu package for a much larger variety of encoding functions). Efficient locale-sensitive support for text I/O is also supported. http://www.serpentine.com/blog/2010/09/01/major-version-of-the-haskell-text…

8 17

ANNOUNCE: Grempa 0.1.0, Embedded grammar DSL and LALR parser generator
by Olle Fredriksson 08 Sep '10

08 Sep '10

Hello everyone, I'm pleased to announce the first release of Grempa: A library for expressing programming language grammars in a form similar to BNF, which is extended with the semantic actions to take when a production has been parsed. The grammars are typed and are to be be used with the LALR(1) parser generator, also part of the library, which can generate a parser for the language either at compile time using Template Haskell, producing fast parsers with no initial runtime overhead, or dynamically, which has the initial overhead of generating the parser, but can be used for example when the grammar depends on an input. Here is a small example (from Ex1 in the examples directory) of what a grammar may look like: data E = Plus E E | Times E E | Var | ... expr :: Grammar Char E expr = do rec e <- rule [ Plus <@> e <# '+' <#> t , id <@> t ] t <- rule [ Times <@> t <# '*' <#> f , id <@> f ] f <- rule [ id <@ '(' <#> e <# ')' , Var <@ 'x' ] return e The corresponding BNF grammar is the following: E ::= E + T | T T ::= T * F | F F ::= ( E ) | x Generating a parser from the grammar is simple: parseExpr :: Parser Char E parseExpr = $(mkStaticParser expr [|expr|]) There are a few other examples in the examples directory of the package, most notably a grammar and parser for a simple functional language similar to Haskell. It is possible to generate random input strings and their expected outputs for grammars written using Grempa which makes it possible to test the generated parsers with QuickCheck. The package and documentation (should be up soon) can be found here: http://hackage.haskell.org/package/Grempa-0.1.0 Please get in touch with me if you have any comments, issues, questions, bug reports or would like to contribute to the project. I would love to get some more people involved in the project, as there are many areas of the library that could be improved. Thanks to Daniel Gustafsson and everyone else at Chalmers Uni for valuable input and getting me into Haskell (respectively). Regards, Olle Fredriksson

3 4

ANNOUNCE: grammar-combinators 0.1 (initial release): A parsing library of context-free grammar combinators
by Dominique Devriese 08 Sep '10

08 Sep '10

The grammar-combinators library is a parsing library employing a novel grammar representation with explicit recursion. The library features much of the power of a parser generator like Happy or ANTLR, but with the library approach and most of the benefits of a parser combinator library. Grammars and grammar algorithms are defined in a functional style. The library currently has the following features: * Grammar specified completely in Haskell using an elegant syntax * Grammar algorithms implemented in a functional style (no fresh identifiers), with elegant and meaningful types. * Multi-backend: use the same grammar with a Packrat, Parsec or UUParse parser * Grammar transformations: use left-recursive grammars directly thanks to a powerful grammar transformation library, featuring the left-corner left-recursion removal transform, a uniform version of the classic Paull left-recursion removal, and various smaller transformations (dead-branch removal, dead non-terminal removal, consecutive epsilon combination, selective unfolding etc.). * Grammar utility functions: printing of grammars, FIRST-set calculation, reachability analysis of non-terminals, etc. * Compile-time transformations (using Template Haskell), given a suitable definition of the grammar. This is currently limited to a certain set of transformations. The library is currently not intended for mainstream use. Its API is relatively stable, but performance needs to be looked at further. We are submitting a paper about the ideas behind this library to PADL 2011. A draft is linked on the project's website. More information: * Project website: http://projects.haskell.org/grammar-combinators/ * Tutorial: http://projects.haskell.org/grammar-combinators/tutorial.html * Hackage: http://hackage.haskell.org/package/grammar-combinators All comments welcome! Dominique PS. The documentation on hackage currently doesn't build because of (seemingly) a Hackage dependency problem during the build [1]. Compiling and generating the documentation locally should work fine. A version of the docs is available on the project's webpage as a temporary replacement [2]. Footnotes: [1] http://www.haskell.org/pipermail/libraries/2010-September/014168.html [2] http://projects.haskell.org/grammar-combinators/docs/index.html

3 6

Re: ghc HEAD
by Johannes Waldmann 08 Sep '10

08 Sep '10

Yuras Shumovich <shumovichy <at> gmail.com> writes: > http://hackage.haskell.org/trac/ghc/ticket/3910 So what is the magic "link-time flag to en/disable the RTS options"? It seems it would be needed for all things multi-core, since you'd want to modify +RTS -Nx J.W.

6 5

Re: [Haskell-cafe] Re: Crypto-API is stabilizing
by Thomas DuBuisson 08 Sep '10

08 Sep '10

On Sat, Sep 4, 2010 at 3:23 AM, Heinrich Apfelmus <apfelmus(a)quantentunnel.de> wrote: >>> A better reason is the data structure has >>> no way to implement generateKeyPair. > > That's a non-problem: each algorithm (RSA, DSA, ...) implements a > function with the same type as generateKeyPair . Compare > > rsa :: RangomGen g => BitLength -> g -> ((Key,Key), g) > > vs > > ((k1 :: RSA, k2), g') = generateKeyPair g > > You always have to write down the name of the algorithm ("RSA") when > using generateKeyPair , so you may as well drop it entirely. That simply isn't true. What if you have a key exchange in which the ephemeral key is of the same type as your signing key? Slightly contrived example: buildAgreementMessage :: (Monad m, CryptoRandomGen g, ASymetricCipher k) => g -> k -> m (B.ByteString,g) buildAgreementMessages g k = do (e,g') <- liftM eitherToFail (buildAsymKey g `asTypeOf` k) let eBS = encode e msg = runPut (putByteString agreementHeader >> putWord16be (B.length eBS) >> putByteString eBS) return msg

2 2