root/cps.runtime/MapOpsAsyncShift

MapOpsAsyncShift

class MapOpsAsyncShift[K, V, CC <: ([KX, VX] =>> MapOps[KX, VX, CC, CC[KX, VX]] & CI[(KX, VX)]), CI <: ([X] =>> Iterable[X] & IterableOps[X, CI, CI[X]]), CKV <: CC[K, V] & PartialFunction[K, V]]() extends IterableOpsAsyncShift[(K, V), CI, CKV] with PartialFunctionAsyncShiftBase[K, V, CKV] with AsyncShift[CKV]
Source
MapAsyncShift.scala
class IterableOpsAsyncShift[(K, V), CI, CKV]
class IterableAsyncShift[(K, V), CKV]
trait AsyncShift[CKV]
class Object
trait Matchable
class Any

Value members

Concrete methods

def flatMap[F[_], K2, V2](c: CKV, m: CpsMonad[F])(f: (K, V) => F[IterableOnce[(K2, V2)]]): F[CC[K2, V2]]
def foreachEntry[F[_], U](c: CKV, m: CpsMonad[F])(f: (K, V) => F[U]): F[Unit]
def getOrElse[F[_], V1 >: V](c: CKV, m: CpsMonad[F])(key: K, default: () => F[V1]): F[V1]
def map[F[_], K2, V2](c: CKV, m: CpsMonad[F])(f: (K, V) => F[(K2, V2)]): F[CC[K2, V2]]

Inherited methods

