- Haskell-Cafe - Haskell.org

Possible ghc bug
by Michel Haber 10 Apr '19

10 Apr '19

Hello Cafe, I was trying to load a module containing this function in ghci: "add x y = wrap $ unwrap x + unwrap y" with the following extensions activated: ConstraintKinds DataKinds DeriveFunctor DuplicateRecordFields FlexibleContexts FlexibleInstances GADTs KindSignatures MultiParamTypeClasses PolyKinds TypeFamilies TypeOperators AllowAmbiguousTypes And it loaded without problem. So then I tested its type with ":t add", which gave: add :: (Num a, Newtype a b1, Newtype a b2, Newtype a b3) => b2 -> b3 -> b1 Then I added this signature to the function in the module. This caused ghci to refuse to load it and give the following error: src/Exercises.hs:55:11: error: • Could not deduce (Newtype Integer b1) arising from a use of ‘wrap’ from the context: (Num a, Newtype a b1, Newtype a b2, Newtype a b3) bound by the type signature for: add :: forall a b1 b2 b3. (Num a, Newtype a b1, Newtype a b2, Newtype a b3) => b2 -> b3 -> b1 at src/Exercises.hs:54:1-74 • In the expression: wrap $ unwrap x + unwrap y In an equation for ‘add’: add x y = wrap $ unwrap x + unwrap y | 55 | add x y = wrap $ unwrap x + unwrap y | ^^^^^^^^^^^^^^^^^^^^^^^^^^ src/Exercises.hs:55:18: error: • Could not deduce (Newtype Integer b2) arising from a use of ‘unwrap’ from the context: (Num a, Newtype a b1, Newtype a b2, Newtype a b3) bound by the type signature for: add :: forall a b1 b2 b3. (Num a, Newtype a b1, Newtype a b2, Newtype a b3) => b2 -> b3 -> b1 at src/Exercises.hs:54:1-74 • In the first argument of ‘(+)’, namely ‘unwrap x’ In the second argument of ‘($)’, namely ‘unwrap x + unwrap y’ In the expression: wrap $ unwrap x + unwrap y | 55 | add x y = wrap $ unwrap x + unwrap y | ^^^^^^^^ src/Exercises.hs:55:29: error: • Could not deduce (Newtype Integer b3) arising from a use of ‘unwrap’ from the context: (Num a, Newtype a b1, Newtype a b2, Newtype a b3) bound by the type signature for: add :: forall a b1 b2 b3. (Num a, Newtype a b1, Newtype a b2, Newtype a b3) => b2 -> b3 -> b1 at src/Exercises.hs:54:1-74 • In the second argument of ‘(+)’, namely ‘unwrap y’ In the second argument of ‘($)’, namely ‘unwrap x + unwrap y’ In the expression: wrap $ unwrap x + unwrap y | 55 | add x y = wrap $ unwrap x + unwrap y | ^^^^^^^^ Failed, no modules loaded. This does not make sense to me, since I only used the signature that ghci itself gave me. Is this a bug? if not, could someone please explain this behaviour to me? Thanks, Michel

4 7

ANN: gitlab-haskell
by Rob Stewart 10 Apr '19

10 Apr '19

This new gitlab-haskell library provides read/write access to data on a GitLab server, using the GitLab web API. The library provides access to: branches, commits, groups, issues, jobs, members, merge requests, pipelines, projects, repositories, repository files and users. JSON responses are parsed into typed Haskell values for convenience. https://hackage.haskell.org/package/gitlab-haskell-0.1.0.0 -- Rob Stewart

2 1

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

10 Apr '19

>> 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) > > That's the thing I was saying destroys streaming. The problem is that > it returns ([log], [a]), instead of [Either log a], so the > interleaving has been lost. > Evan, When you say interleaving, do you think of lists like the following? [Left warning1,Right value 1,Left warning 2,Right value2,...] The above is isomorphic to [(warning1,value1),(warning2,value2),...] I don't think that the writer monad destroys streaming. Below is a somewhat contrived, but ordinary use case. {-- begin example --} import Control.Monad.Writer -- from mtl type Log = [String] -- some Monoid half :: Int -> Writer Log Int half x = case x `quotRem` 2 of (y,0) -> return y (y,1) -> writer (y,["Warning: "++(show x)++" was uneven."]) stream :: [Int] stream = 4:8:5:3:7:2: error "broken stream" (ys,warnings) = runWriter (mapM half stream) {-- end example --} ghci> -- load the example above ghci> ys [2,4,2,1,3,1*** Exception: broken stream ghci> mapM_ putStrLn warnings Warning: 5 was uneven. Warning: 3 was uneven. Warning: 7 was uneven. *** Exception: broken stream You see that there is some output before the error is reached, proving that both ys and warnings could be consumed in a streaming manner. Here it is important that the Log monoid's `mappend` function is not strict in the second argument. It would not, for example, work with Log = Data.Sequence.Seq String With mtl you could easily throw in a State monad component that keeps track of the position in the stream, so that warning messages can hint at the place where the warning originated. Olaf

2 2

[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 09 Apr '19

09 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