== 基本的な定数 ==
self : char
自分

opp : char
相手

true, false : bool
真と偽

nil : nil
有効な値がないことを示す値

地, 火, 水, 風, 剣 : panel-kind
パネルの種類

all_kinds : set(panel-kind)
すべてのパネルの種類の集合。{地:火:水:風:剣}と同義

炸撃, 報復, ... 暗殺 : skill
スキル名はそのままそのスキルを表す

all_skills : set(skill)
すべてのスキルの集合。

opening : time
ゲーム開始時刻

== 基本的な関数 ==
id : a -> a
恒等関数

const : a -> (b -> a)
定数関数を作る

not : bool -> bool
論理否定

eq : a -> (a -> bool)
カリー化された等値比較

even : int -> bool
偶数である

odd : int -> bool
奇数である

pow : int int -> int
累乗

== 大域的な状態変数 ==
first_to_move : char
このターンの先攻プレイヤー

first : bool
自分が先攻であるか

second : bool
自分が後攻であるか

turn_count : int
現在のターン番号。1から数える

sudden_death : bool
サドンデス中かどうか

current_turn : turn
現在のターン

current_invocation : invocation | nil
現在、スキルの発動に対する受動タイミングでプランが評価されている場合、その発動
そうでなければnil

current_attack : attack | nil
現在、攻撃または反撃に対する受動タイミングでプランが評価されているなら、その攻撃
そうでなければnil

== キャラクター ==
char_name : char -> string
キャラの名前

vitality: char -> int
体力

reflexes : char -> int
神経反射

intelligence : char -> int
知性

HP, max_HP : char -> int
現在のHPと最大HP

has_skill : char skill -> bool
スキルを習得しているか

skills : char -> list(skill)
習得済みスキル

ready : char skill -> bool
スキルを構えているかどうか

skills_ready : char -> set(skill)
構えているスキルの集合

skill_slots : char -> list(skill-slot)
スキルスロットの一覧

patterns : char -> list(skill-pattern)
スキルパターンの一覧

current_pattern_number : char -> (int | nil)
現在使用しているスキルパターンの番号(0から数える)

current_pattern : char -> (skill-pattern | nil)
使用中のスキルパターン

current_panels : char -> list(panel)
使用中のスキルパターンに含まれるパネル

current_panel_kinds : char -> list(panel-kind)
使用中のスキルパターンの内容(地水剣、など)
利便性のための関数

held_invocations : char -> set(invocation)
持続中のスキル発動の集合。

holding : char skill -> bool
特定のスキルを維持しているかどうか

plans : char -> list(plan)
プランの一覧

== スキル ==
skill_name : skill -> string
スキルの名前

cost : skill -> list(panel-kind)
スキルの発動コスト

is_sword, is_fire, is_magic, is_attack, is_counter, is_mutative,
is_obstructive, is_reactive, is_defensive, is_recovery, is_continuous, is_strengthening : skill -> bool
スキルの各種属性を判定

possible_targets : char skill -> set(target)
キャラがスキルを使った場合に指定し得るターゲットの集合

level : skill -> int
スキルのレベル

element : panel-kind  -> (skill -> bool)
スキルが特定の属性であるかどうか

== スキルスロット ==
slot_skill : skill-slot -> skill
スキルスロットに入っているスキル

weaken : skill-slot -> int
スキルスロットにかかっているweakenの数

is_weakened : skill-slot -> bool
スキルスロットにweakenがかかっているか

bind : (skill-slot | plan | panel) -> int
スキルスロットにかかっているBindの数

is_bound : (skill-slot | plan | panel) -> bool
スキルスロットにBindが一つでもかかっているかどうか

owner : skill-slot -> char
スキルスロットの持ち主

== スキルパターン ==
panels : skill-pattern -> list(panel)
パターン内のパネルの一覧

pattern_name : skill-pattern -> string
スキルパターンの名前

pattern_number : skill-pattern -> int
スキルパターンの番号。0から数える

owner : skill-pattern -> char
スキルパターンの持ち主

pattern_by_name : char string -> (skill-pattern | nil)
指定した名前のスキルパターン。存在しないならnil

== パネル ==
kind : panel -> panel-kind
パネルの種類

poison, confuse : panel -> int
パネルにかかっているPoisonおよびConfuseの数

is_poisoned, is_confused : panel -> bool
パネルにPoisonやConfuseがかかっているか

is_used : panel -> bool
パネルが使用済であるか

