Odersky M. Programming in Scala

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

Glossary 711

is Array and the type of the value that results is Array[String]. A

class that takes type parameters is called a type constructor. A type can

be said to have a class as well, as in: the class of type Array[String]

is Array.

closure A function object that captures free variables, and is said to be

“closed” over the variables visible at the time it is created.

companion class A class that shares the same name with a singleton object

deﬁned in the same source ﬁle. The class is the singleton object’s

companion class.

companion object A singleton object that shares the same name with a

class deﬁned in the same source ﬁle. Companion objects and classes

have access to each other’s private members. In addition, any implicit

conversions deﬁned in the companion object will be in scope anywhere

the class is used.

contravariant A contravariant annotation can be applied to a type param-

eter of a class or trait by putting a minus sign (-) before the type

parameter. The class or trait then subtypes contravariantly with—

in the opposite direction as—the type annotated parameter. For ex-

ample, Function1 is contravariant in its ﬁrst type parameter, and so

Function1[Any, Any] is a subtype of Function1[String, Any].

covariant A covariant annotation can be applied to a type parameter of a

class or trait by putting a plus sign (+) before the type parameter. The

class or trait then subtypes covariantly with—in the same direction

as—the type annotated parameter. For example, List is covariant in

its type parameter, so List[String] is a subtype of List[Any].

currying A way to write functions with multiple parameter lists. For in-

stance def f(x: Int)(y: Int) is a curried function with two param-

eter lists. A curried function is applied by passing several arguments

lists, as in: f(3)(4). However, it is also possible to write a partial

application of a curried function, such as f(3).

declare You can declare an abstract ﬁeld, method, or type, which gives an

entity a name but not an implementation. The key difference between

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Glossary 712

declarations and deﬁnitions is that deﬁnitions establish an implemen-

tation for the named entity, declarations do not.

deﬁne To deﬁne something in a Scala program is to give it a name and

an implementation. You can deﬁne classes, traits, singleton objects,

ﬁelds, methods, local functions, local variables, etc. Because deﬁni-

tions always involve some kind of implementation, abstract members

are declared not deﬁned.

direct subclass A class is a direct subclass of its direct superclass.

direct superclass The class from which a class or trait it is immediately de-

rived, the nearest class above it in its inheritance hierarchy. If a class

Parent is mentioned in a class Child’s optional extends clause, then

Parent is the direct superclass of Child. If a trait is mentioned in

Child’s extends clause, the trait’s direct superclass is the Child’s di-

rect superclass. If Child has no extends clause, then AnyRef is the

direct superclass of Child. If a class’s direct superclass takes type pa-

rameters, for example class Child extends Parent[String], the

direct superclass of Child is still Parent, not Parent[String]. On

the other hand, Parent[String] would be the direct supertype of

Child. See supertype for more discussion of the distinction between

class and type.

equality When used without qualiﬁcation, equality is the relation between

values expressed by ‘==’. See also reference equality.

existential type An existential type includes references to type variables

that are unknown. For example, Array[T] forSome { type T } is

an existential type. It is an array of T, where T is some completely

unknown type. All that is assumed about T is that it exists at all. This

assumption is weak, but it means at least that an Array[T] forSome

{ type T } is indeed an array and not a banana.

expression Any bit of Scala code that yields a result. You can also say that

an expression evaluates to a result or results in a value.

ﬁlter An if followed by a boolean expression in a for expression. In

for(i <- 1 to 10; if i % 2 == 0), the ﬁlter is “if i % 2 == 0”.

The value to the right of the if is the ﬁlter expression.

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Glossary 713

ﬁlter expression A ﬁlter expression is the boolean expression following an

if in a for expression. In for(i <- 1 to 10; if i % 2 == 0), the

ﬁlter expression is “i % 2 == 0”.

ﬁrst-class function Scala supports ﬁrst-class functions, which means you

can express functions in function literal syntax, i.e., (x: Int) => x + 1,

and that functions can be represented by objects, which are called func-

tion values.

for comprehension Another name for for expression.

free variable A free variable of an expression is a variable that’s used inside

the expression but not deﬁned inside the expression. For instance, in

