- Haskell-Cafe - Haskell.org

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

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

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

22 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

Foldable intercalate for Data.Text?
by Benjamin Redelings 22 Jan '23

22 Jan '23

Hi, I was looking at intercalate in Data.Text, and I see that the signature is Text -> [Text] -> Text. I'm curious why this isn't (say) Foldable f => Text -> f Text -> Text Perhaps because this would be harder to optimize? -BenRI

2 2

Anyone working on improving HPC
by Ivan Perez 21 Jan '23

21 Jan '23

Hi everyone, A while back there were a few exchanges about the state of HPC and I remember reading that someone was interested in pushing a bit for improving the tool and the reports generated. Does anyone know if that's happening and who is working on that? I forgot where I saw it and I can't find it. It could have been haskell-cafe, discord, chat, idk. Thanks, Ivan

7 6

Everything you never wanted to know about Applicative laws and more
by Alexandre Esteves 21 Jan '23

21 Jan '23

I've spent some time recently going down this particular rabbit hole. The original motivation was replacing the current formulation of Applicative laws with the Monoidal-ish one, but one thing led to the other and I ended up making a post about the various sets of laws and related free theorems: https://github.com/alexfmpe/semantic-satiation/blob/main/src/Posts/001-appl…

1 0

C++ Haskell interpreter with GADTs + Type Families + Rank-n types
by Benjamin Redelings 21 Jan '23

21 Jan '23

Hi all, I don't want to oversell this, but in case anyone is interested, I've been working on a Haskell interpreter that is written in C++. This isn't intended to compete with GHC. It doesn't generate machine code, and it is not fast. However, I had a reason to try and implement Haskell typechecking in C++. So if anyone is interested in how to write their own Haskell compiler, then this might possibly be of interest. Otherwise, probably not. So far I have: 1. Parser 2. Renamer - hacky. Infix handling is a separate pass. 3. Typechecker - standard constraints + rank n types + GADTS + type families. But no newtypes and no coercions. 4. Desugarer - the desugarer generates a language w/o type-level lambdas or coercions. 5. Optimizer - inlining, let-floating, case-of-case, etc. No SpecConstr. No Rules. 6. Translation to de-Bruijn notation prior to execution (See Sestoft 1997, "Deriving a lazy abstract machine") 7. Interpreter - a special-purpose dependency-tracking interpreter. The revelant code is here: https://github.com/bredelings/BAli-Phy/tree/master/src/computation After compiling the executable, you would run use it to run a Haskell program like this: bali-phy --run-module Main.hs Tests are in: https://github.com/bredelings/BAli-Phy/tree/master/tests/haskell -BenRI

2 3

Re: [Haskell-cafe] induction on type-level Nat
by Olaf Klinke 16 Jan '23

16 Jan '23

> Alternative approach with a GADT: > > data T n a where > End :: T 0 a > Cons :: a -> T n a -> T (n+1) a > > viewL :: T (n+1) a -> (a, T n a) > viewL (Cons x xs) = (x, xs) > > testEnd :: T 0 a -> () > testEnd End = () > > > For viewL GHC reports a missing pattern match on 'End' and for > testEnd it > reports a missing match on 'Cons'. If I add the constraint (1<=n+1) > to > Cons then the testEnd warning disappears. If I add the constraint > (1<=n+1) > to viewL, then its warning disappears, as well. So the theory of type-level nats lacks the theorem forall m n. n+m <= n :: Nat -> Nat -> Constraint The infix type operator + from GHC.TypeLits constrains n in Cons to kind Nat. So the theorem above ought to be available to the type checker. Hiromi's type-natural package has Lemmas plusLeqL and plusLeqR for this. Olaf

1 0

Re: [Haskell-cafe] [ANNOUNCE] GHC 9.6.1-alpha1 is now available
by Ben Gamari 16 Jan '23

16 Jan '23

George Colpitts <george.colpitts(a)gmail.com> writes: > Hi > > I believe llvm does not work in this alpha as 21936 is still open. Is that > correct? > Indeed we do not yet support LLVM 15 but all previous LLVM versions continue to work. We can try to fix this for the final release. > I also believe that when it does work it will require llvm 15 which will be > incompatible with earlier versions of ghc. Is that correct? > Early indications suggest that supporting LLVM 15 will require that we raise the minimum supported version to LLVM 13. Cheers, - Ben

1 0

induction on type-level Nat
by Henning Thielemann 16 Jan '23

16 Jan '23

I want to define a list with type-level Nat length: type family List (n::Nat) :: Type -> Type where List 0 = End List n = Cons (List (n-1)) data End a = End data Cons f a = Cons { head :: a, tail :: f a } But this way, GHC cannot match ‘List (n+1)’ with ‘Cons (List n)’, also not with the magic type checker plugings suggested before. I guess I need a another way to define List or some support for the type checker to accept List (n+1) ~ Cons (List n).

1 2

[ANNOUNCE] GHC 9.6.1-alpha1 is now available
by Ben Gamari 14 Jan '23

14 Jan '23

The GHC team is very pleased to announce the availability of GHC 9.6.1-alpha1. As usual, binaries and source distributions are available at downloads.haskell.org: https://downloads.haskell.org/ghc/9.6.1-alpha1/ This is the first alpha release in the 9.6 series which will bring a number of exciting features: * A new Javascript code generation backend * A new WebAssembly code generation backend, * Significant latency improvements in the non-moving garbage collector * Support for loading of multiple components in GHCi * Efficient support for delimited continuations * Improvements in error messages * Numerous improvements in compiler-residency Note that both the Javascript and WebAssembly backends are still in a state of infancy and are present in this release as a technology preview; we hope that they will mature considerably before the final 9.6.1 release. Please give this release a try and open a [ticket] if you see anything amiss. Cheers, - Ben [ticket]: https://gitlab.haskell.org/ghc/ghc/issues/