is_ensnared : panel -> bool
パネルが陥穽の効果によって回復を妨げられているか

bind : (skill-slot | plan | panel) -> int
パネルにかかっているBindの数

is_bound : (skill-slot | plan | panel) -> bool
パネルにBindが一つでもかかっているかどうか

owner :: panel -> char
パネルの持ち主

== プラン ==
plan_code : plan -> expr
プランを表現するコード

bind : (skill-slot | plan | panel) -> int
プランにかかっているBindの数

is_bound : (skill-slot | plan | panel) -> bool
プランにBindが一つでもかかっているかどうか

owner : plan -> char
プランの持ち主

== 存在確認 ==

exists : (skill-slot | plan | panel | skill-pattern) -> bool
指定したものが存在するかどうか

== コマンド ==
dont_use : skill-spec -> command
指定されたスキルを使わない、というコマンド
*skill-specについて
論理的にはスキルスロットを指定するところだが、
利便性のためにスキルやそのリストや集合を指定することもできる。
形式的に書くと
skill-spec = skill-slot | skill | set(skill-spec) | list(skill-spec)
複数のスキルスロットが指定された場合、すべてがdisableの対象になる

prioritize : skill-spec -> command
指定されたスキルを最優先にする、というコマンド

prioritize_bottom : skill-spec -> command
指定されたスキルの優先度を最低にする、というコマンド

prioritize_above, prioritize_below : skill-spec skill-spec -> command
最初のスキルの優先度を二番目のスキルのちょうど上または下に設定する、というコマンド
二番目のスキルとして複数のスキルスロットが指定された場合、
そのすべてより上(または下)の位置になるように設定する。

use : skill-spec -> command
指定されたスキルの使用を強制するコマンド
霧の防壁など、指示がなければ使われないスキルにのみ効果がある

target : skill-spec target-spec -> command
スキルの追加効果の対象を指定するコマンド
target-spec = panel | skill-slot | plan | skill | panel-kind | list(target) | set(target)

target_with_priorities : skill-spec list(target-spec) -> command
対象候補をリストとして複数指定する。
対象として有効な候補のなかでもっとも左側に現れたものを選び、それを対象として指定するコマンドを返す。
possible_targetsとtargetを使って同じ挙動を実現できる。利便性のための関数。

switch_to : pattern-spec -> command
スキルパターンを設定するコマンド
スキルパターンの名前か、(0から数えた)番号を指定しても良い
pattern-spec = skill-pattern | string | int

reserve : skill-spec panel-spec -> command
指定されたパネルを指定されたスキル以外で使わない、というコマンド
これもskill-specと同様に、パネルを指定する代わりにパネルの種類を指定できる
panel-spec = panel | panel-kind | set(panel-spec) | list(panel-spec)

hold : invocation-spec -> command
指定された発動を維持するコマンド
発動を指定する代わりにスキルスロットやスキルを指定できる
invocation-spec = invocation | skill-slot | skill | set(invocation-spec) | list(invocation-spec)

set_reaction_count : skill-spec int -> command
受動スキルの最大発動回数を設定するコマンド
厳密にはスキルスロットに対する設定であることに注意
したがって、例えば報復を二つ習得している場合、set_reaction_count 報復,2;とすると、
二つのスキルスロットの報復がそれぞれ二回ずつ、計四回発動される。

modify_plan : plan-spec (expr -> expr) -> command
指定したプランの内容を指定した関数によって書き換えるコマンド
plan-spec = plan | int | set(plan-spec) | list(plan-spec)

nop : command
なにもしない、というコマンド

seq : command command -> command
二つのコマンドを組み合わせる。
結果のコマンドを実行するのは、左のコマンドを実行してから右のコマンドを実行するのと同じ。
ただし矛盾する指定がなされた場合は左側優先

sequence : list(command) -> command
リスト中のコマンドをすべて組み合わせる

== 集合 ==
union : (set | list) (set | list) -> set
二つの集合の和集合

unions : (set(set | list) | list(set | list)) -> set
多数の集合の和集合

intersection : (set | list) (set | list) -> set
二つの集合の積集合

difference : (set | list) (set | list) -> set
二つの集合の差集合

insert : a (set(a) | list(a)) -> set(a)
集合に新しい要素を追加した集合。insert x, a; は union {x}, a; と同じ

delete : a (set(a) | list(a)) -> set(a)
集合から要素を削除した集合。delete x, a; は difference a, {x}; と同じ

