結合パターン

結合パターンは、メッセージ パッシングによって同時実行、並列実行、分散実行のコンピュータ プログラムを作成する方法を提供します。スレッドやロックの使用と比較すると、これは通信構造モデルを使用して同時実行環境の複雑さを抽象化し、スケーラビリティを実現する高レベルのプログラミング モデルです。その焦点は、チャネルのグループからアトミックに消費されるメッセージ間の コードの実行にあります。

このテンプレートは結合計算に基づいており、パターン マッチングを使用します。具体的には、同時呼び出しとメッセージ パターンを一致させることにより、複数の関数やチャネルの結合定義を許可することでこれを実現します。これは、これらのエンティティが通信し、マルチスレッド プログラミング パラダイムを処理することをより簡単かつ柔軟にするため、並行性パターンの一種です。

結合パターン（またはCωのコード）は、同期とマッチングを備えたスーパーパイプラインのようなものです。実際、この概念は、異なるメッセージキューから利用可能な一連のメッセージを一致させて結合し、それらをすべて1つのハンドラーで同時に処理することによって要約されます。[ ^1]whenこれは、予想される最初の通信を指定するキーワード、and他のチャネルを結合/ペアにするキーワード、およびdo収集されたさまざまなメッセージを使用していくつかのタスクを実行するキーワードによって表すことができます。構築された結合パターンは通常、次の形式になります。

j.(a1).そして(a2). ... .そして(an).Do(d)

の引数a1When(a1)は同期チャネルまたは非同期チャネル、あるいは非同期チャネルの配列である。 の後続の各引数ai（の場合）は非同期チャネルでなければならない。^[2]And(ai)i > 1

より正確には、メッセージがリンクされたパターンのチェーンと一致すると、そのハンドラが実行されます（非同期コンテキストの場合は新しいスレッドで実行されます）。それ以外の場合は、パターンの1つが有効になるまでメッセージはキューに入れられます。複数のパターンが一致する場合は、指定されていないパターンが選択されます。^[3]

イベントハンドラは、そのイベントの他のすべてのハンドラと組み合わせて、一度に複数の代替イベントの1つを処理しますが、結合パターンはチャネルの結合を待機し、他の有効なパターンと実行を競合します。^[4]

結合パターンは、送信と受信という2つの異なる操作をサポートするπ計算チャネルxのセットによって定義されます。これを実装するには、送信（メッセージ）用のチャネル名xと値（リクエスト）を受信するための関数名xの2つの結合計算名が必要です。結合定義の意味は、への呼び出しがチャネルに送信された値を返すことです。関数が同時に実行されるたびに、戻りプロセスがトリガーされ、他の結合と同期されます。^[5]x()x<>

J ::= //結合パターン| x < y > //メッセージ送信パターン| x ( y ) //関数呼び出しパターン| J | JBIS //同期  
  
  
    

クライアントの観点から見ると、チャネルは同じ名前とシグネチャのメソッドを宣言するだけです。クライアントは、チャネルをメソッドとして呼び出すことで、メッセージを投稿したり、リクエストを発行したりします。継続メソッドは、継続の When 句に続く各チャネルに単一のリクエストまたはメッセージが到着するまで待機する必要があります。継続が実行される場合、各チャネル呼び出しの引数はキューから取り出され (したがって消費され)、継続のパラメータに (アトミックに) 転送されます。^[6]

ほとんどの場合、パフォーマンス上の理由から、同期呼び出しの順序は保証されません。最後に、試合中にキュー内のメッセージが介入スレッドによって盗まれる可能性があります。実際、起動されたスレッドは再び待機しなければならない場合があります。^[7]

π計算はプロセス計算のファミリーに属し、チャネル名をチャネル自体に沿って通信することで並行計算の特性を記述および分析するための数学的形式論を可能にし、このようにして、計算中にネットワーク構成が変化する可能性がある並行計算を記述することができます。

結合パターンは、分散環境での効率的な実装のために設計された非同期プロセス代数である、Fournet と Gonthier の基礎的な結合計算で初めて登場しました。^[8]結合計算は、完全なπ 計算と同じくらい表現力豊かなプロセス計算です。分散プログラミング言語の設計の正式な基礎を提供するために開発されたため、ランデブー通信などの他のプロセス計算に見られる通信構造を意図的に避けています。

