Dotty-Scalaの未来

5月末、私はコペンハーゲンで開催されたScala Daysカンファレンスの聴衆の中にいました。 主要な講演者の1人は、Scala言語の作成者であるMartin Oderskyでした。 彼は言語の開発、特にDottyと呼ばれるコンパイラーの開発について話しました。 Dottyに基づいて、バージョン3.0の新しいコンパイラが開発される予定です。



Martinはこのテーマについて何度も話をしましたが、ここでDottyに関連するすべての情報を収集したいと思います。不要なものとして削除された新しい重要な機能と要素です。





マーティン・オーデルスキー。 今後数年間のScala開発計画



この投稿は専門家と初心者の両方に役立ちます。私はDottyについての会話の前に、Scalaの機能についての話と数学的な基礎にあることについて話をします。



Scalaはマルチパラダイムプログラミング言語で、元々はJVM（Java仮想マシン）の下で開発されました。 しかし現在、JavaScript（ScalaJS）およびネイティブコード（Scalaネイティブ）の翻訳者も開発されています。 Scalaという名前は、スケーラブル言語（「スケーラブル言語」）に由来します。 実際、Scalaでインタープリターで実行できるいくつかの行の小さなスクリプト（read-eval-print loop、REPL）と、多数のマシンのクラスターで実行される複雑なシステム（特に、 akkaおよびApache sparkフレームワークを使用）。



Scalaを開発する前、Martin OderskyはJavaのジェネリック型の開発に関与していました。これは2004年にJava 5に登場しました。 ほぼ同時期に、MartinはJVM用の新しい言語を作成するというアイデアを思い付きました。これには、当時のJavaにあった大きな後方互換性がありません。 Martinが計画したように、新しい言語は、Javaのオブジェクト指向アプローチとHaskell、OCaml、Erlang言語で使用されているのと同様の機能的アプローチを組み合わせ、同時に強く型付けされた言語でした。



強く型付けされた言語としてのScalaの主な機能の1つは、自動型推論のサポートです。 式ごとに型を明示的に指定する必要がある他の型付き言語とは異なり、Scalaでは、変数の型と関数の戻り値の型を暗黙的に決定できます。 たとえば、Javaの定数定義は次のようになります。

final String s = "Hello world";
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これは、Scalaの次の式と同等です。

 val s = "Hello world"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ただし、Scalaでは、たとえば、変数が指定された式のスーパータイプである型を持たなければならない場合など、式の型を明示的に指定することもできます。

 val cs: CharSequence = "Hello world"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Martin Oderskyは、暗黙的な型推論の規則を、他の言語と区別する言語の主要な特徴であると考えています。 現在、彼はこのシステムの改善と、DOT微積分（DOT微積分）と呼ばれる数学的基礎の研究を指揮しています。

ドット計算

DOTは依存オブジェクトタイプ、つまり 依存オブジェクトのタイプを推測します。 依存型とは、特定の操作の結果として取得される型です。 言語の現在のバージョンでは、既存のものに基づいて型を導出するための特定のルールセットが既にあります。たとえば、上または下からの継承階層の制限、または引数に応じた型推論（パス依存型）です。 以下に小さな例を示します。

 trait A { type B def someFunction(b: B): B } trait C[X <: D] { type Y = (X, D) def fun1(x: X): Y def fun2(a: A): aB }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この例では、AとCの2つの特性を定義します。特性AにはタイプフィールドBがあり、タイプB入力を受け取るsomeFunction関数も定義します。タイプBの値は、Aの特定の実装に応じて決まります。型パラメーターXは、型Dの子孫でなければなりません。特性Cは、型フィールドYと、2つの関数fun1およびfun2を定義します。 fun1はタイプXの入力を受け入れ、タイプYの値を返します。fun2はタイプAの値を受け入れますが、戻り値のタイプは引数AのタイプフィールドBの値によって決まります。



DOT計算は、このような導出の規則の数学的形式化です。 DOT計算の主な要素：