image : (a -> b) (set(a) | list(a)) -> set(b)
各要素を指定した関数によって変形してできた要素の集合。mapも参照。

to_list : set -> list
集合を適当に並べてリストを作る

to_set : list -> set
リストの要素からなる集合

「集合とリストに共通の演算」の項も参照。

== リスト ==
find : (a -> bool) list(a) -> (a | nil)
条件を満たす最初の要素。そのようなものがない場合はnil

append : list list -> list
リストの連結

foldr : (a b -> b) b list(a) -> b
右畳み込み。
foldr f, z, [a0:a1:a2: ... :aN]
は、
f a0, (f a1, (f a2, ...  (f aN, z) ... ))
と同じ

head : list(a) -> (a | nil)
リストの先頭要素。リストが空ならnil

tail : list(a) -> list(a)
先頭以外の要素。リストが空ならそのまま

cons : a list(a) -> list(a)
リストの先頭に要素を付け加えたリスト

sort : (list(a) | set(a)) -> list(a)
リストを昇順に並べ替えたもの

sort_on : (a -> (int | string | time)) (list(a) | set(a)) -> list(a)
指定された指標に基づいて並べ替えたリスト。

map : (a -> b) (set(a) | list(a)) -> list(b)
各要素を指定された関数によって変形したリスト。

reverse : list -> list
逆順のリスト

「集合とリストに共通の演算」の項も参照。

== 集合とリストに共通の演算 ==
member : a (set(a) | list(a)) -> bool
ある値を集合/リストが含むかどうか。

size : (set | list) -> int
要素数

empty : (set | list) -> bool
空であるかどうか

filter : (a -> bool) set(a) -> set(a)
filter : (a -> bool) list(a) -> list(a)
与えられた集合/リストから条件を満たす要素のみ抜き出した集合/リスト

any : (a -> bool) (set(a) | list(a)) -> bool
少なくとも一つの要素が条件を満たしているかどうか

all : (a -> bool) (set(a) | list(a)) -> bool
すべての要素が条件を満たしているかどうか

count : (a -> bool) (set(a) | list(a)) -> int
条件を満たす要素の個数

max, min : (set(a) | list(a)) -> (a | nil)
最大値または最小値。空集合/空リストが与えれた場合はnil。

max_on, min_on : (a -> (int | string | time)) (set(a) | list(a)) -> (a | nil)
評価基準を指定したmaxとmin。例えば、
max_on time, all_invocations;
で、もっとも最近起こった発動が得られる。

== 乱数 ==
init_g : random
最初の乱数

split : random int -> list(random)
一個の乱数から指定された個数の乱数を作りだす

random_int : random int -> int
ランダムな整数。
random_int n, gen
は0からn-1までの整数をひとつ生成して返す

choose : random (list(a) | set(a)) -> a
リストか集合から要素をランダムに一つ選んで返す

== 発動 ==
invocation_slot : invocation -> slot
どのスロットで発動されたスキルか

invocation_skill : invocation -> skill
発動したスキル

invocation_cost : invocation -> set(panel)
発動のコストとして使われたパネル

invocation_type : invocation -> string
発動の型。能動的発動なら"action"、攻撃に対する
受動的発動なら"reaction"、スキルに対する受動的発動なら
"skill reaction"、維持の開放による発動なら"release"。

is_action : invocation -> bool
発動が能動的であるか

is_reaction : invocation -> bool
発動が受動的であるか

invocation_cause : invocation -> (attack | invocation | nil)
発動の元となった出来事。型が"reaction"のときは攻撃、
"skill reaction"または"release"のときは発動。
型が"action"の時はnil。

time : event -> time
発動時刻

turn : event -> turn
発動ターン

invoker : invocation -> char
発動したキャラクター

all_invocations : set(invocation)
過去に起こったすべての発動の集合

turn_invocations : char turn -> set(invocation)
特定のターンに起こった特定のキャラによるすべての発動の集合

== 攻撃または反撃 ==
attack_invocation : attack -> invocation
攻撃/反撃したスキルの発動

attack_skill : attack -> skill
攻撃/反撃に使われたスキル。
attack_skill a; は invocation_skill attack_invocation a;;と同じ

attack_cause : attack -> (block | nil)
干渉の結果の反撃なら、その干渉。
そうでないなら、nil

claimed_damage : attack -> int
発動側で指定されたダメージ値

