First Steps to Scala

06 Jun 17

rafanunes

19 Sep 14

yu he

statically typed, object-oriented
The main Scala compiler, scalac, generates Java class files that can be run on the JVM. However, another Scala compiler exists that generates binaries that can be run on the .NET CLR
It has the conciseness of a dynamic language like Ruby or Python, but it is statically typed, like Java.
The type Int names the class Int in the package scala. Values of this class are implemented just like Java's int values. In fact, Scala treats int as an alias for scala.Int
More generally, all of Java's primitive types are defined as aliases for classes in the scala package.
The type of the result here is scala.Unit, which is Scala's analogue to void in Java. The main difference between Scala's Unit and Java's void is that Scala lets you write down a value of type Unit, namely (), whereas in Java there is no value of type void
() is the one and only value of type Unit in Scala
Scala differentiates between vals, variables that are assigned once and never change, and vars, variables that may change over their lifetime
because Scala strings are also Java strings. (In fact every Java class is available in Scala.)
This example also points out an important and very useful feature of Scala: type inference. Notice that you never said the word java.lang.String or even String in the val definition
In contrast to Java, where you specify a variable&8217;s type before its name, in Scala you specify a variable's type after its name, separated by a colon.
scala> val msg2: java.lang.String = "Hello again, world!" msg2: java.lang.String = Hello, world!
def max(x: Int, y: Int): Int = if (x < y) y else x
A type annotation must follow every method parameter, preceded by a colon in the Scala way, because the Scala compiler (and interpreter, but from now on we'll just say compiler) does not infer method parameter types.
the method is recursive¹, for example, you must explicitly specify the method result type. In the case of max however, you may leave the result type specifier off and the compiler will infer it.
Since max's body consists of just one statement, you need not place it inside curly braces, but you can if you want. So you could also have written:
If you want to put more than one statement in the body of a method, you must enclose them inside curly braces.
def greet() = println("Hello, world!")
but you access an element by specifying an index in parentheses rather than square brackets. So the first element in a Scala array named steps is steps(0), not steps[0]
// Say hello to the first argument println("Hello, " + args(0) + "!")
The expression "Hello, " + "world!" will result in the string "Hello, world!".
#!/bin/sh exec scala $0 $@ !# // Say hello to the first argument println("Hello, " + args(0) + "!")
var i = 0 while (i < args.length) { println(args(i)) i += 1 }
var i = 0 while (i < args.length) { if (i != 0) print(" ") print(args(i)) i += 1 } println()
Note that in Scala, as in Java, you must put the boolean expression for a while or an if in parentheses.
Scala does use semi-colons to separate statements as in Java, except that in Scala the semi-colons are very often optional, giving some welcome relief to your right pinky finger
For example, another (far more concise) way to print each command line argument is:
```
args.foreach(arg => println(arg))
```
In this case, you're passing in an anonymous function (one with no name), which takes one parameter named arg
If you'd prefer to be more explicit
the Scala interpreter infers type of arg to be String
If an anonymous function consists of one method application that takes a single argument, you need not explicitly name and specify the argument
args.foreach(println)
To summarize, the syntax for an anonymous function is a list of named parameters, in parentheses, a right arrow, and then the body of the function.
Figure 1. The syntax of a Scala anonymous function.
In an effort to guide you in a functional direction, only a functional relative of the imperative for (called a for comprehension) is available in Scala.
for (arg <- args) println(arg)
In addition to being functional, Scala is object-oriented.
In the previous example, you parameterize the String instance with the initial value "Hello, world!". You can think of parameterization as meaning configuring an instance at the point in your program that you create that instance
The main difference is that instead of the angle brackets used for this purpose in Java, in Scala you use square brackets
val greetStrings = new Array[String](3) greetStrings(0) = "Hello" greetStrings(1) = ", " greetStrings(2) = "world! " for (i <- 0 to 2) print(greetStrings(i))
val greetStrings: Array[String] = new Array[String](3)
When you define a variable with val, the variable can't be reassigned, but the object to which it refers could potentially still be mutated. So in this case, you couldn't reassign greetStrings to a different array; greetStrings will always point to the same Array[String] instance with which it was initialized. But you can change the elements of that Array[String] over time,
for (i <- 0 to 2) print(greetStrings(i))
The first line of code in this for comprehension illustrates another general rule of Scala: if a method takes only one parameter, you can call it without a dot or parentheses. to is actually a method that takes one Int argument
The code 0 to 2 is transformed into the method call 0.to(2).
(This to method actually returns not an Array but a Scala iterator that returns the values 0, 1, and 2.)
Arrays are simply instances of classes like any other class in Scala. When you apply parentheses to a variable and pass in some arguments, Scala will transform that into an invocation of a method named apply. So greetStrings(i) gets transformed into greetStrings.apply(i).
Similarly, when an assignment is made to a variable that is followed by some arguments in parentheses, the compiler will transform that into an invocation of an update method that takes two parameters. For example,
```
greetStrings(0) = "Hello" 
```
greetStrings.update(0, "Hello")
However, it is significant to note that in Scala this uniformity does not usually come with a performance cost as it often has in other languages that have aimed to be pure in their object orientation.
the conceptual simplicity of a pure object-oriented language with the runtime performance characteristics of language that has special cases for performance reasons.
Another benefit of the functional style in a statically typed language is that everything that goes into and out of a method is checked by a type checker, so logic errors are more likely to manifest themselves as type errors.
If you create a String with the value "Hello, ", it will keep that value for the rest of its lifetime. If you later call concat("world!") on that String, it will not add "world!" to itself. Instead, it will create and return a brand new String with the value Hello, world!".
a Scala Array is a mutable sequence of objects that all share the same type
Thus, Arrays are mutable objects. An immutable, and therefore more functional-oriented, sequence of objects that share the same type is Scala's List. As with Arrays, a List[String] contains only Strings. Scala's List, scala.List, differs from Java's java.util.List type in that Scala Lists are always immutable (whereas Java Lists can be mutable). But more importantly, Scala's List is designed to enable a functional style of programming.
val oneTwoThree = List(1, 2, 3)
(You don't need to say new List because “List” is defined as a factory method on the scala.List singleton object. More on Scala's singleton object construct in Step 11.)
List has a method named ::: that concatenates a passed List and the List on which ::: was invoked.
Perhaps the most common operator you'll use with Lists is ::, which is pronounced “cons.” Cons prepends a new element to the beginning of an existing List, and returns the resulting List
val twoThree = List(2, 3) val oneTwoThree = 1 :: twoThree println(oneTwoThree)
Given that a shorthand way to specify an empty List is Nil
val oneTwoThree = 1 :: 2 :: 3 :: Nil
thrill.count(s => s.length == 4) Counts the number of String elements in thrill that have length 4 (returns 2)
thrill.drop(2) Returns the thrill List without its first 2 elements (returns List("until")) thrill.dropRight(2) Returns the thrill List without its rightmost 2 elements (returns List("Will"))
thrill.filter(s => s.length == 4) Returns a List of all elements, in order, of the thrill List that have length 4 (returns List("Will", "fill"))
thrill.forall(s => s.endsWith("l")) Indicates whether all elements in the thrill List end with the letter "l" (returns true) thrill.foreach(s => print(s)) Executes the print statement on each of the Strings in the thrill List (prints "Willfilluntil")
thrill.map(s => s + "y") Returns a List resulting from adding a "y" to each String element in the thrill List (returns List("Willy", "filly", "untily")) thrill.remove(s => s.length == 4) Returns a List of all elements, in order, of the thrill List except those that have length 4 (returns List("until"))
thrill.tail Returns the thrill List minus its first element (returns List("fill", "until"))
Besides List, one other ordered collection of object elements that's very useful in Scala is the tuple. Like Lists, tuples are immutable, but unlike Lists, tuples can contain different types of elements. Thus whereas a list might be a List[Int] or a List[String], a tuple could contain both an Int and a String at the same time.
And it is simple: to instantiate a new tuple that holds some objects, just place the objects in parentheses, separated by commas. Once you have a tuple instantiated, you can access its elements individually with a dot, underscore, and the one-based index of the element.
val pair = (99, "Luftballons") println(pair._1) println(pair._2)
Scala infers the type of the tuple to be Tuple2[Int, String], and gives that type to the variable pair as well
When it comes to Sets and Maps, Scala also provides mutable and immutable alternatives, but in a different way. For Sets and Maps, Scala models mutability in the class hierarchy.
For example, the Scala API contains a base trait for Sets, where a trait is similar to a Java interface. (You'll find out more about traits in Step 12.) Scala then provides two subtraits, one for mutable Sets, and another for immutable Sets.
import scala.collection.mutable.HashSet val jetSet = new HashSet[String] jetSet += "Lear" jetSet += ("Boeing", "Airbus") println(jetSet.contains("Cessna"))
the third line initializes jetSet with a new HashSet that will contain only Strings. Note that just as with Lists and Arrays, when you create a Set, you need to parameterize it with a type (in this case, String), since every object in a Set must share the same type
Had you wanted to, instead of writing jetSet += "Lear", you could have written jetSet.+=("Lear"). Because the += method takes a variable number of arguments, you can pass one or more objects at a time to it.
Another useful collection class in Scala is Maps. As with Sets, Scala provides mutable and immutable versions of Map, using a class hierarchy.
// In treasure.scala import scala.collection.mutable.HashMap val treasureMap = new HashMap[Int, String] treasureMap += 1 -> "Go to island." treasureMap += 2 -> "Find big X on ground." treasureMap += 3 -> "Dig." println(treasureMap(2))
As illustrated in previous examples, the Scala compiler transforms an binary operation expression like 1 -> "Go to island." into 1.->("Go to island.").
Because maps are such a useful programming construct, Scala provides a factory method for Maps that is similar in spirit to the factory method shown in Step 9 that allows you to create Lists without using the new keyword.
// In numerals.scala val romanNumeral = Map(1 -> "I", 2 -> "II", 3 -> "III", 4 -> "IV", 5 -> "V") println(romanNumeral(4))
In numerals.scala you take advantage of the fact that the the immutable Map trait is automatically imported into any Scala source file.
class SimpleGreeter { val greeting = "Hello, world!" def greet() = println(greeting) } val g = new SimpleGreeter g.greet()
One difference between Java and Scala involves constructors. In Java, classes have constructors, which can take parameters, whereas in Scala, classes can take parameters directly. The Scala notation is more concise—class parameters can be used directly in the body of the class; there’s no need to define fields and write assignments that copy constructor parameters into fields
class FancyGreeter(greeting: String) { def greet() = println(greeting) } val g = new FancyGreeter("Salutations, world") g.greet
Instead of defining a constructor that takes a String, as you would do in Java, in greetFancily.scala you placed the greeting parameter of that constructor in parentheses placed directly after the name of the class itself
When defined in this way, greeting essentially becomes a value (not a variable—it can't be reassigned) field that's available anywhere inside the body.
Fortunately, you can. Any code sitting inside the curly braces surrounding the class definition, but which isn't part of a method definition, is compiled into the body of the primary constructor. In essence, the primary constructor will first initialize what is essentially a final field for each parameter in parentheses following the class name. It will then execute any top-level code contained in the class's body.
class CarefulGreeter(greeting: String) { if (greeting == null) { throw new NullPointerException("greeting was null") } def greet() = println(greeting) } new CarefulGreeter(null)
The Scala compiler places this if statement into the body of the primary constructor, just after code that initializes what is essentially a final field named greeting with the passed value. Thus, if you pass in null to the primary constructor, as you do in the last line of the greetCarefully.scala script, the primary constructor will first initialize the greeting field to null. Then, it will execute the if statement that checks whether the greeting field is equal to null, and since it is, it will throw a NullPointerException
In Java, you sometimes give classes multiple constructors with overloaded parameter lists. You can do that in Scala as well, however you must pick one of them to be the primary constructor, and place those constructor parameters directly after the class name
You then place any additional auxiliary constructors in the body of the class as methods named this.
class RepeatGreeter(greeting: String, count: Int) { def this(greeting: String) = this(greeting, 1) def greet() = { for (i <- 1 to count) println(greeting) } } val g1 = new RepeatGreeter("Hello, world", 3) g1.greet() val g2 = new RepeatGreeter("Hi there!") g2.greet()
The body of this constructor consists of a single statement: an invocation of the primary constructor parameterized with the passed greeting and a count of 1
Another area in which Scala departs from Java is that you can't have any static fields or methods in a Scala class. Instead, Scala allows you to create singleton objects using the keyword object. A singleton object cannot, and need not, be instantiated with new. It is essentially automatically instantiated the first time it is used, and as the “singleton” in its name implies, there is ever only one instance. A singleton object can share the same name with a class, and when it does, the singleton is called the class's companion object. The Scala compiler transforms the fields and methods of a singleton object to static fields and methods of the resulting binary Java class.
class WorldlyGreeter(greeting: String) { def greet() = { val worldlyGreeting = WorldlyGreeter.worldify(greeting) println(worldlyGreeting) } } // The WorldlyGreeter companion object object WorldlyGreeter { def worldify(s: String) = s + ", world!" }
In fact, when the Scala compiler generates bytecodes for this file, it will create a Java class named WorldlyGreeter that has an instance method named greet (defined in the WorldlyGreeter class in the Scala source) and a static method named worldify (defined in the WorldlyGreeter companion object in Scala source).
you invoke the singleton object's worldify method using a syntax similar to the way you invoke static methods in Java: the singleton object name, a dot, and the method name:
val worldlyGreeting = WorldlyGreeter.worldify(greeting)

99 more annotations...

11 Sep 14

robusta

It has the conciseness of a dynamic language like Ruby or Python, but it is statically typed, like Java. Another reason is that Scala comes with an Erlang-like Actors library that greatly simplifies concurrent programming, but runs on the JVM

11 Aug 14

Alex D

23 Feb 14

Jose Asuncion

scala

object-oriented programming language that blends imperative and functional programming styles.
The main Scala compiler, scalac, generates Java class files that can be run on the JVM.
Scala language can be used alongside the Java language
it allows you to increase your productivity compared to Java while leveraging JVM execution speed,
has the conciseness of a dynamic language like Ruby or Python, but it is statically typed, like Java.
Actors library that greatly simplifies concurrent programming,
vals, variables that are assigned once and never change,
type inference.
Method definitions start with def instead of val or var.
you must always explicitly specify a method's parameter types regardless of whether you explicitly specify its result type.
you'll likely often find yourself programming in a more functional style. I
unctions are first class constructs,
Scala achieves a conceptual simplicity by treating everything, from arrays to expressions, as objects with methods.
ons prepends a new element to the beginning of an existing List,

12 more annotations...

20 Feb 14

Lei Tang

In contrast to Java, where you specify a variable&8217;s type before its name, in Scala you specify a variable's type after its name, separated by a colon.
What you can't do with msg, given that it is a val not a var,
scala> def max(x: Int, y: Int): Int = if (x < y) y else x
def max2(x: Int, y: Int) = if (x < y) y else x
def max3(x: Int, y: Int) = { if (x < y) y else x }
as in Java, you must put the boolean expression for a while or an if in parentheses. (In other words, you can't say in Scala things like if i < 10 as you can in a language such as Ruby.
If an anonymous function consists of one method application that takes a single argument, you need not explicitly name and specify the argument.
for (arg <- args) println(arg)
When you define a variable with val, the variable can't be reassigned, but the object to which it refers could potentially still be mutated
val oneTwoThreeFour = oneTwo ::: threeFour
the most common operator you'll use with Lists is ::, which is pronounced “cons.” Cons prepends a new element to the beginning of an existing List, and returns the resulting List.
val oneTwoThree = 1 :: 2 :: 3 :: Nil
Like Lists, tuples are immutable, but unlike Lists, tuples can contain different types of elements
println(pair._1) println(pair._2)
in Scala, classes can take parameters directly.
Another area in which Scala departs from Java is that you can't have any static fields or methods in a Scala class. Instead, Scala allows you to create singleton objects using the keyword object.
this singleton object is not a companion object. It is instead called a stand-alone. object
Scala includes a construct called a trait, which is similar in spirit to Java's interface

16 more annotations...

01 Feb 14

Jimmy Royer

Great lenghty but quick tutorial for Scala.

scala tutorial

04 Oct 13

Raza Rehman

Scala

14 Aug 13

Rahul Sharma

he first line of code in this for comprehension illustrates another general rule of Scala: if a method takes only one parameter, you can call it without a dot or parentheses. to is actually a method that takes one Int argument. The code 0 to 2 is transformed into the method call 0.to(2). (This to method actually returns not an Array but a Scala iterator that returns the values 0, 1, and 2.) Scala doesn't technically have operator overloading, because it doesn't actually have operators in the traditional sense. Characters such as +, -, *, and /, have no special meaning in Scala, but they can be used in method names. Thus, the expression 1 + 2, which was the first Scala code you typed into the interpreter in Step 1, is essential in meaning to 1.+(2), where + is the name of a method defined in class scala.Int.
Similarly, when an assignment is made to a variable that is followed by some arguments in parentheses, the compiler will transform that into an invocation of an update method that takes two parameters. For example,
```
greetStrings(0) = "Hello"  
```
will essentially be transformed into
```
greetStrings.update(0, "Hello")
```

04 Aug 13

Murray Smithers

Folders Languages Other Scala

09 Apr 13

Erwin Karbasi

scala_first_step scala_tutorial scala_for_starter scala_tutorial_*

04 Nov 12

K Miura

a bit outdated, scala 2.5

scala tutorial +++++

03 Oct 12

Arthanareeswaran S

scala tutorial

27 May 12

rhm2ktmi

scala tutorial programming java introduction

27 Mar 12

tiitkriiska

development scala

14 Mar 12

carlos puentes

Scala is a statically typed, object-oriented programming language that blends imperative and functional programming styles. Scala is designed to integrate easily with applications that run on modern virtual machines, primarily the Java virtual machine (JVM). The main Scala compiler, scalac, generates Java class files that can be run on the JVM. However, another Scala compiler exists that generates binaries that can be run on the .NET CLR, as Scala is designed to integrate with both the Java and .NET worlds. In the Java world, the Scala language can be used alongside the Java language—either as an alternative to Java—to build applications that run on the JVM.

scala tutorial programming java introduction language languages functional

17 Feb 12

cchaulk

scala

31 Jan 12

adrian kalaveshi

development languages language functional java programming scala

06 Dec 11

stamp85

07 Nov 11

ellecer

scala tutorial java

10 Oct 11

Hector Miuler Malpica Gallegos

scala tutorial

04 Oct 11

scala

16 Sep 11

Geir Amdal

scala

04 Sep 11

akundu

book scalabook bookscala

26 Aug 11

Lucien Pereira

scala

25 Aug 11

Jhonghee park

scala> println("Hello, world!") Hello, world! unnamed2: Unit = ()
The type of the result here is scala.Unit, which is Scala's analogue to void in Java. The main difference between Scala's Unit and Java's void is that Scala lets you write down a value of type Unit, namely (), whereas in Java there is no value of type void. (In other words, just as 1, 2, and 3, are potential values of type int in both Scala and Java, () is the one and only value of type Unit in Scala. By contrast, there are no values of type void in Java.) Except for this, Unit and void are equivalent.
The recommended style guideline for such method invocations is that if the method may have side effects⁴, you should provide the parentheses even if the compiler doesn't require them. Thus in this case, since the greet method prints to the standard output, it has side effects and you should invoke it with parentheses to alert programmers looking at the code.

1 more annotation...

05 Aug 11

Yi Wang

scala tutorial step

29 Jul 11

José Devezas

scala programming development tutorials

25 Jul 11

metin ofo

scala tutorials reference

08 Jul 11

Dan Connolly

scala programming

04 Jul 11

david_r_whiting

[Seems to be a bit out of date, but is a good intro]

scala

Scott Linford

scala tutorial Functional

More generally, all of Java's primitive types are defined as aliases for classes in the scala package. For example, if you type boolean in a Scala program, the type you'll actually get is scala.Boolean. Or if you type float, you'll get scala.Float.
scala.Unit, which is Scala's analogue to void in Java
1, 2, and 3, are potential values of type int in both Scala and Java, () is the one and only value of type Unit in Scala. By contrast, there are no values of type void in Java.
Sometimes the Scala compiler will require you to specify the result type of a method. If the method is recursive¹, for example, you must explicitly specify the method result type.
indented two spaces, the recommended indentation style for Scala
```
// In greetFancily.scala  class FancyGreeter(greeting: String) {   def greet() = println(greeting) }  val g = new FancyGreeter("Salutations, world") g.greet 
```
Instead of defining a constructor that takes a String, as you would do in Java, in greetFancily.scala you placed the greeting parameter of that constructor in parentheses placed directly after the name of the class itself, before the open curly brace of the body of class FancyGreeter. When defined in this way, greeting essentially becomes a value (not a variable—it can't be reassigned) field that's available anywhere inside the body.
Any code sitting inside the curly braces surrounding the class definition, but which isn't part of a method definition, is compiled into the body of the primary constructor. In essence, the primary constructor will first initialize what is essentially a final field for each parameter in parentheses following the class name. It will then execute any top-level code contained in the class's body.
Thus, a singleton object is either a companion or a stand-alone object. The distinction is important because companion objects get a few special privileges, such as access to private members of the like-named class.
Note that one difference with Java is that to override a method in Scala, you must precede the method's def with override

7 more annotations...

01 Jul 11

scala

20 Jun 11

scala tutorial introduction

17 Jun 11

Abhijeet Sutar

scala tutorial language languages

31 May 11

Entro Adun

scala

23 May 11

rvs1257

scala

10 Mar 11

Soo Kim

scala

15 Jan 11

Armando Ramos

scala tutorial functional

03 Jan 11

nicolas 3

scala introduction tutorial

25 Dec 10

Dawiiid unknown

Tutorial konstrukci

scala tutorial

23 Dec 10

nikolavp

06 Dec 10

Filipe Chagas

tutorial scala

filipeochagas

tutorial scala

01 Dec 10

Andrew Tolopko

scala tutorial article programming

30 Nov 10

pt chia

statically typed, object-oriented programming language that blends imperative and functional programming styles.
integrate with both the Java and .NET worlds.
developed starting in 2003 by Martin Odersky's group at EPFL, Lausanne, Switzerland.
He co-designed the first version of Java generics and was the original author of the current javac compiler.
increase your productivity compared to Java
vast array of APIs available for the JVM.
In Italian, Scala means staircase
examples in this article were run with Scala version 2.5.0-RC1, so make sure you download a version at least as recent as 2.5.0-RC1.
add the full pathname of the bin directory to your PATH
other requirement you'll need to fulfill is an installation of Java 1.4 or above
vals, variables that are assigned once and never change, and vars, variables that may change over their lifetime.
If reassignment is what you want, you'll need to use a var, as in:
Method definitions start with def
write some methods.
always explicitly specify a method's parameter types

scala> def greet() = println("Hello, world!") greet: ()Unit

You can call it with or without parentheses:

scala> greet() Hello, world! unnamed7: Unit = ()  scala> greet Hello, world! unnamed8: Unit = ()

println("Hello, world, from a script!")

then run:

>scala hello.scala

// Say hello to the first argument println("Hello, " + args(0) + "!")

then run:

>scala helloarg.scala planet

can run a Scala script as a shell script
The initial #!/bin/sh must be the very first line in the file. Once you set its execute permission:
```
>chmod +x helloarg
```
var i = 0 while (i < args.length) { println(args(i)) i += 1 }
ou must put the boolean expression for a while or an if in parentheses
Scala gives you the conciseness of a scripting language such as Ruby or Python, but without requiring you to give up the static type checking of more verbose languages like Java or C++.
support for the functional programming style
args.foreach(arg => println(arg))

scala pa.scala Concise is nice

You should see:

Concise is nice

args.foreach((arg: String) => println(arg))
addition to being functional, Scala is object-oriented.
val s = new String("Hello, world!") println(s)
val greetStrings = new Array[String](3) greetStrings(0) = "Hello" greetStrings(1) = ", " greetStrings(2) = "world! " for (i <- 0 to 2) print(greetStrings(i))
val greetStrings: Array[String] = new Array[String](3)
index inside parentheses, not square
greetStrings(0) = "Hello" greetStrings(1) = ", " greetStrings(2) = "world! "
to is actually a method that takes one Int
variable can't be reassigned, but the object to which it refers could potentially still be mutated.
define a variable with val,
Arrays are simply instances of classe
a method named apply.
any type into an apply method call, n
, the compiler will transform that into an invocation of an update method that takes two parameters. For example,
you insight into why arrays are accessed with parentheses in Scala.
hat methods should not have side effects
method should be to compute the value or values that are returned by the method.
To apply this functional philosophy to the world of objects, you would make objects immutable.
Scala Array is a mutable sequence of objects that all share the same type.
val oneTwoThree = List(1, 2, 3)
most common operator you'll use with Lists is ::, which is pronounced “cons.”

val twoThree = List(2, 3) val oneTwoThree = 1 :: twoThree println(oneTwoThree)

And execute it with scala consit.scala, you should see:

List(1, 2, 3)

For example, if you type the following code into a file named consinit.scala:
```
val oneTwoThree = 1 :: 2 :: 3 :: Nil println(oneTwoThree)
```
n Scala is the tuple. Like Lists, tuples are immutable, but unlike Lists, tuples can contain different types of elements.
ordered collection of object e
Scala infers the type of the tuple to be Tuple2[Int, String], and gives that type to the variable pair as well. In the second line, you access the _1 field, which will pro
Scala aims to help you take advantage of both functional and imperative styles, its collections libraries make a point to differentiate between mutable and immutable collection classes.
the Scala API contains a base trait for Sets, where a trait is similar to a Java interface
Scala then provides two subtraits, one for mutable Sets, and another for immutable Sets.

To try out Scala Sets, type the following code into a file named jetset.scala:

import scala.collection.mutable.HashSet  val jetSet = new HashSet[String] jetSet += "Lear" jetSet += ("Boeing", "Airbus") println(jetSet.contains("Cessna"))

Scala provides mutable and immutable versions of Map, using a class hierarchy. As you can see in Figure 3, the class hierarchy for Maps looks a lot like the one for Sets. There's a base Map trait in package s
Another useful collection class in Scala is Maps.
Implementations of Map, such as the HashMaps shown in the class hierarchy in Figure 3, implement either the mutable or immutable trait.

val treasureMap = new HashMap[Int, String] treasureMap += 1 -> "Go to island." treasureMap += 2 -> "Find big X on ground." treasureMap += 3 -> "Dig." println(treasureMap(2))

On the first line of treasure.scala, you import the mutable form of HashMap

type the following code into a file called numerals.scala:

// In numerals.scala val romanNumeral = Map(1 -> "I", 2 -> "II", 3 -> "III", 4 -> "IV", 5 -> "V") println(romanNumeral(4))

The Scala notation is more concise—class parameters can be used directly in the body of the class; there’s no need to define fields and write assignments that copy constructor parameters into fields. This can yield substantial savings in boilerplate code; especially for small classes. To see this in action, type the following code into a file named greetFancily.scala:
construct called a trait, which is similar in spirit to Java's interface. One main difference between Java interfaces and Scala's traits are that whereas all methods in Java interfaces are by definition abstract, you can give methods real bodies with real code in Scala traits. Here's an example:
get more productivity while leveraging existing investments.
productivity compared to the Java langauge

63 more annotations...

17 Nov 10

Wong Iseng

Indecisive, everything seems to be interesting

scala learn

18 Oct 10

Diego _V

scala 7-languages

06 Oct 10

Travis Taylor

delicious scala tutorial programming java defib.it delicious_import

03 Oct 10

Takahiro Nishimura

scala

02 Oct 10

scala

17 Sep 10

learning scala tutorial 101 programming jvm functional oop java

30 Jul 10

Vijay Challa

First Steps to Scala

scala tutorial programming java

10 Jul 10

Esfand S

scala java tutorial companion

Another area in which Scala departs from Java is that you can't have any static fields or methods in a Scala class. Instead, Scala allows you to create singleton objects using the keyword object. A singleton object cannot, and need not, be instantiated with new. It is essentially automatically instantiated the first time it is used, and as the “singleton” in its name implies, there is ever only one instance. A singleton object can share the same name with a class, and when it does, the singleton is called the class's companion object. The Scala compiler transforms the fields and methods of a singleton object to static fields and methods of the resulting binary Java class.

06 Jul 10

borislv

Scala introduction

17 Jun 10

clementi1832

scala introduction tutorial programming software development language languages functional toread

13 May 10

Marcin Mincer

scala

10 May 10

José Carlos Souza

Scala

08 May 10

Gabriel Kastenbaum

scala tutorial

17 Feb 10

Carlos Ramirez Martinez-Eiroa

scala

03 Feb 10

Per L

scala tutorial programming

22 Jan 10

Danilo Barsotti

Tutorial que faz um getting started no scala, muito interessante e com um excelente conteudo.

scala

20 Jan 10

Robert Boyd

introduction development howto functional programming java language languages tutorial scala

02 Jan 10

beattakeshi

programming scala tutorial jvm

20 Dec 09

Kostas Maistrelis

scala tutorial

20 Nov 09

ariel_araza

scala

05 Nov 09

Mathias Weber

scala

01 Nov 09

Rajeev K

Scalazine
First Steps to Scala
by Bill Venners, Martin Odersky, and Lex Spoon

17 Oct 09

rdohmen

informatica scala programming tutorial programmeren java

07 Oct 09

scala JVM

01 Oct 09

tvaananen

IT scala tutorial

27 Sep 09

dagblakstad

scala tutorial programming

☢Yoshifumi YAMAGUCHI

scala tutorial

15 Sep 09

J B

programming Scala tutorial

14 Sep 09

Vitaliy Berdinskikh

10 Sep 09

Daniel Quirino Oliveira

15 Aug 09

fusion

scala

10 Aug 09

Erico Marineli

scala language

24 Jul 09

Helmut Sins

scala programming

16 Jul 09

Isaac Ruiz

First Steps to Scala

SCALA beginner

HJ Kim

Scala

21 Jun 09

df nord

tuple

scala tutorial

05 Jun 09

Gubbe Sue

scala tutorial delicious

24 Apr 09

Chris Maloney

scala to-read java language tutorial from-delicious

08 Apr 09

Tomasz Palacz

programowanie programming scala java

jamessweeney

programming

06 Apr 09

Douglas Muth

scala programming java reference documentation delicious

Francois Zaninotto

Scala is a statically typed, object-oriented programming language that blends imperative and functional programming styles. Scala is designed to integrate easily with applications that run on modern virtual machines, primarily the Java virtual machine (JV

scala tutorial java

05 Apr 09