November 2016 - Haskell-Cafe

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

Creating a instance for (Storable Text)
by Cody Goodman 27 Nov '16

27 Nov '16

Any ideas on how I'd write this instance? I know for it to be storable it needs a size, couldn't I just get the length of the text? Has anyone did anything similar? I ran into a surprise when trying to use storable-record and derive-storable and tried using them with a record that contained a Text field. My end goal is having a vector of records that could contain Text, UTCTime, or other similarly complex types which I can write as an mmap to disk and then read back to the original format. Thanks!

5 4

2nd Cfa TTT 2017 (Type Theory Based Tools)
by Andreas Abel 27 Nov '16

27 Nov '16

2ND CALL FOR ABSTRACTS TTT : Type Theory Based Tools ============================= Satellite workshop of POPL 2017, Paris France, January 15th [We have funding possibilities for students and young researchers, see below. Note the early deadline!] Overview ======== The aim of this workshop is to showcase modern tools based on type theory, whether designed for programming or for verification, whether academic projects or used in an industrial setting. It will provide a forum to highlight and discuss their common and their distinctive features, and the future directions of development of the tools. The program will consist of invited and contributed talks, and will encourage informal discussion. Abstracts will be displayed on the website of the workshop but there will be no proceedings. We solicit abstract submissions proposing demos, case studies, describing the impact of a theoretical result on practice, or any other aspect of the development and use of tools based on type theory. In particular, we welcome submissions about prototype implementations and promising work in progress, as soon as they have the potential of raising interesting discussions. This workshop is funded by the EUTypes COST project (https://eutypes.cs.ru.nl/) The program will include a plenary discussion on the role of the EUTypes project in the community and planning of activities for 2017. Invited Speakers ================ Robbert Krebbers, Delft University of Technology, Netherlands Aaron Tomb, Galois, US More speakers to be confirmed Registration ============ Registration information will be soon available at the main POPL 2017 website: http://conf.researchr.org/home/POPL-2017 Participant funding =================== The EUTypes COST project (https://eutypes.cs.ru.nl/) can fund students and young researchers from countries participating in the project to attend the workshop – check http://www.cost.eu/COST_Actions/ca/CA15123?parties to see if your country is listed. The application should include the following information: * Your name * Your institution * The name of your supervisor(s) * The url of your webpage if you have one * Your research topics or interests in 1 paragraph and should be sent to ttt2017(a)easychair.org as soon as possible and no later than November 20th. Contact ======= For any query about this workshop, please contact us at ttt2017(a)easychair.org Call for abstracts ================== Submissions for talks and demonstrations should be described in an extended abstract, between 1 and 2 pages in length. We suggest formatting the text using the two-column SIGPLAN LaTeX style (9pt font). Submission page: https://easychair.org/conferences/?conf=ttt2017 Important dates =============== Submission deadline: 30 November 2016 Notification: 15 December 2016 Workshop: 15 January 2017 Program Committee ================= Andreas Abel, Gothenburg University, Sweden Andrej Bauer, University of Ljubljana, Slovenia Assia Mahboubi, Inria Université Paris-Saclay, France Keiko Nakata, Germany -- Andreas Abel <>< Du bist der geliebte Mensch. Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden andreas.abel(a)gu.se http://www2.tcs.ifi.lmu.de/~abel/ _______________________________________________ Haskell-Cafe mailing list To (un)subscribe, modify options or view archives go to: http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe Only members subscribed via the mailman list are allowed to post. -- Andreas Abel <>< Du bist der geliebte Mensch. Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden andreas.abel(a)gu.se http://www2.tcs.ifi.lmu.de/~abel/

1 0

Haskell TLS and monad-control?
by Viktor Dukhovni 25 Nov '16

25 Nov '16

[ Knowledge of DANE entirely optional, if some of the below is Greek to you, just skip the bits that are unfamiliar. ] I have the beginning of a DANE verification module for hs-tls as an alternative to Data.X509.Validation. So far it just handles the easy case of checking just the leaf certificate against DANE-EE(3) certificate usage TLSA records, the rest is more complex, but follows naturally enough. Having verified the certificate a la DANE, I'd like to be able to return more detail to the caller than just success/failure. This part seems difficult to do cleanly. The TLS client state is encapsulated in a State monad which keeps track of the shared (SMTP) protocol state across a source/conduit/sink triple: type SmtpM = StateT ProtoState IO source :: Source SmtpM ByteString proto :: Conduit ByteString SmtpM ByteString sink :: Sink ByteString SmtpM () When the peer supports STARTTLS, I perform a TLS handshake, and make use of a TLS-enabled source/sink pair. This works well enough, but I also need to capture TLS-handshake metadata in the protocol state: * The peer's validated certificate chain. * The DNS name matched in the peer certificate. * Which TLSA record matched the peer's chain * ... A plausible interface is for the DANE version of the X509 verification code to expose one or more optional callbacks that will invoke a function of the caller's choice that will be passed the desired metadata. It would then be up to that function to squirrel this data away for later use. If this callback were to be invoked in the context of the application state monad, I'd just call "modify" in the callback and examine the results post-handshake as needed. However, life is not so simple. The TLS handshake is performed via Network.TLS.handshake, which internally calls the certificate verification code via: processCertificate :: ClientParams -> Context -> Handshake -> IO (RecvState IO) processCertificate cparams ctx (Certificates certs) = do -- run certificate recv hook ctxWithHooks ctx (\hooks -> hookRecvCertificates hooks $ certs) -- then run certificate validation usage <- catchException (wrapCertificateChecks <$> checkCert) rejectOnException case usage of CertificateUsageAccept -> return () CertificateUsageReject reason -> certificateRejected reason return $ RecvStateHandshake (processServerKeyExchange ctx) where shared = clientShared cparams checkCert = (onServerCertificate $ clientHooks cparams) (sharedCAStore shared) (sharedValidationCache shared) (clientServerIdentification cparams) certs processCertificate _ ctx p = processServerKeyExchange ctx p which lives in the base IO monad, and even if I pass in the current state to the `checkCert` hook, there is no opportunity to return the modified state into a context where "restoreM" can make appropriate updates in the caller. The best I can do is provide the hook with a suitable mutable object (likely an MVar). Interestingly enough, the outer Network.TLS.handshake function appears to be more flexible: handshake :: MonadIO m => Context -> m () Which makes possible calls of the form: res <- liftBaseWith $ \runInIO -> do Sys.timeout tmout $ Sys.tryIOError $ runInIO $ TLS.handshake ctx case res of Just x | Right st <- x -> restoreM st; ... success ... | Left e <- x -> ... I/O Error ... _ -> ... timeout ... which turn out futile, since `handshake` immediately switches to doing all the work in the IO monad, and so the underlying internals are not compatible with MonadControl. This prevents back-propagation of state changes via the various callbacks in TLS.ClientParams.clientHooks. -- | Handshake for a new TLS connection -- This is to be called at the beginning of a connection, and during renegotiation handshake :: MonadIO m => Context -> m () handshake ctx = liftIO $ handleException $ withRWLock ctx (ctxDoHandshake ctx $ ctx) where handleException f = catchException f $ \exception -> do let tlserror = maybe (Error_Misc $ show exception) id $ fromException exception setEstablished ctx False sendPacket ctx (errorToAlert tlserror) handshakeFailed tlserror So my question is whether it makes sense to rework the TLS modules to live in a more abstract monad (as in the handshake function) and only work in the base IO monad briefly, when performing actual I/O operations? Thus, perhaps instead: processCertificate :: MonadIO m => ClientParams -> Context -> Handshake -> m (RecvState m) ... Doing this throughout the TLS stack looks a lot of work, so the question is perhaps whether such an effort would be justified? Or is it too late to retrofit monad control over large existing code bases, with the monad control pattern mostly suitable just for de novo work? -- Viktor.

1 0