Scala（プログラミング言語）

スカラ

パラダイム	マルチパラダイム:並行、関数型、命令型、オブジェクト指向
デザイン：	マーティン・オデルスキー
開発者	ローザンヌ連邦エコール工科大学プログラミング手法研究所
初登場	2004年1月20日; 20年前 (2004-01-20)
安定リリース	3.5.0 [1]  / 2024年8月22日; 35日前 (22 August 2024)
タイピングの規律	推測、静的、強い、構造的
実装言語	スカラ
プラットフォーム	Java 仮想マシン(JVM) JavaScript (Scala.js) LLVM (Scala Native) (実験的)
ライセンス	アパッチ2.0 [2]
ファイル名拡張子	.scala、.sc
Webサイト	scala.org より
影響を受けた
Common Lisp、[3] Eiffel、Erlang、F#、Haskell、[4] Java、[5] OCaml、[5] Oz、Pizza、[6] Scheme、[5] Smalltalk、Standard ML [5]
影響を受けた
Ceylon、Chisel、Fantom、F#、C#、Kotlin、Lasso、Red、Flix
Wikibooks の Scala

Scala（/ ˈ s k ɑː l ɑː / SKAH -lah）^{[7] [8]は}、オブジェクト指向プログラミングと関数型プログラミングの両方をサポートする、強力な 静的型付けの 高水準 汎用プログラミング言語です。簡潔になるように設計されており、^{[9] Scalaの設計上の決定の多くは、} Javaに対する批判に対処することを目的としています。^[6]

ScalaのソースコードはJavaバイトコードにコンパイルでき、Java仮想マシン（JVM）上で実行できます。また、ScalaはJavaScriptにトランスパイルしてブラウザで実行することも、ネイティブ実行可能ファイルに直接コンパイルすることもできます。JVM上で実行する場合、ScalaはJavaとの言語相互運用性を提供するため、どちらの言語で書かれたライブラリもScalaまたはJavaコードで直接参照できます。^[10] Javaと同様に、Scalaはオブジェクト指向であり、C言語に似た中括弧と呼ばれる構文を使用します。Scala 3以降では、オフサイドルール（インデント）を使用してブロックを構造化するオプションもあり、その使用が推奨されています。Martin Oderskyは、これがScala 3で導入された最も生産的な変更であると述べています。^[11]

Javaとは異なり、Scalaにはカリー化、不変性、遅延評価、パターンマッチングなど、関数型プログラミング言語（Scheme、Standard ML、Haskellなど）の多くの機能があります。また、代数的データ型、共変性と反変性、高階型（高階型は除く）、匿名型、演算子オーバーロード、オプションパラメータ、名前付きパラメータ、生の文字列、およびJavaのチェック例外のより強力なバージョンと見なすことができる代数的効果の実験的な例外のみのバージョンをサポートする高度な型システムもあります。^[12]

Scalaという名前は、スケーラブル（拡張可能）と言語（言語）を組み合わせた造語で、ユーザーの要求に応じて成長するように設計されていることを意味します。^[13]

Scalaの設計は、2001年にスイスのローザンヌにあるローザンヌ連邦工科大学（EPFL）でマーティン・オデルスキーによって開始されました。これは、関数型プログラミングとペトリネットのアイデアを組み合わせたプログラミング言語であるFunnelの開発に続くものです。^[14]オデルスキーは以前、Generic JavaやSunのJavaコンパイラであるjavacの開発に携わっていました。^[14]

2003年後半に内部リリースされた後、Scalaは2004年初頭にJavaプラットフォーム上で公開リリースされました。^{[15] [6] [14] [16]} 2番目のバージョン（v2.0）は2006年3月にリリースされました。^[6]

2011年1月17日、Scalaチームは欧州研究会議から5年間で230万ユーロを超える研究助成金を獲得した。^{[17] 2011年5月12日、オデルスキーと共同研究者は、Scalaの商用サポート、トレーニング、サービスを提供する会社であるTypesafe Inc.（後に}Lightbend Inc.に改名）を設立した。Typesafeは2011年にGreylock Partnersから300万ドルの投資を受けた。^{[18] [19] [20] [21]}

ScalaはJavaプラットフォーム（Java仮想マシン）上で動作し、既存のJavaプログラムと互換性があります。^[15] Androidアプリケーションは通常Javaで書かれ、パッケージ化時にJavaバイトコードからDalvikバイトコード（インストール時にネイティブマシンコードにさらに変換される場合もあります）に変換されるため、ScalaのJava互換性はAndroid開発に適しており、関数型アプローチが好まれる場合には特に適します。^[22]

コンパイラとライブラリを含むリファレンスScalaソフトウェアディストリビューションは、Apacheライセンスの下でリリースされています。^[23]

Scala.jsはJavaScriptにコンパイルするScalaコンパイラであり、WebブラウザやNode.jsで実行できるScalaプログラムを書くことができます。^[24] 2013年から開発されていたこのコンパイラは、2015年に実験的なものではなくなったと発表されました（v0.6）。バージョンv1.0.0-M1は2018年6月にリリースされ、バージョン1.1.1は2020年9月にリリースされました。^[25]

Scala Nativeは、Boehmガベージコレクターを使用する軽量マネージドランタイムを使用する実行可能コードを作成するためにLLVMコンパイラインフラストラクチャをターゲットとするScalaコンパイラです。このプロジェクトはDenys Shabalinが主導しており、2017年3月14日に最初のリリース0.1が行われました。Scala Nativeの開発は、コードの最初のランタイムコンパイルを排除し、ネイティブルーチンを直接呼び出す機能を提供することで、 JVMのジャストインタイムコンパイルよりも高速になることを目標に2015年に始まりました。^{[26] [27]}

.NET Frameworkとその共通言語ランタイムを対象としたリファレンスScalaコンパイラは2004年6月にリリースされましたが^[14] 、 2012年に正式に廃止されました。^[28]

