スカラ。 はじめに

こんにちはハブラ



少し前、私は現在JVMの下にある多くの言語の1つであるScalaに興味を持ちました。 これには多くの理由がありますが、主な理由は、cppのような言語で作業するときの不便さの高まり続ける感じです。 私の目はRuby、Groovy、Pythonに交互に目を向けましたが、それらはすべて、私の通常の作業タスクにあまり適していないツールの印象を残しました（Pythonは良いですが、型付けされていない言語には独自の制限があります）。 一方、Scalaはかなり良い言語のように見えました。 ハブでの検索ではそれに関する記事が見つかりませんでした（いくつかありましたが、入門ではなく軽度に置くため）、私は小さなレビューを書いて大衆と​​共有することにしました。

無料の博覧会における言語の哲学

言語の作成者が追求する主な目標は何ですか？ 私の態度によると：

まず、互換性。 開発者は、タスクの中で、Java言語との互換性を維持し、さまざまなタスクを解決するためのgovnokodov開発の数千の例を設定しました。

第二に、主に（しかし完全にはほど遠い）Javaとは異なる機能的な機能を備えた言語の集中的な飽和。

第三に、あなたとの私たちの仕事の円滑化。 実際、Scalaコンパイラーはプログラマーを1語で理解し、特にラクダではないことを説明するためのコードを書くために、これまでにチャンスがありませんでした。

第4に、モジュール化された疎結合のソフトウェアコンポーネントの作成をサポートし、既存のコンポーネントの幅広い適応オプションと組み合わせることを推奨します。 目標は、完全に反対であるということではなく、同時に達成するために特定の困難を生み出します。 さて、何が起こるか見てみましょう。

5番目に、これは並行性サポートです。 残念ながら、私の手と頭はこの領域に到達していませんでしたが（これまでのところ）、この点に重点を置いて、すべての言語リソースに常に取り組んでいます。



言語実験のために、ここからお気に入りのIDEに適切なプラグインを配置してください。



それでは、言語自体を見てみましょう...

一般的な言語のアイデア、構文の例

おそらく最も重要なのは、「オブジェクトの統一モデル」です。 この用語は、著者によって次のようにデコードされます。「各値はオブジェクトであり、各操作はメソッド呼び出しです。」 これはもちろん「すべてがオブジェクト」ではありませんが、エンティティはJavaに比べて減少しており、エンティティが少ないほど寿命は短くなります:)適用された用語では、これは数字と記号が共通のヒープに存在する不変オブジェクトになり、すべての操作が参照セマンティクスを取得します。 たとえば、 5 + 5



コードは非常に有効であり、ガベージコレクターがすぐに投稿するヒープ上に新しいオブジェクトを生成します（実際、コンパイラーがアイデアの深さを理解し、何も生成しないことを静かに願っています:)）。



このような高貴な紹介の後、古典的な問題の解決策を見ることができます。

object Main {

def main(args:Array[ String ]) :Unit = {

print( "Hello, " + args(0) + "!" )

}

}



その中には次のものがあります。

• 個々のオブジェクトを宣言できます。 これには珍しいことは何もありません;例えば、Groovyでも同様の可能性があります。 このようなオブジェクトは、Javaで記述されたSingeltonテンプレートの実装と同じように動作します。
• 関数宣言は異常に見えますが、非常に読みやすいです：[キーワードdef] [名前]（[パラメーターリスト]）：[戻り値の型] = [コードブロック]。
• 情報負荷を持たないタイプは、ユニットタイプです。 Cライクな言語のvoidと非常によく似ています。
• 関数パラメーター宣言（および実際にはローカル変数も）は[名前]：[タイプ]のようになります。
• 型のパラメーター化には、通常の<>
  
  
  
  使用しませんが、一見永続的に配列に割り当てられます[]
  
  
  
  。
• 配列の要素（ある種のわいせつ）を参照するには、（）を使用します。
• 追加のインポートなしで、デフォルトでコードで使用できるいくつかの組み込み関数があります。

さらに、別の短い例を見てみましょう。

println( ( "Hello, " + args(0) + "!" ).toUpperCase )

println( "Hello, " + args(0) + "!" toUpperCase )



