Some

data class Some<out T> : Option<T>

Constructors

<init> Some(t: T)

Properties

t	`val ~~t~~: T`
value	`val value: T`

Functions

isEmpty	Returns true if the option is None, false otherwise.`fun isEmpty():` `Boolean`
toString	`fun toString():` `String`

Extension Functions

altFold	`fun <T, F, A> Kind<T, A>.altFold(AF:` `Alternative<F>, FT:` `Foldable<T>): Kind<F, A>`
altFromOption	`fun <F, A>` `Option<A>.altFromOption(AF:` `Alternative<F>): Kind<F, A>`
altSum	`fun <T, F, A> Kind<T, Kind<F, A>>.altSum(AF:` `Alternative<F>, FT:` `Foldable<T>): Kind<F, A>`
combine	`fun <A>` `Option<A>.combine(SGA:` `Semigroup<A>, b:` `Option<A>):` `Option<A>`
combineAll	`fun <A>` `Option<A>.combineAll(MA:` `Monoid<A>): A`
ensure	`fun <A>` `Option<A>.ensure(error: () ->` `Unit, predicate: (A) ->` `Boolean):` `Option<A>`
filterIsInstance	Returns an Option containing all elements that are instances of specified type parameter R.`fun <B>` `Option<*>.filterIsInstance():` `Option<B>`
fix	`fun <A>` `OptionOf<A>.~~fix~~():` `Option<A>`
flatten	`fun <A>` `Option<Option<A>>.flatten():` `Option<A>`
getOrElse	Returns the option’s value if the option is nonempty, otherwise return the result of evaluating `default`.`fun <T>` `Option<T>.getOrElse(default: () -> T): T`
handleError	`fun <A>` `Option<A>.handleError(f: (Unit) -> A):` `Option<A>`
handleErrorWith	`fun <A>` `Option<A>.handleErrorWith(f: (Unit) ->` `Option<A>):` `Option<A>`
or	`infix fun <T>` `OptionOf<T>.or(value:` `Option<T>):` `Option<T>`
orElse	Returns this option’s if the option is nonempty, otherwise returns another option provided lazily by `default`.`fun <A>` `OptionOf<A>.orElse(alternative: () ->` `Option<A>):` `Option<A>`
redeem	`fun <A, B>` `Option<A>.redeem(fe: (Unit) -> B, fb: (A) -> B):` `Option<B>`
redeemWith	`fun <A, B>` `Option<A>.redeemWith(fe: (Unit) ->` `Option<B>, fb: (A) ->` `Option<B>):` `Option<B>`
reflect	The inverse of splitM.`fun <F, A> Kind<ForOption,` `Tuple2<Kind<F, A>, A>>.reflect(ML:` `MonadLogic<F>): Kind<F, A>`
replicate	`fun <A>` `Option<A>.replicate(n:` `Int, MA:` `Monoid<A>):` `Option<A>`
rethrow	`fun <A>` `Option<Either<Unit, A>>.rethrow():` `Option<A>`
salign	`fun <A>` `Option<A>.salign(SA:` `Semigroup<A>, b:` `Option<A>):` `Option<A>`
select	`fun <A, B>` `Option<Either<A, B>>.~~select~~(f:` `OptionOf<(A) -> B>):` `Option<B>`
separateEither	Separate the inner Either value into the Either.Left and Either.Right.`fun <A, B>` `Option<Either<A, B>>.separateEither():` `Pair<Option<A>,` `Option<B>>`
separateValidated	Separate the inner Validated value into the Validated.Invalid and Validated.Valid.`fun <A, B>` `Option<Validated<A, B>>.separateValidated():` `Pair<Option<A>,` `Option<B>>`
sequence	`fun <A>` `Option<Iterable<A>>.sequence():` `List<Option<A>>`
sequenceEither	`fun <A, B>` `Option<Either<A, B>>.sequenceEither():` `Either<A,` `Option<B>>`
sequenceValidated	`fun <A, B>` `Option<Validated<A, B>>.sequenceValidated():` `Validated<A,` `Option<B>>`
unalign	`fun <A, B>` `Option<Ior<A, B>>.unalign():` `Pair<Option<A>,` `Option<B>>` `fun <A, B, C>` `Option<C>.unalign(f: (C) ->` `Ior<A, B>):` `Pair<Option<A>,` `Option<B>>`
unite	`fun <A>` `Option<Iterable<A>>.unite(MA:` `Monoid<A>):` `Option<A>`
uniteEither	`fun <A, B>` `Option<Either<A, B>>.uniteEither():` `Option<B>`
uniteValidated	`fun <A, B>` `Option<Validated<A, B>>.uniteValidated():` `Option<B>`
unzip	`fun <A, B>` `Option<Pair<A, B>>.unzip():` `Pair<Option<A>,` `Option<B>>` `fun <A, B, C>` `Option<C>.unzip(f: (C) ->` `Pair<A, B>):` `Pair<Option<A>,` `Option<B>>`
widen	Given A is a sub type of B, re-type this value from Option to Option`fun <B, A : B>` `Option<A>.widen():` `Option<B>`