Join計算は、名前渡し計算であると同時に、並行および分散プログラミングのコア言語でもあります。^[9]そのため、分散プログラミングを備えたJoin計算に基づく分散Join計算^[10]が1996年に作成されました。この研究では、エージェントがプログラムであるだけでなく、通信機能を備えた実行中のプロセスのコアイメージであるモバイルエージェントを使用します。

JoCaml ^{[11] [12]}とFunnel ^{[13] [14]}は宣言的結合パターンをサポートする関数型言語である。これらは関数型の設定でプロセス計算を直接実装するためのアイデアを提示している。

Javaの別の拡張であるJoinJavaは、von ItzsteinとKearneyによって独立して提案されました。^[15]

Cardelli、Benton、Fournetは、C#用の結合パターンのオブジェクト指向バージョンであるPolyphonic C#を提案した。^[16]

Cωは結合計算をオブジェクト指向の設定に適応させたものです。^[17]このポリフォニックC#の変種は、2004年にCω（別名Comega）の公開リリースに含まれていました。

Scala Joinsは、拡張可能なパターンマッチングのコンテキストでScalaのJoin-Patternを使用し、既存のアクターベースの並行性フレームワークに結合を統合するためのライブラリです。^[18]

Erlang は、並行性、リアルタイム性、分散性をネイティブにサポートする言語です。プロセス間の並行性は複雑であったため、このプロジェクトでは Join 計算に基づいた新しい言語 JErlang ( J はJoinの略) を構築しました。

「結合パターンは、アクターやアクティブオブジェクトなどの関連する並行性のイディオムを簡単にエンコードするために使用できます。」^[19]

• 障壁^[20]

