There’s no standard computation builder for options, but if you don’t need things like laziness (as added in the examples you linked) the code is straightforward enough that there’s no reason not to trust it (particularly given the suggestively named Option.bind function from the standard library). Here’s a fairly minimal example: type OptionBuilder() = member … Read more
You have many options. Already noted: boolean isEqual = maybeFoo.equals(Optional.of(testFoo)); Alternatively: boolean isEqual = maybeFoo.isPresent() && maybeFoo.get().equals(testFoo); Or: boolean isEqual = testFoo.equals(maybeFoo.orElse(null)); These last two do have slightly different semantics: each returns a different value when maybeFoo is empty and testFoo is null. It’s not clear which is the correct response (which I guess is … Read more
A logical solution would be to use *string as mentioned by Ainar-G. This other answer details the possibilities of obtaining a pointer to a value (int64 but the same works for string too). A wrapper is another solution. Using just string An optional string means a string plus 1 specific value (or state) saying “not … Read more
Yes, this is perfectly safe: std::queue<T> q; // add stuff… T top = std::move(q.front()); q.pop(); pop() doesn’t have any preconditions on the first element in the q having a specified state, and since you’re not subsequently using q.front() you don’t have to deal with that object being invalidated any more. Sounds like a good idea … Read more
Extend the java API with a method to unwrap Optional: fun <T> Optional<T>.unwrap(): T? = orElse(null) Then use it like you wanted: val msg: Something? = optional.unwrap() // the type is enforced See https://kotlinlang.org/docs/reference/extensions.html for details.
Unless otherwise specified, a moved-from object of class type is left in a valid but unspecified state. Not necessarily a “reset state”, and definitely not “invalidated”. For primitive types , moving is the same as copying, i.e. the source is unchanged. The defaulted move-constructor for a class type with primitive members will move each member, … Read more
From Joshua Bloch effective Java, Chapter 2. Creating and Destroying Objects, 1 Item: Consider static factory methods instead of constructors Why? One advantage of static factory methods is that, unlike constructors, they have names. With static factory methods we can specify some instantiation behavior in the method definition. This makes the API easier to use … Read more
There are many similarities and just a handful of differences. (Regular) Optionals Declaration: var opt: Type? Unsafely unwrapping: let x = opt!.property // error if opt is nil Safely testing existence : if opt != nil { … someFunc(opt!) … } // no error Safely unwrapping via binding: if let x = opt { … … Read more
I don’t believe there’s a direct function equivalent to liftM2, but you can combine Option::and_then and Option::map like this: fn main() { let a = Some(5); let b = Some(10); let f = |a, b| { a + b }; println!(“{:?}”, a.and_then(|a| b.map(|b| f(a, b)))); } Output: Some(15)
At time of writing, TypeScript does not support the optional chaining operator. See discussion on the TypeScript issue tracker: https://github.com/Microsoft/TypeScript/issues/16 As a warning, the semantics of this operator are still very much in flux, which is why TypeScript hasn’t added it yet. Code written today against the Babel plugin may change behavior in the future … Read more