以下のように、演算子の使用.



絶対に必要ではありません。 言語の構文では、代わりにスペースを使用できます（メソッド引数は、メソッド名の直後に角かっこやカンマなしで記述することもできます）。 そして、見てわかるように、これは非常に有用であることがわかります。最初の行には、優先度の高い演算子があり.



括弧コードを詰まらせて不要なものを書くようになります。2番目の方法では、より簡潔で明確な形式で記述します。



開発者への支援として、Scalaはインタラクティブモードもサポートしています。 つまり、インタープリターを開始して、コマンドを1つずつ入力できます。 IDEに組み込まれたインタープリターは何らかの理由で定期的に機能せず、その別のバージョンはUbuntaリポジトリにあります。他のディストリビューションもうまく機能していると思います。幸せなWindows所有者はいつものように苦しむ必要があります:)

$ scala

Welcome to Scala version 2.7.3final (Java HotSpot(TM) Server VM, Java 1.6.0_16).

Type in expressions to have them evaluated.

Type :help for more information.

scala>







非常に小さな例：

scala> 1 to 10

res0: Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)







ここに、パラメーターを使用したメソッド呼び出しの例を示します。 誰も推測しなかった場合、クラスInt



1のオブジェクトが、同じタイプ10のパラメーターを持つto



メソッドで呼び出され、結果は値の範囲になります。



別の関数を作成してみましょう。 彼女に与えられた範囲内の数の合計を数えてみましょう：

scala> def sum(a: Int, b: Int): Int = {

| var result = 0

| for (i <- a to b) result += i

| result

| }

sum: (Int,Int)Int



scala> sum(1, 5)

res3: Int = 15







他の3つの重要なポイントがここに表示されます。

• varキーワードを使用して、ローカル変数を宣言できます
• ブロックの計算結果は、その中の最後の式です
• 自由にforループを使用して、特定の範囲内の値の計算を実行できます（実際には、任意のコンテナーオブジェクトのオブジェクトに対して）

機能操作

ここで何ができますか？ はい、何でも=）関数はプログラムの本格的なオブジェクトです。 オブジェクトのプロパティとして保存し、パラメータと戻り値として渡し、実行時に実際に作成できます。 これらのプロパティを使用すると、独自の種類で動作するいわゆる高階関数を構築できます。



説明のために、合計を計算する古典的な例を考えてみましょう。

scala> def sum(f: Int => Int, a: Int, b: Int): Int =

| if (a > b) 0 else f(a) + sum(f, a + 1, b) sum: ((Int) => Int,Int,Int)Int







この例では、おなじみの、すべての和演算子を表すsum関数が定義されています。 パラメータには次の意味があります。

fは、整数を合計の限界から合計の要素に変換する関数です。 パラメーターのタイプの宣言に注意してください：記号=>



は、パラメーターが関数であることを意味し、受け入れられる値のタイプはその左側の括弧内にリストされます（この例のようにパラメーターが1つしかない場合は省略できます）、返される結果のタイプは右側にあります。

それは簡単に動作します：範囲の下限で関数の値を計算し、それを1より小さい範囲で計算した結果と加算します。

また、この例では、言語の別の機能が表示されます-値の式である場合（ちなみに、以前に使用されたforも式であり、結果はUnit



型です）。 条件が真の場合、結果は最初のオプションになり、そうでない場合は2番目のオプションになります。

aとbは合計の限界です。



ほんの2つのid



関数とsquare



関数は、それぞれパラメーターとその正方形に等しくなります。

scala> def id(x: Int): Int = x

id: (Int)Int

scala> def square(x: Int): Int = x * x

square: (Int)Int







ここで、別の叙情的な余談を行う必要があります。Scalaの関数には宣言スタイルの宣言があります。 結果を得る方法ではなく、それが何に等しいかを説明しています。 ただし、関数本体で逐次計算を整理する場合、問題はありません-ブロックがあります。



これで、前に書いた内容を活用できます。

scala> sum(id, 1, 5)

res1: Int = 15

scala> sum(square, 1, 5)

res2: Int = 55







ここで、この部分のクライマックスが起こります-関数を取得して別の関数に渡します。 インターフェイス、匿名クラス、デリゲートはありません：ここにあります-少しの幸せ。



