Haskellプログラムに外部言語を含める

この記事では、Haskellプログラムで他のプログラミング言語で作成されたライブラリーを使用できるようにする手法について簡単に説明します。 Haskellでこれらのライブラリを書き換えたり、Cで無数のラッパーを記述したり、明示的なバインダーを記述する必要はありません。 結果のプログラムでは、「エイリアン」コードを直接呼び出すか、他の人のコードHaskellから関数を呼び出すことができます。 関数コード自体は拡張プラグイン言語で記述できるため、プラグイン言語の専門家はそれを使用できますが、残念ながら、Haskellにはまだ慣れていません。



このタスクはゼロからは発生しませんでしたが、Rで記述されたコードとHaskellで記述されたモデルを一緒に使用するために1つの企業に必要でした。 同時に、Rプログラミングの専門家がHaskellを学ぶ必要がないように、それを使用することが望まれました。



したがって、課題はHaskellの他の言語のライブラリとコードを効率的な方法で有効にすることでした。 この場合の効率とは、異なる言語の関数間で可能な限りデータ変換のオーバーヘッドコストがなく、言語間で関数を呼び出すのが可能な限り安いことです。 現時点では、例を使用して2つの類似したライブラリがinline-rとinline-cで記述されています。その例を使用して、この手法の特定の概念を説明します。

• inline-cは、Cコードをhaskellコードに挿入できるようにするかなり単純なライブラリです。 実際には、このライブラリは、独自の補助関数を記述し、それらのFFIラッパーを作成するためのかなり単純な手順の自動化です。 このライブラリは、Haskellコードで言語のインクルージョンを簡単にする（ランタイムをなくす）方法を示しています。
• inline-r-HaskellコードにRコードを含めることを可能にするライブラリ。異なるランタイムシステムを組み合わせる方法を示しているので、すでに非常に興味深いものです。 動的に型指定されたRコードをHaskellコードに組み込み、2つのガベージコレクターがあるシステム上のデータを効率的に管理します。

このようなソリューションを実装するには、次の問題を解決する必要がありました。

1. 他の言語のコードを接続する方法、
2. 別の言語での挿入の構文はどうあるべきか。 コード入力方法、
3. 両方のライブラリが動作するようにデータを変換する方法

さまざまなRTS（ランタイムシステム）実行システム（複数のガベージコレクターなど）で発生するその他の問題、動的型付けの使用

ランタイム統合

RTSを持たない単純な言語（C、Rust）を有効にするには、すべてが非常に簡単です。それらのランタイムはHaskellのプログラムです。 この場合、FFI外部関数を呼び出すためのインターフェイスのみがサポートされ、Cインターフェイスはほとんどの場合に適しています。

しかし、Rのようなパフォーマンスシステムの場合、それを起動して通信する方法の問題が生じます。 この問題を解決するための標準的なアプローチの1つは、「インタープリター」（プログラムターゲット言語）を別のプロセスとして起動し、RPCツールの1つを使用してソースプログラムとメッセージを交換することです。 ただし、この方法にはいくつかの欠点があります。



ランタイムにeval



メソッドの類似物がない場合は、自分で作成する必要があります。 特定のタスクに特化が必要になる場合があり、ソリューションの一般性が低下します。 いずれにせよ、このメソッドは、実行の安全性に関する疑問を提起します。



プロバイダーにデータを転送するには、ネットワークを介してデータを送信する必要があり（ゼロコピーを使用すると複雑さを軽減できる）、シリアル化と逆シリアル化が必要です。 代替手段として、共有メモリの使用に基づく転送メカニズムの作成がありますが、コピーガベージコレクターの使用など、メモリへの直接アクセスが制限されたり、追加の問題が発生したりする言語では非常に困難な作業になります。



この方法の利点の1つは、ソリューションの単純さであり、イベントループを統合する必要がないことです。これは、たとえばグラフィックスのレンダリングに必要です。



