- Haskell-Cafe - Haskell.org

ifdef based on which OS you're on
by Andrew Cowie 26 Feb '13

26 Feb '13

I've got a piece of code that looks like this: baselineContextSSL :: IO SSLContext baselineContextSSL = do ctx <- SSL.context SSL.contextSetDefaultCiphers ctx #if defined __MACOSX__ SSL.contextSetVerificationMode ctx SSL.VerifyNone #elif defined __WIN32__ SSL.contextSetVerificationMode ctx SSL.VerifyNone #else SSL.contextSetCADirectory ctx "/etc/ssl/certs" SSL.contextSetVerificationMode ctx $ SSL.VerifyPeer True True Nothing #endif return ctx all very nice (this being necessary because apparently the non-free operating systems don't store their certs in a reliably discoverable place; bummer). That, however, is not the problem. After all, this sort of thing is what #ifdefs are for. The problem is needing to get an appropriate symbol based on what OS you're using defined. I naively assumed there would be __LINUX__ and __MACOSX__ and __WIN32__ defined by GHC because, well, that's just the sort of wishful thinking that powers the universe. So my question is: what's an appropriate Haskell mechanism for building code that is OS / arch / distro specific? It's not like I have autoconf running generating me a config.h I could #include, right? This feels simple and an appropriate use of CPP; even the symbol names look just about like what I would have expected; stackoverflow said so, must be true. Just need to get the right symbol defined at build time. Any suggestions? AfC Sydney

8 14

ANN: lazy-csv - the fastest and most space-efficient parser for CSV
by Malcolm Wallace 25 Feb '13

25 Feb '13

There are lots of Haskell CSV parsers out there. Most have poor error-reporting, and do not scale to large inputs. I am pleased to announce an industrial-strength library that is robust, fast, space-efficient, lazy, and scales to gigantic inputs with no loss of performance. http://code.haskell.org/lazy-csv/ Downloads from Hackage: http://hackage.haskell.org/package/lazy-csv This library has been in industrial use for several years now, but this is the first public release. No doubt the API is not as general as it could be, but it already serves many purposes very well. I'm happy to receive bug reports and suggestions for improvements. Regards, Malcolm

7 7

ANN: conduit-network-stream, A base layer for network protocols with Conduits
by Nils 25 Feb '13

25 Feb '13

Hello everyone, I just uploaded my "conduit-network-stream" package to hackage. It's a base layer for network protocols based on the "Conduit" package by Michael Snoyman which makes it possible to send multiple messages over a continuous network connection in a convenient way. I wrote more about it at: https://github.com/mcmaniac/conduit-network-stream/blob/master/README.md It is available on hackage and github: http://hackage.haskell.org/package/conduit-network-stream https://github.com/mcmaniac/conduit-network-stream Until the documentation on hackage is generated, I also host the haddock documentation at: http://hs.nils.cc/conduit-network-stream/index.html For any questions/problems/requests, please ask! - Nils

3 5

Thunks and GHC pessimisation
by Tom Ellis 25 Feb '13

25 Feb '13

