- Haskell-Cafe - Haskell.org

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

30 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 28 Jan '23

28 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 28 Jan '23

28 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 27 Jan '23

27 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 26 Jan '23

26 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

Benchmarking using instruction counting
by Alexey Khudyakov 25 Jan '23

25 Jan '23

Hello! I want to announce new benchmarking framework tasty-papi[1,2] Unlike criterion, gauge or tasty-bench is uses instruction counting instead of time measurements. It should be affected by OS scheduler much less so it should be possible to run benchmarks on CI. Although not on github CI (not enough permissions) For measurements papi[3] is used. So all hardware and OS limitations are inherited from there. At least it works on linux Here is example output: > 6: OK (0.02s) > ALLOC=528 TOT_INS=3609 TOT_CYC=4981 BR_INS=907 BR_MSP=58 > 7: OK > ALLOC=864 TOT_INS=5518 TOT_CYC=5138 BR_INS=1378 BR_MSP=50 > 8: OK > ALLOC=1408 TOT_INS=8614 TOT_CYC=6515 BR_INS=2142 BR_MSP=63 For each benchmark we measure number of allocated bytes, number of instructions and cycles spent as well as number of branching instructions and branch mispredictions. Counter set could be adjusted using command line flags. This library hasn't seen much real world use. So treat measurement with care. [1] https://hackage.haskell.org/package/tasty-papi [2] https://github.com/Shimuuar/tasty-papi [3] https://icl.utk.edu/papi/ - Alexey

2 1

GHC Nightlies: how would you use them?
by David Christiansen 25 Jan '23

25 Jan '23

Dear all, I'm currently helping to assemble a set of use cases that a more convenient means of accessing GHC nightly builds would support. More details are available here: https://discourse.haskell.org/t/ghc-nightlies-how-would-you-use-them/5655 Please feel free to provide feedback on that thread or via email - I'll assemble it into a final report when the discussion seems to have died down. All the best, David

1 0

Inscrutable error message from PolyKinds (should it be in GHC202X?)
by Tom Ellis 24 Jan '23

24 Jan '23

I love the idea of GHC2021, but I've just discovered that PolyKinds, which is part of it, leads to inscrutable error messages. Firstly, a scrutable error message, without PolyKinds: {-# LANGUAGE GHC2021 #-} {-# LANGUAGE NoPolyKinds #-} -- Error: • No instance for (Foldable t) arising from a use of -- ‘length’ foo :: t a -> Int foo = length Good. I know exactly how to fix that. Now the inscrutable message: {-# LANGUAGE GHC2021 #-} -- • Couldn't match kind ‘k’ with ‘*’ -- When matching types -- t0 :: * -> * -- t :: k -> * -- Expected: t a -> Int -- Actual: t0 a0 -> Int -- ‘k’ is a rigid type variable bound by -- the type signature for: -- foo :: forall {k} (t :: k -> *) (a :: k). t a -> Int -- at /tmp/bar.hs:3:1-17 -- • In the expression: length -- In an equation for ‘foo’: foo = length -- • Relevant bindings include -- foo :: t a -> Int (bound at /tmp/bar.hs:4:1) foo :: t a -> Int foo = length What? Non-expert users will experience much puzzlement. (PolyKinds tries to generalise the kind of `a` and fails, because the use of `length` restricts it to `Type`.) Should PolyKinds really be in GHC202X? Tom

3 4

Type constraint rewrite rules
by Henning Thielemann 23 Jan '23

23 Jan '23

Has anyone thought about rewrite rules for type constraints as light-weight alternative to type-checker plugins? Rewrite rules could be n + 'Zero -> n Back (Forth a) -> a for closed type families Back and Forth, where Back is the inverse of Forth Ideally the programmer would also provide a correctness proof for the proposed rewrite, e.g. with a function that generates a data BackForthProof a = (Back (Forth a) ~ a) => BackForthProof

2 1