effects

Value Members

1. object IO

2. object ST

3. 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.

4. def bufferFile(f: File): IO[BufferedReader]

5. def closeReader(r: Reader): IO[Unit]

6. def enumerateBy[A](action: IO[A]): EnumeratorM[IO, A]

   Repeatedly apply the given action, enumerating the results.

7. 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.

8. def getChar: IO[Char]

   Get the next character from standard input

9. def getFileLines(f: File): EnumeratorM[IO, String]

10. val getLines: EnumeratorM[IO, String]

    Enumerate the lines on standard input as Strings

11. def getReaderLines(r: ⇒ BufferedReader): EnumeratorM[IO, String]

    Enumerate the lines from a BufferedReader

12. def io[A](a: ⇒ A): IO[A]

    Perform the given side-effect in an IO action

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

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

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

    Allocates a fresh mutable array.

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

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

    Allocates a fresh mutable reference.

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

    Write a character to standard output

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

    Print the given object to standard output

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

    Write a String to standard output

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

    Write a String to standard output, followed by a newline

22. def rReadLn(r: BufferedReader): IO[Option[String]]

    Read a line from a buffered reader

23. def readLn: IO[String]

    Read the next line from standard input

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

    Put a value in a state thread

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

    Run a state thread

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

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

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

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

    Equality for STRefs is reference equality

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

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

    Throw the given error in the IO monad.

32. def wPutStr(w: PrintWriter, s: String): IO[Unit]

    Write a string to a PrintWriter

33. def wPutStrLn(w: PrintWriter, s: String): IO[Unit]

    Write a String to a PrintWriter, followed by a newline