ここでは、入れ子関数と匿名関数の例を意図的に提供せず、カリー化しています。 このScalaはすべて実行できますが、短いレビューに含めることはできません。 上記の例は、プログラミングツールとしての高階関数の重要性、そして最も重要なことを理解するには十分だと思います。 最後に、プログラミングに関するすばらしい本のこの章を読むことをお勧めします。

クラスの特徴

簡単なクラスを説明しましょう。 複素数にします。 次のコードを作成します。

class Complex(r: Double, i: Double) {

def real = r

def image = i

def magnitude = Math .sqrt(r*r + i*i)

def angle = Math .atan2(i, r)



def + (that: Complex) = new Complex( this .real + that.real, this .image + that.image)



override def toString = real+ " + i*" +image+ " | " +magnitude+ "*e^(i*" +angle+ "))"

}



object Main {

def main(args:Array[ String ]) :Unit = {

val first = new Complex(1, 5)

val second = new Complex(2, 4)

val sum = first + second

println(first)

println(second)

println(sum)

}

}



まず、クラスはいくつかのパラメーターで宣言されます。 続編から推測できるように、これらはオブジェクトの存続期間を通じて利用可能なコンストラクターパラメーターです。

第二に、いくつかのメソッドがクラスで宣言されています-セレクター。 1つはデカルト表現用で、もう1つは極座標用です。 ご覧のとおり、どちらもコンストラクターパラメーターを使用しています。

第三に、加算演算子がクラスで宣言されています。 通常のメソッドとして宣言され、 Complex



を受け入れて返します。

そして最後に、このクラスでは、すべてのJavaプログラマーになじみのあるtoString



関数がtoString



たことは間違いありません。 Scalaのオーバーライドメソッドは、常にoverride



キーワードで明示的に指定する必要があることに注意することが重要です。



非常に大きな実用的価値にもかかわらず、このクラスにはいくつかの欠点があります。

• その機能のために不当に大量の画面スペースが必要です
• 自分を自分と比較する方法がわからない

さて、この美しい言語の助けを借りて欠点を修正してみましょう。

class Complex(val real: Double, val image: Double) extends Ordered[Complex] {

def magnitude = Math .sqrt(real*real + image*image)

def angle = Math .atan2(image, real)

def + (that: Complex) = new Complex( this .real + that.real, this .image + that.image)

def compare(that: Complex): Int = this .magnitude compare that.magnitude

override def toString = real+ " + i*" +image+ " | " +magnitude+ "*e^(i*" +angle+ "))"

}



object Main {

def main(args:Array[ String ]) :Unit = {

val first = new Complex(1, 5)

val second = new Complex(2, 4)

if (first > second )

println( "First greater" )

if (first < second )

println( "Second greater" )

if (first == second )

println( "They're equal" )

}

}



それで、新機能：

• コンストラクターパラメーターにはキーワードvalがあり、対応するセレクターは表示されません。 はい、すべてが明白です。これは、コンパイラーがセレクターを自動的に作成するための許可です。
• なじみのないクラス（またはむしろ特性）からの継承を追加しました。 はい、単純ではありませんが、クラスによってパラメーター化されています。 名前が示すように、それは私たちの標本の注文に役立つはずです。
• モジュールを比較して2つの複素数を比較する比較メソッドが登場しました。
• the>、<、==演算子の使用は、テストメソッドに現れました。 明らかにそれらを定義しませんでした。

特性のアイデアについていくつかの言葉を言う時が来ました。 これは特別なタイプのクラスであり、コンストラクターを持つことはできませんが、メソッドと属性を持つことができます。 通常、彼らは彼らの可能な相続人との相互作用のための何らかのプロトコルを確立します。 このプロトコルを使用して、子孫から必要な情報を取得し、それに何らかの動作を実装できます。 したがって、任意のクラス（またはオブジェクト）を任意の数の特性（および1つのクラスのみ）から継承できます。 たとえば、 Ordered



は抽象メソッドを宣言し、 compare



それに基づいて継承クラスを演算子<、<=、>などで補完します。 ここでは、異なるオブジェクトの真実を提供し、hashCodeを使用したequalsメソッドもそのような場合に再定義する必要があるため、提供された==演算子を再定義する価値があることに注意してください。