1. 最上位タイプ（任意）-階層の最上位のタイプは、すべてのタイプのスーパークラスです。
   
   
2. ボトムタイプ（なし）-階層の下のタイプは、すべてのタイプのサブタイプです。
   
   
3. 型宣言-指定された境界の上下の型宣言。
   
   
4. タイプの選択-変数に応じたタイプの推論。
   
   
5. 関数-入力としてさまざまなタイプの1つ以上の引数を取り、特定のタイプの値を持つ関数。
   
   

さらに、DOT計算では、次の一連の有効な型操作が定義されています。

1. 継承 境界線（この例では、Any and Nothing）でない場合、任意のタイプは、スーパータイプまたは別のタイプのサブタイプのいずれかです。 各タイプはそれ自体のスーパータイプおよびサブタイプです。
   
   
2. 他のタイプ（変数のオブジェクトおよび構造に類似）を含む構造タイプ（レコード）の作成。
   
   
3. 型の結合。 結果の型は、元の型のフィールドと操作の分離です。
   
   
4. タイプの交差。 結果の型は、元の型のフィールドと操作の組み合わせになります。
   
   
5. 型の再帰的な定義。
   
   

DOTの詳細な説明は、この出版物の範囲外です。 DOT計算に関する詳細は、 こちらをご覧ください 。

Dottyイノベーションの概要

DOT計算は、Dottyコンパイラーの数学的な基盤です。 実際、これはその名前に反映されています。



Dottyは、新しい言語の概念とコンパイル技術をテストするための実験的なプラットフォームになりました。 Martin Oderskyによれば、Dottyの開発の目標は、基本的な構造を強化し、言語の不要な要素を取り除くことです。 Dottyは現在、独立したプロジェクトとして開発されていますが、やがてメインのScalaブランチに統合される予定です。







革新の完全なリストは、Dottyの公式Webサイトで見つけることができます。 そして、この記事では、Dottyで最も重要だと考えるイノベーションのみを検討します。

1.交差点を入力します

型の交差は、元の型のすべてのプロパティを同時に持つ型として定義されます。 特定のタイプAおよびBを定義したとします。

 trait A { def fun1(): Int } trait B { def fun2(): String }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

タイプCは、タイプAとBの共通部分として定義されます。

 type C = A & B
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この場合、次の関数を記述できます。

 def fun3(c: C): String = s"${c.fun1()} - ${c.fun2()}"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

例からわかるように、パラメーターcについては、タイプAに対して定義されたfun1（）メソッドとタイプBに対して定義されたfun2（）メソッドの両方を呼び出すことができます。



コンパイラの現在のバージョンでは、この機能はwith構文を介してサポートされています。例：

 type C = A with B def fun3(c: C): String = s"${c.fun1()} - ${c.fun2()}"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

＆構文とwith構文には大きな違いがあります。＆は可換演算です。つまり、タイプA＆BはタイプB＆Aと同等ですが、BとAはBとAと同等ではありません。以下に例を示します。

 trait A { type T = Int } trait B { type T = String }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

タイプAとBの場合、タイプTの値はIntです。これは、AがBより優先されるためです。Dottyでは、タイプAとBの場合、タイプTはInt＆Stringになります。



型のwithコンストラクトはDottyで引き続きサポートされていますが、非推奨として宣言されており、将来削除する予定です。

2.タイプunion

型の和集合は、元の型のいずれかのプロパティを持つ型として定義されます。 型の共通部分とは異なり、現在のバージョンのscalaコンパイラには、型を結合するための類似性がありません。 統一された型を持つ値の場合、標準ライブラリには型[A、B]があります。 次のタイプが定義されているとします：

 case class Person(name: String, surname: String) case class User(nickname: String)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この場合、次の関数を記述できます。

 def greeting(somebody: Person | User) = somebody match { case Person(name, surname) => s"Hello, $name $surname" case User(nickname) => s"Hello $nickname, (sorry, I actually don't know your real name)" }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

型結合は、現在のバージョンの言語でいずれかを使用する場合と比較して、より短い表記法を提供します。

 def greeting(somebody: Either[Person, User]) = somebody match { case Left(Person(name, surname)) => s"Hello, $name $surname" case Right(User(nickname)) => s"Hello $nickname, (sorry, I actually don't know your real name)" }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

