# Scala

To use this language, use the class "language-scala".

## Comments

    // Single line comment
    /* Mutli-line
    comment */

## Strings and characters

    'a'
    "foo bar baz"
    """Multi-line
    string"""

## Numbers

    0
    21
    0xFFFFFFFF
    -42L
    0.0
    1e30f
    3.14159f
    1.0e-100
    .1

## Symbols

    'x
    'identifier

## Full example

    // Contributed by John Williams
    package examples

    object lazyLib {

      /** Delay the evaluation of an expression until it is needed. */
      def delay[A](value: => A): Susp[A] = new SuspImpl[A](value)

      /** Get the value of a delayed expression. */
      implicit def force[A](s: Susp[A]): A = s()

      /**
       * Data type of suspended computations. (The name froms from ML.)
       */
      abstract class Susp[+A] extends Function0[A]

      /**
       * Implementation of suspended computations, separated from the
       * abstract class so that the type parameter can be invariant.
       */
      class SuspImpl[A](lazyValue: => A) extends Susp[A] {
        private var maybeValue: Option[A] = None

        override def apply() = maybeValue match {
          case None =>
            val value = lazyValue
            maybeValue = Some(value)
            value
    	  case Some(value) =>
            value
        }

        override def toString() = maybeValue match {
          case None => "Susp(?)"
          case Some(value) => "Susp(" + value + ")"
        }
      }
    }

    object lazyEvaluation {
      import lazyLib._

      def main(args: Array[String]) = {
        val s: Susp[Int] = delay { println("evaluating..."); 3 }

        println("s     = " + s)       // show that s is unevaluated
        println("s()   = " + s())     // evaluate s
        println("s     = " + s)       // show that the value is saved
        println("2 + s = " + (2 + s)) // implicit call to force()

        val sl = delay { Some(3) }
        val sl1: Susp[Some[Int]] = sl
        val sl2: Susp[Option[Int]] = sl1   // the type is covariant

        println("sl2   = " + sl2)
        println("sl2() = " + sl2())
        println("sl2   = " + sl2)
      }
    }

## Known failures

There are certain edge cases where Prism will fail. There are always such cases in every regex-based syntax highlighter. However, Prism dares to be open and honest about them. If a failure is listed here, it doesn’t mean it will never be fixed. This is more of a “known bugs” list, just with a certain type of bug.

### Nested block comments

    /* Nested block
    	/* comments
    	are */
    not supported */