Scala 3 で書かれたHello World プログラムの形式は次のとおりです。

@main def main () = println ( "Hello, World!" )    

Java 用のスタンドアロン Hello World アプリケーションとは異なり、クラス宣言はなく、静的であると宣言されているものは何もありません。

プログラムがHelloWorld.scalaファイルに保存されている場合、ユーザーは次のコマンドでコンパイルします。

$ scalac HelloWorld.scala

そしてそれを実行する

$ スカラ HelloWorld

これは、Java コードをコンパイルして実行するプロセスに似ています。実際、Scala のコンパイルおよび実行モデルは Java のものと同一であり、Apache Antなどの Java ビルド ツールと互換性があります。

「Hello World」Scala プログラムの短縮版は次のとおりです。

println ( "こんにちは、世界！" )

Scalaには対話型シェルとスクリプトサポートが含まれています。^[29]という名前のファイルに保存されHelloWorld2.scala、次のコマンドを使用してスクリプトとして実行できます。

$ scala HelloWorld2.scala

オプション-eを使用して、Scala インタープリターにコマンドを直接入力することもできます。

$ scala -e 'println("Hello, World!")'

REPLでは対話的に式を入力できます。

$ scala
 Scala 2.12.2 (Java HotSpot(TM) 64 ビット サーバー VM、Java 1.8.0_131) へようこそ。
評価する式を入力してください。または、:help を試してください。

scala> List(1, 2, 3).map(x => x * x) 
res0: List[Int] = List(1, 4, 9)

スカラ>

次の例は、Java と Scala の構文の違いを示しています。関数 mathFunction は整数を受け取り、それを二乗し、その数値の立方根をその数値の自然対数に加算して、結果 (つまり、) を返します。 ${\displaystyle n^{2/3}+\ln(n^{2})}$

このコードには次のような構文上の違いがあります。

• Scala では、文を終了するためにセミコロン (;) は必要ありません。
• Int, Double, Boolean値の型は ではなく大文字で表記されます (文頭大文字) int, double, boolean:。
• パラメータと戻り値の型は、Cのように前ではなく、Pascalのように後ろに続きます。
• メソッドの前には が付く必要がありますdef。
• valローカル変数またはクラス変数の前には、 (不変変数を示します) またはvar(可変変数を示します)を付ける必要があります。
• 関数内で演算子returnは不要です (ただし、許可されています)。通常、最後に実行されたステートメントまたは式の値が関数の値になります。
• (Type) fooScalaでは、 Java キャスト演算子 の代わりに、 、またはや などfoo.asInstanceOf[Type]の特殊な関数を使用します。toDoubletoInt
• import foo.*;Scala では、Java の の代わりにを使用しますimport foo._。
• 関数またはメソッドは、foo()単に として呼び出すこともできますfoo。メソッドは、thread.send(signo)単に として呼び出すこともできますthread send signo。また、メソッドは、foo.toString()単に として呼び出すこともできますfoo toString。

これらの構文緩和は、ドメイン固有言語のサポートを可能にするために設計されています。

その他の基本的な構文上の違い:

• array(i)配列参照は、ではなく、 のように関数呼び出しのように記述されますarray[i]。(Scala の内部では、前者は参照を返す array.apply(i) に展開されます)
• List[String]ジェネリック型は、 Java の ではなく、たとえば として記述されますList<String>。
• 疑似型の代わりにvoid、Scala には実際のシングルトン クラス Unitがあります(以下を参照)。

次の例では、Java と Scala のクラスの定義を対比しています。

上記のコードは、Java と Scala のクラスの処理における概念的な違いの一部を示しています。

• Scala には静的変数やメソッドはありません。代わりに、シングルトン オブジェクトobjectがあります。これは基本的にインスタンスが 1 つだけのクラスです。シングルトン オブジェクトはではなく を使用して宣言されますclass。静的変数とメソッドをクラス名と同じ名前のシングルトン オブジェクトに配置するのが一般的で、これはコンパニオン オブジェクト と呼ばれます。^[15] (シングルトン オブジェクトの基になるクラスには が追加されます。したがって、コンパニオン オブジェクト の場合、内部的にはコンパニオン オブジェクトのコードを含むクラスがあり、シングルトン パターンを使用してこのクラスのオブジェクトが 1 つ作成されます。)$class Fooobject FooFoo$
• Scala には、コンストラクタパラメータの代わりに、関数のパラメータと同様にクラスに配置されるクラスパラメータvalがあります。またはvar修飾子を使用して宣言すると、フィールドも同じ名前で定義され、クラスパラメータから自動的に初期化されます。(内部的には、パブリックフィールドへの外部アクセスは常に、自動的に作成されるアクセサ(ゲッター)メソッドとミューテーター(セッター)メソッドを経由します。アクセサ関数はフィールドと同じ名前を持つため、上記の例ではアクセサメソッドを明示的に宣言する必要はありません。) Java と同様に、代替コンストラクタも宣言できることに注意してください。デフォルトコンストラクタに入るコード(メンバー変数の初期化以外)は、クラスレベルで直接行われます。
• Scala では、シンボルをメソッド名として使用して演算子を定義することができます。 の代わりにaddPoint、Scala の例では を定義し、これを中置記法でとして+=呼び出します。grid += this
• Scala のデフォルトの可視性は ですpublic。

Scala はJavaやC#と同じコンパイル モデル、つまり個別のコンパイルと動的なクラス読み込みを備えているため、Scala コードは Java ライブラリを呼び出すことができます。

Scala の操作特性は Java と同じです。Scala コンパイラは、Java コンパイラによって生成されるバイトコードとほぼ同じバイトコードを生成します。^[15]実際、Scala コードは、特定のコンストラクタ操作を除いて、読み取り可能な Java コードに逆コンパイルできます。Java仮想マシン(JVM) にとって、Scala コードと Java コードは区別できません。唯一の違いは、1 つの追加のランタイムライブラリです。scala-library.jar[ ^30]

