Scala keywords explained

We will take a tour of all Scala language reserved keywords.

Reserved keywords are words that have a special meaning in Scala. They cannot be used as an identifier (variable name or class name). For each reserved keyword there is a list of use cases and for each use case there is a concise explanation. The uses cases and explanations are mostly taken from the Scala language specification

There are currently 40 reserved keywords in Scala language:


abstract	case	catch	class	def
do	else	extends	false	final
finally	for	forSome	if	implicit
import	lazy	macro	match	new
null	object	override	package	private
protected	return	sealed	super	this
throw	trait	try	true	type
val	var	while	with	yield

Let’s explain them all!

abstract

abstract class ClassName { ... }

Defines an abstract class, a class that allows incomplete members.

abstract override def traitMethod = ...

Defines a trait method that calls an unrelated super method. In short, it allows the usage of the stackable trait pattern.

case

x match {
  case 1 => ...
  case 2 => ...
  ...
}

When x value matches one of the cases, the associated statement is executed. This feature is called pattern matching.

x match {
  case a if (a > 2) => ...
}

Defines a pattern matching with a guard. The if condition must be satisfied to match the pattern.

try {
  ...
} catch {
  case error: ErrorClassName => ...
}

Handles an error when it matches the pattern matching.

case class ClassName(param: Type, ...)

Defines a case class. It is a class made to hold data. Case class instances have the following features:
1. supports pattern matching,
2. can be compared with each other a == b,
3. produces a readable message when printed.

case object ObjectName { ... }

Defines an object that can be serialized.

def x: Type1 => Type2 = {
  case x => ...
}

Defines a function that processes its parameter through pattern matching.

catch

try { ... } catch { ... }

Handles a run time error. The expected errors are specified with case keyword.

class

class ClassName { ... }

Defines a class. A class is a blueprint for values called instances. A class can be defined with the following modifiers:
```
abstract class ClassName { ... }
```
- Defines an abstract class that allows incomplete members.
```
final class ClassName { ... }
```
- Defines a final class that cannot be extended.
```
sealed class ClassName { ... }
```
- Defines a sealed class that can only be extended by classes defined in the same source file.

case class ClassName(...)

Defines a case class, a class made to hold data.

def

def myFunction(...) = { ... }

Defines a function. A function is an identifier that can be called with or without attributes.

do

do {
  ...
} while (...)

Executes the statement in the do block as long as the while condition is true. That is a do-while loop

else

if (a > 2) ... else ...

Defines the statement that is executed when the if condition is false.

extends

class ClassName extends BaseClassName

Creates a class that inherits from an other class.

false

val x: Boolean = false

The Boolean literal false.

final

final class ClassName { ... }

Defines a class that cannot be extended. This class modifier cannot be combined with sealed.

final def classMember = ...

Defines a class member that cannot be overridden.

final val x = 10

Without a type, it defines a constant.

finally

try {
  ...
} catch {
  ...
} finally {
  ...
}

Runs the associated statement after a try-catch block. Whether an error is caught or not.

for

for (x <- items) ...

Runs a for-loop. It retrieves each element of the container items.

for (x <- items) yield ...

Runs a for comprehension. This sentence produces a value that can be iterated through.

for (x <- items if (x > 2)) ...

Defines a for comprehension with a guard. When the if guard is false the current element is skipped.

forSome

type T = A forSome { type A }

Defines an alias for an existential type. Existential type are generic types that are used to work with Java wildcard types and Java raw types. Existential types should be avoided unless you don’t have any other choice.

if

if (a > 2) ... else ...

Starts a conditional execution statement.

for (x <- items if (x > 2)) ...

Defines a for loop or a for comprehension with a guard. When the if condition is false the current element is skipped.

x match {
  case a if (a > 2) => ...
}

Defines a pattern matching alternative with a guard. The associated statement is executed when the x value matches the pattern and the if condition is true.

implicit

def methodName(implicit param: String) = ...

Defines a parameter that is implicitly replaced by a statement when the method is called. This mechanism is called implicit conversion.

implicit val x = 2

Defines an identifier that will be used to replace an implicit parameter.

import

import packagename.ClassName

imports an identifier. It makes the identifier visible and usable in the current scope.

import packagename._

