- Haskell-Cafe - Haskell.org

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

haskell-ci problems
by Sven Panne 16 Nov '21

16 Nov '21

I am (finally) about to switch my Haskell projects on GitHub from Travis CI to GitHub Actions, so I've tried haskell-ci (from HEAD) for creating the workflow files from the .cabal files. But something went wrong, see https://github.com/haskell-opengl/StateVar/actions/runs/1456427818/workflow Initially, I thought that this failure was related to using the latest and greatest GHC version, so I removed that, but the failure stays: https://github.com/haskell-opengl/StateVar/actions/runs/1456437461/workflow Any hints on what I'm doing wrong? Or is it a haskell-ci bug? Cheers, S.

4 10

About adding msync and anonymous mapping (virtual allocation) API to mmap package
by YueCompl 15 Nov '21

15 Nov '21

Dear Gracjan Polak, and Cafe for wider attention, I'm using the great [mmap](https://hackage.haskell.org/package/mmap <https://hackage.haskell.org/package/mmap>) package, and now I need 2 more features closely related to its existing features: - API to perform `msync` so as for: - A long running process to checkpoint the persistence of modifications - Parallel readers to see other writer's modification with cache coherence, i.e. invalidate cache as notified - API to do anonymous mmap-ping for volatile (virtual) memory allocation I expect the coding work to be trivial and intend to do it myself, however it's better to ask your opinion meanwhile I experiment with the ideas. Would you like to accept such features into [mmap] package? How do you think about details of such features? For the background of my needs: I'm working on a shared immutable heap implementation, persistency will be provided by disk backed storage servers, parallel work horse servers will build heap contents in rather coarse grained fashion, first as volatile heaps in one's private memory, then publish into shared storage with bulk writing, so all servers will be able to mmap such public heaps into their own memory address space, with kernel pages as cache shared by all processes on a same physical node. I hope it's okay to ask in the Cafe list at the same time, as I also anticipate more feedbacks/opinions from the list with broader expertise, will much appreciate! Thanks with best regards, Compl

1 0

Breaking change to Eq accepted by Core Libraries Committee
by Rune K. Svendsen 14 Nov '21

14 Nov '21

Dear list, I would like to bring attention to the fact that the Haskell “Core Libraries Committee” has just accepted a breaking change to the Eq type class in exchange for very little apparent benefit. Please use this GitHub issue to voice your opinion on the issue: https://github.com/haskell/core-libraries-committee/issues/3 I don’t think it’s been sufficiently discussed yet. /Rune

4 3

clz / bsr functions on Integer
by james faure 13 Nov '21

13 Nov '21

Why is there no `countLeadingZeros` function for Integer? This seems particularly strange because gmp provides mp_bitcnt_t mpz_scan0 (const mpz_t op, mp_bitcnt_t starting_bit) More importantly, what is the recommended way to access it?

4 3