Scala は Java と比べて多数の機能を追加しており、式と型の基盤モデルにいくつかの基本的な違いがあります。これにより、言語は理論的にクリーンになり、Java のいくつかの特殊なケースが排除されます。Scala の観点からは、Scala で追加されたいくつかの機能は C# でも利用できるため、これは実用的に重要です。

上で述べたように、Scala は Java と比較して構文の柔軟性が非常に高くなっています。次に例をいくつか示します。

• セミコロンは不要です。行が通常この位置に来ることができないトークンで始まるか終わる場合、または閉じていない括弧または角括弧がある場合、行は自動的に結合されます。
• 任意のメソッドを中置演算子として使用できます。たとえば"%d apples".format(num)、 と は"%d apples" format num同等です。実際、 や などの算術演算子は、関数名が任意のシンボルのシーケンスで構成できるため、他のメソッド+と<<同様に扱われます (括弧、角括弧、中括弧など、特別に処理する必要があるいくつかの例外を除く)。このようなシンボル名のメソッドが受ける唯一の特別な処理は、優先順位の処理に関するものです。
• メソッドapplyと には、update構文上の短縮形があります。foo()- はfoo値 (シングルトン オブジェクトまたはクラス インスタンス) です - は の短縮形foo.apply()、は のfoo() = 42短縮形です。foo.update(42)同様に、foo(42)は の短縮形foo.apply(42)、 はfoo(4) = 2の短縮形です。これはコレクション クラスに使用され、 STMfoo.update(4, 2)セルなどの他の多くのケースにも拡張されます。
• Scala は、括弧なし ( def foo = 42) メソッドと空括弧 ( def foo() = 42) メソッドを区別します。空括弧メソッドを呼び出す場合、括弧を省略できます。これは、foo.toStringの代わりにを使用するなど、この区別を認識しない Java ライブラリを呼び出す場合に便利です。慣例により、副作用 をfoo.toString()実行するメソッドは、空括弧を使用して定義する必要があります。
• コロン ( ) で終わるメソッド名は:、左側に引数、右側にレシーバーを期待します。たとえば、 は4 :: 2 :: Nilと同じでNil.::(2).::(4)、最初の形式は結果 (最初の要素が 4、2 番目の要素が 2 のリスト) に視覚的に対応します。
• クラス本体の変数は、別々の getter メソッドと setter メソッドとして透過的に実装できます。 の場合trait FooLike { var bar: Int }、実装は になります。呼び出しサイトでは、簡潔な を引き続き使用できます。object Foo extends FooLike { private var x = 0; def bar = x; def bar_=(value: Int) { x = value }} } }foo.bar = 42
• メソッド呼び出しでは、括弧の代わりに中括弧を使用できます。これにより、新しい制御構造の純粋なライブラリ実装が可能になります。^[31]たとえば、は言語で定義されたキーワードのbreakable { ... if (...) break() ... }ように見えますが、実際にはサンク引数を取るメソッドにすぎません。サンクまたは関数を取るメソッドは、多くの場合、これらを2番目のパラメータリストに配置して、括弧と中括弧の構文を混在させることができます。はと同じです。中括弧のバリアントにより、式を複数行にまたがることができます。breakableVector.fill(4) { math.random }Vector.fill(4)(math.random)
• for 式 (後述) はmap、、、flatMapなどのモナド メソッドを定義する任意の型に対応できますfilter。

これらは、それ自体では疑問のある選択のように思えるかもしれませんが、全体としては、コンパイラを拡張することなく、Scala でドメイン固有言語を定義できるようにするという目的を果たします。たとえば、アクターにメッセージを送信するためのErlangの特別な構文、つまり ie は、actor ! message言語拡張を必要とせずに Scala ライブラリで実装できます (実際に実装されています)。

intJava では、プリミティブ型 (例: およびboolean) と参照型 (任意のクラス)が明確に区別されています。 から派生した参照型のみが継承スキームの一部ですjava.lang.Object。Scala では、すべての型がトップレベルクラス から継承されAny、その直接の子はAnyVal(値型、たとえばIntやBoolean) と(参照型、Java の場合と同様) です。つまり、プリミティブ型とボックス化された型 (例:と) の Java の区別は Scala には存在しません。つまり、AnyRefボックス化とボックス化解除は、ユーザーに対して完全に透過的です。Scala 2.10 では、ユーザーが新しい値型を定義できます。 intInteger

イテレータをループするJava の " foreach " ループの代わりに、Scala には -式があります。これは、 Haskellなどの言語のリスト内包表記、またはPythonのリスト内包表記とジェネレータ式の組み合わせforに似ています。 キーワードを使用する for 式では、既存のコレクションを反復処理して新しいコレクションを生成し、同じタイプの新しいコレクションを返すことができます。これらは、コンパイラによって一連の、、呼び出しに変換されます。が使用されていない場合、コードは に変換され、命令型のループに近似されます。 yieldmapflatMapfilteryieldforeach

簡単な例は次のとおりです。

val s = for ( x <- 1 to 25 if x * x > 50 ) yield 2 * x              

実行した結果は次のベクトルになります。

Vector(16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50)

（式は1 to 25特別な構文ではないことに注意してください。このメソッドは、to標準Scalaライブラリで整数の拡張メソッドとして定義されており、暗黙の変換^[32]と呼ばれる手法を使用して、既存の型に新しいメソッドを追加することができます。）

マップを反復処理するより複雑な例は次のとおりです。

