Pollak D. Beginning Scala

Подождите немного. Документ загружается.

CHAPTER 1 ■ ABOUT SCALA AND HOW TO INSTALL IT

Test that you can access the JDK. Click the Start button and select Run…; in the dialog,

type cmd and click the OK button. A DOS window should appear with a prompt that looks

like the following:

C:\Documents and Settings\dpp>

At this prompt, type java -version and press Enter. You should see something like the

following:

java version "1.6.0_11"

Java(TM) SE Runtime Environment (build 1.6.0_11-b03)

Java HotSpot(TM) Client VM (build 11.0-b16, mixed mode, sharing)

Next, test to see that the Java compiler is installed. Type javac -version. You should see

something like the following:

javac 1.6.0_11

Next, let’s install Scala. Download the Scala lzPack installer from http://scala-tools.org/

downloads. This download is typically the first on the page. Save this file to the Desktop or

some other place that you can find it. Double-click on the

scala-2.7.3.final-installer.jar

file to start the install process. Once complete, you need to create the

SCALA_HOME environ-

ment variable and add Scala to your

PATH variable. Follow the same process that you used

for creating

JAVA_HOME, but name the variable SCALA_HOME and set the PATH to the place Scala

was installed. Next, update the

PATH variable to include %SCALA_HOME%\bin;.

Open a new command prompt and type scala. You should see the following:

Welcome to Scala version 2.7.3.final (Java HotSpot(TM) Client VM, Java 1.6.0_11).

Type in expressions to have them evaluated.

Type :help for more information.

Congratulations, you’ve installed Scala.

19897ch01.fm Page 7 Wednesday, April 1, 2009 5:10 PM

CHAPTER 1

■ ABOUT SCALA AND HOW TO INSTALL IT

Installing on Mac OS X and Linux

Make sure you’ve got the Java JDK 1.5 or 1.6 installed. By default, the JDK is installed on Mac

OS X 10.4 and greater. Download the Scala lzPack installer from

http://scala-tools.org/

downloads. Open a terminal window and change directories to the location where you

downloaded the Scala installer. Type the following:

sudo java -jar scala-2.7.3.final-installer.jar

Now select /usr/local/share as the place to install Scala. Once Scala is installed, run the

following commands:

cd /usr/local/share

sudo ln -s scala-2.7.3-final scala

cd /usr/local/bin

sudo ln -s ../share/scala/bin/scala scala

sudo ln -s ../share/scala/bin/fsc fsc

sudo ln -s ../share/scala/bin/scalac scalac

sudo ln -s ../share/scala/bin/scaladoc scaladoc

Change to your home directory and type scala. You should see the following:

Welcome to Scala version 2.7.3.final (Java HotSpot(TM) 64-Bit Server VM, Java

1.6.0_07).

Type in expressions to have them evaluated.

Type :help for more information.

scala>

Congratulations, you’ve installed Scala on your machine.

The Scala Community

The Scala community is a wide-ranging, rich, and vibrant group of people. It’s a warm and

welcoming place for newbies, but it also offers academically rigorous debate and lots of

ideas from the cutting edge of computer science made practical.

19897ch01.fm Page 8 Wednesday, April 1, 2009 5:10 PM

CHAPTER 1 ■ ABOUT SCALA AND HOW TO INSTALL IT

There are lots of cool people from lots of different backgrounds in the Scala community.

• You’ll find academics like Martin and his team. They actively participate in the

community, answering questions from newbies and from seasoned folks about

Scala basics, design choices, and more.

• There’s a cohort of extremely skilled and experienced functional programming

gurus, including David MacIver. They help drive Scala forward.

• James Iry is another highly skilled functional programming guru who has a magic

touch when it comes to explaining complex Scala concepts to just about anyone.

• Jon Pretty and Jamie Webb of Sygneca provide consulting services and a ton of

backbone for the Scala list and Scala community.

• You may hear from Jorge Ortiz who, like James, is great at explaining complex Scala

topics to folks at all skill levels.

The list of Scala mailing lists managed by EPFL (Martin’s group) can be found at

http://www.scala-lang.org/node/199.

The main Scala list is available at

scala@listes.epfl.ch, or you can access it on the Web

via Nabble at

http://www.nabble.com/Scala-f14147.html. This list is for discussing Scala,

asking questions, and making observations. It’s a great place for intermediate and advanced

Scala developers to exchange ideas and information.

The Scala User list is oriented toward newbies, and it’s a great place for folks to learn

about Scala by seeing the kind of questions that other newbies have about the language.

The e-mail for the list is

scala-user@listes.epfl.ch, and it’s available on Nabble via a web

interface at

http://www.nabble.com/Scala---User-f30217.html.

