Clojureを学ぶ理由

良いプログラミング言語とは何ですか？ 彼はどのような資質と特徴を持っているべきですか？ 答えを出すのは難しいです。 考えられる定義の1つを次に示します。優れたPLは、それに割り当てられたタスクを適切に解決する必要があります。 結局のところ、YPはプログラマーの手にある単なるツールです。 ツールは私たちの仕事を助けてくれなければなりません。 最後に、これが作成の理由です。 さまざまなPLがさまざまな問題を解決しようとします（成功はさまざまです）。 Clojureの設計時に設定された目標は、作成したプログラムを単純にすることでした。 そして、結果として、作成、テストを加速します。 そして最も重要なことは、彼らの理解、変更、保守のための時間を短縮することです。

クロージュア岩？

すぐに警告します-Clojureのクールさを示すコードスニペットはありません。 「X言語では5行かかり、Clojureでは4行しかかからなかった」といったフレーズはありません。 これは、言語の品質に関する嫌な基準です！ 最終的に、 qsort



を2行で記述できるかどうかは気にしません。または、5本も指をqsort



なければなりません。実際には、ライブラリ関数を使用します。



ラムダを持っている人を驚かせることはありません。それらはどこにでもあります（通常、ほとんどの場合、8番目のバージョンではどこにでも表示されます）。 コレクション（並列を含む）、リスト式、さまざまな構文糖の処理-多くの言語でこれで十分です。 実のところ、私はそのような記事をただ崇拝しています。 しかし、このような比較は、言語の品質を比較するのにはまったく不適切です！ これは、プログラムが「Hello、world！」と表示する速さによってYPの速度を測定する方法です。 さて、 HQ9 +の速度を測定しない限り。 考えてみると、このような詳細は大規模なシステムにとってそれほど重要ではありません。 プロジェクトが成長するにつれて、括弧やインデントを使用するか、中置記法、接頭辞記法のどちらを使用するかについて、私たちはますます心配しなくなります。 配列の合計を見つけるときの余分な行は、すでにすべての人を悩ますことをやめます-そもそも、異なる種類の問題が出てきます。

難易度

私たちが作成するシステムは本質的に揮発性です。 要件が変更されなければ、非常に良いでしょう。 開発の最初の段階ですべての状況を事前に予測できるとしたら、それは素晴らしいことです。 悲しいかな、実際には、私たちは常に仕上げ、改造、改善、書き換え、交換、最適化する必要があります...最も不快なことは、時間が経つにつれてシステムの複雑さが増すことです。 絶えず、継続的に。 開発の初期段階では、すべてがシンプルで透過的であり、変更はすべて「クランチ」なしで迅速に行われます。 美人 時間が経つにつれて、状況はとてもバラ色で陽気になります。 コードのわずかな編集でも、システムの動作に雪崩のような変化が生じる可能性があります。 慎重に研究し、コードを分析し、各変更による副作用を予測する必要があります。 正確に言えば、時間が経つにつれて、文字通り、変更のすべての可能な結果を​​完全に分析することはできません。



人は本来、限られた量の情報しか一度に知覚できません。 プロジェクトが成長するにつれて、内部接続の数も増加します。 さらに、ほとんどの接続は暗黙的です。 頭の中で必要なものを維持することがますます困難になっています。 そして現時点では、チームは成長しており、チームは変化しています-新しい人々はプロジェクト全体をもはや知りません。 責任が分離されているため、さらに混乱する可能性があります。 徐々に、システムが複雑になります。