the function literal expression (x: Int) => (x, y), both variables x

and y are used, but only y is a free variable, because it is not deﬁned

inside the expression.

function A function can be invoked with a list of arguments to produce a

result. A function has a parameter list, a body, and a result type.

Functions that are members of a class, trait, or singleton object are

called methods. Functions deﬁned inside other functions are called

local functions. Functions with the result type of Unit are called pro-

cedures. Anonymous functions in source code are called function lit-

erals. At run time, function literals are instantiated into objects called

function values.

function literal A function with no name in Scala source code, speciﬁed

with function literal syntax. For example, (x: Int, y: Int) => x + y.

function value A function object that can be invoked just like any other

function. A function value’s class extends one of the FunctionN traits

(e.g., Function0, Function1) from package scala, and is usually

expressed in source code via function literal syntax. A function value

is “invoked” when its apply method is called. A function value that

captures free variables is a closure.

functional style The functional style of programming emphasizes functions

and evaluation results and deemphasizes the order in which operations

occur. The style is characterized by passing function values into loop-

ing methods, immutable data, methods with no side effects. It is the

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Glossary 714

dominant paradigm of languages such as Haskell and Erlang, and con-

trasts with the imperative style.

generator A generator deﬁnes a named val and assigns to it a series of

values in a for expression. For example, in for(i <- 1 to 10), the

generator is “i <- 1 to 10”. The value to the right of the <- is the

generator expression.

generator expression A generator expression generates a series of values

in a for expression. For example, in for(i <- 1 to 10), the generator

expression is “1 to 10”.

generic class A class that takes type parameters. For example, because

scala.List takes a type parameter, scala.List is a generic class.

generic trait A trait that takes type parameters. For example, because trait

scala.collection.Set takes a type parameter, it is a generic trait.

helper function A function whose purpose is to provide a service to one or

more other functions nearby. Helper functions are often implemented

as local functions.

helper method A helper function that’s a member of a class. Helper meth-

ods are often private.

immutable An object is immutable if its value cannot be changed after it

is created in any way visible to clients. Objects may or may not be

immutable.

imperative style The imperative style of programming emphasizes careful

sequencing of operations so that their effects happen in the right order.

The style is characterized by iteration with loops, mutating data in

place, and methods with side effects. It is the dominant paradigm

of languages such as C, C++, C# and Java, and contrasts with the

functional style.

initialize When a variable is deﬁned in Scala source code, you must initial-

ize it with an object.

instance An instance, or class instance, is an object, a concept that exists

only at run time.

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Glossary 715

instantiate To instantiate a class is to make a new object from the class, an

action that happens only at run time.

invariant Invariant is used in two ways. It can mean a property that always

holds true when a data structure is well-formed. For example, it is an

invariant of a sorted binary tree that each node is ordered before its

right subnode, if it has a right subnode. Invariant is also sometimes

used as a synonym for nonvariant: “class Array is invariant in its type

parameter.”

invoke You can invoke a method, function, or closure on arguments, mean-

ing its body will be executed with the speciﬁed arguments.

JVM The JVM is the Java Virtual Machine, or runtime, that hosts a running

Scala program.

literal 1, "One", and (x: Int) => x + 1 are examples of literals. A literal

is a shorthand way to describe an object, where the shorthand exactly

mirrors the structure of the created object.

local function A local function is a def deﬁned inside a block. To contrast,

a def deﬁned as a member of a class, trait, or singleton object is called

a method.

local variable A local variable is a val or var deﬁned inside a block. Al-

though similar to local variables, parameters to functions are not re-

ferred to as local variables, but simply as parameters or “variables”

without the “local.”

member A member is any named element of the template of a class, trait,

or singleton object. A member may be accessed with the name of its

owner, a dot, and its simple name. For example, top-level ﬁelds and

methods deﬁned in a class are members of that class. A trait deﬁned

inside a class is a member of its enclosing class. A type deﬁned with

the type keyword in a class is a member of that class. A class is a

member of the package in which is it deﬁned. By contrast, a local

variable or local function is not a member of its surrounding block.

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Glossary 716

message Actors communicate with each other by sending each other mes-

