HN 日本語サマリー

← 一覧へ戻る
プログラミング

Hobbes – 言語と組み込みJITコンパイラ

Hobbes – A Language and Embedded JIT Compiler (github.com)

6 pointsby ryan-ca0 コメント

要約

Hobbesは、効率的な動的式評価、データストレージ、分析のための言語、組み込みコンパイラ、およびランタイムです。LLVM 3.3以降、cmake 3.4以降、GNU gcc 4.8以降、Linuxカーネル2.5以降が必要です。C++アプリケーションとの高性能な統合のために構築されており、メモリへの直接アクセスやリモートでのネイティブコードコンパイル・実行をサポートしますが、サンドボックス化されたランタイム環境やランタイム安全機能は提供しません。基本的な式評価、データ構造、型クラス、パターンマッチングなどをサポートしています。

全文翻訳

hobbes

[画像: Lifecycle Active] [画像: OSS-Fuzz] [画像: OpenSSF Scorecard]

効率的な動的式評価、データストレージ、および分析のための言語、組み込みコンパイラ、およびランタイム

sectiondescription
Buildinghobbesのビルドとインストールの方法
EmbeddingC++プログラムでのhobbesの使用方法
Evaluation基本的なhobbes式の評価方法
Storage帯域外分析のためのデータ記録方法
Networkingリモートhobbesプロセスとの対話方法
Comprehensionsデータ分析のためのシーケンスの変換/ソート/結合/フィルタリング/グループ化方法
Pattern Matchingデータの効率的な分類と分解方法
ParsingLALR(1)文法によるテキストの解析方法
Type Classesオーバーロードとコンパイル時計算
Unqualifier Modulesカスタム制約処理のためのユーザー定義「コンパイラプラグイン」

Hobbesの使用に関する注意

Hobbesは、C/C++アプリケーションとの高性能な統合のために構築されています。Hobbesはコンパイル時チェックを提供する強く型付けされた言語ですが、サンドボックス化されたランタイム環境やランタイムの安全性機能はありません。設計上、Hobbesはメモリに直接アクセスでき、配列境界チェックもありません。さらに、Hobbesはネットワーク(RPC)経由でのネイティブコードのコンパイルと実行をサポートしています。この機能は、信頼できる内部ネットワーク内での使用を目的としています。このような機能を利用することを選択した場合、これらの設計上の選択を認識し、セキュリティ上の影響を理解する必要があります。

Building

Hobbesをビルドするには、LLVM 3.3以降、cmake 3.19以降、GNU gcc 4.8以降、およびバージョン2.5以降のLinuxカーネルが必要です。

LLVM、cmake、およびg++がインストールされた状態で、このコードをダウンロードした後、次のコマンドを実行するだけでhobbesをビルドおよびインストールできるはずです。

$ cmake .
$ make
$ make install

LLVMをインストールした場所によっては、cmakeにLLVMのcmakeモジュールへのパスを指定しないと、これらの手順が機能しない場合があります。特に、LLVMのLLVMConfig.cmakeファイルへのパスが必要です。環境変数LLVM_DIRをそのディレクトリに設定すると、前の手順は正常に完了するはずです。

ビルドプロセスにより、静的ライブラリlibhobbes.aが生成されます。これはC++実行可能ファイルにリンクできます(.soファイルで使用したい場合は、ビルドで別の静的ライブラリlibhobbes-pic.aが生成されます)。

さらに、ビルドプロセスにより、ユーティリティプログラムhiとhogの2つが生成されます。hiプログラムはhobbes式の基本的なインタラクティブインタープリタであり、hogプログラムはアプリケーションによって生成された構造化データを効率的にデータファイルに記録します(これらのファイルはhiで同時にロードおよびクエリできます)。これらのプログラムのソースコードも参考になるはずです。なぜなら、それらはhobbes APIの多くの異なる側面を示しているからです。

Embedding

簡単なC++プログラムにhobbesを埋め込む方法を考えてみましょう。このコードは、hiに似た非常に基本的なシェルを実装しています。

#include <iostream>
#include <stdexcept>
#include <hobbes/hobbes.H>

int main() {
  hobbes::cc c;

  while (std::cin) {
    std::cout << "> " << std::flush;

    std::string line;
    std::getline(std::cin, line);
    if (line == ":q") break;

    try {
      c.compileFn<void()>(std::string("print(") + line + ")")();
    } catch (std::exception& ex) {
      std::cout << "*** " << ex.what();
    }

    std::cout << std::endl;
    hobbes::resetMemoryPool();
  }

  return 0;
}

まず、任意の式をコンパイルするには、hobbes::ccオブジェクトを構築する必要があります。次に、例外ハンドラのコンテキストで、compileFnメソッドを使用してこのhobbes::ccオブジェクトから関数をコンパイルできます。この場合、期待される戻り値の型はvoid()であり、その型にコンパイルできると期待される文字列も指定します。コンパイルのいずれかの段階で失敗した場合(パースエラー、型不一致など)、失敗に関する詳細を含む例外が発生します。最後に、hobbes::resetMemoryPool()を呼び出して、コンパイルされた式によって動的に割り当てられた可能性のあるメモリ(つまり、コンパイルされた式によって割り当てられたメモリですが、コンパイルされた関数自体は、hobbes::ccが破棄されるか、hobbes::cc::releaseMachineCodeが使用されて破棄されるまで解放されません)を解放します。

コンパイルされた関数がメモリを割り当てることを決定すると、その割り当ては「メモリ領域」から行われます。メモリ領域は、割り当てが発生する動的に拡張可能なバイトシーケンスであり、hobbes::resetMemoryPool()が呼び出されたときに一括で解放されます。これにより、割り当てと解放が非常に効率的になりますが、「論理トランザクション」の境界を確立するためにいくつかの考慮が必要です。アクティブなメモリ領域はスレッドローカルであるため、同期の問題を心配することなく、複数のスレッドで同じ関数ポインタを同時に使用できます。

最後に、上記のプログラムをtest.cppというファイルに保存した場合、次のようにビルドできます。

$ g++ -pthread -std=c++17 -I <path-to-hobbes-headers> -I <path-to-llvm-headers> test.cpp -o test -L <path-to-hobbes-libs> -lhobbes -ldl -lrt -ltinfo -lz -L <path-to-llvm-libs> `llvm-config --libs x86asmparser x86codegen x86 mcjit passes`

明示的なパス指定は、LLVMとhobbesがシステムにどのようにインストールされているかによって不要な場合があります。llvm-configプログラムのインライン呼び出しは、いくつかのライブラリを明示的にリストアップすることを避けるために、LLVMユーザーによく使用されます。

すべてが正しく機能した場合、基本的なシェルが得られ、hobbes式を評価できるようになります。

Evaluation

これで動作するシェルができたので、hobbes言語の仕組みを理解するために式を試すことができます。まず、典型的な定数値を見てみましょう。

> 'c'
'c'
> 42
42
> 3.14159
3.14159

合計で、サポートされているプリミティブ型/定数は次のとおりです。

nameexampledescription
unit()Cの'void'に似ており、単一の値を持つトリビアルな型
boolfalsetrueまたはfalseのいずれか
char'c'単一のテキスト文字
byte0Xff単一バイト(0-255)
short42S2バイトの数値
int424バイトの数値
long42L8バイトの数値
float42.0f4バイトの浮動小数点値
double42.08バイトの浮動小数点値

これらのプリミティブは配列と組み合わせることができます。

> [1, 2, 3]
[1, 2, 3]
> "foobar"
"foobar"
> 0xdeadbeef
0xdeadbeef

レコード/タプルとも組み合わせることができます。

> {name="Jimmy", age=45, job="programmer"}
{name="Jimmy", age=45, job="programmer"}
> ("Jimmy", 45, "programmer")
("Jimmy", 45, "programmer")

またはレコード/タプルの配列と組み合わせることもでき、それらはテーブルとして便利に表示されます。

> [{name="Jimmy", age=45, job="programmer"}, {name="Chicken", age=40, job="programmer"}]
   name age        job
------- --- ----------
  Jimmy  45 programmer
