Definitely looks
unsafe
to me.Image Transcription:
type Wtf = Option>>>>>>>; let two = Some(Some(Some(Some(Some(Some(None)))))); let three = Some(Some(Some(Some(Some(None))))); let six = Some(Some(None)); unsafe { assert_eq!( std::mem::transmute::(two) * std::mem::transmute::(three) std::mem::transmute::(six) ); }
I am a human who transcribes posts to improve accessibility on Lemmy. Transcriptions help people who use screen readers or other assistive technology to use the site. For more information, see here.
If you think that’s bad take a look at this real code posted as a real issue on one of my Github repos, which was described as quite short
That’s not actual code though, it looks like some kind of trace. Notice the filenames at the end of each line.
The actual solution the issue opener there might be looking for is to disable C++ parsing, since it’s not actually C++ code, it’s just some text they pasted into VSCode and they’re wondering why their editor can’t handle it.
Peano arithmetic moment
loud suicide noises
Since all of the expressions just wrap a
None
, I wouldn’t be surprised if the transmutes basically get compiled to0
, making the assertion at the endassert_eq!(0 * 0, 0)
.Nah these are the actual integer representations. Otherwise you would have
Some(None) == Some(Some(None))
which is way too Javascripty for Rust folks.
Is that a Peano Axioms reference ?
https://en.wikipedia.org/wiki/Natural_number#Peano_axiomsIs this how you do Fin in peasant languages?
No, not at all. It’s a joke post, abusing the in-memory representation of the
Option
type to construct numbers. When nesting theOption
type, it turns into a densely packed bit vector…And if I understand the purpose of
Fin
correctly, you’re picking on the one ‘peasant language’ that actually has something like that built-in.
In Rust, you can specify the type of an array as e.g[
. Which is an array containing values of type ]u8
(unsigned 8-bit integer) with a fixed, compile-time-guaranteed length of3
. So,[
could be used to represent an RGB color, for example. ]
It is an array, not a set, but well, close enough.Fin
is a type of finite oridinals bounded by a nat. For example theWTF
type in there is the same type asFin 8
.Of course every language can have
Fin
with a fixed integer, like the post suggest, by just stacking options.However for a properly defined
Fin
type, the input number is dynamic, serves as a bound for the element of the type. For example, Adga was able to type the fact thatn
th fibonacci number is a finite ordinal bounded by a function ofn
. Which I believe is not typable in rust?
For those interested, this is because of how Rust uses value gaps to represent its nullable/enum structures. E.g., like how
None
forOption NonZeroU8
[sic, can’t get formatting to work] is represented internally by a0
instead of a wrapping structure.When you have that many layers around a unit, it will start at
0
and bump the internal representation for eachSome
you turn into aNone
.It’s kinda like lambda calculus numbers
And yet still more better than writing a serious macro