It makes perfect sense for the equality operator to support optionals, because it’s absolutely clear that for any integer valued variable i: nil == nil nil != i i != nil i == i if and only if their values are the same On the other hand, it’s not clear how comparison to nil should … Read more
Use map if the function returns the object you need or flatMap if the function returns an Optional. For example: public static void main(String[] args) { Optional<String> s = Optional.of(“input”); System.out.println(s.map(Test::getOutput)); System.out.println(s.flatMap(Test::getOutputOpt)); } static String getOutput(String input) { return input == null ? null : “output for ” + input; } static Optional<String> getOutputOpt(String input) … Read more
The type of the expression &l you match against is &Option<i32>, so if we are strict the patterns should be &None and &Some(x), and if we use these patterns, the type of x indeed is i32. If we omit the ampersand in the patterns, as you did in your code, it first looks like the … Read more
We all know that every object allocated in Java adds a weight into future garbage collection cycles,… That sounds like a statement nobody could deny, but let’s look at the actual work of a garbage collector, considering common implementations of modern JVMs and the impact of an allocated object on it, especially objects like Optional … Read more
You’re right, optionals can be a pain, which is why you shouldn’t overuse them. But they’re more than just something you have to deal with when using frameworks. They’re a solution to an incredibly common problem: how to handle a call that returns a result that might be OK, or might not. For example, take … Read more
from: swift-users mailing list Basically, @escaping is valid only on closures in function parameter position. The noescape-by-default rule only applies to these closures at function parameter position, otherwise they are escaping. Aggregates, such as enums with associated values (e.g. Optional), tuples, structs, etc., if they have closures, follow the default rules for closures that are … Read more
Use a Stream: Stream.of(find1(), find2(), find3()) .filter(Optional::isPresent) .map(Optional::get) .findFirst(); If you need to evaluate the find methods lazily, use supplier functions: Stream.of(this::find1, this::find2, this::find3) .map(Supplier::get) .filter(Optional::isPresent) .map(Optional::get) .findFirst();
(Updated for Swift >=3) “Double optionals” can be useful, and the Swift blog entry “Optionals Case Study: valuesForKeys” describes an application. Here is a simplified example: let dict : [String : String?] = [“a” : “foo” , “b” : nil] is a dictionary with optional strings as values. Therefore let val = dict[key] has the … Read more
This is part of JDK 9 in the form of or, which takes a Supplier<Optional<T>>. Your example would then be: return serviceA(args) .or(() -> serviceB(args)) .or(() -> serviceC(args)); For details see the Javadoc or this post I wrote.
Not setting a read-only (constant) field with either an: initialization expression initializer is almost certainly an indication of an error in your program. Since you have no other opportunity to set the value of your let field, the value of the field is going to remain nil (or some other default). It is rather unlikely … Read more