Chicken  40 programmer
> [("Jimmy", 45, "programmer"),("Chicken", 40, "programmer")]
  Jimmy 45 programmer
Chicken 40 programmer

型をバリアントまたはサム(レコードに対するタプルと同様、「名前のない」バリアントの形式)と組み合わせることができます。ネイキッドバリアントの導入は定義上不完全であるため、明示的な型注釈を導入する必要がある場合があります。

> |food="pizza"|::|vehicle:int,food:[char]|
|food="pizza"|
> |1="pizza"|::(int+[char])
|1="pizza"|

また、バリアントはアイソレカーシブ型と組み合わせて連結リストを作成できます。これらは表示時に便利な形式を持ち、再帰型およびバリアント型のボイラープレートを回避するための組み込み関数があります。

> roll(|1=("chicken", roll(|1=("hot dog", roll(|1=("pizza", roll(|0=()|))|))|))|) :: ^x.(()+([char]*x))
"chicken":"hot dog":"pizza":[]
> cons("chicken", cons("hot dog", cons("pizza", nil())))
"chicken":"hot dog":"pizza":[]

これらの型と型コンストラクタは、MLファミリーのプログラミング言語(SML、ocaml、Haskellなど)で一般的な「代数的データ型」を構成します。これらの型の構文と名前も、MLおよび一般的な学術プログラミング言語の教科書(TaPLやPFPLなど)に由来しています。

Haskellと同様に、hobbesは型クラスやユーザー定義の制約リゾルバ(後で詳しく説明します)を使用した修飾型の一種をサポートしています。これらは多くの用途の1つですが、混合型算術と型推論の両方を共存させることができます。

> 0X01+2+3.0+4L+5S
15
> (\x y z u v.x+y+z+u+v)(0X01,2,3S,4L,5.0)
15

また、hiプログラム(例で示したものより少し複雑なインタープリタで、hobbesと共に配布されています)を使用して、このような式を評価し、その型を検査することもできます。たとえば、前に検討したプリミティブ式の型はクエリできます。

$ hi
hi : an interactive shell for hobbes
      type ':h' for help on commands

> :t ()
()
> :t false
bool
> :t 'c'
char
> :t 0Xff
byte
> :t 42S
short
> :t 42
int
> :t 42L
long
> :t 42.0f
float
> :t 42.0
double

レコード、配列、バリアント、および再帰値の型も同様です。

> :t [1..10]
[int]
> :t "foobar"
[char]
> :t 0xdeadbeef
[byte]
> :t {name="Jimmy", age=45, job="programmer"}
{ name:[char], age:int, job:[char] }
> :t ("Jimmy", 45, "programmer")
([char] * int * [char])
> :t cons("foo",nil())
^x.(() + ([char] * x))

修飾型についても、この機能を使用して開いている/解決されていない型制約のセットを表示できます。

> :t \x.x.foo
(a.foo::b) => (a) -> b
> :t .foo
(a.foo::b) => (a) -> b

ここで、入力値の「foo」フィールドの値を返す単純な関数の型は、制約(型とその左側の=>の部分、Haskellと同じ)を持っていることがわかります。この場合、型全体は、型aにb型のfooという名前のフィールドがある場合、関数はa -> bの型を持つと述べています。この制約の追加の複雑さにより、この関数は任意の条件を満たす型aで使用できます。この特定の制約は、関数に対する一種のダックタイピングを可能にします。

Binding

C++プロセス内でhobbesを使用している場合(hiでスクリプトを実行するだけの場合とは異なり)、ある時点でC++値を(通常は関数を)hobbes::ccインスタンスにバインドして、後で動的式で使用できるようにする必要があります。この作業の多くは自動化されており、バインディングロジックについて考える必要がなくなることがよくあります。

たとえば、既に定義した可能性のあるC++関数を考えてみましょう。

int applyDiscreteWeighting(int x, int y) { return x * y; }

これで、この定義を以前のプログラムにインポートし、次の行を追加してhobbes::ccインスタンスにバインドできます。

  c.bind("applyDiscreteWeighting", &applyDiscreteWeighting);

その後、プログラムを実行すると、そのシェルはこの関数を使用できるようになり、型構造と矛盾する方法でそれを使用する式は拒否されます。

> applyDiscreteWeighting(3, 4)
12
> applyDiscreteWeighting(3, "pizza")
*** stdin:1,1-22: Cannot unify types: int != [char]

他の場合では、hobbesでネイティブに理解される型と動的メモリ割り当てを使用する方が便利な場合があります。

typedef std::pair<size_t, const hobbes::array<char>*> MyRecord;

const hobbes::array<MyRecord>* loadRecords(int key) {
  static const char* names[] = { "chicken", "hot dog", "foobar", "jimmy" };

  auto rs = hobbes::makeArray<MyRecord>(key);
  for (size_t i = 0; i < rs->size; ++i) {
    rs->data[i].first  = i;
    rs->data[i].second = hobbes::makeString(names[i % 4]);
  }

  return rs;
}
// [...]
  c.bind("loadRecords", &loadRecords);
// [...]

hobbes::makeArrayおよびhobbes::makeStringへのこれらの呼び出しは、呼び出しスレッドのメモリ領域から割り当てを行い、hobbesが汎用的に分解して便利な形式で表示できるデータを生成します。これは、テストプログラムで再度実行するとわかります。

> loadRecords(10)
0 chicken
1 hot dog
2  foobar
3   jimmy
4 chicken
5 hot dog
6  foobar
7   jimmy
8 chicken
9 hot dog

レコードをタプルではなく意味のあるフィールド名を持つ構造体で表すことを好む場合は、代わりにDEFINE_STRUCTマクロを使用して型を定義できます(これは純粋に構文上の違いです。タプルと構造体の最終的なランタイム表現はhobbesでは同じです)。たとえば、前の例のMyRecord型を次のように定義した場合:

DEFINE_STRUCT(MyRecord,
  (size_t, index),
  (const hobbes::array<char>*, name)
);

そしてloadRecordsの初期化コードをフィールド名で参照するように変更した場合:

// [...]
    rs->data[i].index = i;
    rs->data[i].name  = hobbes::makeString(names[i % 4]);
// [...]

すると、hobbesからフィールド名を名前でアクセスでき、たとえばそのようなレコードのテーブルはフィールド名を表示するヘッダーと共に表示されます。

> loadRecords(10)
index    name
----- -------
    0 chicken
    1 hot dog
    2  foobar
    3   jimmy
    4 chicken
    5 hot dog
    6  foobar
    7   jimmy
    8 chicken
    9 hot dog

また、「逆方向」にC関数型を使用してバインドすることもできます。つまり、C++コードを有効なhobbesシンボルとして表示するのではなく、hobbes式を有効なC++シンボルとして表示できます。たとえば、次のようなC++バインディングを考えてみましょう。

int iter2(int (*pf)(int,int), int x) {
  return pf(pf(x, x), pf(x, x));
}
// [...]
  c.bind("iter2", &iter2);
// [...]

ここでは、関数自体を入力として受け取る関数をバインドしました。hobbes構文の匿名関数を使用して、このC++関数が使用するロジックを決定できます。

> iter2(\x y.x*x+y, 2)
42

バリアントは、hobbes::variant<...>型としてC++とhobbesの間で渡すことができます。

typedef hobbes::variant<int, const hobbes::array<char>*> classification;

const classification* classifyParameter(int x) {
  if (x < 42) {
    return hobbes::make<classification>(42 - x);
  } else {
    return hobbes::make<classification>(hobbes::makeString("achievement unlocked"));
  }
}
// [...]
  c.bind("classifyParameter", &classifyParameter);
// [...]

これらも標準的な方法で表示されるはずです(このバリアントのコンストラクタに名前がないため、最初のケースと2番目のケースでコンストラクタ名「0」と「1」が表示されます)。ペイロード型が表示可能であると仮定します。

> classifyParameter(16)
|0=26|
> classifyParameter(8675309)
|1="achievement unlocked"|

