- Haskell-Cafe - Haskell.org

Fearing Haskell
by Henk-Jan van Tuyl 03 Dec '16

03 Dec '16

L.S., IBM's Watson can analyze web pages, see https://alchemy-language-demo.mybluemix.net/ . If I feed it the URL https://wiki.haskell.org/Haskell , Watson states that this page is about a person called Haskell, with a fearful sentiment. With the URL https://en.wikipedia.org/wiki/Haskell_(programming_language) , there is both joy and sadness in Haskell. :-) Regards, Henk-Jan van Tuyl -- Folding@home What if you could share your unused computer power to help find a cure? In just 5 minutes you can join the world's biggest networked computer and get us closer sooner. Watch the video. http://folding.stanford.edu/ http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

1 0

monad-coroutine alternatives
by Alex 02 Dec '16

02 Dec '16

Hello, Are there any data structures isomorphic to Coroutine[0] available on Hackage? -- Alex [0] https://hackage.haskell.org/package/monad-coroutine-0.9.0.3/docs/Control-Mo…

2 2

An idea on extensible effects (anonymous record)
by winter 30 Nov '16

30 Nov '16

Hi everyone! First of all, i don't know if this idea is already being discussed so if there's a discussion on this i'd like to follow. To illustrate, first i want to create a class like: class Has a t where get :: t -> a then i define instance for simple product type such as tuple: instance Has a (a, b) where get (a, _) = a instance Has b (a, b) where get (_, b) = b ... You can image i will use th to make lots of instance for difference tuple size. Now if i want an extensible reader, i use Has class like this: someReader :: Has Int t => Reader t Int someReader = do x <- ask return $ get x + 1 Then i can run it with any tuple with an Int field like: runReader someReader (0 :: Int, "adad”) -- 1 This typeclass almost solved all problem of my network application: sometime’s i want ensure a logger, a sql backend and a http client pool in my monad’s environment, but i don’t want to fix my environment into a record. We can add a set :: a -> t -> t, or use lens to define Has, so that we can have extensible states. We can also use Tagged to achieve something like: (Has (Tagged “SqlBackEndOne” SqlBackEnd) t, Has (Tagged “SqlBackEndTwo" SqlBackEnd) t) => Reader t () It there a library doing this, maybe in lens? or there’re some drawbacks i didn’t notice? All ideas are welcomed! Cheers~ Winter

4 8

Debug tracing in Haskell
by Clinton Mead 30 Nov '16

30 Nov '16

I've been debugging some Haskell code, including a lot of work on Mutable Vectors, so naturally I've found `trace` useful, and in particular `traceM`, because it fits in nicely with monadic code. The problem is that unlike `assert`, both `trace` and `traceM` execute unconditionally, I can't toggle them with a compiler flag. I could however do something like this in every file I want to do tracing. {-# LANGUAGE CPP #-} #ifdef TRACE trace = Debug.Trace.trace traceM = Debug.Trace.traceM #else trace _ = id traceM _ = pure () #endif But already, that's a lot of boilerplate. I'd also like to trace based on debug levels. For example, at TRACE level 2, only print trace statements at level 1 or 2, but at TRACE level 4, print trace statements at level 1, 2, 3 and 4, providing more detail (but more noise). This makes the above code even more complex. This wouldn't be a problem if I could put the code in a separate package, but I can't, as then whether tracing is on or not depends on the compiler settings of the tracing package, not on the calling package, which defeats the purpose somewhat. I considered using implicit parameters to quietly pass whether I want tracing and at what level into the tracing module, but it seems to be that implicit parameters can't be defined at the top level. It gets even more complex. When debugging, I might want to print something of type 'a'. Obviously 'a' will need some sort of show method for this to work, but outside of debug mode I don't want to restrict my function's types to things which are showable. So I considered doing this: #ifdef TRACE type DebugShow a = Show a debugShow = show #else type DebugShow a = () debugShow _ = error "DEBUG SHOWING OUTSIDE OF DEBUG MODE" #endif And of course, if you're only using `debugShow` as part of an argument to `trace`, lazy evaluation will avoid `debugShow` ever being called when tracing is not enabled. But put all this together and you've got around a dozen lines of boilerplate just to do tracing, without even having tracing levels yet, that have to be put in every module you want to use tracing, but don't want a whole lot of debug data being spat out in a release compile. Also, adding any other tracing functions just makes this longer. The only approach I can think of so far is to whack this all in a template haskell module and add code that splices it all into the current module: e.g. #ifdef TRACE $(traceFunctions True) #else $(traceFunctions False) #endif Where `traceFunctions` is a template haskell function that dumps all the appropriate functions and type definitions mentioned above (and maybe more) at the top level of the calling module. So my questions are: 1. Is there a better way? And 2. Has this problem already been solved?

7 8

complexity of functions in PriorityQ.hs
by Michael Litchard 30 Nov '16

30 Nov '16

