kyo-data
API
Generated with
kyo-data/kyo/Maybe

Maybe

kyo.Maybe$package.Maybe
opaque object Maybe

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Self type
Maybe.type

Members list

Type members

Classlikes

object Defined

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Defined.type
sealed abstract class Empty

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Empty
case object Empty extends Empty

Attributes

Companion
class
Supertypes
trait Singleton
trait Product
trait Mirror
trait Serializable
trait Product
trait Equals
class Empty
class Object
trait Matchable
class Any
Show all
Self type
Empty.type
final implicit class Ops[A](maybe: Maybe[A]) extends AnyVal

Attributes

Supertypes
class AnyVal
trait Matchable
class Any

Types

opaque type Defined[+A]

Value members

Concrete methods

def apply[A](v: A): Maybe[A]
def empty[A]: Maybe[A]
def fromOption[A](opt: Option[A]): Maybe[A]
inline def when[A](cond: Boolean)(inline v: => A): Maybe[A]

Givens

Givens

inline given given_CanEqual_Maybe_Maybe[A, B](using inline ce: CanEqual[A, B]): CanEqual[Maybe[A], Maybe[B]]
given given_Conversion_Maybe_IterableOnce[A]: Conversion[Maybe[A], IterableOnce[A]]

Extensions

Extensions

extension [A](self: Maybe[A])
inline def collect[B](pf: PartialFunction[A, B]): Maybe[B]
def contains[B](elem: B)(using CanEqual[A, B]): Boolean
inline def exists(inline f: A => Boolean): Boolean
inline def filter(inline f: A => Boolean): Maybe[A]
inline def filterNot(inline f: A => Boolean): Maybe[A]
inline def flatMap[B](inline f: A => Maybe[B]): Maybe[B]
inline def flatten[B](using inline ev: A <:< Maybe[B]): Maybe[B]
inline def fold[B](inline ifEmpty: => B)(inline ifDefined: A => B): B
inline def forall(inline f: A => Boolean): Boolean
inline def foreach(inline f: A => Unit): Unit
def get: A
inline def getOrElse[B >: A](inline default: => B): B
inline def isDefined: Boolean
def isEmpty: Boolean
def iterator: Iterator[A]
inline def map[B](inline f: A => B): Maybe[B]
inline def nonEmpty: Boolean
inline def orElse[B >: A](inline alternative: => Maybe[B]): Maybe[B]
inline def toLeft[X](inline right: => X): Either[A, X]
def toList: List[A]
def toOption: Option[A]
inline def toRight[X](inline left: => X): Either[X, A]
inline def withFilter(inline f: A => Boolean): Maybe[A]
def zip[B](that: Maybe[B]): Maybe[(A, B)]

Implicits

Implicits

final implicit def Ops[A](maybe: Maybe[A]): Ops[A]
Generated with