「これはすべて良いことです」とアウトソーシング市場の経験豊富なファイターは、「しかし、ナンセンスな属性修飾子を使用して、通常のドメインクラスが必要な場合はどうなりますか？」

当然、解決策があります:)

class User {

private [ this ] var _name: String = ""

def name = _name toUpperCase

def name_=(name: String ) = {

_name = if (name != null ) name else ""

}

}

• まず、このクラスは、異様な修飾子private[this]
  
  
  
  だけでなく、本体で既におなじみのキーワードvar
  
  
  
  使用します。 クラス本体のこのキーワードの値は、ブロックの内部の値とまったく同じであり（さらに、秘密を教えてくれます。コンストラクターに詰め込むこともできます）、クラス属性を可変にします。 outlandish修飾子は、変数はこのオブジェクトからのみアクセス可能であるべきだと述べています。 たとえば、 private[User]
  
  
  
  を記述して、私たちのような他のオブジェクトで利用できるようにしたり、パッケージの名前を指定したりすることができます（ 何かを思い出させます）。
• 次に、フィールドを大文字で返す関数が宣言されます。
• name_=
  
  
  
  に、奇妙な関数name_=
  
  
  
  は、文字列をパラメーターとして受け取り、それがnull
  
  
  
  ないことを確認して、フィールドに書き込みます。

これをすべて使用する方法を理解するために、次のコードの結果を見てみましょう（簡潔にするため、ここではオブジェクトとメインメソッドの説明は含めませんでした）。

val user = new User( "Scala!!!" )

println(user.name)

user.name = "M. Odersky"

println(user.name)

SCALA!!!

M. ODERSKY









注意、結論：<object>構造を使用すると、<something> _ =という名前のメソッドが呼び出されます。 私がScalaで知っている限り、これは2番目のハックです（最初のハックは()



をapply



メソッドの呼び出しに変換しapply



） 。Guidoは演算子の使用をメソッド呼び出しに暗黙的に変換することを遺言しました。

パターンマッチング

あなたは遠くから少し始めなければなりません。 Scalaには、いわゆるケースクラスがあります（当然、オブジェクトも）。 それらはキーワードcase



で宣言され、その後コンパイラは次のことを行う自由を取ります：

1. クラスに一致する名前でコンストラクター関数を作成します。
2. コンストラクター引数に基づいて、クラスtoString、equals、hashCodeに実装します。
3. すべてのコンストラクター引数のセレクターを作成します。

このすべての魔法は、 match



メソッドを使用するための道を開きます。 例を見てみましょう：

abstract class User



case class KnownUser(val name: String ) extends User



case class AnonymousUser() extends User



object Test {

val users = List (KnownUser( "Mark" ), AnonymousUser(), KnownUser( "Phil" ))



def register(user: User): Unit = user match {

case KnownUser(name) => println( "User " + name + " registered" )

case AnonymousUser() => println( "Anonymous user can't be registered" )

}



def main(args: Array[ String ]) =

users. foreach ( register )

}

したがって、コードの全体像は次のとおりです。ユーザーの抽象クラスがあり、彼のカジュアルな子孫が2つあります。有名な匿名ユーザーです。 （ここではファンタジーを含む）会議のユーザーのリストを登録します。 このために、パターンマッチングを使用します。これにより、さまざまな種類のオブジェクトに対するメソッドのさまざまな動作を決定し、これらのオブジェクトからのデータサンプリングを提供できます。



このような実例の後に、 match



メソッドの動作に関する理論があります。 ケース式ごとに、型がテンプレートクラスと一致するかどうか、およびコンストラクターパラメーターがテンプレートと一致するかどうかを確認します。 一般的な場合のテンプレートには、次のものが含まれます。

1. 他のケースクラスのコンストラクタ。 ここではすべてが非常に再帰的であり、テンプレートのネストの深さはプログラマーの狂気によって制限されません。
2. テンプレート変数。 これらは、結果を計算するために関数の本体で利用可能になります。
3. シンボル_
   
   
   
   興味のない意味を示します。