これらの制限は、通常、最小オーバーヘッド要件と互換性がありません。 したがって、多くの場合、Haskellにランタイム環境を組み込む方が適切でした。 このソリューションは、いくつかの追加機能を同時に開きます。

• 共有メモリを使用するため、データのシリアル化と送信という余分な作業はなくなります。
• C API（Cインターフェースを使用してライブラリからエクスポートされた関数によって提供されるAPI）を使用することが可能になり、可能な場合は、インタープリター/プログラムエラーの制御が強化されます。
• そのようなプログラムは、それらを実行できるデータと機能について「よく知られている」ため、実行をさらに最適化できます。

このソリューションでは、たとえば言語ランタイム環境が追加の制限を課す場合、たとえばTLS（スレッドローカルストレージ）を使用する場合、または本質的にシングルスレッドである場合、技術的な問題が発生する可能性があります。 最初のケースでは、 Control.Concurrent.forkOSを使用してOSリンクスレッドを作成する（またはメインスレッドのみを使用する）必要があります。 次に、言語の側でクエリをシリアル化する必要があります。たとえば、これはかなり単純な「パターン」を使用して実行できます。

 {-# LANGUAGE ExistentialQuantification #-} import Control.Concurrent data Task = forall a . Task (IO a) (MVar (Either SomeException a)) sendTask :: Chan -> IO a -> IO a sendTask chan f = do result <- newEmptyMVar writeChan chan (Task f result) takeMVar result runTasks :: Chan -> IO () runTasks chan = forever $ do Task f result <- readChan chan mask_ $ do r <- try f putMVar result r
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このアプローチには、たとえば、プログラムレベルでこのチャネルの一意性を保証する必要がある場合、 ReaderT Chan



またはグローバル変数の環境にチャネルを保存するなど、いくつかのバリエーションがあります（このソリューションを選択する前に3回考えてくださいが、正式に正当化できます）。 また、場合によっては、発信者が生成したアクションをチャネルに転送し、そこで結果をMVarに入れて応答する方が良い場合もあります。 しかし、セマンティック上（正確に（および）例外を処理してこのスレッドの実行を完了する前に）、他のソリューションはこれと同等になります。

データ転送

データを転送するとき、解決する必要がある最初の質問は、Haskellで外部言語からデータを表示する方法です。これを可能にする最も単純なタイプは、Cタイプ、CChar、CInt、CString、CStringLen、Ptrなどです。 これは、CタイプのHaskellのタイプへのマッピングであり、低レベル言語のデータを表すのに十分です。 それらの型安全な作業のために、そのようなデータはラッパー型（newtypes）でラップできます。これにより、一方では型システムが許可し、他方では実行時にまったく負荷をかけません。

特にプラグイン言語は動的である可能性があるため、Rは言語でその意味をどのように表現するかという問題を提起します。 同時に、可能であれば、可能であれば静的に既知の型情報を持ちたいと思います。 この場合、コンパイラーはコードの正確性をさらに保証し、タイプごとにコードを生成することができます（Haskellのタイプクラスを参照）。 ここで、動的型システムを持つ言語はユニタイプ言語である、つまり 静的では、そこに表される型の全体の宇宙は、単一の型によって記述されます。 このアプローチを使用すると、式のタイプを示すファントムタイプでタグ付けされたポインターとして言語の値を想像できます（ポインターの代わりに、含まれる言語での表示方法に応じて、テーブル内のインデックスまたは値を一意に識別する別の識別子が存在する場合があります）

 data SEXPTYPE -- generated by hsc2hs newtype SEXP a = SEXP (Ptr SEXPTYPE)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

SEXPTYPE



は、C言語インターフェイスにエクスポートされるタイプです。 動的言語で予想されるように、式の型が不明であることを示すために、次のアプローチを使用します。

型に関する情報を転送するには、 DataKinds



拡張機能を使用できます。これにより、単純なデータ型のコンストラクターを型のレベル、つまり `SomeThing 'False`のようなタイプを作成します。 次に、プラグ可能な言語で可能なすべてのプリミティブ型をリストします。たとえば、Rの場合、

 data SEXPTYPE = NIL | Symbol | List | Closure | Int | Real ... deriving (Eq,Ord,Show)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

式に特定の型があることがわかっている場合（たとえば、Haskellで作成された場合）、その型を明示的に「SEXP 'List`または `SEXP' Real」と書くことができます。 ただし、動的言語で作業する場合、これは十分ではありません。 すべての戻り値の型はそこで知られていないため、真に動的な型を渡すことができるようにしたいと思います。 これを行うには、Rank2Types拡張機能を使用して次のタイプを記述します。

 data SomeSEXP = SomeSEXP (forall a . SEXP a)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このコードは、すべてa



SomeSEXP a



式のSomeSEXP a



が正しいことを意味します。 動的な価値の事実を正確に反映しています。 外部言語のメソッドがSomeSEXP



を安全に返すことができるようになりSomeSEXP



た。型を既知の型に変換するには、関数を作成できます

 cast :: SomeSEXP -> Maybe (SEXP a)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

式のタイプをチェックし、式またはエラーを返します。

また、いくつかの関数ではさまざまなタイプの変数を入力に適用できるため、合計タイプを使用できるようにしたいと考えています。

そのようなタイプを作成するには、TypeFamilies拡張機能を使用し、このタイプが許可されたタイプのリストに含まれているかどうかをチェックする新しいタイプ `In`を作成できます。

 infix 1 :∈ -- | The predicate @a :∈ as@ states that @a@ is a member type of the set @as@. type family (a :: SEXPTYPE) :∈ (as :: [SEXPTYPE]) :: Constraint where 'Any :∈ as = () a :∈ (a ': as) = () a :∈ (b ': as) = a :∈ as type In ab = a :∈ b
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このコードは、タイプレベルでの通常のパターンマッチングと同じように機能します。 ()



は成功を示し、ステートメントを検証できないことはエラーです。 In 'Int (Env ': Int ': '[])