アプリケーション変数と関数をhobbes::ccインスタンスにバインドするプロセスで、hobbesは各C++型を同等のhobbes型に「リフト」する方法を決定します。多くの一般的なケースは既に透過的に処理されています。上記の例のように、size_t、std::pair、hobbes::arrayのような型は、特別な作業なしに「リフト」されます。hobbesが型のリフト方法を知らない場合、それは「不透明なC++型」としてリフトされ、hobbesは一貫した使用法のみをチェックします(必要に応じてクラス階層と派生/基底変換を尊重しますが、それ以外は型の構造について何も知りません)。

たとえば、次のようなバインディングケースを考えてみましょう(複雑な型階層を表すことを意図しています)。

class Top {
public:
  Top(int x, double y, int z) : x(x), y(y), z(z) { }

  int    getX() const { return this->x; }
  double getY() const { return this->y; }
  int    getZ() const { return this->z; }
private:
  int    x;
  double y;
  int    z;
};

class Left : public virtual Top {
public:
  Left(int x, double y, int z) : Top(x, y, z) { }
};

class Right : public virtual Top {
public:
  Right(int x, double y, int z) : Top(x, y, z) { }
};

class Bottom : public Left, public Right {
public:
  Bottom(int x, double y, int z) : Left(x*z, y*y, z*x), Right(x*x, y*y, z*z), Top(x, y, z) { }
};
// [...]
  c.bind("getX", memberfn(&Top::getX));
  c.bind("getY", memberfn(&Top::getY));
  c.bind("getZ", memberfn(&Top::getZ));

  static Bottom b(1, 3.14159, 42);
  c.bind("b", &b);
// [...]

これでシェルに戻り、バインドされたBottomインスタンスでバインドされたTopメソッドを呼び出すことができます(hobbesはgccと連携して正しいポインタ調整を適用します)。

> b.getX()
1
> b.getY()
3.14159
> b.getZ()
42

C++型のリフトのデフォルトロジックが不十分な場合、hobbes::lift<T>型を特殊化して、より有用な説明を決定できます(hobbes/lang/tylift.Hのコードに多くの例があります。ここでデフォルトのリフト定義セットが作成されます)。

Storage

adhocな動的クエリでアプリケーションデータを「プル」するためにhobbesを使用する代わりに、リアルタイムまたは履歴分析のために大量のアプリケーションデータをローカルまたはリモートストレージに「プッシュ」するためにもhobbesを使用できます。この場合、コンパイラインスタンスは必要なく、ストレージプロセスの基本的なサービス品質パラメータを定義するだけで済みます。たとえば、簡単なモック気象モニターを考えてみましょう。

#include <hobbes/storage.H>
#include <stdlib.h>

DEFINE_STORAGE_GROUP(
  WeatherMonitor,              /* our data set の任意の名前 */
  3000,                        /* システムページ単位の最大予想スループット(この制限まで記録すると、ドロップまたはブロックします) */
  hobbes::storage::Unreliable, /* ドロップする方がブロックするより良い */
  hobbes::storage::AutoCommit  /* バッチで複数のレコードを相関させる必要はありません(非トランザクション) */
);

// センサー読み取りのセット
DEFINE_HSTORE_STRUCT(
  Sensor,
  (double, temp),
  (double, humidity)
);

int main() {
  while (true) {
    // どこかからランダムなセンサー読み取りを記録
    const char* locations[] = { "AZ", "CO", "HI" };
    const char* location    = locations[rand() % 3];

    Sensor s;
    s.temp     = 1.0 + 50.0 * ((double)(rand() % 100)) / 100.0;
    s.humidity = ((double)(rand() % 100)) / 100.0;

    HSTORE(WeatherMonitor, sensor, location, s);

    // 時々、通過する車を記録
    if (rand() % 100 == 0) {
      HSTORE(WeatherMonitor, carPassed, location);
    }
  }
  return 0;
}

まずDEFINE_STORAGE_GROUPを使用して、記録するデータセットの名前(選択した名前は後で重要になります)、一時的にデータが格納されるリングバッファに割り当てるメモリページ数(ほとんどのシステムではページは4KB)、データを生成する速度で格納できない場合に待機するか破棄するか、およびバッチ/トランザクションでデータを相関させる必要があるかどうかを決定します。

次にDEFINE_HSTORE_STRUCTを使用して、簡単なSensor構造体を定義します。

最後に、モックセンサーデータを生成および記録する簡単なループを実行します。データを記録するために使用するHSTOREマクロは、ストレージグループの名前、このデータを識別するための一意の名前、およびそれに続く引数を格納するデータとして受け取ります。ストレージグループが「信頼性の低い」モードで使用されている場合(上記の例)、コンシューマが遅れているためにデータがドロップされた場合、HSTOREマクロはfalseを返します。多くの一般的な型はHSTOREで自動的に格納できます(プリミティブ、std::string、std::vectorなど)。C++シンボルへのバインディングと同様に、hobbes::storage::store<T>型を特殊化することによってカスタム型のストレージを定義することが可能です(ここではhobbes/storage.Hの定義が参考になります)。

このプログラムが実行されているのと同時に、このデータを消費するためにもう1つのプログラムを実行したいでしょう。hogプログラムは、この目的のためにhobbesと共に配布されています。そのソースコードは、ストレージコンシューマAPIを理解したい場合や、そのロジックをカスタマイズしたい場合に参考になるかもしれません。このプログラムでの記録オプションの概要を取得するには、引数なしで実行できます。

$ hog
hog : record structured data locally or to a remote process

  usage: hog [-d <dir>] [-g group+] [-p t s host:port+] [-s port] [-c] [-m <dir>] [-z]
where
  -d <dir>          : structured data (or temporary data) を格納する場所を決定します
  -g group+         : このマシン上のメモリからどのデータを記録するかを決定します
  -p t s host:port+ : t時間単位またはsバイト(非圧縮)書き込みごと​​にリモートプロセスにデータを送信することを決定します
  -s port           : 指定されたポートでデータを受信することを決定します
  -c                : 同じ型のデータをプロセス間で単一のファイルに格納することを決定します
  -m <dir>          : プロデューサ登録のためのドメインソケットを配置する場所を決定します(デフォルト: /var/tmp)
  -z                : データを圧縮して格納します
$ 

これは、このプログラムを使用して、次の3つのモードのいずれかでデータを消費および格納できることを示しています。

  1. ローカルディスクファイルへの即時ストレージ
  2. リモートプロセスへの正常な送信を待機中のローカル一時ストレージ(バッチ処理、圧縮)
  3. ネットワークサーバー、リモートプロセスからのローカルファイルへのストレージ

上記のテストプログラムの場合、ローカルにデータを格納するだけで十分です。プロデューサ(テストプログラム)を開始する前に、hogコンシューマを実行する必要があります。hogを実行してからテストプログラムを開始すると、hogが次のような出力を生成するはずです。