def _cpsWithFilterSubst(ca: CKV, predicate: (K, V) => Boolean): WithFilterSubstAsyncShift[(K, V), CI, CKV]
def andThen[F[_], A](f: PartialFunction[K, V], m: CpsMonad[F])(g: V => F[A]): PartialFunctionCallChainSubst[F, K, A]
def applyOrElse[F[_], A1 <: K, B1 >: V](f: PartialFunction[K, V], m: CpsMonad[F])(x1: A1, default: A1 => F[B1]): F[B1]
def collect[F[_], B](c: CKV, monad: CpsMonad[F])(pf: PartialFunction[(K, V), F[B]]): F[CI[B]]
def collectFirst[F[_], B](c: CKV, monad: CpsMonad[F])(pf: PartialFunction[(K, V), F[B]]): F[Option[B]]
def compose[F[_], A](f: PartialFunction[K, V], m: CpsMonad[F])(g: A => F[K]): PartialFunctionCallChainSubst[F, A, V]
def corresponds[F[_], B](c: CKV, monad: CpsMonad[F])(that: IterableOnce[B])(p: ((K, V), B) => F[Boolean]): F[Boolean]
def count[F[_]](c: CKV, monad: CpsMonad[F])(p: (K, V) => F[Boolean]): F[Int]
def dropWhile[F[_]](c: CKV, monad: CpsMonad[F])(p: (K, V) => F[Boolean]): F[CI[(K, V)]]
def exists[F[_]](c: CKV, monad: CpsMonad[F])(p: (K, V) => F[Boolean]): F[Boolean]
def filter[F[_]](c: CKV, monad: CpsMonad[F])(p: (K, V) => F[Boolean]): F[CI[(K, V)]]
def filterNot[F[_]](c: CKV, monad: CpsMonad[F])(p: (K, V) => F[Boolean]): F[CI[(K, V)]]
def find[F[_]](c: CKV, monad: CpsMonad[F])(p: (K, V) => F[Boolean]): F[Option[(K, V)]]
def flatMap[F[_], B](c: CKV, monad: CpsMonad[F])(f: (K, V) => F[IterableOnce[B]]): F[CI[B]]
def flatten[F[_], B](c: CKV, monad: CpsMonad[F])(implicit asIterable: (K, V) => F[IterableOnce[B]]): F[CI[B]]
def fold[F[_], A1 >: (K, V)](c: CKV, monad: CpsMonad[F])(z: A1)(op: (A1, A1) => F[A1]): F[A1]
def foldLeft[F[_], B](c: CKV, monad: CpsMonad[F])(z: B)(op: (B, (K, V)) => F[B]): F[B]
def foldRight[F[_], B](c: CKV, monad: CpsMonad[F])(z: B)(op: ((K, V), B) => F[B]): F[B]
def forall[F[_]](c: CKV, monad: CpsMonad[F])(p: (K, V) => F[Boolean]): F[Boolean]
def foreach[F[_], U](c: CKV, monad: CpsMonad[F])(f: (K, V) => F[U]): F[Unit]
def groupBy[F[_], K](c: CKV, monad: CpsMonad[F])(f: (K, V) => F[K]): F[Map[K, CI[(K, V)]]]
def groupMap[F[_], K, B](c: CKV, monad: CpsMonad[F])(key: (K, V) => F[K])(f: (K, V) => F[B]): F[Map[K, CI[B]]]
def groupMapReduce[F[_], K, B](c: CKV, monad: CpsMonad[F])(key: (K, V) => F[K])(f: (K, V) => F[B])(reduce: (B, B) => F[B]): F[Map[K, B]]
def map[F[_], B](c: CKV, monad: CpsMonad[F])(f: (K, V) => F[B]): F[CI[B]]
def maxBy[F[_], B](c: CKV, monad: CpsTryMonad[F])(f: (K, V) => F[B])(implicit cmp: Ordering[B]): F[(K, V)]
def maxByOpOption[F[_], B](c: CKV, monad: CpsMonad[F])(f: (K, V) => F[B])(cmp: (B, B) => Int): F[Option[(K, V)]]
def maxByOption[F[_], B](c: CKV, monad: CpsMonad[F])(f: (K, V) => F[B])(implicit cmp: Ordering[B]): F[Option[(K, V)]]
def minBy[F[_], B](c: CKV, monad: CpsTryMonad[F])(f: (K, V) => F[B])(implicit cmp: Ordering[B]): F[(K, V)]
def minByOption[F[_], B](c: CKV, monad: CpsMonad[F])(f: (K, V) => F[B])(implicit cmp: Ordering[B]): F[Option[(K, V)]]
def partition[F[_]](c: CKV, monad: CpsMonad[F])(p: (K, V) => F[Boolean]): F[(CI[(K, V)], CI[(K, V)])]
def partitionMap[F[_], A1, A2](c: CKV, monad: CpsMonad[F])(f: (K, V) => F[Either[A1, A2]]): F[(CI[A1], CI[A2])]
def reduce[F[_], B >: (K, V)](c: CKV, monad: CpsTryMonad[F])(op: (B, B) => F[B]): F[B]
def reduceLeft[F[_], B >: (K, V)](c: CKV, monad: CpsTryMonad[F])(op: (B, (K, V)) => F[B]): F[B]
def reduceLeftOption[F[_], B >: (K, V)](c: CKV, monad: CpsTryMonad[F])(op: (B, (K, V)) => F[B]): F[Option[B]]
def reduceOption[F[_], B >: (K, V)](c: CKV, monad: CpsTryMonad[F])(op: (B, B) => F[B]): F[Option[B]]
def reduceRight[F[_], B >: (K, V)](c: CKV, monad: CpsTryMonad[F])(op: ((K, V), B) => F[B]): F[B]
def reduceRightOption[F[_], B >: (K, V)](c: CKV, monad: CpsTryMonad[F])(op: ((K, V), B) => F[B]): F[Option[B]]
def scanLeft[F[_], B](c: CKV, monad: CpsMonad[F])(z: B)(op: (B, (K, V)) => F[B]): F[CI[B]]
def scanRight[F[_], B](c: CKV, monad: CpsMonad[F])(z: B)(op: ((K, V), B) => F[B]): F[CI[B]]
def shiftedFold[F[_], S, B, R](c: CKV, monad: CpsMonad[F])(prolog: S, action: (K, V) => F[B], acc: (S, (K, V), B) => S, epilog: S => R): F[R]

sequentially do action. each action is started after prev. is finished

sequentially do action. each action is started after prev. is finished

Inherited from
IterableAsyncShift
Source
IterableAsyncShift.scala
def shiftedStateFold[F[_], S, R](c: CKV, monad: CpsMonad[F])(prolog: S, acc: (S, (K, V)) => F[S], epilog: S => R): F[R]
def shiftedWhile[F[_], S, R](c: CKV, monad: CpsMonad[F])(prolog: S, condition: (K, V) => F[Boolean], acc: (S, Boolean, (K, V)) => S, epilog: S => R): F[R]
def span[F[_]](c: CKV, monad: CpsMonad[F])(p: (K, V) => F[Boolean]): F[(CI[(K, V)], CI[(K, V)])]
def takeWhile[F[_]](c: CKV, monad: CpsMonad[F])(p: (K, V) => F[Boolean]): F[CI[(K, V)]]
def tapEach[F[_], U](c: CKV, monad: CpsMonad[F])(f: (K, V) => F[U]): F[CI[(K, V)]]
def withFilter[F[_]](c: CKV, m: CpsMonad[F])(p: (K, V) => F[Boolean]): DelayedWithFilter[F, (K, V), CI, CKV]