これに対処する方法は？ 回帰テストの最大カバレッジと各変更後にそれらを実行しますか？ テストは非常に便利ですが、安全ロープにすぎません。 テストはパスしませんでした-何かが正しくありません。問題があります。 これは症状の治療ですが、テストは問題の本質を解決しません。 厳格なガイドラインとパターンの広範な使用？ いいえ、問題は地元の問題ではありません。 コード内でコンポーネントがどのように相互作用するかを理解するのをやめるだけです。暗黙的なリンクが多すぎます。 たぶん一定のリファクタリングですか？ これは万能薬ではありません;低レベルのソリューションから複雑さは増しません。 実際、問題は包括的に対処する必要があります。 そして、重要なツールの1つは適切なツールです。 優れたプログラミング言語は、シンプルで透過的なプログラムを作成するのに役立ちます。

シンプルで簡単

しかし、「シンプル」とは「簡単」という意味ではありません。 これらは異なる概念です。 このテーマで、Rich Hickey（Clojureの著者）は有名なレポートSimple Made Easyを作成しました 。 スライドの翻訳は Habr で公開されています。 シンプルさは客観的な概念です。 この複雑さの欠如（複雑さ）、織り込みの欠如、混乱、少数の接続。 一方、「簡単」は非常に主観的です。 自転車に乗ることは簡単ですか？ チェスの試合に勝ちますか？ ドイツ語を話す ドイツ語はわかりませんが、これは「この言語は必要ない、複雑すぎる」と言う理由ではありません。 それは私にとって難しいことであり、それでも私は単にそれを知らないからです。



私たちはすべて、関数呼び出しf(x, y)



呼び出しに慣れています。 私たちは、OOPのフレームワークでのプログラミングに慣れています。 これは当たり前です。 しかし実際、肺は必ずしも単純ではありません。 私たちは、あるものの複雑さに慣れ、それを無視し始め、当たり前だと思っています。 関数の例：

 (defn select "Returns a set of the elements for which pred is true" {:added "1.0"} [pred xset] (reduce (fn [sk] (if (pred k) s (disj sk))) xset xset))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

それは非常に... 奇妙に見えます！ 言語を習得し、その概念を習得して、言語を簡単にする必要があります。 しかし、単純さ（または複雑さ）は一定です。 ツールをよく調べれば、内部依存関係の数はとにかく変わりません。 私たちにとっては簡単ですが、より複雑でも単純でもありません。



使い慣れたツールを使用すると、すぐに最良の結果をすぐに得ることができますが、長期的には、最も単純なソリューションが最良の結果を示します。

副作用

プログラムの難しさの原因は何ですか？ それらの1つは副作用です。 それらなしでは完全に行うことはできませんが、ローカライズすることはできます。 そして、言語はこれに役立つはずです。



Clojureは関数型言語であり、純粋な関数を書くことを奨励しています。 このような関数の結果は、入力パラメーターのみに依存します。 「うーん、でも、この関数を呼び出す前にこれを起動するとどうなりますか」と頭を悩ます必要はありません。 入力がある場合は、週末があります。 関数を何度実行しても、結果は同じになります。 これにより、テストが非常に簡単になります。 呼び出しのさまざまな順序をソートしたり、正しい外部状態を再作成（シミュレーション）する必要はありません。



純粋な関数は分析が簡単で、文字通り「遊び」、ライブデータでの動作を確認できます。 デバッグしやすいコード。 関数の結果は以前に実行されたものに依存しないため、エラーを引き起こすパラメーターを渡すだけで、純粋な関数でいつでも問題を再現できます。 純粋な機能は、多くの作業を行う場合でも非常に簡単です。



もちろん、Clojureは高階関数、その構成をサポートしています。

 ((juxt dec inc) 1) ; => [0 2] ((comp str *) 1 2 3) ; => "6" (map (partial * 10) [1 2 3]) ; => [10 20 30] (map (comp inc inc) [1 2 3]) ; => [3 4 5]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Clojureは純粋な言語ではなく、関数には副作用があります。 たとえば、 println



は関数呼び出し、アクションです。 そのような機能の本質が外の世界との相互作用にあることが重要です。 ファイルに値を出力するには、HTTPリクエストを送信し、SQLを実行します。これらのアクションはすべて、それらが作成する副作用とは別に無意味です。 したがって、このような機能（クリーンとダーティ）を分離することは非常に便利です。