例を考えてみましょう。 最初に、 Int



は'Env



と一致せず、型はIn 'Int ('Int ': '[])



と等しいため、3番目の条件になります。 そのコンパイラーはさらに単純化され、2番目の式に分類されます。 'Real



にチェックマークを付けると、 In 'Real '[]



進み、パターンがないため型エラーが発生します。

このアプローチの問題は、型が単射ではないことです。 式foo :: In a ['Int,'Real] => a -> SEXP 'Int



ある場合、型a



推測することはできません。これは便利ではないかもしれません。



このビューでは、C APIを使用して既に関数を操作し、コードを書く際にある程度の利便性を実現できます。 最初は、このアプローチは、サンプルや代数的データ構造との比較など、最新のプログラミング言語を使用する能力を妨げるように思われるかもしれませんが、そうではありません。

このような構造を使用するには、次の手法を使用できます。 構造（ビュー）のイメージを作成し、構造の浅い表現のみを定義します。これにより、メモリ内に構造全体の表示を作成する必要がなくなります。さらに、一般的な場合、コンパイラはすべての中間構造を完全に削除し、オーバーヘッドなしで外部データ構造を操作するのに便利です。

 data HExp :: * -> SEXPTYPE -> * where -- Primitive types. The field names match those of <RInternals.h>. Nil :: HExp R.Nil -- Fields: pname, value, internal. Symbol :: SEXP R.Char -> SEXP a -> SEXP b -> HExp R.Symbol -- Fields: carval, cdrval, tagval. List :: (R.IsPairList b, c :∈ [R.Symbol, R.Nil]) => SEXP a -> SEXP b -> SEXP c -> HExp R.List ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

そして、そのような画像を作成する関数 `hexp`を紹介します：

 hexp :: SEXP sa -> HExp sa
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次に、 ViewPatterns



拡張機能を使用して、パターンマッチングを使用できます。

 foo (hexp -> Symbol s) = ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

完全を期すには、機能が必要です

 unhexp :: HExp sa -> ms (SEXP a)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここでは、予想されるunhexp . hexp = id