sages. Sending a message does not interrupt what the receiver is do-

ing. The receiver can wait until it has ﬁnished its current activity and

its invariants have been reestablished.

meta-programming Meta-programming software is software whose input

is itself software. Compilers are meta-programs, as are tools like

scaladoc. Meta-programming software is required in order to do any-

thing with an annotation.

method A method is a function that is a member of some class, trait, or

singleton object.

mixin Mixin is what a trait is called when it is being used in a mixin com-

position. In other words, in “trait Hat,” Hat is just a trait, but in

“new Cat extends AnyRef with Hat,” Hat can be called a mixin.

When used as a verb, “mix in” is two words. For example, you can

mix traits into classes or other traits.

mixin composition The process of mixing traits into classes or other traits.

Mixin composition differs from traditional multiple inheritance in that

the type of the super reference is not known at the point the trait is

deﬁned, but rather is determined anew each time the trait is mixed into

a class or other trait.

modiﬁer A keyword that qualiﬁes a class, trait, ﬁeld, or method deﬁnition in

some way. For example, the private modiﬁer indicates that a class,

trait, ﬁeld, or method being deﬁned is private.

multiple deﬁnitions The same expression can be assigned in multiple deﬁ-

nitions if you use the syntax val v1, v2, v3 = exp.

nonvariant A type parameter of a class or trait is by default nonvariant.

The class or trait then does not subtype when that parameter changes.

For example, because class Array is nonvariant in its type parameter,

Array[String] is neither a subtype nor a supertype of Array[Any].

operation In Scala, every operation is a method call. Methods may be in-

voked in operator notation, such as b + 2, and when in that notation, +

is an operator.

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Glossary 717

parameter Functions may take zero to many parameters. Each parameter

has a name and a type. The distinction between parameters and ar-

guments is that arguments refer to the actual objects passed when a

function is invoked. Parameters are the variables that refer to those

passed arguments.

parameterless function A function that takes no parameters, which is de-

ﬁned without any empty parentheses. Invocations of parameterless

functions may not supply parentheses. This supports the uniform ac-

cess principle, which enables the def to be changed into a val without

requiring a change to client code.

parameterless method A parameterless method is a parameterless function

that is a member of a class, trait, or singleton object.

parametric ﬁeld A ﬁeld deﬁned as a class parameter.

partially applied function A function that’s used in an expression and that

misses some of its arguments. For instance, if function f has type

Int => Int => Int, then f and f(1) are partially applied functions.

path-dependent type A type like swiss.cow.Food. The swiss.cow part

is a path that forms a reference to an object. The meaning of the type is

sensitive to the path you use to access it. The types swiss.cow.Food

and fish.Food, for example, are different types.

pattern In a match expression alternative, a pattern follows each case key-

word and precedes either a pattern guard or the => symbol.

pattern guard In a match expression alternative, a pattern guard can follow

a pattern. For example, in “case x if x % 2 == 0 => x + 1”, the pattern

guard is “if x % 2 == 0”. A case with a pattern guard will only be

selected if the pattern matches and the pattern guard yields true.

predicate A predicate is a function with a Boolean result type.

primary constructor The main constructor of a class, which invokes a su-

perclass constructor, if necessary, initializes ﬁelds to passed values,

and executes any top-level code deﬁned between the curly braces of

the class. Fields are initialized only for value parameters not passed to

the superclass constructor, except for any that are not used in the body

of the class and can therefore by optimized away.

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Glossary 718

procedure A procedure is a function with result type of Unit, which is

therefore executed solely for its side effects.

reassignable A variable may or may not be reassignable. A var is re-

assignable while a val is not.

recursive A function is recursive if it calls itself. If the only place the func-

tion calls itself is the last expression of the function, then the function

is tail recursive.

reference A reference is the Java abstraction of a pointer, which uniquely

identiﬁes an object that resides on the JVM’s heap. Reference type

variables hold references to objects, because reference types (instances

of AnyRef) are implemented as Java objects that reside on the JVM’s

heap. Value type variables, by contrast, may sometimes hold a refer-

