effects

Type Members

trait Dup[H[_[_]]] extends AnyRef

Duplicate a handle in the parent region.
case class FinalizerHandle[R[_]](finalizer: RefCountedFinalizer) extends Product with Serializable

A handle to a finalizer that allows you to duplicate it to a parent region using "dup".
sealed trait IO[A] extends AnyRef
class IORef[A] extends NewType[STRef[RealWorld, A]]

A mutable reference in the IO monad.
abstract class MonadControlIO[M[_]] extends NewType[MonadIO[M]]

A class of IO-based monads supporting an extra operation liftControlIO, enabling conrol operations on IO to be lifted into the monad.
abstract class MonadIO[M[_]] extends NewType[Monad[M]]

Classifies IO-like monads, enabling IO actions to be lifted into the monad.
sealed trait RealWorld extends AnyRef
case class RefCountedFinalizer(finalizer: IO[Unit], refcount: IORef[Int]) extends Product with Serializable

A finalizer paired with its reference count which defines how many times it has been registered in some region.
case class RegionT[S, P[_], A](value: Kleisli[P, IORef[List[RefCountedFinalizer]], A]) extends NewType[Kleisli[P, IORef[List[RefCountedFinalizer]], A]] with Product with Serializable

A monad transformer in which scarce resources can be opened.
type RunInBase[M[_], Base[_]] = Forall[[B](M[B]) ⇒ Base[M[B]]]

Definition Classes
package
sealed trait ST[S, A] extends AnyRef

Purely functional mutable state threads.
class STArray[S, A] extends AnyRef

Mutable array in state thread S containing values of type A.
class STRef[S, A] extends AnyRef

Mutable variable in state thread S containing a value of type A.

Value Members

object Dup extends AnyRef
object IO extends AnyRef
object MonadIO extends AnyRef
object RegionT extends Serializable
object ST extends AnyRef
def accumArray[F[_], A, B](size: Int, f: (A, B) ⇒ A, z: A, ivs: F[(Int, B)])(implicit arg0: Foldable[F], arg1: Manifest[A]): ImmutableArray[A]

Accumulates an integer-associated list into an immutable array.
Accumulates an integer-associated list into an immutable array.

Definition Classes
package
def controlIO[M[_], A](f: (RunInBase[M, IO]) ⇒ IO[M[A]])(implicit m: MonadControlIO[M]): M[A]

Definition Classes
package
def dup[H[_[_]], PP[_], CS, PS](h: H[[α]RegionT[CS, [β]RegionT[PS, PP, β], α]])(implicit arg0: Dup[H], arg1: MonadIO[PP]): RegionT[CS, [α]RegionT[PS, PP, α], H[[β]RegionT[PS, PP, β]]]

Duplicates a handle to its parent region.
Duplicates a handle to its parent region.

Definition Classes
package
def fixST[S, A](k: (⇒ A) ⇒ ST[S, A]): ST[S, A]

Allows the result of a state transformer computation to be used lazily inside the computation.
Allows the result of a state transformer computation to be used lazily inside the computation.

Definition Classes
package
def getChar: IO[Char]

Definition Classes
package
def idLiftControl[M[_], A](f: (RunInBase[M, M]) ⇒ M[A])(implicit arg0: Monad[M]): M[A]

Definition Classes
package
implicit def ioMonoid[A](implicit arg0: Monoid[A]): Monoid[IO[A]]

Definition Classes
package
implicit def ioToST[A](io: IO[A]): ST[RealWorld, A]

Definition Classes
package
def newArr[S, A](size: Int, z: A)(implicit arg0: Manifest[A]): ST[S, STArray[S, A]]

Allocates a fresh mutable array.
Allocates a fresh mutable array.

Definition Classes
package
def newIORef[A](a: ⇒ A): IO[IORef[A]]

Definition Classes
package
def newVar[S, A](a: A): ST[S, STRef[S, A]]

Allocates a fresh mutable reference.
Allocates a fresh mutable reference.

Definition Classes
package
def onExit[S, P[_]](finalizer: IO[Unit])(implicit arg0: MonadIO[P]): RegionT[S, P, FinalizerHandle[[α]RegionT[S, P, α]]]

Register a finalizer in the current region.
Register a finalizer in the current region. When the region terminates, all registered finalizers will be performed if they're not duplicated to a parent region.

Definition Classes
package
def putChar(c: Char): IO[Unit]

Definition Classes
package
def putOut[A](a: A): IO[Unit]

Definition Classes
package
def putStr(s: String): IO[Unit]

Definition Classes
package
def putStrLn(s: String): IO[Unit]

Definition Classes
package
def readLn: IO[String]

Definition Classes
package
def returnST[S, A](a: ⇒ A): ST[S, A]

Put a value in a state thread
Put a value in a state thread

Definition Classes
package
def runRegionT[P[_], A](r: Forall[[S]RegionT[S, P, A]])(implicit arg0: MonadControlIO[P]): P[A]

