Object Console.Console

object Console extends AnsiColor

Implements functionality for printing Scala values on the terminal. For reading values use StdIn. Also defines constants for marking up text on ANSI terminals.

Console Output

Use the print methods to output text.

scala> Console.printf(
  "Today the outside temperature is a balmy %.1f°C. %<.1f°C beats the previous record of %.1f°C.\n",
  -137.0,
  -135.05)
Today the outside temperature is a balmy -137.0°C. -137.0°C beats the previous record of -135.1°C.

ANSI escape codes

Use the ANSI escape codes for colorizing console output either to STDOUT or STDERR.

import Console.{GREEN, RED, RESET, YELLOW_B, UNDERLINED}

object PrimeTest {

  def isPrime(): Unit = {

    val candidate = io.StdIn.readInt().ensuring(_ > 1)

    val prime = (2 to candidate - 1).forall(candidate % _ != 0)

    if (prime)
      Console.println(s"${RESET}${GREEN}yes${RESET}")
    else
      Console.err.println(s"${RESET}${YELLOW_B}${RED}${UNDERLINED}NO!${RESET}")
  }

  def main(args: Array[String]): Unit = isPrime()

}

IO redefinition

Use IO redefinition to temporarily swap in a different set of input and/or output streams. In this example the stream based method above is wrapped into a function.

import java.io.{ByteArrayOutputStream, StringReader}

object FunctionalPrimeTest {

  def isPrime(candidate: Int): Boolean = {

    val input = new StringReader(s"$candidate\n")
    val outCapture = new ByteArrayOutputStream
    val errCapture = new ByteArrayOutputStream

    Console.withIn(input) {
      Console.withOut(outCapture) {
        Console.withErr(errCapture) {
          PrimeTest.isPrime()
        }
      }
    }

    if (outCapture.toByteArray.nonEmpty) // "yes"
      true
    else if (errCapture.toByteArray.nonEmpty) // "NO!"
      false
    else throw new IllegalArgumentException(candidate.toString)
  }

  def main(args: Array[String]): Unit = {
    val primes = (2 to 50) filter (isPrime)
    println(s"First primes: $primes")
  }

}

Console Output

These methods provide output via the console.

Source

def flush(): Unit

Flushes the output stream. This function is required when partial output (i.e. output not terminated by a newline character) has to be made visible on the terminal.

Source

def print(obj: Any): Unit

Prints an object to out using its toString method.

Source

def printf(text: String, args: Any*): Unit

Prints its arguments as a formatted string to the default output, based on a string pattern (in a fashion similar to printf in C).

The interpretation of the formatting patterns is described in java.util.Formatter.

Source

def println(): Unit

Prints a newline character on the default output.

Source

def println(x: Any): Unit

Prints out an object to the default output, followed by a newline character.

IO Defaults

These values provide direct access to the standard IO channels

Source

def err: PrintStream

The default error, can be overridden by withErr

Source

def in: BufferedReader

The default input, can be overridden by withIn

Source

def out: PrintStream

The default output, can be overridden by withOut

IO Redefinition

These methods allow substituting alternative streams for the duration of a body of code. Threadsafe by virtue of scala.util.DynamicVariable.

Source

def withErr[T](err: PrintStream)(thunk: => T): T

Set the default error stream for the duration of execution of one thunk.

withErr(Console.out) { err.println("This goes to default _out_") }

Source

def withErr[T](err: OutputStream)(thunk: => T): T

Sets the default error stream for the duration of execution of one thunk.

Source

def withIn[T](reader: Reader)(thunk: => T): T

Sets the default input stream for the duration of execution of one thunk.

val someFile:Reader = openFile("file.txt")
withIn(someFile) {
  // Reads a line from file.txt instead of default input
  println(readLine)
}

Source

def withIn[T](in: InputStream)(thunk: => T): T

Sets the default input stream for the duration of execution of one thunk.

Source

def withOut[T](out: PrintStream)(thunk: => T): T

Sets the default output stream for the duration of execution of one thunk.

withOut(Console.err) { println("This goes to default _error_") }

Source

def withOut[T](out: OutputStream)(thunk: => T): T

Sets the default output stream for the duration of execution of one thunk.

color-magenta

Source

final val MAGENTA: "\u001b[35m"

Foreground color for ANSI magenta

Source

final val MAGENTA_B: "\u001b[45m"

Background color for ANSI magenta

color-blue

Source

final val BLUE: "\u001b[34m"

Foreground color for ANSI blue

Source

final val BLUE_B: "\u001b[44m"

Background color for ANSI blue

color-red

Source

final val RED: "\u001b[31m"

Foreground color for ANSI red

Source

final val RED_B: "\u001b[41m"

Background color for ANSI red

color-cyan

Source

final val CYAN: "\u001b[36m"

Foreground color for ANSI cyan

Source

final val CYAN_B: "\u001b[46m"

Background color for ANSI cyan

style-control

Source

final val BLINK: "\u001b[5m"

ANSI blink

Source

final val BOLD: "\u001b[1m"

ANSI bold

Source

final val INVISIBLE: "\u001b[8m"

ANSI invisible

Source

final val RESET: "\u001b[0m"

Reset ANSI styles

Source

final val REVERSED: "\u001b[7m"

ANSI reversed

Source

final val UNDERLINED: "\u001b[4m"

ANSI underlines

color-yellow

Source

final val YELLOW: "\u001b[33m"

Foreground color for ANSI yellow

Source

final val YELLOW_B: "\u001b[43m"

Background color for ANSI yellow

color-white

Source

final val WHITE: "\u001b[37m"

Foreground color for ANSI white

Source

final val WHITE_B: "\u001b[47m"

Background color for ANSI white

color-black

Source

final val BLACK: "\u001b[30m"

Foreground color for ANSI black

Source

final val BLACK_B: "\u001b[40m"

Background color for ANSI black

color-green

Source

final val GREEN: "\u001b[32m"

Foreground color for ANSI green

Source

final val GREEN_B: "\u001b[42m"

Background color for ANSI green