ルールが満たさunhexp . hexp = id



いないことに注意することが重要unhexp . hexp = id



unhexpは常に新しい構造を作成するため、 unhexp . hexp = id



。



この手法により、外部の複雑な構造を簡単に操作できます。 また、任意の外部プログラミング言語に移植できます。 ここでの最後のステップは、マーシャリングHaskellデータ構造を外部言語構造に変換することです。これのために、型クラスを入力できます

 class Literal a ty | a -> ty where -- | Internal function for converting a literal to a 'SEXP' value. You -- probably want to be using 'mkSEXP' instead. mkSEXP :: a -> IO (SEXP V ty) fromSEXP :: SEXP s ty -> a
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

`| a-> ty`はパラメーター間の機能的な関係であり、タイプ 'a`がtyのタイプを一意に決定することを示します。 この情報は、コンパイラが型を導出するのに非常に役立ち、誤ったインスタンスを作成することを許可しません。 次に、Haskellのネイティブ型に対して、変換関数を定義します。

外国語でコードを書く

コードを記述するために、内部埋め込み言語（e-dsl）（高レベル言語では、ライブラリと埋め込み専用言語の境界は非常にぼやけています）または本格的なdslを作成できます。 「DSL」、つまり 実際にはわずかに変更されたプラグイン。 この方法は、Haskellを知らないが埋め込み言語を知っている人がコードを作成できるため、より便利に見えます。 どのように整理でき、どのように見えるか。



Haskellのソースコードを生成するために、ASTを構築できるTemplate Haskell拡張がありますが、それには一連の制限があり、さらに型チェックは非常に制限されています。 生成されたすべての式はそれぞれ同じタイプのQ Exp



持ち、コンパイラーはコントラクトの一部をチェックできません。その結果、無効なコードが生成される可能性があり、コード生成時にコンパイラーによって拒否されます。

疑似引用符を作成することもできます。QuasiQuotes [generator|some-code |]



ここでgenerator



は、 some-code



を解析して結果を取得する関数です。 結果は、TemplateHaskellを使用して生成されたHaskellコード、ファイル（たとえば、外部Cファイル）の作成、 find / -delete



または基本的にどんな仕事でも。



準引用はコードを含めるための優れた候補です。新しいパーサーを作成できます。 さらに、プロジェクトをコンパイルするときに、Rを呼び出してソースコードを渡し、ASTを取得します。 その後、このASTを処理し、Haskellからの変数置換を考慮して、実行時に同じASTを構築するコードを生成します。

たとえば、簡単なコード：

 let x = [1,2,3] in [r| x_hs + x_hs|]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