Imports every accessible identifier that is in the package.

import packagename.{Name1, Name2, ...}

Imports the listed identifiers.

import packagename.{Name => NewName}

Imports and renames an identifier.

lazy

lazy val x = ...

Defines a lazy value, a value that is evaluated only when it is used for the first time.

macro

def methodName: Unit = macro methodImplementation

Defines a Scala macro implementation method.

match

x match {
  case 1 => ...
  case 2 => ...
}

Defines a pattern matching. It executes the statement associated with the case pattern that matches x value.

new

val x = new ClassName

Creates a new instance of a class.

null

val x: String = null

Assigns a null value to x. Null value exists for compatibility reasons with Java. Because Arnold hates NullPointerException it is safer to not explicitly use null and handle null values through optional values.

object

object ObjectName

Defines an object. An object is a singleton class’s instance.

case object ObjectName

Defines an object that can be serialized.

package object ObjectName

Defines an object that is used as a package. The object members can be imported through import ObjectName.memberName.

override

override val classMember = 2

Redefines a class member that have been previously defined in a parent class.

abstract override def traitMethod = ...

Override an abstract method in a traits.

package

package packagename

Placed on top of a file: means that every item defined in the file is part of the package.

package name { ... }

Means that all the identifiers defined in the block are parts of the package.

package object ObjectName

Defines an object that is used as a package. The object members can be imported through import ObjectName.memberName

private

private val classMember = 1

Defines a class member that can only be accessed from inside the current class & the companion class or object. Private members cannot be used by sub classes.

private[EnclosingClass] val classMember = 2

Defines a private value of an enclosed class that can be accessed by the enclosing class.

private[this] val classMember = 3

Defines an object protected member. This member is only visible in the current class. The companion class or companion object cannot access it.

protected

protected val classMember = 1

Defines a class member that can only be accessed from inside the class, from its derived classes and from its companion class or object.

protected[EnclosingClass] val classMember = 2

Defines a protected value of an enclosed class that can be accessed by the enclosing class & derived classes.

protected[this] val classMember = 2

Defines a member that is only visible in the current class and its derived classes. The companion class or companion object cannot access it.

return

return x

Returns a value from a function. Scala implicitly returns the last statement of a function that have been executed. Thanks to that, explicit returns can be avoided in most cases.

sealed

sealed class ClassName

Defines a class that can only be inherited by classes defined in the same source file. Therefore sealed and final modifiers cannot be used on the same class.

super

super.superClassMember

Gives access to the super classes members.

this

this.classMember

Here this represents the current instance of the class.

class ClassName {
  this: InjectedClassName =>
  ...
}

Injects a class members into an other class. This mechanism is called self-type.

def this(param: Int) = this(param, 2L, ...)

Defines an alternative constructor for the current class.

private[this] val classMember = 2

Defines an object protected member. This member is only visible in the current class. The companion class or companion object cannot access it.

protected[this] val classMember = 2

Defines a member that is only visible in the current class and sub classes. The companion class or companion object cannot access it.

throw

throw new ErrorClass(message)

Throws an error. The error should be handled by a try-catch block.

trait

trait TraitName { ... }

Defines a trait. A trait is a class that cannot be instantiated.

try

try {
  ...
} catch {
  ...
}

Handles run time errors that occurs in the try block. The error is caught and processed through pattern matching.

true

val x: Boolean = true

The Boolean literal true.

type

type T

Defines an abstract type.

val

val x = 1

Defines a value, an identifier that cannot be reassigned to an other value.

var

var x = 2

Defines a variable, an identifier that can be reassigned to other values.

while

do {
  ...
} while (...)

Starts a do-while loop. Loops until the while condition is false.

while (...) {
  ...
}

Starts a while loop. Loops until the while condition is false.

with

class ClassName extends Base1 with Trait1 with Trait2

Creates a class that inherits from multiple classes and traits.

val x = new ClassName with Trait1 with Trait2

Instantiate an anonymous class by combining multiple types (class & traits).

yield

for (x <- items) yield ...

Defines a for comprehension. The generator produces a composite value (List, Array, etc…).

You can leave a comment or request changes here.

This project is maintained by Y. Somda (yoeo)
Logo by Icon Island — theme by orderedlist — remixed by yoeo