It will be really handy to have infix or function in Optional for fallback to default value in case of None like:

val some = Some(1)
val someOrDefault = some or 2

Implementation functional operations for Option like scala, java 8

sealed class Optional<out T : Any> : Serializable {
    val isPresent: Boolean get() = this != None
}

inline fun <T : Any> Iterable<Optional<T>>.foreach(action: (T) -> Unit): Unit =
    this.filter { it.isPresent }.map { (it as Some<T>).value }.forEach(action)

inline fun <T : Any, R> Iterable<Optional<T>>.flatMap(mapper: (T) -> R): List<R> =
    this.filter { it.isPresent }.map { (it as Some<T>).value }.map(mapper)

@weefbellington from our team at Lyft has been working on serializing/deserializing Koptional values in JSON and we've stuck for some time discussing following use case:

Optional<Optional<T>> (and other levels of direct nesting).

This use case is weird on its own, however Koptional does nothing to prevent it (neither does Arrow btw), so it's a valid state for Koptional 1.x.

Right now we've decided to serialize/deserialize without enhancing JSON with additional metadata, which results in following convention for JSON:

Some(None) → None

However, that creates difference between how we represent Some(None) in-memory vs JSON.

With all that in mind, I'd like to raise a discussion about this and propose following changeset for Koptional 2.x:

• Hide Some constructor
• Expose a function named Some(): Optional<T> that would return None for Some(None)

cc @ming13 @dmitry-novikov @nostra13 @AlecStrong @Egorand

Hello! Your library is published only to jcenter. Please consider publishing it also to mavenCentral, as jcenter is shutting down in May.

Here is some info on how to publish artifacts to mavenCentral.

Often times in code i do something like:

optionalStream()
  .subscribe { fooOptional ->
    val foo = fooOptional.toNullable()
    if (foo != null) ...
    else ...
  }

with operator fun component1() = toNullable() implemented on Optional I could instead do:

optionalStream()
  .subscribe { (foo) ->
    if (foo != null) ...
    else ...
  }

tiny optimization. Happy to contribute this if it makes sense but since its api changing I figured I'd issue first in case it doesnt make sense

Example:

val stream = if (true) {
    Observable.just(Some(IOException()), None)
} else {
    Observable.just(Some(RuntimeException()), None)
}

stream.filterSome() // Compile error

stream is of type Observable<out Optional<Exception>> and filterSome() (and other RxJava 2 extensions) can't be applied to such streams. Need to fix it.

Currently, the type parameter of Optional is constrained to not be nullable; however, if it weren't, it would allow an important distinction between no value and not present (e.g.: deserializing data).

Would this be possible (or make sense), and would it fit the design goals of this library?