になります：

 eval $ unhexpIO =<< Lang (installIO “+”) (unHexp $ List (mkSEXP x) (List (mkSEXP x) Nil)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

実際、生成されたコードはリソースの保護、GCに関する記事の詳細を正確に監視するため、コードを理解するのは少し難しくなります。

メモリシステムの領域と表示

この言語の組み合わせの最大の難点は、ガベージコレクターとのやり取りです。 特に、ガベージコレクタがアセンブリ中にオブジェクトを移動できる場合、問題は複雑になります。 幸いなことに、C（ガベージコレクターが存在しない）もRへのオブジェクトも移動できないため、それらの操作が大幅に簡素化されます。

安全な操作のための最も簡単なメカニズムは、保護されたオブジェクトが削除されるのを防ぐ特別なオブジェクトの作成であり、その有効期間は別の言語から制御できます。Haskellの場合：



Foreign.StablePtr.newStablePtr



「保護」オブジェクトの作成

Foreign.StablePtr.freeStablePtr



「保護」オブジェクトの削除

extern void hs_free_stable_ptr (HsStablePtr sp);



-外部言語からの「保護」オブジェクトの削除



Rでは、次のとおりです。

preserveObject



オブジェクトを使用済みとしてマークする

releaseObject



オブジェクトを未使用としてマークする



次に、Rからのオブジェクトを使用してhaskellを実行すると、次のことができます。

 newtype Protected a = Prected (ForeignPtr SEXPPTR) protect (SEXP p) = do preserveObject p newForeignPtr p releaseObject
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この方法は十分ですが、すべての言語に適用できるわけではありません。 必要なAPIがない場合があり、「スタック」上のオブジェクトに対しては機能せず、最後に、R O(N)



でオブジェクトを作成および削除するコストなど、非常に高いコストがかかる可能性がありますN



この方法で保護されるオブジェクトN



数。 したがって、このような方法を主な方法として使用することはお勧めできません。

ただし、これはRのオブジェクトを保護する唯一の方法ではありません。この保護方法に加えて、「保護スタック」に基づく別の方法があります。任意のオブジェクトをスタックに配置し、N個のオブジェクトをスタックから削除できます。これらの操作の複雑さはO（1）です。 オブジェクト保護に対するこのアプローチは、R自体とCで記述された関数の両方で使用されます。そして、この方法をHaskellでも表示したいと思います。 このため、静的領域を使用して実装することができます。この手法はOleg Kiselevの記事で説明されています 。



Rのガベージコレクションシステムの機能により、このアプローチは元のソリューションとは異なりますが、表現力は同等です



newtype R sma = R {runR :: ReaderT（IORef Int）ma}

派生（ファンクター、Applicative、Monad）





IORef



、「スタック」のこのセグメントに割り当てられたオブジェクトの数を保存し、終了時にそれらをすべて解放できるようにします。 次に、補助機能が導入されます。

 runRegion :: (forall s . R s IO a) -> IO a runRegion f = do ref <- newIORef 0 runReaderT (runR f) ref
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

および主な機能：

 region :: (forall s . R (sm) ma) -> ma region f = … 
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここSEXP



、追加のファントム変数s



でSEXP



タイプSEXP



展開する必要があります。これは、この変数が割り当てられた、または保護された領域を示します。



ここでsは地域の役割を果たします;さらに、2つの地域を紹介します：

data V



空の領域。変数がスタックのどのセグメントにも属しておらず、保護されていないことを意味します（次回メモリが割り当てられたときに削除できます）

data G



はグローバル領域であり、変数が保存によって保護されており、すべての領域で使用できることを示します。

そして、リージョン機能の助けを借りて、 forall s1 s2 s3 . s1 (s2 s3 V))



構造の階層を構築できますforall s1 s2 s3 . s1 (s2 s3 V))



forall s1 s2 s3 . s1 (s2 s3 V))



。



ここで最も興味深いのは、領域の埋め込み（領域）の操作に関して閉じている格子を導入できることです。 この場合、次のようになります。

V < .. < s2 (s1) < s1 < G





この場合、小さい領域の「大きい」領域の要素を安全に使用できること、および操作を導入できることを知っています。

 loosen :: (s1 < s2) => SEXP s2 a -> SEXP s1 a <source>     ,       : <source language="haskell"> someOperation :: (s < s1, s < s2) => SEXP s1 Int -> SEXP s2 Int -> R s (SEXP s Int)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

中間領域でリレーションを作成するためにのみ残ります：

 type Ancestor = (<) class Ancestor s s1 instance Ancestor (R sm) (R sm) instance Ancestor parent region => Ancestor parent (R s region)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

おわりに

上記は、Haskellに他の言語を含めるために適用できるテクニックの基本要素を説明しています。 この手法は、 C



やRust



などの低レベル言語のコードを含めるために適用でき、コードの効率を向上させます（必要に応じて、実際に向上させます）。 または、多数のライブラリを持つ言語。これにより、既に行われた作業をやり直すことなく、便利なプログラミング言語で作業することができます。たとえば、 python



、またはmaxima



、 reduce



または独自の類似物などの特殊言語です。



また、外部コードとの相互作用、領域の作成、コード生成は非常に表面的であると考えられており、それらをより詳細に検討する必要がある場合は、次の記事でこれを行うことができます。