// ツイートのセットで言及された Twitter ユーザー
と各ユーザーが言及された回数を指定するマップが与えられた場合、
既知の政治家のマップでユーザーを検索し、
民主党の政治家のみ (文字列ではなくオブジェクトとして)を示す
新しいマップを返します。val dem_mentions = for ( mention , times ) < -mentions account < - accounts.get ( mention ) if account.party == "Democratic " yield ( account , times )    
       
               
       
    

式はパターン マッチング(mention, times) <- mentionsの例です(下記参照)。マップを反復処理すると、キーと値のタプルのセットが返されます。パターン マッチングを使用すると、タプルをキーと値の別々の変数に簡単に分解できます。同様に、理解の結果もキーと値のタプルを返します。これは、ソース オブジェクト (変数 から) がマップであるため、自動的にマップに再構築されます。代わりにリスト、セット、配列、またはその他のタプルのコレクションを保持した場合、上記とまったく同じコードで同じタイプの新しいコレクションが生成されることに注意してください。 mentionsmentions

Scala は、Java で利用可能なすべてのオブジェクト指向機能をサポートし (実際、さまざまな方法でそれらを拡張しています)、通常は関数型プログラミング言語にのみ備わっている多数の機能も提供します。これらの機能を組み合わせることで、Scala プログラムをほぼ完全に関数型のスタイルで記述できるようになり、関数型とオブジェクト指向のスタイルを混在させることもできます。

例:

• 文と表現の区別がない
• 型推論
• キャプチャセマンティクスを持つ匿名関数（クロージャなど）
• 不変変数とオブジェクト
• 遅延評価
• 区切られた継続(2.8 以降)
• 高階関数
• ネストされた関数
• カレー作り
• パターンマッチング
• 代数的データ型（ケースクラス経由）
• タプル

CやJavaとは異なり、 Lispなどの言語と同様に、Scala では文と式を区別しません。すべての文は、実際には何らかの値に評価される式です。C や Java で return として宣言される関数voidや、while論理的には値を返さないそのような文は、Scala ではUnit、その型のオブジェクトを 1 つだけ持つシングルトン型である型 を返すものとみなされます。まったく返らない関数と演算子 (たとえば、演算子や、例外を使用して常に非ローカルにthrow終了する関数)は、論理的には戻り値の型 を持ちます。これは、オブジェクトを含まない特別な型、つまりボトム型、つまりすべての可能な型のサブクラスです。(これにより、型はすべての型と互換性があり、型推論が正しく機能できるようになります。) ^[33]NothingNothing

同様に、if-then-else「ステートメント」は実際には式であり、値、つまり 2 つのブランチのいずれかを評価した結果を生成します。つまり、このようなコード ブロックは式が必要な場所に挿入できるため、Scala で 三項演算子を使用する必要はありません。

同様の理由から、Scalareturnではステートメントは不要であり、実際推奨されていません。Lisp と同様に、コード ブロック内の最後の式はそのコード ブロックの値であり、コード ブロックが関数の本体である場合は、関数によって返されます。

すべての関数が式であることを明確にするために、戻り値を返すメソッドもUnit等号で記述します。

def printValue ( x : String ): Unit = println ( "私は %s を食べました" . format ( x ))     
  

または同等です（型推論を使用し、不要な改行を省略します）。

def printValue ( x : String ) = println ( "私は%sを食べました" format x )      

型推論により、変数、関数の戻り値、その他多くの式の型は、コンパイラが推論できるため、通常は省略できます。例としては、val x = "foo"(不変定数または不変オブジェクトの場合) やvar x = 1.5(後で値を変更できる変数の場合) があります。Scala の型推論は、Haskell、ML 、その他のより純粋に関数的な言語で使用されるよりグローバルなHindley-Milnerアルゴリズムとは対照的に、基本的にローカルです。これは、オブジェクト指向プログラミングを容易にするために行われます。その結果、特定の型 (最も顕著なのは、関数のパラメータと再帰関数の戻り値の型) は依然として宣言する必要があります。例:

def formatApples ( x : Int ) = "私はリンゴを %d 個食べました" . format ( x )    

または（再帰関数の戻り値の型を宣言した場合）

def factorial ( x : Int ): Int = x == 0の場合は1 、それ以外の場合はx * factorial ( x - 1 )    
       
       

Scala では、関数はオブジェクトであり、匿名関数を指定するための便利な構文が存在します。一例としてx => x < 2、式 は、引数が 2 未満かどうかを比較する 1 つのパラメータを持つ関数を指定します。これは、Lisp 形式 と同等です(lambda (x) (< x 2))。 の型もx戻り値の型も明示的に指定する必要はなく、通常は型推論によって推論できますが、(x: Int) => x < 2や のように明示的に指定することもできます(x: Int) => (x < 2): Boolean。

匿名関数は、囲んでいる関数の環境で語彙的に利用可能な変数を自動的にキャプチャするという点で、真のクロージャとして動作します。これらの変数は、囲んでいる関数が戻った後でも利用可能であり、Java の匿名内部クラスの場合とは異なり、final として宣言する必要はありません。(このような変数が可変である場合は変更することも可能であり、変更された値は次に匿名関数が呼び出されたときに利用可能になります。)

さらに短い形式の匿名関数では、プレースホルダー変数を使用します。たとえば、次のようになります。

list map { x => sqrt(x) }

より簡潔に書くと

list map { sqrt(_) }

あるいは

list map sqrt

Scala では、不変変数と可変変数の区別が強制されます。可変変数はvarキーワードを使用して宣言され、不変値は キーワードを使用して宣言されますval。 キーワードを使用して宣言された変数は、Java で キーワードを使用して宣言された変数を再割り当てできないvalのと同じように、再割り当てできません。は浅い意味でのみ不変であり、つまり、 val によって参照されるオブジェクト自体が不変であるとは保証されません。 finalval

