- Haskell-Cafe - Haskell.org

Logging
by Olaf Klinke 22 Nov '21

22 Nov '21

Dear Hilco, attached is a module we use in production. It builds on top of the monad-logger package which is used, among other places, in Yesod. Olaf

1 0

Re: [Haskell-cafe] Logging
by Olaf Klinke 22 Nov '21

22 Nov '21

As someone who works with timeseries for a living, I can say that what is a nightmare is timestamps that do not correspond to a unique UTC time. So you'd want a ZonedTime timestamp. I've been using monad-logger and rolled my own extension which adds (formatted) time stamps to the log messages. Olaf

1 0

Locate errors in TH for Haskell code
by Anton Kholomiov 21 Nov '21

21 Nov '21

I have a task to convert one Haskell expression to another. And I'd like to report errors properly. [interpret| -- error reported here valid haskell code invalid code <- error |] I can parse it with haskell-src-exts or haskell-src-meta. but if I have error in the code (type-check) error is positioned on the first line of the QQ-expression. Do you know is it possible to report error at the line where it has happened or to keep original source code location in the Exp. In the function I do transformation Exp -> Exp. Or maybe there is a better way to do it instead of QQ?

4 4

Re: [Haskell-cafe] code in postings mangled?
by Olaf Klinke 19 Nov '21

19 Nov '21

> Why is code in postings so often mangled: > Seems it is only the linebreaks. Some programs on Windows, including TextEdit and likely your mail client, don't consider a newline '\n' character to be a line break, since Windows terminates lines by "\r\n". Then OS X has '\r' line terminators, which again might not be considered a linebreak on some systems. I remember all kinds of stupid things arising from this, including version control systems flagging every line as changed when it was only the line breaks. I read this list as digest, so I can not verify using the particular raw email you quoted. Can someone else check this? Regards, Olaf

2 1

Partial record access
by Georgi Lyubenov 19 Nov '21

19 Nov '21

Hey Cafe, With the advent of RecordDotSyntax (or more precisely OverloadedRecordDot?) in 9.2, I was expecting this wart to be fixed: data Ty = X {x :: String} | Y {y :: Int} > y $ X "lol" *** Exception: No match in record selector y As it seems like the perfect opportunity to introduce a breaking change for a behaviour that is usually undesirable (in my experience). But instead: > :set -XOverloadedRecordDot > (X "lol").y *** Exception: No match in record selector y Unfortunately, I couldn't follow and/or remember all of the discussion around RecordDotSyntax, so this might be something I missed. Is there a reason why we don't generate HasField x r a only when all of the constructors for r have a field "x" :: a? If not, is the community open to changing this, while the new extension is still ripe? Cheers! ======= Georgi

2 2

[ANN] Release candidate for `mtl-2.3`
by Emily Pillmore 19 Nov '21

19 Nov '21

