Bluefin, a new effect system (discourse.haskell.org)
I've mentioned my new effect system, Bluefin, a few times on this forum. It's now ready for me to announce it more formally....
I've mentioned my new effect system, Bluefin, a few times on this forum. It's now ready for me to announce it more formally....
6d03,
counterVariable, French Dear mother of transistors does #Haskell syntax feel like a bunch of math nerds tried to create a new language. It feels so unreadable.
BoydStephenSmithJr, (edited ) French @counterVariable The grammar is fairly simple, but custom binary operators and precedence can mean there's actually more to keep up with when reading.
As a big fan of Haskell syntax, that is constantly playing around with new languages, are there specific "mistakes" you feel were made, that I might try to avoid in any of my future languages?
MrTarantoga, German Ein Freund von mir hat einen Parser in #Haskell geschrieben. Dieser ist schnell, fehlerfrei und gut lesbar.
Leider darf er diesen nicht verwenden, da Haskell keine im Projekt zugelassene Sprache ist.
Jetzt verwendet er ihn stattdessen, um die in der Spezifikation abgelegten Konfigurationen zu erzeugen und den C-Parser vollständig zu testen.
Die Firma ist sehr an der Methode zur Verifikation interessiert. Dabei ist es egal, dass es Haskell ist.
abuseofnotation, A great paper for understanding #dependenttypes (partly authored by @pigworker )
https://www.andres-loeh.de/LambdaPi/LambdaPi.pdf
I like how it introduces the typing rules of simply-typed lambda calculus and then amends them to support dependent types.
BoydStephenSmithJr, No type equalities. For any fixed a, given
c :: a -> f a
andsi :: (forall f r. Functor f => a -> f r -> f (a -> r)
provide a runtime value (aBool
) that is True isa
is isomorphic to Void and False otherwise.#haskell ?
glocq, @BoydStephenSmithJr I thought so too, but then I read your original post again and the hypotheses were stated clearly (well, except for the type mistake 😅 which did probably change quite a lot since it turned a negative
a
into a positive one)What would probably have helped me better understand the question is the context, though: how did you encounter that problem?
BoydStephenSmithJr, @glocq I'm off in my own world trying to do some type checking for a dependently-typed core (GRTT) in Haskell but avoiding GADTs (and TypeEquality constraitns) and other GHC-only features.
I'm using bound, so I have a type parameter on terms, contexts, etc. to represent variables, but I'd like to test a context to see if it is empty (as part of checking well-formedness). It's somewhere between checking to see if a bound-style term is closed and seeing if the type parameter to Context is Void.
Jose_A_Alonso, Core inspection. ~ Oleg Grenrus. https://oleg.fi/gists/posts/2024-04-12-core-inspection.html #Haskell #FunctionalProgramming
BoydStephenSmithJr, Anyone in my #haskell (or other, I guess) circles in charge of www.cs.nott.ac.uk ? It was working yesterday, but it keeps timing out (for me) today.
I need to re-read the section of blampied-thesis.pdf on the prefix functor, and especially how it works when the non-uniform type is self-nested in interesting ways.
Trying to do a "project :: t -> f t" and keep getting hung up on the Scope-modified recursions.
Alternatively, is that thesis available elsewhere? I searched, but haven't found.
duplode, @BoydStephenSmithJr The Wayback Machine has caught the file, assuming it's this one: http://web.archive.org/web/20231117182855/http://www.cs.nott.ac.uk/Research/fop/blampied-thesis.pdf
BoydStephenSmithJr, @duplode Nice! That should work. I thought I searched archive.org, but I guess I didn't do it well.
News about the Haskell programming language from 2024-04-18.
haskell_foundation, The term 'telemetry' can raise a lot of concerns, especially within the realm of #OSS. In the latest episode of #TheHaskellInterlude, Joachim Breitner and Andres Löh interview @avi_press, the CEO of @scarf_oss. Learn more about the episode here: https://haskell.foundation/podcast/47/
#Haskell
jesper, This is a great blog post on the WellTyped blog on specialization in Haskell! It's a good reminder that I (or someone) should really get around to getting rid of
-fexpose-all-unfoldings
and-fspecialize-agressively
in the Agda codebase.well-typed.com/blog/2024/04/choreographing-specialization-pt1/
(Also I didn't know about
-flate-specialise
and-fpolymorphic-specialisation
, though I think I'd rather avoid relying on even more flags.)
fargate, Helsinki Haskell Users Group's first book club had its conclusion meeting today with Sockets and Pipes coming to its very end. It has been a ride, one with plenty of scheduling difficulties, but I think we only fell like a month and a half from the original planned schedule and actually had a member retention rate of 100% (of members who were there in the beginning, sadly we could not quite make it 133%)!
To talk a bit about the book as a whole, I do feel like I understand Monad Transformers a lot better now though I'll still need to reread the sections introducing them I am sure. ReaderT especially was something I could see was colossally handy, but given it was in the second to last chapter we were already quite deep with trying to understand everything else so the true utility of it remains somewhat hazy despite the quality of the chapter itself which felt higher than those surrounding it. The habit of reading RFCs and attempting to match the spec in the types one writes is also one I should include in my general workflow, though that is probably a no-brainer for most. It just wasn't a thing in my previous work, so bear with me while I call it a novel concept!
I'm still working on my personal project, but getting nix-build working seems difficult. I'll just have to bring it up in the next main group Office Hours meetup I suppose, lest I never get this show on the road!
Jose_A_Alonso, The Haskell Unfolder Episode 23: specialisation. ~ Edsko de Vries (@EdskoDeVries), Andres Löh (@kosmikus). https://www.youtube.com/live/ksW04Cl2dgo #Haskell #FunctionalProgramming
flora_pm, French Only very few breakages from Flora's #Haskell dependencies with GHC 9.10.1-alpha3. We may be able to adopt it as soon as HLS supports it (and a nice dose of "allow-newer" in cabal.project configuration)
haskell_foundation, GHC 9.6.5 is now available! This release focuses on fixing bugs discovered in the 9.6 series. Check out the details https://www.haskell.org/ghc/blog/20240416-ghc-9.6.5-released.html #Haskell
haskell, #Haskell GHC 9.6.5 bugfix release is now available!
Read the announcement at https://discourse.haskell.org/t/ghc-9-6-5-is-now-available/9341
haskell, #Haskell GHC 9.10.1-alpha3 is now available!
Read the announcement at https://discourse.haskell.org/t/ghc-9-10-1-alpha3-is-now-available/9336
haskell, This release brings exciting new things, like:
• The GHC2024 Language Edition
• Type Arguments to functions
• Backtrace information in exceptionsYou can read about them in the release notes: https://downloads.haskell.org/ghc/9.10.1-alpha3/docs/users_guide/9.10.1-notes.html
This is the first of a two-part series of blog posts on GHC specialization, an optimization technique used by GHC to eliminate the performance overhead of ad-hoc polymorphism and enable other powerful optimizations. There will also be a Haskell Unfolder episode about this topic.
kosmikus, New blog post by my colleague Finley on "Choreographing a dance with the GHC specializer (Part 1)". This is in addition to our #Haskell #Unfolder episode on the same topic tomorrow, 2024-04-16, at 1830 UTC on YouTube.
https://well-typed.com/blog/2024/04/choreographing-specialization-pt1/
This fuses:...
BoydStephenSmithJr, Anyone know if the #haskell #haskellstack #docker images (e.g.: https://hub.docker.com/layers/fpco/stack-build/lts-22/images/sha256-09dcc6cf3739dbb5f73bbb84dc15ee815f463409653c5159673afc7d3b4134b7?context=explore) are still maintained, and what might be the best way to report a bug? :blobfoxconfused:
The LTS_SLUG seems wrong, and when I attempt a
stack build
in that image, I run out of space compiling GHC. (e.g.: https://gitlab.com/bss03/restman/-/jobs/6622698704) :blobfoxsurprised:I expect the docker image would contain a GHC that stack would find and use; I am using the matching resolver for the tag (e.g.: 22.17). :blobfoxhappy:
BoydStephenSmithJr, @simonmic Done-ish (mostly linked to my post here)
On a separate note, how portable is my account? I just picked element since it seemed like a zero-install option. If I use matrix more, I might want to switch clients to something that integrates will with KDE.
simonmic, I believe I'm right in saying you can use your account with any web-based or local #matrix client.
haskell, (edited ) The #Haskell Cryptography Group calls for early adopters of its #libsodium, #botan and one-time-password libraries! https://discourse.haskell.org/t/call-for-early-adopters-of-sel-botan-and-one-time-password/9326
brokenix, pseq combinator is used for sequencing; informally, it eval-
uates its first argument to weak-head normal form, and then eval-
uates its second argument, returning the value of its second argu-
ment. Consider this definition of parMap:
parMap f [] = []
parMap f (x:xs) = y ‘par‘ (ys ‘pseq‘ y:ys)
where y = f x
ys = parMap f xs
The intention here is to spark the evaluation of f x, and then
evaluate parMap f xs, before returning the new list y:ys. The
programmer is hoping to express an ordering of the evaluation: first
spark y, then evaluate ys.
The obvious question is this: why not use #Haskell’s built-in seq
operator instead of pseq? The only guarantee made by seq is that
it is strict in both arguments; that is, seq a ⊥ = ⊥ and seq ⊥
a = ⊥. But this semantic property makes no operational guaran-
tee about order of evaluation. An implementation could impose this
operational guarantee on seq, but that turns out to limit the optimi-
sations that can be applied when the programmer only cares about
the semantic behaviour. Instead, we provide both pseq and seq
(with and without an order-of-evaluation guarantee), to allow the
programmer to say what she wants while leaving the compiler with
as much scope for optimisation as possible.
https://simonmar.github.io/bib/papers/multicore-ghc.pdf
sgraf, German @brokenix ironically, the implementation of pseq is broken today https://gitlab.haskell.org/ghc/ghc/-/issues/23233 and probably has been broken since inception
maralorn, (edited )
kosmikus, It's finally time for the next episode of the #Haskell #Unfolder. In episode 23, my colleagues Finley, Edsko, and I will discuss the topic of "specialisation", an important GHC optimisation that can help eliminate the cost intrinsic to overloaded functions. This will be streamed live on YouTube, on Tuesday, 2024-04-16, at 1830 UTC. https://www.youtube.com/watch?v=ksW04Cl2dgo&list=PLD8gywOEY4HaG5VSrKVnHxCptlJv2GAn7&index=23