ただし、慣例により不変クラスが推奨されており、Scala 標準ライブラリは不変コレクションクラスの豊富なセットを提供しています。Scala はほとんどのコレクション クラスに対して可変および不変のバリアントを提供しており、可変バージョンが明示的にインポートされない限り、不変バージョンが常に使用されます。^[34] 不変バリアントは永続的なデータ構造であり、古いオブジェクトを破壊的に更新するのではなく、常に古いオブジェクトの更新されたコピーを返します。この例としては、不変リンク リストがあります。このリストの先頭に要素を追加するには、要素とリスト末尾への参照で構成される新しいリスト ノードを返します。リストに要素を追加するには、古いリストのすべての要素を、新しい要素のみを含む新しいリストの先頭に追加する必要があります。同様に、リストの途中に要素を挿入すると、リストの前半がコピーされますが、リストの後半への参照は保持されます。これは構造的共有と呼ばれます。これにより、非常に簡単な並行処理が可能になります。共有オブジェクトが変更されることはないため、ロックは必要ありません。^[35]

評価はデフォルトで厳密（"eager"）です。つまり、Scala は必要に応じてではなく、利用可能になるとすぐに式を評価します。ただし、lazyキーワードを使用して変数を非厳密（"lazy"）として宣言することは可能です。つまり、変数の値を生成するコードは、変数が最初に参照されるまで評価されません。さまざまなタイプの非厳密なコレクションも存在し（非Stream厳密なリンク リストの 型など）、 メソッドを使用して任意のコレクションを非厳密にすることができますview。非厳密なコレクションは、サーバーが生成したデータなどにセマンティックに適合します。サーバーが生成したデータでは、リストの後の要素を生成するコードの評価（これにより、Web 上の別の場所にある可能性のあるサーバーへのリクエストがトリガーされます）は、要素が実際に必要な場合にのみ行われます。

関数型プログラミング言語では、スタックオーバーフローの問題を起こさずに再帰を広範囲に使用できるように、末尾呼び出し最適化が一般的に提供されています。Java バイトコードの制限により、JVM での末尾呼び出し最適化は複雑になっています。一般に、末尾呼び出しで自分自身を呼び出す関数は最適化できますが、相互再帰関数は最適化できません。回避策としてトランポリンが提案されています。^[36]トランポリンのサポートは、Scala ライブラリによってオブジェクトとともに提供されています(Scala 2.8.0 (2010 年 7 月 14 日リリース))。関数にはオプションで を注釈付けできます。その場合、末尾再帰でない限りコンパイルされません。^[37]scala.util.control.TailCalls@tailrec

この最適化の例は、階乗定義を使用して実装できます。たとえば、階乗の再帰バージョンは次のようになります。

def factorial ( n : Int ): Int = n == 0の場合は1 、それ以外の場合はn * factorial ( n - 1 )    
       
       

次のように末尾再帰バージョンに最適化できます。

@tailrec 
def Factorial ( n : Int , accum : Int ): Int = if n == 0 then accum else Factorial ( n - 1 , n * accum )       
       
        

ただし、定義に新しい引数があるため、他の関数との組み合わせ可能性が損なわれる可能性があるため、元のシグネチャを保持するためにクロージャを使用するのが一般的です。

階乗を定義する( n : Int ): Int =     

  テイルレック
  defループ( current : Int 、accum : Int ): Int =       
  
    n == 0の場合、累積する     
    elseループ( current - 1 , n * accum )      
  
  loop ( n , 1 ) // ベースケースを使用してクロージャを呼び出す  
  
階乗終了 

これにより、末尾呼び出しの最適化が保証され、スタック オーバーフロー エラーが防止されます。

Scala にはパターン マッチングのサポートが組み込まれています。これは、 switch 文のより洗練された拡張可能なバージョンと考えることができます。任意のデータ型 (整数、ブール値、文字列などの単純な型だけでなく) をマッチングでき、任意のネストもできます。case クラスと呼ばれる特別な種類のクラスが提供されており、パターン マッチングの自動サポートが含まれており、多くの関数型プログラミング言語で使用される代数データ型をモデル化するために使用できます。(Scala の観点から見ると、case クラスは、単に通常のクラスであり、コンパイラーが自動的に特定の動作を追加しますが、これらの動作は手動でも提供できます。たとえば、深い比較やハッシュを提供するメソッドの定義や、パターン マッチング中にコンストラクター パラメーターで case クラスを分解するなどです。)

パターン マッチングを使用したクイックソートアルゴリズムの定義の例を次に示します。

def qsort ( list : List [ Int ] ): List [ Int ] = list match case Nil => Nil case pivot :: tail = > val ( larger , rest ) = tail .partition ( _ < pivot ) qsort ( larger ) ::: pivot :: qsort ( rest )       
     
      
          
        

ここでの考え方は、リストをピボット未満の要素とピボット以上の要素に分割し、各部分を再帰的にソートし、ピボットを挟んで結果を貼り付けるというものです。これは、マージソートやその他の高速ソートアルゴリズムと同じ分割統治戦略を使用します。

演算子は、matchに格納されているオブジェクトに対してパターン マッチングを行うために使用されますlist。各case式は、一致するかどうかが順番に試され、最初に一致した式によって結果が決定されます。この場合、 はNilリテラル オブジェクト にのみ一致しますNilが、pivot :: tail空でないリストに一致し、同時に指定されたパターンに従ってリストを分解しますpivot。この場合、関連付けられたコードは、リストの先頭を保持する という名前のローカル変数と、tailリストの末尾を保持する別の変数にアクセスできます。これらの変数は読み取り専用であり、Lisp および Scheme で 演算子 を使用して確立される変数バインディングと意味的に非常に似ていることに注意してください。let

パターン マッチングは、ローカル変数の宣言でも行われます。この場合、呼び出しの戻り値はtail.partitionタプル (この場合は 2 つのリスト) です。(タプルは、常に固定サイズであり、要素が異なる型になる可能性があるという点で、リストなどの他の種類のコンテナーとは異なりますが、ここでは両方とも同じです。) パターン マッチングは、タプルの 2 つの部分を取得する最も簡単な方法です。