Hello all, Chessai and I are excited to announce a release candidate for `mtl`: [`mtl-2.3-rc3`]( https://github.com/haskell/mtl/releases/tag/v2.3-rc3 )! ## Timeline The timeline for release will be as follows: - This announcement marks the start of the timeline - We will give 2 weeks of testing before considering release - If no major issues are filed before then, `mtl-2.3-rc3` will be released as `mtl-2.3`, and if issues are found, they will be amended, and a new release candidate will be announced, resetting the 2 week period. To test `mtl-2.3-rc3` for yourself, please feel free to add the following to your `cabal.project`: ``` source-repository-package type: git location: https://github.com/haskell/mtl.git tag: 5d0f62b8007bb96e49f36a5544741cfe96a97130 ``` or, if you're a stack user add this entry to your `extra-deps`: ``` - git: https://github.com/haskell/mtl.git commit: 5d0f62b8007bb96e49f36a5544741cfe96a97130 ``` And make sure to adjust all bounds/`allow-newer` accordingly. Please note that this release of `mtl` is a full major version release, and *will be the last of the 2.x series before work begins on updating the mtl class hierarchy*. ## Changelog * Add instances for `Control.Monad.Trans.Writer.CPS` and `Control.Monad.Trans.RWS.CPS` from `transformers` 0.5.6 and add `Control.Monad.Writer.CPS` and `Control.Monad.RWS.CPS`. * `Control.Monad.Cont` now re-exports `evalCont` and `evalContT` * Add `tryError`, `withError`, `handleError`, and `mapError` to `Control.Monad.Error.Class`, and re-export from `Control.Monad.Except`. * Remove `Control.Monad.List` and `Control.Monad.Error` * Remove instances of deprecated `ListT` and `ErrorT` * Remove re-exports of `Error` * Add instances for `Control.Monad.Trans.Accum` and ` Control.Monad.Trans.Select ( http://control.monad.trans.select/ ) ` * Remove re-exports of `Control.Monad`, `Control.Monad.Fix` and `Data.Monoid` modules I'd like to thank the many contributors who offered patches, tickets, and other help in the preparation of this release. We appreciate all of your help! Happy hacking! Emily

1 0

[ANNOUNCE] GHC 9.2.1 now available
by Ben Gamari 18 Nov '21

18 Nov '21

Hi all, The GHC developers are very happy to at long last announce the availability of GHC 9.2.1. Binary distributions, source distributions, and documentation are available at https://downloads.haskell.org/ghc/9.2.1 GHC 9.2 brings a number of exciting features including: * A native code generation backend for AArch64, significantly speeding compilation time on ARM platforms like the Apple M1. * Many changes in the area of records, including the new `RecordDotSyntax` and `NoFieldSelectors` language extensions, as well as Support for `DuplicateRecordFields` with `PatternSynonyms`. * Introduction of the new `GHC2021` language extension set, giving users convenient access to a larger set of language extensions which have been long considered stable. * Merging of `ghc-exactprint` into the GHC tree, providing infrastructure for source-to-source program rewriting out-of-the-box. * Introduction of a `BoxedRep` `RuntimeRep`, allowing for polymorphism over levity of boxed objects (#17526) * Implementation of the `UnliftedDataTypes` extension, allowing users to define types which do not admit lazy evaluation ([proposal]) * The new [`-hi` profiling] mechanism which provides significantly improved insight into thunk leaks. * Support for the `ghc-debug` out-of-process heap inspection library [ghc-debug] * Significant improvements in the bytecode interpreter, allowing more programs to be efficently run in GHCi and Template Haskell splices. * Support for profiling of pinned objects with the cost-centre profiler (#7275) * Faster compilation and a smaller memory footprint * Introduction of Haddock documentation support in TemplateHaskell (#5467) Finally, thank you to Microsoft Research, GitHub, IOHK, the Zw3rk stake pool, Tweag I/O, Serokell, Equinix, SimSpace, and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Moreover, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release. As always, do open a [ticket] if you see anything amiss. Happy testing, - Ben [apple-m1]: https://www.haskell.org/ghc/blog/20210309-apple-m1-story.html [proposal]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0265-u… [-hi profiling]: https://well-typed.com/blog/2021/01/first-look-at-hi-profiling-mode/ [ghc-debug]: http://ghc.gitlab.haskell.org/ghc-debug/ [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new

3 2

type checking failure curiosity
by Julian Bradfield 18 Nov '21

18 Nov '21

In the course of updating a tutorial for this year's course, I found the provided code didn't compile. This is because a key value is "undefined" in order for the students to fill it in, but I'm curious why it can't be typechecked nonetheless. The code is: reachable :: (Ord q) => FSM q -> Set(Set(q)) -> Set(Set(q)) reachable fsm@(FSM qs as ts ss fs) supers = let new :: Set(Set(q)) -- typechecking fails without this declaration new = undefined in if null new then supers else reachable fsm (supers \/ new) The \/ in the last line is just Set.union. On the face of it, the last term directly forces "new" to have type Set(Set(q)), so why doesn't Haskell see that? Without the explicit type declaration of "new", we get: • Could not deduce (Foldable t0) arising from a use of ‘null’ from the context: Ord q bound by the type signature for: reachable :: forall q. Ord q => FSM q -> Set (Set q) -> Set (Set q) at CLTutorial9.hs:127:1-60 The type variable ‘t0’ is ambiguous These potential instances exist: instance Foldable (Either a) -- Defined in ‘Data.Foldable’ instance Foldable Set -- Defined in ‘Data.Set.Internal’ instance Foldable Maybe -- Defined in ‘Data.Foldable’ ...plus two others ...plus 27 instances involving out-of-scope types (use -fprint-potential-instances to see them all) • In the expression: null new In the expression: if null new then supers else reachable fsm (supers \/ new) In the expression: let new = undefined in if null new then supers else reachable fsm (supers \/ new) | 130 | in if null new then supers else reachable fsm (supers \/ new) | ^^^^^^^^

4 5

code in postings mangled?
by Gregory Guthrie 17 Nov '21

17 Nov '21

Why is code in postings so often mangled: Subject: [Haskell-cafe] ContT and MonadSafe ... Then I implement this kind of method withHdf5PathP :: (MonadSafe m, Location l) => l -> Hdf5Path sh e -> (Dataset -> m r) -> m r withHdf5PathP loc (H5RootPath subpath) f = withHdf5PathP loc subpath f withHdf5PathP loc (H5GroupPath n subpath) f = withGroupP (openGroup loc n Nothing) $ \g -> withHdf5PathP g subpath f withHdf5PathP loc (H5GroupAtPath i subpath) f = withGroupAtP loc i $ \g -> withHdf5PathP g subpath f withHdf5PathP loc (H5DatasetPath n) f = withDatasetP (openDataset' loc n Nothing) f withHdf5PathP loc (H5DatasetPathAttr (a, c)) f = withDatasetP (openDatasetWithAttr loc a c) f withHdf5PathP loc (H5Or l r) f = withHdf5PathP loc l f `catchAll` const (withHdf5PathP loc r f) I decided to switch to the ContT transfomer and try to implement this like this withHdf5PathP :: (MonadSafe m, Location l) => l -> Hdf5Path sh e -> ContT r m Dataset withHdf5PathP loc (H5RootPath subpath) = withHdf5PathP loc subpath withHdf5PathP loc (H5GroupPath n subpath) = do g <- withGroupP (openGroup loc n Nothing) withHdf5PathP g subpath withHdf5PathP loc (H5GroupAtPath i subpath) = do g <- withGroupAtP loc i withHdf5PathP g subpath withHdf5PathP loc (H5DatasetPath n) = withDatasetP (openDataset' loc n Nothing) withHdf5PathP loc (H5DatasetPathAttr (a, c)) = withDatasetP (openDatasetWithAttr loc a c) withHdf5PathP loc (H5Or l r) = ???

2 1

ContT and MonadSafe
by PICCA Frederic-Emmanuel 16 Nov '21

16 Nov '21

Hello, I have some code like this data Hdf5Path sh e = H5RootPath (Hdf5Path sh e) | H5GroupPath ByteString (Hdf5Path sh e) | H5GroupAtPath Int (Hdf5Path sh e) | H5DatasetPath ByteString | H5DatasetPathAttr (ByteString, ByteString) | H5Or (Hdf5Path sh e) (Hdf5Path sh e) deriving (Show) Then I implement this kind of method withHdf5PathP :: (MonadSafe m, Location l) => l -> Hdf5Path sh e -> (Dataset -> m r) -> m r withHdf5PathP loc (H5RootPath subpath) f = withHdf5PathP loc subpath f withHdf5PathP loc (H5GroupPath n subpath) f = withGroupP (openGroup loc n Nothing) $ \g -> withHdf5PathP g subpath f withHdf5PathP loc (H5GroupAtPath i subpath) f = withGroupAtP loc i $ \g -> withHdf5PathP g subpath f withHdf5PathP loc (H5DatasetPath n) f = withDatasetP (openDataset' loc n Nothing) f withHdf5PathP loc (H5DatasetPathAttr (a, c)) f = withDatasetP (openDatasetWithAttr loc a c) f withHdf5PathP loc (H5Or l r) f = withHdf5PathP loc l f `catchAll` const (withHdf5PathP loc r f) I decided to switch to the ContT transfomer and try to implement this like this withHdf5PathP :: (MonadSafe m, Location l) => l -> Hdf5Path sh e -> ContT r m Dataset withHdf5PathP loc (H5RootPath subpath) = withHdf5PathP loc subpath withHdf5PathP loc (H5GroupPath n subpath) = do g <- withGroupP (openGroup loc n Nothing) withHdf5PathP g subpath withHdf5PathP loc (H5GroupAtPath i subpath) = do g <- withGroupAtP loc i withHdf5PathP g subpath withHdf5PathP loc (H5DatasetPath n) = withDatasetP (openDataset' loc n Nothing) withHdf5PathP loc (H5DatasetPathAttr (a, c)) = withDatasetP (openDatasetWithAttr loc a c) withHdf5PathP loc (H5Or l r) = ??? during the process, I also changed all the withXXX method to use Continuation. -bracket' :: MonadSafe m => (a -> IO ()) -> IO a -> (a -> m r) -> m r -bracket' r a = bracket (liftIO a) (liftIO . r) +bracket' :: MonadSafe m => (a -> IO ()) -> IO a -> ContT r m a +bracket' r a = ContT (bracket (liftIO a) (liftIO . r)) -withBytes :: MonadSafe m => Int -> (ForeignPtr a -> m r) -> m r +withBytes :: MonadSafe m => Int -> ContT r m (ForeignPtr a) withBytes n = bracket' touchForeignPtr (mallocForeignPtrBytes n) -withFileP :: MonadSafe m => IO File -> (File -> m r) -> m r +withFileP :: MonadSafe m => IO File -> ContT r m File withFileP = bracket' closeFile -withGroupP :: MonadSafe m => IO Group -> (Group -> m r) -> m r +withGroupP :: MonadSafe m => IO Group -> ContT r m Group withGroupP = bracket' closeGroup -withGroupAtP :: (Location l, MonadSafe m) => l -> Int -> (Group -> m r) -> m r -withGroupAtP l i f = do +withGroupAtP :: (Location l, MonadSafe m) => l -> Int -> ContT r m Group +withGroupAtP l i = do es <- liftIO $ nxEntries' l - withGroupP (openGroup l (es !! i) Nothing) f + withGroupP (openGroup l (es !! i) Nothing) -withDatasetP :: MonadSafe m => IO Dataset -> (Dataset -> m r) -> m r +withDatasetP :: MonadSafe m => IO Dataset -> ContT r m Dataset withDatasetP = bracket' closeDataset -withDataspaceP :: MonadSafe m => IO Dataspace -> (Dataspace -> m r) -> m r +withDataspaceP :: MonadSafe m => IO Dataspace -> ContT r m Dataspace withDataspaceP = bracket' closeDataspace The H5Or is a sort of Alternative which try to extract the info from l and if any exception is triggered switch to the right part r. Would you be so kind to help me write the H5Or part with the continuation. I am not sure that I understand all the ContT arcanes. thanks for your help Frederic

2 2