February 2023 - Haskell-Cafe

HKD and Generic
by PICCA Frederic-Emmanuel 09 Feb '23

09 Feb '23

Hello, I have this class DataSource data family DataSourcePath a :: Type data family DataSourceAcq a :: Type class DataSource a where withDataSourceP :: (Location l, MonadSafe m) => l -> DataSourcePath a -> (DataSourceAcq a -> m r) -> m r The purpose is to acquire a ressources from a data source path (for example, in a hdf5 file, "hdf5://path/to/my/dataset" I need to obtain a C struct which point on the Dataset) and then do something with this ressources Here an example of an instance in order to extract an Angstrom from a file or provide directly the constant value. -- Angstrom data instance DataSourcePath Angstrom = DataSourcePath'Angstrom (Hdf5Path Z Double) | DataSourcePath'Angstrom'Const Angstrom deriving (Eq, Generic, Show, FromJSON, ToJSON) data instance DataSourceAcq Angstrom = DataSourceAcq'Angstrom Dataset | DataSourceAcq'Angstrom'Const Angstrom instance DataSource Angstrom where withDataSourceP f (DataSourcePath'Angstrom p) g = withHdf5PathP f p $ \ds -> g (DataSourceAcq'Angstrom ds) withDataSourceP _ (DataSourcePath'Angstrom'Const a) g = g (DataSourceAcq'Angstrom'Const a) next, I build a bunch of DataFrame which contain all these ressources. data DataFrameQCustom = DataFrameQCustom Attenuation -- attenuation Geometry -- geometry Image -- image Index -- timestamp in double deriving Show data instance DataSourcePath DataFrameQCustom = DataSourcePath'DataFrameQCustom (DataSourcePath Attenuation) (DataSourcePath Geometry) (DataSourcePath Image) (DataSourcePath Index) deriving (Eq, Generic, Show, FromJSON, ToJSON) data instance DataSourceAcq DataFrameQCustom = DataSourceAcq'DataFrameQCustom (DataSourceAcq Attenuation) (DataSourceAcq Geometry) (DataSourceAcq Image) (DataSourceAcq Index) Indded I now need to write the withDataSource instance by hand instance DataSource DataFrameQCustom where withDataSourceP f (DataSourcePath'DataFrameQCustom a g i idx) gg = withDataSourceP f a $ \a' -> withDataSourceP f g $ \g' -> withDataSourceP f i $ \i' -> withDataSourceP f idx $ \idx' -> gg (DataSourceAcq'DataFrameQCustom a' g' i' idx') this seems so mechanical that I am wondring if this should not be automatize via Generic. Another point would be to avoiding mistake when writting the DatasourcePath instance and Generate the from an uniq structure using HKD Something like -- "Higher-Kinded Data" type family HKD f a where HKD Identity a = a HKD f a = f a data DataFrameHkl' f = DataFrameHkl (HKD f DataFrameQCustom) (HKD f Sample) deriving (Generic) type DataFrameHkl = DataFrameHkl' Identity type DataFrameHklPath = DataFrameHkl' DataSourcePath so I would like your help in order to write first a Generic version of withDataSourceP I read this https://reasonablypolymorphic.com/blog/higher-kinded-data/ but I am not completly sure how to convert my withDataSourceP :: (Location l, MonadSafe m) => l -> DataSourcePath a -> (DataSourceAcq a -> m r) -> m r signature into something Generic Thanks for considering Fred

1 0

Volunteers wanted to administer a security advisory DB for Hackage
by David Christiansen 09 Feb '23

09 Feb '23

Hello fellow Haskellers, The HF is in the process of getting a security advisory database up and running for Haskell libraries, to enable both automated and manual audit workflows. We're looking for volunteers to help administer the database. If you have a background in security and would like to make a high-impact positive contribution to the Haskell ecosystem, please consider volunteering! More details are available at https://discourse.haskell.org/t/call-for-nominations-haskell-security-respo… . Thanks in advance! All the best, David Thrane Christiansen Executive Director The Haskell Foundation

1 0

Haskell Tiny Game Jam!
by Simon Michael 07 Feb '23

07 Feb '23

The first Haskell Tiny Game Jam is now open! All welcome! Your mission: make Haskell games in 10 lines. https://github.com/haskell-game/tiny-games-hs and the #haskell-game chat room await your entries. Best, -Simon

2 1

[ANN] Yampa-0.14.1
by Ivan Perez 07 Feb '23

07 Feb '23

Dear all, I'm happy to announce the release of Yampa 0.14.1! Yampa is a fast, elegant Functional Reactive Programming implementation. Yampa prides itself in being a long-standing community project. It has now been around for 20 years!!! This is probably the largest release to the Yampa project in a decade: The unit tests for all of Yampa's public API are now complete. Many of the new tests are implemented using QuickCheck, and care has been taken, whenever possible, to express the properties based on the continuous-time (FRP) interpretation of Yampa's primitives and combinators. Hopefully, this battery of tests will help speed up the process of accepting new features and changes, and will free resources that can be dedicated to investigating other issues. See https://github.com/ivanperez-keera/yampa#features for details on Yampa's features. * Summary of Version 0.14.1 - Complete remaining unit tests for all public API. - Fix typo in documentation.- Fix broken links in documentation. As always, Yampa and yampa-test are released in sync. For details, see: - https://github.com/ivanperez-keera/Yampa/releases/tag/v0.14.1 - https://github.com/ivanperez-keera/Yampa/blob/develop/yampa/CHANGELOG - https://github.com/ivanperez-keera/Yampa/blob/develop/yampa-test/CHANGELOG * Releases You can explore the current versions at: - https://hackage.haskell.org/package/Yampa - https://hackage.haskell.org/package/yampa-test * Code The github repo is located at: https://github.com/ivanperez-keera/Yampa * What's coming This release comes exactly 2 months after the last release. The next release is planned for Apr 7, 2023. There are several issues open that you can contribute to: https://github.com/ivanperez-keera/Yampa/issues Following our roadmap, the pending changes remain as follows: - Full conformance to style guide. - Removal of unnecessarily exposed elements from the interface (e.g., FRP.Yampa.Arrow.arr3) that are not used and belong in other libraries. This topic is open to discussion. - Benchmarks: Facilitate making sound, evidence-based decisions about suggested improvements to the implementation, by completing a series of benchmarks. - New mailing list: We will in the future lose access to Yale's CS department-based mailman list, and are thinking of the best place to move the mailing list to. * Donations Our project is now seeking donations to help continue developing Yampa, create new open source libraries, new material, and give talks. Special thanks go to @johannes-riecken for sponsoring my work on the Yampa project with a regular contribution. Github will match the first 5K donated, so if you donate $1/month, github will donate the same amount. No donation is too small. Any contribution will absolutely help. See https://github.com/sponsors/ivanperez-keera for details. If you can help, please come forward. All the best, Ivan