交差のような型結合も可換演算です。



型共用体の1つの使用例は、null構造を完全に取り除くことです。 現在、nullを使用する代わりに、Option構造が使用されますが、これはラッパーとして実装されているため、追加のパッキングおよびアンパッキング操作が必要なため、これはわずかに遅くなります。 型集約を使用すると、解決はコンパイル段階で行われます。

 def methodWithOption(s: Option[String]) = s match { case Some(string) => println(string) case None => println("There's nothing to print") } type String? = String | Null def methodWithUnion(s: String?) = s match { case string: String => println(string) case Null => println("There's nothing to print") }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

3.最も近いサブタイプとスーパータイプの決定

ユニオンやインターセクションなどの複合型に対する新しい操作の導入により、継承階層で最も近い型を計算するためのルールが変更されました。 Dottyは、すべてのタイプTおよびUについて、最も近いスーパータイプはT | U、および最も近いサブタイプはT＆Uになります。したがって、いわゆるサブタイピングラティスが形成されます。 彼女は下の図にいます。







現在のScala実装では、最も近いスーパータイプが2つのタイプの共通スーパータイプとして定義されています。 したがって、一般に、2つのケースクラスTおよびUの場合、最も近いスーパータイプはSerializableの製品になります。 Dottyでは、これはT | Tとして一意に定義されます。 U.



現在のScala実装で最も近いサブタイプの場合、単一の答えはありません。 最も近いサブタイプは、Uを含むTまたはTを含むUのいずれかです。前述のように、with操作は可換ではありません。したがって、Uを含むタイプTはTを含むタイプUと同等ではありません。Dottyは、最も近いサブタイプをT＆ U.操作＆は可換であるため、意味は一意です。

 val s = "String" val i  = 10 val result = if (true) s else i
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Scala 2.12では、結果の値にはAny型が割り当てられます。 Dottyでは、結果のタイプを明示的に指定しない限り、タイプAnyも割り当てられます。 ただし、結果のタイプを明示的に指定できます。

 val result: String | Int = if (true) s else i
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

したがって、結果の有効な値のセットをString型とInt型に制限しました。

4.型のラムダ式

Scalaの最も複雑な言語機能の1つは、いわゆる高次型のサポートです。 高階型の本質は、一般化されたプログラミングを使用するときに抽象化のレベルをさらに高めることです。 高次タイプの詳細については、 この記事で説明します 。 Dean WamplerとAlex Payne（第2版）の著書Programming Scalaから引用した特定の例を検討します。

 trait Functor[A, +M[_]] { def map2[B](f: A => B): M[B] } implicit class SeqFunctor[A](seq: Seq[A]) extends Functor[A, Seq] { override def map2[B](f: (A) => B): Seq[B] = seq map f } implicit class OptionFunctor[A](opt: Option[A]) extends Functor[A, Option] { override def map2[B](f: (A) => B): Option[B] = opt map f }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここでは、値型AとラッパーMの型という2つの型によってパラメーター化されるFunctor型を作成します。Scalaでは、式M（パラメーターなし）は型コンストラクターと呼ばれます。 新しいオブジェクトを作成するために特定のパラメーターセットを取得できるオブジェクトコンストラクターとの類推により、型コンストラクターは特定の型を定義するためにパラメーターを取得することもできます。 したがって、この例からFunctorの特定のタイプを判別するには、いくつかのステップを完了する必要があります。

1. タイプは、AおよびBに対して決定されます。
   
   
2. M [A]およびM [B]のタイプが決定されます。
   
   
3. Functorのタイプを定義します[A、M]
   
   

したがって、コンパイラは3回目の反復後にのみFunctorの型を決定できるため、高次型と見なされます。 一般的な場合、高次の型は、単純型と型コンストラクターの両方をパラメーターとして受け入れる型です。