The Scala Debate list is a place for seasoned Scala folks to discuss the language,

make suggestions, and conspire to move Scala forward. You can post to the list via

e-mail at

scala-debate@listes.epfl.ch or via Nabble at http://www.nabble.com/Scala---

Debate-f30218.html

. Note that this list is a hard-core, no-holds-barred discussion of

Scala that sees some minor flame wars occasionally break out among the mathematically

inclined. If you venture into this forum, keep in mind that it does, from time to time,

devolve into discussion that is not kind and gentle and that often the discussion is

indecipherable for those of us who do not have a PhD in mathematics. If this is the kind

of discussion that is interesting to you, please check out Lambda the Ultimate at

19897ch01.fm Page 9 Wednesday, April 1, 2009 5:10 PM

CHAPTER 1

■ ABOUT SCALA AND HOW TO INSTALL IT

http://lambda-the-ultimate.org. LtU provides a forum for a broad spectrum of program-

ming language theory (PLT) discussions.

Lift is the leading web framework for Scala. The Lift community is hosted at Google.

You can learn more at

http://groups.google.com/group/liftweb/. While I’m the lead devel-

oper for Lift, we’re not going to focus much on web development in this book, but if you’re

a web developer, I’d love it if you’d join the Lift community.

Those are the main mailing lists in the Scala community. As you explore with Scala,

please join the online discussion and share your questions and thoughts.

Summary

You’ve learned a little about what attracted me to Scala, a little about where Scala comes

from, and you’ve installed Scala. You’ve learned about, and hopefully joined, the Scala

community. Now it’s time to explore Scala and see whether it resonates with you the same

way it resonates with me. Turn the page and write your first Scala program.

6. Paul Snively, the technical editor of this book, is an editor on LtU. It’s a pleasure and an honor to have

him participate in this project. If you dive deep into PLT, I hope you find Paul to be a compass and a

beacon as I do.

19897ch01.fm Page 10 Wednesday, April 1, 2009 5:10 PM

■ ■ ■

CHAPTER 2

Scala Syntax, Scripts, and

Your First Scala Programs

We’re going to get our hands dirty with Scala code in this chapter. We’ll write some Scala

code, starting with the ubiquitous “Hello World,” and moving on to more complex

Scala programs. This will give your eyes and brain an idea of what Scala code looks like.

Next, we’re going to take a long and boring tour of Scala’s syntax. Finally, we’re going to

see some options for running (and compiling) Scala programs.

Scala at the Command Line and Scala Scripts

Scala offers different ways to run programs:

• You can run them interactively at a REPL (read-eval-print loop) command line.

• You can run single-file Scala scripts.

• You can compile your Scala programs into class files that can be combined into JAR

files, just as in Java.

Scala’s flexibility allows you to choose the environment that’s best for you.

Interactive Scala

When I’m exploring a new construct or library, I want instant feedback. I want to type a

couple of lines of code and see what happens. Scala’s REPL gives me the immediacy and

interactivity that I need when I’m exploring.

19897ch02.fm Page 11 Wednesday, April 1, 2009 5:34 PM

CHAPTER 2

■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS

To start Scala’s REPL, open a command prompt or terminal and type scala. You should

see the following:

>scala

Welcome to Scala version 2.7.3.final (Java HotSpot(TM) Client VM, Java 1.6.0_11)

Type in expressions to have them evaluated.

Type :help for more information.

scala>

You can start typing things and see how they’re evaluated in Scala, for example:

scala> 1 + 1

res0: Int = 2

scala> res0 * 8

res1: Int = 16

scala> val x = "Hello World"

x: java.lang.String = Hello World

scala> var xl = x.length

xl: Int = 11

19897ch02.fm Page 12 Wednesday, April 1, 2009 5:34 PM

CHAPTER 2 ■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS

You can even access Java libraries:

scala> import java.util._

import java.util._

scala> val d = new Date

d: java.util.Date = Wed Jan 14 22:03:31 PST 2009

Most of the examples in this book are done at the Scala REPL.

Scala Scripts

If your program grows beyond the few lines in the REPL, you can start building Scala

scripts. Scala scripts are single files of Scala code. They do not have an explicit

main method.

In fact, when you run your script, Scala wraps the entire file into the

main method of a

class, compiles the code, and calls the generated

main method. All you have to do is put

valid Scala code in a file. To invoke the script, type

> scala MyFile.scala

You can access the command-line arguments in your script with the argv variable,

which is an

Array[String].

Compiling Scala Programs

You can compile Scala programs just as you compile Java programs, and the results are

JVM class files that can be packaged into JAR files. The Scala compiler requires that source

files contain one or more class, trait, or object definitions. To compile Scala source files

into class files, type the following:

> scalac File1.scala File2.scala

