kyo-core
API
Generated with
kyo-core/kyo/all

all

kyo.all$
object all

Attributes

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

Members list

Concise view

Value members

Concrete fields

val KyoApp: KyoApp.type

Extensions

Extensions

extension [E, T](a: Abort[E, T])
final def toEither: Either[E, T]
final def toOption: Option[T]
extension [M[_], E <: Effect[M]](e: E)
final def apply[T]()(using h: DeepHandler[M, E], s: Safepoint[E]): T > E => M[T]
extension [T](fiber: Fiber[T])
final def block: T > IOs
final def interrupt: Boolean > IOs
final def interrupt(reason: String): Boolean > IOs
final def isDone: Boolean > IOs
final def join: T > Fibers
final def joinTry: Try[T] > Fibers | IOs
final def onComplete(f: T > IOs => Unit): Unit > IOs
final def transform[U](t: T => Fiber[U]): Fiber[U]
extension (l: Logger)
final def debug(msg: => String, t: Throwable): Unit > IOs
final def debug(msg: => String): Unit > IOs
final def error(msg: => String, t: Throwable): Unit > IOs
final def error(msg: => String): Unit > IOs
final def info(msg: => String, t: Throwable): Unit > IOs
final def info(msg: => String): Unit > IOs
final def trace(msg: => String, t: Throwable): Unit > IOs
final def trace(msg: => String): Unit > IOs
final def warn(msg: => String, t: Throwable): Unit > IOs
final def warn(msg: => String): Unit > IOs
extension [T](p: Promise[T])
final def complete(v: => T > IOs): Boolean > IOs
final def unsafeComplete(v: T > IOs): Boolean
extension [T](ref: AtomicRef[T])
final def cas(curr: T, next: T): Boolean > IOs
final def get: T > IOs
final def getAndSet(v: T): T > IOs
final def lazySet(v: T): Unit > IOs
final def set(v: T): Unit > IOs
extension (ref: LongAdder)
final def add(v: Long): Unit > IOs
final def decrement: Unit > IOs
final def get: Long > IOs
final def reset: Unit > IOs
extension (ref: AtomicLong)
final def addAndGet(v: Long): Long > IOs
final def cas(curr: Long, next: Long): Boolean > IOs
final def decrementAndGet: Long > IOs
final def get: Long > IOs
final def getAndAdd(v: Long): Long > IOs
final def getAndDecrement: Long > IOs
final def getAndIncrement: Long > IOs
final def getAndSet(v: Long): Long > IOs
final def incrementAndGet: Long > IOs
final def lazySet(v: Long): Unit > IOs
final def set(v: Long): Unit > IOs
extension (ref: AtomicInt)
final def addAndGet(v: Int): Int > IOs
final def cas(curr: Int, next: Int): Boolean > IOs
final def decrementAndGet: Int > IOs
final def get: Int > IOs
final def getAndAdd(v: Int): Int > IOs
final def getAndDecrement: Int > IOs
final def getAndIncrement: Int > IOs
final def getAndSet(v: Int): Int > IOs
final def incrementAndGet: Int > IOs
final def lazySet(v: Int): Unit > IOs
final def set(v: Int): Unit > IOs
extension (ref: AtomicBoolean)
final def cas(curr: Boolean, next: Boolean): Boolean > IOs
final def get: Boolean > IOs
final def getAndSet(v: Boolean): Boolean > IOs
final def lazySet(v: Boolean): Unit > IOs
final def set(v: Boolean): Unit > IOs
extension (ref: DoubleAdder)
final def add(v: Double): Unit > IOs
final def get: Double > IOs
final def reset: Unit > IOs
extension [T](u: Queue[T])
final def capacity: Int
final def isEmpty: Boolean > IOs
final def isFull: Boolean > IOs
final def offer(v: T): Boolean > IOs
final def peek: Option[T] > IOs
final def poll: Option[T] > IOs
final def size: Int > IOs
final def unsafe: Unsafe[T]
extension [M[_], T, S](v: M[T] > S)
final def >[E <: Effect[M]](e: E)(using fr: Frame[">"]): T > S | E
extension [T, S, S2](v: T > S > S2)
final def flatten(using x$2: Frame["apply"]): T > S | S2
extension [T, S](v: T > S)
final def <[M[_], E <: Effect[M], S2 <: S](e: E)(using x$3: S => S2 | E)(using h: Handler[M, E], s: Safepoint[E], fr: Frame["<"]): M[T] > S2
final def <<[U](f: T > S => U): U
final def >>[M1[_], M2[_], E1 <: Effect[M1], E2 <: Effect[M2], S2, S3](tup: (E1, E2))(using i: Injection[M1, E1, M2, E2, S3], fr: Frame["<<"])(using x$5: S => S2 | E1 | E2): T > S2 | S3 | E2
final def apply[U, S2](f: T => U > S2)(using fr: Frame["apply"]): U > S | S2
final def flatMap[U, S2](f: T => U > S2): U > S | S2
final def map[U](f: T => U): U > S
final def unit: Unit > S
final def withFilter(p: T => Boolean): T > S

