September 2015 - Haskell-Cafe

persistent sqlite: getting record by ID
by miro 18 Sep '15

18 Sep '15

Please, can you help me with following? I’m trying to get a record from sqlite by id. I have found following peace of code,…but I’m missing the place that where can I specify the table I’m actually querying (like PersonId). get $ Key $ (PersistInt64 $ fromIntegral id) Cheers, Miro

2 1

Looking for better than Dragon Book
by Michael Litchard 18 Sep '15

18 Sep '15

I've got the Tiger Book, ML version, which I will use to help me implement Tiger in Haskell. Below is a class curriculum I've found. But besides the Tiger Book, it uses the Dragon Book. I know there are more modern books out there. Looking for suggestions as what might be a good fit. http://cs.nyu.edu/courses/fall13/CSCI-GA.2130-001/

4 4

London Haskell eXchange & Haskell Infrastructure Hackathon
by Oliver Charles 18 Sep '15

18 Sep '15

Hi all, In October Skills Matter & Well-Typed are organising a few Haskell events in London that will (I expect!) be of interest to people here. On the 8-9th of October is the Haskell eXchange, a 2-day conference on various topics about Haskell. The programme includes a variety of topics from the theoretical to the practical, with a mixture of talks, keynotes, lightning talks and workshop. A promo-code is valid until Sept 19th for 25% off - use HASKELL-EXCHANGE-25. For more details and booking, see https://skillsmatter.com/conferences/7069-haskell-exchange-2015. Shortly after the Haskell eXchange, Well-Typed will co-organize and participate in a two-day Haskell Hackathon <https://skillsmatter.com/conferences/7316-haskell-hackathon-2015>, which takes place directly after the Haskell eXchange, 10-11th October. This Hackathon aims at bringing together Haskell developers – both beginners and experts – who want to help improve the Haskell infrastructure, predominantly Hackage and Cabal. We’ll aim to arrange some introductory overview talks, to e.g. provide an overview over the code bases and the most important open issues. Participation is free, but please register online: https://skillsmatter.com/conferences/7316-haskell-hackathon-2015. Hope to see you there! ocharles

1 0

Replication class
by David Feuer 17 Sep '15

17 Sep '15

A number of types support some version of replication. Lists and vectors offer replicateM, while sequences have replicateA (the same thing, but generalized to Applicative). Is there, or should there be, a class for structures that support this operation?

2 2

Anchors in Haddock
by Sven Panne 17 Sep '15

17 Sep '15

Haddock offers a way to add anchors to the documentation and to link to them, see https://www.haskell.org/haddock/doc/html/ch03s08.html#idm140354810720016. I've got

1 1

Linking to anchors in Haddock
by Sven Panne 17 Sep '15

17 Sep '15

Haddock offers a way to add anchors to the documentation and to link to them, see https://www.haskell.org/haddock/doc/html/ch03s08.html#idm140354810720016. I've got 2 problems with that: * A link to an anchor "Foo.Bar#Baz" is always rendered with the text "Foo.Bar" in the HTML backend. Is there a way to change that? With the HTML backend I actually want something like: <a href="path-to-Foo.Bar#Baz">My own link text</a> * Using relative hype [My own link text](Foo-Bar.html#Baz) instead has problems, too: The "Foo-Bar.html" part is fragile and depends on Haddock flags. Furthermore, when using the LaTeX backend, the resulting LaTeX code is broken (the '#' needs an escaping backslash). So is there a non-fragile way working with several backends which makes it possible to specify the link text? Staring at the Haddock docs and the Haddock source code didn't help, and several experiments gave no clue, either. :-/

1 0

test socket buffer full
by Alberto G. Corona 17 Sep '15

17 Sep '15

