January 2023 - Haskell-Cafe

Best way to implement "scoped exceptions"?
by Tom Ellis 16 Jun '23

16 Jun '23

I'd like to implement "scoped exceptions"[1], that is, a combinator of type withScopedException :: ((forall a. e -> IO a) -> IO r) -> IO (Either e r) so I can use exceptions in a convenient way, without having to set up fragile "action at a distance" based on the type of the thing I'm throwing and catching, for example: scopedExceptionExample :: IO (Either String (Either Int Void)) scopedExceptionExample = do withScopedException $ \throw1 -> withScopedException $ \throw2 -> if (1 :: Int) < 0 then throw1 "Hello" else throw2 1234 -- ghci> scopedExceptionExample -- Right (Left 1234) Here's a hacky way of doing it, based on tagging each exception with a unique value, and then filtering when handling: data MyException where MyException :: e -> Data.Unique.Unique -> MyException instance Show MyException where show _ = "<MyException>" instance Exception MyException withScopedException :: ((forall a. e -> IO a) -> IO r) -> IO (Either e r) wiathScopedException f = do fresh <- Data.Unique.newUnique flip tryJust (f (\e -> throwIO (MyException e fresh))) $ \case MyException e tag -> -- unsafeCoerce is very unpleasant if tag == fresh then Just (unsafeCoerce e) else Nothing This is the approach taken by the effectful library[2]. But is there a better way? Can I persuade GHC's RTS to work like this directly? Tom [1] I don't know if these already have a name [2] https://hackage.haskell.org/package/effectful-core-2.2.1.0/docs/src/Effectf…

3 5

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

Re: [Haskell-cafe] [ANNOUNCE] GHC 9.6.1-alpha2 is now available
by Olaf Klinke 31 Jan '23

31 Jan '23

This may be a naive question and I may be completely misunderstanding what WebAssembly is all about: What can the Haskell developer expect once the WebAssembly and JavaScript backends of GHC have matured? I dream of a commutative square like follows. f x -----> y Haskell source | | |GHC |GHC | | v v b -----> b HTML w GHC would become a functor from (a sub-category of) Hask to a category with one object and a rich hom-set of (serializable) endomorphisms. Cloud Haskell [0] seems to provide a functor of this kind. In detail, for a pure Haskell function between Haskell types x and y, the compiler would be able to map values to a web representation b and compile f to a web representation w :: b -> b. The latter should be embeddable in static HTML [1], so that a client-server architecture is not needed. There are obvious limitations, e.g. when b = JSON and w is a JavaScript function, then x and y may be limited to Generic types. One application of this functor would be a web version of Haskintex [2], where one can ensure that certain elements of a document have a relationship y = f(x) defined by a Haskell function. But unlike Haskintex, the computation would take place not at create-time but at display-time so that a limited amount of interaction is possible. Olaf [0] https://hackage.haskell.org/package/distributed-static [1] According to [3], WebAssembly is currently designed to be fetched, not embedded. This appears to be no fundamental restriction, however, as binary images can also be embedded in static HTML. [2] https://hackage.haskell.org/package/haskintex [3] https://developer.mozilla.org/en-US/docs/WebAssembly/Loading_and_running

1 0

[ANNOUNCE] GHC 9.6.1-alpha2 is now available
by Ben Gamari 31 Jan '23

31 Jan '23

The GHC team is very pleased to announce the availability of GHC 9.6.1-alpha2. As usual, binaries and source distributions are available at downloads.haskell.org: https://downloads.haskell.org/ghc/9.6.1-alpha2/ Beginning with GHC 9.6.1, GHC can be built as a cross-compiler to WebAssembly and JavaScript. This is an important step towards robust support for compiling Haskell to the Web, but there are a few caveats to be aware of in the 9.6 series: - Both the Javascript and WebAssembly backends are still at an early stage of development and are present in this release as a technology preview - Using GHC as a cross-compiler is not as easy as we would like it to be; in particular, there are challenges related to Template Haskell. - GHC is not yet run-time retargetable; a given GHC binary targets exactly one platform, and both WebAssembly and JavaScript are considered platforms for this purpose. Cross-compilers must be built from source by their users We hope to lift all of these limitations in future releases. Additionally, 9.6.1 will include: - Significant latency improvements in the non-moving garbage collector - Efficient runtime support for delimited continuations - Improvements in compiler error messages - Numerous improvements in the compiler's memory usage See the [release notes] for a comprehensive accounting of changes in this release. As always, one can find a [migration guide] to aid in transitioning from older releases on the GHC Wiki. We have also recently started extending our release process to cover a wider set of Linux distributions. In particular, we now offer Rocky 8 and Ubuntu 20.04 binary distributions which cover RedHat-derivative and distributions using older `glibc` releases (namely 2.27), respectively. Please do give this release a try and open a [ticket] if you see anything amiss. Cheers, - Ben [ticket]: https://gitlab.haskell.org/ghc/ghc/issues/ [migration-guide]: https://gitlab.haskell.org/ghc/ghc/-/wikis/migration/9.6 [release notes]: https://downloads.haskell.org/ghc/9.6.1-alpha2/docs/users_guide/9.6.1-notes…