attack_is_sword, attack_is_fire : attack -> bool
剣属性および火属性の攻撃/反撃であるか

attacker : attack -> char
攻撃/反撃したキャラ

attackee : attack -> char
攻撃/反撃を受けたキャラ

damage_amount : attack -> (int | nil)
実際に与えたダメージ。まだダメージ処理が済んでいないならnil

damage : attack -> (damage | nil)
発生したダメージイベント。まだダメージ処理が済んでいないか、ダメージを与えなかった場合はnil。

is_negated : attack -> (bool | nil)
攻撃/反撃の追加効果が無効化されたか。まだ確定していないならnil。

blocks : attack -> set(block)
攻撃/反撃に対して発生した干渉の集合

turn_attacks : char turn -> set(attack)
あるターンに発生した特定のキャラによる攻撃/反撃の集合

turn_attacks_from : char turn -> set(attack)
あるターンに発生した、特定のキャラから自分への攻撃/反撃の集合

all_attacks : set(attack)
過去のすべての攻撃/反撃の集合

time : event -> time
攻撃/反撃の時刻

turn : event -> turn
攻撃/反撃の行われたターン

== 干渉 ==
block_target : block -> attack
干渉の対象

input_damage : block -> int
干渉前のダメージ量

output_damage : block -> int
干渉後のダメージ量

block_negate : block -> bool
干渉によって追加効果を無効にしたかどうか

block_invocation : block -> invocation
干渉を行ったスキルの発動

block_skill : block -> skill
干渉を行ったスキル

block_type : block -> string
干渉の型。新たに発動したスキルで干渉したなら"invoked"。
すでに発動済みのスキルが干渉したなら"held"

time : event -> time
干渉時刻

turn : event -> turn
干渉ターン

turn_blocks : char turn -> set(block)
あるターンに発生したあるキャラによるすべての干渉の集合

all_blocks : set(block)
過去に起こったすべての干渉の集合

== ダメージ ==
damage_value : damage -> int
ダメージの量

sufferer : damage -> char
ダメージを受けたキャラ

damage_type : damage -> string
ダメージの種類。攻撃によるダメージなら"attack"、毒によるダメージなら"poison"

damage_attack : damage -> (attack | nil)
ダメージの原因となった攻撃。攻撃によらないダメージの場合はnil。

time : damage -> time
ダメージ発生の時刻

turn : damage -> turn
ダメージ発生ターン

turn_damages : char turn -> set(damage)
あるターンにあるキャラの受けたダメージの集合

all_damages : set(damage)
過去に発生したすべてのダメージの集合

== ターン ==
beginning : turn -> time
ターン開始時刻

end : turn -> time
ターン終了時刻。
ターンt中に発生したすべての出来事eについて、
beginning t; <= time e; && time e; < end t;
が成り立つ。逆にこれが成り立つならeはt中で発生している。

next : turn -> (turn | nil)
次のターン。最新のターンが指定された場合はnil

prev : turn -> (turn | nil)
前のターン。最初のターンが指定された場合はnil

turn_number : turn -> int
ターンの番号。1から数える

number_turn : int -> (turn | nil)
指定された番号を持つターン。1から数える。存在しない場合はnil。

all_turns : set(turn)
すべてのターン。

== 維持の継続 ==
continued_invocation : continuation -> invocation
継続された発動

time : continuation -> time
継続の時刻

turn : continuation -> turn
継続が行なわれたターン

turn_continuations : char turn -> set(continuation)
あるターン、あるキャラによって行なわれた継続の集合

all_continuations : set(continuation)
すべての継続の集合

== 維持の解除 ==
dropped_invocation : drop -> invocation
解除された発動

drop_type : drop -> string
なぜ解除されたかの分類。ターン終了時の意図的な解除なら"will"、
パネルのロールによる解除なら"roll"、スキルによる無効化による解除なら"negation"、
パネルが失われたことによる解除なら"lost panel"、スキルが失われたことによる解除なら"lost skill"

time : drop -> time
解除された時刻

turn : drop -> turn
解除されたターン

turn_drops : char turn -> set(drop)
あるターン、あるキャラによって行なわれた解除の集合

all_drops : set(drop)
すべての解除の集合

== 文字列 ==
unpack : string -> list(int)
文字列をUnicodeコードポイントの列に変換する

pack : list(int) -> string
Unicodeコードポイントの列から文字列を得る

== デバッグ用 ==
debug_out : string a -> a
第二引数を表示する