この形式は、プレースホルダー変数を使用した無名関数_ < pivotの宣言です。無名関数に関する上記のセクションを参照してください。

リスト演算子( Lisp や Scheme と::同様に、リストの先頭に要素を追加する) と(Lisp や Scheme と同様に、2 つのリストを結合する) の両方が表示されます。見た目に反して、これらの演算子のどちらも「組み込み」ではありません。上で指定したように、任意のシンボルの文字列を関数名として使用でき、オブジェクトに適用されたメソッドはピリオドや括弧なしで「中置」スタイルで記述できます。上記の行は次のように記述されます。 cons:::append

qsort(smaller) ::: pivot :: qsort(rest)

次のように書くこともできます:

qsort(rest).::(pivot).:::(qsort(smaller))

より標準的なメソッド呼び出し表記法です。(コロンで終わるメソッドは右結合であり、右側のオブジェクトにバインドされます。)

上記のパターン マッチングの例では、演算子の本体は部分関数matchです。部分関数は一連の式で構成され、 switch ステートメントの本体と同様に、最初に一致する式が優先されます。部分関数は、ステートメントの例外処理部分でも使用されます。 casetry

試してください... case nfe : NumberFormatException => { println ( nfe ); List ( 0 ) } case _ => Nilをキャッチします 
  
 
         
     

最後に、部分関数は単独で使用することができ、それを呼び出した結果は、matchそれに対して a を実行することと同等です。たとえば、クイックソートの前のコードは次のように記述できます。

val qsort : List [ Int ] = > List [ Int ] = case Nil => Nil case pivot :: tail = > val ( smaller , rest ) = tail.partition ( _ < pivot ) qsort ( smaller ) ::: pivot :: qsort ( rest )      
     
      
          
        

ここでは、整数のリストから整数のリストへの関数の型を持つ読み取り専用変数が宣言され、部分関数にバインドされます。(部分関数の単一のパラメータは明示的に宣言または名前付けされないことに注意してください。) ただし、この変数を通常の関数とまったく同じように呼び出すことができます。

scala > qsort (リスト( 6 , 2 , 5 , 9 )) res32 :リスト[ Int ] =リスト( 2 , 5 , 6 , 9 ) 
      

Scala は、すべての値がオブジェクトであるという意味で、純粋なオブジェクト指向言語です。オブジェクトのデータ型と動作は、クラスと特性によって記述されます。クラスの抽象化は、サブクラス化と柔軟なmixin ベースの構成メカニズムによって拡張され、多重継承の問題を回避します。

トレイトは、Java のインターフェースの Scala 版です。Java バージョン 8 未満のインターフェースは、抽象関数宣言のみを含むことができるなど、非常に制限されています。このため、インターフェースに便利なメソッドを提供するのは扱いにくい (同じメソッドをすべての実装で再実装する必要がある) という批判があり、公開されたインターフェースを下位互換性のある方法で拡張することは不可能です。トレイトは、クラス パラメータ (Java のコンストラクタ パラメータに相当する Scala のもの) 以外は通常の抽象クラスのほぼすべての機能を備えているという点で、ミックスイン クラスに似ています。これは、トレイトが常にクラスとミックスインされるためです。super演算子はトレイトで特別に動作し、継承に加えて合成を使用してトレイトを連鎖させることができます。次の例は、単純なウィンドウ システムです。

抽象クラスWindow : // abstract def draw ()  
  
   


class SimpleWindow extends Window : def draw () println ( "in SimpleWindow" ) // 基本的なウィンドウを描画する   
    
    
    
  

特性WindowDecoration はWindowを拡張します   


特性 Horizo ​​ntalScrollbarDecoration はWindowDecorationを拡張します: // 親関数が抽象であるため、"super()" が機能するには、ここで "abstract override" が必要です。 具体的であれば、通常の "override" で十分です。abstract override def draw () println ( "in Horizo​​ntalScrollbarDecoration" ) super . draw () // ここで水平スクロールバーを描画します   
  
  
      
    
    
    
  

特性VerticalScrollbarDecoration はWindowDecorationを拡張します: abstract override def draw () println ( "in VerticalScrollbarDecoration" ) super . draw () // 垂直スクロールバーを描画します   
      
    
    
    
  

特性TitleDecoration はWindowDecorationを拡張します: abstract override def draw () println ( "in TitleDecoration" ) super . draw () // タイトルバーを描画します   
      
    
    
    

変数は次のように宣言できます。

val mywin =新しいSimpleWindow with VerticalScrollbarDecoration with Horizo​​ntalScrollbarDecoration with TitleDecoration          

呼び出しの結果はmywin.draw()次のようになります。

TitleDecorationのHorizo ​​ntalScrollbarDecorationのVerticalScrollbarDecorationのSimpleWindow 
 
 
 

言い換えると、 の呼び出しは最初に（ミックスインされた最後の特性）drawのコードを実行し、次に（呼び出しを通じて）他のミックスインされた特性を遡って最終的に のコードを実行しますが、どの特性も互いに継承していません。これは、デコレータ パターンに似ていますが、親ウィンドウを明示的にカプセル化したり、実装が変更されない関数を明示的に転送したり、エンティティ関係の実行時の初期化に依存したりする必要がないため、より簡潔でエラーが発生しにくくなります。他の言語では、実装継承の長い線形チェーンを使用してコンパイル時に同様の効果を実現できますが、Scala と比較すると、ミックスインの可能な組み合わせごとに 1 つの線形継承チェーンを宣言する必要があるという欠点があります。 TitleDecorationsuper()Window

Scalaは、抽象化の安全で一貫した使用を主に強制する表現力豊かな静的型システムを備えています。しかし、型システムは健全ではありません。^[38]特に、型システムは以下をサポートしています。

