From Wikipedia, the free encyclopedia

This article is about the programming language. For other uses, see Scala.

Scala
Paradigm	multi-paradigm: functional, object-oriented
Appeared in	2003
Designed by	Martin Odersky
Developer	Programming Methods Laboratory of EPFL
Latest release	2.6.0/ September 11, 2007
Typing discipline	static, strong
Major implementations	Scala
Influenced by	Smalltalk, Java, Haskell, Standard ML, Objective Caml
Website	www.scala-lang.org

Scala is a multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. The current implementation runs on the Java Virtual Machine and is compatible with existing Java programs.

Contents 1 Object-oriented features 2 Functional programming 3 Static typing 4 Extensibility 5 Platform independence 6 Hello World example 7 Unit and Other Testing 8 See also 9 External links

Scala is a pure object-oriented language in the sense that every value is an object. Types and behavior of objects are described by classes and traits. Class abstractions are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance.

Scala is also a functional language in the sense that every function is a value. Scala provides a lightweight syntax for defining anonymous functions, it supports higher-order functions, it allows functions to be nested, and supports currying. Scala's case classes and its built-in support for pattern matching model algebraic types used in many functional programming languages.

Furthermore, Scala's notion of pattern matching naturally extends to the processing of XML data with the help of regular expression patterns. In this context, sequence comprehensions are useful for formulating queries. These features make Scala ideal for developing applications like web services.

Scala is equipped with an expressive type system that enforces statically that abstractions are used in a safe and coherent manner. In particular, the type system supports:

• generic classes,
• variance annotations,
• upper and lower type bounds,
• classes and abstract types as object members,
• compound types,
• explicitly typed self references,
• views, and
• polymorphic methods.

The design of Scala acknowledges the fact that in practice, the development of domain-specific applications often requires domain-specific language extensions. Scala provides a unique combination of language mechanisms that make it easy to smoothly add new language constructs in form of libraries:

• any method may be used as an infix or postfix operator, and
• closures are constructed automatically depending on the expected type (target typing).

A joint use of both features facilitates the definition of new statements without extending the syntax and without using macro-like meta-programming facilities.

Scala is designed to interoperate well with popular programming environments like the Java 2 Runtime Environment (JRE) and the .NET CLR. In particular, the interaction with mainstream object-oriented languages like Java and C# is as smooth as possible.

In other words, Scala can effortlessly make use of all libraries available for Java/C#, addressing the common drawback of using advanced functional languages which is that the small community, much of it centered around academia, often does not get to implementing quality libraries for common real-world tasks such as relational database access, XML processing, regular expressions, and so on. Scala can accomplish those tasks in a manner very similarly to how one would in Java or C#.

Scala has the same compilation model (separate compilation, dynamic class loading) as Java and C#, and allows thousands of high-quality libraries to be accessed.

Here is the canonical Hello world program written in Scala:

object HelloWorld {
  def main(args: Array[String]) =
    Console.println("Hello, world!")
}

Notice how similar it is to the stand-alone Hello World application for Java. The notable difference is that we do not declare anything to be static or void; the object keyword gives us a singleton object, freeing us from having to invoke any such constructs.

One would then compile this from the command line roughly as follows, assuming it was saved in a filename called HelloWorld.scala:

> scalac HelloWorld.scala

One would then run it like so:

> scala -classpath . HelloWorld

This is analogous to how one compiles and runs a Java "hello world" program. Indeed, Scala's compilation and execution model is identical to that of Java, making it compatible with Java build tools such as Ant.

There are two current ways to test code in Scala:

• The scala-library itself provides SUnit, a xUnit like framework using Assertions.
• The Rehersal project provides a more extensive framework using Expectations and natural language for test names. It also has integration with Apache Ant.

• Boo - a language with similar objectives but targeting the Common Language Infrastructure
• Jacl - A Java implementation of Tcl including TclBlend for JNI
• JRuby - Pure Java reimplementation of Ruby
• Jython - A Java implementation of Python
• BeanShell - A lightweight interpreter of Java source codes
• Grails - a web application framework which uses the Groovy programming language
• Groovy is an object-oriented alternative on the Java Platform to the Java programming language.
• Curl 5.0 from Curl Inc. as a non-JVM non-CLR alternative
• Rebol programming language as a Java JVM alternative
• Seaside for Smalltalk with Gemstone as an alternative to Lift or Rails/Grails

• Scala website
• Scala Wiki
• Literate Programs - Scala
• The Scala Community
• Scala Presentation From The Googleplex [1] (video) - given by Martin Odersky, creator of the language; accompanying slides from the talk
• Rehersal (A testing framework for Scala)
• The Scala Search Engine
• Lift Web Framework
• Podcast Interview with Martin Odersky on Scala