April 2019 - Haskell-Cafe

[Announcement] Copilot 3.0, a hard realtime C generator and runtime verification framework
by Frank Dedden 09 Apr '19

09 Apr '19

Dear all, We are very pleased to announce the release of Copilot 3.0, a stream-based DSL for writing and monitoring embedded C programs, with an emphasis on correctness and hard realtime requirements. Copilot is typically used as a runtime verification framework, where programs serve as specifications to the system we want to monitor. Additional libraries provide utility functions for temporal logic (LTL, PTLTL and MTL), clocks and voting algorithms. Over the years, Copilot has been used at the Safety Critical Avionics Systems Branch of NASA Langley Research Center for monitoring test flights of drones. This new release contains a number of additional features that make writing programs easier: * The extended language with support for monitoring and generating structs and arrays in a type-safe manner. * A completely rewritten C99 code generator to support the new features. * Significant improvements on the quality and readability of the output code, which help in traceability and certification of the code. * Internal simplifications for a more future proof codebase. Copilot is available on hackage [1]. For more information, including documentation, examples and links to the source code, please visit the webpage [2]. Kind regards, The Copilot developers: - Frank Dedden (maintainer) - Alwyn Goodloe (maintainer) - Ivan Perez [1] http://hackage.haskell.org/package/copilot [2] https://copilot-language.github.io

1 0

OO "dot" notation and records...
by Nicholls, Mark 09 Apr '19

09 Apr '19