• オブジェクトのメンバーとしてのクラスと抽象型
• 構造タイプ
• パス依存型
• 複合型
• 明示的に型指定された自己参照
• ジェネリッククラス
• 多態的メソッド
• 上限と下限の型境界
• 分散
• 注釈
• ビュー

Scala は使用によって型を推測することができます。これにより、ほとんどの静的型宣言はオプションになります。コンパイラ エラーによって必要性が示されない限り、静的型を明示的に宣言する必要はありません。実際には、コードの明確さのために、いくつかの静的型宣言が含まれています。

Scala の一般的な手法である「enrich my library」^[39] (当初は2006 年に Martin Odersky によって「 pimp my library 」と呼ばれていましたが、 ^{[32]この表現には否定的な意味合い[40]}と未熟さ^[41]があるため懸念が提起されました) を使用すると、新しいメソッドを既存の型に追加されたかのように使用できます。これは C# の拡張メソッドの概念に似ていますが、より強力です。この手法はメソッドの追加に限定されず、たとえば新しいインターフェイスの実装にも使用できるためです。Scala では、この手法では、メソッドを「受け取る」型から、元の型をラップして追加のメソッドを提供する新しい型 (通常はクラス) への暗黙的な変換を宣言します。特定の型のメソッドが見つからない場合、コンパイラは、問題のメソッドを提供する型への適用可能な暗黙的な変換を自動的に検索します。

この手法により、アドオン ライブラリを使用して既存のクラスに新しいメソッドを追加することができ、アドオン ライブラリを インポートするコードのみが新しい機能を取得し、他のすべてのコードは影響を受けません。

Int次の例は、メソッドisEvenとによる型の強化を示していますisOdd。

オブジェクトMyExtensions : extension ( i : Int ) def isEven = i % 2 == 0 def isOdd = ! isEven 
    
           
        
 

import MyExtensions . _ // スコープに暗黙的なエンリッチメントを導入する4 . isEven // -> true   
  

のメンバーをインポートすると、MyExtensions拡張クラスへの暗黙的な変換がIntPredicatesスコープ内に入ります。^[42]

Scalaの標準ライブラリには、標準のJava並行性APIに加えて、futuresとpromisesのサポートが含まれています。元々はアクターモデルのサポートも含まれていましたが、これは現在Lightbend社によってライセンスされた別のソースコードが利用可能なプラットフォームAkka [43]として利用可能です。Akkaアクターは分散することも、ソフトウェアトランザクションメモリ（トランザクタ）^と組み合わせることもできます。チャネルベースのメッセージパッシングのための代替の通信シーケンシャルプロセス（CSP）実装は、通信Scalaオブジェクト^{[44]または単に}JCSP経由です。

アクターはメールボックスを持つスレッドインスタンスのようなものです。これはsystem.actorOf、メソッドをオーバーライドしてreceiveメッセージを受信し、!(感嘆符)メソッドを使用してメッセージを送信することで作成できます。^[45] 次の例は、メッセージを受信して​​印刷できるEchoServerを示しています。

val echoServer = actor (新しいAct : become : case msg => println ( "echo " + msg ) )    
  
         


echoServer ! 「こんにちは」  

Scalaには、バージョン2.9.0以降、標準ライブラリに統合された 並列コレクション^[46]の形で、データ並列プログラミングのサポートが組み込まれています。

次の例は、並列コレクションを使用してパフォーマンスを向上させる方法を示しています。^[47]

val urls = List ( "https://scala-lang.org" 、"https://github.com/scala/scala" )    

def fromURL ( url : String ) = scala.io.Source.fromURL ( url ) .getLines ( ) . mkString ( " \ n " )​​    
  

val t = System.currentTimeMillis () urls.par.map ( fromURL ( _ ) ) // parはコレクションの並列実装を返しますprintln ( " time : " + ( System.currentTimeMillis - t ) + " ms " )   
 
      

Scalaは、未来と約束、アクターのサポート、データ並列性に加えて、ソフトウェアトランザクションメモリとイベントストリームを使用した非同期プログラミングもサポートしています。^[48]

Scala で書かれた最も有名なオープンソースのクラスターコンピューティング ソリューションは、 Apache Spark です。さらに、 Spark やその他のストリーム処理テクノロジで人気のあるパブリッシュ/サブスクライブメッセージ キューであるApache Kafka もScala で書かれています。

Scalaでコードをテストする方法はいくつかあります。ScalaTestは複数のテストスタイルをサポートし、Javaベースのテストフレームワークと統合できます。^{[49] ScalaCheckはHaskellの}QuickCheckに似たライブラリです。^[50] specs2は実行可能なソフトウェア仕様を記述するためのライブラリです。^[51] ScalaMockは高階関数とカリー化関数のテストをサポートしています。^[52] JUnitとTestNGはJavaで書かれた人気のあるテストフレームワークです。

Scala is often compared with Groovy and Clojure, two other programming languages also using the JVM. Substantial differences between these languages exist in the type system, in the extent to which each language supports object-oriented and functional programming, and in the similarity of their syntax to that of Java.

Scala is statically typed, while both Groovy and Clojure are dynamically typed. This makes the type system more complex and difficult to understand but allows almost all^[38] type errors to be caught at compile-time and can result in significantly faster execution. By contrast, dynamic typing requires more testing to ensure program correctness, and thus is generally slower, to allow greater programming flexibility and simplicity. Regarding speed differences, current versions of Groovy and Clojure allow optional type annotations to help programs avoid the overhead of dynamic typing in cases where types are practically static. This overhead is further reduced when using recent versions of the JVM, which has been enhanced with an invoke dynamic instruction for methods that are defined with dynamically typed arguments. These advances reduce the speed gap between static and dynamic typing, although a statically typed language, like Scala, is still the preferred choice when execution efficiency is very important.