Hi haskellers I´m implementing a form of intelligent streaming among nodes so that a process could know if there are bottlenecks on sending/receiving data so the process can increase or decrease the number of worker threads, for example. For this purpose, I planned to use hPutBufNonBlocking and hGetBufNonBlocking to detect when the buffer is full, using block buffering. I created hPutStrLn' that tries to write the entire string in the buffer. if it does not fit, the process would be notified in a state variable, then it would do a flush of the buffer and the rest of the string would be sent with hPutBuf. Doing some tinkering here and there It came up to be this: hPutStrLn' h str= do let bs@(PS ps s l) = BS.pack $ str ++ "\n" n <- withForeignPtr ps $ \p-> hPutBufNonBlocking h (p `plusPtr` s) l when( n < l) $ do error "BUFFER FULLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL" hFlush h withForeignPtr ps $ \p -> hPutBuf h ( p `plusPtr` (n * sizeOf 'x' ) ) (l - n) return () The error condition is the one that I expected to detect in the tests. In the real code, this line just would set a state variable, that would be read by the process somewhere else. The problem is that this routine behaves identically to hPutStrLn. The error condition never happens and hPutBufNonBlocking send the complete string every time. I created a program https://gist.github.com/agocorona/6568bd61d71ab921ad0c The example print the output of the receiver "hello" continuously Note that in the complete running code below, the receiver has a threadDelay of a second, so the send and receive buffers should be full. That happens in Windows and Linux, in a single process (like in the example) or within two processes in the same machine. How the processes can detect the congestion? -- Alberto.

3 8

Simple question about blackholing
by Kei Davis 16 Sep '15

16 Sep '15

Hello, By all accounts I've found a thunk is blackholed by replacing its header with a (the) blackhole code pointer (or blackhole info pointer in the unregisterized case). My simple-minded question is how garbage collection can take place given that the layout of the payload is lost. Surely not a custom blackhole for each (statically defined) thunk? A list of blackholes maintained somewhere that the GC knows about? Thanks for any insight! Kei -- Kei Davis Applied Computer Science Group CCS-7, Mail Stop B287 Los Alamos National Laboratory Los Alamos, NM 87545, U.S.A.

2 3

Converting EpochTime to Integer
by Bram Neijt 16 Sep '15

16 Sep '15

Dear Haskell cafe, I want to convert form mtime :: System.Posix.Types.EpochTime to something aeson can eat without having to define an instance. I choose Integer. My current solution[1] is just using (read . show). I know, ugly, but the only thing I could get going. What is the proper way to convert System.Posix.Types.EpochTime to Integer or something else aeson will automatically convert without making a ToJSON instance? As a beginner I wonder: is there a general way to go about finding conversion paths between types? Greetings, Bram Neijt [1] https://github.com/bneijt/httpmtimeline/blob/master/src/Main.hs#L21

6 11

Re: [Haskell-cafe] Powerset of a set
by Olaf Klinke 16 Sep '15

16 Sep '15

Jerzy is right, of course. I should have issued the warning to Jorge: If you just want to understand how to compute the powerset, don't look into filterM. But in a way, filterM works like Jerzy's Prolog example: filterM (const [False,True]) [] = [[]] -- filterM is defined via foldr with base case (return []). filterM (const [False,True]) (x:xs) = do includeFirstElement <- [False,True] -- in reality, includeFirstElem <- const [False,True] x subsetOfxs <- filterM (const [False,True] xs) -- recursive call. return (if includeFirstElement then x:subsetOfxs else subsetOfxs) In order to produce a sublist of a list, we need to decide for each element if we want to include it in the sublist. That is, a sublist of xs :: [a] can be obtained by running filter (p :: a -> Bool) xs for some decision procedure p. The type of filterM allows the decision procedure to give more than one answer. In our case, the p, when asked "Should we include this particular element in the sublist?" always answers "Yes and No!". Is there a monad transformer generalisation of filterM, where the monad [] is replaced by other monad(-transformer)s? Recall that many monad transformers rely on distributive laws. class Distributive t where distrib :: (Monad m) => t (m a) -> m (t a) instance Distributive [] where distrib = sequence The term \p -> liftM (\x -> liftM (\b -> if b then return x else mzero) (p x)) can be given the type (Monad m, MonadPlus t) => (a -> m Bool) -> t a -> t (m (t a)) Therefore the term \p -> (liftM join).distrib.(liftM (\x -> liftM (\b -> if b then return x else mzero) (p x))) can be given the type (MonadPlus t,Distributive t, Monad m) => (a -> m Bool) -> t a -> m (t a) Indeed for t = [] it is equivalent to filterM. To explain what's going on, notice that sequence :: Monad m => [m a] -> m [a] computes, when m = [], all possible ways of picking one element from each list in a list of lists. One could say that sequence produces choice functions. I used sequence above: To compute the powerset of a set, replace each element x by the set {{},{x}}, then compute all choices, and then take the union of each such choice. -- Olaf

1 0