上記の例には1つの欠点があります。Functor型のパラメーターでは、M型のコンストラクターは1つのパラメーターを受け取ります。 キーを変更せずに、Map [K、V]の値を変更するmap2メソッドを記述する必要があるとします。 Dean Wamplerは彼の本の中で次の解決策を提供しています。

 implicit class MapFunctor[K,V1](mapKV1: Map[K,V1]) extends Functor[V1,({type λ[α] = Map[K,α]})#λ] { def map2[V2](f: V1 => V2): Map[K,V2] = mapKV1 map {   case (k,v) => (k,f(v)) } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この例では、1つのパラメーターを取り、Mapの最初のパラメーターKを閉じる、タイプλの新しいコンストラクターを作成します。 この実装は非常に紛らわしいです。なぜなら、タイプλのコンストラクターを作成するために、構造タイプ{typeλ[α] = Map [K、α]}を最初に作成します。型の投影メカニズム（Dottyはこれを取り除くことにしました）を介して。



そのような場合のために、Dottyは型のラムダ式のメカニズムを開発しました。 構文は次のとおりです。

 [X] => Map[K, X]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この式は、1つのパラメーターを持つタイプとして読み取られます。これは、マップタイプを構築します。キータイプKは任意で、値のタイプはパラメーターと等しくなります。 したがって、次のようにMapの値を操作するFunctorを作成できます。

 implicit class MapFunctor[K,V1](mapKV1: Map[K,V1]) extends Functor[V1, [X] => Map[K,X]] { def map2[V2](f: V1 => V2): Map[K,V2] = mapKV1 map {  case (k,v) => (k,f(v)) } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この例からわかるように、Dottyで導入された型のラムダ式の構文を使用すると、MapFunctorクラスの定義を簡素化して、混乱するすべての構造を取り除くことができます。



型のラムダ式を使用すると、引数の共分散および反分散に制約を課すこともできます。次に例を示します。



[+ X、Y] =>マップ[Y、X]

5.タプルに対する関数のアリティの適応性

このイノベーションは、タプルからのコレクションの操作を単純化する構文糖衣であり、Productクラスのすべての実装での一般的なケース（これらはすべてケースクラスです）と同様です。

 val pairsList: List[(Int, Int)] = List((1,2), (3,4))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 case class Rectangle(width: Int, height: Int) val rectangles: List[Rectangle] = List(Rectangle(1,2), Rectangle(3,4))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この種類のコレクションを操作するために、1つの引数を持ついずれかの関数を使用できます。

 val sums = pairsLIst.map(pair => pair._1 + pair_2) val areas = rectangles.map(r => r.width * r.height)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

または、部分関数を使用できます。

 val sums = pairsLIst.map { case (a, b) => a + b } val areas = rectangles.map { case Rectangle(w, h) => w * h }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Dottyは、よりコンパクトで便利なオプションを提供します。

 val sums = pairsLIst.map(_ + _) val areas = rectangles.map(_ * _)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

したがって、タイプProduct Dottyのサブクラスでは、アリティが元の製品のアリティと等しい関数を選択します。

6.特性のパラメーター

Dottyは、特性を定義するときにパラメーターを設定する機能を最終的に追加しました。 これは、複雑な継承階層の場合、パラメーター値が未定義であったという事実により、これまで行われていません。 Dottyは、パラメーター化された特性の使用に追加の制限を導入しました。

• 特性のパラメータ値は、クラスを定義するときにのみ渡すことができますが、別の特性を渡すことはできません

 trait A(x: Int) trait B extends A trait B1 extends A(42) //  class C extends A(42)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

• パラメーター化された特性を実装するクラスを定義する場合、パラメーター値を指定する必要があります。 クラスが別のクラスを拡張し、特定の値が特性に渡されたかどうかを判断する場合、この場合、値を指定する必要はありません。
  
  

 class D extends A //  class D1 extends C class D2 extends C with A(84) // ,        C
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

• パラメータ化された特性の子孫であるクラスを拡張する特性は、この特性の明示的な指示を通じて値を渡す必要があります。
  
  

 class E extends B // ,       A class E extends A(42) with B
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

7.ノンブロッキング遅延値

Scalaの現在のバージョンでは、lazy valは、含まれているオブジェクトの同期メカニズムを使用して実装されています。 このソリューションには、次の欠点があります。

• 値が1つのスレッドのみで使用される場合、意味のない追加の同期コスト。
  
  
• 潜在的なデッドロック、たとえば：
  
  

 object A { lazy val a1 = B.b1 lazy val a2 = 42 } object B { lazy val b1 = A.a2 }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

2つのスレッドが同時に値a1とb1の初期化を開始すると、それぞれオブジェクトAとBのロックを取得します。 b1の初期化にはオブジェクトAでまだ初期化されていないa2の値が必要であるため、2番目のスレッドはオブジェクトBのロックが解除されるまで待機し、オブジェクトBのロックを保持します。オブジェクトBの2番目のスレッドによるブロックが原因です。その結果、デッドロックまたはデッドロックが発生しました。 （この例は、Dmitry Petrashkoによるレポートから取られています ）



Dottyでは、遅延値の場合、スレッドセーフな初期化がキャンセルされました。 複数のスレッドで使用するために値の安全な発行が必要な場合、そのような変数には次のように注釈を付ける必要があります。

  @volatile 

 @volatile lazy val x = {... some initialization code …}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

8.列挙

Dottyは列挙型をサポートしました。 それらを定義するための構文は、Javaとの類推によって行われました。

 enum Color { case Red, Green, Blue }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

列挙のサポートは、ソースコード解析のレベルで実装されます。 この段階で、enumコンストラクトは次の形式に変換されます。

 sealed class Color extends Enum object Color { private def $new(tag: Int, name: String) = {   new Color {     val enumTag = tag     def toString = name     //       } } val Red = $new(0, "Red") val Green = $new(1, "Green") val Blue = $new(2, "Blue") }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Javaと同様に、Dottyの列挙型もパラメーターをサポートしています。

 enum Color(code: Int) { case Red extends Color(0xFF0000) case Green extends Color(0x00FF00) case Blue extends Color(0x0000FF) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

したがって、列挙型には、封印されたケースクラス階層のすべてのプロパティがあります。 さらに、列挙型を使用すると、名前、インデックス、またはすべての有効な値のコレクションによって値を取得できます。

 val green = Color.enumValue(1) val blue = Color.enumValueNamed("Blue") val allColors = Color.enumValues
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

9.暗黙的（暗黙的）パラメーターの機能タイプ

現在のScala言語実装では、暗黙的な関数パラメーターは、実行コンテキストを表す標準的な方法です。

 def calculate(a: Int, b: Int)(implicit context: Context): Int = { val x = context.getInt("some.configuration.parameter") a * x + b }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この例では、コンテキストは暗黙的に渡され、その値はいわゆる暗黙的なスコープから取得されます。

 implicit val context: Context = createContext() val result = calculate(1,2)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

したがって、calculate関数を呼び出すたびに、パラメーターaとbのみを渡す必要があります。 そのような呼び出しごとに、コンパイラは、対応する暗黙のスコープから取得したコンテキスト値を置き換えます。 現在のアプローチの主な問題は、暗黙的なパラメーターの同じセットを取る多数の関数の場合、それらの関数ごとに指定する必要があることです。



Dottyでは、暗黙的なパラメーターを取る関数は型として表すことができます。

 type Contextual[T] = implicit Context => T
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Function型の実装である通常の関数との類推により、暗黙的なA => B型のすべての実装は、次の特性のサブタイプになります。

 trait ImplicitFunction1[-T0, +R] extends Function1[T0, R] { def apply(implicit x0: T0): R }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Dottyは、引数の数に応じて、22までのImplicitFunction特性のさまざまな定義を提供します。



したがって、Contextual型を使用すると、次のように計算関数をオーバーライドできます。

 def context: Contextual[Context] = implicitly[Context]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 def calculate(a: Int, b: Int): Contextual[Int] = { val x = context.getInt("some.configuration.parameter") a * x + b }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここで、環境から必要なコンテキストを取得する特別な関数defコンテキストを定義します。 したがって、calculate関数の本体はあまり変更されていません。ただし、コンテキストが括弧で囲まれなくなり、各関数で宣言する必要がなくなりました。

Dottyに含まれていないもの

レビューの最後に、言語から削除された要素について説明します。 原則として、新しい便利なデザインの導入後にそれらの必要性は消滅しました。または、それらの実装はより問題が多くなり、競合を引き起こし始めたため、削除が容易であることが判明しました。



やがてDottyがScala言語の新しいバージョンの基礎となり、バージョン番号はすでに3.xxになっている可能性が高いため、2.x.x言語の以前のバージョンとの後方互換性は保証されません。 ただし、Dotty開発チームは、バージョン2.x.xから3.x.xへの移行を容易にする特別なツールを開発することを約束しています。

1.プロジェクションを入力

型射影は、T＃Aという形式の構造体です。Tは任意の型で、AはT型の型フィールドです。次に例を示します。

 trait T { type A val a: A def fun1(x: A): Any def fun2(x: T#A): Any }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次の2つの変数が定義されているとします。

 val t1: T = new T { … } val t2: T = new T { … }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この場合、t1のfun1メソッドへの引数は、t2.aではなく、t1.aの値のみです。 メソッドの引数は「タイプTのタイプAのフィールドの任意の値」として定義されているため、fun2メソッドの引数はt1.aまたはt2.aのいずれかになります。



このデザインは、安定しておらず、タイプを横断するときに衝突を引き起こす可能性があるため、除外されました。 たとえば、次のコードはコンパイルされますが、実行時にClassCastExceptionがスローされます（ ここから取得）。

 object Test { trait C { type A } type T = C { type A >: Any } type U = C { type A <: Nothing } type X = T & U def main(args: Array[String]) = {   val y: X#A = 1   val z: String = y } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

型射影の代わりに、依存型（パス依存型）または暗黙的なパラメーターを使用することをお勧めします。

2.存在タイプ

存在型は、他の型のパラメーターである未知の型があることを示しています。このタイプの値は私たちには興味がありません;それが存在するという事実は私たちにとって単に重要です。したがって、名前。このタイプのタイプは、主にJavaのパラメーター化されたワイルドカードマスクタイプとの互換性を確保するためにScalaに追加されました。たとえば、Javaのコレクションはパラメーター化されており、パラメーターの種類に関心がない場合は、次のようにマスクを使用して設定できます。

 Iterable<?>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

パラメータのタイプに興味がないが、制限が課されていることがわかっている場合、この場合、タイプは次のように決定されます。

 Iterable<? extends Comparable>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Scalaでは、これらのタイプは次のように定義されます。

 Iterable[T] forSome { type T } //      Iterable[T] forSome { type T <: Comparable } //     
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Scalaには、マスクタイプをパラメーター化する機能もあります。

 Iterable[_] //      Iterable[_ <: Comparable] //     
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

最近のバージョンでは、これらの記録形式は完全に同等です。したがって、X [T] forSome {type T}形式を放棄することが決定されました。一般に、forSome設計はやや面倒であるため広く使用されていません。Javaの型との統合が必要なほぼすべての場所で、マスクによるパラメーター化を使用した構成が使用されるようになり、Dottyに残すことが決定されました。

3.事前初期化

Scalaの特性にはパラメーターがありません。これは、いくつかの特定のパラメーターが依存する抽象パラメーターの一部が特性にある場合に問題を引き起こしました。次の例を考えてみましょう。

 trait A { val x: Int val b = x * 2 } class C extends A { val x = 10 } val c = new C
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この場合、cbの値は20ではなく0です。初期化の規則に従って、特性の本体が最初にScalaで初期化され、その後でクラスが初期化されるためです。フィールドbが初期化される時点では、xの値はまだ定義されていないため、Int型のデフォルト値として0が使用されます。



この問題を解決するために、Scalaは事前初期化構文を導入しました。これを使用して、前の例のバグを修正できます。

 class C extends {val x = 10} with A
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この設計の欠点は、単純にポリモーフィズムを使用するのではなく、非自明なソリューションに頼る必要があることです。特性のパラメーターの導入により、初期イニシャライザーの必要性はなくなりました。この例は、よりシンプルで理解しやすい方法で実装できます。

 trait A(x: Int) { val b = x * 2 } class C extends A(10)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

4.遅延初期化

Scalaには遅延初期化のための特別な特性があります

 trait DelayedInit { def delayedInit(body: => Unit): Unit }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

初期化中にこの特性を実装するクラスは、delayedInitメソッドを呼び出します。このメソッドから、bodyパラメーターを介してクラスの初期化子を呼び出すことができます。

 class Test extends DelayedInit { def delayedInit(body: => Unit): Unit = {   println("This is delayedInit body")   body } println("This is class body") }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

したがって、新しいTestオブジェクトを作成すると、次の出力が得られます。



これはdelayInit本体です

これは



Scalaのクラス本体Trait DelayedInitはDeprecatedとして宣言されています。Dottyでは、特性をパラメータ化できるようになったため、彼はライブラリから完全に除外されました。したがって、名前による呼び出しのセマンティクスを使用すると、同様の動作を実現できます。

 trait Delayed(body: => Unit) { println("This is delayed body") body } class Test extends Delayed(println("This is class"))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

新しいテスト出力を作成する場合も同様に、次のとおりです。



この古い体が遅れている

。これは、クラスであります

5.手続き構文

関数の宣言を統一するために、返される型がUnitである関数を定義するための手続き構文を放棄することが決定されました。代わりに

 def run(args: List[String]) { //Method body }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

今、あなたは書く必要があります

 def run(args: List[String]): Unit = { //Method body }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

特にIntelliJ IDEAの多くのIDEが、手続き型の構文を機能的な構文に自動的に置き換えていることに注意してください。Dottyでは、コンパイラレベルで既に放棄されていました。

おわりに

一般に、Dottyは、Scalaでの開発中に発生する長期延滞の問題に対して、かなりシンプルで興味深いソリューションを提供します。たとえば、私の実践では、継承階層を介して接続されていない複数のタイプのオブジェクトを受け入れることになっているメソッドを記述する必要性にどういうわけか出会いました。引数の型としてAnyを使用し、その後にパターンマッチングを行う必要がありました。 Dottyでは、型の連結によってこの問題を解決できます。さらに、私は特性のパラメーターも欠いています。場合によっては、それらは非常に役立ちます。



会議でのレポートから判断すると、ScalaコミュニティーはDottyのリリースも待っています。特に、akkaフレームワークに関する1つのレポートで、受信メソッドとしてすべてのメッセージを結合するtypeメソッドを指定することにより、アクターをタイプすることができる方法について説明しました。



Dottyはすでに試用できます。DottyWebサイトには、インストールと構成の手順が記載されています。ただし、まだ不安定であるため、著者はまだ産業コードでの使用を推奨していません。



著者について



私の名前はアレクサンダートカレフであり、サーバーソフトウェアを10年以上開発しています。彼はPHP開発者として始まり、Javaに切り替え、最近Scalaに切り替えました。 2015年以来、私はCleverDATAで働いていますここで、ScalaはJavaとPythonとともに主要な開発言語の1つです。私たちは主に、Apache Sparkを使用して大量のデータを処理するプロセスを開発し、Akka Streamsに基づいて外部システムとやり取りするための高負荷のRESTサービスを構築するためにScalaを使用します。



追加資料

1. 2017年5月のScala Daysコペンハーゲン会議でのMartin Oderskyのレポート：ビデオ
   
   
2. 公式Scala言語サイト
   
   
3. Dottyプロジェクトの公式サイト
   
   
4. 記事 Scalaの言語についてのウィキペディアで
   
   
5. ドット計算
   
   
6. 記事Scalaの本質
   
   
7. Martin Oderskyによる DOT on YOWについてのレポート！夜、2017年2月
8. Dottyの開発者の1人であるDmitry Petrashkoによるレポート
   
   
9. 種類の多い
   
   
10. 暗黙的な関数タイプ