Regarding programming paradigms, Scala inherits the object-oriented model of Java and extends it in various ways. Groovy, while also strongly object-oriented, is more focused in reducing verbosity. In Clojure, object-oriented programming is deemphasised with functional programming being the main strength of the language. Scala also has many functional programming facilities, including features found in advanced functional languages like Haskell, and tries to be agnostic between the two paradigms, letting the developer choose between the two paradigms or, more frequently, some combination thereof.

Regarding syntax similarity with Java, Scala inherits much of Java's syntax, as is the case with Groovy. Clojure on the other hand follows the Lisp syntax, which is different in both appearance and philosophy.^{[citation needed]}

Back in 2013, when Scala was in version 2.10, the ThoughtWorks Technology Radar, which is an opinion based biannual report of a group of senior technologists,^[139] recommended Scala adoption in its languages and frameworks category.^[140]

In July 2014, this assessment was made more specific and now refers to a “Scala, the good parts”, which is described as “To successfully use Scala, you need to research the language and have a very strong opinion on which parts are right for you, creating your own definition of Scala, the good parts.”.^[141]

In the 2018 edition of the State of Java survey,^[142] which collected data from 5160 developers on various Java-related topics, Scala places third in terms of use of alternative languages on the JVM. Relative to the prior year's edition of the survey, Scala's use among alternative JVM languages fell from 28.4% to 21.5%, overtaken by Kotlin, which rose from 11.4% in 2017 to 28.8% in 2018. The Popularity of Programming Language Index,^[143] which tracks searches for language tutorials, ranked Scala 15th in April 2018 with a small downward trend, and 17th in Jan 2021. This makes Scala the 3rd most popular JVM-based language after Java and Kotlin, ranked 12th.

The RedMonk Programming Language Rankings, which establishes rankings based on the number of GitHub projects and questions asked on Stack Overflow, in January 2021 ranked Scala 14th.^[144] Here, Scala was placed inside a second-tier group of languages–ahead of Go, PowerShell, and Haskell, and behind Swift, Objective-C, Typescript, and R.

The TIOBE index^[145] of programming language popularity employs internet search engine rankings and similar publication counting to determine language popularity. In September 2021, it showed Scala in 31st place. In this ranking, Scala was ahead of Haskell (38th) and Erlang, but below Go (14th), Swift (15th), and Perl (19th).

As of 2022^[update], JVM-based languages such as Clojure, Groovy, and Scala are highly ranked, but still significantly less popular than the original Java language, which is usually ranked in the top three places.^[144][145]

• In April 2009, Twitter announced that it had switched large portions of its backend from Ruby to Scala and intended to convert the rest.^[146]
• Tesla, Inc. uses Akka with Scala in the backend of the Tesla Virtual Power Plant. Thereby, the Actor model is used for representing and operating devices that together with other components make up an instance of the virtual power plant, and Reactive Streams are used for data collection and data processing.^[147]
• Apache Kafka is implemented in Scala with regards to most of its core and other critical parts. It is maintained and extended through the open source project and by the company Confluent.^[148]
• Gilt uses Scala and Play Framework.^[149]
• Foursquare uses Scala and Lift.^[150]
• Coursera uses Scala and Play Framework.^[151]

• Apple Inc. uses Scala in certain teams, along with Java and the Play framework.^[152][153]
• The Guardian newspaper's high-traffic website guardian.co.uk^[154] announced in April 2011 that it was switching from Java to Scala.^[155][156]
• The New York Times revealed in 2014 that its internal content management system Blackbeard is built using Scala, Akka, and Play.^[157]
• The Huffington Post newspaper started to employ Scala as part of its content delivery system Athena in 2013.^[158]
• Swiss bank UBS approved Scala for general production use.^[159]
• LinkedIn uses the Scalatra microframework to power its Signal API.^[160]
• Meetup uses Unfiltered toolkit for real-time APIs.^[161]
• Remember the Milk uses Unfiltered toolkit, Scala and Akka for public API and real-time updates.^[162]
• Verizon seeking to make "a next-generation framework" using Scala.^[163]
• Airbnb develops open-source machine-learning software "Aerosolve", written in Java and Scala.^[164]
• Zalando moved its technology stack from Java to Scala and Play.^[165]
• SoundCloud uses Scala for its back-end, employing technologies such as Finagle (micro services),^[166] Scalding and Spark (data processing).^[167]
• Databricks uses Scala for the Apache Spark Big Data platform.
• Morgan Stanley uses Scala extensively in their finance and asset-related projects.^[168]
• There are teams within Google and Alphabet Inc. that use Scala, mostly due to acquisitions such as Firebase^[169] and Nest.^[170]
• Walmart Canada uses Scala for their back-end platform.^[171]
• Duolingo uses Scala for their back-end module that generates lessons.^[172]
• HMRC uses Scala for many UK Government tax applications.^[173]
• M1 Finance uses Scala for their back-end platform.^[174]

In November 2011, Yammer moved away from Scala for reasons that included the learning curve for new team members and incompatibility from one version of the Scala compiler to the next.^[175] In March 2015, former VP of the Platform Engineering group at Twitter Raffi Krikorian, stated that he would not have chosen Scala in 2011 due to its learning curve.^[176] The same month, LinkedIn SVP Kevin Scott stated their decision to "minimize [their] dependence on Scala".^[177]

• sbt, a widely used build tool for Scala projects
• Spark Framework is designed to handle, and process big-data and it solely supports Scala
• Neo4j is a java spring framework supported by Scala with domain-specific functionality, analytical capabilities, graph algorithms, and many more
• Play!, an open-source Web application framework that supports Scala
• Akka, an open-source toolkit for building concurrent and distributed applications
• Chisel, an open-source language built on Scala that is used for hardware design and generation.^[178]

Wikibooks has a book on the topic of: Scala