Is there something in Haskell like this? I could do with getting OO like intelisense going...i.e. you have some values, the types are inhered in my environment, and the available functions prompt the programmer. (I'm not a big Haskell user, but I'm trying to "sell" it as an alternative for F# and scala in an industrial context). CONFIDENTIALITY NOTICE This e-mail (and any attached files) is confidential and protected by copyright (and other intellectual property rights). If you are not the intended recipient please e-mail the sender and then delete the email and any attached files immediately. Any further use or dissemination is prohibited. While MTV Networks Europe has taken steps to ensure that this email and any attachments are virus free, it is your responsibility to ensure that this message and any attachments are virus free and do not affect your systems / data. Communicating by email is not 100% secure and carries risks such as delay, data corruption, non-delivery, wrongful interception and unauthorised amendment. If you communicate with us by e-mail, you acknowledge and assume these risks, and you agree to take appropriate measures to minimise these risks when e-mailing us. MTV Networks International, MTV Networks UK & Ireland, Greenhouse, Nickelodeon Viacom Consumer Products, VBSi, Viacom Brand Solutions International, Be Viacom, Viacom International Media Networks and VIMN and Comedy Central are all trading names of MTV Networks Europe. MTV Networks Europe is a partnership between MTV Networks Europe Inc. and Viacom Networks Europe Inc. Address for service in Great Britain is 17-29 Hawley Crescent, London, NW1 8TT.

2 1

looking for yesod-auth example with LTS-13
by Johannes Waldmann 09 Apr '19

09 Apr '19

Dear Cafe, I am trying to update some legacy code, and I have trouble getting yesod-auth to work under LTS-13. It worked with LTS-10. I think the error in this demonstration project (not mine) is related to what I am seeing: https://github.com/TobyGoodwin/auth38/issues/1 My actual code (and error message) is here https://gitlab.imn.htwk-leipzig.de/autotool/all0/issues/565 but "auth38" is certainly easier to reproduce. I was unable to apply this idea: https://stackoverflow.com/questions/23188494/yesod-subsites-and-forms/29394… (which seems dated - the HandlerT type is gone?) Any ideas? Thanks - J.W.

1 1

Package takeover intent - dyre
by Fraser Tweedale 09 Apr '19

09 Apr '19

The dyre[1] package is unmaintained for 5 years. I would like to contribute to it or take over maintainership, but have been unable to contact the maintainer (Cc'd). Pursuant to wiki[2] I am announcing my intention to take over the package. [1] https://hackage.haskell.org/package/dyre [2] https://wiki.haskell.org/Taking_over_a_package Thanks, Fraser

1 1

[ANNOUNCE] comprehensions-ghc: ApplicativeComprehensions as a GHC plugin
by Matthew Farkas-Dyck 08 Apr '19

08 Apr '19

https://hackage.haskell.org/package/comprehensions-ghc See description for instructions how to use. A comprehension makes more sense than a `do` expression for `Applicative` types — `ApplicativeDo` relies on a kludge: checking whether the last expression has the form `pure _` or `return _`. Indeed, for an `Applicative` term, it can ultimately (modulo aliases, let-expressions, η-expansion, etc) have no other! So far, however, the plugin merely rewrites each comprehension as a `do` expression. (It ignores comprehensions with features which can't be converted.) My most compelling use case so far has been context-free-parsing records (for examples: with `optparse-applicative` or `regex-applicative`). It lets one write the following: `[Options {..} | foo <- parseFoo, bar <- parseBar]` Cheers, happy hacking ☺

1 0

Re: [Haskell-cafe] streaming with logs / metadata
by Olaf Klinke 08 Apr '19

08 Apr '19

Dear Evan, Probably you want to have a look whether the mtl package has something for you. Anything beyond the Functor instance for (Either e), though, models exceptions that abort the computation as soon as the first Left arises. You seem to use the type in a different way which may be one reason why you do not find your functions implemented elsewhere. For logging or warnings, most Haskellers use something like a writer monad transformer. The underlying monad, Writer w a = (w,a) for some monoid w, is exceptionally versatile because of the function Functor f => Writer w (f a) -> f (Writer w a) which in combination with traverse lets you move the (Writer w) type in and out of nested types easily. Cheers, Olaf

2 1

GHC extensions
by Michel Haber 08 Apr '19

08 Apr '19

Hello Cafe, So I've been learning a bit about the GHC extensions from https://github.com/i-am-tom/haskell-exercises. But the lessons say nothing about how the extensions work behind the scenes. For example, I've assumed that RankNTypes would require something similar to dynamic dispatch in imperative languages in order to work. But this is just an assumption. So I was wondering where I can get a quick succinct read (or a summary at least) about how these extensions are implemented, as well as their performance cost (or gain!). Also if someone knows other tutorials and lessons for these, and other extensions, please feel free to share them :p Thank you, Michel :)

4 4

[ANNOUNCE] GHC 8.6.5-rc1 is now available
by Ben Gamari 08 Apr '19

08 Apr '19

Hello everyone, The GHC team is proud to announce the first release candidate of 8.6.5. The source distribution, binary distributions, and documentation are available at https://downloads.haskell.org/~ghc/8.6.5-rc1 This release fixes a handful of issues with 8.6.4: - Binary distributions once again ship with Haddock documentation including syntax highlighted source of core libraries (#16445) - A build system issue where use of GCC with `-flto` broke `configure` was fixed (#16440) - An bug affecting Windows platforms wherein XMM register values could be mangled when entering STG has been fixed (#16514) - Several Windows packaging issues resulting from the recent CI rework. (#16408, #16398, #16516) Since this is a relatively small bugfix release we are bypassing the alpha releases and moving right to the release candidate stage. If all goes well the final release will be cut next week. As always, if anything looks amiss do let us know. Happy testing! Cheers, - Ben

1 0

[ANN] Haskell.Org Discourse Instance
by Jasper Van der Jeugt 08 Apr '19

08 Apr '19

Hello all, We would like to announce a new discourse-based forum for the Haskell community, at: https://discourse.haskell.org/ This is inspired by the Rust, Nix and Elm discourse instances, where these forums have had a strong positive effect on the community. We will run this as a "beta" for 6 months and then evaluate its usefulness. It is meant as an extra alternative to Haskell-cafe, reddit and Haskell IRC, but it does not replace any of those. Discourse is completely open source and easily accessible using an email client. We would like to thank the Haskell.Org admin team for provisioning a server and Matthew Pickering for suggesting this and doing the hard work setting up the instance. Warm regards, Jasper Van der Jeugt on behalf of the Haskell.Org Committee

4 3

streaming with logs / metadata
by Evan Laforge 07 Apr '19

07 Apr '19

I have a pattern that's come up several times, and I'm wondering if there's a name for it, or a better way to do it. It has to do with processing streams, which in the presence of laziness and the absence of effects can be done with just lists. For instance, imagine a parser that produces [Token], then various processing stages that go [Token] -> [x], [x] -> [y], [y] -> [Output]. If I have a transform function that works on a single element 1:1 and is stateless, then I can express it with 'map'. If it needs simple state, then I can switch 'map' for 'mapAccumL', which is just a specialization of the State monad. If it needs to know the next element, I can compose a 'zipNext' (zip xs (drop 1 xs)) on the front. If it returns multiple elements, there's concatMap, and of course mapM for arbitrary monads. Now suppose it needs warnings, or logging, so to preserve streaming I wind up with '[Either e a] -> [Either e b]'. I still want to do all the same stuff, but factor out the Lefts so I don't have to be explicitly passing through all the time. So I start reimplementing the usual list functions: module E where map :: (a -> b) -> [Either e a] -> [Either e b] mapE :: (a -> Either e b) -> [Either e a] -> [Either e b] concatMap :: (a -> [b]) -> [Either e a] -> [Either e b] concatMapE :: (a -> [Either e b]) -> [Either e a] -> [Either e b] mapAccumL :: (state -> a -> (state, Either e b)) -> state -> [Either e a] -> (state, [Either e b]) And of course the monadic / applicative variants: mapM :: Applicative m => (a -> m b) -> [Either e a] -> [Either e b] mapEM :: Monad m => (a -> m (Either e b)) -> [Either e a] -> m [Either e b] ... etc. But to deal with supplying extra state, or looking into the future or filtering I have to reinvent those too: zip :: [a] -> [Either e b] -> [Either e (a, b)] zip{2,3,4,...} :: ... zipNexts :: [Either e a] -> [Either e (a, [a])] filter :: (a -> Bool) -> [Either e a] -> [Either e a] The zips become asymmetrical, but they're in service of a common pattern which I'm not sure how to describe, but is used to get the Lefts out of the way. E.g. if a duration can be derived from a Right value, to annotate Rights with start times: 'E.zip (scanl (+) 0 (map durationOf (Either.rights xs))) xs'. It's a bit unsatisfying because it relies on the transformation preserving 1:1 with its input, or at least new elements are added only at the end and I can ignore them. 'scanl . map' happens to have this property, but it's not obvious or guaranteed. My questions are, is this a known pattern? Is there an implementation on hackage, or at least a good thing to call it? And then, is there a a way to construct these functions systematically, or to compose them from smaller parts? The 1:1 stateless ones like 'map' and 'mapM' work out nicely because they're just 'fmap . fmap' or 'traverse . traverse', and I can implement 'concatMapM' and then implement a lot of other kinds of maps as specializations, though efficiency may suffer. But for the zips and filters and takeWhiles I wind up just rewriting the recursion. They feel ad-hoc and unsatisfying, that if I were more clever I would figure out how to abstract out the Lefts in one spot, once and for all. There is a general way to get all of the '[a] -> [b]' functions into '[Either e a] -> [Either e b]', and that's to partitionsEithers, apply second, then concat, but of course it spoils streaming and is inefficient if there are lots of Lefts. Still, it's the only way I can think of to get those Lefts out of the picture in a modular way. Using a Writer I think is equivalent. There's a similar problem with being able factor out annotations, similar to the way I want to factor out logs / warnings / other metadata above. E.g. if we have '[(annot, a)] -> [(annot, b)]' then we start with a simple fmap.fmap, but any more complicated transforms means you either have to intersperse the "ignore annotation" logic and clutter things up with 'snd's and 'second's everywhere, or come up with a whole new map filter zip toolkit.

1 0