19897ch02.fm Page 13 Wednesday, April 1, 2009 5:34 PM

CHAPTER 2

■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS

However, startup time for the compiler is non-trivial. You can also compile using the

fast Scala compiler,

fsc:

> fsc File1.scala File2.scala

fsc

is a separate compiler process that continues to run, waiting for new compilation jobs,

even after the compilation process is finished. This results in much faster compilation

times, but if you’re on a machine with limited RAM, you might not want to keep the

compilation process alive.

If you are working on medium-sized to large projects, you probably use some sort of

build tool such as Ant or Maven. There are Scala plug-ins for both Ant and Maven, so you

can integrate Scala code into existing Java projects with very little effort and no require-

ment of using new build tools.

Your First Scala Programs

In this section, we’re going to write a couple of basic Scala programs. These programs will

give you a sense of Scala’s flavor and get you acquainted with running Scala programs.

Hello World

Yep, it’s the ubiquitous “Hello World” program. In Scala, it’s short, simple, and to the

point. Open up your favorite text editor: Emacs, vi, TextMate, whatever. Create a new file

called

HelloWorld.scala and place the following line in it:

println("Hello World!")

Save the file. Open a terminal window or command prompt and change into the directory

where the file is and type scala HelloWorld.scala.

You should see

Hello World!

1. See http://www.scala-lang.org/node/91 for an up-to-date list of IDE plug-ins and other tools for creating

Scala programs. You can join the Scala tools mailing list at http://www.scala-lang.org/node/199.

19897ch02.fm Page 14 Wednesday, April 1, 2009 5:34 PM

CHAPTER 2 ■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS

In Scala, you can write simple programs that look and feel like scripts that you would

write in Ruby or Python. In this case, you’re calling the

println method with the string

constant

Hello World!. It’s a thin layer on top of System.out.println(). Because println is

used so frequently, it’s part of Scala’s

Predef, the predefined stuff that’s automatically part

of every program. This is like the

java.lang package that is automatically imported in every

Java program.

Printing Some Numbers

Let’s write a program that will print the numbers from 1 to 10 in the Print1.scala file:

for {i <- 1 to 10}

println(i)

You can run the code by typing scala Print1.scala in the terminal. The program assigns

the numbers 1 to 10 to the variable

i and then executes println(i), which prints the

numbers 1 to 10.

for means much more in Scala than in Java. You can nest expressions

in a

for comprehension (the fancy Scala name for the for statement). In the Print2.scala

file, put

for {i <- 1 to 10

j <- 1 to 10}

println(i * j)

In this program, we’re iterating over 1 to 10 in an outer loop and assigning each number

i. In the inner loop, we’re also iterating from 1 to 10 and assigning each number to j.

The product of

i * j is printed, so you’ll see 100 lines output. There are many more uses

of the

for comprehension that we’ll cover later in the book.

Adding Things Up

The next program will read all the lines from the input and sum each line that contains a

valid integer. This program introduces you to a substantial number of Scala’s concepts,

including passing functions as parameters, Scala’s type system, immutable data structures,

and more. It’s a bit of a dive into the deep end, so let’s go. Create a file called

Sum.scala

containing the code in Listing 2-1.

19897ch02.fm Page 15 Wednesday, April 1, 2009 5:34 PM

CHAPTER 2

■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS

Listing 2-1. Sum.scala

import scala.io._

def toInt(in: String): Option[Int] =

try {

Some(Integer.parseInt(in.trim))

} catch {

case e: NumberFormatException => None

}

def sum(in: Seq[String]) = {

val ints = in.flatMap(s => toInt(s))

ints.foldLeft(0)((a, b) => a + b)

}

println("Enter some numbers and press ctrl-D (Unix/Mac) ctrl-C (Windows)")

val input = Source.fromInputStream(System.in)

val lines = input.getLines.collect

println("Sum "+sum(lines))

Let’s go through this file in detail.

Importing Stuff

The import scala.io._ code imports all the classes from the scala.io package. This is the

same as Java’s

import scala.io.*;. Scala uses the _ rather than the * as a wildcard. Coming

from Javaland, it takes a little getting used to, but it’ll soon make sense.

Parsing a String to an Int

Next, we define the toInt method, which takes a single parameter called in. That parameter

has the type

String:

def toInt(in: String): Option[Int] =

In Scala, method definitions begin with the def keyword. The method name follows, along

with the method’s parameter list. In this case, the

toInt method takes one parameter: in,

whose type declaration follows it rather than precedes it. In some cases, the Scala compiler

can figure out or infer the type of a variable or the return type of a method. You need to

declare the parameter types for a Scala method, but we may omit the return type if the

19897ch02.fm Page 16 Wednesday, April 1, 2009 5:34 PM