$ hog -g WeatherMonitor
[2018-01-01T09:00:00.867323]: hog running in mode : |local={ dir="./", groups={"WeatherMonitor"} }|
[2018-01-01T09:00:00.867536]: polling for creation of memory regions
[2018-01-01T09:00:00.873862]: group 'WeatherMonitor' ready, preparing to consume its data
[2018-01-01T09:00:01.637614]:  ==> carPassed :: ([char]) (#1)
[2018-01-01T09:00:01.733374]:  ==> sensor :: ([char] * { temp:double, humidity:double }) (#0)
[2018-01-01T09:00:01.848340]: finished preparing statements, writing data to './WeatherMonitor/data-2018.01.01-0.log'

これらのプログラム(hogとテストプログラムの両方)を実行したまま、同時に3番目のプログラムを実行して、記録されているデータをロードおよびクエリできます。これは、前に見たhiプログラムの良いユースケースです。hogがその出力ファイルを書き込んでいるディレクトリに入ると、記録しているデータを調べることができます。

$ hi
hi : an interactive shell for hobbes
      type ':h' for help on commands

> wm = inputFile :: (LoadFile "./WeatherMonitor/data-2018.01.01-0.log" w) => w
> wm.sensor
AZ {temp=44.572017, humidity=44.582017}
AZ   {temp=3.575808, humidity=3.585808}
HI {temp=39.150116, humidity=39.160116}
...
> wm.carPassed
AZ
AZ
CO
AZ
...
> 

このファイルをロードするための構文は少し変わっているように見えるかもしれませんが(または、修飾型と型クラスをさらに詳しく説明した後であればそうでないかもしれません)、hiでこのファイルをロードする方法は、記録しているものを比較的迅速に確認できるはずです。データが書き込まれている間に同じデータを繰り返しクエリすると、データのビューが「ライブ」であるため、異なる結果が表示されるはずです。更新を処理する関数を登録して、特定のデータを書き込まれたとおりに「テール」することも可能です。

> signals(wm).sensor <- (\_.do { putStrLn("sensor batch updated"); return true })
> sensor batch updated
sensor batch updated
sensor batch updated
sensor batch updated

より複雑なアプリケーションでは、統計情報の収集、記録データのインデックス作成、特定の条件でのアラートなどの機能を使用する場合があります。

バッチ処理または「トランザクション」データを記録したい場合もあります。その場合、ストレージステートメントを相関させる必要があります。たとえば、モックチーズバーガー注文管理アプリケーションを考えてみましょう。

#include <hobbes/storage.H>
#include <stdlib.h>

DEFINE_STORAGE_GROUP(
  Orders,
  3000,
  hobbes::storage::Reliable,    /* すべての注文を追跡する必要があります */
  hobbes::storage::ManualCommit /* すべての注文イベントを相関させる必要があります */
);

int main() {
  while (true) {
    // 顧客が店に入る
    const char* names[] = { "Harv", "Beatrice", "Pat" };
    const char* name    = names[rand() % 3];

    HSTORE(Orders, customerEntered, name);

    // チーズバーガーを注文する
    const char* products[] = { "BBQ Attack", "Cheese Quake", "Bacon Salad" };
    const char* product    = products[rand() % 3];

    HSTORE(Orders, productOrdered, product);

    // 飲み物を追加することを決定するかもしれない
    if (rand() % 5 == 0) {
      const char* drinks[] = { "Soda", "Lemonade", "Water" };
      const char* drink    = drinks[rand() % 3];

      HSTORE(Orders, drinkOrdered, drink);
    }

    // 顧客が気が変わるか、支払いを済ませて帰る
    if (rand() % 10 == 0) {
      HSTORE(Orders, orderCanceled);
    } else {
      HSTORE(Orders, paymentReceived, 10.0 * ((double)(rand() % 100)) / 100.0);
    }

    // 注文が完了したので、トランザクションを終了する
    Orders.commit();
  }
  return 0;
}

意味のあるトランザクションを記録していることを示したので、このストレージグループに対してhogを実行すると、各ストレージステートメントのログに加えて、「transactions」シーケンスも記録されます。

$ hog -g Orders
[2018-01-01T09:00:00.371394]: hog running in mode : |local={ dir="./", groups={"Orders"} }|
[2018-01-01T09:00:00.371633]: polling for creation of memory regions
[2018-01-01T09:00:00.371697]: group 'Orders' ready, preparing to consume its data
[2018-01-01T09:00:01.615395]:  ==> paymentReceived :: (double) (#4)
[2018-01-01T09:00:01.736183]:  ==> orderCanceled :: () (#3)
[2018-01-01T09:00:01.753279]:  ==> drinkOrdered :: ([char]) (#2)
[2018-01-01T09:00:01.838780]:  ==> productOrdered :: ([char]) (#1)
[2018-01-01T09:00:01.880418]:  ==> customerEntered :: ([char]) (#0)
[2018-01-01T09:00:01.927219]:  ==> transactions :: <any of the above>
[2018-01-01T09:00:02.136798]: finished preparing statements, writing data to './Orders/data-2018.01.01-0.log'

そして、このファイルを同時にロードすると、すべてのストレージステートメントとこの新しい「transactions」データをクエリできることがわかります。各トランザクションはタイムスタンプとすべての可能なストレージステートメントのバリアントの配列として格納されるため、どのステートメントが記録されたか、およびその順序を知ることができます。

$ hi
hi : an interactive shell for hobbes
      type ':h' for help on commands

> orders = inputFile :: (LoadFile "./Orders/data-2018.01.01-0.log" w) => w
> orders.transactions
                      time                                                                                                              entries
-------------------------- --------------------------------------------------------------------------------------------------------------------
2018-01-01T12:19:03.244206                                       [|customerEntered=("Pat")|, |productOrdered=("Bacon Salad")|, |orderCanceled|]
2018-01-01T12:19:03.244172                                 [|customerEntered=("Beatrice")|, |productOrdered=("Cheese Quake")|, |orderCanceled|]
2018-01-01T12:19:03.244127    [|customerEntered=("Pat")|, |productOrdered=("Cheese Quake")|, |drinkOrdered=("Water")|, |paymentReceived=(6.4)|]
2018-01-01T12:19:03.244092                               [|customerEntered=("Pat")|, |productOrdered=("Bacon Salad")|, |paymentReceived=(6.4)|]
2018-01-01T12:19:03.244047 [|customerEntered=("Pat")|, |productOrdered=("Cheese Quake")|, |drinkOrdered=("Lemonade")|, |paymentReceived=(2.1)|]
2018-01-01T12:19:03.244013                               [|customerEntered=("Pat")|, |productOrdered=("Bacon Salad")|, |paymentReceived=(7.6)|]
2018-01-01T12:19:03.243978                           [|customerEntered=("Beatrice")|, |productOrdered=("BBQ Attack")|, |paymentReceived=(3.4)|]
2018-01-01T12:19:03.243944                          [|customerEntered=("Beatrice")|, |productOrdered=("Bacon Salad")|, |paymentReceived=(3.5)|]
2018-01-01T12:19:03.243910                             [|customerEntered=("Harv")|, |productOrdered=("Cheese Quake")|, |paymentReceived=(6.3)|]
...

これらのトランザクションの内容は非常に大きいように見えるかもしれませんが、実際にはデータの格納方法によるわずかな追加にすぎません。非常に効率的にクエリすることもできます。

Networking

C++から構造化アプリケーションデータを記録するための軽量で効率的な方法が必要な場合と同様に、hobbesを理解するリモートプロセスからプレーンなC++データを効率的にクエリするための同様の方法が必要になる場合があります。これは、対話のシグネチャを受け取り、それを実装する型を生成するDEFINE_NET_CLIENTマクロによって可能になります。

簡単なテストプログラムで直接本題に入ることができます。

#include <iostream>
#include <hobbes/net.H>

// 私たちのRPCシグネチャ
DEFINE_NET_CLIENT(
  Connection,                       // この接続プロファイルの名前
  (add, int(int,int), "\x y.x+y"), // 式 '\x y.x+y' によってリモートで実装される型 int(int,int) の関数 "add"
  (mul, int(int,int), "\x y.x*y")  // 上記と同様ですが、式 '\x y.x*y' のための "mul"
);

int main(int, char**) {
  try {
    Connection c("localhost:8080");

    std::cout << "c.add(1,2) = " << c.add(1,2) << std::endl
              << "c.mul(1,2) = " << c.mul(1,2) << std::endl;

  } catch (std::exception& e) {
    std::cout << "*** " << e.what() << std::endl;
  }
  return 0;
}

ここでは、localhost:8080でリクエストを受け付けるプロセスが実行されていると仮定します。接続が確立されると、リモートエンドを期待される式/型で初期化します(これにより、後でIDだけで効率的に呼び出すことができます)。このプロセスのいずれかの部分が失敗した場合(接続またはリモート型チェック)、失敗を説明する例外が発生します。それ以外の場合、このケースの実行は、両方の関数を呼び出して結果を報告するだけです。

ポート8080で静かにリッスンするhiプロセスを次のように実行できます。

$ hi -s -p 8080
> 

そして、上記のテストプログラムをtestという実行可能ファイルにコンパイルした場合、実行して実行中のサーバーに対して実行し、次のような結果を観察できます。

$ ./test
c.add(1,2) = 3
c.mul(1,2) = 2
$ 

軽量なストレージ定義をhobbes::storage::store<T>を特殊化することによって追加できるのと同様に、軽量なRPCコーデックもhobbes::net::io<T>を特殊化することによって追加できます(hobbes/net.Hには多くの型および型ファミリーがサポートされています。たとえば)。

このネットワーキング/リモート評価方法は、hobbesからのみアクセスすることもできます。たとえば、前のhiサーバープロセスがまだ実行されている場合、次のように話しかける新しいhiプロセスを開始できます。

$ hi -s
> c = connection :: (Connect "localhost:8080" p) => p
> 

これで、コンパイル時に接続が確立されました。この接続の(現在の)静的構造は、printConnection関数を使用して決定できます。これは現在次のように表示されます。

> printConnection(c)
localhost:8080

id expr input output
-- ---- ----- ------

> 

ここで、これらのプロセス間で一部の対話を行うための基本的な関数を作成できます。たとえば、従業員に関するデータセットを記録する関数があるとします。

> sendData = \x.receive(invoke(c, `\x.println(x)`, x :: [{name:[char], age:int, salary:double}]))

> :t sendData
([{ name:[char], age:int, salary:double }]) -> ()

ここで、リモート評価を実行するための新しい関数invokeと結果を解析するためのreceiveの2つが表示されます。まだsendDataを呼び出していませんが、この接続をコンパイル時に保持しているため、hiはリモートプロセスと通信してその結果の型が何になるかを知ることができました(ただし、入力型のみを指定しました)。printConnectionを再度呼び出すと、ネゴシエートされたこの静的プロトコルの詳細が表示されるはずです。

> printConnection(c)
localhost:8080

id                                                       expr                                     input output
-- ---------------------------------------------------------- ----------------------------------------- ------
 0 \(.arg0).(let .t13409.rv0 = .arg0 in println(.t13409.rv0)) [{ name:[char], age:int, salary:double }]     ()

これにより、リモート(脱糖された)式が静的に知られており、入力および出力型、および式のユニークなIDが決定されたことがわかります。後で(「実行時」または「クリティカルパス上」)、このリモート式を呼び出すために、送信者プログラムは、リモート側がこの特定の式に対して期待する入力データの後に、この値0を書き込むだけで済みます(ただし、これ以上の「自己記述」データはありません)。

これはまた、hobbesの型表現の機能に決定的に依存しています。それは、静的に知られた式を運ぶことができることです。この例では、「引用された式」形式を使用してこの式を運び、コンパイル時に使用できるようにします。

> :t `\x.println(x)`
(quote \(.arg0).(let .t14200.rv0 = .arg0 in println(.t14200.rv0)))

この型は実行時に()に相当します(つまり、実行時には存在しません)。しかし、この方法で引用された式を運ぶことにより、コンパイル時に式の詳細を推論し、送受信することができます。

そして、定義した関数を呼び出すと。

> sendData([{name="bob", age=40, salary=23.2}, {name="jane", age=51, salary=53.1}])

リモート側は期待どおりに表示します。

name age salary
---- --- ------
 bob  40   23.2
jane  51   53.1

Comprehensions

アプリケーションバインディング、帯域外ライブ/履歴データ、または準備されたリモートクエリに対して直接クエリを実行しているかどうかにかかわらず、最終的にはデータのソート、結合、グループ化、フィルタリング、および変換が必要になります。従来はこのような問題にSQLクエリを考えるかもしれませんが、hobbes(Haskellに触発されています)はコンプリヘンションと基本的な関数を使用します。

コンプリヘンションは一般的な形式をとります。

[E | p <- S, C]

ここで、Eは変換またはマップ式、Sはシーケンス(のある型)を生成する式、pはSの各値に対してマッチングされるパターン(Eで使用される変数を導入する可能性がある)、CはSの値のうちどれを選択するかを決定するブールフィルタ式です。C式はオプションであり、省略できます。パターンpは通常単なる変数の名前ですが、必要に応じてより複雑になることもあります。

たとえば、最初の20個の自然数から3で割り切れる数の文字列表現が必要になる場合があります。

> [show(x) | x <- [0..20], x % 3 == 0]
["0", "3", "6", "9", "12", "15", "18"]

前に見たモック気象モニター例のストレージファイルをロードした場合、AZの読み取り値を取得したい場合があります。

> [p.1 | p <- wm.sensor, p.0 == "AZ"]
temp humidity
---- --------
12.5    12.51
  33    33.01
  16    16.01
  48    48.01
 5.5     5.51
...

あるいは、タプルインデックスを単純化し、等価性チェックを行うためにパターンバインディングを使用することもできます(パターンに一致しない値は除外されます)。

> [s | ("AZ", s) <- wm.sensor]
temp humidity
---- --------
12.5    12.51
  33    33.01
  16    16.01
  48    48.01
 5.5     5.51
...

シーケンスをカテゴリ化するためにgroupBy関数を使用し、次に結果に対してコンプリヘンションを使用して要約することができます。

> [(k, sum(vs)) | (k, vs) <- groupBy(\x.x % 3, [0..20])]
0 63
1 70
2 77

joinBy関数を使用して、共通のキーで2つの値のシーケンスを結合できます。

> joinBy(.name, [{name="bob", score=20}, {name="jim", score=50}], .id, [{id="jim", age=6}, {id="bob", age=42}])
name score  id age
---- ----- --- ---
 bob    20 bob  42
 jim    50 jim   6

スライス表記を使用してサブシーケンスを選択することもできます。構文S[i:e]は、Sからiで始まりeで終わる値を選択するために使用できます。iとeの両方はシーケンス内のインデックスとして解釈されますが、シーケンスの末尾を示すために空にしたり、シーケンスの末尾からのオフセットを示すために負にしたりできます。範囲外のインデックスは結果に含まれません。iがeより大きい場合、結果はSの元の順序と比較して逆になります。いくつかの例を試してみましょう。

> "foobar"[0:3]
"foo"
> "foobar"[3:0]
"oof"
> "foobar"[-3:]
"bar"
> "foobar"[:-3]
"rab"
> "foobar"[0:]
"foobar"
> "foobar"[:0]
"raboof"

シーケンスをsortまたはsortWith関数でソートできます。シーケンス型が順序付け可能であるか、またはシーケンスの値に対する順序付け可能な型への関数を提供できると仮定します。値は昇順で与えられますが、シーケンスを逆にするだけで降順を取得できます。

> sort([0..10])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
> sortWith(.age, [{name="jimmy", age=30, state="AZ"}, {name="bob", age=42, state="CO"}, {name="frank", age=37, state="HI"}])
 name age state
----- --- -----
jimmy  30    AZ
frank  37    HI
  bob  42    CO
> sortWith(.age, [{name="jimmy", age=30, state="AZ"}, {name="bob", age=42, state="CO"}, {name="frank", age=37, state="HI"}])[:0]
 name age state
----- --- -----
  bob  42    CO
frank  37    HI
jimmy  30    AZ

これらのシーケンスを消費する方法を組み合わせることで、hobbes対応プロセスの状態を検査したり、記録されたアプリケーションデータを分析したりするのに特に役立ちます。

Pattern Matching

Hobbes言語は、データ分類と分解のためのパターンマッチングの一種をサポートしています。パターンマッチングの最も一般的な形式はmatch式にあり、シーケンスコンプリヘンションのような他のマッチングの使用が、この一般的な形式に書き換えられる(または「脱糖」される)方法を検討します。

match式の重要な特殊ケースはC++のswitchステートメントです。なぜなら、C++コード:

switch (x) {
case 0:  return "foo";
case 1:  return "bar";
case 2:  return "chicken";
default: return "beats me";
}

は、hobbesのmatch式と同等です(パターン_は任意の値をマッチするため)。

match x with
| 0 -> "foo"
| 1 -> "bar"
| 2 -> "chicken"
| _ -> "beats me"

そして一般的に、r個の異なるケースに対して、両方ともO(log(r))時間で効率的に結果を決定します(ただし、上記の例のような一部の式はO(1)時間で実行できるように配置できます)。

しかし、match式はswitchステートメントをいくつかの重要な方法で一般化します。

まず、match式では複数の値を一度にマッチさせることができます(c個の値とr個のケースの場合、マッチはO(c*log(r))時間で決定できます。switch例ではc=1であり、期待される時間計算量です)。たとえば、次のようなmatch式を記述できます。

match x y with
| 0 0 -> "foo"
| 0 1 -> "foobar"
| 1 0 -> "bar"
| 1 1 -> "barbar"
| 2 0 -> "chicken"
| 2 1 -> "chicken bar!"
| _ _ -> "beats me"

そうでなければ、次のようなswitchステートメントを記述する必要がありました。

switch (x) {
case 0:
  switch (y) {
  case 0:  return "foo";
  case 1:  return "foobar";
  default: return "beats me";
  }
case 1:
  switch (y) {
  case 0:  return "bar";
  case 1:  return "barbar";
  default: return "beats me";
  }
case 2:
  switch (y) {
  case 0:  return "chicken";
  case 1:  return "chicken bar!";
  default: return "beats me";
  }
default:
  return "beats me";
}

そして、両方のコードフラグメントが同じ時間で同じ結果を計算する(おそらくまったく同じ方法で)としても、match式はより簡潔であり、いくらかの表記上の便宜を提供します。

match式がswitchステートメントを一般化するもう1つの方法は、値の一部に変数をバインドできることです。たとえば、前のストレージ例の注文トランザクションエントリ型のような複雑なバリアント型にマッチさせることができます。

match e with
| |paymentReceived=x| -> "received " ++ show(x)
| _                   -> "something happened"

この場合、パターン|paymentReceived=x|はeのバリアントがpaymentReceivedケースであることをチェックし、そうであればそのペイロードを変数xにバインドして、後で使用できるようにします。このマッチングとバインディングプロセスは任意の深さにネストできるため、たとえばこの式:

match [(1,2),(3,4),(5,6)] with
| [_, (3, x), _] -> x
| _              -> -1

最初のパターン行が、最初の値が3で2番目の値がxにバインドされるペアである長さ3の配列をチェックし(入力の場合、x=4)、その後xがすぐに返されるため、4に評価されます。

文字配列にマッチングする特殊ケースとして、正規表現を典型的なバインディング構文と共にパターンとして使用することもできます。たとえば、この式:

match "foobar" with
| 'f(?<us>u*)bar' -> us
| 'f(?<os>o*)bar' -> os
| _               -> "???"

2番目の正規表現にマッチし、変数osにo*にマッチする入力のサブシーケンスをバインドするため、"oo"に評価されます。

最後に、match式がswitchステートメントを一般化するもう1つの方法は、ケースにガード式を含めることができることです。これにより、ブランチをフォローするかどうかを最終的に決定できます。たとえば、この式:

match 1 2 with
| 1 x where x > 10 -> 1
| _ _              -> 2

入力はパターン1 xで最初の行にマッチしますが、ガード式x > 10(この場合、2 > 10)はfalseに評価されるため、その行のブランチはフォローされず、最後の行のみがマッチするため、2が返されます。

有効(およびそれに続くコンパイル)と見なされるためには、matchテーブルは網羅的であり、すべての行は到達可能である必要があります。網羅的であるということは、matchテーブルのすべての可能な入力に対してマッチする行があることを意味します(これが、例が常に「すべてをマッチする」行で終わる理由です。例:| _ -> -1)。行が到達可能であるということは、前の行がそれを完全に包含して冗長にしないことを意味します(このチェックはコンパイラフラグで無効にできますが、プログラマがパターン行を導入するのはそれらが関連性があることを意図しているという仮定の下でデフォルトでオンになっています)。matchのこの解釈は、ocamlやHaskellとはわずかに異なります。たとえば、網羅的でないマッチは警告でフラグ付けされ、実行時に一致しない入力が与えられたときにプログラムの実行を中止する可能性があります。

match式の完全な一般形式は次のように記述できます。

match I0 I1 ... IN with
| p00 p10 ... pN0 where C0 -> E0
| p01 p11 ... pN1 where C1 -> E1
| ...
| p0R p1R ... pNR          -> ER

ここで、I0、I1、...、INはそれぞれマッチングされる値の式であり、各pijはIiとマッチするパターン、Crはp0rからpNrまでの変数に対して評価される条件、各Erは行rが選択された場合に返される結果式です(暗黙的に、各Erの型は同じである必要があります)。

そしてパターンは、文法によって自由に生成される任意の項です。

pattern := constant
        |  variable
        |  [pattern, pattern, ..., pattern]
        |  regex
        |  (pattern, pattern, ..., pattern)
        |  {f0=pattern, f1=pattern, ..., fN=pattern}
        |  |C=pattern|

ここで、constantは任意の定数値(()、true、42、'c'など)、variableは任意の名前(行全体で一意)、f0、f1、...、fNはレコードフィールド名、Cはバリアントコンストラクタ名です。

便宜上、式E matches pはmatch E with | p -> true | _ -> falseに脱糖されます。パターンpが不可避(つまり、決してマッチに失敗しない)場合、let p = E in Bはmatch E with | p -> Bに脱糖されます。パターンpが不可避の場合、\p.Eは\x.match x with | p -> Eに脱糖されます。パターンpが回避可能な場合、式\p.Eは\x.match x with | p -> just(E) | _ -> nothingに脱糖されます。パターンpが不可避の場合、[E | p <- S]はmap(\p.E, S)に脱糖されます。パターンpが回避可能な場合、[E | p <- S]はdropNulls(map(\p.E, S))に脱糖されます。

パターンマッチングは、さまざまな種類のアプリケーションで非常に役立ちます。hobbesのいくつかの用途では、それは「ルールエンジン」の一種としても機能します(行が「ルール」である場合)。ユーザーは非常に効率的なマシンコードを非常に大きなmatchテーブルから導き出すことができます。

Parsing

多くの解析問題はmatch式で解決できますが、基本的な式言語はmatch式でサポートされている単純な正規表現では解析できません。

これらのケースでは、hobbesは文脈自由文法(技術的には、LALR(1)パーサーを生成します)に基づいたパーサーの導入のための構文を定義します。これらの方法の多く(例:yacc、GNU bison、happyなど)と同様に、解析ルールは構文と各ルールから意味値を生成するための「アクション」の両方を定義します。

例として、算術式の基本的な計算機を構築できます。まず、最も簡単な最初のステップ、単一の数字を認識するパーサーから始めましょう。

$ cat p.hob

calc = parse {
  D := "0" {0} | "1" {1} | "2" {2} | "3" {3} | "4" {4}
    |  "5" {5} | "6" {6} | "7" {7} | "8" {8} | "9" {9}
}

ここでは、単一の定義(calc変数を定義するため)のみを含むファイルがあります。この定義で、parse { RULES }構文を使用して、RULES内のすべてのルールに基づいたパーサーを構築し、シーケンスの最初のルール(この場合はDのルール)から開始します。ここでは構文項は単純です("0"、"4"などの定数字句値)し、アクションも単純です(0、4などを返す)。これらのアクションは任意のhobbesコードにすることができ、パーサーをより有用なものに開発する際に役立ちます。

今のところ、このファイルをhiプログラムでロードした場合、まずこの新しい定義の型を確認できます。

$ hi p.hob
hi : an interactive shell for hobbes
      type ':h' for help on commands

loaded module 'p.hob'
> :t calc
Array a char => (a) -> (() + int)

これは、準備されたパーサーが実際にはオーバーロードされた関数であり、文字の配列として解釈できる任意の型を「おそらくint」(パーサー入力が認識されない可能性があるため、「おそらく」です)にマッピングすることを示しています。

このパーサーと対話して、その単純な動作を確認できます。

> calc("9")
9
> calc("42")

> 

これで、単一の数字を含む文字列は認識されますが、複数桁の入力を読み取ろうとすると値が生成されないことがわかります。そこで、p.hobファイルに戻り、複数桁を受け入れるように文法を少し拡張できます。

calc = parse {
  V := v:V d:D { v*10 + d }
    |  d:D     { d }

  D := "0" {0} | "1" {1} | "2" {2} | "3" {3} | "4" {4}
    |  "5" {5} | "6" {6} | "7" {7} | "8" {8} | "9" {9}
}

ここで、いくつかの新しいアイデアを導入しました。まず、Vのルールは、字句構文を直接指定するのではなく、D(およびV自体)のルールに基づいて構文を定義します。また、Vのルールは、マッチしたサブルールに値をバインドします(vとd変数)。これらの値は、それらのルールのためのアクションで使用できます。最後に、Vの最初のルールは、通常の整数値に段階的に変換される、無制限長の字句数字シーケンスを受け入れるために左再帰を使用します。これは、別の対話で確認できます。

> calc("42")
42
> calc("8675309")
8675309

しかし、無意味な入力(まだ算術演算子を含む入力)は拒否されます。

> calc("1+2")

> calc("cheeseburger")

> 

最後に、典型的な算術文法によって、標準的な演算順序を尊重して算術演算子のサポートを追加できます。

calc = parse {
  E := x:E "+" y:T { x + y }
    |  x:E "-" y:T { x - y }
    |  x:T         { x }

  T := x:T "*" y:F { x * y }
    |  x:T "/" y:F { x / y }
    |  x:F         { x }

  F := "(" x:E ")" { x }
    |  x:V         { x }

  V := v:V d:D { v*10 + d }
    |  d:D     { d }

  D := "0" {0} | "1" {1} | "2" {2} | "3" {3} | "4" {4}
    |  "5" {5} | "6" {6} | "7" {7} | "8" {8} | "9" {9}
}

そして、単純な算術式の認識と評価ができるパーサーができました。

> calc("9*(7+(8-4*3)/2)-3")
42

構文的に有効なすべてのパーサー定義が有効なパーサーを生成するわけではありません。一部のパーサー定義は曖昧な選択を導入します(パーサーが2つの等しく有効なパスから選択する必要がある場合)。Hobbesでは、これらは予測不能なパフォーマンスを受け入れるのではなく、エラーとして扱われます(すべての解析時間はn入力文字に対してO(n)になります)。

たとえば、次のようなパーサー定義を考えてみましょう。

$ cat e.hob

err = parse {
  S := "a" { 1 }
    |  z:Z { z }

  Z := "a" { 2 }
}

ここで、入力"a"に対してS定義を解析すると、S := "a"の最初のパス(結果として1を与える)を選択するか、またはz:Zを介してZ := "a"を選択する(結果として2を与える)かのいずれかを選択できるため、曖昧である必要があります。この選択が曖昧であるため、hobbesは文法が間違っている場所を示すエラーでパーサーを拒否します。

$ hi -s e.hob
e.hob:2,7-7,1: Conflict between r0 and r0 on $
S -> 'a'# [$]
Z -> 'a'# [$]

このエラーメッセージでは、記号#は基本的な文法規則の(パーサーアイテムのような)位置を示すことを意図しており、角括弧内の記号は、規則が完了または削減できるとパーサーが結論付けることを可能にするルックアヘッド値を示しています。したがって、上記のエラーメッセージは、指定された状態では、入力終了ターミナル(別名$)でS -> 'a'#またはZ -> 'a'#で削減できることを示しています。

Type Classes

Hobbesでは、ユーザー定義のオーバーロードとアドホックな型分析は、型クラスの使用を通じて定義できます。型クラスは、元々Haskellで導入されましたオーバーロードと型推論を組み合わせる方法として。これらは、Hobbesで採用されている見解(ただし、Hobbesプログラムの型制約の大部分はこれまで型クラスを指定しています)と同様に、修飾型の特殊な使用法としても見ることができます。形式的な声明の前にアイデアの直観を得るために、いくつかの簡単な例を考えてみましょう。

考慮すべき最も単純な型クラスの1つは、値を文字列に変換する役割を持つShowクラスです。Hobbesでは、Showは次のように定義されています。

class Show a where
  show :: a -> [char]

この定義は、制約Show aが、a -> [char]の関連関数showが存在する場合にのみ真であると読むことができます。Haskellと同様に、インスタンス定義でこれらの関連関数を導入します。

instance Show int where
  show = showInt

Hobbesによってデフォルトで定義されている関数showInt :: int -> [char]が存在するため、int値のshow関数として完全に機能します。この定義が設定されていると、次のように評価できます。

> show(42)
"42"

しかし、Hobbesは通常の型のファミリもサポートしており、各Showインスタンスを個別に定義することはプリミティブ型にとって十分に機能しますが、[int]型の値や[[int]]や[[[int]]]などの値を示すために同じことをしなければならない場合、非常にフラストレーションがたまるでしょう。配列の場合のように、規則的なルールがある場合は、インスタンスジェネレータを使用できます。

instance (Show a) => Show [a] where
  show xs = "[" ++ cdelim(map(show, xs), ", ") ++ "]"

この定義は、前の通常のinstance定義とほぼ同じように見えますが、制約が=>の左側にあるという点で、修飾型と同様です。この場合、(Show a) => Show [a]を読み取るのに良い方法は、「Show aインスタンスが存在することが真実であれば、Show [a]インスタンスを作成できる」ということです。次に、そのような[a]型の任意の値に対して機能するshowの定義を導入します。cdelim :: ([[char]]*[char]) -> [char]という関数が文字列をインターリーブされた文字列の配列を連結するために利用可能であるため、この関数を簡単に記述して、入力配列の各値を表示し、それらを1つの大きな文字列に結合できます。

プロンプトで実験すると、複数のレベルの配列ネストがこの定義を一様に適用することがわかります。

> :t [[[1,2],[3,4]], [[5,6],[7,8]]]
[[[int]]]
> show([[[1,2],[3,4]], [[5,6],[7,8]]])
"[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]"

> :t [[1,2,3,4], [5,6,7,8]]
[[int]]
> show([[1,2,3,4], [5,6,7,8]])
"[[1, 2, 3, 4], [5, 6, 7, 8]]"

> :t [1,2,3,4,5,6,7,8]
[int]
> show([1,2,3,4,5,6,7,8])
"[1, 2, 3, 4, 5, 6, 7, 8]"

配列と同様にタプルを考慮する場合、タプルに対してShow型のセットをさらに拡張できます。この場合、タプルは配列とは異なり、異種型になるように意図的に設計されているため、それらを評価するためのmapのような単純な関数はありません。しかし、同様の役割を果たす新しい型クラスを作成できます。

class ShowTuple p where
  showTuple :: p -> [[char]]

タプルが完全に考慮されたときに単位型()で底を打つ場合(タプルをデコンストラクトするために、インスタンスジェネレータ内でp=(h*t)という特別な制約を使用できます)。

instance (p=(h*t), Show h, ShowTuple t) => ShowTuple p where
  showTuple p = [show(p.0)] ++ showTuple(tupleTail(p))
instance ShowTuple ()
  showTuple _ = []

これらの定義があれば、配列に対して決定したものと同じ中間文字列配列を決定できます。これらをShowに持ち込むために必要なのは、同じcdelimメソッドを使用することだけです。

instance (ShowTuple p) => Show p where
  show p = "(" ++ cdelim(showTuple(p), ", ") ++ ")"

そして、前のShowの定義と共にプロンプトでこれを実行すると、さらに複雑な型を表示できます。

> show(42)
"42"
> show((42,[1,2,3]))
"(42, [1, 2, 3])"
> show((42,[1,2,3],[(4,5),(6,7)]))
"(42, [1, 2, 3], [(4, 5), (6, 7)])"

これまではShowを典型的な型クラスの例として検討してきましたが、複数の型を組み合わせて検討する必要がある場合もあります。たとえば、オーバーロードされた加算の単純な型クラスを試すことができます。

class Addable a b c where
  (+) :: (a,b) -> c

整数加算のプリミティブCPU命令の関数iadd :: (int,int) -> intが存在すると仮定すると、インスタンスを導入しようとするかもしれません。

instance Addable int int int where
  (+) = iadd

これは確かに機能しますが、プロンプトでこれを使用しようとするとエラーが発生します。

> 1 + 2
stdin:1,1-5: Failed to compile expression due to unresolved type constraints:
  Addable int int a
  Print a
> 

ここでの問題は、結果の型を推論できなかったことです。結果の型を明示的に注釈付けすると機能します。

> (1+2)::int
3
> (3+4)::int
7

しかし、これは非常に不便な制限であり、より複雑な型や複数の連続した合計ではさらに不条理になる可能性があります。要するに、加算の結果の型は変化する可能性があるが、最初の2つの型によって一意に決定されることを型推論とインスタンス選択に伝える方法が必要です。現在Hobbesでは、この問題に対処する方法は関数従属です。要するに、型クラスを定義するときに、3番目の型が最初の2つによって一意に決定されるという事実を含めます。

class Addable a b c | a b -> c where
  (+) :: (a,b) -> c

この変更により、結果の明示的な型注釈を導入する必要はなくなります。インスタンス選択は最初の2つの型に基づいてのみ検索し、見つかった単一のインスタンスに対してc=intであることを型推論に伝えます。

型クラスの例とアプリケーションは、hobbes/boot/スクリプトにさらに記載されています。これらは、C++でhobbes::ccインスタンスが構築されるとき、またはhiプログラムが最初に実行されるときにロードされます。

HobbesとHaskellにおける型クラスの解釈の重要な違いは、Hobbesがオーバーロードされた識別子の一般的な辞書渡し変換を使用しないことです。代わりに、Hobbesは、任意の満たされた制約に対して、その制約を含む式をそれを含まない等価な式に書き換えることができるロジックも提供する必要があると要求します。たとえば、Show例でのhiプロンプトで、:uコマンドを使用して、式レベルでのこのプロセスの結果を示すことができます(ここでは明白な型注釈が削除されています)。

> :u show(42)
showInt(42)

この区別は重要です。なぜなら、間接関数辞書が渡される場合よりも効率的なマシンコードを導き出すことができるからです(ただし、アプローチはよく知られており、欠点もあります)。

Unqualifier Modules

HobbesのC++インターフェースは、カスタム「アンクオリファイヤ」の導入をサポートしています(そして、前述の型クラスシステムは、そのような「アンクオリファイヤ」実装の1つにすぎません)。標準のアンクオリファイヤセットはhobbes/lang/preds/に定義されていますが、Unqualifierインターフェースを実装することによって独自のものを導入することが可能です。これにより、前述のすべてのメカニズムが利用可能になります。この定義はhobbes/lang/tyunqualify.Hにあります。

struct Unqualifier {
  // 制約内の暗示的な型変数をバインドする
  virtual bool refine(const TEnvPtr& tenv, const ConstraintPtr& cst, MonoTypeUnifier* u, Definitions* ds) = 0;

  // この制約が満たされているかどうかを判断する
  virtual bool satisfied(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const = 0;

  // この制約が満たされる可能性があるかどうかを判断する
  virtual bool satisfiable(const TEnvPtr& tenv, const ConstraintPtr& cst, Definitions* ds) const = 0;

  // この制約が解消されなかったのはなぜか?
  virtual void explain(const TEnvPtr&, const ConstraintPtr&, const ExprPtr&, Definitions*, annmsgs*) = 0;

  // 修飾式を解決する
  virtual ExprPtr unqualify(const TEnvPtr& tenv, const ConstraintPtr& cst, const ExprPtr& e, Definitions* ds) const = 0;

  // オーバーロードされたシンボルを許可する(型クラスのように)
  virtual PolyTypePtr lookup(const std::string& vn) const = 0;
  
  // オーバーロードされたシンボルをリストする(存在する場合)
  virtual SymSet bindings() const = 0;

  // 制約パラメータ間の関数従属をリストする(存在する場合)
  virtual FunDeps dependencies(const ConstraintPtr&) const = 0;
};

独自の制約アンクオリファイヤを実装するために実装する必要がある主要な関数は次のとおりです。

  • refine:制約の一部を他の部分から推論できます。
  • satisfied:制約が完全に満たされているかどうかを判断します。
  • unqualify:満たされた制約を持つ式を、その制約のない等価な式に書き換えます。

通常、新しいアンクオリファイヤをこのように導入する必要はありませんが、他のすべてのオプションが不十分な場合には非常に役立つツールになります。独自のコンパイラモジュールの実装を定義したら、型がPであり、"ConstraintName"という名前の制約を解決したいと仮定して、hobbes::cc::typeEnv()->bind("ConstraintName", UnqualifierPtr(new P()))でインストールできます。

独自のアンクオリファイヤモジュールを実装することを決定する理由は何でしょうか?最終的にはユースケースの特定の問題になりますが、一般的には、初期段階で外部リソースを設定して、後続の段階で任意にクエリできるようにする必要がある場合に良いオプションです。

前に見たように、hobbesにはLoadFile制約があり、コンパイル時文字列(構造化データファイルへのパス)と型変数を受け取ります。この制約を処理するUnqualifier実装(hobbes/db/bindings.Cにあります)は、ファイルをコンパイル時にロードし、その型構造を決定し、制約の2番目の引数をこの型構造にrefine(または統一)して、後続の型チェックとファイルの内容に対するコンパイルを可能にします。また、構造化ファイルデータへの更新に応答するコールバックまたは「テール」の以前に言及したインストールの処理(最終的にはLinux上のepollとinotifyとの対話に還元される)を処理するためのAddDBFieldSignal制約もhobbes/db/signals.Cに定義されています。これらのアンクオリファイヤモジュールを追加することで、型チェックや記録されたデータを反応/クエリするための効率的なコードのコンパイルを犠牲にすることなく、記録されたデータに対する柔軟な「動的なダックタイピング」スクリプティングが可能になります。

前に見たもう1つの例は、hobbesのConnect制約です。これもコンパイル時文字列を受け取り、コンパイル時に確立された接続を表す一意の型を生成します。これは、プロトコルをネゴシエートし、リモートプロセスとの通信のための効率的なコードを導き出すために、さらに(および他のサポート制約/アンクオリファイヤと共に)使用されます。

これらはUnqualifierインターフェースを介したhobbesの拡張のほんの一例ですが、このオプションがhobbesを使用するアプリケーションに役立つ可能性のある他の多くの方法があることは間違いありません。

Releases

リリースはソースのみです。Hobbesはコンパイルによって消費されるため、ビルド成果物は公開されません。各リリースは、再現可能なソースアーカイブ、SHA256SUMSファイル、およびそれらのチェックサムに対するSigstore署名で構成されます。

署名はキーレスです。署名はリリースワークフローのOIDC IDにバインドされ、公開されているRekorトランスペアレンシーログに記録されるため、管理する署名キーはありません。その正確なIDに対して検証してください。以下のパターンは、このリポジトリ、このワークフローファイル、およびタグ参照にバインドされるため、他のワークフローによって生成された署名は受け入れられません。

cosign verify-blob \
  --certificate SHA256SUMS.pem \
  --signature SHA256SUMS.sig \
  --certificate-identity-regexp \
    '^https://github\.com/morganstanley/hobbes/\.github/workflows/release\.yml@refs/tags/v' \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com \
  SHA256SUMS

sha256sum -c SHA256SUMS

リリースは、v*に一致するタグをプッシュすることによってカットされ、リリースに名前が付けられます。タグに署名することは推奨されます(誰がカットしたかを証明します)が、ワークフローはそれを要求せず、リリース署名はそれに依存しません。

git tag -s v1.0.0 -m "hobbes 1.0.0"
git push origin v1.0.0

各メジャーバージョンにはコードネームも含まれています。哲学からの2つの頭文字の単語で、順に文字が付けられています。したがって、v1.xはAnalytic Aporia、v2.xはBeing Becomingなど、Zeno's Zenithまで続きます。完全なリストはRELEASE_CODENAMES.tsvにあります。リリースワークフローは、リリースをタイトル付けするためにそれを読み取ります(v1.0.0 "Analytic Aporia")。タグは権威あるバージョンとして残ります。コードネームは装飾であり、行のないメジャーバージョンには単にそれがないだけです。