1 0

function composition and Rank2Types
by Olaf Klinke 04 Feb '23

04 Feb '23

Dear Cafe, I used to believe that f . g $ x is equivalent to f $ g x but apparently that is not the case when rank-2 types are involved. Counterexample: {-# LANGUAGE RankNTypes #-} type Cont = forall r. (() -> r) -> r data Foo = Foo Cont mkCont :: () -> Cont mkCont x = \f -> f x foo1 :: () -> Foo foo1 x = Foo $ mkCont x foo2 :: () -> Foo foo2 x = Foo . mkCont $ x The function foo1 type-checks, the function foo2 doesn't. And that is although ghci tells me that mkCont :: () -> Cont Foo :: Cont -> Foo so I should be able to compose? What is going on here? GHC 9.0.2 errors with • Couldn't match type ‘b0’ with ‘Cont’ Expected: b0 -> Foo Actual: Cont -> Foo Cannot instantiate unification variable ‘b0’ with a type involving polytypes: Cont • In the first argument of ‘(.)’, namely ‘Foo’ In the expression: Foo . mkCont and GHC 8.8.4 errors with • Couldn't match type ‘(() -> r0) -> r0’ with ‘Cont’ Expected type: ((() -> r0) -> r0) -> Foo Actual type: Cont -> Foo • In the first argument of ‘(.)’, namely ‘Foo’ In the expression: Foo . mkCont The latter suggests that r is unnecessarily specialized to some specific-yet-unknown r0 which destroys the universal quantification. Olaf

3 6

2nd Call for Participation: BOB 2023 (Berlin, March 17)
by Stefan Wehr 02 Feb '23

02 Feb '23

========================================================================= BOB 2023 Conference “What happens if we simply use what’s best?” March 17, 2023, Berlin https://bobkonf.de/2023/ Program: https://bobkonf.de/2023/program.html Registration: https://bobkonf.de/2023/registration.html ========================================================================= BOB conference is a place for developers, architects, and decision-makers to explore technologies beyond the mainstream in software development and to find the best tools available to software developers today. Our goal is for all participants of BOB to return home with new insights that enable them to improve their own software development experience. The program features 14 talks and 8 tutorials on current topics: https://bobkonf.de/2023/program.html Talk subjects includes functional programming, software architecture, accessibility, digital transformation, version control, formal methods, and devops. BOB will feature tutorials on Elixir, Scheme, Kotlin, Agda, Domain Storytelling, Hexagonal Frontend Architecture, and other topics. Yulia Startsev will give the keynote talk on "Re-thinking Modules for the Web". Registration is open - tickets are all under 200€, and many discount options are available, as are grants for members of groups underrepresented in tech: https://bobkonf.de/2023/registration.html

1 0

Haskell text
by Simon Thompson 02 Feb '23

02 Feb '23

I'm happy to announce that the PDF of Haskell, The Craft of Functional Programming (3rd edition) is available to view and download for free. Later in the year I'll revise it and make it available as an online text. But for now, here it is, uncorrected: https://simonjohnthompson.github.io/craft3e/craft3e.pdf Simon Sent from my iPhone

3 2

how to write a pipes Consumer which return a final state
by PICCA Frederic-Emmanuel 01 Feb '23

01 Feb '23

Hello, I try to create a pipes which return at the end a Cube. the process is quite simple 1) extract data from a file 2) comput a cube of data from these data 3) accumulate these cube during the process 4) when there is no more cube return the final cube I am trying for now to write the part with the 'state' which is hiden in a recursion like this. accumulateP :: (MonadIO m, Shape sh) => Cube sh -> Consumer (DataFrameSpace sh) m (Cube sh) accumulateP cube = do s <- await accumulateP =<< (liftIO $ addSpace s cube) the add Space method return the modified Cube At some point I should see that await can not return a value and I would decide to return the value instead of doing another loop My question is how do I stop this recursion and return the final cube ? thanks for your help.

1 0

multiline strings editor for emacs
by Markus Läll 01 Feb '23

01 Feb '23

Dear Cafe, searched, but this didn't turn up anything -- does there exist a "multiline string editor for emacs" in haskell? I.e something that would pop-out a new buffer to edit the string, and that would be inserted and slash-aligned back into the original file once done? This would be simple enough to implement, perhaps someone has already done it? (And just to be sure: there isn't a built-in multiline quasiquoter in base, right? I know that there are multitudes of packages that implement this, but would just like something that is built in.) Thanks! -- Markus Läll

5 4