Show HN：すべてが値渡しの小さなプログラミング言語

Herd

Herd はすべてが値であるというシンプルな解釈型プログラミング言語です。

免責事項：これは趣味用の言語です。本格的に使うことはおすすめしません。

Herd の特徴

Herd では、リストや辞書も含めてすべてが 値渡し（pass‑by‑value）です。
関数へリストや辞書を渡しても、元のコピーは変更できません。

var foo = { a: 1 };
var bar = foo;        // foo のコピーを作る
set bar.a = 2;         // bar を変更（コピーが作られる）
println foo.a bar.a;   // 1 2 と出力される

動作原理

文字列・リスト・辞書などの参照型は参照カウントで管理されます。
参照型をコピーするとカウントが増加します。変更時には次のように動きます。

• 参照が一つだけなら、値をその場で変更できる。
• 参照が複数ある場合は「shallow copy（浅いコピー）」を作り、そのコピーに変更を適用する。

すべての値は

var

他言語との比較

言語ツアー

Hello world

println 'Hello, world!'

変数

x = 1;            // 不可変変数
var y = 2;        // 可変変数
set y = 3;        // 可変変数を変更

型

()

bool

true

false

number

string

list

[1, 2, 3]

dict

{ x: 1, y: 2 }

function

\x y\ x + y

リストと辞書

var list = ['a', 'b', 'c'];
set list.[1] = 'z';
println list;      // ['a', 'z', 'c']

var dict = { x: 1, y: 2 };
set dict.x = 3;
println dict;      // { x: 3, y: 2 }

x = 10;
y = 20;
dict = { x, y };   // ショートハンドで { x: x, y: y }

ブロック

x = (
  a = 2;
  b = 3;
  a + b
);
println x;         // 5

関数

すべての関数は匿名構文で書く。

// 二引数関数
multiply1 = \a b\ (
  return a * b;
);

x = multiply1 3 4;
println x;         // 12

// 単一式ボディ（return は不要）
multiply2 = \a b\ (a * b);

// シンプルな式構文
double = \n\ n * 2;

// 引数なし関数
getRandomNumber = \\ Math.randomInt 0 100;
println getRandomNumber ();   // ランダム整数

// 可変長引数（最後のパラメータは `..`）
min = \first ..rest\ (
  var minVal = first;
  for x in rest do (
    if x < minVal then set minVal = x
  );
  minVal
);
println min 5 3 8;   // 3

値と可変性

var

list = ['a', 'b'];          // 不可変
set list.[0] = 'A';         // ❌ 変更不可

var list1 = ['a', 'b'];
var list2 = list1;          // コピー
set list2.[0] = 'c';
println list1;              // ['a', 'b']
println list2;              // ['c', 'b']

関数へ値を渡すときもコピーが作られます。

doubleEveryItem = \var list\ (
  for [i, x] in List.enumerate list do set list.[i] = x * 2;
  list
);
list1 = [3, 4];
list2 = doubleEveryItem list1;
println list1;              // [3, 4]
println list2;              // [6, 8]

パターンマッチング

!

list = [1, 2];
![a, b] = list;
println a;                 // 1
println b;                 // 2

dict = { x: 10, y: 20 };
!{ x, y } = dict;
println x;                 // 10
println y;                 // 20

switch 式：

x = [1, 2, 3];
y = switch x on {
  [] => 'Empty list',
  [1, ...rest] => 'Begins with 1, then ' ++ toString rest,
  [a] => 'Single item: ' ++ toString a,
  _ => 'Something else'
};
println y;                 // Begins with 1, then [2, 3]

可変変数への分解：

list = [1, 2];
[a, var b] = list;
set b = b + 10;
println [list, a, b];      // [[1, 2], 1, 12]

パイプ演算子

関数呼び出しをチェーンします。

x = [1, 2, 3]
  | List.map \(_ * 2)          // 各要素を二倍
  | List.filter \(_ > 3);      // 3より大きいものだけ残す
println x;                     // [4, 6]

|=

var x = [1, 2];
set x |= List.push 3;
println x;                     // [1, 2, 3]

モジュールとインポート

コードを返してエクスポートします。

// file1.herd
x = 42;
double = \n\ n * 2;
return { x, double };

他でインポート：

!{ x, double } = import 'file1.herd';
println double x;              // 84

File1 = import 'file1.herd';
println File1.double File1.x;  // 84

標準ライブラリ

モジュールは事前にインポートされ、

Module.function

グローバル関数として

not

range

assert

toString

print

println

len

マルチスレッド

list = [1, 2, 3];
squared = Parallel.parallelMap list \(_ * _);
println squared;              // [1, 4, 9]

getOrder = \id\ (...);        // TODO
getCatalog = \\ (...);        // TODO
orderId = 123;

![order, catalog] = Parallel.parallelRun [
  \\ getOrder orderId,
  \\ getCatalog ()
];

データ競合は起こらず、スレッド間の通信は戻り値で行います。

設計方針

動的型付け

簡潔さとインタープリタ設計の実験を重視して採用しました。

ユーザー定義型

現在は存在しません。将来的には構造体や多相ディスパッチを追加する予定です。

セミコロン

読みやすさのために使用していますが、文法上必須ではありません。

変数宣言

デフォルトで不変（

=

var

set

関数構文

Rust のクロージャ (

\

\(func x _)

パフォーマンス

• Cranelift を使った単一パス JIT → CPython と競合的、最新の JS ランタイムより遅い。
• プリミティブは NaN‑boxing でヒープ割り当てを回避。
• 主なボトルネック：ホットループでの原子参照カウントオーバーヘッド、単一パス JIT の最適化不足。

ベンチマーク（i5‑13600KF）：