ence (to a boxed wrapper type) and sometimes not (when the object

is being represented as a primitive value). Speaking generally, a Scala

variable refers to an object. The term “refers” is more abstract than

“holds a reference.” If a variable of type scala.Int is currently rep-

resented as a primitive Java int value, then that variable still refers to

the Int object, but no reference is involved.

reference equality Reference equality means that two references identify

the very same Java object. Reference equality can be determined, for

reference types only, by calling eq in AnyRef. (In Java programs, ref-

erence equality can be determined using == on Java reference types.)

reference type A reference type is a subclass of AnyRef. Instances of refer-

ence types always reside on the JVM’s heap at run time.

referential transparency A property of functions that are independent of

temporal context and have no side effects. For a particular input, an

invocation of a referentially transparent function can be replaced by its

result without changing the program semantics.

refers A variable in a running Scala program always refers to some object.

Even if that variable is assigned to null, it conceptually refers to the

Null object. At runtime, an object may be implemented by a Java

object or a value of a primitive type, but Scala allows programmers to

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Glossary 719

think at a higher level of abstraction about their code as they imagine

it running. See also reference.

result An expression in a Scala program yields a result. The result of every

expression in Scala is an object.

result type A method’s result type is the type of the value that results from

calling the method. (In Java, this concept is called the return type.)

return A function in a Scala program returns a value. You can call this

value the result of the function. You can also say the function results

in the value. The result of every function in Scala is an object.

runtime The Java Virtual Machine, or JVM, that hosts a running Scala pro-

gram. Runtime encompasses both the virtual machine, as deﬁned by

the Java Virtual Machine Speciﬁcation, and the runtime libraries of the

Java API and the standard Scala API. The phrase at run time (with a

space between run and time) means when the program is running, and

contrasts with compile time.

runtime type The type of an object at run time. To contrast, a static type

is the type of an expression at compile time. Most runtime types are

simply bare classes with no type parameters. For example, the runtime

type of "Hi" is String, and the runtime type of (x: Int) => x + 1 is

Function1. Runtime types can be tested with isInstanceOf.

script A ﬁle containing top level deﬁnitions and statements, which can be

run directly with scala without explicitly compiling. A script must

end in an expression, not a deﬁnition.

selector The value being matched on in a match expression. For example,

in “s match { case _ => }”, the selector is s.

self type A self type of a trait is the assumed type of this, the receiver,

to be used within the trait. Any concrete class that mixes in the trait

must ensure that its type conforms to the trait’s self type. The most

common use of self types is for dividing a large class into several traits

as described in Chapter 27.

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Glossary 720

semi-structured data XML data is semi-structured. It is more structured

than a ﬂat binary ﬁle or text ﬁle, but it does not have the full structure

of a programming language’s data structures.

serialization You can serialize an object into a byte stream which can then

be saved to ﬁles or transmitted over the network. You can later deseri-

alize the byte stream, even on different computer, and obtain an object

that is the same as the original serialized object.

shadow A new declaration of a local variable shadows one of the same name

in an enclosing scope.

signature Signature is short for type signature.

singleton object An object deﬁned with the object keyword. Each sin-

gleton object has one and only one instance. A singleton object that

shares its name with a class, and is deﬁned in the same source ﬁle as

that class, is that class’s companion object. The class is its compan-

ion class. A singleton object that doesn’t have a companion class is a

standalone object.

standalone object A singleton object that has no companion class.

statement An expression, deﬁnition, or import, i.e., things that can go into

a template or a block in Scala source code.

static type See type.

subclass A class is a subclass of all of its superclasses and supertraits.

subtrait A trait is a subtrait of all of its supertraits.

subtype The Scala compiler will allow any of a type’s subtypes to be used

as a substitute wherever that type is required. For classes and traits

that take no type parameters, the subtype relationship mirrors the sub-

class relationship. For example, if class Cat is a subclass of abstract

class Animal, and neither takes type parameters, type Cat is a sub-

type of type Animal. Likewise, if trait Apple is a subtrait of trait

Fruit, and neither takes type parameters, type Apple is a subtype of

type Fruit. For classes and traits that take type parameters, however,

variance comes into play. For example, because abstract class List

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index