1 0

Re: [Haskell-cafe] Current state of type-level natural number programming
by Henning Thielemann 13 Jan '23

13 Jan '23

On Fri, 13 Jan 2023, rowan goemans wrote: > I'm a heavy user of ghc-typelits-natnormalise. > > I can feel your pain that it sometimes isn't able to solve seemingly "simple" > constraints. But not all is lost in those cases. The `constraints` package > allows one to solve `Nat` constraints out of thin air, provided you go > through a function to do it. > > nLEZeroIsZeroRule :: (n <= 0) :- (n ~ 0) > nLEZeroIsZeroRule = Sub (unsafeCoerce (Dict :: Dict (a ~ a))) Good to know that there are ways to add missing transformations. Ideally there would be a way without unsafeCoerce, i.e. that I could prove a property manually using some proof steps expressed in functions. Alternatively, maybe I can write missing steps in a custom type checker plugin. Has someone already tried to connect SBV to a type checker plugin?

2 1

Current state of type-level natural number programming
by Henning Thielemann 13 Jan '23

13 Jan '23

Almost ten years ago I tried to convert the package llvm-tf to use type-level naturals but it did not lead very far. What is the current state of type-level natural number programming and reasoning? I need type-level naturals for vectors of static size. The type checker must know things like: n+n ~ 2*n n*m ~ m*n (Pos - positive natural number) n::Nat, m::Pos -> n+m :: Pos n::Nat, m::Pos -> n*m :: Nat n::Pos, m::Pos -> n*m :: Pos I need to access an element from a heterogeneous list with a typenat index. That is, I need a kind of induction. I know of ghc-typelits-natnormalise, but it has some problems with inequalities that I need: "Could not deduce n~0 from the context n<=0" https://github.com/clash-lang/ghc-typelits-natnormalise/issues/33 "Could not deduce: (n0 + 1) ~ m from the context: 1 <= m" https://github.com/clash-lang/ghc-typelits-natnormalise/issues/59 So, what is the current state of the art? What libraries, what GHC extensions? Any tutorials?

5 6

Emily Pillmore presentation on Haskell
by Jonathan Drews 13 Jan '23

13 Jan '23

Hi Folks: Next Tuesday, January 17th, Emily Pillmore will give an online presentation to South Eastern Michigan BSD User group (http://www.semibug.org/) at 7 PM Detroit, MI time. I will post the Jitsi link to this list the day before the meeting. I believe the talk will be about 40 - 60 minutes long. It may cover the following topics: * An overview of the Haskell programming language * The Haskell Foundation: what it does and the resources it offers. * Cabal: Common Architecture for Building Applications and Libraries * Question and answer session. -- Kind regards, Jonathan

1 1

Fully Funded PhD Scholarship at St Andrews
by Christopher Brown 11 Jan '23

11 Jan '23

We have a fully funded PhD scholarship available in the School of Computer Science at the University of St Andrews on "Trustworthy Refactoring Tools for Haskell Programs". Any potential candidates are advised to contact Chris Brown (cmb21(a)st-andrews.ac.uk<mailto:cmb21@st-andrews.ac.uk>) for more information. Full details of the scholarship, the general topic, and how to apply are here: https://blogs.cs.st-andrews.ac.uk/csblog/2023/01/11/fully-funded-phd-schola… The deadline for applications is the 1st March 2023 with a September start-date (although there is room for some flexibility due to circumstances). The scholarship is fully funded for 3.5 years. The positions are open for both UK and international applications. You can apply formally at https://www.st-andrews.ac.uk/computer-science/prospective/pgr/how-to-apply/ Kind regards, Chris

1 0

Actual levity polymorphism
by Tom Ellis 11 Jan '23

11 Jan '23

I'm investigating unboxed types in GHC 9.2. Levity polymorphism seems to be severely limited in a way that makes it hard to envisage a Haskell ecosystem which comfortably combines lifted and unlifted types. Am I missing something? Understandably, the following attempt at defining a RuntimeRep-polymorphic identity does not work: myId1 :: forall (r :: RuntimeRep) (t :: TYPE r). t -> t myId1 x = x The GHC Users Guide explains why[1]. It's impossible to generate code for myId1 because there is no way of determining the machine representation of the argument x. But worse, it's not even possible to define a *Levity*-polymorphic identity: myId2 :: forall (lev :: Levity) (t :: TYPE (BoxedRep lev)). t -> t myId2 x = x In this case the argument can only have kind TYPE LiftedRep or TYPE UnliftedRep. The machine representation is the same in each case. The problem this time is that the code generator doesn't know whether it should emit code to evaluate the argument (UnliftedRep case) or not (LiftedRep case). But this seems like a solvable problem. Surely a KnownLevity type class (possibly magical) could solve the problem. This seems like it should work myId3 :: forall (lev :: Levity) (t :: TYPE (BoxedRep lev)). KnownLevity lev => t -> t myId3 x = x and in fact I wouldn't be surprised if this could be made to work: myId4 :: forall (r :: RuntimeRep) (t :: TYPE r). KnownRuntimeRep r => t -> t myId4 x = x So what is the situation here? 1. myId3 already works (then where is KnownLevity made available and why isn't it mentioned in the Users Guide?) 2. myId3 can never work (then why not?) 3. myId3 might be able to work but it's an open research problem (then who is working on it, if anyone?) 4. myId3 would work and it would be useful but no one's proposed or implemented it (then who would be the best person to collaborate with on that?) 5. myId3 would work but it would not actually be useful (then what have I misunderstood?) I suspect the answer is 1 (or maybe 4) based on the following passage in the Levity Polymorphism[2] paper by RE & SPJ[2]: > users can use a runtime type check (though GHC’s Typeable feature) > to determine the memory representation of an as-yet- unbound > argument to a function (and the same questions for myId4). Thanks, Tom [1] https://downloads.haskell.org/~ghc/9.4.4/docs/users_guide/exts/representati… [2] https://www.microsoft.com/en-us/research/wp-content/uploads/2016/11/levity-…