ただし、それら（ダーティ関数）には状態がありません。 それらは外の世界との相互作用の手段としてのみ機能します。 後で見るように、Clojureは間接リンクを使用してプログラムの状態を分離します。

免疫

Clojureのすべてのデータ構造は不変です。 ベクター要素を変更する方法はありません。 できることは、1つの要素が変更された新しいベクトルを作成することだけです。 非常に重要な点は、Clojureがすべての標準的な収集操作に対して（時間とメモリの点で）アルゴリズムの複雑さを保持していることです。 まあ、ほとんど、ベクトルのO（1）の代わりに、O（log ₃₂ （N））があります。 実際には、数百万の要素のコレクションでさえ、lg ₃₂ （N）は5を超えません。



この複雑さは、 永続的なコレクションを使用して実現されます。 構造が「変更」されると、古いバージョンと新しいバージョンが内部データのほとんどを共有するという考え方です。 同時に、古いバージョンは完全に機能し続けます。 さらに、構造のすべてのバージョンにアクセスできます。 これは重要なポイントです。 もちろん、不要なバージョンはガベージコレクターによって収集されます。

 (def a [1 2 3 4 5 6 7 8]) ; a -> [1 2 3 4 5 6 7 8] (def b (assoc a 3 999)) ;b -> [1 2 3 999 5 6 7 8]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

