You have syntaxList(1, 2, 3) to create a list of three integers andMap('A' -> 1, 'C' -> 2) to create a map with two bindings. This is actually a universal feature of Scala collections. You can take any collection name and follow it by a list of elements in parentheses. The result will be a new collection with the given elements. Here are some more examples:

Traversable()             // An empty traversable objectList()                    // The empty listList(1.0, 2.0)            // A list with elements 1.0, 2.0Vector(1.0, 2.0)          // A vector with elements 1.0, 2.0Iterator(1, 2, 3)         // An iterator returning three integers.Set(dog, cat, bird)       // A set of three animalsHashSet(dog, cat, bird)   // A hash set of the same animalsMap('a' -> 7, 'b' -> 0)   // A map from characters to integers

“Under the covers” each of the above lines is a call to theapply method of some object. For instance, the third line above expands to

List.apply(1.0, 2.0)

So this is a call to theapply method of the companion object of theList class. That method takes an arbitrary number of arguments and constructs a list from them. Every collection class in the Scala library has a companion object with such anapply method. It does not matter whether the collection class represents a concrete implementation, likeList, orStream orVector, do, or whether it is an abstract base class such asSeq,Set orTraversable. In the latter case, calling apply will produce some default implementation of the abstract base class. Examples:

scala> List(1, 2, 3)res17: List[Int] = List(1, 2, 3)scala> Traversable(1, 2, 3)res18: Traversable[Int] = List(1, 2, 3)scala> mutable.Traversable(1, 2, 3)res19: scala.collection.mutable.Traversable[Int] = ArrayBuffer(1, 2, 3)

Besidesapply, every collection companion object also defines a memberempty, which returns an empty collection. So instead ofList() you could writeList.empty, instead ofMap(),Map.empty, and so on.

Descendants ofSeq classes provide also other factory operations in their companion objects. These are summarized in the following table. In short, there’s

• concat, which concatenates an arbitrary number of traversables together,
• fill andtabulate, which generate single or multidimensional sequences of given dimensions initialized by some expression or tabulating function,
• range, which generates integer sequences with some constant step length, and
• iterate, which generates the sequence resulting from repeated application of a function to a start element.

Factory Methods for Sequences

Contributors to this page:

• Introduction
• Mutable and Immutable Collections
• Trait Traversable
• Trait Iterable
• The sequence traits Seq, IndexedSeq, and LinearSeq
• Sets
• Maps
• Concrete Immutable Collection Classes
• Concrete Mutable Collection Classes
• Arrays
• Strings
• Performance Characteristics
• Equality
• Views
• Iterators
• Creating Collections From Scratch
• Conversions Between Java and Scala Collections
• Migrating from Scala 2.7

• English
• 日本語
• 中文 (简体)