5 8

[ANN] Copilot 3.13
by Ivan Perez 10 Jan '23

10 Jan '23

Dear all, I'm very excited to announce Copilot 3.13. Copilot is a stream-based DSL for writing and monitoring embedded C programs, with an emphasis on correctness and hard realtime requirements. Copilot is typically used as a high-level runtime verification framework, and supports temporal logic (LTL, PTLTL and MTL), clocks and voting algorithms. Among others, Copilot has been used at the Safety Critical Avionics Systems Branch of NASA Langley Research Center for monitoring test flights of drones. It also serves as a runtime monitoring backend for the requirements elicitation tool FRET (https://github.com/NASA-SW-VnV/fret/) via Ogma ( https://github.com/nasa/ogma) This release fixes 4 bugs in copilot-core and copilot-c99. We have also removed 2 deprecated modules and one dependency. The new release has been published on hackage, as well as github. Current emphasis is on increasing test coverage, removing unnecessary dependencies, hiding internal definitions, and formatting the code to meet our new coding standards. Users are encouraged to participate by opening issues and asking questions via our github repo ( https://github.com/copilot-language/copilot) I'd also like to take this opportunity to announce that Copilot is now being made available on Ubuntu Lunar 23.04 and Debian Bookworm. We would like to thank the Debian Haskell Group and, most especially, Scott Talbert, for continued effort making Copilot available on Debian-based distros. This will be extremely useful to a great portion of our users, who need to use Copilot as a runtime verification system targeting C, but do not need to become proficient in Haskell. We hope to continue this effort by making Copilot easily available on other distributions and OSs. Happy Haskelling, The Copilot team

1 0

HLS in VS Code is identifying problems that don't when I run stack on the command line
by Dennis Raddle 07 Jan '23

07 Jan '23

I'm trying to get HLS set up with a stack project on VS Code. I'm getting messages like this: Could not load module ‘Control.Monad.Except’ It is a member of the hidden package ‘mtl-2.2.2’. You can run ‘:set -package mtl’ to expose it. (Note: this unloads all the modules in the current scope.) But these are in the "Problems" tab of VS Code (and show as red underlines). When I run stack clean, stack build I don't see any error like this at all. And yes, I made sure mtl was added everywhere in cac.cabal. (I'm using cac.cabal not stack.yaml... is that my problem?) I tried stack clean; stack build; restart HLS several times.

2 4

Surprising behavior with wildcard pattern and unlifted type
by Tom Ellis 07 Jan '23

07 Jan '23

