Guides and Overviews

Scala's Collection Library.

Contents

• Introduction
• Mutable and Immutable Collections
• Trait Iterable
• The sequence traits Seq, IndexedSeq, and LinearSeq
• 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

This page describes the main changes for collection users that migrate to Scala 2.13 and shows how to cross-build projects with Scala 2.11 / 2.12 and 2.13.

These pages describe the architecture of the collections framework introduced in Scala 2.13. Compared to the Collections API you will find out more about the internal workings of the framework.

In this document you will learn how the collections framework helps you define your own collections in a few lines of code, while reusing the overwhelming part of collection functionality from the framework.

This guide shows how to write operations that can be applied to any collection type and return the same collection type, and how to write operations that can be parameterized by the type of collection to build.

Everything you need to know about compatibility and migration to Scala 3.

A detailed tutorial to cover all the features involved in writing macros in Scala 3.

Value classes are a new mechanism in Scala to avoid allocating runtime objects. This is accomplished through the definition of new AnyVal subclasses.

An overview over the TASTy format aimed at end-users of the Scala language.

String Interpolation allows users to embed variable references directly in processed string literals. Here’s an example:

val name = "James"
  println(s"Hello, $name")  // Hello, James

In the above, the literal s"Hello, $name" is a processed string literal. This means that the compiler does some additional work to this literal. A processed string literal is denoted by a set of characters preceding the ". String interpolation was introduced by SIP-11, which contains all details of the implementation.

Scala 2.10 introduced a new feature called implicit classes. An implicit class is a class marked with the implicit keyword. This keyword makes the class’ primary constructor available for implicit conversions when the class is in scope.

A light introduction to the Scala language, focused on Scala 2. Now updated for Scala 3, we are in the process of merging the two.

Lists all the tools that library authors should setup to publish and document their libraries.

Futures provide a way to reason about performing many operations in parallel– in an efficient and non-blocking way. A Future is a placeholder object for a value that may not yet exist. Generally, the value of the Future is supplied concurrently and can subsequently be used. Composing concurrent tasks in this way tends to result in faster, asynchronous, non-blocking parallel code.

Scala's Parallel Collections Library.

Contents

• Overview
• Concrete Parallel Collection Classes
• Parallel Collection Conversions
• Concurrent Tries
• Architecture of the Parallel Collections Library
• Creating Custom Parallel Collections
• Configuring Parallel Collections
• Measuring Performance

Which Scala versions work on what JDK versions

When two versions of Scala are binary compatible, it is safe to compile your project on one Scala version and link against another Scala version at run time. Safe run-time linkage (only!) means that the JVM does not throw a (subclass of) LinkageError when executing your program in the mixed scenario, assuming that none arise when compiling and running on the same version of Scala. Concretely, this means you may have external dependencies on your run-time classpath that use a different version of Scala than the one you’re compiling with, as long as they’re binary compatible. In other words, separate compilation on different binary compatible versions does not introduce problems compared to compiling and running everything on the same version of Scala.

A diverse and comprehensive set of libraries is important to any productive software ecosystem. While it is easy to develop and distribute Scala libraries, good library authorship goes beyond just writing code and publishing it. In this guide, we cover the important topic of Binary Compatibility.

We regularly publish 'nightlies' of both Scala 3 and Scala 2 so that users can preview and test the contents of upcoming releases. Here's how to find and use these versions.

The Scala REPL is a tool (scala) for evaluating expressions in Scala.

The scala command will execute a source script by wrapping it in a template and then compiling and executing the resulting program

Updates in Scala 3 to Scala’s API documentation generation tool.

Scala's API documentation generation tool.

Contents

• Overview
• Scaladoc for Library Authors
• Using the Scaladoc Interface

Scala's runtime/compile-time reflection framework.

Contents

• Overview
• Environment, Universes, and Mirrors
• Symbols, Trees, and Types
• Annotations, Names, Scopes, and More
• TypeTags and Manifests
• Thread Safety
• Changes in Scala 2.11

Scala's metaprogramming framework.

Contents

• Use Cases
• Blackbox Vs Whitebox
• Def Macros
• Quasiquotes
• Macro Bundles
• Implicit Macros
• Extractor Macros
• Type Providers
• Macro Annotations
• Macro Paradise
• Roadmap
• Changes in 2.11

Quasiquotes are a convenient way to manipulate Scala syntax trees.

Contents

• Dependencies and setup
• Introduction
• Lifting
• Unlifting
• Hygiene
• Use cases
• Syntax summary
• Expression details
• Type details
• Pattern details
• Definition and import details
• Terminology summary
• Future prospects

Compiler plugins permit customizing and extending the Scala compiler. This tutorial describes the plugin facility and walks you through how to create a simple plugin.

Various options to control how scalac compiles your code.

A new engine for more user-friendly error messages, printing chains of dependent implicits and colored found/required type diffs.

The compiler can perform various optimizations.

Scala's Collection Library.

Contents

• 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

These pages describe the architecture of the Scala collections framework in detail. Compared to the Collections API you will find out more about the internal workings of the framework. You will also learn how this architecture helps you define your own collections in a few lines of code, while reusing the overwhelming part of collection functionality from the framework.