Exports

Defined exports

final type > = >
Exported from core$
final type AKyo = AKyo
Exported from core$
final val Abort: Abort.type
Exported from aborts
final type Abort = Abort
Exported from aborts$
final val Aborts: Aborts.type
Exported from aborts
final type Aborts = Aborts
Exported from aborts$
final val Adders: Adders.type
Exported from adders
val Arrows: Arrows
Exported from arrows
final type Arrows = Arrows
Exported from arrows$
final type AtomicBoolean = AtomicBoolean
Exported from atomics$
final type AtomicInt = AtomicInt
Exported from atomics$
final type AtomicLong = AtomicLong
Exported from atomics$
final type AtomicRef = AtomicRef
Exported from atomics$
final val Atomics: Atomics.type
Exported from atomics
final type Channel = Channel
Exported from channels$
final val Channels: Channels.type
Exported from channels
final val Clock: Clock.type
Exported from clocks
final type Clock = Clock
Exported from clocks$
final val Clocks: Clocks.type
Exported from clocks
final type Clocks = Clocks
Exported from clocks$
final val Console: Console.type
Exported from consoles
final type Console = Console
Exported from consoles$
final val Consoles: Consoles.type
Exported from consoles
final type Consoles = Consoles
Exported from consoles$
final type DeepHandler = [M[_], E <: Effect[M]] =>> DeepHandler[M, E]
Exported from core$
final type DoubleAdder = DoubleAdder
Exported from adders$
final type Effect = [M[_]] =>> Effect[M]
Exported from core$
final type Env = Env
Exported from envs$
final val Envs: Envs.type
Exported from envs
final type Envs = Envs
Exported from envs$
final type Fiber = Fiber
Exported from fibers$
val Fibers: Fibers
Exported from fibers
final type Fibers = Fibers
Exported from fibers$
final type Handler = [M[_], E <: Effect[M]] =>> Handler[M, E]
Exported from core$
final type IO = IO
Exported from ios$
val IOs: IOs
Exported from ios
final type IOs = IOs
Exported from ios$
final type Injection = [M1[_], E1 <: Effect[M1], M2[_], E2 <: Effect[M2], S] =>> Injection[M1, E1, M2, E2, S]
Exported from core$
final type InlineConversion = InlineConversion
Exported from core$
final type Kyo = [M[_], E <: Effect[M], T, U, S] =>> Kyo[M, E, T, U, S]
Exported from core$
final type KyoCont = [M[_], E <: Effect[M], T, U, S] =>> KyoCont[M, E, T, U, S]
Exported from core$
final type KyoIO = KyoIO
Exported from ios$
final type KyoRoot = [M[_], E <: Effect[M], T, S] =>> KyoRoot[M, E, T, S]
Exported from core$
final type Latch = Latch
Exported from latches$
final val Latches: Latches.type
Exported from latches
val Lists: Lists
Exported from lists
final type Lists = Lists
Exported from lists$
final type Local = Local
Exported from locals$
final val Locals: Locals.type
Exported from locals
final type Logger = Logger
Exported from loggers$
final val Loggers: Loggers.type
Exported from loggers
final type LongAdder = LongAdder
Exported from adders$
final type Meter = Meter
Exported from meters$
final val Meters: Meters.type
Exported from meters
val Options: Options
Exported from options
final type Options = Options
Exported from options$
final val Preempt: Preempt.type
Exported from ios
final type Preempt = Preempt
Exported from ios$
final type Promise = Promise
Exported from fibers$
final type Queue = Queue
Exported from queues$
final val Queues: Queues.type
Exported from queues
final val Random: Random.type
Exported from randoms
final type Random = Random
Exported from randoms$
final val Randoms: Randoms.type
Exported from randoms
final type Randoms = Randoms
Exported from randoms$
final type Resource = Resource
Exported from resources$
final val Resources: Resources.type
Exported from resources
final type Resources = Resources
Exported from resources$
final val Safepoint: Safepoint.type
Exported from core
final type Safepoint = [E <: Effect[_[_]]] =>> Safepoint[E]
Exported from core$
final val Timer: Timer.type
Exported from timers
final type Timer = Timer
Exported from timers$
final val TimerTask: TimerTask.type
Exported from timers
final type TimerTask = TimerTask
Exported from timers$
final val Timers: Timers.type
Exported from timers
final type Timers = Timers
Exported from timers$
val Tries: Tries
Exported from tries
final type Tries = Tries
Exported from tries$
def collect[T, S](v: List[T > S]): List[T] > S
Exported from core
def zip[T1, T2, T3, T4, S](v1: T1 > S, v2: T2 > S, v3: T3 > S, v4: T4 > S): (T1, T2, T3, T4) > S
Exported from core
def zip[T1, T2, T3, S](v1: T1 > S, v2: T2 > S, v3: T3 > S): (T1, T2, T3) > S
Exported from core
def zip[T1, T2, S](v1: T1 > S, v2: T2 > S): (T1, T2) > S
Exported from core
Generated with