The Nineteenth Byte

Rydwolf Programs

18:00

Actually yes

But it should still use Rust enums

Not unions

Because any time you're using a union you still have an enum structure somewhere

Even if it's very indirectly

And IMO it makes way more sense to put the data in the enum instead of having them loosely related

Seggan

@RydwolfPrograms as in like under the hood?

Rydwolf Programs

No, in your code

How else do you know what the type is

Even when you provide it to a function knowing it's a String, sure the function knows it's a String, but how does the caller know?

It has to store that somewhere

(and if your sum types work like that, then yeah, you also have to store it under the hood, but I'm assuming you do that anyway)

By partly decoupling the thing that determines the union's type from the union itself, you just introduce tons of opportunities for bugs

Rust's method might be very slightly more verbose, but it's good verbosity

(Verbosity that actually makes the code's possible actions clearer and common bugs impossible, rather than just adding clutter)

Seggan

@RydwolfPrograms no the sum type exists only in the mind of the compiler

lua is dynamic, so it takes care of that for me

Rydwolf Programs

?

I'm talking about the code

Not the compiler

How does your code know if it's a String or an Int or an Expr

Seggan

by casting or matching

Rydwolf Programs

18:07

Wdym by casting. Doesn't that require knowing what to cast to?

And if you're matching, how's that any different from a Rust-style enum? It's just less powerful since you can't have multiple things with the same type (e.g., an int used for a time vs. an int used for a full datetime)

Seggan

what i meant was flow typing

@RydwolfPrograms thats my point

sum types can pretty much perfectly simulate rust enums

Rydwolf Programs

No they can't

Not without tons of annoying clutter

E.g., if you want to use a struct as one of the options, or have multiple options with the same type signature

Seggan

i dont see how tons

i.e. in a hypothetical kotlin dialect

Rydwolf Programs

You'd have to create a whole new type wrapping something like an int just to be able to have two different options in the union with the same type

Seggan

true

i was thinking of making this syntactic sugar

Rydwolf Programs

18:11

And Rust enums carry information about the purpose for having those types, while unions don't

Seggan

but its so complicated

Rydwolf Programs

With a Rust enum you can do things way more complicated than an AST, where it would be very unclear what types map to what possibilities, which would be unsuitable for unions

Seggan

argh fine you won

but im not calling them enums

such a misleading name

Rydwolf Programs

Good, enum is a gross word :p

Seggan

and im still adding union types

Rydwolf Programs

18:13

Wouldn't they be redundant?

Seggan

no

i dont have function overloading

Rydwolf Programs

Rust-style enums mean you can merge enums and union types into a single construct

@Seggan Neither does Rust

Seggan

yeah but its so nice being able to give different types to the same function

besides rust has traits, and i dont

you can simply implement a trait and bam

Rydwolf Programs

@Seggan Which you can do with Rust-style enums?

Right?

Just make your "union types" syntactic sugar for an enum

Seggan

id rather make it the other way

Rydwolf Programs

18:17

You can't tho

Enums are a superset of unions

They carry more information

Seggan

like?

Rydwolf Programs

Like...normal enums. How do you represent enum { ThingOne, ThingTwo, ThingThree } with a union?

Seggan

@RydwolfPrograms unnecessary boilerplate alert

@RydwolfPrograms you dont

Rydwolf Programs

How do you represent enum Signed { Pos(i64), Neg(i64) }

Seggan

im also having java style enums regardless

Rydwolf Programs

18:19

@Seggan Then you can't do the other way around

Seggan

@RydwolfPrograms with wrapper classes

Rydwolf Programs

@Seggan What...if you had Rust-style enums, they would replace Java-style ones

It would make literally no sense to not do that

Because they are a superset of them

Seggan

nope

Rydwolf Programs

There is nothing you can do with a Java-style enum that you can't do with a Rust-style one

Seggan

java style enums are 1. constant and 2. they can have associated information with them

Rydwolf Programs

18:20

Wdym by either of those points

Seggan

i can write in java enum X { Y(1), Z(2); int num; X(int num) {this.num = num}} and then do X.Y.num which gives me 1

useful for making periodic tables lol

Rydwolf Programs

Okay admittedly that is kind of cool, but no reason you can't fit that in with Rust-style ones

Seggan

@RydwolfPrograms by constant i mean that in rust every Option::Some(x) is a different Some object, right?

Rydwolf Programs

In what sense

Seggan

@RydwolfPrograms i cant have both in one

Rydwolf Programs

18:23

Binary-wise they are identical

Comparison wise I believe they are identical

Seggan

yes but they are still different instances across memory, no?

java enums are strictly uninstantainable

Rydwolf Programs

Wdym across memory? In the stack or in the heap? If you put it in the heap with a Box or something then ofc the Boxes would be different

But the Boxes would contain the exact same data

Seggan

let x = Some(1)
let y = Some(2)

2 different Somes, right?

Rydwolf Programs

That question doesn't make sense

Seggan

argh

what im trying to say is you can make more and more of that enum

Rydwolf Programs

18:25

Some(1) is basically just a tuple ([Option::Some's index thingy], 1)

Seggan

in java, the enums instances are all youve got (barring reflection)

Rydwolf Programs

Well yeah 'cause they're just ints internally right?

That's all an enum is, an int with names

Seggan

no

Rydwolf Programs

or with Rust-style ones, an int with names that's the first item in a tuple that can also contain more data

Seggan

java enums are full on objects

Rydwolf Programs

18:27

Well that's dumb

Don't be like Java

Ginger

~~Stop it. Get some help.~~

Seggan

well i am planning to

Rydwolf Programs

Wait hang on what would the difference even be

At a low level

Isn't calling it an object just a choice, but it behaves just like an int with a name? When would it be different?

Seggan

then all data is ints :P

there is no difference between a string and a horse

Rydwolf Programs

@Seggan At some level yes

But those ints can be pointers to more ints

And the numbers of ints varies

And what they mean varies

An enum is just a single int that isn't a pointer, right?

Seggan

18:29

yeah?

Rydwolf Programs

Then it's an int with a name

Seggan

with possibly data associated with it

Rydwolf Programs

A Some(1) is just an int with a name sitting next to an int

Seggan

all objects are

Rydwolf Programs

@Seggan That's not actually stored with the enum value tho right?

Seggan

18:30

it is

Rydwolf Programs

Like I'd assume an X.Y isn't literally stored as ([Y's index], 1)

@Seggan what the literal fuck

Well not literal

But why

Seggan

java enums are syntax sugar for limited instance uninstantainable objects

Rydwolf Programs

Wouldn't you just store a single lookup table that you'd index into?

@Seggan I have no clue what that means but I don't think it matters here

And if you're taking inspiration from Java and it actually does store enums that way my official medical advice is to stop right now :p

Seggan

@RydwolfPrograms because you can add methods too

and use this and all that coolness

Rydwolf Programs

You can do that in Rust, which doesn't do that

I don't see how associated information would at all change whether methods could be added

Or why methods would require storing copies of the associated data all over the place

Seggan

18:42

@RydwolfPrograms what i mean is the X enum is literally (ive seen the bytecode myself) compiled as

class X { static X Y = new X(1); static X Z = new X(2); final int number; private X(int number) { this.number = number }}

@RydwolfPrograms they... dont? thats what i mean by constant

there is only one instance per enum variant

Rydwolf Programs

Then this is false?

Seggan

in C its true

Rydwolf Programs

And an enum is just a pointer to a tuple containing the variant and associated data?

@Seggan Yeah sure but we're not talking about C

Seggan

i thought thats what u meant, my mistake

Rydwolf Programs

nw

Seggan

18:44

ima have to store enums as object anyway, bc lua

Rydwolf Programs

@Seggan I have only one reply to this

Seggan

lol

i forgot the extends Enum but it doesnt matter

Ginger

@RydwolfPrograms AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Rydwolf Programs

Seriously tho we got enums right the first time (then improved them a ton with Rust). Overcomplicating them would be silly.

Java definitely overcomplicates them

Seggan

blame java "everything is an object even functions and enums"

Rydwolf Programs

18:47

@Seggan Why not?

Seggan

how am i to tell the compiler the difference between constant associated data and parameters

Rydwolf Programs

~~The constant associated data is constant~~

But actually just ^

Wouldn't they look different?

A type tends to be distinguishable from a piece of data

Seggan

@RydwolfPrograms i meant as in syntax

Rydwolf Programs

Yeah so do I

enum ThisOneHasParamters {
    X(i64),
    Y(String, Expr),
    Z {
        x: Thing,
        y: String
    }
}

enum ThisOneHasAssocData {
    X(16),
    Y(name),
    Z {
        x: Thing { ... },
        y: "Hi!"
    }
}

@RydwolfPrograms (the types are all different here but ignore that; didn't want to make three different enums)

Seggan

fair enough

Rydwolf Programs

18:52

Although I do see why Rust doesn't do assoc data; it would make more sense to put that in like, a match on the enum rather than in the enum itself a lot of the time

Doing both at once might be kind of mutually exclusive for whether or not they're reasonable

Seggan

yeah thats my point

switches over enums for that purpose are discouraged in java

Rydwolf Programs

Yeah but Rust-style is way more capable than Java-style, right? And no reason you can't just have some sort of method that allows you to conveniently use a dict for associated data

Seggan

it better to (kotlin) enum Element(val atomicNum: Int) { HYDROGEN(1) ...

Rydwolf Programs

Imagine if your lang allowed indexing into hashmaps using enum variants

Seggan

java/kotlin/scala/jvmstuff does

Rydwolf Programs

18:54

Isn't that kinda redundant then?

Seggan

no

its slower

and more verbose

Rydwolf Programs

@Seggan Not if you optimize it out

And given the code you showed me that made me do the darwin face I don't think Java enums particularly care about performance

Sandbox Posts

0

A: Sandbox for Proposed Challenges

How spherical is my ellipsoid? (Willmore energy) code-golfmathgeometry Define the (unnormalised) Willmore energy of a surface as the integral of squared mean curvature over it: $$W=\int_SH^2\,dA$$ For surfaces topologically equivalent to a sphere \$W\ge4\pi\$, and \$W=4\pi\$ iff it is actually a ...

Rydwolf Programs

That also allows you to store different (possibly conflicting) sets of data for the same enum, or without modifying the original enum

Seggan

@RydwolfPrograms still better than hashmaps

@RydwolfPrograms huh

Rydwolf Programs

18:56

E.g., another library can't add atomic mass to your enum's associated data

Seggan

true

Rydwolf Programs

But it can just define a hashmap you'd index into with the enum for atomic mass

Seggan

why cant they do a hashmap

Rydwolf Programs

AtomicMassLib::Mass[myElement]

Seggan

also verbosity

Rydwolf Programs

18:57

That's also more readable than, what, myElement[0]?

parz

( ͡° ͜ʖ ͡°)

Seggan

@RydwolfPrograms myElement.atomicNumber

Rydwolf Programs

Oh right the weird thing

Also, no reason you couldn't also impl a method onto the enum that uses the hashmap

Seggan

thats not how i do things in rol

Rydwolf Programs

myElement.atomicNumber would then just be identical to AtomicNumber[myElement]

@Seggan So it's not...how you rol? :p

Ginger

18:58

ಠ_ಠ

Seggan

no typeclasses

or should i say i dont do oop the way rust does it

Rydwolf Programs

D:

But seriously tho I find AtomicMass[myElement] basically just as readable as myElement.atomicMass

@RydwolfPrograms (I feel like I should get more than a gingerface for that pun :p)

Seggan

oh no

i think a massive wall of text is coming

Rydwolf Programs

Coming up with a good name for OTTNB is so hard because it needs to communicate more off-topic than a Nineteenth Byte/Hole, but still needs to communicate "golfing/CGCC"

I think the bowling direction is promising

Seggan

nvm then

Rydwolf Programs

19:02

Especially since without additional restrictions code-bowling is off-topic

Yet code bowling's still clearly a part of our site

Seggan

the eleventh pin

argh ninja'd

parz

( ͡° ͜ʖ ͡°)

Ginger

ಠ_ಠ

Rydwolf Programs

parz, lenny faces aren't funny on their own y'know

parz

.o.

Rydwolf Programs

19:05

They have to be used with careful consideration to maximize their potential

parz

IF THERE ARE ENOUGH LENNY FACES THEY WILL BE

Rydwolf Programs

Otherwise we risk building immunity to them

parz

HAHAHAHAHQBHAHHAAHHAHAHAH

Lenny immunity is bad, but nobody can build Comic Sans immunity who is not born to it.

Ginger

@parz Those who do not learn the past are condemned to repeat it

DLosc

^

mathcat