クラスSymmetricBarrier { public readonly Synchronous . Channel Arrive ; 

       

    public SymmetricBarrier ( int n ) { // j を作成し、チャネルを初期化します (省略) var pat = j . When ( Arrive ); for ( int i = 1 ; i < n ; i ++ ) pat = pat . And ( Arrive ); pat . Do (() => { }); } }  
    
        
           
                
              
           
    

• 食事哲学者問題^[21]

var j = Join.Create ( ) ;同期.Channel [ ] hungry ;非同期.Channel [ ] chopstick ; j.Init ( out hungry , n ) ; j.Init ( out choice , n ) ;​​   
 
 
  
  

for ( int i = 0 ; i < n ; i ++ ) { var left = choice [ i ]; var right = choice [( i + 1 ) % n ]; j . when ( hungry [ i ]). And ( left ). And ( right ). Do (() => { eat (); left (); right (); // 箸を交換する}); }        

       
         
      
        
        
         
    

• 相互排除^[22]

クラスLock { public readonly Synchronous.Channel Acquire ; public readonly Asynchronous.Channel Release ;​​​​ 

       
       

    public Lock () { // j を作成し、チャネルを初期化します (省略) j . When ( Acquire ). And ( Release ). Do (() => { }); Release (); // 最初は解放されています} } 
    
        
           
         
    

• 生産者/消費者^[23]

クラスBuffer < T > { public readonly Asynchronous . Channel < T > Put ; public readonly Synchronous < T > . Channel Get ; 

       
       

    public Buffer () { Join j = Join.Create ( ); // Joinオブジェクトを割り当てますj.Init ( out Put ) ; //チャネルをバインドしますj.Init ( out Get ) ; j.When ( Get ) .And ( Put ) .Do // chord ( t => { return t ; }); } } 
    
            
         
        
         
         
             
    

• リーダーライターロック^[20]

クラスReaderWriterLock { private readonly Asynchronous.Channel idole ; private readonly Asynchronous.Channel < int > shared ; public readonly Synchronous.Channel AcqR 、AcqW 、RelR 、RelW ;​​​​​​ 

       
       
          

    public ReaderWriterLock () { // j を作成し、チャネルを初期化します (省略) j . When ( AcqR ). And ( idol ). Do (() => shared ( 1 )); j . When ( AcqR ). And ( shared ) . Do ( n => shared ( n + 1 )); j . When ( RelR ). And ( shared ). Do ( n => { if ( n == 1 ) { idol (); } else { shared ( n - 1 ); } }); j . When ( AcqW ). And ( idol ). Do (() => { }); j . When ( RelW ). Do (() => idol ()); idol (); // 最初は解放されています} } 
    
        
          
          
          
               
            
                
            
            
            
                
            
        
           
          
         
    

• セマフォ^[22]

クラスSemaphore { public readonly Synchronous.Channel Acquire ; public readonly Asynchronous.Channel Release ;​​​​ 

       
       

    public Semaphore ( int n ) { // j を作成し、チャネルを初期化します (省略) j . When ( Acquire ). And ( Release ). Do (() => { }); for (; n > 0 ; n -- ) Release (); // 最初は n が空いています} }  
    
        
           
             
             
    

• Join 計算 : Join パターンの最初の出現は、このプロセス計算で現れます。
• メッセージ パッシング : Join パターンは、並列処理のためにメッセージ パッシング システムと連携して動作します。
• チャネル : チャネルは、同時に実行されるスレッド間で同期してメッセージを渡すために使用されます。一般に、チャネルは複数の結合パターンに関係する可能性があり、各パターンはチャネルが呼び出されたときに実行される可能性のある異なる継続を定義します。^[6]
• 同期 : 結合パターンは結果を返す同期チャネルを使用できます。同期パターンの継続は同期送信者のスレッドで実行されます。^[6]
• 非同期 : 結果を返さずに引数を受け取る非同期チャネルを使用することもできます。非同期パターンの継続は、新しく生成されたスレッドで実行されます。結合パターンは、その継続がサブルーチンであり、When 句が非同期チャネルのみをリストしている場合、完全に非同期にすることができます。^[6]
• 同期と非同期を組み合わせる：同期バッファと非同期バッファの宣言をマージすると、2つの通信タイプのコンシューマをサポートするモジュールが生成されます。^[6]
• スケジューラ : 結合パターン間のスケジューリングがあります（例：ラウンドロビンスケジューラ、ファーストマッチスケジューラ）。^[6]
• デザイン パターン : 結合パターンは、まず第一に動作と並行性のパターンです。
• 並行プログラミング : 並行して実行されます。
• パターン マッチング : 結合パターンは、一致するタスクで機能します。
• 並列プログラミング : タスクを並列に実行します。
• 分散プログラミング : このパターンを使用すると、ジョブをさまざまなエージェントや環境に分散させることができます。
• ソフトウェア トランザクション メモリ : ソフトウェア トランザクション メモリ (STM) は、ジョイント間の通信の可能な実装の 1 つです。
• 重複 : パターンは、重複するチャネル セットで宣言されたパターンを許可できます。

モバイル エージェントは、一定の社会的能力と、最も重要なモビリティを備えた自律的なソフトウェア エージェントです。実行を継続しながら、異なるコンピューター間を自動的に移動できるコンピューター ソフトウェアとデータで構成されています。

移動エージェントは、Join 計算を使用すれば、並行性と分散性を一致させるために使用できます。そのため、「分散型 Join 計算」という新しい概念が生まれました。これは、移動性を記述するための場所とプリミティブを備えた Join 計算の拡張です。この革新は、エージェントを通信機能を備えた実行中のプロセスとして使用し、エージェントの実際の位置を表す物理的な場所の概念を可能にします。Join 計算のおかげで、1 つの場所を別の場所にアトミックに移動できます。^[24]

エージェントのプロセスは、メッセージの非同期送信、他の場所への移動などの機能を定義するセットとして指定されます。その結果、エージェントの動きをより簡単に表すために、場所はツリーに編成されます。この表現により、このソリューションの利点は、障害の単純なモデルを作成できることです。通常、物理サイトのクラッシュは、そのすべての場所で永続的な障害を引き起こします。しかし、結合計算を使用すると、場所の問題を他の実行中の場所で検出できるため、エラー回復が可能になります。^[24]

したがって、Join 計算は分散プログラミング言語の中核です。特に、操作的意味論は、障害のある分散設定で簡単に実装できます。したがって、分散 Join 計算は、チャネル名と場所名を語彙スコープを持つ第一級の値として扱います。場所は自身の移動を制御し、名前を受け取った場所に向かってのみ移動できます。これは、静的分析と安全なモビリティの堅実な基盤を提供します。これは、分散構成を表現するのに最適です。ただし、障害がない場合、プロセスの実行は分散とは無関係です。この場所の透明性は、モバイル エージェントの設計に不可欠であり、そのプロパティを確認するのに非常に役立ちます。^[24]

2007年には、エージェントをプロアクティブにする手法を備えた基本的な結合計算の拡張が登場しました。エージェントは、エージェント間で共有される環境を観察できます。この環境により、すべてのエージェントと共有変数を定義することができます（たとえば、エージェント同士でエージェントを発見するための命名サービスなど）。^[25]

結合言語は、結合計算をコア言語として構築されています。そのため、すべての計算は非同期プロセスで分析され、結合パターンは結果を同期するためのモデルを提供します。^[9]
これを実現するために、2つのコンパイラが存在します。

• Join コンパイラ: 「join langage」という言語のコンパイラ。この言語は、join 計算専用に作成されました。
• Jocaml コンパイラー(Wayback Machineで 2005-10-01 にアーカイブ済み) : 結合計算を使用するために作成された Objectif Caml の拡張機能のコンパイラー。

この 2 つのコンパイラは、同じシステム、つまりオートマトンで動作します。

A(n) | B() = P(n)とします。
そしてA(n) | C() = Q(n)
;;

これは、完了した結合モデルに到着したメッセージの消費を表します。各状態はコード実行の可能なステップであり、各遷移は 2 つのステップ間で切り替えるためのメッセージの受信です。したがって、すべてのメッセージが取得されると、コンパイラは完了したモデル結合に対応する本体結合コードを実行します。

したがって、結合計算では、基本的な値は例の A、B、または C のような名前です。したがって、2 つのコンパイラーは、この値を 2 つの方法で表します。
結合コンパイラーは、2 つのスロットを持つベクトルを使用します。1 つ目は名前自体、2 つ目は保留中のメッセージのキューです。Jocaml
は、名前を定義のポインターのように使用します。この定義は、ステータス フィールドとメッセージによる一致する日付構造を持つ他の名前の他のポインターを格納します。
基本的な違いは、ガード プロセスが実行されるとき、最初の場合はすべての名前が保留中のメッセージの準備ができているかどうかを確認するのに対し、2 番目は 1 つの変数のみを使用して他の変数にアクセスし、モデルが完了したかどうかを確認します。^[9]

最近の研究では、コンパイル方式は、ディスパッチと転送という 2 つの基本ステップの組み合わせであると説明されています。ディスパッチャの設計と正確さは、基本的にパターン マッチング理論に由来していますが、通信に内部転送ステップを挿入することは自然なアイデアであり、直感的にプロセスの動作は変わりません。彼らは、拡張された結合パターン マッチングをランタイム レベルで直接実装すると、メッセージ キューの管理が大幅に複雑になり、メッセージを消費する前に一致するメッセージを探すためにスキャンする必要があるという点に注目する価値があると述べました。^[26]

Joinパターンは、さまざまな言語で使用されています。Polyphonic C#やMC#などの言語では、実装のベースとしてJoinパターンを使用していますが、 ScalaのScala Joins ^[27]やVBのJoinsライブラリなどのライブラリによってJoinパターンを統合している言語もあります。^{[28]さらに、Joinパターンは、} Schemeなどの言語を通じてJoinパターンをアップグレードするために使用されます。 ^[29]

Join Java ^[30]は、 Javaプログラミング言語をベースにした言語で、結合計算を使用することができます。3つの新しい言語構造を導入しています。

• Join メソッドは、2 つ以上の Join フラグメントによって定義されます。Join メソッドは、Join パターンのすべてのフラグメントが呼び出されると実行されます。戻り値の型が標準の Java 型の場合、先頭のフラグメントは、Join パターンが完了してメソッドが実行されるまで呼び出し元をブロックします。戻り値の型がシグナル型の場合、先頭のフラグメントはすぐに戻ります。末尾のフラグメントはすべて非同期であるため、呼び出し元をブロックしません。

例：

class  JoinExample { intfragment1 () & fragment2 ( int x ) { // xの値をfragment1の呼び出し元に返しますreturn x ; } } 
         
        
         
    

• 非同期メソッドは、シグナル戻り型を使用して定義されます。これは、メソッドがすぐに戻る点を除いて、void 型と同じ特性を持ちます。非同期メソッドが呼び出されると、メソッドの本体を実行するために新しいスレッドが作成されます。

例：

class  ThreadExample { signal thread ( SomeObject x ) { // このコードは新しいスレッドで実行されます} } 
       
        
    

• 順序修飾子

Join フラグメントは複数の Join パターンで繰り返すことができるため、フラグメントが呼び出されたときに複数の Join パターンが完了する場合があります。このようなケースは、以下の例で B()、C()、D() の後に A() が呼び出された場合に発生する可能性があります。最後の A() フラグメントは 3 つのパターンを完了するため、呼び出される可能性のあるメソッドは 3 つあります。ここでは、ordered クラス修飾子を使用して、どの Join メソッドが呼び出されるかを決定します。デフォルトでは、unordered クラス修飾子を使用する場合は、メソッドの 1 つがランダムに選択されます。ordered 修飾子を使用すると、メソッドは宣言された順序に従って優先順位が付けられます。

例：

クラスは SimpleJoinPatternを順序付けしました{ void A () & B () { } void A () & C () { } void A () & D () { } signal D () & E () { } }  
        
    
        
    
        
    
        
    

最も近い関連言語はPolyphonic C#です。

Erlangでは、複数のプロセス間の同期をコーディングするのは簡単ではありません。そのため、Erlangの拡張であるJErlang ^{[31]が作成されました。JはJoinの略です。実際、この制限を克服するために、} Join-Calculusに触発されたErlangの拡張であるJErlangが実装されました。この言語の特徴は次のとおりです。

• 結合により、最初の一致セマンティクスが可能になり、メッセージの順序を維持しながら複数のパターンを持つ可能性が生まれます。

操作() ->受信{ ok , sum }と{ val , X }と{ val , Y } -> { sum , X + Y }; { ok , mult }と{ val , X }と{ val , Y } -> { mult , X * Y }; { ok , sub }と{ val , X }と{ val , Y } -> { sub , X - Y };終了終了 
    
                
               
                
               
                
               
    

• ガードはパターンで表現しない追加のフィルタリングを提供します。副作用のない表現の数は限られています

( Lower <= MかつM <= Upper )の場合、{ Transaction , M }および{ limit , Lower , Upper }を受け取ります-> commit_transaction ( M , Transaction )終了         
                 
     

• 非線形パターンでは、メッセージは複数の結合に一致する可能性がある

{ get , X }と{ set , X } -> { found , 2 , X }を受け取ります... { Pin , id }と{ auth , Pin }と{ commit , Id }を受け取ります-> perform_transaction ( Pin , Id )を受け取ります         
          



            
         

• 伝播により、正しいメッセージを削除するのではなくコピーできるようになります。

prop ({ session , Id })と{ act , Action , Id }を受け取ります-> perform_action ( Action , Id ); { session , Id }と{ logout , Id } -> logout_user ( Id )を受け取ります... { Pin , id }と{ auth , Pin }と{ commit , Id }を受け取ります-> perform_transaction ( Pin , Id )を受け取ります          
         
         
        



            
         

• 同期呼び出し

受信
{ accept , Pid1 }および{非同期, Value }および{ accept , Pid2 } -> Pid1 ! { ok , Value }、Pid2 ! { ok , Value }終了        
                      
           
           

Yigong Liu は、非同期および同期チャネル、コードなどの便利なツールをすべて含む結合パターン用のクラスをいくつか作成しました。これは Boost c++ プロジェクトに統合されています。

テンプレート< typename V >クラスbuffer : public join { public : async < V > put ; synch < V , void > get ; buffer () { chord ( get , put , & buffer :: chord_body ); } V chord_body ( void_t g , V p ) { return p ; } };  
    

   
   
   
      
  
       
     
  

この例では、基本的な操作putとgetを備えたスレッドセーフなバッファとメッセージキューを示しています。^[32]

Polyphonic C# は、 C# プログラミング言語の拡張機能です。同期および非同期 (呼び出し元に制御を返す) メソッドとコード (「同期パターン」または「結合パターン」とも呼ばれる) を備えた新しい並行性モデルを導入します。

パブリッククラスBuffer { public String get () & public async put ( String s ) { return s ; } }  

           
    
         
    

これは単純なバッファの例です。^[33]

MC# は、 Wayback Machine言語で 2011-09-10 にアーカイブされてお​​り、同時分散計算向けに Polyphonic C# 言語を改良したものです。

パブリックハンドラーGet2 long () &チャネルc1 ( long x ) &チャネルc2 ( long y ) { return ( x + y ); }         
    

       

この例では、コードを同期ツールとして使用する方法を示します。

Parallel C# は Polyphonic C# をベースとしており、移動可能なメソッドや高階関数などの新しい概念がいくつか追加されています。

システムの使用; 

クラスTest13 { int Receive () & async Send ( int x ) { return x * x ; } 

         
    
           
    

    パブリック静的void Main ( string [ ] args ) { Test13t = new Test13 ( ) ; t.Send ( 2 ) ; Console.WriteLine ( t.Receive ( ) ) ; } }    
    
            
        
        
    

この例では結合の使い方を示しています。^[34]

Cωは、並行プログラミングをサポートする新しい言語機能を追加します（以前のPolyphonic C#に基づいています）。C#およびその他の.NET言語用のJoins並行性ライブラリはこのプロジェクトから派生しています。^{[35] [36]}

これは、宣言型でスケーラブルな、使いやすい結合パターンライブラリです。Russoライブラリ^[28]とは対照的に、グローバルロックはありません。実際、比較とスワップのCASとアトミックメッセージシステムで動作します。ライブラリ^[37]は、結合パターンに3つの改良を加えています。

• 未使用のリソースに対するメッセージの盗難（割り込みを許可する）
• レイジーキューは、楽観的な高速パスによる割り当てまたはエンキューを回避することで、割り当てと潜在的にプロセッサ間通信の両方を節約します。
• ステータス「WOKEN」: ブロックされた同期呼び出し元が 1 回だけ起動されることを保証します。

JoCamlは、joinパターンが実装された最初の言語です。実際、当初はさまざまな実装がすべてJoCamlコンパイラでコンパイルされていました。JoCaml言語はOCaml言語の拡張です。並行性と同期、プログラムの分散実行、実行中のアクティブなプログラムフラグメントの動的な再配置をサポートすることでOCamlを拡張しています。^[38]

タイプ コイン =  Nickel  |  Dime 
、 ドリンク =  Coffee  |  Tea 
、 ボタン =  BCoffee  |  BTea  |  BCancel ;;

(* def は Join パターン セット句を定義します
* = の左側の "&" は join (チャネル同期) を意味します
* 右側の "&" は並列プロセスを意味します
* synchronized_reply :== "reply" [x] "to" channel_name 
* 同期チャネルには関数のような型があります (`a -> `b) 
* 非同期チャネルには型があります (`a Join.chan) 
* パターンの rhs 式の最後のステートメントのみが非同期メッセージになることができます
* 非同期メッセージ位置の 0 は STOP (CSP 用語では "送信メッセージなし") を意味します。
   *)

def  put ( s )  =  print_endline  s  ;  0  (* STOP *) 
  ;;  (* put: string Join.chan *)

def  serve ( drink )  =  drink をCoffeeと一致させる -> put ( "Cofee" ) | Tea -> put ( "Tea" ) ;; (* serve: drink Join.chan *) 
                   
                    
               

def  reply ( v )  =  let  s  =  Printf . sprintf  "Refund %d"  v  in  put ( s ) 
    ;;  (* reply: int Join.chan *)

let  new_vending  serve  fund  = 
  let  vend  ( cost : int )  ( credit : int )  =  if  credit  >=  cost 
                      then  ( true ,  credit  -  cost ) 
                      else  ( false ,  credit ) 
  in 
  def  coin ( Nickel )  &  value ( v )  =  value ( v + 5 )  &  reply  ()  to  coin
  または coin ( Dime )  &  value ( v )  =  value ( v + 10 )  &  reply  ()  to  coin

  または、 button ( BCoffee )  &  value ( v )  =  
     let  should_serve 、 remainder  =  vend  10  v  in 
     ( if  should_serve  then  serve ( Coffee )  else  0  (* STOP *) ) 
             &  value ( remainder )  &  reply  ()  to  button

  または、 ボタン( BTea )  &  value ( v )  =  
     let  should_serve 、 remainder  =  vend  5  v  in 
     ( if  should_serve  then  serve ( Tea )  else  0  (* STOP *) ) 
             &  value ( remainder )  &  reply  ()  to  button

  または、 ボタン( BCancel )  &  value ( v )  = 払い戻し(  v )  &  value ( 0 )  &  reply  () を ボタン
  の spawn  value ( 0 )  ;
  コイン、 ボタン  (* coin, button: int -> unit *) 
  ;;  (* new_vending: drink Join.chan -> int Join.chan -> (int->unit)*(int->unit) *)

let  ccoin ,  cbutton  =  new_vending  serve  fund  in 
  ccoin ( Nickel );  ccoin ( Nickel );  ccoin ( Dime ); 
  Unix.sleep ( 1 ) ; cbutton ( BCoffee ); Unix.sleep ( 1 ); cbutton ( BTea ); Unix.sleep ( 1 ); cbutton ( BCancel ); Unix.sleep ( 1 ) ( *最後のメッセージが表示されるようにする* ) ;; 
   
   
   
  

与える

コーヒー
お茶
払い戻し5

Hume ^[39]は、非同期メッセージの受け渡し、データフロープログラミング、Haskellのような構文に基づく並行性を備えた、リソースが限られたプラットフォーム向けの厳密で強く型付けされた 関数型言語です。

Hume は同期メッセージングを提供しません。

共通のチャネルを持つ結合パターン セットをボックスとしてラップし、すべてのチャネルをinタプルにリストし、すべての可能な出力をoutタプルに指定します。

セット内のすべての結合パターンは、必須でないチャネルに '*' を指定するボックス入力タプル タイプに準拠し、出力タプルに準拠するタイプの式を指定して、入力されない出力に '*' をマークする必要があります。

ワイヤー条項は、

1. 対応する入力元またはソースとオプションで開始値のタプル
2. 出力先のタプル。チャネルまたはシンク (stdout、..) です。

ボックスでは、出力タプルに準拠する式を使用して例外ハンドラーを指定できます。

データコイン= 5 セント| 10 セント;データドリンク=コーヒー|紅茶;データボタン= BCoffee | BTea | BCancel ;     
     
       

type Int = int 32 ; type String = string ; show u = u as string ;     
    
      

box coffee in ( coin :: Coins , button :: Buttons , value :: Int ) -- 入力チャネルout ( drink_outp :: String , value ' :: Int , fund_outp :: String ) -- 名前付き出力 
            
            

match 
-- * 未入力の出力および未消費の入力のワイルドカード
( Nickel 、* 、v ) -> ( * 、v + 5 、* ) | ( Dime 、* 、v ) -> ( * 、v + 10 、* ) | ( * 、BCoffee 、v ) -> vend Coffee 10 v | ( * 、BTea 、v ) -> vend Tea 5 v | ( * 、BCancel 、v ) -> let fund u = "Refund " ++ show u ++ " \n " in ( * 、0 、fund v ) ;             
              
         
            
               
                           


飲み物を販売します。コストはクレジットです。クレジット>=コストの場合、(ドリンクを提供、クレジット-コスト、* )、それ以外の場合は( * 、クレジット、* )です。        
                             
                          

ドリンクを提供する=ケースドリンクの場合コーヒー-> "Cofee \n "紅茶-> "Tea \n " ;     
                 
                 


ボックスコントロールin ( c :: char ) out ( coin :: Coins 、button :: Buttons )に一致します'n' -> ( Nickel 、* ) | 'd' -> ( Dime 、* ) | 'c' -> ( * 、BCoffee ) | 't' -> ( * 、BTea ) | 'x' -> ( * 、BCancel ) | _ -> ( * 、* ) ; 
   
     

    
     
     
     
     
     


console_outp を"std_out"にストリームします。console_inpを"std_in"からストリームします。    
    

-- データフロー配線

wire cofee --入力（チャンネルの起点）（control.coin 、control.button 、coffee.value （最初は0 ））--出力先（console_outp 、coffee.value 、console_outp ）； 
    
        
    
      


ワイヤーコントロール( console_inp ) (コーヒー.コイン、コーヒー.ボタン) ;