Laping (.lp)

Lap + Lang = Laping

読んだ順に理解できて、間違いにすぐ気づけることを目指した、C言語製のインタプリタ型プログラミング言語です。 Lexer → Parser → Tree-walking Interpreter という構成で、外部の構文解析ライブラリには依存していません（HTTP通信用に自動更新機能のみ libcurl を使用）。

record Sale(shop, price, qty)
fn Sale.total(s) => s.price * s.qty

sales = [Sale("東京", 120, 30), Sale("大阪", 110, 45), Sale("東京", 400, 8)]

# データは -> で左から右へ流す
tokyo = sales -> filter(fn s => s.shop == "東京") -> map(fn s => s.total()) -> sum()
print("東京の売上: {tokyo:>8} 円")

# 無いかもしれない値は else で既定値に
config = {server: {host: "example.com"}}
port = config.server.port else 8080

# 何をするかを先に、条件は後ろに（後置修飾子）
print("{s.shop}: {s.total()}") for s in sales if s.total() > 3000

# テストは同じ言語で、すぐ横に書ける（laping test で実行）
test "売上を計算できる" {
    expect Sale("東京", 100, 3).total() == 300
}

🤖 AI に Laping のコードを書かせるとき

Laping は新しい言語なので、AI（ChatGPT・Claude・Gemini など）はそのままでは Python や JavaScript の書き方を混ぜてしまいます。AI 向けの仕様書 docs/AI_GUIDE.md を用意しているので、次の指示文を会話の最初に貼り付けてください。

これから Laping（拡張子 .lp）というプログラミング言語でコードを書いてください。
Laping は Python や JavaScript に似ていますが別の言語です。推測で他の言語の書き方を使わず、
次の仕様書に書かれている構文と組み込み関数だけを使ってください。
https://raw.githubusercontent.com/Lapius7/laping-lang/main/docs/AI_GUIDE.md

