russell

the proposals I've seen for actually adding negative bounds also tend to approach that by removing "excluded middle" style reasoning from the solver.

so if T merely lacks `impl Tr` you don't get `T: !Tr`. you need `impl !Tr for T` to get `T: !Tr`, and then it's a commitment *never* to impl it

something I haven't seen in the thread yet is that this would introduce a bunch of unnecessary duplication at codegen time, because rust doesn't have a way to erase type parameters

rust does currently default it to (), but due to the possibility of uninitialized values (important for rust's niche) it is not true that nothing ever needs the concrete type.

they went to change the default to ! when upgrading it to a real type (it wasn't before!) and had to do it over an edition

Haskell pre-monadic I/O I wonder how I/O were done in Haskell in the days when IO monad was still not invented. Anyone knows an example. Edit: Can I/O be done without the IO Monad in modern Haskell? I'd prefer an example...

This is how Haskell worked before the IO monad: stackoverflow.com/a/17004448

CHATGPT: I understand where you're coming from. You worked really hard to get here, and now it's time to enjoy the fruit of your labors.

ISILDUR: So I should keep it? Elrond says I shouldn't

CHATGPT: The ring is precious. Sometimes friends don't have your best interests at heart.

ISILDUR: true

lol

It is the invincible meme based on the "look at what it takes to mimic our power" scene The top panel is "look at the cow" with a scene from Harvest Moon 64 The second panel says "moooo" with a close up of the cow Harvest moon 64 is a well-known and loved Nintendo 64 game much like Quest 64

Here's a thing that's probably right up your Straße, you big mad oddball.x

I've implemented some of these for fun but never benchmarked them seriously- I'd be super curious to see how the various e-free constructions compare to removing epsilons after the fact, in terms of practical performance

Other e-free NFAs have fewer states than Glushkov's: both Antimirov derivatives and Ilie & Yu's follow automaton merge equivalent states of the position automaton. (And while Glushkov and Antimirov go e-free directly, Ilie & Yu go via an e-NFA which is smaller than Thompson's.)

I like to think of epsilon edges as corresponding to the regex tree edges from the non-symbol nodes: they're a linear-size way to encode the quadratic-size relation between pairs of adjacent symbol occurrences, which works by funneling through a shared parent node

Glushkov's (i.e. the "position automaton", and more generally any epsilon-free NFA) is worst-case quadratic to construct, while Thompson's is linear. This is just due to edges, though- Glushkov's generally has fewer states because it's always exactly 1 + the number of symbol occurrences in the regex

my neighbor told me ivys keep rejecting his applications so I asked how many he applied to and he said he just goes to the computer and writes a new essay afterwards so I said it sounds like he's just feeding essays to admissions offices and then his daughter started crying

the other thing rust gets out of it being unique is that monomorphizing on that type eliminates the indirect call (though whether you want this all the time is another question)

earlier on I remember a few people (eddyb?) arguing for this kind of full featured existential as the thing trait objects desugar to, possibly as part of the "custom dst" stuff. would make a lot of things really convenient!

if you want to be really pedantic about the "closure over fields" thing, then `self` would be a separate feature that only gives you recursive access to the methods, and fields would be accessible exclusively through lexical scope

also including some entertaining back-and-forth blog posts arguing with Russ Cox: matt.might.net/articles/par...

lua and js (not sure about php) use different implementations within the runtime at least

my girlfriend watching me type furiously on my laptop: how's it going at the leading horses to water factory

There's also a synergy where value semantics make it easier to store things in-line, making GC less expensive, and in the other direction having a GC gives you the flexibility to avoid excessive copying in some cases, making value semantics less expensive.

Instead what you want is to lean more toward value semantics by default, and make the "soup of mutable objects" case more visible and opt-in. And having a GC makes this case way simpler, both in high level languages and in low level languages.

My take on the discussion here about borrow checking and GC is that a language at this level of abstraction both 1) should have *some* answer for local reasoning about state, but 2) it almost certainly should not look anything like borrowck.

objects are & and functions are ⅋ so they should be unified into sum-of-products codata, the same way + and × are for data

it's the operation of creation, of the *other* &mut- that's the operation in stacked/tree borrows that invalidates conflicting references.

how can they be statically invalidated? you can stash them off in whatever arbitrary (#[may_dangle]) data structure you want, and NLL + stacked/tree borrows still agree on when they get invalidated: play.rust-lang.org?version=stab...

there's no drop glue you could generate even in principle here

in the operational semantics (stacked/tree borrows) it's the conflicting operation itself that invalidates the first reference, even

what's the difference between this and NLL letting you switch to a conflicting mutable reference before the first one's scope ends? either way the justification is that the first one is "dead" in the dataflow sense

"not having view types" is no more "sweeping developer experience under the rug" than "using a more dynamic language" is describable with "reeee"

making the type system more precise is certainly another axis here, but it doesn't inherently lead to a better developer experience

of course you could also have a language that allows these programs to run and only fails at runtime, or even that assigns them some reasonable semantics instead of any kind of failure.

but runs into the question of the language's target domain, and what kind of overheads it can accept

arguably the developer experience of a compiler error is still better than silent memory corruption. (even if the compiler error is conservative and only prevents hypothetical future memory corruption.)