すぐに使えるClojureは、単一リンクリスト、ベクトル、ハッシュテーブル、赤黒木をサポートしています。 永続キューの実装があります（スタックにはリストまたはベクターを使用できます）。 そして、すべては不変です。 パフォーマンスを向上させるために、独自のレコードタイプを作成できます。

 (defrecord Color [red green blue]) (def a (Color. 0.5 0.6 0.7) ; a => {:red 0.5, :green 0.6, :blue 0.7}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここでは、3フィールド構造を宣言します。 Clojureコンパイラーは、5つのフィールド（2つの「追加」）を持つオブジェクトを作成します。 メタデータ用の1つのフィールド。この例ではnullです。 実際のデータ用の3つのフィールド。 そしてもう1つのフィールド-追加キー用。 プログラムの速度を上げるために、フィールドを明示的に列挙した構造体を宣言したとしても、Clojureはさらに値を追加する機会を残しています。

 (defrecord Color [red green blue]) (def b (assoc a :alpha 0.1)) ; b => {:alpha 0.1, :red 0.5 :green 0.6, :blue 0.7}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

はい、Clojureのデータ構造には特別な構文があります。

 ;  [1 2 3] ; - {:x 1, :y 2} ;  #{"a" "b" "c"}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

状態

したがって、純粋な関数があり、アプリケーションのビジネスロジックを決定します。 外部システム（ソケット、データベース、Webサーバー）での対話に使用されるダーティ関数があります。 そして、システムの内部状態があり、間接参照としてClojureに保存されます。



標準リンクには4つのタイプがあります。

• var
  
  
  
  コンテキストデータの設定に使用されるスレッドローカル変数の類似物。データベースへの現在の接続、現在のHTTP要求、数式の精度パラメーターなど。
• atom
  
  
  
  原子セル 。状態を同期的に更新できますが、調整はできません 。
• agent
  
  
  
  -アクターの軽量アナログ（ある意味では、それらは対掌体であり、以下でさらに詳しく説明します）、状態との非同期作業に役立ちます。
• ref
  
  
  
  トランザクションメモリのセル。状態を使用して同期および調整された作業を提供します。

すべてのグローバル変数はvar



（関数を含む）に保存されます。 したがって、「ローカル」に再定義できます。

 (def ^:dynamic *a* 1) (println a) ; => 1 (binding [a 42] (println a)) ; => 42
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここで、変数a



は動的でa



必要があることをコンパイラーに指摘しました。 ThreadLocal内に保存されます。 ThreadLocal



を使用するとパフォーマンスがわずかに低下するため、デフォルトではすべてのvar



セルに適用されるわけではありません。 ただし、必要に応じて、作成後に任意のvar



動的にすることができます（テストでよく使用されます）。



テストでは、関数全体を置き換えることができます。

 ;     ,   .. (defn some-function-with-side-effect [x] ...) ;       (defn another-function [x] ...) (deftest just-a-test ... (binding [some-function-with-side-effect (fn [x] ...)] ;  mock- (another-function 123)) ...)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Clojureのすべてのリンクは、 deref



（値の取得）操作をサポートしています。 var



セルの場合、次のようになります。

 ;   #'a (def a 123) (println a) ; => 123 (println #'a) ; => #'user/a (println (deref #'a)) ; => 123
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

セルは値（不変）を格納しますが、それ自体は独立したエンティティです。 deref



関数に特別な構文が導入deref



れました（はい、それはただの砂糖です）。 atom



の使用例を次に示します。

 (let [x (atom 0)] (println @x) ; => 0 (swap! x inc) ; CAS- (println @x)) ; => 1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

swap!



機能swap!



アトムと「変化」関数を取ります。 後者はアトムの現在の値を取得し、新しい値を返す必要があります。 ここでは、永続的なデータ構造が非常に便利です。 たとえば、100万個の要素のベクトルをアトムに格納できますが、「変更」関数はCASに十分な速さで実行されます（永続コレクションの操作の複雑さは、通常の変更可能なものと同じであることを覚えています）。 または、ハッシュテーブルのいくつかのフィールドを更新できます。

 (def user (atom {:login "theuser" :email "theuser@example.com"})) (swap! account assoc :phone "12345") ;    (swap! account (fn [x] (assoc x :phone "12345")))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

関数は数回実行できるため、関数がクリーンであることが重要です。 次のような記述はできません（すべきではありません！）。

 (swap! x (fn [x] (insert-new-record-to-db x) (inc x)))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

エージェント

エージェントは、副作用に直接関係する状態をサポートする役割を果たします。 アイデアはシンプルです。 セルがあり、関数のキューがそれに「接続」されています。 このセルに格納されている値に関数が1つずつ適用され、関数の結果が新しい値になります。 すべてが個別のスレッドプールで非同期的に計算されます。

 (def a (agent 0)) ;   (send a inc) (println @a) ; => 1 (send a (fn [x] (Thread/sleep 100) (inc x))) (println @a) ; => 1 ;  100  (println @a) ; => 2
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

エージェントは値を非同期に更新します。 ただし、エージェントの状態はいつでも確認できます。 エージェントは互いにメッセージを送信できます;送信するとき、送信エージェントがステータスを更新するまでメッセージは遅延します。 つまり、あるエージェントで例外がスローされた場合、そこから送信されたメッセージはどこにも送信されません。

 (def a (agent 0)) (def b (agent 0)) (send a (fn [x] (send b inc) ;    b (throw (Exception. "Error")))) (println @b) ; -> 0,     
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

俳優のモデルとのある類推は、 それ自体を示唆しています 。 これらは似ていますが、根本的な違いがあります。 エージェントの状態は明示的であり、いつでもderef



を呼び出してエージェントの値を取得できます。 これは、メッセージを送受信することで間接的にしか状態を知ることができないアクターの概念と矛盾しています。 俳優の場合、彼の状態にインタビューしたことを確信することさえできません。私たちは「偶然」それを変えないでしょう。 この意味で、エージェントは完全に信頼できます。その状態は、 send



およびsend-off



関数（メッセージが処理されるスレッドプールのみが異なる）でのみ変更できます。



2番目の重要な違いは、エージェントが機能を変更および追加できることです。 アクターの動作を変更する唯一の方法は、コードを書き直すことです。 エージェントは単なるリンクであり、独自の動作はありません。 新しい関数を作成して、エージェントキューに送信できます。



アクターは、プログラムの状態を、バラバラにしたり分離したりしやすい小さな部分に分割しようとしています。 ステータスの更新および読み取り操作は、メッセージの送信になります。 これは非常に便利な場合があります（たとえば、複数のノードでerlangプログラムを実行する場合）。 しかし、多くの場合、これは必要ありません。 時にはその逆です。 したがって、エージェントは、キャッシュ、セッション、数学的計算の中間結果など、フロー間を移動するために必要な大量の情報を保存すると便利です。



アクターについては、彼が応答できる多くのメッセージを修正します（彼は残りを誤っていると考えています）。 メッセージの順序も重要であり、潜在的に副作用がある可能性があります。 これは彼の公開契約です。 エージェントの場合、保存できるデータ、その構造のみを記録します。 エージェントがアクターを置き換えることをまったく試みていないことを強調することは非常に重要です。 これらは異なる概念であり、その範囲は異なります。



前述のように、エージェントは非同期に動作します。 イベントのチェーン（エージェントからエージェントへのメッセージの送信）を構築できます。 しかし、エージェントの助けだけでは、プログラムの状態を調整された方法で変更することはできません。

STM

ソフトウェアトランザクションメモリは、Clojureの主要な機能の1つです。 MVCCによって実装されます。 そしてすぐに例：

 (def account1 (ref 100) (def account2 (ref 0)) (dosync (alter account1 - 30) (alter account2 + 30))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

1つの値を増やし、同時に別の値を減らします。 何か問題が発生した場合（例外）、トランザクション全体がキャンセルされます。

 (println @account1) ; => 70 (println @account2) ; => 30 (dosync (alter account1 * 0) (alter account2 / 0)) ; => ArithmeticException ;    (println @account1) ; => 70 (println @account2) ; => 30
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

通常のACIDと非常に似ていますが、耐久性がありません。 トランザクションを入力すると、すべてのリンクがフリーズしているように見え、それらの値はトランザクション全体の期間中固定されます。 リンクの読み取り/書き込み時に、その値が既に変更されている（他のトランザクションが完了し、私たちの生活を台無しにしている）ことが判明した場合、現在のトランザクションが再開されます。 したがって、トランザクション内での副作用（入出力、アトムの操作）はありません。 そして、ここでエージェントが役に立ちます。

 (def a (ref 0)) (def b (ref 0)) (def out-agent (agent nil)) (dosync (println "transaction") (alter a inc) ;      (let [a-value @a b-value @b] (send-off out-agent (fn [_] (println "a" a-value "b" b-value)))) (alter b dec)) ;     
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

エージェントへのすべてのメッセージは、トランザクションが完了した瞬間に従います。 この例では、リンクa



とb



変更a



とトランザクションが再開される場合があり、「トランザクション」という単語を数回印刷できます。 ただし、エージェント内のコードは、トランザクションが完了した後に一度だけ実行されます。



さまざまなトランザクションが互いに干渉しないように、Clojureのリンクは値の履歴を保持します。 デフォルトでは、これは最後の値のみですが、競合が発生すると（1つのトランザクションの書き込みと他の読み取り）、特定のリンクに対して、保存された履歴のサイズが1つ（最大5つの値）増加します。 共通の構造要素を共有するリンクに永続構造を保存することを忘れないでください。 したがって、このようなストーリーをClojureに保存することは、メモリ消費の観点から非常に安価です。



STMトランザクションは、コードを変更するときに気にしません。 現在のトランザクションで1つまたは別のリンクを使用できるかどうかを分析する必要はありません。 それらはすべて利用可能であり、既存のコードに完全に透過的に新しいリンクを追加できます。 リンクは相互に作用しません。 たとえば、通常のロックを使用する場合、デッドロックが発生しないようにロック/ロック解除の順序を監視する必要があります。



同時アクセスでは、 ReadWriteLockを使用するのと同じように、リーダートランザクションは互いにブロックしません。 さらに、トランザクションライターはリーダーをブロックしません！ リンクを変更するトランザクションが現在実行されている場合でも、ブロックせずに値を取得できます。



エージェントとSTMリンクは互いに補完します。 前者は調整された状態の変化には適していませんが、後者は副作用を扱うことはできません。 しかし、それらの共同使用により、「古典的な」ツール（ミューテックス、セマフォなど）を使用するよりも、プログラムがより透明で単純（複雑ではない）になります。

メタプログラミング

現在、多くの言語に何らかのメタプログラミングツールがあります。 これらは、Java用のAspectJ 、Groovy用のAST変換、Python用のデコレーターとメタクラス、さまざまなリフレクションです。



Clojureは、Lispファミリーのメンバーとして、これらの目的でマクロを使用します。彼らの助けを借りて、言語自体を使って言語をプログラム（拡張）できます。マクロは「通常の」関数ですが、唯一の違いはプログラムのコンパイル中に実行されることです。まだコンパイルされたコードはマクロ入力に渡されません。マクロの実行結果は、コンパイラが既にコンパイルした新しいコードです。

 (defmacro unless [pred ab] `(if (not ~pred) ~a ~b)) (unless (> 1 10) (println "1 > 10. ok") (println "1 < 10. wat"))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

独自の制御構造（逆バージョンif



）を作成しました。あなたがする必要があるのは、関数を書くことです！



マクロはClojureで広く使用されています。ところで、言語に組み込まれている演算子の多くは、実際にはマクロです。たとえば、以下は実装or



です。

 (defmacro or ([] nil) ([x] x) ([x & next] `(let [or# ~x] (if or# or# (or ~@next)))))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

でもdefn



ただマクロに展開def



してfn



。ちなみに、構造化もマクロを使用して実装されます。

 (let [[ab] [1 2]] (+ ab)) ;   - ... (let* [vec__123 [1 2] a (clojure.core/nth vec__123 0 nil) b (clojure.core/nth vec__123 1 nil)] (+ ab))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

最近、try-with-resourcesが Javaに登場しました。同時に、Javaの第7バージョンが登場するのをほんの数年待ちました。Clojureの場合は、数行書くだけです。

 (defmacro with-open [[vr] & body] `(let [~r ~v] (try ~@body (finally (.close ~v)))))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

他の言語では、状況は良くなりますが、それでも理想からはほど遠いです。重要なことは、言語に特定の構造が存在することではなく、独自の構造を追加する能力です。したがって、たとえば、Clojureのパターンマッチングが個別のプラグインライブラリとして実装されていることは驚くことではありません。そのようなものを言語のコアに含める必要はまったくありません。それらをマクロの形で実装する方がはるかに便利です。状況は、モナドのサポート、論理プログラミング、高度なエラー処理、およびその他の言語拡張と同様です。オプションの静的型付けもあります！



DSLを作成することの利便性に言及するしかありません。 Clojureにはたくさんあります。これとHTML生成およびHTTP-要求のルーティングとはで動作するリレーショナル データベースの データ、及びでの作業バイナリプロトコルと検証データ（この場合は、あなたが停止する際に知っておく必要がありますが）...簡単かつ効果的に作成します。



Clojure（すべてのLispライクな言語と同様）には非常に重要な機能があります-それは同種ユニークです。言い換えると、プログラムのソースコード用に別のプレゼンテーションを作成する必要はありません。余分なプレゼンテーションを作成する必要はありません。いくつかの追加のASTツリーの形での抽象化のレベル、プログラムはこのツリーです。さらに、このツリーは特別な構造ではなく、通常のリスト、ベクトル、およびシンボルです。そして、通常のデータと同じ方法でプログラムを操作できます。

 (defn do2 [x] (list 'do xx)) (do2 '(println 1)) ; => '(do (println 1) (println 1)) ;   ; => (list 'do (list 'println 1) (list 'println 1))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Clojureのマクロは、その力のすべてについて、プログラムの可読性を損ないません（もちろん、適度に使用する場合を除きます）。結局のところ、マクロは単なる関数であり、現在のコンテキストでどの関数を使用するかを常に一意に決定できます。たとえば、コードを見ると、(dosomething [ab] c)



名前の後ろに隠れているものを見つけるのは簡単dosomething



です。ファイルの先頭（他のモジュールがインポートされている場所）を見るだけです。これがマクロの場合、そのセマンティクスは一定であり、よく知られています。このコードを理解するのに高度なIDEは必要ありません。もちろん、高度な開発環境ではマクロを適切に「展開」することができます。これにより、コンパイラーがプログラムをどのように変えるかを確認できます。

多型

Clojureには、ポリモーフィック関数を作成するための2つのメカニズムがあります。当初、この言語は強力なツールであるマルチメソッドのみをサポートしていましたが、ほとんどの場合は過剰でした。バージョン1.2（およびバージョン1.5.1が現在関連）から、新しい概念が言語に追加されました-プロトコル。



プロトコルはJavaインターフェースに似ていますが、互いに継承することはできません。各プロトコルには、一連の機能が記述されています。

 (defprotocol IShowable (show [this])) ; ... (map show [1 2 3])
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これにより、プロトコル自体と関数の2つのエンティティを宣言しますshow



。これは通常のClojure関数で、呼び出されると、最初の引数の型に基づいて最も適切な実装を検索します。別途、必要なデータ構造を宣言し、それらにプロトコルの実装を示します。

 (defrecord Color [red green blue] IShowable (show [this] (str "<R" (:red this) " G" (:green this) " B" (:blue this))))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

サードパーティタイプのプロトコルを実装できます（ビルトインであっても）。

 (extend-protocol IShowable String (show [this] (str "string " this)) clojure.lang.IPersistentVector (show [this] (str "vector " this)) Object (show [this] "WAT")) (show "123") ; => "string 123" (show [1 2 3]) ; => "vector [1 2 3]" (show '(1 2 3)) ; => "WAT"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ソースコードにアクセスできない場合でも、既存のタイプにプロトコル実装を追加できます。バイトコードまたは同様のトリックによる魔法の操作はありません。 Clojureはグローバルテーブルを作成します ->



。プロトコルメソッドが呼び出されると、階層を考慮して、このテーブルで最初の引数のタイプによって検索されます。したがって、プロトコルの新しい実装の宣言は、グローバルテーブルの更新に帰着します。



ただし、プロトコルでは不十分な場合があります。たとえば、二重スケジューリングの場合。この場合（だけでなく）、マルチメソッドが便利になります。。マルチメソッドを宣言するとき、特別なサイド関数ディスパッチャーを指定します。ディスパッチャーは、マルチメソッドと同じ引数を受け取ります。最終実装の検索は、ディスパッチャによって返された値によって既に実行されています。タイプ、キーワード、またはベクトルを指定できます。ベクトルの場合、いくつかの値を使用して最適な実装を検索します。

 (defmulti convert (fn [obj target-type] [(class obj) target-type])) (defmethod convert [String Integer] [x _] (Integer/parseInt x)) (defmethod convert [String Long] [x _] (Long/parseLong x)) (defmethod convert [Object String] [x _] (.toString x)) (defmethod convert [java.util.List String] [x _] (str "V" (vec x))) (convert "123" Integer) ; -> 123 (convert "123" Long) ; -> 123 (convert 123 String) ; -> "123" (convert [1 2 3] String) ; -> "V[1 2 3]"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここで、最初の引数の型と2番目の引数の値（これはクラスでなければなりません）に基づいて実装が選択される抽象関数を発表しました。もちろん、Clojureは適切な実装を探す際に型階層を考慮します。タイプは使いやすいですが、階層は厳密に固定されています。ただし、キーワードから独自のアドホック階層を作成できます。

 ;   "-" (derive ::rect ::shape) (derive ::square ::rect) (derive ::circle ::shape) (derive ::triangle ::shape) (defmulti perimeter :type) ;       ,  :type ~ (fn [x] (:type x)) (defmethod perimeter ::rect [x] (* 2 (+ (:hx) (:wx)))) (defmethod perimeter ::triangle [x] (reduce + ((juxt :a :b :c) x))) (defmethod perimeter ::circle [x] (* 2 Math/PI (:rx))) (perimeter {:type ::rect, :h 10, :w 3}) ; -> 26 (perimeter {:type ::square, :h 10, :w 10}) ; -> 40 (perimeter {:type ::triangle, :a 3, :b 4, :c 5}) ; -> 12 (perimeter {:type ::shape}) ; -> throws IllegalArgumentException
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

複数の階層を宣言できます。型と同様に、複数の値を一度にディスパッチできます（ベクター）。独自の階層を定義する場合、キーワードとJavaタイプを混在させることもできます！

 (derive java.util.Map ::collection) (derive java.util.Collection ::collection) (derive ::tag .java.lang.Iterable) ; -> ClassCastException
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

キーワードから型を「継承」できます（逆も同様です）。これは、拡張が可能なクラスグループを作成するのに便利です。



マルチメソッドシステムはシンプルですが、非常に強力です。通常、日常的なニーズにはプロトコルの機能で十分ですが、複雑な非標準の状況ではマルチメソッドが優れたソリューションになります。

常識

言語は、インフラストラクチャなしでは意味がありません。コミュニティ、ライブラリ、フレームワーク、さまざまなユーティリティのセットなし。 Clojureの強みの1つは、JVMプラットフォームの使用です。 Javaとの統合（双方向）は非常に簡単です。 Javaには膨大な数のライブラリが存在することは秘密ではありません（その品質については説明しません）。それらはすべてClojureから直接使用できます。ただし、ネイティブライブラリの数は非常に多く（常に増加しています）います。EclipseとIDEAの



プラグインは活発に開発されています。プロジェクトを構築するために、コミュニティ全体で使用されているラインニングユーティリティは、長い間事実上の標準でした。作成するためのさまざまなフレームワークがあります WEBアプリケーションと非同期サーバー： 不変の



アプリケーションサーバーが開発されています（JBoss AS7のラッパー）。 Immutantは、リング（ClojureのHTTPスタック）、非同期メッセージ、分散キャッシュ、スケジュールされたタスク、分散トランザクション、クラスタリングなどを操作するためのインターフェースを提供します。 Immutantの展開と構成は非常に簡単です。



Clojureには、.Net CLRの下のポートなどの代替実装もあります。しかし、真実は言われます、ClojureScriptは最も注目に値する、JavaScript用のポート。もちろん、マルチスレッドツールはありません。そのため、トランザクションメモリとエージェントがあります。ただし、永続構造、マクロ、プロトコル、マルチメソッドなど、他のすべての言語機能を使用できます。また、ClojureScriptとJavaScriptの統合は、ClojureとJavaの統合と同じくらい優れており、単純です（場所によってはさらに優れています）。

次は？

そして、すべてが簡単です。ツールがあります。労働者、信頼できる。特効薬ではありませんが、十分な汎用性があります。シンプル。はい、あなたはそれを習得するためにいくつかの時間を費やす必要があるかもしれません。多くは珍しくて奇妙に見えるかもしれません。しかし、これは習慣の問題にすぎません。言語の全体の美しさは、個々の要素が単一の全体に繊細に結合しているという有機性にあることにすぐに気付くでしょう。



Clojureを知ることは価値があります。間違いなく。 このツールが何らかの理由であなたに合わない場合でも、そこに組み込まれているアイデアは非常に有用であることが証明されます。