Scala

Implementation of programming language Scala

The reference implementation of Scala programming language.

Examples:

Hello, World!:

Example for versions Scala 2.7.7-final, Scala 2.8.0-final 
object Main {
    def main(args: Array[String]) {
        println("Hello, World!")
    }
}

Factorial:

Example for versions Scala 2.7.7-final

This example uses recursive factorial definition. 

object Factorial {
    def factorial(n: Int): Long = 
        if (n == 0) 1 
               else n * factorial(n - 1)
    def main(args: Array[String]) {
        for {i <- List.range(0, 17)} 
            yield { println(i + "! = " + factorial(i)) }
    }
}

Factorial:

Example for versions Scala 2.7.7-final

This example uses iterative factorial definition. 

object Factorial {
    def main(args: Array[String]) {
        var f = BigInt(1)
        format("0! = %s\n", f)
        for {i <- 1 to 16} {
             f *= i;
             format("%s! = %s\n", i, f)
        }
    }
}

Fibonacci numbers:

Example for versions Scala 2.7.7-final

This example uses recursive definition of Fibonacci numbers. 

object Fibonacci {
    def fibonacci(n: Int): Int = 
        if (n < 3) 1 
              else fibonacci(n - 1) + fibonacci(n - 2)
    def main(args: Array[String]) {
        for {i <- List.range(1, 17)} 
            yield { print(fibonacci(i) + ", ") }
        println("...")
    }
}

Fibonacci numbers:

Example for versions Scala 2.7.7-final, Simply Scala

This example shows the usage of lazy evaluations and infinite lists in Scala. Infinite list of Fibonacci numbers is defined using functions .zip and .tail in the same way as in Haskell example. 

lazy val fib: Stream[Int] = Stream.cons(1, Stream.cons(1, fib.zip(fib.tail).map(p => p._1 + p._2)))
fib.take(16).print

Quadratic equation:

Example for versions Scala 2.7.7-final, Scala 2.8.0-final

This example expands the interactive one with variables input. 

import java.io.{BufferedReader, InputStreamReader}
 
object Main {
    def main(args: Array[String]) {
        var stdin = new BufferedReader(new InputStreamReader(System.in));
        var A = augmentString(stdin.readLine()).toInt;
        var B = augmentString(stdin.readLine()).toInt;
        var C = augmentString(stdin.readLine()).toInt;
        solve(A,B,C);
    }
    def output(real: Double, imag: Double): String = 
        if (imag == 0) ""+real
                  else "("+real+","+imag+")"
 
    def solve(A: Int, B: Int, C: Int)
    {   if (A == 0) print("Not a quadratic equation.")
        else
        {   def D = B*B - 4*A*C;
            if (D == 0) print("x = "+output(-B/2.0/A, 0));
            else if (D > 0) 
                      print("x1 = "+output((-B+Math.sqrt(D))/2.0/A, 0)+"\nx2 = "+output((-B-Math.sqrt(D))/2.0/A, 0));
                 else print("x1 = "+output(-B/2/A, Math.sqrt(-D)/2.0/A)+"\nx2 = "+output(-B/2/A, -Math.sqrt(-D)/2.0/A));
        }
    }
}

CamelCase:

Example for versions Scala 2.8.0-final

This example uses regular expressions twice. First one, words, describes the words in the text; each match of it is replaced with itself, converted to lower case and capitalized. Second one, separators, describes the spaces between words; all matches of it are replaced with empty string, i.e., just removed from the string. 

import java.io.{BufferedReader, InputStreamReader}
import scala.util.matching.Regex
 
object Main {
    def main(args: Array[String]) {
        var stdin = new BufferedReader(new InputStreamReader(System.in));
        var text = stdin.readLine();
        val words = """([a-zA-Z]+)""".r
        text = words.replaceAllIn(text, m => m.matched.toLowerCase.capitalize)
        val separators = """([^a-zA-Z]+)""".r
        text = separators.replaceAllIn(text, "");
        println(text);
    }
}