I'm trying to figure out the complexity of the functions in Melissa O'Neill's Priority Queue library, Priority.Q.hs Below find definitions, and what I think the complexity is. I'd appreciate feedback, especially on the ones I have marked as guesses. data PriorityQ k v = Lf | Br {-# UNPACK #-} !k v !(PriorityQ k v) !(PriorityQ k v) deriving (Eq, Ord, Read, Show) O(log n) . This is a guess but alternating which side of the sub-tree is being traversed is my hint. insert :: Ord k => k -> v -> PriorityQ k v -> PriorityQ k v insert wk wv (Br vk vv t1 t2) | wk <= vk = Br wk wv (insert vk vv t2) t1 | otherwise = Br vk vv (insert wk wv t2) t1 insert wk wv Lf = Br wk wv Lf Lf I have no idea. Reasoning help here please. siftdown :: Ord k => k -> v -> PriorityQ k v -> PriorityQ k v -> PriorityQ k v siftdown wk wv Lf _ = Br wk wv Lf Lf siftdown wk wv (t @ (Br vk vv _ _)) Lf | wk <= vk = Br wk wv t Lf | otherwise = Br vk vv (Br wk wv Lf Lf) Lf siftdown wk wv (t1 @ (Br vk1 vv1 p1 q1)) (t2 @ (Br vk2 vv2 p2 q2)) | wk <= vk1 && wk <= vk2 = Br wk wv t1 t2 | vk1 <= vk2 = Br vk1 vv1 (siftdown wk wv p1 q1) t2 | otherwise = Br vk2 vv2 t1 (siftdown wk wv p2 q2) Whatever the cost of siftdown is. deleteMinAndInsert :: Ord k => k -> v -> PriorityQ k v -> PriorityQ k v deleteMinAndInsert wk wv Lf = error "Empty PriorityQ" deleteMinAndInsert wk wv (Br _ _ t1 t2) = siftdown wk wv t1 t2 This looks like O(log N) to me. leftrem :: PriorityQ k v -> (k, v, PriorityQ k v) leftrem (Br vk vv Lf Lf) = (vk, vv, Lf) leftrem (Br vk vv t1 t2) = (wk, wv, Br vk vv t2 t) where (wk, wv, t) = leftrem t1 leftrem _ = error "Empty heap!" The cost of siftdown, which is probably more expensive than leftrem. deleteMin :: Ord k => PriorityQ k v -> PriorityQ k v deleteMin (Br vk vv Lf _) = Lf deleteMin (Br vk vv t1 t2) = siftdown wk wv t2 t where (wk,wv,t) = leftrem t1 deleteMin _ = error "Empty heap!" Thanks for the feedback. I'm new to computational analysis and this is the most complicated code I have tried to tackle thus far. I have Okasaki's book, but am having trouble making best use of it.

2 2

HWWG
by Ben Spencer 30 Nov '16

30 Nov '16

Hello all, Is there a way to get involved with the HWWG? Is there a slack channel or a mailing list? Best, Ben Spencer Sent from my iPhone

1 0

[ANN] Sprinkles - zero-programming web dev platform
by Tobias Dammers 30 Nov '16

30 Nov '16

A little something I've been working on: https://sprinkles.tobiasdammers.nl/ You feed it a bunch of templates, content in files, databases, APIs, etc., define routes and map them onto data sources and templates using a YAML configuration file, and it'll serve that as a full blown website. It sits somewhere in between a classic CMS and a static site generator. The code is available on github: https://github.com/tdammers/sprinkles Both the sprinkles website and that for ginger (https://ginger.tobiasdammers.nl/) are built on Sprinkles (following some advice about dog food I read somewhere). Before I unleash this to a more general audience, I'd like to get some honest (harsh) criticism here, on both the code itself and the available materials (website, documentation). Feel free to roast me relentlessly. -- Tobias Dammers - tdammers(a)gmail.com

3 2

Munich Haskell Meeting, 2016-11-30 @ 19:30
by Christian Neukirchen 28 Nov '16

28 Nov '16

Dear all, This week, our monthly Munich Haskell Meeting will take place again on Wednesday, November 30 at Max-Emanuel-Brauerei at 19h30. For details see here: http://muenchen.haskell.bayern/dates.html If you plan to join, please add yourself to this dudle so we can reserve enough seats! It is OK to add yourself to the dudle anonymously or pseudonymously. https://dudle.inf.tu-dresden.de/haskell-munich-nov-2016/ Everybody is welcome! cu, -- Christian Neukirchen <chneukirchen(a)gmail.com> http://chneukirchen.org

1 0

Package takeover: indents
by Jasper Van der Jeugt 28 Nov '16

28 Nov '16

The indents [1] package provides a very simple way to create indentation-aware parsers with Parsec. Unfortunately, it does not compose very well (the user cannot use a custom monad anymore), and there are several bugs in it, for example this pretty bad one [2]. I have patches that has been running in production at Fugue [3] for over a year which fixes all of these issues, while keeping a fully compatible API. I have tried contacting the author (CC'ed) over a year ago (June 2015) but I haven't received a response. The latest package upload is from May, 2012. I would like to take over this package so I can share the fixes. [1]: https://hackage.haskell.org/package/indents [2]: http://lpaste.net/344393 [3]: https://fugue.co/ Regards, Jasper

3 4

Searching for free copy of Bird paper
by Michael Litchard 28 Nov '16

28 Nov '16

I'm looking for a copy of the paper below. Can anyone point me to a free copy? Bird, R. S. (1984) Using circular programs to eliminate multiple traversals of data

2 1