4. 言語リテラル。 たとえば、 1
   
   
   
   または"Hello"
   
   
   
   です。

したがって、構造（クラス）および/または格納されたデータに基づいてオブジェクトから特定の値を取得する方法を説明できるツールを取得します。



OOPの基本原則に精通している人は、当然、この問題が仮想関数を使用することで完全に解決されることにすぐに気付くでしょう（さらに、提案されたアプローチはベストプラクティスではありません）。 ただし、その使用には2つの困難が伴います。まず、多数のそのような関数を使用するコードのサポートが複雑になります（結局、イベント、グループ、ブログなどでユーザーを登録し、それぞれの場合に仮想メソッドを作成します） ？）、第二に、同じタイプのオブジェクトは基本的に異なる構造を持つことができ、データを提供できないという事実に関する問題を解決しません。



2番目の問題に特に注意を払いたいと思います。 上記のコードはJavaではどのようになりますか？ 1つのクラス。匿名ユーザーをnull



設定し、毎回チェックする場合（私のような麻酔薬はisAnonymousのようなメソッドを開始します。これは、フィールドを同じnull



と比較することで構成されnull



）。 問題は明白です-暗黙的で安全ではありません。 オブジェクトの構造のさまざまなバリエーションが1つのクラスに結合され、特定のケースで使用されていないものがnullで詰まっている場合、さらに悪いことにデフォルト値が発明された場合、そのような例は非常に多くあります。 Scalaでは、オブジェクトの構造のバリエーションを明示的に記述することができ、これらのバリエーションを操作するための便利なメカニズムが提供されます。



結論として、この手法を仮想機能の代替として効果的に適用できる時期についてのいくつかの考え：

• 多くの機能があります。 はい、オブジェクトの構造と内容に応じて、数回使用される数百の操作がある場合、ケースクラスに基づいたシステム-パターンマッチングが明らかによりよくサポートされます。
• クラスはほとんどありません。 一対のオプションからの一致は常によく読まれます。
• オブジェクトの構造には大きな違いがありますが、それらは統一された方法で保存および処理する必要があります。

逆はすべてのポイントに当てはまります。たとえば、12個のクラスにパターンマッチングを使用するのは良い考えではないようです。

型推論

既にお気付きだと思いますが、コードでは、クラスとメソッドを宣言するときにのみ型を指定しています。 コードブロックでは、ほとんど常にそれらを省略しました。 実際、プログラマーが明示的に型を指定しない場合、Scalaはコンテキストから型を決定しようとします。 たとえば、 def s = "Scala"



定義で定数値を初期化するときdef s = "Scala"



コンパイラは定数のタイプを文字列として決定します。 これはすべて、ジェネリック型でも機能します。たとえば、上記のval users = List(KnownUser("Mark"), AnonymousUser(), KnownUser("Phil"))



は、タイプList[User]



定数を作成し、自動的に階層の適切なレベルに上がります継承し、それを使用してコンテナタイプをパラメータ化します。 実際には、これは、そのような広告を大幅に節約できることを意味します（楽しみのために、JavaまたはC＃で同じコードを記述してください:)）。

おわりに

うーん...投稿の開始までに、長い間スクロールします。 明らかにそれは終了する時間です。 そして、私はもっと多くのことを言いたい：一般化されたクラスを記述するための最も興味深いメカニズムについて、暗黙の変換について、そしてそれらが実際に明示的で、定数の遅延初期化であるという事実について。



私自身は、マルチスレッドモデルとその実装に特有の一連のプリミティブをまだ調査しておらず、xml言語サポートを扱い、DSL構造を操作し、主力プロジェクトであるLiftを見て...



ただし、いくつかの結論を立てることを敢えてします。

• Scalaは非常に簡潔で表現力豊かな言語です
• シンプルで美しいプログラムを作成するための強力なツールを提供します。

以上です。 批判は大歓迎です。

最後に、大衆への質問：このトピックは興味深いですか、続編を書く価値がありますか？



UPD：これを手伝ってくれたみんなに感謝して、文法を修正しました。 特に、大規模なコンマ用のganqqwerty 。



_________

ソースコードハイライターですべてのソースコードが強調表示されました。

テキストはHabraで準備されます