News for hackers. Stuff that matters.
Re:Overhead of Returning Optional Values in Java and Rust by Traubenfuchs on Saturday October 16, 2021 @12:44PM (#28889142)
Using null is fine. You probably don‘t need Optional. Using Optional is often „clever“ (=bad) overengineering.

Every NullPointerExceptipn my code ever caused was good, because it helped find an error state that had no acceptable default non error state alternative.

Re:Overhead of Returning Optional Values in Java and Rust by setr on Saturday October 16, 2021 @12:49PM (#28889184)
> Every NullPointerExceptipn my code ever caused was good, because it helped find an error state that had no acceptable default non error state alternative.

Isn’t that the point of Optional? It just moves that identification of those error states to compile-time rather than at runtime.

Re:Overhead of Returning Optional Values in Java and Rust by xxs on Saturday October 16, 2021 @04:05PM (#28890990)
My takes is that Option is (next to) useless - the most common pattern is ...orElseNull() - yikes.

The only sane approach is removing all nulls as early as they come and declaring/initializing all member variable in the c-tors.

Re:Overhead of Returning Optional Values in Java and Rust by setr on Saturday October 16, 2021 @09:00PM (#28893057)
The problem I think is that if your dependent apis aren’t also consuming Optionals, and relying on type = null || type logic, then you end up constantly translating back and forth between the two endlessly, defeating any ergonomic gains.

The ideal state is that anything that isn’t Optional is guaranteed to be non-null. So when you go ahead and remove all nulls as early as possible, you can statically guarantee that remains true forever-more.

But if all your libraries just go ahead and drop this knowledge anyways, and when they return an object without meaning non-nullable, then you’re back to where you started.

Whereas in an ML, I know every library is already adhering to this, so something being not-optional actually means something. Bolting it into a language ad-hoc, you go from everything can be null to this weird tristate — a type might be nullable, or might not be nullable and if it’s in an optional, it definitely is nullable… so your best bet is just checking for null every time anyways

Re:Overhead of Returning Optional Values in Java and Rust by valenterry on Saturday October 16, 2021 @12:47PM (#28889163)
Not sure if satire. But if not:

> Every NullPointerExceptipn my code ever caused was good, because it helped find an error state that had no acceptable default non error state alternative.

Yeah, and with Optional you would have found it at compile-time.

Re:Overhead of Returning Optional Values in Java and Rust by shawnz on Saturday October 16, 2021 @01:09PM (#28889350)
Using "Optional" doesn't provide any extra compile-time guarantees except that the function could return Optional.empty(). It's already possible to see that it could return null, so there's no extra guarantees there. The only advantage of "Optional" is that it lets you deal with the empty/null case with a nice functional API instead of if statements. It doesn't do anything to solve the reverse problem of guaranteeing that non-Optional functions can't return null.

If you just want to provide a hint to the caller at compile time about whether you intend for the possibility of returning null, you could use @Nullable/@NotNull annotations to achieve that with no overhead.

Re:Overhead of Returning Optional Values in Java and Rust by ubercow13 on Saturday October 16, 2021 @01:10PM (#28889368)
Yes, in a language like Java where it's retrofitted in years after the decision was already made to allow literally everything to be null. In other languages, that doesn't apply.
Re:Overhead of Returning Optional Values in Java and Rust by brabel on Saturday October 16, 2021 @01:44PM (#28889742)
It doesn't apply in other languages either as long as their nulls are "safe", as in Kotlin or TypeScript.
Re:Overhead of Returning Optional Values in Java and Rust by Zababa on Saturday October 16, 2021 @01:58PM (#28889897)
The thing is that people usually don't have a lot of code to handle the null case, so having optional where you can easily chain the happy case often offers a better experience. It also allows you to differentiate when people will return null for nothing, or when they will return an empty object. I know that in the codebase I work with, people use both. With Optional, you don't have that problem.
Re:Overhead of Returning Optional Values in Java and Rust by shawnz on Saturday October 16, 2021 @05:03PM (#28891485)
Why not just chain the happy case by ignoring nulls, and let any potential NullPointerException bubble up to the point in the code where you would have had an "Optional.orElse" or whatever? Isn't that often just as easy? If you want it to be explicit then you could just add "@throws NullPointerException" to your javadoc. And of course having Optional in your type signature doesn't guarantee you'll never return empty objects (or even null).
Re:Overhead of Returning Optional Values in Java and Rust by valenterry on Saturday October 16, 2021 @09:36PM (#28893217)
Because then you cannot differentiate anymore between "NullPointerException as a bug" or "NullPointerException as a feature".

E.g. you might want to return the streetnumber of a user's address. When a NPE is thrown, was it because there is a bug somewhere in the code or because the user's address has no street number?

With Optional, it is clear: there was no street number.

Re:Overhead of Returning Optional Values in Java and Rust by hashmash on Saturday October 16, 2021 @01:04PM (#28889310)
Only if you never have the case where Optional is empty but you expected it not to be. How often is Optional.get or orElseThrow called blindly? How often is boilerplate code written which checks if the optional is empty and then throws "should not happen" exception or just logs a message? Once NullPointerException got "helpful" messages, I don't see that much advantage to Optional, considering that it provides less information out of the box.
Re:Overhead of Returning Optional Values in Java and Rust by thinkharderdev on Saturday October 16, 2021 @02:51PM (#28890353)
The advantage is if you are explicitly modelling a value that could be empty. You can encode that into the type system by making git an Option<T> instead of just a T (that could be null). At it's most basic level it can just help reduce the possibility of NullPointerExceptions but the real benefit and reduction of boilerplate comes when you use Option as a monad. For instance, in Scala if you have a something like

case class Address(street: String, city: String, state, String) case class User(id: Int, name: String, address: Option[Address])

def filterCAUsers(users: List[User]): List[User] = users.filter(_.address.exists(_.state != "CA"))

Re:Overhead of Returning Optional Values in Java and Rust by esrauch on Saturday October 16, 2021 @01:59PM (#28889903)
> Only if you never have the case where Optional is empty but you expected it not to be

I kind of think that sentence is contrary to the point of Optional, and if you start from that mindset then Optionals do end up no better than nulls.

Instead you enforce good hygiene where you unwrap early and pass non-Optionals for anything that you "know" is non-null. If you call a function which returns optional, and you're find yourself thinking "nah, I _know_ this is definietly non-empty" then you're incorrect; the API explicitly is telling you that it definitely can be empty.

Re:Overhead of Returning Optional Values in Java and Rust by hashmash on Saturday October 16, 2021 @02:27PM (#28890160)
There are certainly cases where Optional is better than a "this can be null" comment, but consider the possibility that the Map interface was designed to always return Optional. If I'm using a Map that I have complete control over, that I know what's in it (I think), then I'll call Map.get(x).orElseThrow(). This isn't an improvement over a Map.get(x) call that can return null. It's also uglier, and as shown by the Rust benchmark, much slower. I'd be happier with a Map interface that had a "tryGet" and "get" pair, where only the latter threw an exception. No need for Optional.
Re:Overhead of Returning Optional Values in Java and Rust by valenterry on Saturday October 16, 2021 @09:44PM (#28893252)
It _is_ an improvement.

If you just do "Map.get(x)" and you get null because your thinking was wrong, then the NPE will pop up potentially 10 layers later or an hour later, when the null-value was tried to be used in your program.

On the other hand, with "Map.get(x).orElseThrow()" you will have an exception thrown immediately! Even better, you should customize that as "Map.get(x).orElseThrow(NoSuchElementException(x))" so that you know the value that was unexpectedly not in the list.

That will make debugging much easier and will potentially fail a test case while a "Map.get(x)" might not cause the test to fail.

Re:Overhead of Returning Optional Values in Java and Rust by convolvatron on Saturday October 16, 2021 @01:13PM (#28889401)
for me this is one of the bigger festering wounds in programming. error handling doubles the size of the code. error handling is complicated.

so we put on our big-dev pants and build all sorts of structures around handling errors to make it more sound/ergonomic.

but at the end of the day:

   o its still very difficult to respond in a semantically meaningful way to errors as code

   o they still almost always just get dumped into a log or ignored, or just result in a panic

   o even if we have managed to surface them - they still aren't really that actionable by the end user
so we haven't helped the situation much, but some of these answer like catch/throw have really unpleasant consequences - we may have made it worse
Re:Overhead of Returning Optional Values in Java and Rust by valenterry on Saturday October 16, 2021 @09:40PM (#28893233)
It's pretty much a solved problem. Just use a language that has better ergonomics for errors.

Scala's ZIO is one of the better examples if you are interested to look into an alternative.

Re:Overhead of Returning Optional Values in Java and Rust by Zababa on Saturday October 16, 2021 @01:57PM (#28889883)
> Using null is fine. You probably don‘t need Optional. Using Optional is often „clever“ (=bad) overengineering.

Option types are 8 years older than null (ML: 1973, null: 1965). There's nothing clever about it. It's simple to understand, and is an explicit wrapper around an object, while a pointer is an "implicit" pointer around an object. Option<Obj> is clear, you know that it can be something or nothing. Plain Obj is deceiving.

> Every NullPointerExceptipn my code ever caused was good, because it helped find an error state that had no acceptable default non error state alternative.

That's the point of option types and pattern matching, it can force you to handle both cases.

Re:Overhead of Returning Optional Values in Java and Rust by plmpsu on Saturday October 16, 2021 @01:18PM (#28889449)
I agree. Add null checking at compile time with something like checkerframework to get the best of both worlds.
Re:Overhead of Returning Optional Values in Java and Rust by brabel on Saturday October 16, 2021 @01:50PM (#28889813)
Exactly. I don't get why people complain about null-pointers in Java when all it takes to get rid of them is enabling static analysis that enforces checking for null at compile time... as that's exactly as safe as using Optional, and as Kotlin has shown, it's also possible to have a nicer interface (e.g. `something?.let { it.isNotNullHere() }`) with bare nulls... without incurring the cost of allocation or of declaring generic types everywhere.

Since I started using "safe" nulls with Ceylon, nearly a decade ago, later with Kotlin and TypeScript, I've been firmly in the camp of supporting nulls in the language instead of `Optional` or `Maybe`. Rust should've used them IMO... using `?` for error propagation instead is such a weird choice.

Re:Overhead of Returning Optional Values in Java and Rust by Zababa on Saturday October 16, 2021 @02:13PM (#28890016)
? is used for Result, and not for Option. For Option, you use .unwrap(). Supporting nulls in the language also means that everything else is going to be second-class, while sum types allows you to do pretty much everything you want.
Re:Overhead of Returning Optional Values in Java and Rust by brabel on Saturday October 16, 2021 @02:55PM (#28890399)
Looks like you have much to learn about Rust. Option can also use `?`

Example (from [1]):

    // Assume
    // fn halves_if_even(i: i32) -> Option<i32>

    fn do_the_thing(i: i32) -> Option<i32> {
        let i = halves_if_even(i)?;

        // use `i`
    }
Besides, the `?` is syntax sugar for the `try!` macro as explained in the `try!` macro docs [2], and has nothing to do with sum types, at least not directly.

Ceylon would be a closer case where nullable types are represented as sum types and not a special-case in the language (`String | Null` is the same as `String?`)... but Ceylon, as Rust, special-cased the `?` operator for "something"... in Ceylon, they are used for null-checks, and in Rust, for propagating errors via the `try!` macro, which is what my previous comment was about.

[1] https://stackoverflow.com/questions/42917566/what-is-this-qu...

[2] https://doc.rust-lang.org/std/macro.try.html

Re:Overhead of Returning Optional Values in Java and Rust by Zababa on Saturday October 16, 2021 @03:35PM (#28890750)
You're right, I'm not sure how I thought that it worked only with Result. Thanks for the correction.

> Ceylon would be a closer case where nullable types are represented as sum types and not a special-case in the language (`String | Null` is the same as `String?`).

Aren't those union types? My understanding is that they are different from sum types, as you usually have to declare the sum types beforehand, and sum types are collections of values, while union types are collections of types, and are often declared "on the spot". At least that's how they work in Typescript, I don't know much about Ceylon.

To go back to option types, people usually like them because there are well-known patterns to program with them (like map). Of course you can get the same safety with static flow analysis (Typescript does this), but I think part of it is ergonomics, influenced by functional programming. Though if there is an overhead like in Java, I'm not sure about their value.

Re:Overhead of Returning Optional Values in Java and Rust by brabel on Monday October 18, 2021 @07:35AM (#28904357)
I don't know if there's a meaningful difference between sum types and union types as both end up allowing a variable to be of one of a set of types.

Ceylon:

    alias StringOrInt = String | Integer;
    StringOrInt myValue = "foo";
    StringOrInt otherValue = 10;
Rust:

    enum StringOrInt {
        Str(String),
        Int(usize),
    }
    let my_value: StringOrInt = StringOrInt::Str("foo");
    let other_value: StringOrInt = StringOrInt::Int(10);
In Ceylon, you're right you don't need to name a "union", which IMO makes it much nicer, as I was able to use adhoc unions everywhere, e.g. inside streaming operations:

    [ for x in foos if (x.something()) "foo" else 10 ]
The above "automatically" has type `[String | Integer]`. In Rust (and Kotlin) I would need to name a type just for this.

Another disadvantage of Rust's approach is that the type variants are not types themselves. That's really annoying sometimes, e.g. you want to have a method that only handles one of the variants, but you can't (you need to pass the values the variant wraps separately, but that may be undesirable semantically as that would allow something that has no instance of the enum to also use the function).

Re:Overhead of Returning Optional Values in Java and Rust by Zababa on Tuesday October 19, 2021 @05:40AM (#28916391)
I think there is a difference. Sum types allows you to choose between values, union types allows you to choose between types. The values of the sum types can contain themselves types, but they don't have to. On the other hand, you have to declare sum types beforehand, and you don't have that with union types. The equivalent of sum types in Ceylon seems to be enumerated types, which from what I understand you also have to declare beforehand. The difference with Rust is that Ceylon also has union types (Scala is the same, Typescript has unions but lacks proper sum types).

As an interesting aside, Rust has what seem to be intersection types for trait bounds (fn toto<T: Trait1 + Trait2)(a: T)).

I'm still not sure about the tradeoffs between union/intersection types and sum/product types. I think the difference is that "set types" are structural, while algebraic types are nominal, which comes with the usual tradeoffs, but I'm not sure.

Re:Overhead of Returning Optional Values in Java and Rust by Measter on Sunday October 17, 2021 @08:29AM (#28895978)
The `?` operator doesn't desugar to the the `try!` macro, it uses the `Try` trait.

https://doc.rust-lang.org/std/ops/trait.Try.html

Re:Overhead of Returning Optional Values in Java and Rust by brabel on Monday October 18, 2021 @07:22AM (#28904294)
Ah, right... but as far as I know, it's the exact same behaviour, at least currently... reading the docs for the try macro, however, is what made me finally understand the behaviour of the `?` operator (e.g. how it can "magically" convert error types).
Re:Overhead of Returning Optional Values in Java and Rust by kangalioo on Saturday October 16, 2021 @03:05PM (#28890484)
(? works for both Option and Result, as does unwrap(). ? propagates to the caller, while unwrap() initiates a panic and unwinds the stack)
Re:Overhead of Returning Optional Values in Java and Rust by khuey on Saturday October 16, 2021 @02:54PM (#28890384)
? is used for Option. Just like Result, ? propagates the Err/None to your caller, and unwrap asserts that it's not present.
Re:Overhead of Returning Optional Values in Java and Rust by pjmlp on Sunday October 17, 2021 @02:22AM (#28894396)
Because otherwise how would they sell their favourite guest language?

It is like Google uses their pseudo Java dialect when selling Kotlin features, instead of comparing it with proper Java.

Re:Overhead of Returning Optional Values in Java and Rust by pkolaczk on Saturday October 16, 2021 @02:48PM (#28890339)
With Kotlin based approach to nulls you can't represent Option<Option<T>> values.
Re:Overhead of Returning Optional Values in Java and Rust by brabel on Saturday October 16, 2021 @03:00PM (#28890435)
And that's a good thing, no? I've never met a good use cases for double-wrapping values like this.
Re:Overhead of Returning Optional Values in Java and Rust by Zababa on Saturday October 16, 2021 @03:38PM (#28890764)
I'm not an expert on Kotlin but this reminds me of JS promises. The issue was that by not supporting Promise<Promise<T>>, promises were not monadic. It look like the same issue in Kotlin.
Re:Overhead of Returning Optional Values in Java and Rust by nemetroid on Saturday October 16, 2021 @04:13PM (#28891054)
I thought this was a good example: https://news.ycombinator.com/item?id=28746293