Execute a region inside its parent region P.
Execute a region inside its parent region P. All resources which have been opened in the given region and which haven't been duplicated using "dup", will be closed on exit from this function whether by normal termination or by raising an exception. Also all resources which have been duplicated to this region from a child region are closed on exit if they haven't been duplicated themselves. The Forall quantifier prevents resources from being returned by this function.

Definition Classes
package
def runST[A](f: Forall[[S]ST[S, A]]): A

Run a state thread
Run a state thread

Definition Classes
package
implicit def stApplicative[S]: Applicative[[A]ST[S, A]]

Definition Classes
package
implicit def stMonad[S]: Monad[[A]ST[S, A]]

Definition Classes
package
implicit def stMonoid[S, A](implicit arg0: Monoid[A]): Monoid[ST[S, A]]

Definition Classes
package
implicit def stRefEqual[S, A]: Equal[STRef[S, A]]

Equality for STRefs is reference equality
Equality for STRefs is reference equality

Definition Classes
package
implicit def stToIO[A](st: ST[RealWorld, A]): IO[A]

Definition Classes
package
def throwIO[A](e: Throwable): IO[A]

Throw the given error in the IO monad.
Throw the given error in the IO monad.

Definition Classes
package

package effects

Type Members

trait Dup[H[_[_]]] extends AnyRef

case class FinalizerHandle[R[_]](finalizer: RefCountedFinalizer) extends Product with Serializable

sealed trait IO[A] extends AnyRef

class IORef[A] extends NewType[STRef[RealWorld, A]]

abstract class MonadControlIO[M[_]] extends NewType[MonadIO[M]]

abstract class MonadIO[M[_]] extends NewType[Monad[M]]

sealed trait RealWorld extends AnyRef

case class RefCountedFinalizer(finalizer: IO[Unit], refcount: IORef[Int]) extends Product with Serializable

case class RegionT[S, P[_], A](value: Kleisli[P, IORef[List[RefCountedFinalizer]], A]) extends NewType[Kleisli[P, IORef[List[RefCountedFinalizer]], A]] with Product with Serializable

type RunInBase[M[_], Base[_]] = Forall[[B](M[B]) ⇒ Base[M[B]]]

sealed trait ST[S, A] extends AnyRef

class STArray[S, A] extends AnyRef

class STRef[S, A] extends AnyRef

Value Members

object Dup extends AnyRef

object IO extends AnyRef

object MonadIO extends AnyRef

object RegionT extends Serializable

object ST extends AnyRef

def accumArray[F[_], A, B](size: Int, f: (A, B) ⇒ A, z: A, ivs: F[(Int, B)])(implicit arg0: Foldable[F], arg1: Manifest[A]): ImmutableArray[A]

def controlIO[M[_], A](f: (RunInBase[M, IO]) ⇒ IO[M[A]])(implicit m: MonadControlIO[M]): M[A]

def dup[H[_[_]], PP[_], CS, PS](h: H[[α]RegionT[CS, [β]RegionT[PS, PP, β], α]])(implicit arg0: Dup[H], arg1: MonadIO[PP]): RegionT[CS, [α]RegionT[PS, PP, α], H[[β]RegionT[PS, PP, β]]]

def fixST[S, A](k: (⇒ A) ⇒ ST[S, A]): ST[S, A]

def getChar: IO[Char]

def idLiftControl[M[_], A](f: (RunInBase[M, M]) ⇒ M[A])(implicit arg0: Monad[M]): M[A]

implicit def ioMonoid[A](implicit arg0: Monoid[A]): Monoid[IO[A]]

implicit def ioToST[A](io: IO[A]): ST[RealWorld, A]

def newArr[S, A](size: Int, z: A)(implicit arg0: Manifest[A]): ST[S, STArray[S, A]]

def newIORef[A](a: ⇒ A): IO[IORef[A]]

def newVar[S, A](a: A): ST[S, STRef[S, A]]

def onExit[S, P[_]](finalizer: IO[Unit])(implicit arg0: MonadIO[P]): RegionT[S, P, FinalizerHandle[[α]RegionT[S, P, α]]]

def putChar(c: Char): IO[Unit]

def putOut[A](a: A): IO[Unit]

def putStr(s: String): IO[Unit]

def putStrLn(s: String): IO[Unit]

def readLn: IO[String]

def returnST[S, A](a: ⇒ A): ST[S, A]

def runRegionT[P[_], A](r: Forall[[S]RegionT[S, P, A]])(implicit arg0: MonadControlIO[P]): P[A]

def runST[A](f: Forall[[S]ST[S, A]]): A

implicit def stApplicative[S]: Applicative[[A]ST[S, A]]

implicit def stMonad[S]: Monad[[A]ST[S, A]]

implicit def stMonoid[S, A](implicit arg0: Monoid[A]): Monoid[ST[S, A]]

implicit def stRefEqual[S, A]: Equal[STRef[S, A]]

implicit def stToIO[A](st: ST[RealWorld, A]): IO[A]

def throwIO[A](e: Throwable): IO[A]

Inherited from AnyRef

Inherited from Any