To avoid retaining a large lazy data structure in memory it is useful to hide it behind a function call. Below, "many" is used twice. It is hidden behind a function call so it can be garbage collected between uses. That's good. When compiling with "-O" it seems that GHC 7.4.1 decides to keep it in memory anyway. That's bad. (I can't read core so I don't know exactly what's going on). Replacing one of the "many" in "twice" with "different_many" makes everything fine again. Is this considered a bug in GHC? Is it a known bug? It is incredibly concerning that GHC would perform this kind of pessimisation. Tom % cat thunkfail.hs {-# OPTIONS_GHC -fno-warn-unused-binds #-} import Data.List million :: Int million = 10 ^ (6 :: Int) many :: () -> [Int] many () = [1..million] different_many :: () -> [Int] different_many () = [1..million] twice :: (Int, Int) twice = (foldl' (+) 0 (many ()), foldl' (+) 0 (many ())) main :: IO () main = print twice % ghc -fforce-recomp -Wall -Werror -rtsopts thunkfail.hs && ./thunkfail +RTS -M5M [1 of 1] Compiling Main ( thunkfail.hs, thunkfail.o ) Linking thunkfail ... (1784293664,1784293664) % ghc -O -fforce-recomp -Wall -Werror -rtsopts thunkfail.hs && ./thunkfail +RTS -M5M [1 of 1] Compiling Main ( thunkfail.hs, thunkfail.o ) Linking thunkfail ... Heap exhausted; Current maximum heap size is 5242880 bytes (5 MB); use `+RTS -M<size>' to increase it.

3 5

Tournament knock out
by Xinyu LIU 25 Feb '13

25 Feb '13

Hi, Tournament knock out is explained in [1] by Knuth. The limitation is that it can only handle the sequence of the length 2^m for some integer m. When the champion element is removed, it was replaced with negative infinity. Typically negative infinity is represented by a predefined big negative number. Although heap sort solves all these limitation, I found tournament knock out itself can work out. Here is the Haskell code: data Infinite a = NegInf | Only a | Inf deriving (Eq, Show, Ord) only (Only x) = x data Tr a = Empty | Br (Tr a) a (Tr a) deriving Show key (Br _ k _ ) = k wrap x = Br Empty (Only x) Empty branch t1 t2 = Br t1 (min (key t1) (key t2)) t2 fromList :: (Ord a) => [a] -> Tr (Infinite a) fromList = build . (map wrap) where build [] = Empty build [t] = t build ts = build $ pair ts pair (t1:t2:ts) = (branch t1 t2):pair ts pair ts = ts pop (Br Empty _ Empty) = Br Empty Inf Empty pop (Br l k r) | k == key l = let l' = pop l in Br l' (min (key l') (key r)) r | k == key r = let r' = pop r in Br l (min (key l) (key r')) r' top = only . key tsort :: (Ord a) => [a] -> [a] tsort = sort' . fromList where sort' Empty = [] sort' (Br _ Inf _) = [] sort' t = (top t) : (sort' $ pop t) The detailed explanation can be found at: https://github.com/liuxinyu95/AlgoXY/blob/algoxy/preview/ssort-en.pdf?raw=t… [1]. Donald E. Knuth. The art of computer programming, Volume 3, sorting and searching. Larry, LIU Xinyu https://sites.google.com/site/algoxy/ https://github.com/liuxinyu95/AlgoXY

1 0

Re: [Haskell-cafe] Parser left recursion
by wren ng thornton 24 Feb '13

24 Feb '13

On 2/24/13 7:56 AM, Kim-Ee Yeoh wrote: > On Sun, Feb 24, 2013 at 7:47 PM, Roman Cheplyaka <roma(a)ro-che.info> wrote: > >> Or perhaps you meant that the production itself, when interpreted as a >> definition, is corecursive? > > I was merely thrown off by your mention of "well-founded" and the assertion > that you're left with a "strictly smaller" input. I don't see any of this. But the problem here really is an issue of well-foundedness rather than productivity. Consider the grammar, A ::= epsilon | A B B ::= ...whatever... In order to use this grammar as-is, when processing a string we must be able to magically determine how many times to recurse in order to get our epsilon. This is magic because the correct number of times to recurse is defined by the rest of the string--- which we haven't looked at! Proof theoretically speaking, this is the same as magically knowing when to use the inductive hypothesis vs when to bottom out at a base case. Using this grammar as-is, the recursive descent parser always decides to use the inductive hypothesis. Hence, infinite loop. It should be apparent that this isn't an issue with left-recursion (when reading the string from right to left), because on left-recursion we're always consuming some of the string, and therefore the input string is getting smaller on each recursive call, and therefore it is guaranteed that we will eventually run out of string, at which point we can backtrack as necessary. The problem with right-recursion is that we never know when to stop recurring. If we stop at some arbitrary point, well maybe the parse will end up failing when it could've succeeded if only we had recursed a bit further. But recursive descent doesn't allow the kind of backtracking that would be required to exhaust the search space for right-recursion. -- Live well, ~wren

1 0

presentation on Diffusion of Innovation mentioning several times Haskell
by Luc TAESCH 24 Feb '13

24 Feb '13

Just found an Interesting presentation mixing Diffusion of Innovation with Social Patterns, mentioning several times Haskell. Good introduction to a mix of techniques for whoever interested in Haskell proselytism, and go to market strategy, http://www.taesch.com/haskell/go-to-market/introduction-to-diffusion-of-inn…

1 0

Install qtHaskell 1.1.4 using Visual Studio 2010 and GHC 7.4.2
by leonardo davinci 24 Feb '13

24 Feb '13

I am trying to install qtHaskell in Windows. I have Qt 4.8.4 (the Visual Studio 2010 version). I am following the section <<2.3.2 Windows Manual Installation>> from the userGuide of qtHaskell. I set the path as described I added the line to qt.cabal, I changed dir to qws I gave qmake -recursive and then instead of mingw32-make I gave nmake which is the equivalent for VS2010. After the compilation process finished with success I switched back to root directory of qtHaskell and I gave "runhaskell Setup.hs configure --ghc" and I took the message: "Setup.hs:1:12: Warning: -fglasgow-exts is deprecated: Use individual extensions instead Configuring qt-1.1.4... " After that I gave the command: "runhaskell Setup.hs makefile" and I got the message: "Setup.hs:1:12: Warning: -fglasgow-exts is deprecated: Use individual extensions instead unrecognised command: makefile (try --help)" Any help in order to continue? Thank in advance

1 0

Munich Haskell Meeting
by Heinrich Hördegen 24 Feb '13

24 Feb '13

Dear all, please note that our monthly Haskell get-together is scheduled on Wed, 27th Feb 2013 at 19h30 at Cafe Puck in Munich, Germany. If you plan to join, please go to http://www.haskell-munich.de/dates and click the button. Everyone interested in functional programming is welcome! I wish everyone of you, joining or not, a nice week, Heinrich

1 0

Fixing undeduceable instance ==> overlapping instance
by Michael Orlitzky 24 Feb '13

24 Feb '13

I'm trying to write a determinant function that works on matrices parameterized by their dimensions (Peano naturals). If I declare the following, -- Define a class so that we get a different determinant function -- on the base/recursive cases. class (Eq a, Ring.C a) => Determined m a where determinant :: (m a) -> a -- Base case, 1x1 matrices instance (Eq a, Ring.C a) => Determined (Mat (S Z) (S Z)) a where determinant m = m !!! (0,0) -- Recursive case, (n+2) x (n+2) matrices. instance (Eq a, Ring.C a, Arity n) => Determined (Mat (S (S n)) (S (S n))) a where determinant m = ... -- Recursive algorithm, the i,jth minor has dimension -- (n+1) x (n+1). foo bar (determinant (minor m i j)) I get an error stating that I'm missing an instance: Could not deduce (Determined (Mat (S n) (S n)) a) ... Clearly, I *have* an instance for that case: if n == Z, then it's the base case. If not, it's the recursive case. But GHC can't figure that out. So maybe if I define a dummy instance to make it happy, it won't notice that they overlap? instance (Eq a, Ring.C a) => Determined (Mat m m) a where determinant _ = undefined No such luck: >>> let m = fromList [[1,2],[3,4]] :: Mat2 Int >>> determinant m Overlapping instances for Determined (Mat N2 N2) Int arising from a use of `determinant' Matching instances: instance (Eq a, Ring.C a) => Determined (Mat m m) a -- Defined at Linear/Matrix2.hs:353:10 instance (Eq a, Ring.C a, Arity n) => Determined (Mat (S (S n)) (S (S n))) a ... I even tried generalizing the (Mat m m) instance definition so that OverlappingInstances would pick the one I want, but I can't get that to work either. Is there some way to massage this?

2 2