仕様書を読めない場合は、少なくとも次を守ってください。
- 関数は fn f(a, b) { return a + b } または fn f(a, b) => a + b。無名関数は fn x => x * 2
- ブロック形式の関数は最後の式を自動では返さない。値を返すところには return を書く
- if / for / while の条件に括弧もコロンも付けない: if x > 0 { ... }、for i in 0...n { ... }（... は終端を含まない、.. は含む）
- nil / true / false（None・null・True は無い）。論理演算は and / or / not
- "a" + 1 はエラー。文字列には "{x}" で埋め込む（書式は "{x:.2}"、"{x:>5}"）。文字の { は \{ と書く
- 無いかもしれない値は 値 else 既定値（例: m.key else 0）。条件で値を選ぶときは 条件 then a else b
- データは -> でつなぐ: xs -> filter(fn x => x > 0) -> map(fn x => x * 2) -> sum()（x -> f(a) は f(x, a)）
- リストへの追加は xs.push(x)、長さは len(xs)。クラスは無いので record Point(x, y) と fn Point.dist(p) => ... を使う
- 関数の中のローカル変数は let x = 1。全部大文字の名前は定数で再代入できない
- 後置修飾子が使える: print(x) if x > 0 / print(x) for x in xs / write("★") repeat 3
- 予約語 repeat is then match などは変数名にしない

AI が Web を読めない場合は、docs/AI_GUIDE.md の中身をそのまま貼り付けても使えます。ルートの llms.txt にも、AI 向けの文書の場所をまとめています。

特徴

• 読んだ順に理解できる: -> パイプライン、後置修飾子（stmt if cond / for / repeat）、then / else による値の選択
• 記号より言葉: 既定値は 値 else 既定値、型の判定は x is list、回数の繰り返しは repeat 3 { }
• 間違いにすぐ気づける: record の打ち間違いフィールド、不明な型名、定数（全部大文字の名前）の書き換えをエラーにし、「もしかして」の候補を出す
• 管理しやすい: import "x" as x でモジュールごとに名前を分け、_ で始まる名前は非公開。テストは test ブロックで同じファイルにも書ける
• 見やすい CLI: 該当行と ^ を示す色付きのエラー表示、コマンド付きの対話モード、laping test / check / new / doc
• 関数・クロージャ・fn x => x * 2・デフォルト引数・可変長引数、リスト・マップ・範囲・内包表記、match（式としても使える）、try / catch / finally
• 文字列への式の埋め込みと書式（"合計 {a + b:>8} 円"）、UTF-8 対応（日本語の文字数・添字・変数名、全角文字の表示幅）
• 表・枠・進捗バー・色などの画面表示、JSON、データ集計を含む 120 以上の組み込み関数（laping doc で一覧）
• 暗黙の型変換なし、マーク&スイープ GC、単一バイナリ、laping update で自動更新

設計方針 — なぜこの書き方なのか

Laping の構文は、他の言語の記号をそのまま借りるのではなく、それぞれに「こう書くと楽になる」「こう書くと間違えにくい」という理由があるものにしています。

インストール

npm（推奨・Linux / macOS / Windows）

npm i -g @lapius/laping-lang

OS と CPU に合ったビルド済みバイナリが入り、laping コマンドが使えるようになります（Node.js 18 以降、C コンパイラ不要）。更新も同じコマンドです（npm 版では laping update は自動更新せず、この更新コマンドを案内します）。

Releaseから取得

Releases から OS に対応するファイルをダウンロードしてください。

• Linux: laping-linux-x86_64
• Windows（インストーラー、推奨）: laping-windows-x86_64-setup.exe
• Windows（zip展開、上級者向け）: laping-windows-x86_64.zip（laping.exe と libcurl-x64.dll が同梱）

Linuxの場合は実行権限を付与してパスの通った場所に置きます。

chmod +x laping-linux-x86_64
mv laping-linux-x86_64 ~/.local/bin/laping

Windowsの場合は laping-windows-x86_64-setup.exe を実行すると、一般的なセットアップウィザード（インストール先選択 → インストール中のプログレスバー → 完了画面）でインストールされます。インストール先は自動でPATHに追加されるため、インストール後はコマンドプロンプトやPowerShellからどのフォルダでも laping コマンドが使えます。スタートメニュー・デスクトップへのショートカット作成、「アプリと機能」からのアンインストールにも対応しています。

laping-windows-x86_64.zip は、インストーラーを使わずにポータブルな形で使いたい場合のみ展開して laping.exe と libcurl-x64.dll を同じフォルダに置いて使います（DLLが無いと起動できません）。

ソースからビルド

libcurl の開発用ヘッダが必要です（自動更新機能のため）。

# Ubuntu/Debian
sudo apt-get install libcurl4-openssl-dev

make
make test      # テストを実行
make install   # ~/.local/bin/laping にインストール

ソースは src/ にあります。

使い方

laping main.lp              # main.lp を実行
laping main.lp a b c        # 引数付きで実行（スクリプト内では args で受け取れる）
laping                      # 対話モード (REPL) を起動
laping run main.lp          # 実行（laping main.lp と同じ）
laping check *.lp           # 実行せずに構文だけを確認
laping test                 # *_test.lp の test ブロックを実行（フォルダやファイルも指定できる）
laping new myapp            # プロジェクトのひな形（main.lp・lib.lp・main_test.lp）を作る
laping doc                  # 組み込み関数の一覧
laping doc format           # 関数の説明
laping -e 'print(1 + 2)'    # コードを直接実行
laping update               # 最新版を確認し自動更新（npm 版は更新コマンドを表示）
laping version              # バージョン表示
laping help                 # 使い方

端末に出力しているときは、エラーや表が色付きで表示されます。NO_COLOR=1 で色を消し、LAPING_COLOR=always で常に色を付けられます。

対話モード

入力した式の値が色付きで表示されます。{ や ( が閉じていない間や、行末が -> の間は続きの行を入力できます。

laping› xs = [3, 1, 2]
laping› xs -> sort()
=> [1, 2, 3]
laping› fn sq(x) {
   …     return x * x
   … }
laping› sq(12)
=> 144
laping› :time (1..100000) -> sum()
=> 5000050000
  0.004 秒

テスト

*_test.lp というファイルに test ブロックを書き、laping test で実行します。expect が失敗すると、比較の左辺と右辺の値が表示されます。

# calc_test.lp
fn add(a, b) => a + b

test "足し算ができる" {
    expect add(1, 2) == 3
}

▶ calc_test.lp
  ✓ 足し算ができる
  ✗ わざと失敗
      expect が失敗しました: 左辺は 4、右辺は 5
      場所: calc_test.lp:6

✗ 2 件中 1 件が失敗しました (0.00 秒)

test ブロックは laping test のときだけ実行され、普通に laping calc_test.lp と実行したときは飛ばされます。そのため、関数を定義したファイルに直接テストを書いておくこともできます。

自動更新の仕組み

Release から取得した版で laping update を実行すると、以下の流れで動作します（npm で入れた場合は自動更新せず、npm i -g @lapius/laping-lang を案内します）。

1. https://api.github.com/repos/Lapius7/laping-lang/releases/latest にアクセスし、最新リリースのタグを取得
2. 実行中のバージョン（laping --version）と比較
3. ローカルより新しければ、OSに対応する配布物をダウンロード（Linuxはlaping-linux-x86_64、Windowsはlaping-windows-x86_64.zip）
4. Windowsの場合は標準搭載のtar.exeでzipを展開し、中のlaping.exeとlibcurl-x64.dllを取り出す（Windows 10 1803以降が必要）
5. 現在の実行ファイル（とWindowsの場合はDLL）をバックアップしてから新しいものに置き換える

開発者がGitHubに新しいバージョンをタグ付き（vX.Y.Z）でプッシュすると、CI（GitHub Actions）がLinux/Windows向けにビルドしてReleaseへ自動添付します。同じタグから npm 版も自動で公開されます。各ユーザーは laping update（npm 版は npm i -g @lapius/laping-lang）を実行するだけで最新版に追従できます。

構文リファレンス

コメント

# 行コメント
x = 1  # 行末コメントも可

#[
  ブロックコメント
  複数行にわたって書ける
]#

文の区切り

文は改行で区切ります。1行に複数の文を書く場合は ; で区切ります。

a = 1; b = 2; print(a + b)

次の場合は改行しても文が続いているとみなされます。

• ( ) や [ ] の内側
• 行末が演算子・,・= などで終わっている
• 次の行が . で始まる（メソッドチェーン）
• 行末に \ を書いた

total = 1 +
    2 +
    3

result = [1, 2, 3, 4]
    .filter(fn(x) => x % 2 == 0)
    .map(fn(x) => x * 10)

値の種類

真偽の判定: false・nil・0・空文字列 ""・空リスト []・空マップ {} は偽、それ以外は真です。

変数と代入

x = 10
name = "Laping"
名前 = "日本語の変数名も使えます"

a, b = 1, 2        # 複数同時に代入
a, b = b, a        # 入れ替え
first, second = ["F", "S"]   # リストを分割して代入

x += 5             # 複合代入: += -= *= /= %=

• 代入は 変数名 = 式。変数は宣言不要（代入した時点で生成される）
• 未定義の変数を参照すると実行時エラーになり、行番号付きで表示される
• let x = 値 は「現在のスコープに新しい変数を作る」宣言です（下記「スコープ」参照）

演算子

優先順位の高い順:

演算子の型の規則（暗黙の型変換はしません）:

and / or は真偽値ではなく、評価したオペランドの値をそのまま返します。0 や "" も置き換えたくない場合は、次の else を使ってください。

パイプライン ->

x -> f(a, b) は f(x, a, b) と同じ意味です。データを左から右へ流すように書けるので、処理を書いた順に読めます。右側が関数そのもの（x -> sqrt）なら sqrt(x) になります。行頭に -> を書けば、次の行へ続けられます。

[3, 1, 4, 1, 5, 9]
    -> filter(fn x => x > 2)
    -> map(fn x => x * 10)
    -> sort()
    -> print()                 # [30, 40, 50, 90]

既定値 else と、値を選ぶ then / else

値 else 既定値 は、値が nil のときに既定値を使います。さらに左側の a.b.c や a[i] の途中で、nil になった・キーが存在しない・添字が範囲外だった場合も、エラーにせず既定値を使います。変数名の打ち間違い（未定義の変数）は、これまでどおりエラーになります。

config = {server: {port: 8080}}
port = config.server.port else 80           # 8080
host = config.server.host else "localhost"  # キーが無いので "localhost"
first = args[0] else "引数なし"               # 範囲外なので "引数なし"
count = 0 else 10                           # 0（or と違い 0 や "" は置き換えない）
name = user.name else throw "name がありません"  # 無ければエラーにする

条件 then 値1 else 値2 は、条件が真なら値1、偽なら値2 になります。

print(n % 2 == 0 then "偶数" else "奇数")
size = n > 100 then "大" else n > 10 then "中" else "小"

連鎖比較と is

1 < x < 10 は 1 < x and x < 10 と同じ意味です（x は1回だけ評価されます）。is は値の型を調べます。

print(0 <= score <= 100)
print(x is number, xs is list, p is Point, v is not nil)

使える型名は nil bool number string list map function range と、record で宣言した名前です。それ以外の名前はエラーになるので、打ち間違いにすぐ気づけます（x is lsit → 「不明な型名 'lsit'／もしかして 'list' ですか？」）。

文字列

name = "世界"
print("こんにちは、{name}！")          # {式} で埋め込み
print("合計: {1 + 2}、一覧: {[1, 2]}")
print("波かっこそのもの: \{ \}")
print('シングルクオートは {埋め込みしない}')
print("改行\nタブ\t引用符\" 絵文字\u{1F600}")

• "..." の中では {式} がその値の文字列表現に置き換わります
• エスケープ: \n \t \r \0 \e \\ \" \' \{ \} \u{16進数}
• '...' は埋め込みを行わず、エスケープも \\ と \' のみです
• {式:書式} で桁揃えや小数の桁数を指定できます（下の表）
• 文字列は改行を含めて複数行に書けます
• 長さ・添字は 文字単位（UTF-8）で数えます: len("こんにちは") は 5、"こんにちは"[1] は "ん"
• 負の添字は後ろから数えます: "abc"[-1] は "c"

埋め込みの書式 {式:書式} は [埋め文字][< > ^][幅][.桁数] の形です。全角文字は幅2として揃えます。

名前 = "花子"
点 = 95.5
print("[{名前:<6}] {点:>7.2} 点")   # [花子  ]   95.50 点
print("[{"中央":*^8}]")             # [**中央**]
print("{3.14159:.3}")               # 3.142

同じ書式は format() でも使えます。"..." の中の {} は埋め込みになるため、書式は '...' で書きます: format('{} は {:>5} 点', name, score)

リスト

xs = [3, 1, 4]
print(xs[0], xs[-1], len(xs))
xs[0] = 10
xs.push(5)              # 末尾に追加（push(xs, 5) と同じ）
last = xs.pop()         # 末尾を取り出す
print(xs + [9], [0] * 3)
print(slice(xs, 1, 3))  # 部分リスト

範囲外の添字はエラーになります。要素を増やすときは push / insert を使います。

マップ

person = {name: "太郎", age: 20, "好きな色": "青"}
print(person.name, person["好きな色"])
person.age += 1
person["city"] = "東京"
print(keys(person), "age" in person)
print(get(person, "email", "未登録"))   # キーがなければ既定値
delete(person, "city")
x = 5
point = {x, y: 10}                       # {x: x, y: 10} の省略形

• キーには 文字列・数値・真偽値・nil が使えます。{name: ...} のように書いた識別子は文字列キーになります
• 存在しないキーを m.key や m["key"] で読むとエラーになります。無いかもしれないキーは get(m, key, 既定値) か key in m で確認してください
• for などで列挙すると、キーを追加した順に並びます

範囲

1..5          # 1, 2, 3, 4, 5（終端を含む）
0...5         # 0, 1, 2, 3, 4（終端を含まない）
range(10)          # 0〜9
range(10, 0, -2)   # 10, 8, 6, 4, 2（増分を指定）
list(1..3)    # [1, 2, 3]

範囲は必要になるまで要素を作らないので、for i in 1..1000000 でも大きなリストは作られません。

出力と入力

print("a", 1, [2])      # 引数をスペース区切りで出力し、改行する
write("改行なし")        # 改行せずに出力
name = input("名前: ")   # 1行読み込む（入力が終わっていれば nil）

条件分岐

if score >= 90 {
    print("A")
} elif score >= 70 {        # else if と書いてもよい
    print("B")
} else {
    print("C")
}

unless logged_in {          # if not と同じ
    print("ログインしてください")
}

• 条件式に括弧は不要（if (cond) ではなく if cond）
• ブロックは必ず { } で囲む
• else / elif は } の次の行に書いてもかまいません

繰り返し

while i < 5 { i += 1 }       # 条件が真の間
until i == 0 { i -= 1 }      # 条件が偽の間
loop {                       # 無限ループ（break で抜ける）
    break if done()
}

for x in [10, 20, 30] { print(x) }        # リスト
for i in 1..10 { print(i) }                # 範囲
for ch in "あいう" { print(ch) }           # 文字列（1文字ずつ）
for key in {a: 1, b: 2} { print(key) }     # マップ（キー）
for i, x in ["a", "b"] { print(i, x) }     # 添字と要素
for key, value in {a: 1} { print(key, value) }  # キーと値

break で最も内側のループを抜け、continue で次の繰り返しに進みます。

後置修飾子構文（Laping 独自のスタイル）

単文（代入・式・return・break・continue・throw）の末尾に if / unless / while / until / for / repeat を置くと、条件付きで、または繰り返して実行できます。「何をするか」を先に書き、条件や繰り返しは後ろに書く、という1つのルールです。

print("正の数です") if x > 0
print("0以下です") unless x > 0
return 0 if n < 1
continue unless i % 3 == 0
throw "不正な値" if value < 0
i += 1 while i < 10
i -= 1 until i == 0
print(x) for x in xs                  # 繰り返し
print(x) for x in xs if x > 0         # 条件付きの繰り返し
write("★") repeat 3                   # 回数だけ繰り返し

• 同じ行に書かれている場合のみ修飾子として解釈されます。改行を挟んだ場合は別々の文として扱われ、誤って次の行の if ブロックを修飾子と誤認識することはありません
• 修飾子の対象にできるのは 単文のみ です。複数の文をまとめて条件付きにしたい場合はブロック構文を使ってください。これにより「修飾子がどこまでを対象にしているか」が常に1文に固定され、構文上の曖昧さが生まれません

内包表記

後置の for と同じ語順で、リストやマップを作れます。ループ変数は外に漏れません。

squares = [i * i for i in 1..5]                  # [1, 4, 9, 16, 25]
evens = [x for x in xs if x % 2 == 0]
lengths = {w: len(w) for w in ["apple", "kiwi"]}  # {"apple": 5, "kiwi": 4}
pairs = ["{k}={v}" for k, v in {a: 1, b: 2}]      # ["a=1", "b=2"]

repeat

回数だけ繰り返します。カウンタ変数が要らないときに使います。break / continue も使えます。

repeat 3 {
    print("やあ")
}

match

値によって処理を振り分けます。上から順に調べ、最初に一致した1つだけを実行します。

match value {
    0 => print("ゼロ")
    1, 2, 3 => print("小さい")           # カンマで複数のパターン
    4..9 => print("一桁")                # 範囲に含まれるか
    "hello" => print("あいさつ")
    _ if value < 0 => print("負の数")    # _ は何にでも一致。if で追加条件
    _ => {
        print("その他")                   # ブロックも書ける
    }
}

match は式としても使え、一致した枝の値になります（どれにも一致しなければ nil）。枝は改行かカンマで区切ります。

fn season(m) => match m { 3..5 => "春", 6..8 => "夏", 9..11 => "秋", _ => "冬" }
label = match code {
    200 => "OK"
    404 => "見つかりません"
    _ => "エラー"
}

関数

fn add(a, b) {
    return a + b
}

fn square(x) => x * x               # 式1つだけなら => で書ける

fn greet(name, greeting = "こんにちは") => "{greeting}、{name}さん"   # デフォルト引数
fn total(...nums) => sum(nums)      # 可変長引数（リストで受け取る）

double = fn(x) => x * 2             # 無名関数
triple = fn x => x * 3              # 引数が1つなら括弧を省略できる
[1, 2, 3] -> map(fn x => x + 1)     # 関数を引数に渡す

• return の無い関数、または値を書かない return は nil を返します
• 引数の数が合わないとエラーになります
• 関数は定義された場所の変数を覚えています（クロージャ）

fn make_counter() {
    let count = 0
    return fn() {
        count += 1
        return count
    }
}
c = make_counter()
c()
print(c())   # => 2

メソッド構文

x.f(a, b) と書くと f(x, a, b) が呼ばれます。組み込み関数にも自分で定義した関数にも使えるため、処理を左から右へつなげて書けます。

fn double(x) => x * 2
print(21.double())                       # double(21)
print("  hi  ".trim().upper())           # upper(trim("  hi  "))
words = "b a c".split().sort().join(",") # "a,b,c"

ただし x がマップで、f という名前のキーに関数が入っている場合はその関数を呼びます。これを使うとオブジェクトのように書けます。

fn Counter() {
    let n = 0
    return {
        inc: fn() { n += 1 },
        value: fn() => n,
    }
}
c = Counter()
c.inc()
print(c.value())   # => 1

record（型の宣言）と型ごとのメソッド

record で、決まったフィールドを持つ型を宣言できます。宣言していないフィールドへの代入はエラーになるので、打ち間違いにすぐ気づけます。

record Point(x, y = 0)             # y は省略すると 0
p = Point(3, 4)
print(p)                           # Point(x: 3, y: 4)
p.x = 10                           # OK
p.z = 1                            # エラー: Point にフィールド 'z' はありません
print(type(p), p is Point)         # Point true

fn 型名.メソッド名(値, ...) で、型にメソッドを追加できます。第1引数がその値です（self は不要）。string list number などの組み込み型にも追加できます。

fn Point.dist(p) => sqrt(p.x ** 2 + p.y ** 2)
print(Point(3, 4).dist())          # 5

fn string.shout(s) => upper(s) + "!"
print("hello".shout())             # HELLO!

x.f(a) は、①型に追加したメソッド ②マップのキー f に入った関数 ③f(x, a) の順に探して呼びます。

定数

全部大文字の名前（2文字以上。MAX_SIZE や API_URL など）は定数になり、2回目の代入はエラーになります。キーワードを増やさずに「変えてはいけない値」を表せます。

MAX_SIZE = 10
MAX_SIZE = 20    # エラー: 定数 MAX_SIZE は変更できません

スコープ

• 関数を呼び出すたびに新しいスコープが作られます。if や for などのブロックは新しいスコープを作りません
• x = 値 は、外側のスコープに x があればそれを書き換え、なければ現在のスコープに作ります
• let x = 値 は常に現在のスコープに新しい変数を作ります。関数の中で外側と同じ名前を使いたいときは let を使ってください

count = 0
fn increment() {
    count += 1        # 外側の count を書き換える
}
fn local_only() {
    let count = 100   # 外側とは別の変数
    return count
}

エラー処理

try {
    risky()
} catch e {             # e にエラーの内容が入る（変数名は省略可）
    print("失敗:", e)
} finally {             # 省略可。成功しても失敗しても必ず実行される
    print("後片付け")
}

throw "値が不正です"             # 任意の値を投げられる
throw {code: 404, message: "Not Found"}

実行時エラー（ゼロ除算・未定義変数など）も catch で捕捉でき、e にはエラーメッセージの文字列が入ります。捕捉されなかったエラーは、行番号と呼び出し履歴を表示して終了コード1で終了します。

Laping: リストの添字 10 が範囲外です（長さ 3） (7行目)
    inner() の呼び出し元: 3行目
    outer() の呼び出し元: 9行目

ファイルの分割（import）

import "lib/util"              # lib/util.lp を読み込んで実行する（.lp は省略可）
import "lib/shapes" as shapes  # モジュールとして読み込む
print(shapes.area(3, 4))

• パスは import を書いたファイルのあるフォルダからの相対パスです
• as を付けない場合、読み込んだファイルで定義した関数や変数は、そのまま使えます。同じファイルは2回目以降は読み込まれません
• as 名前 を付けると、ファイルは独立したスコープで実行され、その変数と関数をまとめたマップが 名前 に入ります。名前の衝突を防げます
• as で読み込んだとき、_ で始まる名前（_helper など）は外から見えません。公開する名前を一目で区別できます

エラー検出

Lapingは曖昧な挙動を避けるため、以下を実行時エラーとして検出します。捕捉されなかったエラーは、場所・該当行・原因の位置（^）・ヒント・呼び出し履歴を表示して、終了コード1で終了します。

エラー: 未定義の変数 'numz'
  --> report.lp:3:28
  |
3 |     return sum(nums) / len(numz)
  |                            ^
  ヒント: もしかして 'nums' ですか？
  呼び出し履歴:
    average() ← 5行目

構文エラーはプログラムの実行前に検出され、構文エラー: ... と表示されます。laping check を使うと、実行せずに構文だけを確認できます。

組み込み関数

どの関数も f(x, a)・x.f(a)・x -> f(a) のどの形でも呼べます。一覧と説明は laping doc（対話モードでは :doc、プログラム中では help()）でも表示できます。

入出力・ファイル

画面表示

端末に出力しているときだけ色や太字が付き、ファイルやパイプに出すときは文字だけになります。全角文字は幅2として桁を揃えます。

table([["りんご", 120], ["バナナ", 98]], ["品名", "価格"])

┌────────┬──────┐
│  品名  │ 価格 │
├────────┼──────┤
│ りんご │  120 │
│ バナナ │   98 │
└────────┴──────┘

型・変換

リスト

文字列

マップ

数学

システム

サンプルコード

文法まとめ（EBNF風）

program     := statement*
statement   := if_stmt | while_stmt | for_stmt | loop_stmt | repeat_stmt | match_stmt
             | try_stmt | fn_decl | record_decl | test_block | import_stmt
             | simple_stmt modifier?                  # 改行 or ";" で終わる
if_stmt     := ("if" | "unless") expr block
               ("elif" expr block | "else" "if" expr block)* ("else" block)?
while_stmt  := ("while" | "until") expr block
for_stmt    := "for" IDENT ("," IDENT)? "in" expr block
loop_stmt   := "loop" block
repeat_stmt := "repeat" expr block
match_stmt  := "match" expr "{" (arm_head (block | simple_stmt))* "}"
arm_head    := pattern ("," pattern)* ("if" expr)? "=>"
pattern     := "_" | expr
try_stmt    := "try" block ("catch" IDENT? block)? ("finally" block)?
fn_decl     := "fn" (IDENT ".")? IDENT fn_rest            # fn Type.method(...)
record_decl := "record" IDENT "(" params ")"
test_block  := "test" STRING block
import_stmt := "import" STRING ("as" IDENT)?
block       := "{" statement* "}"

simple_stmt := "let" IDENT ("," IDENT)* ("=" expr ("," expr)*)?
             | "return" expr? | "break" | "continue" | "throw" expr | "expect" expr
             | target ("," target)* "=" expr ("," expr)*
             | target ("+=" | "-=" | "*=" | "/=" | "%=") expr
             | expr
target      := IDENT | postfix "[" expr "]" | postfix "." IDENT
modifier    := ("if" | "unless" | "while" | "until") expr   # simple_stmt と同じ行のみ有効
             | "for" IDENT ("," IDENT)? "in" expr ("if" expr)?
             | "repeat" expr

expr        := pipe ("then" expr "else" expr | "else" expr | "?" expr ":" expr)?
pipe        := or_expr ("->" or_expr)*                   # x -> f(a) は f(x, a)
or_expr     := and_expr (("or" | "||") and_expr)*
and_expr    := not_expr (("and" | "&&") not_expr)*
not_expr    := "not" not_expr | comparison
comparison  := range ((cmp_op range)+ | ("in" | "not" "in") range | "is" "not"? TYPE)*
cmp_op      := "==" | "!=" | "<" | ">" | "<=" | ">="     # 連鎖できる: 1 < x < 10
range       := additive ((".." | "...") additive)?
additive    := term (("+" | "-") term)*
term        := unary (("*" | "/" | "//" | "%") unary)*
unary       := ("-" | "+" | "!") unary | power
power       := postfix ("**" unary)?
postfix     := primary ("(" args ")" | "[" expr "]" | "." IDENT ("(" args ")")?)*
primary     := NUMBER | STRING | "true" | "false" | "nil" | IDENT | "(" expr ")"
             | "[" (expr ("," expr)* ","? | expr "for" for_clause)? "]"
             | "{" (entry ("," entry)* ","? | expr ":" expr "for" for_clause)? "}"
             | "fn" IDENT? fn_rest | "match" expr "{" (arm_head expr)* "}"
             | "throw" expr
for_clause  := IDENT ("," IDENT)? "in" expr ("if" expr)?
entry       := IDENT ":" expr | IDENT | expr ":" expr
fn_rest     := "(" params? ")" ("=>" expr | block) | IDENT "=>" expr
params      := param ("," param)*
param       := IDENT ("=" expr)? | "..." IDENT

予約語: if elif else unless while until for in loop repeat break continue return fn let true false nil and or not is then match try catch finally throw import

文の先頭の record test expect と、import の後の as は、その位置でだけ特別な意味を持ちます（変数名としても使えます）。

v2.0 からの変更点（v2.1）

v2.0 のプログラムはほぼそのまま動きますが、次の点が変わっています。

• repeat is then が予約語になり、変数名に使えなくなりました
• 式の直後の else（値 else 既定値）は既定値の指定になりました
• 文の先頭の expect は expect 文になりました（expect(...) という名前の関数を文の先頭で呼べなくなりました）
• 全部大文字（2文字以上）の変数は定数になり、再代入するとエラーになります
• "{式:書式}" のように、埋め込み式の最後の : の後ろが書式として読める場合は書式として扱われます
• エラーメッセージの形式が変わりました（Laping: 内容 (N行目) → 場所・該当行・ヒントを含む複数行の表示）
• laping test check new doc run help version がコマンドになりました。これらと同じ名前の拡張子なしファイルを実行するには laping run test のようにします

v1 からの変更点（v2.0）

v1 のプログラム（examples/fizzbuzz.lp など）はそのまま動きますが、次の点が変わっています。

• "..." の中の { } は式の埋め込みになりました。文字として書くには \{ \} を使うか、'...' を使ってください
• 比較演算子の結果は 1 / 0 ではなく true / false になりました
• % の結果の符号は除数に合わせるようになりました（-7 % 3 は 2）。また小数の剰余も計算できます
• 上記の予約語は変数名に使えなくなりました
• print は予約語ではなく組み込み関数になり、複数の引数を受け取れます
• 文字列の長さやリスト・変数の数などの上限がなくなりました

開発者向け

テスト

make test

tests/*.lp を実行し、出力を同名の .expected ファイルと比較します（*_test.lp は laping test で実行します。終了コードは既定で 0、名前.exit があればその値を期待します）。GC の不具合を探すときは、すべての文の実行前に GC を走らせる LAPING_GC_STRESS=1 を付けて実行してください。

LAPING_GC_STRESS=1 tests/run_tests.sh ./laping

AI 向け仕様書の更新

組み込み関数を追加・変更したら、docs/AI_GUIDE.md の一覧を src/builtins.c の関数表から作り直してください。CI でも一覧が最新かを確認しています。

python3 tools/update_ai_guide.py

新バージョンのリリース方法

git tag v2.1.0
git push origin v2.1.0

タグをプッシュすると GitHub Actions が起動し、テストを実行したうえで Linux/Windows向けバイナリをビルドして自動的にReleaseへ添付します。各ユーザーは laping update を実行するだけで新しいバイナリに更新されます。タグのバージョンは src/laping.h の LAPING_VERSION と合わせてください。

ライセンス

(未設定)