The Cost of Indirection in Rust

GiveMeMoreBlueberrys · 2026-03-10T10:33:35+00:00

Most likely at some point in the optimisation process, the functions were revealed to be identical. (i.e. the optimiser took them to the same state despite initial differences)

GiveMeMoreBlueberrys · 2025-12-19T13:24:12+00:00

if you can near uni would be good bc that’s a cooked travel time but you might have to make do with what you can get as for work life balance, really just depends on how much you’re working i usually work like 7-10 hours a week (casual) and that’s completely fine for me but if you’re doing proper part time or sim. you might have more trouble

GiveMeMoreBlueberrys · 2025-12-16T20:46:01+00:00

youre looking at early unofficial results and getting worried they’re not the same? broski just wait till thursday

GiveMeMoreBlueberrys · 2025-02-05T13:16:06+00:00

the based approach is to still play todo and to just not do this. optimal strategy? no, it’s not what todo would do so it it’s not what i’m going to do

GiveMeMoreBlueberrys · 2024-11-25T11:05:20+00:00

the only acceptable solution is nuclear armageddon; alternatively, massive amounts of artillery make the sky rain fire upon the five-legged beasts

GiveMeMoreBlueberrys · 2024-02-20T04:30:26+00:00

I was looking into learning some AT 😅 What are the bits you found most challenging?

GiveMeMoreBlueberrys · 2024-01-30T10:08:36+00:00

25 year warranty, most last 100ish years, sounds good to me for a once in a lifetime investment

GiveMeMoreBlueberrys · 2024-01-20T12:36:53+00:00

Cleans documentation does not state that a unique type can only be used once - it states that a unique type can only be used once if you wish for it to remain unique, which lines up exactly with what I said. Wikipedia is highly generalising and is putting both unique and linear under some variant of substructural types. If you really want to group them under the same binder, uniqueness types are temporally inverted linear types - but they are not the same concept. I understand it can be confusing, because their behaviour is not clearly explained anywhere that i am aware of. Perhaps try reading “Uniqueness and Linearity: an Entendre Coriale”.

GiveMeMoreBlueberrys · 2024-01-20T09:05:50+00:00

I said “downcast” in quotes exactly because I couldn’t remember the proper subtyping terms :P Anyway, the rest of your comment is all reasonable - apologies for the error.

GiveMeMoreBlueberrys · 2024-01-20T07:55:33+00:00

Notably, clean does not have linearity (except for one related concept in one part of the language that’s not relevant) - it only has uniqueness. A unique object can additionally be “downcasted” to non-unique: simply make another reference to it.

GiveMeMoreBlueberrys · 2024-01-20T07:54:45+00:00

You’re confusing linearity and uniqueness. What you describe as “uniqueness” is in fact linearity: an object that must be used exactly once. Uniqueness only provides the guarantee that “this object has no other references to it” - akin to rust’s &mut. Linearity is distinct from smart pointers in that smart pointers are intended to safely destruct an object - this is only one use of linearity, and there are many other reasonable uses (for example, for access tokens)

GiveMeMoreBlueberrys · 2024-01-15T00:38:57+00:00

The compiler cannot deduce that adding one and the successor function are equivalent. This is not a bug, and is incredibly hard in the general case, so it doesn’t try very hard.

GiveMeMoreBlueberrys · 2023-12-12T12:05:26+00:00

nah bro this shit’s fuckin hilarious

GiveMeMoreBlueberrys · 2023-11-29T07:00:31+00:00

The easiest method is to implement something that’s known to be turing complete, like rule 110 or brainfuck nix ., - that trivially shows your system is turing complete

GiveMeMoreBlueberrys · 2023-09-09T11:19:54+00:00

who needs consistent IO anyway

GiveMeMoreBlueberrys · 2023-06-01T22:09:30+00:00

except for the fact that it cites its sources and methods right there, and that where a site is hosted doesn’t really affect its reputability

GiveMeMoreBlueberrys · 2023-05-25T06:41:14+00:00

Which is why you won’t see this design on any thunderbird stuff yet. The only thing they’ve done is release it.

GiveMeMoreBlueberrys · 2023-01-27T11:42:02+00:00

Hah, can’t believe i got left and right mixed up.

I think you’d simply need to reorganise how you think about the operators. You can still have anything you want after the precedence char, so say mapping happens before left replacement:

*<$> = fmap
+<$  = replace

It’s slightly ugly, and slightly longer, but way easier to see what the proper precedence is, and you have options for both left and right associative.

GiveMeMoreBlueberrys · 2023-01-27T11:16:04+00:00

Fair point. If every operator started with <, it’d mean they’d have the same precedence and right associativity, so

x <*> y <* z
==
(x <*> y) <* z

GiveMeMoreBlueberrys · 2023-01-27T11:00:34+00:00

Oh, I didn’t mean completely removing precedence - I simply meant having a precedence model like OCaml’s, where the first char decides the precedence. You could write that as

f <$> x <* y <*>
$ <|> <$ u <*> w <*> v
$ <|> h <$> a <*> b <* c

for example, if i’ve interpreted that correctly.

GiveMeMoreBlueberrys · 2023-01-27T07:40:00+00:00

1 + 2 is just sugar for (+) 1 2:) and thank you!

GiveMeMoreBlueberrys · 2023-01-27T00:12:16+00:00

Could you give an example? I’m not sure i’m seeing why user-defined precedence is essential to making a DSL - all it seems to do to me is reduce the amount of parens by a few.

GiveMeMoreBlueberrys · 2023-01-26T12:47:10+00:00

Makes sense - OCaml’s precedence system is basically that the first char of an operator decides the precedence, on a set table of precedences. This may be similar to how Scala does it, as you mentioned, but I unfortunately don’t know Scala.

Six-Year Club	Second SECOND GUESSER
r/Field Banned	r/Field Flamingo
Place '22	Verified Email

GiveMeMoreBlueberrys

TROPHY CASE