Is there supposed to be this surprising difference between ex1 and ex2? {-# LANGUAGE UnliftedDatatypes #-} {-# OPTIONS_GHC -Wall #-} module Main where import GHC.Exts (UnliftedType) type T :: UnliftedType data T = T ex1 :: () ex1 = let _ = undefined :: T in () ex2 :: () ex2 = let _a = undefined :: T in () ghci> ex1 () ghci> ex2 *** Exception: Prelude.undefined CallStack (from HasCallStack): undefined, called at test17.hs:53:16 in fake-package-0-inplace:Main

2 2

Surprising interaction between @-patterns and nested patterns
by Tom Ellis 05 Jan '23

05 Jan '23

Consider the following: let x0 = (undefined, ()) ; ((_, _), _) = x0 in x0 `seq` () () but then combining the patterns into an @-pattern, which really feels like it shouldn't change semantics: let x1@((_, _), _) = (undefined, ()) in x1 `seq` () -> undefined Does this strike anyone else as odd? The reason for this behaviour is that let x@p = rhs in body is translated to case rhs of ~(x@p) -> body according to section 3.12 of The Report[1] which is then translated to (\x -> body) (case rhs of x@p -> x) if p binds no variables, according to section 3.17.3 of The Report[2], and then to (\x -> body) (case rhs of p -> (\x -> x) rhs) which is equivalent to (\x -> body) (case rhs of p -> rhs) Putting it all together let x0 = (undefined, ()) ; ((_, _), _) = x0 in x0 `seq` () desugars as (\x0 -> x0 `seq` ()) (let v = (undefined, ()) in case v of ((_, _), _) -> v) which evaluates as let v = (undefined, ()) in case v of ((_, _), _) -> () This seems very odd to me. Why should combining two non-diverging patterns into an @-pattern cause divergence? Specifically, the translation from let x@p = rhs in body to case rhs of ~(x@p) -> body seems highly dubious. It comes from the more general rule translating let p = rhs in body to case rhs of ~p in body but it seems to interact badly with @-patterns. It seems like the rule for @-patterns should be something like let x@p = rhs in body translates to case rhs of ~(x@(~p)) in body Then the original expression containing x1 would not diverge. Does anyone else have a view on this matter? Tom [1] https://www.haskell.org/onlinereport/exps.html#sect3.12 [2] https://www.haskell.org/onlinereport/exps.html#sect3.17.3

4 5

CLC Election January 2023
by Andrew Lelechenko 05 Jan '23

05 Jan '23

The terms of three CLC members are ending in January, so we are seeking new nominations! # Who should apply? Anyone who meets the following criteria should apply: * Candidates should have enough bandwidth to review merge requests to `base` on a semi-frequent basis (3 to 5 per month), and sustain this for their 3 years term in a healthy manner. * Candidates should be able to contribute opinions and analysis to issues raised by the community as a part of the CLC proposal process on a semi-frequent basis (3 to 5 per month). * Candidates should be good communicators, and at least be able to articulate to the CLC team when they will be available vs. unavailable. * Candidates should be productive, and be able to follow through on merge requests and conversations to their completion in a diligent and timely manner. We encourage any and all who satisfy these requirements to apply. Please note that we are not looking for the biggest galaxy brain in the room - quite the opposite. We are looking for productive, motivated individuals who want to help support the ecosystem that we love. As such, we hope to build a broad sample of the community. # How can I apply? To apply for one of these positions, send an email to clc.nominations.2023(a)gmail.com that consists of the following data: * The header “CLC Election January 2023 - {your name}”. * Why you think you’re a good fit given the above criteria. * If applicable, please point us to some code you’ve written. Please apply before Feb 1. Best regards, Andrew

1 0

[TFP 2023 Call For Participation] 24th International Symposium on Trends in Functional Programming
by Peter Achten 02 Jan '23

02 Jan '23

# TFP 2023 -- Call For Participation (trendsfp.github.io) ## Dates Registration: Friday 6th January, 2023 TFPIE Workshop: Thursday 12th January, 2023 TFP Symposium: Friday 13th - Sunday 15th January, 2023 The Symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming, taking a broad view of current and future trends in the area. It aspires to be a lively environment for presenting the latest research results, and other contributions. This year, TFP will take place in-person at UMass Boston, Massachusetts in the United States. It is co-located with the Trends in Functional Programming in Education (TFPIE) workshop, which will take on the day before the main symposium. ## Scope The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: * Research Articles: Leading-edge, previously unpublished research work * Position Articles: On what new trends should or should not be * Project Articles: Descriptions of recently started new projects * Evaluation Articles: What lessons can be drawn from a finished project * Overview Articles: Summarizing work with respect to a trendy subject Articles must be original and not simultaneously submitted for publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Topics suitable for the symposium include, but are not limited to: * Functional programming and multicore/manycore computing * Functional programming in the cloud * High performance functional computing * Extra-functional (behavioural) properties of functional programs * Dependently typed functional programming * Validation and verification of functional programs * Debugging and profiling for functional languages * Functional programming in different application areas: security, mobility, telecommunications applications, embedded systems, global computing, grids, etc. * Interoperability with imperative programming languages * Novel memory management techniques * Program analysis and transformation techniques * Empirical performance studies * Abstract/virtual machines and compilers for functional languages * (Embedded) domain specific languages * New implementation strategies * Any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2023 program chair, Stephen Chang. ## Best Paper Awards TFP awards two prizes for the best papers each year. First, to reward excellent contributions, TFP awards a prize for the best overall paper accepted for the post-conference formal proceedings. Second, a prize for the best student paper is awarded each year. TFP traditionally pays special attention to research students, acknowledging that students are almost by definition part of new subject trends. A student paper is one for which the authors state that the paper is mainly the work of students, the students are listed as first authors, and a student would present the paper. In both cases, it is the PC of TFP that awards the prize. In case the best paper happens to be a student paper, then that paper will receive both prizes. ## Instructions to Authors Papers must be submitted at: <https://easychair.org/conferences/?conf=tfp23> Authors of papers have the choice of having their contributions formally reviewed either before or after the Symposium. Further, pre-symposium submissions may either be full (earlier deadline) or draft papers (later deadline). ## Pre-symposium formal review Papers to be formally reviewed before the symposium should be submitted before the early deadline and will receive their reviews and notification of acceptance for both presentation and publication before the symposium. A paper that has been rejected for publication but accepted for presentation may be resubmitted for the post-symposium formal review. ## Post-symposium formal review Draft papers will receive minimal reviews and notification of acceptance for presentation at the symposium. Authors of draft papers will be invited to submit revised papers based on the feedback receive at the symposium. A post-symposium refereeing process will then select a subset of these articles for formal publication. ## Paper categories Draft papers and papers submitted for formal review are submitted as extended abstracts (4 to 10 pages in length) or full papers (20 pages). The submission must clearly indicate which category it belongs to: research, position, project, evaluation, or overview paper. It should also indicate which authors are research students, and whether the main author(s) are students. A draft paper for which all authors are students will receive additional feedback by one of the PC members shortly after the symposium has taken place. ## Format Papers must be written in English, and written using the LNCS style. For more information about formatting please consult the Springer LNCS web site. ## Program Committee Peter Achten, Radboud University Nijmegen, Netherlands Nada Amin, Harvard University, USA Ambrose Bonnaire-Sergeant, Untypable LLC, USA Laura M. Castro, University of A Coruña, Spain Stephen Chang (Chair), University of Massachusetts Boston, US John Clements, Cal Poly, USA Youyou Cong, Tokyo Institute of Technology, Japan Paul Downen, University of Massachusetts Lowell, USA Kathy Gray, Meta Platforms, Inc., UK Ben Greenman, University of Utah, USA Jason Hemann, Seton Hall University, USA Patricia Johann, Appalachian State University, USA Alexis King, Tweag, USA Julia Lawall, Inria-Paris, France Barak Pearlmutter, Maynooth University, Ireland Norman Ramsey, Tufts University, USA Ilya Sergey, National University of Singapore, Singapore Melinda Tóth, Eötvös Loránd University, Hungary Ningning Xie, University of Toronto, Canada

1 0

Special holiday Munich Haskell Meeting, 2023-01-04 @ 19:30
by Leah Neukirchen 30 Dec '22

30 Dec '22

Dear all, Next week, our special holiday Munich Haskell Meeting will take place on Wednesday, January 4 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 dudle anonymously or pseudonymously. https://nuudel.digitalcourage.de/cs8eLiDLkwZEd5hO Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

1 0

[Haskell] [ANNOUNCE] Haskell Language Server 1.9.0.0 released
by Zubin Duggal 26 Dec '22

26 Dec '22

Binaries for this release are available at https://downloads.haskell.org/~hls/haskell-language-server-1.9.0.0/ The prebuilt binaries in this release support the following GHC versions: - 8.10.7 - 9.0.2 - 9.2.5 - 9.4.3 - 9.4.4 These binaries can be installed using [GHCup](https://www.haskell.org/ghcup/) or version [2.0.0 and above](https://github.com/haskell/vscode-haskell/releases) of the VSCode extension. ## Changelog - Binaries for GHC 9.4.3, GHC 9.4.4 and GHC 9.2.5. - Dropped support for GHC 8.8 and GHC 8.10. - New plugins including: - Expanding record wild cards using hls-explicit-record-fields-plugin (#3304). - Formatting cabal fields using cabal-fmt via hls-cabal-fmt-plugin (#2047). - Warnings and errors for cabal files using hls-cabal-plugin (#2954). - Folding ranges using hls-code-range-plugin (#3058). - Support for many plugins like the refactor, splice, retrie, gadt, hlint, fourmolu and class plugins. - Completion for record dot fields (#3080). - Performance and memory usage improvements. - And many more bug fixes and improvements! For the full release notes, see https://github.com/haskell/haskell-language-server/releases/tag/1.9.0.0

1 1

[ANNOUNCE] GHC 9.4.4 is now available
by Ben Gamari 25 Dec '22

25 Dec '22

The GHC developers are happy to announce the availability of GHC 9.4.4. Binary distributions, source distributions, and documentation are available at downloads.haskell.org [1]. This release is primarily a bugfix release. Bugs fixed include: * An issue where the wrong labels were used in the eventlog for events emitted when using info table profiling which was broken in 9.4.3 (#22452) * Fix a long standing bug where invalid eventlogs would be produced with long command-lines (#20221) * Fix a regression in eta-expansion which resulted in serious performance regressions in 9.4.3 (#22424) * Fix the `-fdefer-diagnostics` flag (#22391) * Fixes to several subtle compiler panics (#22491, #22416, #22549, #22475, #22039) * Add necessary write barriers to `IORef` operations, avoiding potential soundness issues on architectures with weakly-ordered memory models (#22468) Note that, as GHC 9.4 is the first release series where the release artifacts are all generated by our new Hadrian build system, it is possible that there will be packaging issues. If you enounter trouble while using a binary distribution, please open a [ticket]. Likewise, if you are a downstream packager, do consider migrating to [Hadrian] to run your build; the Hadrian build system can be built using `cabal-install`, `stack`, or the in-tree [bootstrap script]. See the accompanying [blog post] for details on migrating packaging to Hadrian. We would also like to emphasize that GHC 9.4 must be used in conjunction with Cabal-3.8 or later. This is particularly important for Windows users due to changes in GHC's Windows toolchain. We would like to thank Microsoft Azure, GitHub, IOG, the Zw3rk stake pool, Well-Typed, Tweag I/O, Serokell, Equinix, SimSpace, Haskell Foundation, and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Finally, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release. As always, do give this release a try and open a [ticket] if you see anything amiss. Happy Haskelling, - Ben [1]: https://downloads.haskell.org/ghc/9.4.4 [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new [bootstrap script]: https://gitlab.haskell.org/ghc/ghc/-/blob/e2520df3fffa0cf22fb19c5fb872832d1… [Hadrian]: https://gitlab.haskell.org/ghc/ghc/-/blob/e2520df3fffa0cf22fb19c5fb872832d1… [blog post]: https://www.haskell.org/ghc/blog/20220805-make-to-hadrian.html

2 3

Meetup in Bay area
by Ivan Perez 23 Dec '22

23 Dec '22

Hi, Is there a Haskell or FP meetup in the Bay area? Cheers, Ivan

2 1

lens and Maybe value
by PICCA Frederic-Emmanuel 20 Dec '22

20 Dec '22

Hello, I have a data whcih contain a Maybe value data A = A (_a = Maybe a) I would like to use a lens in order to merge two values with this log replace the value only if it is a (Just a) So My question is is there something more elegant than let myA' = case ma of Nothing -> conf (Just na) -> (a .~ na) myA Thanks for your help Frederic

4 10

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 232, Issue 6
by Douglas McIlroy 19 Dec '22

19 Dec '22

This note is to suggest an approach to introducing Haskell. It is not a pitch for a gig to do so. A big selling point for Haskell is how clean and simple some kinds of Haskell code are. My personal hobby horse of this type is stream processing. Lazy evaluation makes for dramatic simplification, as can be seen in a couple of offerings on my website. I have given talks based on this theme to (mathematically inclined) audiences who have absolutely no Haskell nous. For folks who know freshman calculus, power series computations in Haskell are an eye-opener--no fussing with storage allocation and no subscripts at all! Only rudimentary Haskell ideas need to be discussed to make these functions intelligible. https://www.cs.dartmouth.edu/~doug/powser.html. Another Haskell example, a basic prime-number sieve, reduces a page of C code, or a half-page of shell script to two elegant lines of code. https://www.cs.dartmouth.edu/~doug/sieve/sieve.pdf Doug McIlroy On Mon, Dec 19, 2022 at 7:19 AM <haskell-cafe-request(a)haskell.org> wrote: > > Send Haskell-Cafe mailing list submissions to > haskell-cafe(a)haskell.org > > To subscribe or unsubscribe via the World Wide Web, visit > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > or, via email, send a message with subject or body 'help' to > haskell-cafe-request(a)haskell.org > > You can reach the person managing the list at > haskell-cafe-owner(a)haskell.org > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Haskell-Cafe digest..." > > > Today's Topics: > > 1. Request for a presentation on Haskell (Jonathan Drews) > 2. Re: Request for a presentation on Haskell (Ivan Perez) > 3. Re: Request for a presentation on Haskell (Jonathan Drews) > 4. Re: Request for a presentation on Haskell (Ivan Perez) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Sun, 18 Dec 2022 18:13:02 -0700 > From: Jonathan Drews <jondrews(a)fastmail.com> > To: haskell-cafe(a)haskell.org > Subject: [Haskell-cafe] Request for a presentation on Haskell > Message-ID: <Y5+6ntGmiRUZ4xd1(a)leo.my.domain> > Content-Type: text/plain; charset=us-ascii > > Hi Folks: > > I would like to know if anyone from the Haskell organization would > like to give a presentation on Haskell to our BSD User Group (BSD = > Berkeley Software Development). We are the South Eastern Michigan BSD > User Group (http://www.semibug.org/) Myself and several other members > are very intereested in Haskell and would like to learn more about > this language. > > You would make the presentation online, by means of Jitsi. The date I > am hoping for is January 17th, 2023. I can move that date if need be. > The talks are usually given in the evenings. Contact me off list for > more details. > > Thanks in advance. > > -- > Kind regards, > Jonathan > > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > ~ > > > > ------------------------------ > > Message: 2 > Date: Sun, 18 Dec 2022 20:02:35 -0800 > From: Ivan Perez <ivanperezdominguez(a)gmail.com> > To: Jonathan Drews <jondrews(a)fastmail.com>, Haskell Cafe > <haskell-cafe(a)haskell.org> > Subject: Re: [Haskell-cafe] Request for a presentation on Haskell > Message-ID: > <CACZKWELYiL7qUP_qJ733PhZHHRcve0-OYO6iV8PZdMt5Lj5sSA(a)mail.gmail.com> > Content-Type: text/plain; charset="utf-8" > > Jonathan, > > I might be available, if you are interested. Most of my work is > Haskell-centric. I've made commercial games and apps (mobile, desktop, > web). In the last 5y I've focused on runtime monitoring and language > transformation (very broadly speaking). > > See https://ivanperez.io/ for details. > > If you are interested, we can continue the discussion off-list. > > Thanks, > > Ivan > > On Sun, 18 Dec 2022 at 17:13, Jonathan Drews <jondrews(a)fastmail.com> wrote: > > > Hi Folks: > > > > I would like to know if anyone from the Haskell organization would > > like to give a presentation on Haskell to our BSD User Group (BSD = > > Berkeley Software Development). We are the South Eastern Michigan BSD > > User Group (http://www.semibug.org/) Myself and several other members > > are very intereested in Haskell and would like to learn more about > > this language. > > > > You would make the presentation online, by means of Jitsi. The date I > > am hoping for is January 17th, 2023. I can move that date if need be. > > The talks are usually given in the evenings. Contact me off list for > > more details. > > > > Thanks in advance. > > > > -- > > Kind regards, > > Jonathan > > > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > ~ > > > > _______________________________________________ > > Haskell-Cafe mailing list > > To (un)subscribe, modify options or view archives go to: > > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > > Only members subscribed via the mailman list are allowed to post. >

1 0

Request for a presentation on Haskell
by Jonathan Drews 19 Dec '22

19 Dec '22

Hi Folks: I would like to know if anyone from the Haskell organization would like to give a presentation on Haskell to our BSD User Group (BSD = Berkeley Software Development). We are the South Eastern Michigan BSD User Group (http://www.semibug.org/) Myself and several other members are very intereested in Haskell and would like to learn more about this language. You would make the presentation online, by means of Jitsi. The date I am hoping for is January 17th, 2023. I can move that date if need be. The talks are usually given in the evenings. Contact me off list for more details. Thanks in advance. -- Kind regards, Jonathan ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~

2 3

Maintenance takeover: cached-io
by Luke Worth 15 Dec '22

15 Dec '22

Hello, We’ve recently started using https://hackage.haskell.org/package/cached-io, but the listed maintainer’s email address is bouncing, and the GitHub repo doesn’t exist any more. It appears that the original repository is https://github.com/glasserc/haskell-cached-io, but I cannot find any way to contact the owner. The fork https://github.com/Arguggi/haskell-cached-io has many useful contributions which ought to be incorporated into the Hackage release, but even the fork has been inactive since 2016. If nobody speaks up by Wednesday 2022-12-21, I’ll submit a takeover request to Hackage admins. Luke Worth | Senior Software Engineer ——————————— E luke.worth(a)bellroy.com W bellroy.com

2 1

Interactive book/tutorial platform
by Todd Wilson 14 Dec '22

14 Dec '22

Hi Cafe, I've taught university Computer Science for 20+ years, many of those using Haskell to both illustrate and have students explore the concepts they learn, and now I'm looking to organize my course materials as interactive books or long-form tutorials for non-commercial release to a larger audience, and I am trying to find an appropriate platform. I've looked at a few possibilities already, such as org-mode, IHaskell notebooks, and some blogging platforms, but all would seem to involve significant configuration before they would be suitable for what I'm trying to achieve. And so I'm inquiring here to see if there are some choices that I hadn't considered, or ready-made configurations for some that I have, which I could look into further and adapt. Ideally, I would like to be able to: - use LaTeX or equivalent for high-quality typesetting (most of my current non-interactive materials are LaTeX documents), - organize content hierarchically, with varying visibility of subsections, so that readers could go into as much detail as needed (extra explanations, examples, diagrams, etc., that could be viewed if desired or easily skipped if not), using cookies to remember each reader's current visibility choices starting from an initial default, - provide code snippets that are executable in place with results incorporated into the document and perhaps modifiable for experimentation, - export to PDF. Suggestions or templates for the above would be very welcome. Thanks, Todd Wilson California State University, Fresno

3 2

[ANN] Yampa 0.14
by Ivan Perez 14 Dec '22

14 Dec '22

Dear all, I'm happy to announce the release of Yampa 0.14! 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 almost 20 years!!! See https://github.com/ivanperez-keera/yampa#features for details on Yampa's features. * Summary of Version 0.14 - Introduce new type constraint in functions that use VectorSpaces in order to support simple-affine-space 0.2. This is a breaking change, and may require applications to update code on their side providing new instances. - Unit tests in the yampa-test library for 2 more modules have been completed. As always, Yampa and yampa-test are released in sync. The CHANGELOGs are available at: 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 Feb 7, 2023. There are a number of issues open that you are more than welcome to contribute to: https://github.com/ivanperez-keera/Yampa/issues Following our roadmap, the pending changes remain as follows: - Complete tests: Our goal is to speed up the process of accepting new features and changes by having a comprehensive test suite that catches errors early. By automating the tests, we hope to free resources that can be dedicated to investigating other issues. - 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

2 1

From function body to DAG and back again?
by Mario Lang 14 Dec '22

14 Dec '22

Hi. I have a binary instance for a file format[1] which describes a graph of DSP primitives. This DAG was generated from a function body[2] (in another programming language). I think that language can be boiled down to a pure language with let expressions, to allow an output to be consumed by several inputs. And there the trouble starts. I am working on this without the usual theoretical background. I am not a PLD student, I am a self-taught Haskell fan. The function body is basically a very neat way to make a DAG readable without using visualisation. Since I am blind, this topic has always fascinated me. Since I have this bidirectional binary instance, and Haskell is supposed to be great at writing small languages, I wonder what would be required to * write a decompiler which would generate a version of the original function body as a data structure and * write a compiler which would translate that data structure back to the graph. This is very much for my own learning experience, especially since there is already a Haskell library which implements at least the compilation part, and more. However, I always found it very fascinating to try to understand how this translation works, so I'd finally like to take a stab at implementing it myself. I have now searched a day for matching learning material which would shed some light on the problem for me, without any great success. Most SLC-examples I stumbled across immediately proceed to implement an evaluation fucntion, which is not quite what I need. For both directions, I need to work out the data structure for my small language first, which is where I am stuck. I have a feeling the decompiler might be easier to write then the compiler. My intuition says all I need to do is work backwards from the last graph node, resolving all inputs until I am done. However, I am stuck on the data structure and the compiler part. Any hints on what could help me to get a better grasp on the problem and how to solve it in Haskell are greatly appreciated. [1] https://github.com/mlang/sound-supercollider/blob/master/Sound/SuperCollide… [2] SynthDef(\default, { arg out=0, freq=440, amp=0.1, pan=0, gate=1; var z = LPF.ar( Mix.new( VarSaw.ar(freq + [0, Rand(-0.4,0.0), Rand(0.0,0.4)], 0, 0.3, 0.3) ), XLine.kr(Rand(4000,5000), Rand(2500,3200), 1) ) * Linen.kr(gate, 0.01, 0.7, 0.3, 2); OffsetOut.ar(out, Pan2.ar(z, pan, amp)); }, [\ir]).writeDefFile; Which translates to the following graph. The pairs are inputs, pointing at the corresponding outputs in the graph, -1 refering to the list of constants at the beginning. defaultSynthDef :: SynthDef defaultSynthDef = SynthDef [ GraphDef "default" [-0.4,0.0,0.4,0.3,4000.0,5000.0,2500.0,3200.0,1.0,1.0e-2,0.7,2.0] [0.0,440.0,0.1,0.0,1.0] [("out",0),("freq",1),("amp",2),("pan",3),("gate",4)] [ UGen "Control" Scalar 0 [] [Scalar] , UGen "Control" Control 1 [] [Control,Control,Control,Control] , UGen "VarSaw" Audio 0 [(1,0),(-1,1),(-1,3)] [Audio] , UGen "BinaryOpUGen" Audio 2 [(2,0),(-1,3)] [Audio] , UGen "Linen" Control 0 [(1,3),(-1,9),(-1,10),(-1,3),(-1,11)] [Control] , UGen "Rand" Scalar 0 [(-1,0),(-1,1)] [Scalar] , UGen "BinaryOpUGen" Control 0 [(1,0),(5,0)] [Control] , UGen "VarSaw" Audio 0 [(6,0),(-1,1),(-1,3)] [Audio] , UGen "BinaryOpUGen" Audio 2 [(7,0),(-1,3)] [Audio] , UGen "Rand" Scalar 0 [(-1,1),(-1,2)] [Scalar] , UGen "BinaryOpUGen" Control 0 [(1,0),(9,0)] [Control] , UGen "VarSaw" Audio 0 [(10,0),(-1,1),(-1,3)] [Audio] , UGen "BinaryOpUGen" Audio 2 [(11,0),(-1,3)] [Audio] , UGen "Sum3" Audio 0 [(12,0),(8,0),(3,0)] [Audio] , UGen "Rand" Scalar 0 [(-1,4),(-1,5)] [Scalar] , UGen "Rand" Scalar 0 [(-1,6),(-1,7)] [Scalar] , UGen "XLine" Control 0 [(14,0),(15,0),(-1,8),(-1,1)] [Control] , UGen "LPF" Audio 0 [(13,0),(16,0)] [Audio] , UGen "BinaryOpUGen" Audio 2 [(17,0),(4,0)] [Audio] , UGen "Pan2" Audio 0 [(18,0),(1,2),(1,1)] [Audio,Audio] , UGen "OffsetOut" Audio 0 [(0,0),(19,0),(19,1)] [] ] [] ] -- CYa, ⡍⠁⠗⠊⠕

2 1

Some questions on Atkey-style indexed monads
by Nicolas Trangez 04 Dec '22

04 Dec '22

All, For some project, I'm considering (again) to use an indexed state monad, which are now somewhat ergonomic to use with QualifiedDo. When looking into existing packages exposing relevant types/classes, I had some questions: 1. These packages provide something like ``` class IxFunctor f where imap :: (a -> b) -> f i j a -> f i j b class IxFunctor f => IxApplicative f where ... ``` Is this `IxFunctor` actually required/useful? It seems to me the implementation of `imap` for some `IxFunctor f` would be equal to `fmap` in the `Functor` implementation for `forall i j. f i j`. Hence, can `IxFunctor` be dropped in lieu of ``` class (forall i j. Functor (f i j)) => IxApplicative f where ... ``` 2. Existing packages predate MonadFail and QualifiedDo. The latter requires (in some cases) an implementation of `fail` and `mfix` to be provided by the module also providing `>>=` etc. I was wondering whether or not there need to be (or can be) `IxMonadFail` and `IxMonadFix` classes like ``` class IxMonad m => IxMonadFail m where ifail :: String -> m i j a class IxMonad m => IxMonadFix m where ifix :: (a -> m i j a) -> m i j a ``` I'm not sure it "makes sense" to have an `ifail` which returns an `m i j a` vs. having only a `MonadFail` (and hence `fail`) implementation for `m i i` only, taking into account the requirement for `fail f >>= k` to be equal to `fail f`, hence `ifail f >>=: k` to be equal to `ifail f`. I think the above question boils down to: is there any use in having `ifail :: String -> m i j a` next to `fail :: String -> m i i a`, or should (i)fail always be state-type-preserving? Similar doubts about `IxMonadFix m` vs. `MonadFix (m i i)`. Thanks for any insights, Nicolas

2 2

TFPIE 2023 call for submissions (deadline Dec 27th)
by Elena Machkasova 04 Dec '22

04 Dec '22

Trends in Functional Programming in Education (TFPIE) 2023 Call for papers https://wiki.tfpie.science.ru.nl/TFPIE2023 (January 12th 2023, Boston, MA, USA, co-located with TFP 2023 and followed by POPL 2023) TFPIE 2023 welcomes submissions describing techniques used in the classroom, tools used in and/or developed for the classroom and any creative use of functional programming (FP) to aid education in or outside Computer Science. Topics of interest include, but are not limited to: FP and beginning CS students FP and Computational Thinking FP and Artificial Intelligence FP in Robotics FP and Music Advanced FP for undergraduates FP in graduate education Engaging students in research using FP FP in Programming Languages FP in the high school curriculum FP as a stepping stone to other CS topics FP and Philosophy The pedagogy of teaching FP FP and e-learning: MOOCs, automated assessment etc. Best Lectures - more details below In addition to papers, we are requesting best lecture presentations. What's your best lecture topic in an FP related course? Do you have a fun way to present FP concepts to novices or perhaps an especially interesting presentation of a difficult topic? In either case, please consider sharing it. Best lecture topics will be selected for presentation based on a short abstract describing the lecture and its interest to TFPIE attendees. The length of the presentation should be comparable to that of a paper. In addition, the speaker can provide commentary on effectiveness or student feedback. Submissions Potential presenters are invited to submit an extended abstract (4-6 pages) or a draft paper (up to 20 pages) in EPTCS style. The authors of accepted presentations will have their preprints and their slides made available on the workshop's website. Papers and abstracts can be submitted via easychair at the following link: https://easychair.org/conferences/?conf=tfpie2023 After the workshop, presenters are invited to submit (a revised version of) their article for the formal review. The PC will select the best articles for publication in the Electronic Proceedings in Theoretical Computer Science (EPTCS). Articles rejected for presentation and extended abstracts will not be formally reviewed by the PC. Important Dates Submission deadline: December 27th 2022, Anywhere on Earth. Notification: December 30th 2022 (Note: earlier submissions will receive earlier response) TFPIE Registration Deadline: see https://trendsfp.github.io/register.html Workshop: January 12th 2023 Submission for formal review: April 19th 2023, Anywhere on Earth. Notification of full article: May 24th 2023 Camera ready: July 1st 2023 Program Committee Christopher Anand - McMaster University, Canada Attila Egri-Nagy - Akita International University, Japan Jason Hemann - Seton Hall University, USA Kevin Kappelmann - Technical University of Munich, Germany Elena Machkasova (Chair) - University of Minnesota Morris, USA Kristina Sojakova - INRIA, France Jørgen Villadsen - Technical University of Denmark, Denmark Invited Speaker: Shriram Krishnamurthi, Brown University Registration information: See https://wiki.tfpie.science.ru.nl/TFPIE2023 for updated information. Registration and attendance are mandatory for at least one author of every paper that is presented at the workshop. Only papers that have been presented at TFPIE may be submitted to the post-reviewing process. -- Dr. Elena Machkasova Associate Professor of Computer Science Division of Science and Mathematics University of Minnesota, Morris Office: Sci 2325 (320) 589-6308 http://cda.morris.umn.edu/~elenam/ Pronouns: she/her/hers or any other

1 0

How to create a list of each constructor value
by PICCA Frederic-Emmanuel 03 Dec '22

03 Dec '22

Hello, I have a type like this data InputType = CristalK6C | MarsFlyscan | MarsSbs | SixsFlyMedH | SixsFlyMedV | SixsFlyMedVEiger | SixsFlyMedVS70 | SixsFlyScanUhv | SixsFlyScanUhv2 | SixsFlyScanUhvTest | SixsFlyScanUhvUfxc | SixsSbsFixedDetector | SixsSbsMedH | SixsSbsMedV | SixsSbsMedVFixDetector deriving (Eq, Show) I want to create a list of each values in order to create meaningfull error message for the user and simplify my Arbitrary instances. I do not want to type two time the values. instance Arbitrary InputType where arbitrary = oneof (map pure [ CristalK6C , MarsFlyscan , MarsSbs , SixsFlyMedH , SixsFlyMedV , SixsFlyMedVEiger , SixsFlyMedVS70 , SixsFlyScanUhv , SixsFlyScanUhv2 , SixsFlyScanUhvTest , SixsFlyScanUhvUfxc , SixsSbsFixedDetector , SixsSbsMedH , SixsSbsMedV , SixsSbsMedVFixDetector ] ) Thanks for your help Frederic

7 12