oops

really shortsighted of the team to not call it .takeDownCloudflare()

it's almost like making something that can take down the entire process a single short function call that is literally the easiest way to handle failure wasn't a good idea. who would have thought

huh, TIL that haskell had visible foralls before RequiredTypeApplications (but only in kinds)

omg how did this break now. the only thing i touched was how **function types** (types!!) are parsed

uh oh

what kind of idiot would use chainl1 for function types (i'm the idiot)

you know it's kind of unfair that rust usually gets credit for inventing unsafe blocks when C# has had them since *2001*

laziness is an extremely important property of the language that comes up all the time and makes it harder to reason about code

i really wish people that don't actively use haskell understood haskell, like, at all

it's so typical that CS wikipedia lists "best case performance" for every algorithm like that's a meaningful metric in any way

i've been writing a bit of latex again today and it's... been a really smooth experience where i didn't get annoyed at it once? that's possible??

how to realize you've accidentally clicked on the american version of a medical company's website: there is a big "shop online" button right in the center

some people think that it's impossible to find a job using functional languages that doesn't involve either blockchain or ai bullshit, but that's not true! you can also build weapons for the US government

you would think "you can do functional programming without destroying all your time complexities with completely useless linked lists" would be a trivial position

i really think you should reconsider some things if a core part of your identity is liking a programming language that you're not even directly involved in

SURELY this change that barely even touched the type checker and didn't actually change anything in the surface language didn't break anything, right? (how do people write compilers without tests omg)

i hate compilers

omg. do you see the issue in this code?

i feel like if you know so little about haskell's performance that you think rankNtypes are slow, you maybe shouldn't make any strong claims about the performance of free monads but maybe that's just me

a language is woke if it has too many bottoms

This post has been sitting around in my drafts since March... I hope it has its intended effect bernsteinbear.com/blog/compile...

i should stop writing lean because it's going to make me want to implement its infoview for vega and that would take so much effort....

oops github.com/leanprover/l...

what do you think this lean code outputs? def f(x y : Nat): Nat := x def g : (y x : Nat) -> Nat := f #eval f (x := 1) (y := 2) #eval g (x := 1) (y := 2) #eval (f : (y x : Nat) -> Nat) (x := 1) (y := 2)

i wish arrows were real

would you agree with the following statement: "every tree on at least two vertices contains at least two leaves"

i wonder if noone replied to this because they don't know the anwer or because noone knows how parallel works ^^

can you spot the issue in this code? let graphs = withStrategy (parBuffer whatever rseq) $ filter expensiveCondition (generateLotsOfGraphs ())

i feel like 60% of the benefit of using a functional programming language is just having ubiquitous good persistent data structures (or at least usable ones, depending on the language ^^). there's really no reason imperative languages couldn't have that either (rust gets a pass i guess)

haskell is just so nice to write

good points by graydon hoare on fil-c graydon2.dreamwidth.org/320265.html

is there a reason why higher rank trait bounds (i.e. rust's QuantifiedConstraints) can only range over lifetimes, not types? i get it for regular higher rank arguments that need to be passed at runtime somehow, but trait bounds are monomorphized away anyway, aren't they?

This is not a drill: GHC (the #Haskell compiler) now runs in your browser. See the announcement (and please report any bugs) here: discourse.haskell.org/t/ghc-now-ru...

lexa is pretty cool

i feel like PL authors don't know what the word "subset" means

New blog post: "4 Unconventional Ways to Cast in Typescript" https://wolfgirl.dev/blog/2025-10-22-4-unconventional-ways-to-cast-in-typescript/ #programming #typescript

oops

i hate sccs (no, they're actually really cool but this is like the fifth time i got this panic omg)

reading english articles about the nazis is so strange because all the gross nazi euphemism's you're not supposed to use are just everywhere

this thread made me realize that I'm such an idiot and I should absolutely be doing this in vega to solve monomorphizability constraints.

it's so nice talking to people who know what they're talking about

omg i hate error recovery. this is so subtle

<insert bell curve meme> - polymorphism means subtyping - polymorphism and subtyping are different things - polymorphism means subtyping

what did she mean by this

while I'm asking about rust things: why does ! (the type) exist? is it for error messages? like, panic could also have been typed (ignoring that it's a macro for a second) fn panic<T>(message: &str) -> T (which would be more consistent with how Result works anyway)

what is the motivation for negative trait bounds in rust btw? they're extremely anti-modular so I hope there is a good use-case to justify adding them (any type might change to implement the trait you're asserting it doesn't have and that's now a breaking change)

answer: it's rust! by a lot. on my machine, haskell took ~8.8μs, ocaml took ~10μs and rust needed a whole *108μs*. the interesting question is *why* rust is so slow though and it has a really nice, simple answer: with rust's iterators, this code is quadratic.

pop quiz: you are consing 1000 elements to an iterator. which language's iterator implementation is the *SLOWEST*? 1️⃣ Rust (with Iterator::chain) 2️⃣ Haskell (lists) 3️⃣ OCaml (Seq.t) 📊 Show results

haskell