3 2

Introducing a pure EBML (WebM) parser
by Tristan Cacqueray 29 Jan '23

29 Jan '23

Dear Café, I've created a new package to parse the Extensible Binary Meta Language format using the binary library: https://hackage.haskell.org/package/ebml And I just published a motivating example, an audio broadcasting server for WebSocket clients: https://tristancacqueray.github.io/blog/broadcasting-webm Please let me know if you are interested, contributions and bug reports are welcome! Cheers, -Tristan

1 0

Munich Haskell Meeting, 2023-01-30 @ 19:30
by Leah Neukirchen 27 Jan '23

27 Jan '23

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Monday, January 30 at Augustiner-Gaststätte Rumpler at 19h30. For details see here: http://muenchen.haskell.bayern/dates.html If you plan to join, please add yourself to this nuudel so we can reserve enough seats! It is OK to add yourself to the nuudel anonymously or pseudonymously. https://nuudel.digitalcourage.de/mjxWpyCCGJY7r6uA Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

1 0

incomplete-uni-patterns
by Kazu Yamamoto 27 Jan '23

27 Jan '23

Hello, The recent GHC added incomplete-uni-patterns to the -Wall option. So, we have a waning with the following code: let [addr,port] = args To avoid this, I changed the code to: let addr = head args port = head $ tail args In my opinion, this seems Lisp rather than Haskell. Also, I need to avoid: let Just val = mval Rahter, I use: let val = fromJust mval This is annoying to me. How do you get along with incomplete-uni-patterns? I would like to know the best current practice. --Kazu

12 27

Re: [Haskell-cafe] Type constraint rewrite rules
by Anthony Clayden 27 Jan '23

27 Jan '23

> ... rewrite rules for type constraints ... That's what FunDeps are, with the advantage you can stipulate multiple/multi-directional rewrites. (With a bit of effort you can support three FunDeps for `Nat` Plus.) The more I think about it, the more it seems type-land 'solving' is not the same job as term-land 'evaluating'; and Type Families are the wrong tool for the job. AntC

2 2

Re: [Haskell-cafe] incomplete-uni-patterns
by Olaf Klinke 26 Jan '23

26 Jan '23

> From: Tom Ellis <tom-lists-haskell-cafe-2017(a)jaguarpaw.co.uk> > To: haskell-cafe(a)haskell.org > Subject: Re: [Haskell-cafe] incomplete-uni-patterns > > On Thu, Jan 26, 2023 at 12:21:31PM +0900, Kazu Yamamoto (山本和彦) via > Haskell-Cafe wrote: > > > I feel I should raise the naive question, what if args is wrong? > > > > The length of "args" have been checked in advance. > > I'm sure that the length is 2. > > Then, at the point you check the args, put them in a pair? That seems indeed the most realistic use case, and a semi-automatic translation by a linter would be cool: ``` if length args >= 2 then let (addr:port:_) = args in ... else complain_about_insufficient_args ``` transforms to ``` case args of (addr:port:_) -> ... _ -> complain_about_insufficient_args ``` Rice's theorem will get in the way though, since no linter may be able to prove in general that the first branch in the if-expression can only be entered if the pattern match within must succeed. The example might still be tractable, but what about more complicated data structures/pattern matches? I agree with Henning, in this case the incomplete-uni-patterns rightfully informs you that you should re-structure your code and help the compiler know what you as the programmer know. That said, I've been using the former style and it's okay to have different opinions about whether it is good style. Personally, I don't care whether the application aborts on start-up with an incomplete pattern error or my own complain_about_insufficient_args failure. It just can't go on. Henning disagrees. Deep within a library, where you can't control the calling context, such a partial pattern match should be avoided, of course. I collected all my dubious handling of unwanted situations in a module that is sprinkled with DEPRECATED pragmas reminding me that there is code to be tidied. For example, failLeft :: MonadFail m => Either String a -> m a failLeft = either fail return {-# DEPRECATED failLeft "this can fail, consider proper error handling" #-} If you are sure that failing is okay at the particular use site, just replace failLeft by an equivalent version without the DEPRECATED pragma. That would be the akin to the proposed {-# PARTIAL_MATCH #-} pragma, but requires you to avoid the incomplete pattern match in the first place and handle the other patterns somehow. Olaf

1 0

Does an unboxed unit get pushed to the stack?
by Tom Ellis 25 Jan '23

25 Jan '23

If I define bar and baz as below then, as I understand it, calling baz requires pushing an argument onto the machine stack. Is the same true for baz, or is "calling" baz the same as "calling" foo, i.e. no argument needs to be pushed? Thanks, Tom {-# LANGUAGE MagicHash #-} {-# LANGUAGE UnboxedTuples #-} module Bar where import GHC.Prim foo :: Int foo = 1 bar :: (# #) -> Int bar (# #) = 1 baz :: () -> Int baz () = 0

7 16