vim-jp / vimdoc-ja / builtin

builtin - Vim日本語ドキュメント

メインヘルプファイルに戻る English | 日本語 | 編集
builtin.txt   For Vim バージョン 9.0.  Last change: 2022 Apr 25


                VIMリファレンスマニュアル    by Bram Moolenaar


組み込み関数                                    builtin-functions

Note: 式の評価はコンパイル時に無効することができる。そうした場合は、組み込み関
数は利用できない。+eval と no-eval-feature を参照。

1. 概要                                 builtin-function-list
2. 詳細                                 builtin-function-details
3. 機能リスト                           feature-list
4. 文字列内でのパターンマッチング       string-match

==============================================================================
1. 概要                                         builtin-function-list

関数名の上でCTRL-]を使うことで、詳細な説明へ飛ぶことができる。

使用法                          結果    説明

abs({expr})                     浮動小数点数または数値  {expr}の絶対値
acos({expr})                    浮動小数点数    {expr}のアークコサイン
add({object}{item})           リスト/Blob     {item}{object}に追加する
and({expr}{expr})             数値    ビット論理積
append({lnum}{text})          数値    {lnum}行目に{text}を付け加える
appendbufline({expr}{lnum}{text})
                                数値    バッファ{expr}{lnum}行目に{text}を付
                                        け加える
argc([{winid}])                 数値    引数内のファイルの数
argidx()                        数値    引数リスト内の現在のインデックス
arglistid([{winnr} [, {tabnr}]])
                                数値    引数リストID
argv({nr} [, {winid}])          文字列  引数の第{nr}番目
argv([-1, {winid}])             リスト  引数リスト
asin({expr})                    浮動小数点数    {expr}のアークサイン
assert_beeps({cmd})             数値    {cmd} がビープ音を鳴らすことをテストす
                                        る
assert_equal({exp}{act} [, {msg}])
                                数値    {exp}{act}が等しいかどうかテストする
assert_equalfile({fname-one}{fname-two} [, {msg}])
                                数値    ファイルの内容が等しいことをテストする
assert_exception({error} [, {msg}])
                                数値    v:exception{error}であるかテストする
assert_fails({cmd} [, {error} [, {msg} [, {lnum} [, {context}]]]])
                                数値    {cmd}が失敗するかどうかテストする
assert_false({actual} [, {msg}])
                                数値    {actual}がfalseかどうかテストする
assert_inrange({lower}{upper}{actual} [, {msg}])
                                数値    {actual}が範囲内にあるかテストする
assert_match({pat}{text} [, {msg}])    数値  {pat}{text}にマッチするかテス
                                        トする
assert_nobeep({cmd})            数値    {cmd} がビープ音を鳴らさないことをテス
                                        トする
assert_notequal({exp}{act} [, {msg}])  数値  {exp}{act}と等しくないことを
                                        テストする
assert_notmatch({pat}{text} [, {msg}]) 数値  {pat}{text}とマッチしないこと
                                        をテストする
assert_report({msg})            数値    テストの失敗を報告する
assert_true({actual} [, {msg}])
                                数値    {actual}がtrueかどうかテストする
atan({expr})                    浮動小数点数    {expr}のアークタンジェント
atan2({expr1}{expr2})         浮動小数点数    {expr1} / {expr2} のアークタン
                                                ジェント
balloon_gettext()               文字列  バルーン内のカレントテキストを得る
balloon_show({expr})            なし    {expr} をバルーン内に表示
balloon_split({msg})            リスト  {msg} をバルーンで使われるように分割す
                                        る
blob2list({blob})               リスト  {blob} を数値のリストに変換する
browse({save}{title}{initdir}{default})
                                文字列  ファイル選択ダイアログを表示
browsedir({title}{initdir})   文字列  ディレクトリ選択ダイアログを表示
bufadd({name})                  数値    バッファリストにバッファを追加する
bufexists({buf})                数値    バッファ{buf}が存在すればTRUE
buflisted({buf})                数値    バッファ{buf}がリストにあるならTRUE
bufload({buf})                  数値    まだバッファ{buf}がロードされていなけ
                                        ればバッファをロードする
bufloaded({buf})                数値    バッファ{buf}がロード済みならTRUE
bufname([{buf}])                文字列  バッファ{buf}の名前
bufnr([{buf} [, {create}]])     数値    バッファ{buf}の番号
bufwinid({buf})                 数値    バッファ{buf}のウィンドウID
bufwinnr({buf})                 数値    バッファ{buf}のウィンドウ番号
byte2line({byte})               数値    {byte}番目のバイトの行番号
byteidx({expr}{nr})           数値    {expr}{nr}文字目のバイトインデックス
byteidxcomp({expr}{nr})       数値    {expr}{nr}文字目のバイトインデックス
call({func}{arglist} [, {dict}])
                                任意    引数{arglist}をつけて{func}を呼ぶ
ceil({expr})                    浮動小数点数    {expr} を切り上げる
ch_canread({handle})            数値    何か読むものがあるかをチェックする
ch_close({handle})              なし    {handle} を閉じる
ch_close_in({handle})           なし    {handle} の入力を閉じる
ch_evalexpr({handle}{expr} [, {options}])
                                任意    {handle} に {expr} を送り応答をJSONと
                                        して評価する
ch_evalraw({handle}{string} [, {options}])
                                任意    {handle} に {string} を送り応答を生の
                                        文字列として評価する
ch_getbufnr({handle}{what})   数値    {handle}/{what} に割り当てられたバッ
                                        ファ番号を得る
ch_getjob({channel})            ジョブ  {channel} の Job を得る
ch_info({handle})               文字列  チャネル {handle} に関する情報を得る
ch_log({msg} [, {handle}])      なし    チャネルのログファイルに {msg} を書き
                                        込む
ch_logfile({fname} [, {mode}])  なし    チャネルの挙動ログ出力を開始する
ch_open({address} [, {options}])
                                チャネル        {address} へのチャネルを開く
ch_read({handle} [, {options}]) 文字列  {handle} から読み込む
ch_readblob({handle} [, {options}])
                                Blob    {handle} からBlobを読み込む
ch_readraw({handle} [, {options}])
                                文字列  {handle} から生の文字列を読み込む
ch_sendexpr({handle}{expr} [, {options}])
                                任意    {expr}をJSONチャネル{handle}に送る
ch_sendraw({handle}{expr} [, {options}])
                                任意    {expr}をrawチャネル{handle}に送る
ch_setoptions({handle}{options})
                                なし    {handle}にオプションを設定する
ch_status({handle} [, {options}])
                                文字列  チャネル{handle}の状態
changenr()                      数値    現在の変更番号
char2nr({expr} [, {utf8}])      数値    {expr}の先頭文字のASCII/UTF-8コード
charclass({string})             数値    {string} の文字クラス
charcol({expr})                 数値    カーソルかマークのカラム番号
charidx({string}{idx} [, {countcc}])
                                数値    {string} のバイト {idx} の文字のイン
                                        デックス
chdir({dir})                    文字列  現在の作業ディレクトリを変更する
cindent({lnum})                 数値    {lnum}行目のCインデント量
clearmatches([{win}])           なし    全マッチをクリアする
col({expr})                     数値    カーソルかマークのカラムバイトインデッ
                                        クス
complete({startcol}{matches}) なし    挿入モード補完を設定する
complete_add({expr})            数値    補完候補を追加する
complete_check()                数値    補完中に押されたキーをチェックする
complete_info([{what}])         辞書    現在の補完情報を取得
confirm({msg} [, {choices} [, {default} [, {type}]]])
                                数値    ユーザーへの選択肢と番号
copy({expr})                    任意    {expr}の浅いコピーを作る
cos({expr})                     浮動小数点数    {expr} の余弦(コサイン)
cosh({expr})                    浮動小数点数    {expr}のハイパボリックコサイン
count({comp}{expr} [, {ic} [, {start}]])
                                数値     {comp}中に{expr}が何個現れるか数える
cscope_connection([{num}{dbpath} [, {prepend}]])
                                数値    cscope接続の存在を判定する
cursor({lnum}{col} [, {off}])
                                数値    カーソルを{lnum}{col}{off}へ移動
cursor({list})                  数値    カーソルを{list}の位置へ移動
debugbreak({pid})               数値    デバッグするプロセスへ割り込む
deepcopy({expr} [, {noref}])    任意    {expr}の完全なコピーを作る
delete({fname} [, {flags}])     数値    ファイルやディレクトリ{fname}を消す
deletebufline({buf}{first} [, {last}])
                                数値    バッファ {buf} から行を削除する
did_filetype()                  数値    FileTypeのautocommandが実行されたか?
diff_filler({lnum})             数値    差分モードで{lnum}に挿入された行
diff_hlID({lnum}{col})        数値    差分モードで{lnum}/{col}位置の強調
digraph_get({chars})            文字列  {chars} のダイグラフ digraph を取得
digraph_getlist([{listall}])    リスト  すべてのダイグラフ digraph を取得
digraph_set({chars}{digraph}) 真偽値  ダイグラフ digraph の登録
digraph_setlist({digraphlist})  真偽値  複数のダイグラフ digraph の登録
echoraw({expr})                 なし    {expr} をそのまま出力する
empty({expr})                   数値    {expr}が空ならTRUE
environ()                       辞書    すべての環境変数を返す
escape({string}{chars})       文字列  {string}内の{chars}を '\' でエスケープ
eval({string})                  任意    {string}を評価し、値を得る
eventhandler()                  数値    イベントハンドラの内側ならTRUE
executable({expr})              数値    実行可能な{expr}が存在するなら1
execute({command})              文字列  {command}を実行し、出力を得る
exepath({expr})                 文字列  コマンド {expr} のフルパス
exists({expr})                  数値    変数{expr}が存在したらTRUE
exists_compiled({expr})         数値    変数{var}がコンパイル時に存在したらTRUE
exp({expr})                     浮動小数点数    {expr}の指数
expand({expr} [, {nosuf} [, {list}]])
                                任意    {expr}内の特別なキーワードを展開
expandcmd({string} [, {options}])
                                文字列  :edit のように{string}を展開
extend({expr1}{expr2} [, {expr3}])
                                リスト/辞書 {expr1}{expr2}を要素として挿入
extendnew({expr1}{expr2} [, {expr3}])
                                リスト/辞書 extend() と同じだが新しいリスト/
                                辞書を作る
feedkeys({string} [, {mode}])   数値    先行入力バッファにキーシーケンスを追加
filereadable({file})            数値    {file}が読み込み可能ならTRUE
filewritable({file})            数値    {file}が書き込み可能ならTRUE
filter({expr1}{expr2})        リスト/辞書/Blob/文字列
                                        {expr2} が0となる要素を {expr1} からと
                                        り除く
finddir({name} [, {path} [, {count}]])
                                文字列  {path}からディレクトリ{name}を探す
findfile({name} [, {path} [, {count}]])
                                文字列  {path}からファイル{name}を探す
flatten({list} [, {maxdepth}])  リスト  リスト {list} を {maxdepth} の深さまで
                                        平坦化する
flattennew({list} [, {maxdepth}])
                                リスト  {list} のコピーを平坦化する
float2nr({expr})                数値    浮動小数点数 {expr} を数値に変換する
floor({expr})                   浮動小数点数    {expr} を切り捨てる
fmod({expr1}{expr2})          浮動小数点数    {expr1} / {expr2} の余り
fnameescape({fname})            文字列  {fname} 内の特殊文字をエスケープする
fnamemodify({fname}{mods})    文字列  ファイル名を変更
foldclosed({lnum})              数値    {lnum}の折り畳みの最初の行(閉じている
                                        なら)
foldclosedend({lnum})           数値    {lnum}の折り畳みの最後の行(閉じている
                                        なら)
foldlevel({lnum})               数値    {lnum}の折り畳みレベル
foldtext()                      文字列  閉じた折り畳みに表示されている行
foldtextresult({lnum})          文字列  {lnum}で閉じている折り畳みのテキスト
foreground()                    数値    Vimウィンドウを前面に移動する
fullcommand({name})             文字列  {name} から完全なコマンドを取得
funcref({name} [, {arglist}] [, {dict}])
                                Funcref 関数{name}への参照
function({name} [, {arglist}] [, {dict}])
                                Funcref 名前による関数{name}への参照
garbagecollect([{atexit}])      なし    メモリを解放する。循環参照を断ち切る
get({list}{idx} [, {def}])    任意    {list}{def}から要素{idx}を取得
get({dict}{key} [, {def}])    任意    {dict}{def}から要素{key}を取得
get({func}{what})             任意    funcref/partial {func}のプロパティ取得
getbufinfo([{buf}])             リスト  バッファに関する情報
getbufline({buf}{lnum} [, {end}])
                                リスト  バッファ{buf}{lnum}から{end}行目
getbufvar({buf}{varname} [, {def}])
                                任意    バッファ{buf}の変数 {varname}
getchangelist([{buf}])          リスト  変更リスト要素のリスト
getchar([expr])                 数値/文字列     ユーザーから1文字を取得する
getcharmod()                    数値    修飾キーの状態を表す数値を取得
getcharpos({expr})              リスト  カーソル、マーク、その他のカーソル位置
getcharsearch()                 辞書    最後の文字検索を取得
getcharstr([expr])              文字列  ユーザーから1文字を取得する
getcmdline()                    文字列  現在のコマンドラインを取得
getcmdpos()                     数値    コマンドラインのカーソル位置を取得
getcmdtype()                    文字列  現在のコマンドラインの種類を取得
getcmdwintype()                 文字列  現在のコマンドラインウィンドウの種類
getcompletion({pat}{type} [, {filtered}])
                                リスト  コマンドライン補完にマッチするリスト
getcurpos([{winnr}])            リスト  カーソルの位置
getcursorcharpos([{winnr}])     リスト  カーソルの位置の文字
getcwd([{winnr} [, {tabnr}]])   文字列  現在の作業ディレクトリを取得
getenv({name})                  文字列  環境変数を返す
getfontname([{name}])           文字列  使用しているフォントの名前
getfperm({fname})               文字列  ファイル{fname}の許可属性を取得
getfsize({fname})               数値    ファイル{fname}のバイト数を取得
getftime({fname})               数値    ファイルの最終更新時間
getftype({fname})               文字列  ファイル{fname}の種類の説明
getimstatus()                   数値    IME がアクティブの場合は TRUE
getjumplist([{winnr} [, {tabnr}]])
                                リスト  ジャンプリスト要素のリスト
getline({lnum})                 文字列  現在のバッファから行の内容を取得
getline({lnum}{end})          リスト  カレントバッファの{lnum}から{end}行目
getloclist({nr})                リスト  locationリストの要素のリスト
getloclist({nr}{what})        辞書    指定したlocationリストのプロパティ
getmarklist([{buf}])            リスト  グローバル/ローカルのマークのリスト
getmatches([{win}])             リスト  現在のマッチのリスト
getmousepos()                   辞書    マウスの最新の位置
getpid()                        数値    Vim のプロセス ID
getpos({expr})                  リスト  カーソル・マークなどの位置を取得
getqflist()                     リスト  quickfixリストの要素のリスト
getqflist({what})               辞書    指定したquickfixリストのプロパティ
getreg([{regname} [, 1 [, {list}]]])
                                文字列/リスト   レジスタの中身を取得
getreginfo([{regname}])         辞書    レジスタについての情報
getregtype([{regname}])         文字列  レジスタの種類を取得
gettabinfo([{expr}])            リスト  タブページのリスト
gettabvar({nr}{varname} [, {def}])
                                任意    タブ{nr}の変数{varname}または{def}
gettabwinvar({tabnr}{winnr}{name} [, {def}])
                                任意    タブページ{tabnr}{winnr}{name}
gettagstack([{nr}])             辞書    ウィンドウ{nr}のタグスタックを取得
gettext({text})                 文字列  {text} の翻訳の検索
getwininfo([{winid}])           リスト  各ウィンドウに関する情報のリスト
getwinpos([{timeout}])          リスト  Vim ウィンドウのピクセルでの X および
                                        Y 座標
getwinposx()                    数値    Vim ウィンドウのピクセルでの X 座標
getwinposy()                    数値    Vim ウィンドウのピクセルでの Y 座標
getwinvar({nr}{varname} [, {def}])
                                文字列  ウィンドウ{nr}の変数{varname}
glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])
                                任意    {expr}内のfile wildcardを展開
glob2regpat({expr})             文字列  globパターンを検索パターンに変換
globpath({path}{expr} [, {nosuf} [, {list} [, {alllinks}]]])
                                文字列  {path}の全ディレクトリに対し
                                        glob({expr})を行う
has({feature} [, {check}])      数値    機能{feature}がサポートならばTRUE
has_key({dict}{key})          数値    {dict}が要素{key}を持つならTRUE
haslocaldir([{winnr} [, {tabnr}]])
                                数値    現在のウィンドウで :lcd か :tcd が
                                        実行されたならTRUE
hasmapto({what} [, {mode} [, {abbr}]])
                                数値    {what}のマッピングが存在するならTRUE
histadd({history}{item})      数値    ヒストリに追加
histdel({history} [, {item}])   数値    ヒストリからitemを削除
histget({history} [, {index}])  文字列  ヒストリから{index}アイテムを取得
histnr({history})               数値    ヒストリの数
hlID({name})                    数値    highlight group {name}のID
hlexists({name})                数値    highlight group {name}が存在したらTRUE
hlget([{name} [, {resolve}]])   リスト  highlight group の属性を取得
hlset({list})                   数値    highlight group の属性を設定
hostname()                      文字列  vimが動作しているマシンの名前
iconv({expr}{from}{to})     文字列  {expr}のエンコーディングを変換する
indent({lnum})                  文字列  行{lnum}のインデントを取得
index({object}{expr} [, {start} [, {ic}]])
                                数値    {object}中に{expr}が現れる位置
input({prompt} [, {text} [, {completion}]])
                                文字列  ユーザーからの入力を取得
inputdialog({prompt} [, {text} [, {completion}]])
                                文字列  input()と同様。GUIのダイアログを使用
inputlist({textlist})           数値    ユーザーに選択肢から選ばせる
inputrestore()                  数値    先行入力を復元する
inputsave()                     数値    先行入力を保存し、クリアする
inputsecret({prompt} [, {text}]) 文字列 input()だがテキストを隠す
insert({object}{item} [, {idx}])
                                リスト  {object}に要素{item}を挿入 [{idx}の前]
interrupt()                     なし    スクリプトの実行を中断する
invert({expr})                  数値    ビット反転
isabsolutepath({path})          数値    {path} が絶対パスならば TRUE
isdirectory({directory})        数値    {directory}がディレクトリならばTRUE
isinf({expr})                   数値    {expr}が無限大の値(正または負)かどうか
                                        を判定する
islocked({expr})                数値    {expr}がロックされているならTRUE
isnan({expr})                   数値    {expr}がNaNならばTRUE
items({dict})                   リスト  {dict}のキーと値のペアを取得
job_getchannel({job})           チャネル  {job}のチャネルハンドルを取得
job_info([{job}])               辞書    {job}についての情報を取得
job_setoptions({job}{options}) なし   {job}のオプションを設定する
job_start({command} [, {options}])
                                ジョブ  ジョブを開始する
job_status({job})               文字列  {job}のステータスを取得する
job_stop({job} [, {how}])       数値    {job}を停止する
join({list} [, {sep}])          文字列  {list}の要素を連結して文字列にする
js_decode({string})             任意    JS形式のJSONをデコードする
js_encode({expr})               文字列  JS形式のJSONにエンコードする
json_decode({string})           任意    JSONをデコードする
json_encode({expr})             文字列  JSONにエンコードする
keys({dict})                    リスト  {dict}のキーを取得
len({expr})                     数値    {expr}の長さを取得
libcall({lib}{func}{arg})   文字列  ライブラリ{lib}の関数{func}をコール
libcallnr({lib}{func}{arg}) 数値    上と同じ。ただし数値を返す
line({expr} [, {winid}])        数値    行番号の取得
line2byte({lnum})               数値    行{lnum}のバイトカウント
lispindent({lnum})              数値    {lnum}行目のLispインデント量を取得
list2blob({list})               Blob    数値のリスト {list} をBlobに変換する
list2str({list} [, {utf8}])     文字列  数値のリスト {list} を文字列に変換する
listener_add({callback} [, {buf}])
                                数値    変更を監視するためのコールバックを追加
listener_flush([{buf}])         なし    リスナーコールバックを呼び出す
listener_remove({id})           なし    リスナーコールバックを削除する
localtime()                     数値    現在時刻
log({expr})                     浮動小数点数    {expr}の自然対数(底e)
log10({expr})                   浮動小数点数    浮動小数点数 {expr} の 10 を底
                                                とする対数
luaeval({expr} [, {expr}])      任意    Lua の式を評価する
map({expr1}{expr2})           リスト/辞書/Blob/文字列
                                        {expr1} の各要素を {expr2} に変える
maparg({name} [, {mode} [, {abbr} [, {dict}]]])
                                文字列/辞書
                                        モード{mode}でのマッピング{name}の値
mapcheck({name} [, {mode} [, {abbr}]])
                                文字列  {name}にマッチするマッピングを確認
maplist([{abbr}])               リスト  全マッピングのリスト、各要素は辞書
mapnew({expr1}{expr2})        リスト/辞書/Blob/文字列
                                        map() と同様だが新規のリストか辞書を
                                        作る
mapset({mode}{abbr}{dict})  なし    maparg() の結果からマッピングを復元
                                        する
match({expr}{pat} [, {start} [, {count}]])
                                数値    {expr}内で{pat}がマッチする位置
matchadd({group}{pattern} [, {priority} [, {id} [, {dict}]]])
                                数値    {pattern} を {group} で強調表示する
matchaddpos({group}{pos} [, {priority} [, {id} [, {dict}]]])
                                数値    位置を {group} で強調表示する
matcharg({nr})                  リスト  :matchの引数
matchdelete({id} [, {win}])     数値    {id} で指定されるマッチを削除する
matchend({expr}{pat} [, {start} [, {count}]])
                                数値    {expr}内で{pat}が終了する位置
matchfuzzy({list}{str} [, {dict}])
                                リスト  {list} 内について {str} でのファジー
                                        マッチ
matchfuzzypos({list}{str} [, {dict}])
                                リスト  {list} 内について {str} でのファジー
                                        マッチ
matchlist({expr}{pat} [, {start} [, {count}]])
                                リスト  {expr}内の{pat}のマッチと部分マッチ
matchstr({expr}{pat} [, {start} [, {count}]])
                                文字列  {expr}内の{count}番目の{pat}のマッチ
matchstrpos({expr}{pat} [, {start} [, {count}]])
                                リスト  {expr}内の{count}番目の{pat}のマッチ
max({expr})                     数値    {expr}内の要素の最大値
menu_info({name} [, {mode}])    辞書    メニューの項目情報を取得する
min({expr})                     数値    {expr}内の要素の最小値
mkdir({name} [, {path} [, {prot}]])
                                数値    ディレクトリ{name}を作成
mode([expr])                    文字列  現在の編集モード
mzeval({expr})                  任意    MzScheme の式を評価する
nextnonblank({lnum})            数値    {lnum}行目以降で空行でない行の行番号
nr2char({expr} [, {utf8}])      文字列  ASCII/UTF-8コード{expr}で示される文字
or({expr}{expr})              数値    ビット論理和
pathshorten({expr} [, {len}])   文字列  path内の短縮したディレクトリ名
perleval({expr})                任意    Perlの式を評価する
popup_atcursor({what}{options}) 数値  カーソルの近くにポップアップウィンドウ
                                        を作成する
popup_beval({what}{options})  数値    'balloon_eval' のポップアップウィンド
                                        ウを作成する
popup_clear()                   なし    すべてのポップアップウィンドウを閉じる
popup_close({id} [, {result}])  なし    {id} のポップアップウィンドウを閉じる
popup_create({what}{options}) 数値    ポップアップウィンドウを作成する
popup_dialog({what}{options}) 数値    ダイアログとしてポップアップウィンドウ
                                        を作成する
popup_filter_menu({id}{key})  数値    ポップアップウィンドウのメニューのフィ
                                        ルター
popup_filter_yesno({id}{key}) 数値    ポップアップウィンドウのダイアログの
                                        フィルター
popup_findinfo()                数値    情報ポップアップウィンドウの window ID
                                        を取得する
popup_findpreview()             数値    プレビューポップアップウィンドウの
                                        window ID を取得する
popup_getoptions({id})          辞書    ポップアップウィンドウ {id} のオプショ
                                        ンを取得する
popup_getpos({id})              辞書    ポップアップウィンドウ {id} の位置を取
                                        得する
popup_hide({id})                なし    ポップアップメニュー {id} を隠す
popup_list()                    リスト  全ポップアップのウィンドウIDのリストを
                                        取得する
popup_locate({row}{col})      数値    指定位置のポップアップのウィンドウIDを
                                        取得する
popup_menu({what}{options})   数値    メニューとして使われるポップアップウィ
                                        ンドウを作成する
popup_move({id}{options})     なし    ポップアップウィンドウ {id} の位置を
                                        セットする
popup_notification({what}{options})
                                数値    ポップアップウィンドウの通知を作成する
popup_setoptions({id}{options})
                                なし    ポップアップウィンドウ {id} のオプショ
                                        ンを設定する
popup_settext({id}{text})     なし    ポップアップウィンドウ {id} のテキスト
                                        を設定する
popup_show({id})                なし    ポップアップウィンドウ {id} を再表示す
                                        る
pow({x}{y})                   浮動小数点数    {x} の {y} 乗
prevnonblank({lnum})            数値    {lnum}行目以前の空行でない行の行番号
printf({fmt}{expr1}...)       文字列  文字列を組み立てる
prompt_getprompt({buf})         文字列  プロンプト文字列の取得
prompt_setcallback({buf}{expr}) なし  プロンプトコールバック関数を設定する
prompt_setinterrupt({buf}{text}) なし プロンプト割り込み関数を設定する
prompt_setprompt({buf}{text}) なし    プロンプトテキストを設定する
prop_add({lnum}{col}{props})  なし  テキストプロパティ1つを追加
prop_add_list({props}, [[{lnum}{col}{end-lnum}{end-col}], ...])
                                なし    複数のテキストプロパティを追加
prop_clear({lnum} [, {lnum-end} [, {props}]])
                                なし    全てのテキストプロパティを削除
prop_find({props} [, {direction}])
                                辞書    テキストプロパティを検索する
prop_list({lnum} [, {props}])   リスト  {lnum}行目のテキストプロパティを取得
prop_remove({props} [, {lnum} [, {lnum-end}]])
                                数値    テキストプロパティを削除
prop_type_add({name}{props})  なし    新しいプロパティタイプを定義
prop_type_change({name}{props})
                                なし    既存のプロパティタイプを変更
prop_type_delete({name} [, {props}])
                                なし    プロパティタイプを削除
prop_type_get({name} [, {props}])
                                辞書    プロパティタイプの値を取得
prop_type_list([{props}])       リスト  プロパティタイプ一覧を取得
pum_getpos()                    辞書    ポップアップメニューが表示されている場
                                        合、位置とサイズを取得
pumvisible()                    数値    ポップアップメニューが表示されているか
py3eval({expr})                 任意    python3 の式を評価する
pyeval({expr})                  任意    Python の式を評価する
pyxeval({expr})                 任意    python_x の式を評価する
rand([{expr}])                  数値    疑似乱数を取得する
range({expr} [, {max} [, {stride}]])
                                リスト  {expr}から{max}までの要素のリスト
readblob({fname})               Blob    {fname} から Blob を読む
readdir({dir} [, {expr} [, {dict}]])
                                リスト  {expr}によって選択された{dir}内のファ
                                        イル名を取得
readdirex({dir} [, {expr} [, {dict}]])
                                リスト  {expr}によって選択された{dir}内のファ
                                        イル情報を取得
readfile({fname} [, {type} [, {max}]])
                                リスト  ファイル{fname}から行のリストを取得
reduce({object}{func} [, {initial}])
                                任意    {func} を使って {object} の 畳み込み
                                        (reduce) を行う
reg_executing()                 文字列  実行中のレジスタ名を取得する
reg_recording()                 文字列  記録中のレジスタ名を取得する
reltime([{start} [, {end}]])    リスト  時刻の値を取得
reltimefloat({time})            浮動小数点数    時刻の値を浮動小数点に変換
reltimestr({time})              文字列  時刻の値を文字列に変換
remote_expr({server}{string} [, {idvar} [, {timeout}]])
                                文字列  式を送信する
remote_foreground({server})     数値    Vimサーバーを前面に出す
remote_peek({serverid} [, {retvar}])
                                数値    返信文字列を確認する
remote_read({serverid} [, {timeout}])
                                文字列  返信文字列を読み込む
remote_send({server}{string} [, {idvar}])
                                文字列  キーシーケンスを送信する
remote_startserver({name})      なし    サーバー {name} になる
remove({list}{idx} [, {end}]) 任意/リスト
                                        {list}から{idx}{end}間の要素を削除
remove({blob}{idx} [, {end}]) 数値/Blob
                                        {Blob}から{idx}{end}間のバイトを削除
remove({dict}{key})           任意    {dict}から要素{key}を削除
rename({from}{to})            数値    {file}から{to}へファイル名変更
repeat({expr}{count})         文字列  {expr}{count}回繰り返す
resolve({filename})             文字列  ショートカットが指す先のファイル名
reverse({list})                 文字列  {list}をその場で反転させる
round({expr})                   浮動小数点数    {expr} を四捨五入する
rubyeval({expr})                任意    Ruby の式を評価
screenattr({row}{col})        数値    スクリーン位置の属性
screenchar({row}{col})        数値    スクリーン位置の文字
screenchars({row}{col})       リスト  スクリーン位置の文字のリスト
screencol()                     数値    現在のカーソル列
screenpos({winid}{lnum}{col}) 辞書  スクリーン行と列のテキスト
screenrow()                     数値    現在のカーソル行
screenstring({row}{col})      文字列  スクリーン位置の文字列
search({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]])
                                数値    {pattern} を検索する
searchcount([{options}])        辞書    検索の統計の取得もしくは更新する
searchdecl({name} [, {global} [, {thisblock}]])
                                数値    変数の宣言を検索
searchpair({start}{middle}{end} [, {flags} [, {skip} [...]]])
                                数値    開始/終端のペアの他方を検索
searchpairpos({start}{middle}{end} [, {flags} [, {skip} [...]]])
                                リスト  開始/終端のペアの他方を検索
searchpos({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]])
                                リスト  {pattern}を検索
server2client({clientid}{string})
                                数値    返信文字列を送信する
serverlist()                    文字列  利用可能なサーバーのリストを取得
setbufline({expr}{lnum}{text})
                                数値    バッファ {expr} の {lnum} 行目に {text}
                                        を設定する
setbufvar({buf}{varname}{val})      バッファ{buf}内の変数{varname}{val}
                                        セット
setcellwidths({list})           なし    文字のセル幅の上書き設定
setcharpos({expr}{list})      数値    {list} の {expr} 位置に設定
setcharsearch({dict})           辞書    文字検索を{dict}に設定
setcmdpos({pos})                数値    コマンドライン内のカーソル位置を設定
setcursorcharpos({list})        数値    {list} の位置へカーソルを移動
setenv({name}{val})           なし    環境変数を設定
setfperm({fname}{mode})       数値    ファイル {fname} のパーミッションを
                                        {mode} に設定
setline({lnum}{line})         数値    行{lnum}{line}(文字列)をセット
setloclist({nr}{list} [, {action}])
                                数値    {list}を使ってlocationリストを変更
setloclist({nr}{list}{action}{what})
                                数値    指定したlocationリストのプロパティを
                                        変更
setmatches({list} [, {win}])    数値    マッチのリストを復元する
setpos({expr}{list})          なし    {expr}の位置を{list}にする
setqflist({list} [, {action}])  数値    {list}を使ってquickfixリストを変更
setqflist({list}{action}{what})
                                数値    指定したquickfixリストのプロパティを
                                        変更
setreg({n}{v} [, {opt}])      数値    レジスタの値とタイプを設定
settabvar({nr}{varname}{val}) なし  タブページ{nr}の変数{varname}{val}
                                        設定する
settabwinvar({tabnr}{winnr}{varname}{val})
                                なし    タブページ{tabnr}内のウィンドウ{winnr}
                                        の変数{varname}{val}をセット
settagstack({nr}{dict} [, {action}])
                                数値    {dict}を使ってタグスタックを変更
setwinvar({nr}{varname}{val}) なし  ウィンドウ{nr}の変数{varname}{val}
                                        セット
sha256({string})                文字列  {string}のSHA256チェックサム
shellescape({string} [, {special}])
                                文字列  {string}をシェルコマンド引数として使う
                                        ためにエスケープする。
shiftwidth([{col}])             数値    実際に使用される 'shiftwidth' の値
sign_define({name} [, {dict}])  数値    目印を定義または更新する
sign_define({list})             リスト  目印のリストを定義または更新する
sign_getdefined([{name}])       リスト  定義されている目印のリストを取得する
sign_getplaced([{buf} [, {dict}]])
                                リスト  設置されている目印のリストを取得する
sign_jump({id}{group}{buf})
                                数値    目印に移動する
sign_place({id}{group}{name}{buf} [, {dict}])
                                数値    目印を設置する
sign_placelist({list})          リスト  目印のリストを設置する
sign_undefine([{name}])         数値    目印を削除する
sign_undefine({list})           リスト  目印のリストを削除する
sign_unplace({group} [, {dict}])
                                数値    目印を解除する
sign_unplacelist({list})        リスト  目印のリストを解除する
simplify({filename})            文字列  ファイル名を可能なかぎり簡略化する
sin({expr})                     浮動小数点数    {expr} の正弦(サイン)
sinh({expr})                    浮動小数点数    {expr}のハイパボリックサイン
slice({expr}{start} [, {end}])  文字列、リスト、Blob
                                        文字列、リスト、Blob のスライス
sort({list} [, {how} [, {dict}]])
                                リスト  {list} を {how} で比較してソートする
sound_clear()                   なし    すべてのサウンドの再生を停止する
sound_playevent({name} [, {callback}])
                                数値    イベントサウンドを再生する
sound_playfile({path} [, {callback}])
                                数値    サウンドファイル{path}を再生する
sound_stop({id})                なし    サウンド{id}の再生を停止する
soundfold({word})               文字列  {word}のsound-fold
spellbadword()                  文字列  カーソル位置のスペルミスした単語
spellsuggest({word} [, {max} [, {capital}]])
                                リスト  スペリング補完
split({expr} [, {pat} [, {keepempty}]])
                                リスト  {expr}{pat}で区切ってリストを作る
sqrt({expr})                    浮動小数点数    {expr} の平方根
srand([{expr}])                 リスト  rand() 用の種を取得する
state([{what}])                 文字列  Vimの現在の状態
str2float({expr} [, {quoted}])  浮動小数点数    文字列を浮動小数点数に変換する
str2list({expr} [, {utf8}])     リスト  {expr}の各文字をASCII/UTF-8値に変換する
str2nr({expr} [, {base} [, {quoted}]])
                                数値    文字列を数値に変換する
strcharlen({expr})              数値    文字列 {expr} の文字の長さ
strcharpart({str}{start} [, {len} [, {skipcc}]])
                                文字列  {str} 内 {start} 文字目 から {len} 文
                                        字分
strchars({expr} [, {skipcc}])   数値    文字列{expr}の文字の数
strdisplaywidth({expr} [, {col}]) 数値  文字列{expr}の表示幅
strftime({format} [, {time}])   文字列  指定されたフォーマットで時刻を書式化
strgetchar({str}{index})      数値    {str} から {index} 番目の文字インデッ
                                        クスを得る
stridx({haystack}{needle} [, {start}])
                                数値    {haystack}内の{needle}のインデックス
string({expr})                  文字列  {expr}の値の文字列表現
strlen({expr})                  数値    文字列{expr}の長さ
strpart({str}{start} [, {len} [, {chars}]])
                                文字列  {str}{start}バイトから{len}バイト/
                                        文字分
strptime({format}{timestring})
                                数値    {timestring} を unix タイムスタンプに
                                        変換
strridx({haystack}{needle} [, {start}])
                                数値    {haystack}内の最後の{needle}のインデッ
                                        クス
strtrans({expr})                文字列  文字列を表示可能に変更
strwidth({expr})                数値    文字列{expr}の表示セル幅
submatch({nr} [, {list}])       文字列/リスト
                                        ":s" やsubstitute()における特定のマッチ
substitute({expr}{pat}{sub}{flags})
                                文字列  {expr}{pat}{sub}に置換え
swapinfo({fname})               辞書    スワップファイル {fname} に関する情報
swapname({buf})                 文字列  バッファ{buf}のスワップファイル名
synID({lnum}{col}{trans})   数値    {line}{col}のsyntax IDを取得
synIDattr({synID}{what} [, {mode}])
                                文字列  syntax ID{synID}の属性{what}を取得
synIDtrans({synID})             数値    {synID}の翻訳されたsyntax ID
synconcealed({lnum}{col})     リスト  Conceal の情報
synstack({lnum}{col}) リスト  {lnum}{col}列目における構文IDの
                                        スタック
system({expr} [, {input}])      文字列  シェルコマンド{expr}の出力結果
systemlist({expr} [, {input}])  リスト  シェルコマンド{expr}の出力結果
tabpagebuflist([{arg}])         リスト  タブページ内のバッファ番号のリスト
tabpagenr([{arg}])              数値    現在または最後のタブページの番号
tabpagewinnr({tabarg} [, {arg}])
                                数値    タブページ内の現在のウィンドウの番号
tagfiles()                      リスト  使用しているタグファイルのリスト
taglist({expr} [, {filename}])  リスト  {expr}にマッチするタグのリスト
tan({expr})                     浮動小数点数    {expr}のタンジェント
tanh({expr})                    浮動小数点数    {expr}のハイパボリックタンジェ
                                                ント
tempname()                      文字列  テンポラリファイルの名前
term_dumpdiff({filename}{filename} [, {options}])
                                数値    2 つのダンプ間の差分を表示する
term_dumpload({filename} [, {options}])
                                数値    スクリーンダンプの表示
term_dumpwrite({buf}{filename} [, {options}])
                                なし    端末ウィンドウの内容をダンプする
term_getaltscreen({buf})        数値    代替スクリーンフラグを取得する
term_getansicolors({buf})       リスト  GUI カラーモードでの ANSI パレットを取
                                        得する
term_getattr({attr}{what})    数値    属性 {what} の値を取得する
term_getcursor({buf})           リスト  端末のカーソル位置を取得する
term_getjob({buf})              ジョブ  端末に関連付けられているジョブを取得す
                                        る
term_getline({buf}{row})      文字列  端末から 1 行のテキストを取得する
term_getscrolled({buf})         数値    端末のスクロール数を取得する
term_getsize({buf})             リスト  端末のサイズを取得する
term_getstatus({buf})           文字列  端末の状態を取得する
term_gettitle({buf})            文字列  端末のタイトルを取得する
term_gettty({buf}, [{input}])   文字列  端末の tty 名を取得する
term_list()                     リスト  端末バッファのリストを取得する
term_scrape({buf}{row})       リスト  端末スクリーンの行を取得する
term_sendkeys({buf}{keys})    なし    キー入力を端末に送信する
term_setansicolors({buf}{colors})
                                なし    GUI カラーモードでの ANSI パレットを設
                                        定する
term_setapi({buf}{expr})      なし    terminal-api の関数名プリフィックス
                                        を設定する
term_setkill({buf}{how})      なし    端末のジョブを停止するためのシグナルを
                                        設定する
term_setrestore({buf}{command}) なし  端末を復元するためのコマンドを設定する
term_setsize({buf}{rows}{cols})
                                なし    端末のサイズを設定する
term_start({cmd} [, {options}]) 数値    端末ウィンドウを開きジョブを実行する
term_wait({buf} [, {time}])     数値    スクリーンが更新されるのを待つ
terminalprops()                 辞書    端末のプロパティ
test_alloc_fail({id}{countdown}{repeat})
                                なし    メモリの確保を失敗にさせる
test_autochdir()                なし    起動時に 'autochdir' を有効にする
test_feedinput({string})        なし    キー入力を入力バッファに追加する
test_garbagecollect_now()       なし    テスト用に直ちにメモリを解放する
test_garbagecollect_soon()      なし    テスト用にすぐにメモリを解放する
test_getvalue({string})         任意    内部変数の値を取得する
test_gui_event({event}{args}) 真偽値  テスト用の GUI イベントを発生させる
test_ignore_error({expr})       なし    特定のエラーを無視する
test_null_blob()                Blob    テスト用のnull値
test_null_channel()             チャネル        テスト用のnull値
test_null_dict()                辞書    テスト用のnull値
test_null_function()            Funcref テスト用のnull値
test_null_job()                 ジョブ  テスト用のnull値
test_null_list()                リスト  テスト用のnull値
test_null_partial()             Funcref テスト用のnull値
test_null_string()              文字列  テスト用のnull値
test_option_not_set({name})     なし    オプション設定フラグをリセットする
test_override({expr}{val})    なし    Vimの内部処理を置き換えてテストする
test_refcount({expr})           数値    {expr}の参照カウントを取得
test_setmouse({row}{col})     なし    テスト用にマウス位置を設定する
test_settime({expr})            なし    テスト用に現在の時刻を設定する
test_srand_seed([seed])         なし    srand() のテスト用に種を設定する
test_unknown()                  任意    テスト用のunknown値
test_void()                     任意    テスト用のvoid値
timer_info([{id}])              リスト  タイマーに関する情報
timer_pause({id}{pause})      なし    タイマーの一時停止または一時停止解除
timer_start({time}{callback} [, {options}])
                                数値    タイマーを作成する
timer_stop({timer})             なし    タイマーを停止する
timer_stopall()                 なし    すべてのタイマーを停止する
tolower({expr})                 文字列  文字列{expr}を小文字にする
toupper({expr})                 文字列  文字列{expr}を大文字にする
tr({src}{fromstr}{tostr})   文字列  {src}中に現れる文字{fromstr}{tostr}
                                        に変換する
trim({text} [, {mask} [, {dir}]])
                                文字列  {text} から {mask} 内の文字を切り取る
trunc({expr})                   浮動小数点数    浮動小数点数{expr}を切り詰める
type({expr})                    数値    変数{expr}の型
typename({expr})                文字列  {expr}の型を表す
undofile({name})                文字列  {name}に対するアンドゥファイルの名前
undotree()                      リスト  アンドゥファイルツリー
uniq({list} [, {func} [, {dict}]])
                                リスト  リストから隣接した重複を削除
values({dict})                  リスト  {dict}の値のリスト
virtcol({expr})                 数値    カーソルのスクリーンカラム位置
visualmode([expr])              文字列  最後に使われたビジュアルモード
wildmenumode()                  数値    'wildmenu' モードが有効かどうか
win_execute({id}{command} [, {silent}])
                                文字列  ウィンドウ{id}{command}を実行する
win_findbuf({bufnr})            リスト  {bufnr}を含むウィンドウを見つける
win_getid([{win} [, {tab}]])    数値    {tab}{win}のウィンドウIDを取得
win_gettype([{nr}])             文字列  ウィンドウ {nr} の型
win_gotoid({expr})              数値    ID {expr}のウィンドウに行く
win_id2tabwin({expr})           リスト  ウィンドウIDからタブとウィンドウnr取得
win_id2win({expr})              数値    ウィンドウIDからウィンドウnr取得
win_move_separator({nr})        数値    ウィンドウの垂直セパレータの移動
win_move_statusline({nr})       数値    ウィンドウのステータス行の移動
win_screenpos({nr})             リスト  ウィンドウ {nr} のスクリーン位置を取得
                                        する
win_splitmove({nr}{target} [, {options}])
                                数値    ウィンドウ {nr} を {target} の分割へ移
                                        動
winbufnr({nr})                  数値    ウィンドウ{nr}のバッファ番号
wincol()                        数値    カーソル位置のウィンドウ桁
windowsversion()                文字列  MS-Windows OS のバージョン
winheight({nr})                 数値    ウィンドウ{nr}の高さ
winlayout([{tabnr}])            リスト  タブ {tabnr} 内のウィンドウの配置
winline()                       数値    カーソル位置のウィンドウ行
winnr([{expr}])                 数値    現在のウィンドウの番号
winrestcmd()                    文字列  ウィンドウサイズを復元するコマンド
winrestview({dict})             なし    現在のウィンドウのビューを復元
winsaveview()                   辞書    現在のウィンドウのビューを保存
winwidth({nr})                  数値    ウィンドウ{nr}の幅を取得
wordcount()                     辞書    バイト/文字/単語の統計情報を取得
writefile({object}{fname} [, {flags}])
                                数値    行の Blob または list をファイルに
                                        書き込む
xor({expr}{expr})             数値    ビット排他的論理和

==============================================================================
2. 詳細                                         builtin-function-details

すべての関数はここにはなく、いくつかはそのカバーしている特別な機能のヘルプファ
イルへ移動している。

abs({expr})                                                     abs()
                {expr} の絶対値を返す。{expr} の値が浮動小数点数である場合は浮
                動小数点数を返す。{expr} がNumberに変換可能な場合は数値が戻
                り値になる。それ以外の場合はエラーメッセージを表示し、-1
                を返す。
                例:
                        echo abs(1.456)
                        1.456 
                        echo abs(-5.456)
                        5.456 
                        echo abs(-4)
                        4

                method としても使用できる:
                        Compute()->abs()

                {+float 機能を有効にしてコンパイルしたときのみ有効}


acos({expr})                                                    acos()
                {expr} の逆余弦 (アークコサイン) をラジアンで返す。
                値は [0, pi] の範囲の浮動小数点数 (Float)。
                {expr} は [-1, 1] の範囲の浮動小数点数 (Float) か数値
                (Number) でなければならない。
                例:
                        :echo acos(0)
                        1.570796
                        :echo acos(-0.5)
                        2.094395

                method としても使用できる:
                        Compute()->acos()

                {+float 機能を有効にしてコンパイルしたときのみ有効}


add({object}{expr})                                   add()
                List または Blob {object}の末尾に項目{expr}を追加する。結
                果の List か Blob を返す。例:
                        :let alist = add([1, 2, 3], item)
                        :call add(mylist, "woodstock")
                Note {expr}がリストのときは、1個の要素として追加される。リスト
                を連結するにはextend()を使う。
                {object}が Blob の場合、{expr}は数値でなければならない。
                他の位置に要素を追加するにはinsert()を使う。

                method としても使用できる:
                        mylist->add(val1)->add(val2)


and({expr}{expr})                                     and()
                二つの引数のビット論理積。引数は数値に変換される。リスト、辞
                書、浮動小数点数を指定するとエラーになる。
                例:
                        :let flag = and(bits, 0x80)
                method としても使用できる:
                        :let flag = bits->and(0x80)


append({lnum}{text})                                  append()
                {text}がリストListのときは、各要素をカレントバッファの{lnum}
                行目以降にテキストとして追加する。
                リストでないときは、{text}をテキストとしてカレントバッファの
                {lnum}行目以降にテキストとして追加する。
                要素としてどの型でも受け入れて文字列に変換される。
                {lnum}は0でもよく、その場合は1行目の前に行を挿入する。
                {lnum}getline()と同様に扱われる。
                失敗した場合は1を返す({lnum}が不正な範囲であるか、メモリ不足)。
                成功なら0を返す。Vim9 script では不正な引数であるか負数の場
                合は結果がエラーになる。例:
                        :let failed = append(line('$'), "# THE END")
                        :let failed = append(0, ["Chapter 1", "the beginning"])

                リストの後に method としても使用でき、ベースは第2引数として
                渡される:
                        mylist->append(lnum)


appendbufline({buf}{lnum}{text})                    appendbufline()
                append() と同様、ただしバッファ {buf} にテキストを追加する。

                この関数は、ロードされたバッファに対してのみ機能する。必要であ
                れば、最初に bufload() を呼び出すこと。

                {buf} の使い方については bufname() を参照。

                {lnum} は行番号をその下に追加する。Noteline() の使用は、追
                加対象のバッファではなくカレントバッファに適用される。バッファ
                の最後に追加するには "$" を使用する。他の文字列値はサポートれ
                ない。

                成功時には 0 が返り、失敗時には 1 が返る。
                Vim9 script では不正な {lnum} を与えられた時エラーになる。

                {buf} が有効なバッファでない、もしくは {lnum} が有効でない場
                合、エラーメッセージが与えられる。例:
                        :let failed = appendbufline(13, 0, "# THE START")

                リストの後に method としても使用でき、ベースは第2引数として
                渡される:
                        mylist->appendbufline(buf, lnum)


argc([{winid}])                                 argc()
                引数リスト内の、ファイルの数を返す。arglistを参照。
                {winid} が指定されていない場合は、カレントウィンドウの引数リス
                トが使われる。
                {winid} が -1 の場合、グローバル引数リストが使われる。
                もしくは、{winid} は、引数リストが使用されるウィンドウを指定す
                る: ウィンドウ番号またはウィンドウID。引数{winid} が無効な場合
                は -1 を返す。

                                                        argidx()
argidx()        引数リスト内の現在のインデックスを返す。最初のファイルは0とな
                る。argc() - 1が最後のファイルとなる。arglistを参照。

                                                        arglistid()
arglistid([{winnr} [, {tabnr}]])
                引数リストの ID を返す。値は引数リストを区別するための数値であ
                る。ゼロはグローバル引数リストを意味する。arglist 参照。
                引数が無効な場合は -1 を返す。

                引数を指定しなかった場合はカレントウィンドウが使われる。
                {winnr} を指定した場合はカレントタブページ内のウィンドウが使わ
                れる。
                {winnr} と {tabnr} を指定した場合は指定したタブページ内のウィ
                ンドウが使われる。
                {winnr} にはウィンドウ番号またはwindow-IDが使える。

                                                        argv()
argv([{nr} [, {winid}]])
                結果は引数リスト内の、{nr}番目のファイル。arglist を参照。
                "argv(0)" は一番最初のファイルを示す。例:
        :let i = 0
        :while i < argc()
        :  let f = escape(fnameescape(argv(i)), '.')
        :  exe 'amenu Arg.' .. f .. ' :e ' .. f .. '<CR>'
        :  let i = i + 1
        :endwhile
                引数{nr} が指定されなかった場合、または、-1 の場合、引数リス
                ト arglist 全体を返す。

                引数{winid} はウィンドウIDを指定する。
                Vimのコマンドライン引数については、v:argv を参照。

asin({expr})                                            asin()
                {expr} の逆正弦 (アークサイン) をラジアンで返す。
                値は [-pi/2, pi/2] の範囲の浮動小数点数 (Float)。
                {expr} は [-1, 1] の範囲の浮動小数点数 (Float) か数値
                (Number) でなければならない。
                例:
                        :echo asin(0.8)
                        0.927295
                        :echo asin(-0.5)
                        -0.523599

                method としても使用できる:
                        Compute()->asin()

                {+float 機能つきでコンパイルされたときのみ有効}


assert_ 関数群はここに文書化されている: assert-functions-details



atan({expr})                                            atan()
                {expr} の逆正接(アークタンジェント)の主値を浮動小数点数
                Float で返す。主値はラジアンで[-pi/2, +pi/2]の範囲内にある。
                {expr} は Float か Number に評価されなければならない。
                例:
                        :echo atan(100)
                        1.560797
                        :echo atan(-4.01)
                        -1.326405

                method としても使用できる:
                        Compute()->atan()

                {+float 機能つきでコンパイルされたときのみ有効}


atan2({expr1}{expr2})                                 atan2()
                {expr1} / {expr2} の逆正接 (アークタンジェント) をラジアンで返
                す。値は [-pi, pi] の範囲の浮動小数点数 (Float)。
                {expr1} と {expr2} は浮動小数点数 (Float) か数値 (Number)
                でなければならない。
                例:
                        :echo atan2(-1, 1)
                        -0.785398
                        :echo atan2(1, -1)
                        2.356194

                method としても使用できる:
                        Compute()->atan2(1)

                {+float 機能を有効にしてコンパイルしたときのみ有効}

balloon_gettext()                                       balloon_gettext()
                バルーン内の現在のテキストを返す。文字列に対してのみ使用され、
                リストには使用されない。

balloon_show({expr})                                    balloon_show()
                {expr} をバルーン内に表示する。GUI では {expr} は文字列として
                扱われる。端末では {expr} をバルーンの行を含むリストとしてもよ
                い。{expr} がリストでない場合、balloon_split() で分割される。
                {expr} が空文字列の場合、既存のバルーンは削除される。

                例:
                        func GetBalloonContent()
                           " ... 内容の取得を開始
                           return ''
                        endfunc
                        set balloonexpr=GetBalloonContent()

                        func BalloonCallback(result)
                          call balloon_show(a:result)
                        endfunc
                method としても使用できる:
                        GetText()->balloon_show()

                想定される使用方法は、バルーンの内容の取得が 'balloonexpr' か
                ら開始されることである。そこから非同期メソッドを呼び出し、コー
                ルバックから balloon_show() を呼び出す。'balloonexpr' 自身は
                空文字列かプレースホルダーを返すことができる。

                バルーンを表示できないときは何も起こらず、エラーメッセージも表
                示されない。
                {Vimが +balloon_eval もしくは +balloon_eval_term 機能付き
                でコンパイルされたときのみ有効}

balloon_split({msg})                                    balloon_split()
                文字列 {msg} をバルーン内で表示される行に分割する。カレントウィ
                ンドウサイズ用に分割され、デバッガ出力を表示するために最適化さ
                れる。
                分割された行の List を返す。
                method としても使用できる:
                        GetText()->balloon_split()->balloon_show()

                {+balloon_eval_term 機能付きでコンパイルされたときのみ有効}

blob2list({blob})                                       blob2list()
                Blob {blob} の各バイトを数値として保持するリストを返す。例:
                        blob2list(0z0102.0304)  returns [1, 2, 3, 4]
                        blob2list(0z)           returns []
                エラーの時は空リストを返す。list2blob() は反対のことをする。

                method としても使用できる:
                        GetBlob()->blob2list()

                                                        *browse()*
browse({save}{title}{initdir}{default})
                ファイル選択ダイアログを起動。"has("browse")" がTRUEを返すと
                き (幾つかのGUIバージョンに限定)だけ利用可能。
                入力フィールドの意味は:
                    {save}      TRUEならば書込み用ファイルの選択
                    {title}     ダイアログのタイトル
                    {initdir}   ダイアログの始まるディレクトリ
                    {default}   ファイル名の省略値
                ダイアログがキャンセルされるか、何かエラーがあるか、もしくはブ
                ラウジングが不可能ならば、空文字列が戻ってくる。

                                                        browsedir()
browsedir({title}{initdir})
                ディレクトリ選択ダイアログを起動。"has("browse")" がTRUEを返
                すとき(幾つかのGUIバージョンに限定)だけ利用可能。
                ディレクトリ選択ダイアログがないシステムにおいてはファイル選択
                ダイアログが使われる。その場合は、指定したいディレクトリの中の
                ファイルを選択すること。
                入力フィールドの意味は:
                    {title}     ダイアログのタイトル
                    {initdir}   ダイアログの始まるディレクトリ
                ダイアログがキャンセルされるか、何かエラーがあるか、もしくはブ
                ラウジングが不可能ならば、空文字列が戻ってくる。

bufadd({name})                                          bufadd()
                バッファリストに文字列 {name} という名前でバッファを追加する。
                もし、ファイル {name} 用のバッファが既に存在した場合、そのバッ
                ファの番号を返す。そうでなければ、新しく作られたバッファの番号
                を返す。{name} が空の文字列だったときは新しいバッファが常に作
                成される。
                バッファには 'buflisted' が設定されず、まだロードされない。
                バッファにテキストを追加するにはこれを使用する:
                        let bufnr = bufadd('someName')
                        call bufload(bufnr)
                        call setbufline(bufnr, 1, ['some', 'text'])
                method としても使用できる:
                        let bufnr = 'somename'->bufadd()

bufexists({buf})                                        bufexists()
                結果は数値で、{buf}と呼ばれるバッファが存在すればTRUEとなる。
                {buf}が数値の場合、バッファ番号とみなされる。数値の 0 はカレン
                トウィンドウの代替バッファである。

                {buf}が文字列の場合、バッファ名に正確にマッチしなければならな
                い。名前として以下のものが許される:
                - カレントディレクトリからの相対パス。
                - フルパス。
                - 'buftype' が "nofile" であるバッファの名前
                - URL名。
                バッファリストにないバッファも検索される。
                Note :buffersの出力で、ヘルプファイルは短い名前でリストされ
                ているが、bufexists()は長い名前でないと見つけることができない。
                ある名前を bufexists() に与えて非零になったとしても、その名前
                をコマンド :buffer に与える際には expand() を使って展開し
                なければならない場合がある。特に MS-Windows の "c:\DOCUME~1"
                という 8.3 名形式において。
                代替ファイル名が存在するかを判定するには "bufexists(0)" を使う。

                method としても使用できる:
                        let exists = 'somename'->bufexists()

                                                        buffer_exists()
                以前の名前: buffer_exists().

buflisted({buf})                                        buflisted()
                戻り値は数値で、{buf}と呼ばれるバッファが存在しリストされてい
                る ('buflisted' オプションがオンになっている) ならば結果は
                TRUEとなる。引数{buf}bufexists()と同じように扱われる。

                method としても使用できる:
                        let listed = 'somename'->buflisted()

bufload({buf})                                          bufload()
                バッファ{buf}がロードされていることを保証する。バッファの名前
                が既存のファイルを参照しているときは、そのファイルが読み込まれ
                る。そうでなければバッファは空になる。もし既にバッファが読み込
                まれていれば、変更はない。
                バッファのファイルに対して既存のスワップファイルがある場合、ダ
                イアログなしで、バッファはロードされる。
                引数{buf}bufexists()と同じように扱われる。

                method としても使用できる:
                        eval 'somename'->bufload()

bufloaded({buf})                                        bufloaded()
                戻り値は数値で、{buf}と呼ばれるバッファが存在しロード済み(ウィ
                ンドウに表示されているか、隠されているかは問わない)ならば結果
                はTRUEとなる。引数{buf}bufexists()と同じように扱われる。

                method としても使用できる:
                        let loaded = 'somename'->bufloaded()

bufname([{buf}])                                        bufname()
                戻り値はバッファの名前。バッファ名はコマンド :ls で表示され
                るものとほとんど同じだが、例えば "[No Name]" などの特殊名は使
                用しない。
                {buf}が省略された場合は、カレントバッファが使われる。
                {buf}が数値ならば、その番号のバッファ名が返される。0は現在の
                ウィンドウの代替バッファを意味する。{buf}が文字列ならば、バッ
                ファ名に対してファイル名マッチング file-pattern を行うパター
                ンとなる。このマッチングは常に、'magic' をセットし 'cpoptions'
                を空にした状態で行われる。複数マッチしてしまった場合には空文字
                列が返される。
                "" や "%" は現在のバッファを意味し、"#" は代替バッファを意味す
                る。
                完全マッチのものが優先され、完全マッチがなければ、バッファ名の
                先頭でのマッチ、末尾でのマッチ、中間でのマッチが探される。完全
                マッチのみを探すには、パターン先頭に "^" を、末尾に "$" をつけ
                る。
                まずバッファリストにあるバッファが探される。そこで1個だけマッ
                チが見つかればそれを返す。次にバッファリストにないものが探され
                る。
                {buf}が文字列のときに、それをバッファ番号として使いたいならば、
                0を足すことによって強制的に数値にすることができる:
                        echo bufname("3" + 0)
                method としても使用できる:
                        echo bufnr->bufname()

                バッファが存在しないか名前を持っていない場合には、空文字列が返
                される。
        bufname("#")            alternate buffer name
        bufname(3)              name of buffer 3
        bufname("%")            name of current buffer
        bufname("file2")        name of buffer where "file2" matches.
                                                        buffer_name()
                以前の名前: buffer_name().

                                                        bufnr()
bufnr([{buf} [, {create}]])
                結果はバッファの番号。バッファ番号はコマンド :ls で表示され
                るものと同様。{buf}の使い方は前述の bufname() を参照。

                バッファが存在しない場合-1が返される。ただし、{create}が与えら
                れて真であるときは、バッファリストに載せない新しいバッファを作
                成し、その番号を返す。例:
                        let newbuf = bufnr('Scratch001', 1)
                空の名前を使用すると、カレントバッファが使用される。空の名前で
                新しいバッファを作成するには、bufadd() を使用する。

                bufnr("$")は最後のバッファを意味する:
                        :let last_buffer = bufnr("$")
                結果は存在しているバッファのうちで、もっとも大きなバッファ番号
                となる。Note そのバッファ番号より小さいバッファ番号を持つ(ハズ
                の)バッファが、必ずしも全て存在するとは限らない。なぜなら
                ":bwipeout" がバッファを消すことができるからだ。バッファが存在
                するかテストするにはbufexists()を使う。

                method としても使用できる:
                        echo bufref->bufnr()

                以前の名前: buffer_number().            buffer_number()
                                                        last_buffer_nr()
                bufnr("$")の以前の名前: last_buffer_nr().

bufwinid({buf})                                         bufwinid()
                その結果は数値で、バッファ{buf}に関連付けられた最初のウィンド
                ウの window-ID{buf}の使い方は前述のbufname()を参照。バッ
                ファ{buf}が存在しないか、ウィンドウが無い場合は、-1が返される。
                例:

        echo "A window containing buffer 1 is " .. (bufwinid(1))

                現在のタブページのみを処理する。

                method としても使用できる:
                        FindBuffer()->bufwinid()

bufwinnr({buf})                                         bufwinnr()
                bufwinid() と同様だが、バッファの window-ID ではなくウィン
                ドウ番号を返す。バッファ{buf} が存在しないか、ウィンドウが無い
                場合には-1を返す。例:

        echo "A window containing buffer 1 is " .. (bufwinnr(1))

                この番号はCTRL-W_wや ":wincmd w" :wincmdで使える。

                method としても使用できる:
                        FindBuffer()->bufwinnr()

byte2line({byte})                                       byte2line()
                カレントバッファの先頭から{byte}番目の文字が、何行目に含まれる
                かを返す。これにはカレントバッファの 'fileformat' に依存した、
                改行文字も含まれる。先頭の文字にはバイトカウント1が与えられる。
                line2byte()go:gotoも参照。

                method としても使用できる:
                        GetOffset()->byte2line()

                {+byte_offset 機能付きでコンパイルされたときのみ有効}

byteidx({expr}{nr})                                   byteidx()
                文字列{expr}{nr}番目の文字のバイトインデックスを返す。最初の
                文字の{nr}は0であり、そして戻り値は0となる。
                マルチバイト文字がない時は{nr}に等しい値を返す。
                合成文字はまとめて計算される。合成文字のバイト数はそれが合成さ
                れているベース文字のバイト数に合算される。合成文字を別々に数え
                るには byteidxcomp() を参照。
                例 :
                        echo matchstr(str, ".", byteidx(str, 3))
                は4文字目を表示する。次も同じことをする:
                        let s = strpart(str, byteidx(str, 3))
                        echo strpart(s, 0, byteidx(s, 1))
                strgetchar() と strcharpart() も参照。
                {expr}{nr}文字以下の場合は-1を返す。
                {expr}がちょうど{nr}文字の場合は文字列の長さ(バイト単位)を返す。

                method としても使用できる:
                        GetName()->byteidx(idx)

byteidxcomp({expr}{nr})                                       byteidxcomp()
                byteidx() と同じだが、合成文字は個別にカウントされる。例:
                        let s = 'e' .. nr2char(0x301)
                        echo byteidx(s, 1)
                        echo byteidxcomp(s, 1)
                        echo byteidxcomp(s, 2)
                1 番目と 3 番目は 3 が出力される ('e' の長さと合成文字の長さを
                足すと 3 バイト)。2 番目は 1 が出力される ('e' は 1 バイト)。
                'encoding' に Unicode が設定されているときのみ byteidx() と違っ
                た動作になる。

                method としても使用できる:
                        GetName()->byteidxcomp(idx)

call({func}{arglist} [, {dict}])                      call() E699
                リストList{arglist}の要素を引数として関数{func}を呼ぶ。
                {func}Funcrefでも関数の名前でもよい。
                a:firstlineとa:lastlineにはカレント行が代入される。
                呼び出した関数の戻り値を返す。
                {dict}は "dict" 属性つきの関数用で、これがローカル変数 "self"
                に代入される。Dictionary-functionを参照。

                method としても使用できる:
                        GetFunc()->call([arg, arg], dict)

ceil({expr})                                                    ceil()
                {expr} 以上となる最小の整数を浮動小数点数 Float で返す
                (切り上げる)。
                {expr} は Float か Number に評価されなければならない。
                例:
                        echo ceil(1.456)
                        2.0 
                        echo ceil(-5.456)
                        -5.0 
                        echo ceil(4.0)
                        4.0

                method としても使用できる:
                        Compute()->ceil()

                {+float 機能つきでコンパイルされたときのみ有効}


ch_ 関数群はここに文書化されている: channel-functions-details


changenr()                                              changenr()
                最も最近の変更の番号を返す。:undolistで表示される番号と同じ
                であり、:undoコマンドの引数として使うことができる。
                変更を行った直後ではその変更の番号となる。redoを行った直後は
                redoされた変更の番号となる。undoを行った直後はundoされた変更よ
                り1小さい番号になる。

char2nr({string} [, {utf8}])                                    char2nr()
                {string}の最初の文字のASCIIコードを返す。例:
                        char2nr(" ")            returns 32
                        char2nr("ABC")          returns 65
                {utf8} を省略、またはゼロを指定すると、現在の 'encoding' が適
                用される。"utf-8" の場合の例:
                        char2nr("á")            returns 225
                        char2nr("á"[0])         returns 195
                {utf8} に真が指定された場合、常に UTF-8 文字として扱われる。
                合成文字は個別の文字として扱われる。
                nr2char() はこの逆を行う。
                文字列を文字の番号のリストに変換するには:
                    let str = "ABC"
                    let list = map(split(str, '\zs'), {_, val -> char2nr(val)})
                結果: [65, 66, 67]

                method としても使用できる:
                        GetChar()->char2nr()


charclass({string})                                     charclass()
                {string} 内の最初の文字の文字クラスを返す。
                文字クラスは次のいずれか:
                        0       空白
                        1       区切り文字
                        2       単語文字
                        3       絵文字
                        その他  Unicode 固有のクラス
                クラスはパターンと単語単位の移動で使われる。

charcol({expr})                                         charcol()
                col() と同様だが {expr} で返す桁位置がバイトインデックスでは
                なく文字インデックスになる。

                例:
                5行目のテキスト "여보세요" の '세' にカーソルがある状態:
                        charcol('.')            returns 3
                        col('.')                returns 7

                |method| としても使用できる: >
                        GetPos()->col()

                                                        charidx()
charidx({string}{idx} [, {countcc}])
                {string} 内の {idx} バイト目の文字インデックスを返す。最初の文
                字のインデックスは0。
                マルチバイト文字がない時は {idx} に等しい値を返す。
                {countcc} がないもしくは FALSE の場合、合成文字は分割して文
                字としてカウントせず、先行する基底文字に合成文字のバイト長が足
                される。
                {countcc} が TRUE の場合、合成文字は分割した文字としてカウン
                トされる。
                引数が不正であるか {idx} が {string} の最後のバイトより大きい
                場合-1が返る。最初の引数が文字列でない、2番目の引数が数値でな
                い、もしくは3番目の引数ありで0でも1でもない場合はエラーとなる。
                文字インデックスからバイトインデックスを得るには byteidx()
                と byteidxcomp() を参照。
                例:
                        echo charidx('áb́ć', 3)          returns 1
                        echo charidx('áb́ć', 6, 1)       returns 4
                        echo charidx('áb́ć', 16)         returns -1

                method としても使用できる:
                        GetName()->charidx(idx)

chdir({dir})                                            chdir()
                {dir}は文字列でなければならない。
                現在の作業ディレクトリを {dir} に変更する。ディレクトリの変更
                範囲は、カレントウィンドウのディレクトリによって異なる:
                        - カレントウィンドウにウィンドウローカルディレクトリ
                          (:lcd)がある場合は、ウィンドウローカルディレクトリ
                          を変更する。
                        - それ以外の場合、カレントタブページにローカルディレク
                          トリ(:tcd)がある場合は、タブページのローカルディレ
                          クトリを変更する。
                        - それ以外の場合、グローバルディレクトリを変更する。
                成功した場合は、前の作業ディレクトリを返す。ディレクトリを復元
                するには、これを別の chdir() に渡すこと。
                失敗した場合は、空の文字列を返す。

                例:
                        let save_dir = chdir(newdir)
                        if save_dir != ""
                           " ... いくつかの作業をおこなう
                           call chdir(save_dir)
                        endif

                method としても使用できる:
                        GetDir()->chdir()

cindent({lnum})                                         cindent()
                'cindent' で使われるのと同じC言語用のインデント規則に従った場
                合の{lnum}行目のインデント量を返す。
                インデント量はスペースで数えられ、'tabstop' の値は関係ない。
                {lnum}getline()の場合と同様に扱われる。
                {lnum}が無効な値のときや+cindent機能なしでコンパイルされてい
                るときは-1を返す。
                C-indentingを参照。

                method としても使用できる:
                        GetLnum()->cindent()

clearmatches([{win}])                                   clearmatches()
                matchadd() と コマンド :match によりカレントウィンドウに定
                義されたマッチをすべて消去する。
                {win} が指定されれば、カレントウィンドウではなく指定されたウィ
                ンドウあるいはウィンドウID を対象にする。

                method としても使用できる:
                        GetWin()->clearmatches()

                                                        col()
col({expr})     戻り値は数値で、{expr}で与えられる位置の桁番号(バイトインデッ
                クス)。有効な位置は:
                    .       現在の位置
                    $       カレント行の末尾(カレント行のバイト数+1を返す)
                    'x      マークxの位置(マークが設定されていない場合0)
                    v       ビジュアルモードでは: ビジュアル選択領域の開始行
                            (カーソルがその端)。ビジュアルモード以外ではカーソ
                            ル位置を返す。すぐに更新される点が '< と違う。
                さらに {expr} は [lnum, col] という行番号と桁番号のリストで
                あってもよい。col に "$" を指定して、ある行の最後の桁を取得す
                るのにとても便利である。"lnum" か "col" が範囲外である場合は
                0 を返す。
                行番号を取得するにはline()を使う。行番号と桁番号両方を取得す
                るにはgetpos()を使う。
                画面上の桁番号を取得するにはvirtcol()を使う。文字の位置を取
                得するには charcol() を使う。
                Note 現在のファイルのマークしか使えないことに注意。
                例:
                        col(".")                カーソルの桁
                        col("$")                カレント行の長さ+1
                        col("'t")               マークtの桁
                        col("'" .. markname)    マークmarknameの桁
                先頭の桁は1になる。戻り値0はエラーを意味する。
                大文字のマークは他のバッファを指しているかもしれない。
                'virtualedit' が有効なとき、カーソルが行末を越えていると、桁番
                号は行の長さより1大きい値を返す。挿入モードで桁番号を取得する
                には次のマップが使える:
                        :imap <F2> <C-O>:let save_ve = &ve<CR>
                                \<C-O>:set ve=all<CR>
                                \<C-O>:echo col(".") .. "\n" <Bar>
                                \let &ve = save_ve<CR>

                method としても使用できる:
                        GetPos()->col()

complete({startcol}{matches})                 complete() E785
                挿入モード補完の候補を設定する。
                挿入モードでのみ使用できる。CTRL-R = (i_CTRL-R を参照)と組み
                合わせてマッピングを作る必要がある。CTRL-Oの後や、<expr>マッピ
                ングの中では正しく動作しない。
                {startcol}は補完すべき単語の開始位置を示す、行内のバイトオフセッ
                トである。その位置からカーソルまでのテキストが補完すべき単語と
                なる。
                {matches}はリストListでなければならない。リストの各要素が1つ
                の候補となる。この要素として許される値については
                complete-itemsを参照。
                'completeopt' の "longest" は無視される。
                Note この関数を呼んだ後は補完を停止させるようなテキストの挿入
                をしないように注意しなければならない。
                この関数で設定した候補は普通の挿入モード補完と同じ様にCTRL-N
                CTRL-Pで選択できる。設定されていればポップアップメニューが表示
                される。ins-completion-menuを参照。
                例:
        inoremap <F5> <C-R>=ListMonths()<CR>
        func! ListMonths()
          call complete(col('.'), ['January', 'February', 'March',
                \ 'April', 'May', 'June', 'July', 'August', 'September',
                \ 'October', 'November', 'December'])
          return ''
        endfunc
                この例はそれほど役には立たないが、使い方を示している。Note 0が
                挿入されてしまわないように空文字列を返していることに注意。

                method としても使用でき、ベースは第2引数として渡される:
                        GetMatches()->complete(col('.'))

complete_add({expr})                            complete_add()
                候補のリストに{expr}を追加する。'completefunc' で指定された関
                数の中でのみ使われる。
                失敗したときは0を返す(空文字列かメモリ不足)。候補が追加された
                ときは1を返し、その候補が既にリストに存在するときは2を返す。
                {expr}の説明についてはcomplete-functionsを参照。'omnifunc'
                が返すリストと同じである。

                method としても使用できる:
                        GetMoreMatches()->complete_add()

complete_check()                                complete_check()
                補完候補を探している間にキーがタイプされたかどうか確認する。補
                完の検索に時間がかかる場合に使われる。候補の検索を中断しようと
                しているときはTRUEを返す。そうでないときは0を返す。
                'completefunc' で指定された関数の中でのみ使われる。


complete_info([{what}])                         complete_info()
                挿入モードの補完に関する情報を辞書 Dictionary で返す。
                ins-completion を参照。
                要素は以下の通り:
                   mode         現在の補完モード名の文字列。
                                値は complete_info_mode を参照。
                   pum_visible  ポップアップメニューが表示されているなら TRUE
                                pumvisible() を参照。
                   items        補完マッチのリスト。各要素は "word", "abbr",
                                "menu", "kind", "info", "user_data" を含む辞書。
                                complete-items を参照。
                   selected     選択された補完候補のインデックス。最初のイン
                                デックスが 0。どの補完候補も選択されていなけれ
                                ば -1 (入力したテキストのみ表示、もしくは <Up>
                                や <Down> キーを利用した最後の補完後に選択しな
                                かった場合)。
                   inserted     入力された文字列。[現時点では未実装]

                                                        complete_info_mode
                mode の値は:
                   ""                補完モードでない
                   "keyword"         キーワード補完 i_CTRL-X_CTRL-N
                   "ctrl_x"          CTRL-X のみが入力された i_CTRL-X
                   "scroll"          i_CTRL-X_CTRL-E か i_CTRL-X_CTRL-Y
                                     でのスクロール
                   "whole_line"      行全体補完 i_CTRL-X_CTRL-L
                   "files"           ファイル名補完 i_CTRL-X_CTRL-F
                   "tags"            タグ補完 i_CTRL-X_CTRL-]
                   "path_defines"    定義補完 i_CTRL-X_CTRL-D
                   "path_patterns"   インクルード補完 i_CTRL-X_CTRL-I
                   "dictionary"      辞書補完 i_CTRL-X_CTRL-K
                   "thesaurus"       同義語補完 i_CTRL-X_CTRL-T
                   "cmdline"         Vim コマンドライン補完 i_CTRL-X_CTRL-V
                   "function"        ユーザー定義補完 i_CTRL-X_CTRL-U
                   "omni"            オムニ補完 i_CTRL-X_CTRL-O
                   "spell"           スペル補完 i_CTRL-X_s
                   "eval"            complete() 補完
                   "unknown"         その他の内部モード

                オプショナル引数としてリスト {what} が与えられると、 {what} に
                ある項目のみが返る。{what} 内のサポートされていない項目は無視
                される。

                ポップアップメニューの位置とサイズを取得するには、
                pum_getpos() を参照。CompleteChanged イベント中に v:event
                でも利用可能である。

                例:
                        " 全ての項目を取得
                        call complete_info()
                        " 'mode' のみを取得
                        call complete_info(['mode'])
                        " 'mode' と 'pum_visible' のみを取得
                        call complete_info(['mode', 'pum_visible'])

                method としても使用できる:
                        GetItems()->complete_info()

                                                        confirm()
confirm({msg} [, {choices} [, {default} [, {type}]]])
                confirm()はユーザーに選択させるためのダイアログを提供する。戻
                り値は選択した番号になる。最初の選択肢が1である。
                Note: confirm()は、ダイアログサポートを有効にしてコンパイルし
                た時にだけ動作する。+dialog_con+dialog_guiを参照。

                ダイアログには{msg}に加えて{choices}の選択肢が表示される。
                {choices}が指定されない、または空の場合は選択肢 "&OK" が表示さ
                れる(使用している言語に翻訳される)。
                {msg}は文字列で '\n' を改行として使用できる。幾つかのシステム
                では、長すぎる行は自動的に折り返される。

                {choices}は文字列で、個々の選択肢は '\n' によって区切られる。
                例:
                        confirm("Save changes?", "&Yes\n&No\n&Cancel")
                '&' の後の文字は選択肢のショートカットキーになる。この場合
                "Cancel" を選択するのに 'c' をタイプすることができる。ショート
                カットキーは最初の文字である必要は無い:
                        confirm("file has been modified", "&Save\nSave &All")
                コンソールでは、デフォルトのショートカットキーとして、各選択肢
                の最初の文字が使われる。大文字小文字は区別されない。

                省略可能な引数{default}<CR>キーを叩いた時に選択される選択肢
                の番号を指定する。最初の選択肢をデフォルトにするならば1を使用
                する。デフォルトを設定したくないのならば0を使用する。
                {default}を省略した場合、1が使用される。

                省略可能な文字列引数{type}はダイアログの種類を指定する。これは
                GTK, Mac, Motif, Win32 の GUI でアイコンを指定するのに使われ
                る。"Error", "Question", "Info", "Warning", "Generic" のうちど
                れか一つを指定する。以上のうちの先頭の文字だけで指定できる。
                {type} が省略された場合、"Generic" が使用される。

                ユーザーが<Esc>CTRL-Cや、その他の割りこみキーでダイアログを
                中断した場合、confirm()は0を返す。

                例:
                   let choice = confirm("What do you want?",
                                        \ "&Apples\n&Oranges\n&Bananas", 2)
                   if choice == 0
                        echo "make up your mind!"
                   elseif choice == 3
                        echo "tasteful"
                   else
                        echo "I prefer bananas myself."
                   endif
                GUIのダイアログではボタンが使用される。ボタンの配置は
                'guioptions' の 'v' フラグに依存する。もしも 'v' フラグが含ま
                れているのなら、ボタンは常に垂直に配置される。そうでなければ水
                平に配置しようと試みられる。水平配置がうまくマッチしない場合
                は、垂直配置が使われる。幾つかのシステムでは常に水平配置が使わ
                れる。

                method としても使用できる:
                        BuildMessage()->confirm("&Yes\n&No")

                                                        copy()
copy({expr})    {expr}のコピーを作る。数値と文字列の場合は、{expr}そのものとコ
                ピーの間に違いはない。
                {expr}がリストListの場合は浅いコピーを作る。つまり元のリスト
                を変更してもコピーは変更されず、逆も同じである。しかし要素は共
                通で、片方の要素に対し変更を加えると、もう一方の要素も変更され
                る。
                辞書はリストと同様な方法でコピーされる。
                deepcopy()も参照。
                method としても使用できる:
                        mylist->copy()

cos({expr})                                             cos()
                {expr} の余弦(コサイン)をラジアンで浮動小数点数 Float で返す。
                {expr} は Float または Number に評価されなければならない。
                例:
                        :echo cos(100)
                        0.862319
                        :echo cos(-4.01)
                        -0.646043

                method としても使用できる:
                        Compute()->cos()

                {+float 機能つきでコンパイルされたときのみ有効}


cosh({expr})                                            cosh()
                {expr} の双曲線余弦 (ハイパボリックコサイン) を返す。
                値は [1, inf] の範囲の浮動小数点数 (Float)。
                {expr} は浮動小数点数 (Float) か 数値 (Number) でなければ
                ならない。
                例:
                        :echo cosh(0.5)
                        1.127626
                        :echo cosh(-0.5)
                        -1.127626

                method としても使用できる:
                        Compute()->cosh()

                {+float 機能を有効にしてコンパイルしたときのみ有効}


count({comp}{expr} [, {ic} [, {start}]])                      count()
                文字列String、リストListまたは辞書Dictionary {comp} の中
                に値 {expr} が何回現れるかを返す。

                {start} が指定されたときはそのインデックスの要素から検索を開始
                する。{start} は {comp} がリストの場合のみ使用できる。

                {ic} が指定され、TRUEの場合は大文字・小文字は区別されない。

                {comp} が文字列の場合、オーバーラップしていない {expr} の回数
                が返される。{expr} が空文字列の場合は 0 が返る。

                method としても使用できる:
                        mylist->count(val)

                                                        cscope_connection()
cscope_connection([{num} , {dbpath} [, {prepend}]])
                cscope接続が存在するかどうか判定する。引数が1個も指定されな
                かった場合、戻り値は以下のようになる:
                        0, cscopeが利用できない(コンパイル時に無効化されている)
                           またはcscope接続が存在しない場合
                        1, 1個以上のcscope接続が存在する場合

                引数が与えられた場合は次のようになる。{num}は、接続の存在を確
                認する際のマッチング方法を指定する。

                {num}   存在確認の方法
                -----   ------------------------------
                0       引数なしの場合と同じ (例: "cscope_connection()")。
                1       {prepend}を無視し、{dbpath}に部分マッチを行う。
                2       {prepend}を無視し、{dbpath}に部分マッチを行う。
                3       {prepend}を使用し、{dbpath}{prepend}に部分マッチを行
                        う。
                4       {prepend}を使用し、{dbpath}{prepend}に完全マッチを行
                        う。

                Note: 以上のどの場合も文字列の比較は大文字・小文字を区別する。

                例: ":cs show" の表示が以下のようになったとする:

  # pid    database name                        prepend path
  0 27664  cscope.out                           /usr/local

                実行                                            戻り値
                ----------                                      ----------
                cscope_connection()                                     1
                cscope_connection(1, "out")                             1
                cscope_connection(2, "out")                             0
                cscope_connection(3, "out")                             0
                cscope_connection(3, "out", "local")                    1
                cscope_connection(4, "out")                             0
                cscope_connection(4, "out", "local")                    0
                cscope_connection(4, "cscope.out", "/usr/local")        1

cursor({lnum}{col} [, {off}])                         cursor()
cursor({list})
                {lnum}行目の{col}桁目(バイトで数える)にカーソルを移動させる。
                桁番号{col}は1から始まる。

                引数に {list} が 1 つだけ指定された場合は、それは要素が 2 個か
                3 個、または 4 個の List として解釈される:
                        [{lnum}{col}]
                        [{lnum}{col}{off}]
                        [{lnum}{col}{off}{curswant}]
                これは getpos() や getcurpos() の戻り値とほぼ同じである。
                違いは最初の要素がないこと。

                カーソルを文字数でカウントして位置させるには、
                setcursorcharpos() を使う。

                この関数を呼んでもジャンプリストは変更されない。
                {lnum}getline()と同様に扱われる。
                {lnum}がバッファの行数よりも大きい場合は、最後の行へ移動する。
                {lnum}が0の場合はカレント行に留まる。
                {col}がその行のバイト数より大きい場合は、その行の最後の文字へ
                移動する。
                {col}が0の場合は、カレント桁に留まる。
                {curswant} が与えられた場合は、縦方向移動の優先的列番号として
                使われる。指定がない場合は {col} が使われる。

                'virtualedit' が有効のとき、{off}は文字の先頭からの画面上のオ
                フセットを指定する。例えば、<Tab>の中の位置や最後の文字より後
                などへも移動できる。
                カーソルを移動できたときは 0 を、できなかったときは-1 を返す。

                method としても使用できる:
                        GetCursorPos()->cursor()

debugbreak({pid})                                       debugbreak()
                主にデバッグしているプログラムに割り込むために使用される。プロ
                セス {pid} に対して SIGTRAP を発生させる。関係のないプロセスへ
                の振る舞いは未定義である。terminal-debugger を参照。
                {MS-Windows 上でのみ有効}

                method としても使用できる:
                        GetPid()->debugbreak()

deepcopy({expr} [, {noref}])                            deepcopy() E698
                {expr}のコピーを作る。数値と文字列の場合は、{expr}そのものとコ
                ピーの間に違いはない。
                {expr}がリストListの場合は完全なコピーを作る。つまり元のリス
                トを変更してもコピーは変更されず、逆も同じである。要素の1つが
                リストまたは辞書であるときは、再帰的にコピーが作成される。
                よってコピーの要素に変更を加えても元のリストの要素は変更を受け
                ない。
                辞書はリストと同様な方法でコピーされる。

                {noref}が省略された、または0のとき、含まれているリストや辞書は
                1度だけコピーされる。全ての参照はこのただ1つのコピーを指す。
                {noref}が1の場合、リストや辞書は現れるたびに新しいコピーが作ら
                れる。そのため循環参照があるとdeepcopy()は失敗する。
                                                                E724
                ネストは100レベルまで可能である。それ以上参照を繰り返している
                要素があると、{noref}が1の場合は失敗する。
                copy()も参照。

                method としても使用できる:
                        GetObject()->deepcopy()

delete({fname} [, {flags}])                             delete()
                {flags}を指定しないもしくは{flags}を空で指定した場合: ファイル
                {fname}を削除する。

                これは{fname}がシンボリックリンクの時でも動作し、シンボリック
                リンクは、それが示すものではなく、リンク自身が削除される。

                {flags}が "d" の場合: ディレクトリ{fname}を削除する。
                これはディレクトリ{fname}が空でない場合は失敗する。

                {flags}が "rf" の場合: ディレクトリ{fname}、その中に含むすべて
                のものを再帰的に削除する。気をつけて!
                Note: MS-Windowsでは、使用中のディレクトリを削除することはでき
                ない。

                結果は数値であり、削除に成功すれば 0/false、削除に(部分的にで
                も)失敗すれば -1/true である。

                リスト List から項目を削除するには remove() を使う。
                バッファから行を削除するには:deleteもしくはdeletebufline()
                を使う。

                method としても使用できる:
                        GetName()->delete()

deletebufline({buf}{first} [, {last}])                deletebufline()
                {first} から {last} (を含む) までの行をバッファ {buf} から削除
                する。{last} が省略されている場合、{first} 行だけを削除する。
                成功時には 0 が返され、失敗時には 1 が返される。

                この関数は、ロードされたバッファに対してのみ機能する。必要であ
                れば、最初に bufload() を呼び出すこと。

                {buf} の使い方は前述の bufname() を参照。

                {first} および {last} は getline() と同様に扱われる。Note:
                line() の使用はカレントバッファを参照する。バッファ {buf} 内
                の最後の行を参照するには "$" を使用する。

                method としても使用できる:
                        GetBuffer()->deletebufline(1)

                                                        did_filetype()
did_filetype()  autocommandが実行されFileTypeイベントが一度でも起こっていれば、
                TRUEが返る。スクリプトのFileTypeイベントが、複数回呼び出され
                るのを回避するのに使える。 FileType
                :setf FALLBACK が使用されている場合は FALSE を返す。
                他のファイルへ移動すると、このカウンタはリセットされる。よって
                実際は、カレントバッファに対してFileTypeイベントが発生したかど
                うかを判定する。他のバッファを開く自動コマンドの中でこの関数を
                使って 'filetype' を設定し、構文ファイルを読み込むために使え
                る。

diff_filler({lnum})                                     diff_filler()
                {lnum}行目より上にある削除行の数を返す。削除行とは、差分モード
                で他方のウィンドウにテキストが挿入されていることを表す行のこと
                である。削除行は表示はされているが、実際にはバッファに存在しな
                い。
                {lnum}getline()と同様に扱われる。つまり "." はカレント行と
                なり、"'m" はマークmを表す。
                カレントウィンドウが差分モードでないときは0を返す。

                method としても使用できる:
                        GetLnum()->diff_filler()

diff_hlID({lnum}{col})                                diff_hlID()
                差分モードで{lnum}{col}桁(バイト単位)の位置のハイライトIDを
                返す。カレント行に変更がないときは0を返す。
                {lnum}getline()と同様に扱われる。つまり "." はカレント行と
                なり、"'m" はマークmを表す。
                先頭の桁の{col}は1となり、最初の行の{lnum}は1となる。
                ハイライトIDはsynIDattr()を使って構文情報を得るために使える。

                method としても使用できる:
                        GetLnum()->diff_hlID(col)


digraph_get({chars})                                    digraph_get() E1214
                {chars} のダイグラフを返す。これは正確に2文字の文字列である必
                要がある。もし {chars} が2文字ちょうどでない、もしくは {chars}
                のダイグラフがないなら、エラーとなり空文字列を返す。

                必要であれば文字はUnicodeから 'encoding' に変換される。変換が
                利用可能である必要があり、失敗することがある。

                digraph_getlist() も参照。

                例:
                " 組み込みのダイグラフの取得
                :echo digraph_get('00')         " '∞' が返る

                " ユーザー定義のダイグラフの取得
                :call digraph_set('aa', 'あ')
                :echo digraph_get('aa')         " 'あ' が返る

                method としても使用できる:
                        GetChars()->digraph_get()

                この関数は +digraphs 機能付きでコンパイルされたときのみ動作
                する。機能が無効の場合、この関数はエラーメッセージを表示する。


digraph_getlist([{listall}])                            digraph_getlist()
                ダイグラフのリストを返す。引数 {listall} が真で与えられたとき、
                デフォルトのダイグラフを含む全ダイグラフを返す。それ以外はユー
                ザー定義のダイグラフのみを返す。

                必要であれば文字はUnicodeから 'encoding' に変換される。変換が
                利用可能である必要があり、失敗することがある。

                digraph_get() も参照。

                例:
                " ユーザー定義のダイグラフの取得
                :echo digraph_getlist()

                " デフォルトを含む全ダイグラフの取得
                :echo digraph_getlist(1)

                method としても使用できる:
                        GetNumber()->digraph_getlist()

                この関数は +digraphs 機能付きでコンパイルされたときのみ動作
                する。機能が無効の場合、この関数はエラーメッセージを表示する。


digraph_set({chars}{digraph})                         digraph_set()
                ダイグラフ {chars} をリストに追加する。{chars} は2文字の文字列
                の必要がある。{digraph} はUTF-8でエンコードされた1文字の文字
                列。 E1215
                合成文字は無視されないことに注意。この関数は :digraphs と同
                様だがスペース始まりのダイグラフを登録するのに便利である。

                この関数はダイグラフ digraph は登録されたなら v:true を返す。
                もし失敗したなら、エラーメッセージとともに v:false を返す。

                一度に複数のダイグラフを登録したいなら、digraph_setlist() が
                使える。

                例:
                        call digraph_set('  ', 'あ')

                method としても使用できる:
                        GetString()->digraph_set('あ')

                この関数は +digraphs 機能付きでコンパイルされたときのみ動作
                する。機能が無効の場合、この関数はエラーメッセージを表示する。


digraph_setlist({digraphlist})                          digraph_setlist()
                digraph_set() と同じだが複数のダイグラフを一度に追加できる。
                {digraphlist} はリストのリストで、各リストは digraph_set()
                と同じ {chars} と {digraph} の2つの文字列を持つ。 E1216
                例:
                    call digraph_setlist([['aa', 'あ'], ['ii', 'い']])

                これは以下と似ている:
                    for [chars, digraph] in [['aa', 'あ'], ['ii', 'い']]
                          call digraph_set(chars, digraph)
                    endfor
                しかし、この関数は最初のエラーでリターンし、それ以降のダイグラ
                フは追加されない点が異なる。

                method としても使用できる:
                    GetList()->digraph_setlist()

                この関数は +digraphs 機能付きでコンパイルされたときのみ動作
                する。機能が無効の場合、この関数はエラーメッセージを表示する。


echoraw({string})                                       echoraw()
                {string}を表示不可能な文字を含み、そのまま出力する。これは端末
                コードを出力するために使える。例えば、modifyOtherKeysを無効に
                するためには:
                        call echoraw(&t_TE)
                さらに再度有効にするためには:
                        call echoraw(&t_TI)
                この方法でターミナルを壊すことができるため、気を付けて取り扱う
                こと。

empty({expr})                                           empty()
                {expr}が空なら1を、そうでなければ0を返す。
                - リストListまたは辞書Dictionaryは要素を1個も持たないとき
                  空とみなされる。
                - 文字列 String はその長さが0のとき空とみなされる。
                - 数値と浮動小数点数は値が0のとき空とみなされる。
                - v:falsev:nonev:null は空であり、v:true は空では
                  ない。
                - ジョブ Job は開始に失敗したときは空である。
                - チャネル Channel は閉じられていると空である。
                - Blob はその長さが0のときは空である。

                長いリストに対しては長さを0と比較するよりこちらの方がずっと高
                速である。

                method としても使用できる:
                        mylist->empty()

environ()                                               environ()
                すべての環境変数を辞書として返す。このように環境変数が存在する
                かどうかを確認できる:
                        :echo has_key(environ(), 'HOME')
                Note 変数名はキャメルケース(CamelCase)でも構わない。大文字と小
                文字を区別しないためにこれを使用すること:
                        :echo index(keys(environ()), 'HOME', 0, 1) != -1

escape({string}{chars})                               escape()
                {string}内に現れる{chars}の文字をバックスラッシュでエスケープ
                する。例:
                        :echo escape('c:\program files\vim', ' \')
                結果:
                        c:\\program\ files\\vim
                shellescape() および fnameescape() も参照。

                method としても使用できる:
                        GetText()->escape(' \')

                                                        eval()
eval({string})  {string}を評価し、値を返す。string()の戻り値を元の値に戻すの
                に非常に便利である。数値、浮動小数点数、文字列、Blob およびそ
                れらの複合に対して動作する。実際に存在する関数への Funcref
                に対しても動作する。

                method としても使用できる:
                        argv->join()->eval()

eventhandler()                                          eventhandler()
                イベントハンドラの中では1を返す。つまり、ユーザーの文字入力を
                待っている間に、ファイルをドラッグ&ドロップするなど割り込みさ
                れたことを表す。このときは対話的なコマンドは使えない。イベント
                ハンドラの中でないときは0を返す。

executable({expr})                                      executable()
                {expr}という名前の実行可能ファイルが存在するかどうか判定する。
                {expr}は引数を何もつけないプログラム名でなければならない。
                executable()は$PATHと通常のプログラム検索ディレクトリを参照す
                る。                                    PATHEXT
                MS-Windowsでは ".exe"、".bat" などの拡張子は含めても含めなくて
                もよい。省略された場合は$PATHEXTの拡張子を検索する。よって
                "foo.exe" が存在しなければ "foo.exe.bat" が見つかることもあり
                うる。$PATHEXTが存在しなければ ".com;.exe;.bat;.cmd" が使われ
                る。$PATHEXTにドットだけを含めると拡張子なしの名前を検索するこ
                とができる。'shell' がUnixシェルのように思われるときは、{expr}
                の後に拡張子をつけない名前も検索される。
                MS-Windowsではファイルが存在するかどうかだけを判定し、それが
                ディレクトリでないことや、それが本当に実行可能であるかどうかは
                判定されない。
                MS-WindowsではVimと同じディレクトリにある実行ファイルは必ず発
                見できる。Vimがこのディレクトリを$PATHに加えるためである。
                win32-PATH
                戻り値は数値:
                        1       存在する
                        0       存在しない
                        -1      このシステム上では実装されていない
                exepath() は、実行ファイルの絶対パスを取得するのに使用するこ
                とができる。

                method としても使用できる:
                        GetCommand()->executable()

execute({command} [, {silent}])                                 execute()
                単一あるいは複数のExコマンドを実行して、出力を文字列として返
                す。
                {command} は文字列かリストを使える。リストの場合はそれらの行は
                一行ずつ実行される。
                以下と同等である:
                        redir => var
                        {command}
                        redir END

                オプションの {silent} の引数は以下の値を取ることができる:
                        ""              :silent を使わない
                        "silent"        :silent を使う
                        "silent!"       :silent!を使う
                デフォルトは "silent" である。Note "silent!" は redir とは異
                なり、エラーメッセージは削除されることに注意すること。もし外部
                コマンドを使って画面がおかしくなる様であれば、代わりに
                system()を使うことができる。
                                                        E930
                {command} の中のどこかで:redirを使うことができない。

                行のリストを得るために、出力にsplit()を使うことができる:
                        execute('args')->split("\n")

                現在のウィンドウとは別のウィンドウでコマンドを実行するには
                win_execute() を使用すること。

                再帰的に使用されると、再帰呼び出しの出力は、上位呼び出しの出力
                に含まれない。

                method としても使用できる:
                        GetCommand()->execute()

exepath({expr})                                         exepath()
                {expr} が実行ファイルで、それが絶対パス、相対パス、または
                $PATH の中に存在する場合は、そのフルパスを返す。
                Note{expr} が "./" で開始している場合はカレントディレクトリ
                が使われる。Vim のパスを得る場合に問題になるかもしれない:
                        echo exepath(v:progpath)
                {expr} が $PATH の中に見つからないか、それが実行ファイルではな
                かった場合は空文字列が返る。

                method としても使用できる:
                        GetCommand()->exepath()

                                                        exists()
exists({expr})  結果は数値で、変数{expr}が存在すればTRUEとなり、そうでなけれ
                ば0となる。

                Note: コンパイルされる :def 関数は実行時に評価が完了する。
                exists_compiled() を使うことでコンパイル時に式が評価される。

                ある機能がサポートされているか判定するにはhas()を使う。
                ファイルが存在するかを判定するにはfilereadable()を使う。

                引数{expr}は文字列で次のうちいずれかである。
                        varname         内部変数(internal-variables)
                        dict.key        curly-braces-namesDictionaryの要
                        list[i]         素、Listの要素、import要素などに対し
                        import.Func     ても動作する。
                                        コンパイルされる :def 関数内のローカ
                                        ル変数には動作しない。
                                        また関数参照が使用できるため、Vim9
                                        script の関数でも動作する。
                                        インデックスの評価で無効な式であるとエ
                                        ラーメッセージが出る可能性があることに
                                        注意。例:
                                           :let l = [1, 2, 3]
                                           :echo exists("l[5]")
                                           0
                                           :echo exists("l[xx]")
                                           E121: Undefined variable: xx
                                           0
                        &option-name    Vimオプション(存在するかだけを判定し、
                                        本当に動作するかは判定しない)
                        +option-name    動作するVimオプション
                        $ENVNAME        環境変数(空文字列と比較することでも判
                                        定できる)
                        *funcname       組み込み関数(functions参照)かユーザー
                                        が定義した関数(user-functions参照)の
                                        内、実装済みのもの。また Funcref であ
                                        る変数に対しても動作する。
                        ?funcname       実装されているかもしれない組み込み関数。
                                        "funcname" が有効かチェックするのに利
                                        用できる。
                        :cmdname        exコマンド: 組み込みコマンド、ユーザー
                                        定義コマンド、コマンド修飾子:command
                                        戻り値:
                                        1  コマンド名の先頭に一致
                                        2  コマンド名に完全一致
                                        3  複数のユーザー定義コマンドに一致
                                        コマンドが定義されているかどうかを判定
                                        するには、必ず戻り値が2であるかを確認
                                        すること。
                        :2match         :2matchのコマンド。
                        :3match         :3matchのコマンド。
                        #event          このイベントに対する自動コマンド定義
                        #event#pattern  このイベントとパターンに対する自動コマ
                                        ンド定義(パターンは文字そのままに解釈
                                        され、自動コマンドのパターンと1文字ず
                                        つ比較される)
                        #group          自動コマンドグループが存在するか
                        #group#event    このグループとイベントに対して自動コマ
                                        ンドが定義されているか
                        #group#event#pattern
                                        このグループ、イベント、パターンに対す
                                        る自動コマンド定義
                        ##event         このイベントに対する自動コマンドがサ
                                        ポートされているか

                例:
                        exists("&shortname")
                        exists("$HOSTNAME")
                        exists("*strftime")
                        exists("*s:MyFunc")     " 旧来のスクリプトのみ
                        exists("*MyFunc")
                        exists("bufcount")
                        exists(":Make")
                        exists("#CursorHold")
                        exists("#BufReadPre#*.gz")
                        exists("#filetypeindent")
                        exists("#filetypeindent#FileType")
                        exists("#filetypeindent#FileType#*")
                        exists("##ColorScheme")
                シンボルである&/$/*と名前の間には、空白文字があってはならな
                い。
                ある少数の場合では無視されるが、名前の後に余計な文字があっては
                ならない。将来はもっと厳格になる可能性があるので、現在許される
                からといって頼ってはならない。
                正しい例:
                        exists(":make")
                正しくない例:
                        exists(":make install")

                Note 引数は変数そのものではなく、文字列でなければならない。例
                えば、次は動作しない:
                        exists(bufcount)
                これは変数 "bufcount" の存在を判定するのではなく、bufcountの値
                を渡し、それが存在するかどうか判定してしまう。

                method としても使用できる:
                        Varname()->exists()


exists_compiled({expr})                                 exists_compiled()
                exists() と同様だがコンパイル時に評価を行う。関数にあるブロッ
                クが使うとエラーになってしまう場合にスキップするに便利である:
                >
                        if exists_compiled('*ThatFunction')
                           ThatFunction('works')
                        endif
<               exists() を使った場合はコンパイル時に ThatFunction() が未定
                義だとエラーになる。

                {expr} は文字列定数の必要がある。 E1232
                :def 関数の中で使える。 E1233
                引数やローカル変数のチェックには機能しない。


exp({expr})                                                     exp()
                {expr} の指数を返す。
                値は [0, inf] の範囲の浮動小数点数 (Float)。
                {expr} は浮動小数点数 (Float) か数値 (Number) でなければな
                らない。
                例:
                        :echo exp(2)
                        7.389056
                        :echo exp(-1)
                        0.367879

                method としても使用できる:
                        Compute()->exp()

                {+float 機能を有効にしてコンパイルしたときのみ有効}


expand({string} [, {nosuf} [, {list}]])                         expand()
                ワイルドカードと{string}内の特殊なキーワードを展開する。
                'wildignorecase' が適用される。

                {list} が指定されその値がTRUEなら、結果はリストで返される。
                そうでない場合は結果は文字列で返される。その場合、複数のマッチ
                があるときはそれらは文字 <NL> で区切られる。[Note: バージョン
                5.0 では空白文字が用いられ、スペースを含むファイル名について問
                題を引き起こしていた]

                展開が失敗した場合、結果は空文字列となる。{string} が
                '%'、'#'、'<' で始まらない限り、存在しないファイル名というの
                は、結果の文字列には含まれない。下記を参照のこと。

                {string} が '%' か '#' か '<' で始まる場合には、展開は
                cmdline-specialのように、変換子を受け付け、それらに関連付け
                られた変換が施される。ここに簡単な概略を示す:

                        %               現在のファイル名
                        #               代替バッファのファイル名
                        #n              n番の代替バッファのファイル名
                        <cfile>         カーソルの下のファイル名
                        <afile>         autocmdのファイル名
                        <abuf>          autocmdのバッファ名
                        <amatch>        autocmdのマッチした名称
                        <cexpr>         カーソル下のC言語の式
                        <sfile>         取り込み(source)中のファイル名、関数名
                        <slnum>         取り込み(source)中の行番号または関数内
                                        の行番号
                        <sflnum>        スクリプトファイルの行番号。関数内でも
                                        同様。
                        <SID>           "<SNR>123_"  ここで "123" は現在のスク
                                        リプトのID <SID>
                        <script>        取り込み(source)中のファイル名、あるい
                                        は現在の関数が定義されたスクリプトファ
                                        イル名
                        <stack>         コールスタック
                        <cword>         カーソル下の単語(word)
                        <cWORD>         カーソル下の単語(WORD)
                        <client>        最後に受け取ったメッセージの{clientid}
                                        server2client()
                変換子:
                        :p              フルパス名を展開
                        :h              ヘッド(ディレクトリ)
                        :t              テイル(ファイル名だけ)
                        :r              拡張子が削除される
                        :e              拡張子だけ

                例:
                        :let &tags = expand("%:p:h") .. "/tags"
                '%' や '#' や '<' で始まる文字列を展開する時には、それに続くテ
                キストは無視されることに注意。従ってこれは正しくない:
                        :let doesntwork = expand("%:h.bak")
                こうすると良い:
                        :let doeswork = expand("%:h") .. ".bak"
                "<cfile>" やそれらを展開する時には、戻り値が完全な展開をされな
                い参照名であることにも注意が必要。もしも "<cfile>" が
                "~/.cshrc" であった場合、"~/" を展開してホームディレクトリにす
                るために、もう一度expand()を呼び出す必要がある:
                        :echo expand(expand("<cfile>"))

                変数と変換子の間には空白文字があってはならない。関数
                fnamemodify()が通常のファイル名の変換には使用可能である。

                カレントバッファや代替バッファの名前が未定義のときに '%' や
                '#' を使うと空文字列になる。"%:p" を名無しのバッファに使用した
                場合、結果はカレントディレクトリに '/' が付加されたものになる。
                'verbose' が設定されていると、'%', '#' および <> の項目を展開
                できない場合、エラーメッセージが表示される。

                '%' や '#' や '<' で始まらない{string}は、コマンドラインのファ
                イル名と同じように展開される。{nosuf}引数にTRUEを指定しない
                限り、'suffixes' と 'wildignore' が使用される。
                存在しないファイルの名前も結果の文字列に含まれる。"**" を使う
                とディレクトリツリーを検索できる。例えば、カレントディレクトリ
                以下にある全ての "README" を見つけるには次のようにする:
                        :echo expand("**/README")

                expand() はシェルの持っている変数や環境変数を展開できる。しか
                し展開のためにシェルを起動するかもしれないので速度が遅くなるこ
                とがある。expr-env-expand 参照。
                展開された変数はファイル名のリストのように扱われる。環境変数を
                展開できないときはそのままになる。よって、
                ":echo expand('$FOOBAR')" の結果は "$FOOBAR" となる。

                存在するファイルを探すにはglob()を参照。外部コマンドの「生
                の」実行結果を扱うにはsystem()を参照。

                method としても使用できる:
                        Getpattern()->expand()

expandcmd({string} [, {options}])                       expandcmd()
                :edit などのExコマンドに対しておこなわれているように、文字列
                {string} の特殊な項目を展開する。これは {string} の中のどこで
                も、expand() のような特殊なキーワードと環境変数を展開する。
                "~user" および "~/path" は冒頭でのみ展開される。

                引数の辞書 {options} は以下の項目をサポートする:
                    errmsg      TRUEに設定された場合、展開中に遭遇したエラーの
                                エラーメッセージを表示する。デフォルトでは、エ
                                ラーメッセージは表示されない。

                展開された文字列を返す。展開中にエラーに遭遇した場合、変更され
                ていない {string} を返す。

                例:
                        :echo expandcmd('make %<.o')
                        make /path/runtime/doc/builtin.o
                        :echo expandcmd('make %<.o', {'errmsg': v:true})

                method としても使用できる:
                        GetCommand()->expandcmd()

extend({expr1}{expr2} [, {expr3}])                    extend()
                {expr1}{expr2}は両方ともリストListであるか、両方とも辞書
                Dictionariesでなければならない。

                両方ともリストであるなら、{expr2}{expr1}に付け加える。
                {expr3}が指定された場合は、{expr1}の第{expr3}番目の要素の前に
                {expr2}の要素を挿入する。{expr3}が0のときは最初の要素の前に挿
                入する。{expr3}がlen({expr1})に等しいときは末尾に{expr2}が付け
                加えられる。
                例:
                        :echo sort(extend(mylist, [7, 5]))
                        :call extend(mylist, [2, 3], 1)
                {expr1} が {expr2} と同じリストである場合、コピーされる要素の
                数はリストの元の長さと同じである。
                例として {expr3} が 1 のとき、最初の要素の N 個の新しいコピー
                が挿入される(ここで N はリストの元の長さ)。
                リストに1個の要素を加えるにはadd()を使う。2つのリストを連結
                して新しいリストを作るには演算子+を使う:
                        :let newlist = [1, 2, 3] + [4, 5]

                両方とも辞書である場合:
                {expr2}の全要素を{expr1}に加える。
                {expr1}{expr2}で共通のキーがある場合は、{expr3}によって動作
                が決まる:
                {expr3} = "keep" の場合: {expr1}の値そのままにする
                {expr3} = "force" の場合: {expr2}の値で上書きする
                {expr3} = "error" の場合: エラーメッセージを表示する    E737
                {expr3}が省略された場合は "force" と同じになる。

                {expr2}が空でないならば{expr1}が変更される。必要ならば最初に
                {expr1}のコピーを作ること。
                {expr2}は変更されない。
                {expr1} がロックされていて、かつ {expr2} が空でない場合は操作
                は失敗する。
                {expr1}を返す。

                method としても使用できる:
                        mylist->extend(otherlist)


extendnew({expr1}{expr2} [, {expr3}])                 extendnew()
                extend() と同様だが、{expr1} へ要素を追加する代わりに、新し
                いリストまたは辞書が作成されて返される。{expr1} は変更されな
                い。要素は引き続き {expr2} で変更できるが、そうしたくないなら
                最初に deepcopy() を利用すること。


feedkeys({string} [, {mode}])                           feedkeys()
                {string}中の各文字を、あたかもマッピングまたはユーザーによって
                タイプされたかのように、処理キューに入れる。

                デフォルトではこれらの文字は先行入力バッファの末尾に付け足され
                る。そのためマッピングを展開している途中であれば、これらの文字
                はマッピングを展開した後に来ることになる。他の文字の前に挿入す
                るには、'i' フラグを使用する。それらはマッピングからの任意の文
                字の前の挿入の次に実行される。

                この関数は、{string}中の文字が処理されるまでは待たない。

                特殊なキーを{string}に含めるにはダブルクォートと "\..." 記法を
                使う(expr-quoteを参照)。例えば、feedkeys("\<CR>")は<Enter>
                キーの押下をシミュレートする。しかしfeedkeys('\<CR>')とすると、
                この文字の通り5文字を挿入する。
                役に立つかもしれない特別なコードは <Ignore> だ。それは何もせず
                に文字の待機を終了する。  <Ignore>

                {mode}は以下の文字フラグを含む文字列:
                'm'     キーをマップ展開する。これが既定である。{mode}が省略さ
                        れたときは、挿入されたキーはマップ展開の対象になる。
                'n'     キーをマップ展開しない。
                't'     キーをタイプされたかのように扱う。そうでない場合は
                        マッピングから展開されたかのように扱われる。これは
                        undoや折り畳みの展開などで違いが現れる。
                'L'     低レベル入力。UnixまたはGUIを使用している場合にのみ機
                        能する。キーは端末から来ているかのように使われる。他の
                        フラグは使用されない。  E980
                        CTRL-C で割り込み時、かつ 't' が含まれていると内部
                        "got_int" フラグが設定される。
                'i'     追加する代わりに文字を挿入する。(上記参照)
                'x'     先行入力が空になるまでコマンドを実行する。
                        これは ":normal!" を使うのと似ている。
                        'x' なしで数回feedkeys()を呼んだ後、'x' ありで1回
                        ({string}が空でも可能) feedkeys()を呼ぶことで先行入力
                        をすべて実行できる。Note Vimが挿入モードを終了したとき
                        は、スクリプト続行前の文字入力待ちによる立ち往生を避け
                        るために、<Esc>が入力されたかのように振る舞う。
                        Note コマンドの実行中に feedkeys() を再帰的に呼び出し
                        た場合、最後の呼び出しですべての先行入力が消費される。
                'c'     実行時のスクリプトのコンテキストを削除し、旧来のスクリ
                        プトの構文が適用され、"s:var" が動作しないようにする。
                        Note 使用しているキーがスクリプトのコンテキストを設定
                        していてもこれは適用される。
                '!'     'x' と一緒に使用すると挿入モードを終了しない。タイマー
                        が少し後で挿入モードを終了するように設定されているとき
                        にテストで使用できる。CursorHoldIのテストに便利である。

                戻り値は常に0。

                method としても使用できる:
                        GetInput()->feedkeys()

                                                        filereadable()
filereadable({file})
                結果は数値で、{file}というファイルが存在し、読み込むことが可能
                ならばTRUEとなる。ファイル{file}が存在しないかディレクトリ
                だった場合には、結果はFALSEとなる。引数{file}は文字列として
                使えればどのような表現でもよい。
                ファイルが読み込み可能でなくてもよい場合にはglob()を使う。
                {file} はそのまま使用されるため、最初にワイルドカードを展開す
                ることを推奨する:
                        echo filereadable('~/.vimrc')
                        0
                        echo filereadable(expand('~/.vimrc'))
                        1

                method としても使用できる:
                        GetName()->filereadable()
                                                        file_readable()
                以前の名前: file_readable().

filewritable({file})                                    filewritable()
                結果は数値で、{file}というファイルが存在し、書き込むことが可能
                ならば1となる。ファイル{file}が存在しないか書き込み不可能であ
                る場合には、結果は0となる。{file}がディレクトリであり、書き込
                み可能な場合、結果は2となる。

                method としても使用できる:
                        GetName()->filewritable()


filter({expr1}{expr2})                                        filter()
                {expr1}はリスト List、文字列 StringBlob、辞書
                Dictionary でなければならない。
                {expr1}の各要素に対して{expr2}を評価し、その結果が0もしくは偽
                ならばリストまたは辞書からその要素を削除する。Blob の各バイ
                トや文字列 String の各文字も同様に行う。

                {expr2}は文字列stringまたは関数参照Funcrefでなければならな
                い。

                {expr2}が文字列の場合、{expr2}の内部ではv:valが現在の要素の
                値を保持している。辞書の場合はv:keyが現在の要素のキーを保持
                しており、リストの場合はv:keyが現在の要素のインデックスを保
                持している。Blob の場合は v:key が現在のバイトのインデック
                スになる。文字列 String の場合は v:key が現在の文字のイン
                デックスになる。
                例:
                        call filter(mylist, 'v:val !~ "OLD"')
                は要素 "OLD" を削除する。
                        call filter(mydict, 'v:key >= 8')
                は8未満のキーを持つ要素を削除する。
                        call filter(var, 0)
                は全要素を削除する。つまりリストまたは辞書をクリアする。

                Note {expr2}は式を表す文字列である。バックスラッシュを二重に
                しなくても済むようにliteral-stringを使うとよいだろう。ただし
                その場合はシングルクォートを二重にしなければならない。

                {expr2}Funcrefの場合は、2つの引数で呼び出される:
                        1. 現在の要素のキーまたはインデックス。
                        2. 現在の要素の値。
                関数は、その要素を保持すべきときはTRUEを返さなければならな
                い。リストの奇数版目の要素を保持する例:
                        func Odd(idx, val)
                          return a:idx % 2 == 1
                        endfunc
                        call filter(mylist, function('Odd'))
                lambda を使えばより短く書ける。Vim9 の構文では:
                        call filter(myList, (idx, val) => idx * val <= 42)
                旧来のスクリプトの構文では:
                        call filter(myList, {idx, val -> idx * val <= 42})
                "val" を使わない場合は省略できる:
                        call filter(myList, {idx -> idx % 2 == 1})

                Vim9 script では結果が true、false、0もしくは1になる。
                それ以外の値では結果が型エラーになる。

                この操作はその場で(in-place)行われる。リストや辞書を変更したく
                ない場合は最初にコピーを作ること:
                        :let l = filter(copy(mylist), 'v:val =~ "KEEP"')

                {expr1}のリスト ListBlob、 または辞書 Dictionary をフ
                ィルターした結果を返す。{expr2}を評価している最中にエラーが発
                生した場合は、{expr1}内のそれ以降の要素の処理は行われない。
                {expr2}が関数参照の場合、関数が "abort" フラグつきで定義されて
                いない限り、関数内のエラーは無視される。

                リストや辞書でのこの操作はその場で(in-place)行われる。変更した
                くない場合は最初にコピーを作ること:
                        :let l = filter(copy(mylist), 'v:val =~ "KEEP"')

                {expr1}のリスト List または辞書 Dictionary をフィルターし
                た結果、もしくは新規の Blob か文字列 String を返す。{expr2}
                を評価している最中にエラーが発生した場合は、{expr1}内のそれ以
                降の要素の処理は行われない。{expr2}が関数参照の場合、関数が
                "abort" フラグつきで定義されていない限り、関数内のエラーは無視
                される。

                method としても使用できる:
                        mylist->filter(expr2)

finddir({name} [, {path} [, {count}]])                          finddir()
                {path}から{name}という名前のディレクトリを探す。ディレクトリを
                上方・下方のどちらにも再帰的に検索できる。{path}の記法について
                はfile-searchingを参照。

                最初に見つかったディレクトリのパスを返す。そのディレクトリがカ
                レントディレクトリの下にある場合は相対パスを返す。そうでなけれ
                ば絶対パスを返す。
                {path}が省略されたとき、または空のときはオプション 'path' の値
                が使われる。

                省略可能な引数{count}が指定されたときは、最初に見つかったディ
                レクトリでなく、{count}番目に見つかったディレクトリを返す。
                {count}が負の場合は、見つかったディレクトリ全てのリストList
                を返す。

                これはexコマンド:findによく似ている。
                {+file_in_path 機能付きでコンパイルされたときのみ利用可能}

                method としても使用できる:
                        GetName()->finddir()

findfile({name} [, {path} [, {count}]])                         findfile()
                finddir()と同様だが、ディレクトリでなくファイルを検索する。
                'suffixesadd' が適用される。
                例:
                        :echo findfile("tags.vim", ".;")
                この例は、カレントファイルがあるディレクトリから上方に
                "tags.vim" を見つけるまで再帰的に検索する。

                method としても使用できる:
                        GetName()->findfile()

flatten({list} [, {maxdepth}])                                  flatten()
                リスト {list} を {maxdepth} の深さまで平坦化する。{maxdepth}
                が無い場合の結果は {maxdepth} が非常に巨大な数であるのように、
                リスト List からネストを除去する。
                {list} は変更が入るので、それを望まないなら flattennew() を
                使うこと。
                Vim9 script では flatten() は使用できないため、常に
                flattennew() を使う必要がある。
                                                                E900
                {maxdepth} はリストのネストをどれだけ深く変更するかを意味する。
                {maxdepth} が0なら {list} は変更されない。
                {maxdepth} は正の数でなければならない。

                エラーがあったときは数値の0を返す。

                例:
                        :echo flatten([1, [2, [3, 4]], 5])
                        [1, 2, 3, 4, 5]
                        :echo flatten([1, [2, [3, 4]], 5], 1)
                        [1, 2, [3, 4], 5]

                method としても使用できる:
                        mylist->flatten()

flattennew({list} [, {maxdepth}])                       flattennew()
                flatten() と同様だが最初に {list} のコピーを作る。


float2nr({expr})                                        float2nr()
                {expr} の小数点以下を切り捨てて Number に変換する。
                {expr} は Float または Number に評価されなければならない。
                {expr} の値が Number の範囲外の場合、結果は 0x7fffffff また
                は -0x7fffffff になる(64ビット数値が有効化されている場合は
                0x7fffffffffffffff または -0x7fffffffffffffff)。
                NaN は -0x80000000 になる(64ビット数値が有効化されている場合は
                -0x8000000000000000)。
                例:
                        echo float2nr(3.95)
                        3 
                        echo float2nr(-23.45)
                        -23 
                        echo float2nr(1.0e100)
                        2147483647  (または 9223372036854775807)
                        echo float2nr(-1.0e150)
                        -2147483647  (または -9223372036854775807)
                        echo float2nr(1.0e-100)
                        0

                method としても使用できる:
                        Compute()->float2nr()

                {+float 機能つきでコンパイルされたときのみ有効}


floor({expr})                                                   floor()
                {expr} 以下の最大の整数を Float で返す(切り捨て)。
                {expr} は Float または Number に評価されなければならな
                い。
                例:
                        echo floor(1.856)
                        1.0 
                        echo floor(-5.456)
                        -6.0 
                        echo floor(4.0)
                        4.0

                method としても使用できる:
                        Compute()->floor()

                {+float 機能つきでコンパイルされたときのみ有効}


fmod({expr1}{expr2})                                  fmod()
                {expr1} / {expr2} の余りを返す (割り算が表現できなくても)。
                {expr2} が非ゼロなら {expr1} - i * {expr2} の結果を返す (i は
                戻り値が {expr1} と同じ符号を持ちその絶対値が {expr2} よりも小
                さくなるような値)。{expr2} がゼロならゼロが返る。戻り値の型は
                浮動小数点数 (Float)。
                {expr1} と {expr2} は浮動小数点数 (Float) か数値 (Number)
                でなければならない。
                例:
                        :echo fmod(12.33, 1.22)
                        0.13
                        :echo fmod(-12.33, 1.22)
                        -0.13

                method としても使用できる:
                        Compute()->fmod(1.22)

                {+float 機能を有効にしてコンパイルしたときのみ有効}


fnameescape({string})                                   fnameescape()
                コマンド引数のファイル名として使うために {string} をエスケープ
                する。'%' や '|' など特別な意味を持つ全ての文字がバックスラッ
                シュでエスケープされる。
                特別な文字とは、ほとんどのシステムにおいて
                " \t\n*?[{`$\\%#'\"|!<" である。ファイル名にバックスラッシュが
                現れるシステムにおいては 'isfname' の値に依存する。
                先頭の '+' と '>' もエスケープされる(:edit と :write の引
                数では特別な意味を持つ)。{string} が "-" である場合もエスケー
                プされる(:cd の引数では意味を持つ)。
                例:
                        :let fname = '+some str%nge|name'
                        :exe "edit " .. fnameescape(fname)
                上記は次と同じ結果になる:
                        edit \+some\ str\%nge\|name

                method としても使用できる:
                        GetName()->fnameescape()

fnamemodify({fname}{mods})                            fnamemodify()
                ファイル名{fname}{mods}にしたがって変更する。{mods}はコマン
                ドラインで使われるのと同様な文字列である。詳細は
                filename-modifiersを参照。
                例:
                        :echo fnamemodify("main.c", ":p:h")
                結果:
                        /home/mool/vim/vim/src/
                {mods} が空なら {fname} を返す。
                Note{fname}の中の環境変数は展開されない。環境変数を展開させ
                るにはexpand()を使うこと。

                method としても使用できる:
                        GetName()->fnamemodify(':p:h')

foldclosed({lnum})                                      foldclosed()
                結果は数値。{lnum}行目が閉じた折り畳みの中にあるなら、その折り
                畳みを構成する最初の行の行番号を返す。{lnum}行目が閉じた折り畳
                みに入っていないなら-1を返す。
                {lnum} は getline() と同様に扱われる。例えば "." は現在の行、
                "'m" は m でマークした行、など。

                method としても使用できる:
                        GetLnum()->foldclosed()

foldclosedend({lnum})                                   foldclosedend()
                結果は数値。{lnum}行目が閉じた折り畳みの中にあるなら、その折り
                畳みを構成する最後の行の行番号を返す。{lnum}行目が閉じた折り畳
                みに入っていないなら-1を返す。
                {lnum} は getline() と同様に扱われる。例えば "." は現在の行、
                "'m" は m でマークした行、など。

                method としても使用できる:
                        GetLnum()->foldclosedend()

foldlevel({lnum})                                       foldlevel()
                カレントバッファの{lnum}行目の折り畳みレベルを表す数値を返す。
                折り畳みがネストしているときは一番下のレベルを返す。{lnum}行目
                に折り畳みがまったくないときは0を返す。折り畳みが開いているか
                閉じているかは関係ない。('foldexpr' の中で)折り畳みを更新して
                いる最中に呼ぶと、まだ折り畳みを更新していなく、折り畳みレベル
                が未知の行に対しては-1を返す。特別な場合として、普通は1行前の
                レベルは取得できる。
                {lnum} は getline() と同様に扱われる。例えば "." は現在の行、
                "'m" は m でマークした行、など。

                method としても使用できる:
                        GetLnum()->foldlevel()

                                                        foldtext()
foldtext()      閉じた折り畳みに表示する文字列を返す。これはオプション
                'foldtext' のデフォルトの関数であり、'foldtext' を評価している
                ときにだけ呼ぶようにすべきである。この関数は変数v:foldstart,
                v:foldendv:folddashesを使用する。
                戻り値の文字列は次のようになる:
                        +-- 45 lines: abcdef
                先導するダッシュ(-)の数は折り畳みレベルによって決まる。"45" は
                その折り畳みに含まれている行数である。"abcdef" はその折り畳み
                の中の最初の空行でない行のテキストである。行頭の空白と、"//"
                や "/*"、'foldmarker' と'commentstring' に設定されている文字列
                は削除される。
                実際に折り畳みテキストを表示するときには、行の残りは
                'fillchars' で設定した折り畳み用の文字で埋められる。
                {+folding機能付きでコンパイルされたときのみ利用可能}

foldtextresult({lnum})                                  foldtextresult()
                {lnum}行目の閉じた折り畳みに表示される文字列を返す。'foldtext'
                を適切なコンテキストの中で評価する。{lnum}行目に閉じた折り畳み
                がないときは空文字列を返す。
                {lnum}getline()のときと同様に扱われる。つまり "." はカレン
                ト行、"'m" はマークmを表す。
                折り畳まれたテキストをHTMLなどにエクスポートするときに有用。
                {+folding機能付きでコンパイルされたときのみ利用可能}


                method としても使用できる:
                        GetLnum()->foldtextresult()

                                                        foreground()
foreground()    Vimのウィンドウを前面に移動する。この関数はクライアントからVim
                サーバーへ送ると便利である。remote_send()
                Win32では自分自身のウィンドウを前面に持ってくることが必ずしも
                許可されていないので、動作しないかもしれない。そのときは代わり
                にremote_foreground()を使うこと。
                {Win32, Motif, GTKいずれかのGUI版とWin32コンソール版でのみ利用
                できる}

fullcommand({name})                                             fullcommand()
                短縮コマンド名から完全なコマンド名を取得する。コマンドの短縮名
                については 20.2 を参照。

                文字列引数 {name} は : から始まっても [range] を含んでよい
                が、それらはスキップされ戻り値には含まない。
                コマンドが存在しないか、曖昧になってしまう場:空文字列を返す
                (ユーザー定義コマンド用)。

                例えば fullcommand('s')、 fullcommand('sub')
                fullcommand(':%substitute') はすべて "substitute" を返す。

                method としても使用できる:
                        GetName()->fullcommand()

                                                funcref()
funcref({name} [, {arglist}] [, {dict}])
                function()と同様である。ただし、返されたFuncrefは、関数を名
                前ではなく参照で検索する。これは関数{name}が後で再定義されると
                きに重要である。

                function()とは違い、{name}はユーザー定義関数として存在してい
                なければならない。autoload関数ではすでにロード済みのときだけ機
                能する(関数名のみを利用する場合にautoload関数を誤ってロードし
                ないようにするには、代わりに function() を使用する)。{name}
                は組込み関数であってはならない。

                method としても使用できる:
                        GetFuncname()->funcref([arg])

                                function() partial E700 E922 E923
function({name} [, {arglist}] [, {dict}])
                関数{name}を参照するFuncrefの変数を返す。{name}はユーザー定義
                関数でも組み込み関数でもよい。

                ここで{name}は関数の参照、もしくは部分適用である。部分適用であ
                るとき、それに格納されている辞書が使用され、{dict}引数が使用で
                きない。例:
                        let FuncWithArg = function(dict.Func, [arg])
                        let Broken = function(dict.Func, [arg], dict)

                Funcrefが利用されるとき、その関数は{name}から見つけられる。こ
                れは後で再定義された場合も同様である。常に同じ関数を見つけるた
                めにはfuncref()を使うこと。

                {arglist}もしくは{dict}が与えられると、関数の部分適用が作られ
                る。すなわち引数のリスト及び/または辞書はFuncrefに格納され、
                そのFuncrefが呼ばれるときに使用される。

                格納された引数は他の引数よりも前に関数に渡される。しかし、メ
                ソッドからの任意の引数の後になる。例えば:
                        func Callback(arg1, arg2, name)
                        ...
                        let Partial = function('Callback', ['one', 'two'])
                        ...
                        call Partial('name')
                関数は次のように呼び出す:
                        call Callback('one', 'two', 'name')

                method の場合:
                        func Callback(one, two, three)
                        ...
                        let Partial = function('Callback', ['two'])
                        ...
                        eval 'one'->Partial('three')
                次のように関数を呼び出す:
                        call Callback('one', 'two', 'three')

                function()はFuncrefにより多くの引数を加えるためにネストして呼
                び出すことができる。余分な引数は、引数のリストに追加される。
                例えば:
                        func Callback(arg1, arg2, name)
                        ...
                        let Func = function('Callback', ['one'])
                        let Func2 = function(Func, ['two'])
                        ...
                        call Func2('name')
                これは次のように関数を呼び出す:
                        call Callback('one', 'two', 'name')

                辞書は "dict" 関数を呼び出すときのみ有用である。この場合、
                {dict}は "self" として渡される。例えば:
                        function Callback() dict
                           echo "called for " .. self.name
                        endfunction
                        ...
                        let context = {"name": "example"}
                        let Func = function('Callback', context)
                        ...
                        call Func()     " will echo: called for example
                余分な引数がない場合、function()は必要ない。以下の二つは同等で
                ある:
                        let Func = function('Callback', context)
                        let Func = context.Callback

                引数のリストと辞書を同時に使用することもできる:
                        function Callback(arg1, count) dict
                        ...
                        let context = {"name": "example"}
                        let Func = function('Callback', ['one'], context)
                        ...
                        call Func(500)
                これは次のように関数を呼び出す:
                        call context.Callback('one', 500)

                method としても使用できる:
                        GetFuncname()->function([arg])

garbagecollect([{atexit}])                              garbagecollect()
                循環参照を持ち、使われていないリストList、辞書
                Dictionaries、チャネルChannels、ジョブJobs をクリーン
                アップする。

                これはメモリ不足に陥ったときや、'updatetime' 経過後ユーザーの
                キー入力を待っているときに自動的に行われるので、この関数を呼ぶ
                必要があることはほとんどない。循環参照を持たない要素は、使われ
                なくなったとき必ず解放される。長時間実行されるスクリプトの中で
                循環参照を持つ非常に大きなリストや辞書を削除したときに有用であ
                る。

                省略可能な引数 {atexit} に 1 を指定すると、Vim を終了するとき
                にもガーベッジコレクションが行われる。これはメモリリークを発見
                するのに役に立つ。

                ガーベッジコレクションはすぐには実行されず、安全な場合のみ実行
                される。これはユーザーが文字を入力するのを待っているときであ
                る。ガーベッジコレクションを強制するには、すぐに
                test_garbagecollect_now()を使用すること。

get({list}{idx} [, {default}])                        get()
                リストList {list}から{idx}番目の要素を取得する。この要素を取
                得できないときは{default}を返す。{default}が省略されたときは0
                を返す。
                method として使用したいなら:
                        mylist->get(idx)
get({blob}{idx} [, {default}])
                Blob {blob}から{idx}番目のバイトを取得する。このバイトを取得
                できないときは{default}を返す。{default}が省略されたときは -1
                を返す。
                method として使用したいなら:
                        myblob->get(idx)
get({dict}{key} [, {default}])
                辞書Dictionary {dict}からキー{key}に関連づけられた値を取得す
                る。この要素を取得できないときは{default}を返す。{default}が省
                略されたときは0を返す。便利な例:
                        let val = get(g:, 'var_name', 'default')
                g:var_nameの値が存在する場合はこれを取得し使用するが、存在しな
                い場合は 'default' を返す。
                method として使用したいなら:
                        mydict->get(key)
get({func}{what})
                Funcref {func} から項目 {what} を取得する。{what}の可能な値は:
                        "name"  関数名
                        "func"  関数
                        "dict"  辞書
                        "args"  引数リスト
                method として使用したいなら:
                        myfunc->get(what)

                                                        getbufinfo()
getbufinfo([{buf}])
getbufinfo([{dict}])
                バッファの情報を辞書のリストとして取得する。

                引数なしの場合、すべてのバッファに関する情報が返される。

                引数が辞書 Dictionary の場合、指定された条件を満たすバッファ
                のみが返される。{dict}には以下のキーを指定できる:
                        buflisted       リストされたバッファのみを含む。
                        bufloaded       ロードされたバッファのみを含む。
                        bufmodified     修正されたバッファのみを含む。

                それ以外の場合、{buf}は情報を返す特定のバッファを指定する。
                {buf}の使用については、上記のbufname()を参照。バッファが見つ
                かった場合、返されるListには1つの項目がある。それ以外の場合、
                結果は空のリストになる。

                返される各List項目は、次のエントリを持つ辞書である:
                        bufnr           バッファ番号。
                        changed         バッファが変更されている場合はTRUE。
                        changedtick     バッファに加えられた変更の数。
                        hidden          バッファが隠されている場合はTRUE。
                        lastused        バッファが最後に使用されたときの
                                        localtime() のような秒単位のタイムス
                                        タンプ。
                                        {+viminfo 機能付きでコンパイルされた
                                        ときのみ有効}
                        listed          バッファがリストされている場合はTRUE。
                        lnum            バッファがカレントウィンドウに表示され
                                        ていたときの現在行の行番号。
                                        過去にバッファがカレントウィンドウに表
                                        示されていた場合にのみ有効である。特定
                                        のウィンドウの最後のカーソル位置の行番
                                        号が必要な場合は line() を使うこと:
                                                :echo line('.', {winid}))

                        linecount       バッファ内の行数 (ロードされているとき
                                        のみ有効)
                        loaded          バッファがロードされている場合はTRUE。
                        name            バッファ内のファイルへのフルパス。
                        signs           バッファに設置された目印のリスト。
                                        各リスト項目は、次のフィールドを含む辞
                                        書である:
                                            id    目印ID
                                            lnum  行番号
                                            name  目印名
                        variables       バッファローカル変数の辞書への参照。
                        windows         バッファを表示するwindow-IDのリスト
                        popups          バッファを表示するpopupwindow-idのリ
                                        スト

                例:
                        for buf in getbufinfo()
                            echo buf.name
                        endfor
                        for buf in getbufinfo({'buflisted':1})
                            if buf.changed
                                ....
                            endif
                        endfor

                バッファローカルオプションを取得するには:
                        getbufvar({bufnr}, '&option_name')

                method としても使用できる:
                        GetBufnr()->getbufinfo()


                                                        getbufline()
getbufline({buf}{lnum} [, {end}])
                バッファ{buf}{lnum}行目から{end}行目まで(両端含む)の行からな
                るリストListを返す。{end}が省略されたときは{lnum}行目だけか
                らなるリストを返す。

                {buf}の指定の仕方についてはbufname()を参照。

                {lnum}{end}では "$" でバッファの最後の行を表すことができる。
                それ以外は数値でなければならない。

                {lnum}が1より小さいときや、バッファの行数より大きいときは空リ
                ストを返す。

                {end}がバッファの行数より大きいときは、バッファの行数が設定さ
                れたものとして扱う。{end}{lnum}行目より前に設定された場合は
                空リストを返す。

                この関数は読み込まれているバッファに対してのみ動作する。既にア
                ンロードされているバッファや存在しないバッファに対しては空リス
                トを返す。

                例:
                        :let lines = getbufline(bufnr("myfile"), 1, "$")

                method としても使用できる:
                        GetBufnr()->getbufline(lnum)

getbufvar({buf}{varname} [, {def}])                           getbufvar()
                バッファ{buf}のオプションの値やバッファローカル変数{varname}
                の値を返す。Note "b:" をつけない変数名を指定すること。
                {varname} が空文字列の場合、全てのバッファローカル変数からなる
                辞書 Dictionary を返す。
                {varname} が "&" に等しいとき、すべてのバッファローカルオプショ
                ンを持つ辞書 Dictionary を返す。
                そうでなく、{varname} が "&" で始まるとき、バッファローカルオ
                プションの値を返す。
                グローバルオプション、バッファローカルオプションのどちらに対し
                ても動作するが、グローバル変数、ウィンドウローカル変数、ウィン
                ドウローカルオプションに対しては動作しない。
                {buf}の指定の仕方についてはbufname()を参照。
                バッファや変数が存在しないときは{def}または空文字列を返し、エ
                ラーメッセージは表示されない。
                例:
                        :let bufmodified = getbufvar(1, "&mod")
                        :echo "todo myvar = " .. getbufvar("todo", "myvar")

                method としても使用できる:
                        GetBufnr()->getbufvar(varname)

getchangelist([{buf}])                                  getchangelist()
                バッファ {buf} の changelist を返す。{buf} の使い方は前述の
                bufname() を参照。バッファ {buf} が存在しない場合、空のリス
                トが返される。

                返されるリストは 2 つのエントリを含む: 変更位置のリストと、リ
                スト内の現在地。変更リスト内のそれぞれの項目は、以下の項目を含
                む辞書になっている:
                        col             列番号
                        coladd          'virtualedit' 用の列のオフセット
                        lnum            行番号
                バッファ {buf} がカレントバッファの場合、現在地はリスト内の位
                置を指す。それ以外のバッファではリストの長さに設定される。

                method としても使用できる:
                        GetBufnr()->getchangelist()

getchar([expr])                                         getchar()
                ユーザーまたは入力ストリームから1文字を取得する。
                [expr] が省略された場合、1文字を取得できるまで待つ。
                [expr] が0の場合、1文字を取得できる時だけ取得する。取得できな
                        い時は0を返す。
                [expr] が1の場合は、1文字を取得できるかを判定するだけである。
                        入力は消費されない。取得できないと判定された時は0を返
                        す。
                常に文字列として取得したい場合は getcharstr() を使用する。

                [expr] が省略されたときや [expr] が0のときは、文字全体または特
                殊キーを返す。それが1文字なら戻り値は数値である。これを文字列
                に戻すにはnr2char()を使う。それ以外の場合にはエンコードして文
                字列にして返す。
                特殊キーとは0x80(10進数で128)で始まるバイト列からなる文字列で
                ある。これは文字列 "\<Key>" と同じ値である(例: "\<Left>")。戻
                り値は文字列であり、修飾キー(shift, control, alt)は含まれない。

                [expr] が0や Esc が入力された場合は、これがエスケープシーケン
                スの始まりであるかどうかをVimが知るために待つ間、短い遅延があ
                るだろう。

                [expr] が1のときは最初のバイトだけを返す。1バイト文字の場合、
                これはその文字そのものを表す数値である。これを文字列に変換する
                にはnr2char()を使う。

                修飾キーを取得するには getcharmod() を使う。

                ユーザーがマウスをクリックしたときはマウスイベントを返す。クリッ
                クした位置はv:mouse_colv:mouse_lnumv:mouse_winid,
                v:mouse_winで得られる。getmousepos() も使える。マウスの移
                動イベントは無視される。
                以下の例は、普通にマウスがクリックされたときと同じようにカーソ
                ルを移動させる。
                        let c = getchar()
                        if c == "\<LeftMouse>" && v:mouse_win > 0
                          exe v:mouse_win .. "wincmd w"
                          exe v:mouse_lnum
                          exe "normal " .. v:mouse_col .. "|"
                        endif

                bracketed pasteを使用しているときは最初の文字のみが返され、ペー
                ストされた残りのテキストは切り捨てられる。
                xterm-bracketed-paste.

                この関数を呼んだときプロンプトは表示されない。文字入力を待って
                いることをなんらかの方法でユーザーがわかるようにしなければなら
                ないだろう。画面は再描画されない、例えばウィンドウのリサイズ。
                ポップアップウィンドウを使っているなら popup-filter を使うと
                よりよく動作する。
                入力された文字に対してマッピングは適用されない。
                キーコードは置換される。つまりユーザーが<Del>を押した場合、
                「生の」文字シーケンスでなく<Del>キーに対応するコードが得られ
                る。
                例:
                        getchar() == "\<Del>"
                        getchar() == "\<S-Left>"
                以下の例は大文字・小文字を区別しないように "f" を再定義する:
                        :nmap f :call FindChar()<CR>
                        :function FindChar()
                        :  let c = nr2char(getchar())
                        :  while col('.') < col('$') - 1
                        :    normal l
                        :    if getline('.')[col('.') - 1] ==? c
                        :      break
                        :    endif
                        :  endwhile
                        :endfunction

                あなたは<CursorHold>のような合成文字も取得するかもしれない。
                多くの場合、あなたはこれを無視して別の文字を取得することにな
                る:
                        :function GetKey()
                        :  let c = getchar()
                        :  while c == "\<CursorHold>"
                        :    let c = getchar()
                        :  endwhile
                        :  return c
                        :endfunction

getcharmod()                                            getcharmod()
                最後にgetchar()などで得た文字に対する修飾キーの状態を表す数値
                を返す。以下の値の和となる:
                        2       shift
                        4       control
                        8       alt (meta)
                        16      meta (ALT と META が区別される場合)
                        32      マウスのダブルクリック
                        64      マウスのトリプルクリック
                        96      マウスのクアドラプルクリック (== 32 + 64)
                        128     command (Macintosh のみ)
                文字自身に含まれていない修飾キーのみ取得できる。つまり、
                Shift-aは修飾キーなしの "A" となる。

                                                        getcharpos()
getcharpos({expr})
                文字列 {expr} の位置を得る。getpos() と同様だが返すリスト内
                の桁番号はバイトインデックスの代わりに文字インデックスになって
                いる。
                getpos() が v:maxcol と等しい非常に大きな桁番号を返す場合、
                getcharpos() は最後の文字の文字インデックスを返す。

                例:
                5行目のテキスト "여보세요" の '세' にカーソルがある状態:
                        getcharpos('.')         returns [0, 5, 3, 0]
                        getpos('.')             returns [0, 5, 7, 0]

                method としても使用できる:
                        GetMark()->getcharpos()

getcharsearch()                                         getcharsearch()
                現在の文字検索の情報である{dict}を返し、この辞書は下記のエント
                リを持つ:

                    char        文字検索(tfTF)で以前に使われた文
                                字。
                                もし文字検索が実行されていないなら空文字列。
                    forward     文字検索の方向。1は前方、0は後方。
                    until       文字検索の種類。1はtもしくはTの文字検索、0は
                                fもしくはFの文字検索。

                下記の設定は前回の文字検索の方向にかかわらず、; で前方検索、
                , で後方検索を常に行えるようになり便利である:
                        :nnoremap <expr> ; getcharsearch().forward ? ';' : ','
                        :nnoremap <expr> , getcharsearch().forward ? ',' : ';'
                setcharsearch()も参照。

getcharstr([expr])                                      getcharstr()
                ユーザーまたは入力ストリームから1文字を文字列として取得する。
                [expr] が省略された場合、1文字を取得できるまで待つ。
                [expr] が0もしくは偽の場合、1文字を取得できる時だけ取得する。
                        取得できない時は空文字列を返す。
                [expr] が1もしくは真の場合は、1文字を取得できるかを判定するだ
                        けである。入力は消費されない。取得できないと判定された
                        時は空文字列を返す。
                結果の数値が文字列に変換される以外は getchar() と同様に動作
                する。

getcmdline()                                            getcmdline()
                現在のコマンドラインの内容を取得する。コマンドラインを編集して
                いるときのみ動作する。つまりc_CTRL-\_eまたはc_CTRL-R_=を使っ
                ているときのみ有効。
                例:
                        :cmap <F7> <C-\>eescape(getcmdline(), ' \')<CR>
                getcmdtype()getcmdpos()setcmdpos()も参照。
                パスワードを入力する時や inputsecret() を使う時は空文字列を
                返す。

getcmdpos()                                             getcmdpos()
                コマンドラインにおけるカーソル位置をバイト単位で取得する。最初
                の桁は1となる。コマンドラインを編集しているときのみ動作する。
                つまりc_CTRL-\_eまたはc_CTRL-R_=または式マッピングを使って
                いるときのみ有効。そうでないときは 0 を返す。
                getcmdtype()setcmdpos()getcmdline()も参照。

getcmdtype()                                            getcmdtype()
                現在のコマンドラインの種類を返す。戻り値は次のいずれか:
                    :   通常のexコマンド
                    >   デバッグモードコマンド debug-mode
                    /   前方検索コマンド
                    ?   後方検索コマンド
                    @   input() コマンド
                    -   :insert または :append コマンド
                    =   i_CTRL-R_=
                コマンドラインを編集しているときのみ動作する。つまり
                c_CTRL-\_eまたはc_CTRL-R_=または式マッピングを使っていると
                きのみ有効。そうでないときは空文字列を返す。
                getcmdpos()setcmdpos()getcmdline()も参照。

getcmdwintype()                                         getcmdwintype()
                現在のコマンドラインウィンドウ (command-line-window) の種類
                を返す。戻り値の意味は getcmdtype() と同じ。コマンドライン
                ウィンドウでなければ空文字列を返す。

getcompletion({pat}{type} [, {filtered}])             getcompletion()
                コマンドライン補完のマッチするリストを返す。文字列 {type}は何
                のためのものかを指定する。次の補完タイプがサポートされている:

                arglist         引数リスト内のファイル名
                augroup         自動コマンドグループ
                buffer          バッファ名
                behave          :behave サブオプション
                breakpoint      :breakadd および :breakdel サブオプション
                color           カラースキーム
                command         Exコマンド
                cmdline         cmdline-completion の結果
                compiler        コンパイラ
                cscope          :cscopeのサブオプション
                diff_buffer     :diffget と :diffput の補完
                dir             ディレクトリ名
                environment     環境変数名
                event           自動コマンドのイベント
                expression      Vim式
                file            ファイルおよびディレクトリ名
                file_in_path    'path'のファイルおよびディレクトリ名
                filetype        ファイルタイプ名 'filetype'
                function        関数名
                help            ヘルプ項目
                highlight       ハイライトグループ
                history         :history サブオプション
                locale          ロケール名 (locale -aの出力)
                mapclear        バッファ引数
                mapping         マッピング名
                menu            メニュー
                messages        :messagesサブオプション
                option          オプション
                packadd         任意パッケージ pack-add 名
                scriptnames     読み込まれているスクリプト名 :scriptnames
                shellcmd        シェルコマンド
                sign            :signサブオプション
                syntax          構文ファイル名 'syntax'
                syntime         :syntimeサブオプション
                tag             タグ
                tag_listfiles   タグ、ファイル名
                user            ユーザー名
                var             ユーザー変数

                {pat}が空文字列の場合、すべてのマッチが返される。それ以外の場
                合、{pat}と一致する項目のみが返される。{pat}での特殊文字の使用
                については、wildcardsを参照。

                オプションの{filtered}フラグが1に設定されている場合、結果をフィ
                ルタリングするために 'wildignore'が適用される。そうでなければ、
                すべての一致が返される。'wildignorecase'オプションは常に適用さ
                れる。

                'wildoptions' オプションが 'fuzzy' を含む場合、補完のマッチ取
                得にファジーマッチが使われる。そうでない場合は正規表現マッチが
                使われる。その結果この関数はコマンドラインで何が起こるかという
                ユーザー設定に従う。これを望まない場合、getcompletion() が呼ば
                れる前に 'wildoptions' を空にしてその後元に戻すようにする。

                {type}が "cmdline" ならば cmdline-completion の結果が返され
                る。
                例えば、":call" コマンドの後で補完できる値は:
                        echo getcompletion('call ', 'cmdline')

                一致するものがなければ、空のリストが返される。{type}の値が無効
                だと、エラーが発生する。

                method としても使用できる:
                        GetPattern()->getcompletion('color')

                                                        getcurpos()
getcurpos([{winid}])
                カーソルの位置を返す。これは getpos('.') に似ているが、追加の
                "curswant" 情報を含む:
                    [0, lnum, col, off, curswant]
                "curswant" は縦方向移動の優先的列番号である。$ コマンド後は
                非常に巨大な値として v:maxcol と同値を返す。
                getcursorcharpos() と getpos() も参照。
                最初の "bufnum" は常に0である。カーソルのバイトでの位置は
                'col' に返される。文字の位置を得るには getcursorcharpos() を
                使う。

                オプションの {winid} 引数はウィンドウを指定する。これはウィン
                ドウ番号か window-ID である。最後のカーソル位置を返すが、こ
                れはバッファがカレントウィンドウでない場合、現在の値は無効にな
                りうる。
                {winid} が無効の場合、値がゼロのリストを返す。

                次のようにしてカーソル位置の保存と復元ができる:
                        let save_cursor = getcurpos()
                        MoveTheCursorAround
                        call setpos('.', save_cursor)
                Note: これはウィンドウ内でのみ機能する。より多くの状態を復元す
                る方法については winrestview() を参照。

                method としても使用できる:
                        GetWinid()->getcurpos()

                                                        getcursorcharpos()
getcursorcharpos([{winid}])
                getcurpos() と同様だが返すリスト内の桁番号はバイトインデック
                スの代わりに文字インデックスになっている。

                Example:
                3行目のテキスト "여보세요" の '보' にカーソルがある状態:
                        getcursorcharpos()      returns [0, 3, 2, 0, 3]
                        getcurpos()             returns [0, 3, 4, 0, 3]

                method としても使用できる:
                        GetWinid()->getcursorcharpos()

                                                        getcwd()
getcwd([{winnr} [, {tabnr}]])
                結果は現在の作業ディレクトリ名の文字列である。'autochdir' は無
                視される。

                {winnr} が指定された場合、現在のタブページ内の {winnr} のウィ
                ンドウのローカルカレントディレクトリを返す。{winnr} にはウィン
                ドウ番号またはwindow-IDが使える。
                {winnr} が -1 の場合、グローバル作業ディレクトリ名を返す。
                haslocaldir() も参照。

                {winnr}{tabnr}が指定された場合、{tabnr}のタブページ内の
                {winnr}のウィンドウのローカルカレントディレクトリを返す。
                {winnr}が -1 の場合、タブページの作業ディレクトリを返す。
                {winnr}が 0 の場合、カレントウィンドウを使用し、{tabnr}が 0 の
                場合はカレントタブページを使用する。
                引数なしの場合は、カレントウィンドウの実際の作業ディレクトリを
                返す。
                もし引数が不正の場合、空文字列を返す。

                例:
                        " カレントウィンドウの作業ディレクトリを取得
                        :echo getcwd()
                        :echo getcwd(0)
                        :echo getcwd(0, 0)
                        " タブページ2のウィンドウ3の作業ディレクトリを取得
                        :echo getcwd(3, 2)
                        " グローバル作業ディレクトリを取得
                        :echo getcwd(-1)
                        " タブページ3の作業ディレクトリを取得
                        :echo getcwd(-1, 3)
                        " カレントタブページの作業ディレクトリを取得
                        :echo getcwd(-1, 0)

                method としても使用できる:
                        GetWinnr()->getcwd()

getenv({name})                                          getenv()
                環境変数{name}の値を返す。引数 {name} は先行する '$' のない文
                字列。例:
                        myHome = getenv('HOME')

                変数が存在しない場合は v:null が返される。これは、空の文字列
                に設定された変数とは異なるが、一部のシステムは空の値を削除され
                る変数として解釈する。expr-env も参照。

                method としても使用できる:
                        GetVarname()->getenv()

getfontname([{name}])                                   getfontname()
                引数なしで使われた場合には現在の通常のフォント名を返す。ハイラ
                イトグループNormalに対して使われるものと同様hl-Normal
                引数が指定された場合には文字列{name}が有効なフォント名であるか
                判定される。有効でないときは空文字列を返す。
                有効なときは実際のフォント名を返す。またはGUIが実際の名前の取
                得をサポートしていないときは{name}をそのまま返す。
                GUIモードで実行しているときのみ動作する。よってvimrcやgvimrcの
                中では使えない。GUIモードが起動した直後にこの関数を呼ぶには、
                自動コマンドGUIEnterを使うこと。
                Note GTKのGUIはどんなフォント名でも受け付けてしまうため、名前
                が有効であるかのチェックは機能しない。

                method としても使用できる:
                        mydict->has_key(key)

getfperm({fname})                                       getfperm()
                {fname}で指定されたファイルの読み込み、書き込み、実行の許可属
                性を示す文字列を返す。
                {fname}が存在しない、またはそのディレクトリが読み込み不可能な
                ときは空文字列を返す。
                戻り値は "rwxrwxrwx" の形で、"rwx" フラグの各グループは順にファ
                イルの所有者、ファイルが所属するグループ、その他のユーザーを表
                す。許可属性が与えられていないフラグは "-" で置き換えられる。
                例:
                        :echo getfperm("/etc/passwd")
                        :echo getfperm(expand("~/.vimrc"))
                この例は、(セキュリティの観点から望ましい設定がされているなら
                ば) "rw-r--r--" あるいは "rw-------" と表示する。

                method としても使用できる:
                        GetFilename()->getfperm()

                許可属性を設定するにはsetfperm()を使用する。

getfsize({fname})                                       getfsize()
                結果は数値で、{fname}で指定されるファイルのサイズをバイト単位
                で返す。
                {fname}がディレクトリのときは0を返す。
                ファイル{fname}が見つからないときは-1を返す。
                {fname} のサイズが Number の範囲外の場合は -2 を返す。

                method としても使用できる:
                        GetFilename()->getfsize()

getftime({fname})                                       getftime()
                結果は{fname}で与えられたファイルの、最終更新時間を示す数値。
                1970年1月1日からの経過時間(秒)で、strftime()に渡すことができる
                だろう。localtime()strftime()も参照。
                ファイル{fname}が見つからなかった場合には-1を返す。

                method としても使用できる:
                        GetFilename()->getftime()

getftype({fname})                                       getftype()
                {fname}で指定されたファイルの種別を示す文字列を返す。
                {fname}が存在しないときは空文字列を返す。
                ファイルの種別とそれらの結果の表を以下に示す:
                        通常ファイル            "file"
                        ディレクトリ            "dir"
                        シンボリックリンク      "link"
                        ブロックデバイス        "bdev"
                        キャラクタデバイス      "cdev"
                        ソケット                "socket"
                        FIFO                    "fifo"
                        それ以外                "other"
                例:
                        getftype("/home")
                Note "link" などの種別はそれをサポートしているシステムでのみ返
                される。"dir" と "file" しか返らないシステムもある。
                MS-Windowsでは、ディレクトリへのシンボリックリンクは "link" の
                代わりに "dir" を返す。

                method としても使用できる:
                        GetFilename()->getftype()

getimstatus()                                           getimstatus()
                結果は数値で、IMEステータスがアクティブの場合は TRUE である。
                'imstatusfunc' を参照。

getjumplist([{winnr} [, {tabnr}]])                      getjumplist()
                指定されたウィンドウの jumplist を返す。

                引数なしの場合、カレントウィンドウを使用する。
                {winnr} のみの場合、現在のタブページのこのウィンドウを使用す
                る。{winnr} には window-ID も使用できる。
                {winnr} と {tabnr} 両方の場合、指定されたタブページのウィンド
                ウを使用する。

                返されるリストは 2 つのエントリを含む: ジャンプ位置のリストと、
                リスト内の最後に使われたジャンプ位置番号。ジャンプ位置リスト内
                のそれぞれの項目は、以下の項目を含む辞書になっている:
                        bufnr           バッファ番号
                        col             列番号
                        coladd          'virtualedit' 用の列のオフセット
                        filename        利用可能ならばファイル名
                        lnum            行番号

                method としても使用できる:
                        GetWinnr()->getjumplist()

                                                        getline()
getline({lnum} [, {end}])
                {end}が指定されない場合は、カレントバッファの{lnum}行目の内容
                を文字列にして返す。例:
                        getline(1)
                {lnum}が数字ではない文字で始まる文字列であった場合、line()
                よってその文字列が数字に変換される。よって、カーソルのある行の
                文字列を取得するには:
                        getline(".")
                {lnum}が1より小さいかバッファの行数よりも大きい数値の場合、空
                文字列が返される。

                {end}が指定された場合は、カレントバッファの{lnum}行目から
                {end}行目までを要素とするリストListを返す。
                {end}{lnum}と同様に解釈される。
                存在しない行は省略され、エラーメッセージは表示されない。
                {end}{lnum}より前になる場合は空リストを返す。
                例:
                        :let start = line('.')
                        :let end = search("^$") - 1
                        :let lines = getline(start, end)

                method としても使用できる:
                        ComputeLnum()->getline()

                他のバッファの行を取得するにはgetbufline()を参照。

getloclist({nr} [, {what}])                             getloclist()
                ウィンドウ{nr}のlocationリストの全項目からなるリスト List を
                返す。{nr} にはウィンドウ番号または window-ID が使える。{nr}
                に0を指定するとカレントウィンドウになる。

                locationリストウィンドウに対して使用すると、そこに表示されてい
                るlocationリストが返る。ウィンドウ番号{nr}が無効な場合は、空リ
                ストが返る。それ以外は getqflist() と同じ。

                オプションの{what}辞書引数が指定されている場合、{what}にリスト
                されている項目を辞書として返す。{what}のサポートされている項目
                については、getqflist()を参照。

                getqflist() の{what}でサポートされている項目に加え、
                getloclist() では次の項目もサポートされている:

                        filewinid       ロケーションリストからファイルを表示す
                                        るのに使われているウィンドウのID。この
                                        フィールドはロケーションリストウィンド
                                        ウから呼び出されたときのみ適用される。
                                        詳細は location-list-file-window を
                                        参照。

                ウィンドウ {nr} にlocationリストがないなら、デフォルト値の辞書
                Dictionary を返す。
                ウィンドウが存在しない場合、空の辞書を返す。

                例 (getqflist-examples もまた参照):
                        :echo getloclist(3, {'all': 0})
                        :echo getloclist(5, {'filewinid': 0})


getmarklist([{buf}])                                    getmarklist()
                {buf} 引数が無い場合は全グローバルマークについての情報のリスト
                を返す。mark

                オプショナル引数 {buf} が指定されている場合、{buf} で指定され
                たバッファのローカルマークの値を返す。{buf} の使い方は
                bufname() を参照。

                戻り値のリストの各要素は以下の内容の辞書Dictになっている:
                    mark   接頭辞 "'" が付いたマークの名前
                    pos    マークの位置のリストList:
                                [bufnum, lnum, col, off]
                       詳細は getpos() を参照。
                    file   ファイル名

                特定のマークについて取得した情報の詳細は getpos() を参照。

                method としても使用できる:
                        GetBufnr()->getmarklist()

getmatches([{win}])                                     getmatches()
                matchadd() と :match によりカレントウィンドウに定義された
                全てのマッチの List を返す。setmatches() は getmatches()
                で保存されたマッチのリストを復元できるので、getmatches() と
                setmatches() は組み合わせて使うと便利である。
                {win} が指定されたなら、カレントウィンドウの代わりに指定された
                番号かウィンドウIDのウィンドウを使う。
                例:
                        :echo getmatches()
                        [{'group': 'MyGroup1', 'pattern': 'TODO',
                        'priority': 10, 'id': 1}, {'group': 'MyGroup2',
                        'pattern': 'FIXME', 'priority': 10, 'id': 2}]
                        :let m = getmatches()
                        :call clearmatches()
                        :echo getmatches()
                        []
                        :call setmatches(m)
                        :echo getmatches()
                        [{'group': 'MyGroup1', 'pattern': 'TODO',
                        'priority': 10, 'id': 1}, {'group': 'MyGroup2',
                        'pattern': 'FIXME', 'priority': 10, 'id': 2}]
                        :unlet m

getmousepos()                                           getmousepos()
                マウスの最新の位置を示す辞書 Dictionary を返す。マウスクリッ
                クのマッピングやポップアップウィンドウのフィルターで使うことが
                できる。辞書の要素は:
                        screenrow       画面行
                        screencol       画面桁
                        winid           クリックされたウィンドウ ID
                        winrow          "winid" 内の行
                        wincol          "winid" 内の桁
                        line            "winid" 内のテキスト行
                        column          "winid" 内のテキスト桁
                全ての数値は 1 ベースである。

                ウィンドウの上ではない場合、例えばコマンドラインの中などでは
                "screenrow" と "screencol" のみが有効で、残りは 0 になる。

                ウィンドウの下のステータスラインやウィンドウの右の垂直セパレー
                ターの場合、"line" と "column" は 0 になる。

                位置がテキストより後の場合、"column" はテキストのバイト長+1に
                なる。

                マウスがポップアップウィンドウの上の場合、そのウィンドウが使わ
                れる。

                getchar() を使ったとき、Vim 変数 v:mouse_lnum,
                v:mouse_col と v:mouse_winid もこれらの値を提供する。

                                                        getpid()
getpid()        Vim のプロセス ID を数値で返す。Unix と MS-Windows では Vim が
                終了するまでこれは一意な数値である。

                                                        getpos()
getpos({expr})  文字列{expr}の位置を返す。{expr}として指定できる値については
                line()を参照。カーソル位置を得るには getcurpos() を参照。
                結果は次の4個の要素を持つリストList:
                    [bufnum, lnum, col, off]
                "bufnum" は、'0 や 'A のようなマークが指定されたときは、その
                マークのバッファ番号となる。それ以外では0となる。
                "lnum" と "col" はバッファ中の位置。桁番号は1から始まる。
                "off" の値は、'virtualedit' がオフのときは常に0で、オンのとき
                はその文字の始点からの画面上の桁のオフセットである。つまり、
                カーソルが<Tab>の中や、その行の最後の文字より後にあるとき意味
                を持つ。
                Note: ビジュアルモードの '< と '> について: ビジュアルモードが
                "V" (行選択モード) のとき、'< の桁番号はゼロ、'> の桁番号は大
                きな値として v:maxcol と同値になる。
                桁番号は行内のバイト位置のリストとして返される。行内の文字での
                位置を取得するなら、getcharpos() を使う。
                桁番号は v:maxcol と同値の非常に大きな値になり得る。これは
                "行末の後" を意味する。
                この関数はマークの位置を保存し、復元するために使われる:
                        let save_a_mark = getpos("'a")
                        ...
                        call setpos("'a", save_a_mark)
                getcharpos() と getcurpos() そして setpos() も参照。

                method としても使用できる:
                        GetMark()->getpos()

getqflist([{what}])                                     getqflist()
                現在の全quickfixエラーのリスト List を返す。リストの各要素は
                辞書で、以下の要素を持つ:
                        bufnr   ファイル名を持つバッファの番号。その名前を取得
                                するにはbufname()を使う。
                        module  モジュール名
                        lnum    バッファ中の行番号(最初の行は1)
                        end_lnum
                                項目が複数行のときの最後の行番号
                        col     桁番号(最初の桁は1)
                        end_col 項目が範囲を持つときの最後の桁番号
                        vcol    TRUE: "col" は画面上の桁
                                FALSE: "col" はバイトインデックス
                        nr      エラー番号
                        pattern エラーの位置を特定するために使う検索パターン
                        text    エラーの説明
                        type    エラーメッセージの種類。'E', '1' など。
                        valid   TRUE: エラーメッセージが認識されている

                エラーリストがまったくないか、空であるときは空リストを返す。
                quickfixリストの項目が存在しないバッファ番号とともに返る場合は
                "bufnr" を0にして返される。(Note: いくつかの関数はバッファ番号
                0を代替バッファとして受け付けるので、明確に0チェックを行う必要
                がある)。

                役に立つ応用例: 複数のファイルから正規表現検索を行い、見つかっ
                たものに対してなんらかの操作をする:
                        :vimgrep /theword/jg *.c
                        :for d in getqflist()
                        :   echo bufname(d.bufnr) ':' d.lnum '=' d.text
                        :endfor

                オプションの{what}辞書引数が指定されている場合は、{what}にリス
                トされている項目のみを辞書として返す。{what}では、以下の文字列
                項目がサポートされている:
                        changedtick     リストに行われた変更の総数を取得
                                        quickfix-changedtick
                        context quickfix-context を取得
                        efm     "lines" をパースするときに使われるエラーフォー
                                マット。存在しない場合はオプション
                                'errorformat' の値が使用される。
                        id      quickfix-IDに対応するquickfixリストの情報を
                                取得。0 は現在のリストもしくは "nr" で指定され
                                たリストのidを意味する
                        idx     'id' または 'nr' で指定されたquickfixリスト内
                                の情報を取得した最後のエントリのインデックス。
                                もし0なら、カレントのエントリが使われる。
                                quickfix-index を参照
                        items   quickfixリストのエントリ
                        lines   'efm' を使用して行のリストをパースし、結果のエ
                                ントリを返す。List 型のみを受け付ける。現在
                                のquickfixリストは変更を受けない。
                                quickfix-parseを参照。
                        nr      このquickfixリストの情報を取得。0 は現在の
                                quickfixリストを意味し、"$" は最後のquickfixリ
                                ストを意味する
                        qfbufnr quickfixウィンドウに表示されているバッファの番
                                号。quickfixバッファが存在しないなら 0 が返る。
                                quickfix-buffer を参照。
                        size    quickfixリスト内のエントリの数
                        title   リストタイトルを取得 quickfix-title
                        winid   quickfixのwindow-IDを取得
                        all     上記のquickfixのすべてのプロパティ
                {what} の文字列以外の項目は無視される。特定の項目の値を取得す
                るには 0 を設定する。
                "nr" が存在しない場合、現在のquickfixリストが使用される。"nr"
                と 0 でない "id" が両方とも指定されていた場合、"id" で指定され
                たリストが使用される。
                quickfixスタック内のリストの数を取得するには、{what} 内で "nr"
                に "$" を設定する。返される辞書内の "nr" の値がquickfixスタッ
                クサイズである。
                "lines" が指定された場合、"efm" を除くその他すべての項目は無視
                される。返される辞書は、エントリのリストからなるエントリ
                "items" を含む。

                返される辞書には、次のエントリが含まれる:
                        changedtick     リストに行われた変更の総数
                                        quickfix-changedtick
                        context quickfixリストコンテキスト。quickfix-context
                                を参照。存在しない場合、"" に設定される。
                        id      quickfixリストID quickfix-ID。存在しない場
                                合、0 に設定される。
                        idx     リスト内のquickfixのエントリのインデックス。
                                存在しない場合、0 に設定される。
                        items   quickfixリストのエントリ。存在しない場合、空リ
                                ストに設定される。
                        nr      quickfixリスト番号。存在しない場合、0 に設定さ
                                れる。
                        qfbufnr quickfixウィンドウに表示されているバッファの番
                                号。存在しない場合、0 に設定される。
                        size    quickfixリスト内のエントリの数。存在しない場
                                合、0 に設定される。
                        title   quickfixリストのタイトルテキスト。存在しない場
                                合、"" に設定される。
                        winid   quickfixのwindow-ID。存在しない場合、0 に設
                                定される。

                例 (getqflist-examplesも参照):
                        :echo getqflist({'all': 1})
                        :echo getqflist({'nr': 2, 'title': 1})
                        :echo getqflist({'lines' : ["F1:10:L10"]})

getreg([{regname} [, 1 [, {list}]]])                    getreg()
                レジスタ{regname}の中身を文字列にして返す。例:
                        :let cliptext = getreg('*')
                レジスタ {regname} がセットされていないときは、結果は空文字列
                となる。
                引数 {regname} は文字列である必要がある。 E1162

                getreg('=')は最後に評価した式レジスタの値を返す。(マップの中で
                使用する)。
                getreg('=', 1)はその式そのものを返す。これを使ってsetreg()
                復元することができる。他のレジスタの場合は、この引数は無視され
                るので、常に指定していても害はない。
                {list} が指定され、その値がTRUEのときは、戻り値はリスト
                (List) になる。リストの各要素はテキスト 1 行である。これはレ
                ジスタの中に値ゼロのバイトが含まれる場合に使用する。{list} を
                指定しなかった場合は NL 文字と値ゼロのバイトは両方とも NL 文字
                として扱われる (NL-used-for-Nul 参照)。
                指定したレジスタがセットされていないときは、空のリストが返され
                る。

                {regname} が "" の場合、無名レジスタ '"' が使われる。
                {regname}を指定しないときはv:registerが使われる。
                Vim9-script では {regname} は1文字でなくてはならない。

                method としても使用できる:
                        GetRegname()->getreg()

getreginfo([{regname}])                                 getreginfo()
                レジスタ {regname} についての詳細情報として次の項目を持つ辞書
                を返す:
                        regcontents     レジスタ {regname} に格納されている行
                                        の、getreg({regname}, 1, 1) と同様の
                                        リスト。
                        regtype         レジスタ {regname} の getregtype()
                                        相当の種別。
                        isunnamed       真偽値フラグ、v:true は現在指している
                                        レジスタが無名レジスタであることを示
                                        す。
                        points_to       無名レジスタであれば、現在指しているレ
                                        ジスタを示す単一文字 (quotequoteを参
                                        照)。
                                        例えば、行を dd で削除後、このフィー
                                        ルドは "1" となりそのレジスタには削除
                                        したテキストが入る。

                引数 {regname} は文字列。{regname} が不正なレジスタ名もしくは
                未設定の場合、空の辞書が返される。{regname} が "" か "@" の場
                合、無名レジスタ '"' が使われる。
                {regname} が未指定の場合、v:register が使われる。
                戻り値の辞書は setreg() に渡すことができる。
                Vim9-script では {regname} は1文字でなくてはならない。

                method としても使用できる:
                        GetRegname()->getreginfo()

getregtype([{regname}])                                 getregtype()
                レジスタ{regname}の種類を表す文字列を返す。
                戻り値は次のいずれかとなる:
                    "v"                 文字単位characterwiseの場合
                    "V"                 行単位linewiseの場合
                    "<CTRL-V>{width}"   矩形blockwise-visualの場合
                    ""                  空、または未知のレジスタの場合
                <CTRL-V>は値0x16の1文字である。
                引数 {regname} は文字列。{regname} が "" の場合、無名レジスタ
                '"' が使われる。{regname}を指定しないときはv:registerが使わ
                れる。
                Vim9-script では {regname} は1文字でなくてはならない。

                method としても使用できる:
                        GetRegname()->getregtype()

gettabinfo([{tabnr}])                                   gettabinfo()
                {tabnr}を指定しないと、すべてのタブページに関する情報がリスト
                List として返される。各リスト項目は辞書 Dictionary である。
                それ以外の場合、{tabnr} はタブページ番号を指定し、それに関する
                情報が返される。タブページが存在しない場合、空のリストが返され
                る。

                各リストアイテムは、次のエントリを持つ辞書 Dictionary である:
                        tabnr           タブページ番号。
                        variables       タブページローカル変数の辞書への参照。
                        windows         タブページのwindow-IDのリスト。

                method としても使用できる:
                        GetTabnr()->gettabinfo()

gettabvar({tabnr}{varname} [, {def}])                         gettabvar()
                タブページ {tabnr} のタブローカル変数 {varname} を取得する。
                t:var
                タブの番号は 1 から始まる。
                引数 {varname} は文字列。{varname} が空のときは全タブローカル
                変数からなる辞書を返す。
                Note: 指定する変数名は "t:" を除いた名前。
                タブや変数が存在しないときは{def}または空文字列を返し、エラー
                メッセージは表示されない。

                method としても使用できる:
                        GetTabnr()->gettabvar(varname)

gettabwinvar({tabnr}{winnr}{varname} [, {def}])             gettabwinvar()
                タブページ{tabnr}内のウィンドウ{winnr}のウィンドウローカル変数
                {varname}の値を取得する。
                引数 {varname} は文字列。{varname}が空のときは全ウィンドウロー
                カル変数からなる辞書を返す。
                {varname}が "&" と等しい場合はすべてのウィンドウローカルオプ
                ションの値を辞書 Dictionary に入れて返す。
                {varname}が文字 "&" で始まるときはウィンドウローカルオプション
                の値を取得する。
                Note {varname}は "w:" をつけずに指定しなければならない。
                タブページ番号は1から始まる。カレントタブページを指定するには
                getwinvar()を指定する。
                {winnr} にはウィンドウ番号またはwindow-IDが使える。
                {winnr}が0のときはカレントウィンドウとなる。
                グローバルオプション、バッファローカルオプション、ウィンドウ
                ローカルオプションに対しても動作するが、グローバル変数やバッ
                ファローカル変数に対しては動作しない。
                ウィンドウやタブや変数が存在しないときは{def}または空文字列を
                返し、エラーメッセージは表示されない。
                例:
                        :let list_is_on = gettabwinvar(1, 2, '&list')
                        :echo "myvar = " .. gettabwinvar(3, 1, 'myvar')

                すべてのウィンドウローカル変数を取得するには:
                        gettabwinvar({tabnr}, {winnr}, '&')

                method としても使用できる:
                        GetTabnr()->gettabwinvar(winnr, varname)

gettagstack([{winnr}])                                  gettagstack()
                結果は辞書で、それはウィンドウ{winnr}のタグスタックである。
                {winnr}にはウィンドウ番号または window-ID を指定できる。
                {winnr}を指定しない時は、カレントウィンドウが使用される。
                ウィンドウ{winnr}が存在しない場合、空の辞書が返される。

                返される辞書には、次のエントリが含まれる:
                        curidx          スタック内の現在のインデックス。スタッ
                                        クの最上部にあるときは、(length + 1)
                                        に設定される。スタックの最下部のイン
                                        デックスは1である。
                        items           スタック内の項目のリスト。各項目は、以
                                        下で説明するエントリを含む辞書である。
                        length          スタック内の項目数

                スタック内の各項目は、次のエントリを持つ辞書である:
                        bufnr           現在のジャンプのバッファ番号
                        from            タグジャンプの前のカーソル位置。返され
                                        るリストの形式は getpos() を参照。
                        matchnr         現在の一致するタグ番号。名前に一致する
                                        複数のタグが見つかった場合に使用され
                                        る。
                        tagname         タグの名前

                タグスタックについての詳細は、tagstack を参照。

                method としても使用できる:
                        GetWinnr()->gettagstack()


gettext({text})                                         gettext()
                可能であれば文字列 {text} を翻訳する。
                これは主に配布する Vim script で使う。
                メッセージの翻訳を生成するときに {text} が xgettext によって抽
                出され、翻訳者が .po ファイルで翻訳済みメッセージを追加でき
                Vim は gettext() が呼ばれた時に翻訳を検索する。
                {text} はダブルクォートの文字列が望しい、なぜなら xgettext は
                シングルクォートの文字列でのエスケープを理解しないため。


getwininfo([{winid}])                                   getwininfo()
                ウィンドウに関する情報を、辞書のリスト List として返す。

                {winid}が与えられた場合、そのIDを持つウィンドウに関する情報が
                リスト List として1項目にして返される。ウィンドウが存在しな
                い場合、結果は空のリストになる。

                {winid}がなければすべてのタブページのすべてのウィンドウに関す
                る情報が返される。

                リストの各項目は次のエントリを持つ辞書 Dictionary である:
                        botline         最下の完全に表示されたバッファ行
                        bufnr           ウィンドウ内のバッファ番号
                        height          ウィンドウの高さ (winbarを除く)
                        loclist         locationリストを表示してる場合は1
                                        {Vimが+quickfix機能付きでコンパイル
                                        されたときのみ有効}
                        quickfix        quickfixまたはlocationリストウィンドウ
                                        の場合は1
                                        {Vimが+quickfix機能付きでコンパイル
                                        されたときのみ有効}
                        terminal        端末ウィンドウの場合は 1
                                        {Vimが+terminal機能付きでコンパイル
                                        されたときのみ有効}
                        tabnr           タブページ番号
                        topline         最上に表示されたバッファ行
                        variables       ウィンドウローカル変数の辞書への参照
                        width           ウィンドウ幅
                        winbar          ウィンドウがツールバーを持っていれば
                                        1、そうでなければ 0
                        wincol          ウィンドウの最も左のスクリーン列、
                                        win_screenpos() の "col"
                        textoff         テキストの前の'foldcolumn',
                                        'signcolumn', 行番号が占める列数
                        winid           window-ID
                        winnr           ウィンドウ番号
                        winrow          ウィンドウの最も上のスクリーン行、
                                        win_screenpos() の "row"

                method としても使用できる:
                        GetWinnr()->getwininfo()

getwinpos([{timeout}])                                  getwinpos()
                結果は、getwinposx() と getwinposy() の結果が組み合わされ
                た 2 つの数字のリスト List:
                        [x-pos, y-pos]
                {timeout} は端末からの応答をどれくらい待つかを、ミリ秒単位で指
                定するのに使われる。省略された場合は 100 ミリ秒が使用される。
                リモート端末にはより長い時間を指定すること。
                10 より小さい値が使用され、かつその時間内に応答を受け取らなかっ
                た場合、利用可能であれば前に報告された位置が返される。これは位
                置をポーリングし、同時に何かを行う場合に使用することができる:
                        while 1
                          let res = getwinpos(1)
                          if res[0] >= 0
                            break
                          endif
                          " Do some work here
                        endwhile


                method としても使用できる:
                        GetTimeout()->getwinpos()

                                                        getwinposx()
getwinposx()    結果はGUIのVimウィンドウの左端の、デスクトップ上でのX座標値(数
                値)。xtermでも機能する (100 ミリ秒のタイムアウトを使用して)。
                情報が存在しない(コンソールの)場合は-1となる。
                この値は :winpos でも使用される。

                                                        getwinposy()
getwinposy()    結果はGUIのVimウィンドウの上端の、デスクトップ上でのY座標値(数
                値)。xtermでも機能する (100 ミリ秒のタイムアウトを使用して)。
                情報が存在しない(コンソールの)場合は-1となる。
                この値は :winpos でも使用される。

getwinvar({winnr}{varname} [, {def}])                         getwinvar()
                カレントタブページに対するgettabwinvar()と同様。
                例:
                        :let list_is_on = getwinvar(2, '&list')
                        :echo "myvar = " .. getwinvar(1, 'myvar')

                method としても使用できる:
                        GetWinnr()->getwinvar(varname)

glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])              glob()
                {expr}内のファイル名のワイルドカードを展開する。特殊文字につい
                てはwildcardsを参照。

                {nosuf} にTRUEを指定しない限り、'suffixes' と 'wildignore'
                が適用される。つまり 'wildignore' のパターンにマッチする名前は
                スキップされ、'suffixes' がマッチの順番に影響を与える。
                'wildignorecase' は常に適用される。

                {list} が指定されその値がTRUEなら、マッチしたすべてのファイ
                ルがリスト List として返される。リストを使うことで、改行を含
                むファイル名があっても結果を正しく受け取ることができる。
                そうでない場合は結果は文字列で返される。その場合、複数のマッチ
                があるときはそれらは文字 <NL> で区切られる。

                展開が失敗した場合、空の文字列またはリストが返される。

                マッチの数を制限するなど、複雑なことをする必要がある場合にも
                readdir() を使用することができる。

                存在しないファイル名は結果に含まれない。シンボリックリンクは、
                それが存在するファイルを指す場合のみ含まれる。
                ただし、{alllinks} 引数が存在し、それがTRUEである場合はすべ
                てのシンボリックリンクが含まれる。

                多くのシステムではバッククォート(「`」という文字のこと)を、外
                部コマンドの実行結果からファイル名を取得するために使用できる。
                例:
                        :let tagfiles = glob("`find . -name tags -print`")
                        :let &tags = substitute(tagfiles, "\n", ",", "g")
                バッククォート内のプログラムの実行結果は、一行に一つずつの項目
                が含まれてなければならない。項目内のスペースは許容される。

                特殊なVimの変数を展開するためにはexpand()を参照。外部コマン
                ドの生の出力を得るためにはsystem()を参照。

                method としても使用できる:
                        GetExpr()->glob()

glob2regpat({string})                                    glob2regpat()
                glob()に使われるファイルパターンを検索パターンに変換する。
                結果はファイル名の文字列とのマッチに使用できる。例えば、
                        if filename =~ glob2regpat('Make*.mak')
                上記は次と同じである:
                        if filename =~ '^Make.*\.mak$'
                {string}が空文字列の場合、結果は "^$" で、空文字列にマッチす
                る。結果はシステムによって異なることに注意すること。MS-Windows
                では、バックスラッシュは通常、パス区切りを意味する。

                method としても使用できる:
                        GetExpr()->glob2regpat()
                                                                globpath()
globpath({path}{expr} [, {nosuf} [, {list} [, {alllinks}]]])
                {path}の中の全ディレクトリで文字列 {expr} に対してglob()を実
                行し、結果を連結する。例:
                        :echo globpath(&rtp, "syntax/c.vim")

                {path}はコンマ区切りのディレクトリのリスト。各ディレクトリを
                {expr}の前に付加し、glob()と同様にそれを展開する。必要に応じて
                パスの区切り文字が挿入される。
                ディレクトリ名の中にコンマを含めるには、バックスラッシュでエス
                ケープすること。Note MS-Windowsではディレクトリ名の末尾にバッ
                クスラッシュがつくことがある。その後に区切りのコンマを書くとエ
                スケープと見なされてしまうので、バックスラッシュは削除すること。
                どれかのディレクトリに対して展開が失敗してもエラーメッセージは
                表示されない。

                {nosuf} にTRUEが指定されない限り、オプション 'wildignore' が
                適用される。つまり、'wildignore' のパターンにマッチする名前は
                スキップされる。

                {list} が指定され、その値がTRUEなら、マッチしたすべてのファ
                イルがリスト List として返る。リストとして受け取る利点は、改
                行文字を含んだファイル名も正しく扱えることである。{list} を指
                定しなかった場合は、戻り値は文字列であり、マッチした複数のファ
                イル名は <NL> 文字で連結されてしまう。例:
                        :echo globpath(&rtp, "syntax/c.vim", 0, 1)

                {alllinks} はglob()の場合と同様に扱われる。

                "**" を使ってディレクトリツリーを再帰的に検索することができる。
                例えば、'runtimepath' とそれ以下のディレクトリから全ての
                "README.txt" を探すには次のようにする:
                        :echo globpath(&rtp, "**/README.txt")
                上向き検索と、"**" の深さの限界はサポートされていない。よって
                オプション 'path' の値をそのまま使うとうまく動かないことが
                ある。

                method としても使用でき、ベースは第2引数として渡される:
                        GetExpr()->globpath(&rtp)

                                                        has()
has({feature} [, {check}])
                {check} がない、もしくは0: 結果は機能{feature}がサポートしてい
                る場合1、されない場合0となる。引数{feature}は文字列で大文字/
                小文字の区別が無視される。下記の feature-list を参照。

                {check} があり、0でない: 結果は数値で、機能{feature}が既知であ
                る場合1、そうでない場合0となる。これは {feature} の誤字のチェッ
                クとデッドコードの検知に便利。古いバージョンの Vim は後で追加
                される機能のことは知らず、現在のバージョンの Vim は放棄された
                機能のことを知らないということに注意。

                exists() と exists_compiled() も参照。

                Note ある機能が無い時に文法エラーとなるコードをスキップするた
                めには、Vim は行の残りをスキップし、後続の endif を見逃すか
                もしれないことに注意。そのためには、endif を独立した行に置く
                :
                        if has('feature')
                          let x = this->breaks->without->the->feature
                        endif
                もし endif を2行目に "| endif" として移動させると見付けられ
                なくなる。

has_key({dict}{key})                                  has_key()
                結果は数値で、辞書Dictionary {dict}がキー{key}の要素を持つな
                ら真、持たないなら偽となる。引数 {key} は文字列。

                method としても使用できる:
                        mydict->has_key(key)

haslocaldir([{winnr} [, {tabnr}]])                      haslocaldir()
                結果は数値である:
                    1   ウィンドウが :lcd によってローカルディレクトリを設定
                        している時
                    2   タブページが :tcd によってローカルディレクトリを設定
                        している時
                    0   その他

                引数が指定されない場合、現在のウィンドウを対象とする。
                {winnr}が指定された場合、現在のタブページ内の{winnr}のウィンド
                ウを対象とする。
                {winnr}{tabnr}が指定された場合、{tabnr}のタブページ内の
                {winnr}のウィンドウを対象とする。
                {winnr} にはウィンドウ番号またはwindow-IDが使える。
                {winnr}が -1 の場合は無視され、タブページのみが使用される。
                もし引数が不正の場合、0 を返す。

                例:
                        if haslocaldir() == 1
                          " ウィンドウローカルディレクトリの場合
                        elseif haslocaldir() == 2
                          " タブページローカルディレクトリの場合
                        else
                          " グローバルディレクトリの場合
                        endif

                        " カレントウィンドウ
                        :echo haslocaldir()
                        :echo haslocaldir(0)
                        :echo haslocaldir(0, 0)
                        " カレントタブページのウィンドウn
                        :echo haslocaldir(n)
                        :echo haslocaldir(n, 0)
                        " タブページmのウィンドウn
                        :echo haslocaldir(n, m)
                        " タブページm
                        :echo haslocaldir(-1, m)

                method としても使用できる:
                        GetWinnr()->haslocaldir()

hasmapto({what} [, {mode} [, {abbr}]])                  hasmapto()
                結果は数値。右辺側(マップした先)の一部分に{what}を含むマッピン
                グが存在し、それが{mode}で指定されたモードのいずれかで定義され
                ているなら真を返す。
                引数 {what} と {mode} は文字列。
                {abbr}が指定されていてTRUEのときはマッピングでなく短縮入力の
                存在を判定する。挿入モードまたはコマンドモードを指定することを
                忘れないように。
                グローバルマップとバッファローカルマップの両方をチェックする。
                マッピングが1個も見つからなかったときは偽を返す。
                {mode}に対しては以下の文字が利用できる:
                        n       ノーマルモード
                        v       ビジュアルモードおよび選択モード
                        x       ビジュアルモード
                        s       選択モード
                        o       オペレータ待機モード (Operator-pending)
                        i       挿入モード
                        l       Language-Argumentモード ("r", "f", "t" など)
                        c       コマンドラインモード
                {mode}が省略されたときは "nvo" となる。

                この関数はVim scriptの中で、ある関数へのマッピングが既に存在す
                るか判定するために有用である。例:
                        :if !hasmapto('\ABCdoit')
                        :   map <Leader>d \ABCdoit
                        :endif
                この例は、"\ABCdoit" へのマッピングが存在しないときだけ
                "\ABCdoit" へのマッピングを作成する。

                method としても使用できる:
                        GetRHS()->hasmapto()

histadd({history}{item})                              histadd()
                文字列{item}を履歴{history}に追加する。履歴{history}は以下のう
                ちどれか一つから選択:                   hist-names
                        "cmd"    or ":"   コマンドライン履歴
                        "search" or "/"   検索パターン履歴
                        "expr"   or "="   タイプされた式の履歴
                        "input"  or "@"   input()の履歴
                        "debug"  or ">"   デバッグコマンドの履歴
                {history} 文字列はフルネームで指定する必要はありません。頭文字
                だけでも構いません。
                {item}が履歴内に既に存在する場合、それが最新の項目の位置へシフ
                トされる。結果は数値:操作が成功した場合真、そうでなければ偽が
                返る。

                例:
                        :call histadd("input", strftime("%Y %b %d"))
                        :let date=input("Enter date: ")
                サンドボックスsandboxの中では利用できない。

                method としても使用でき、ベースは第2引数として渡される:
                        GetHistory()->histadd('search')

histdel({history} [, {item}])                           histdel()
                {history}の内容を削除する。例えば全てのエントリを消すこともで
                きる。{history}の部分に可能な値はhist-namesを参照。

                パラメーター{item}が文字列に評価される場合、これは正規表現と
                して扱われる。その表現にマッチする全てのエントリがhistoryから
                削除される(複数あっても)。
                "\c" をつけない場合、大文字・小文字が一致しなければならない。
                /\c
                {item}が数値に評価される場合、インデックスとして解釈される。イ
                ンデックスについては:history-indexingを参照。関連するエントリ
                {訳注: The respective entry} も、存在すれば削除される。

                結果は削除に成功すれば真、そうでなければ偽が返る。

                例:
                式レジスタの履歴を削除する:
                        :call histdel("expr")

                検索履歴から、"*" で始まるエントリを全て削除する:
                        :call histdel("/", '^\*')

                次の3つは等価である:
                        :call histdel("search", histnr("search"))
                        :call histdel("search", -1)
                        :call histdel("search", '^' .. histget("search", -1) .. '$')

                最後の検索パターンを削除し、一つ前のパターンを "n" コマンド(次
                のマッチへ移動)と 'hlsearch' の為に設定する:
                        :call histdel("search", -1)
                        :let @/ = histget("search", -1)

                method としても使用できる:
                        GetHistory()->histdel()

histget({history} [, {index}])                          histget()
                結果は{history}の第{index}エントリを表わす文字列。{history} の
                部分に可能な値はhist-namesを、{index}については
                :history-indexingを参照。指定されたエントリが存在しない場合
                は空文字列が返される。{index}が省略された場合には、履歴中の最
                新のエントリが戻り値として使用される。

                例:
                2つ前に行われた検索をやり直す:
                        :execute '/' .. histget("search", -2)

                :historyによって出力される{num}番目のエントリを、再度実行す
                るための ":H {num}" というコマンドを定義する。
                        :command -nargs=1 H execute histget("cmd",0+<args>)

                method としても使用できる:
                        GetHistory()->histget()

histnr({history})                                       histnr()
                結果は数値で{history}の現在のエントリ数。{history}の部分に可能
                な値はhist-namesを参照。エラーが起こった場合、-1が返される。

                例:
                        :let inp_index = histnr("expr")

                method としても使用できる:
                        GetHistory()->histnr()

hlexists({name})                                        hlexists()
                結果は数値で、{name}という名のハイライトグループが存在すれば、
                真が返される。これはなんらかの方法でそのグループが既に定義され
                ている時にのみ起こる。これの為に実際に何らかのハイライティング
                アイテムが設定されている必要はなく、単に構文アイテムとしても使
                われるだろう。
                                                        highlight_exists()
                以前の名前: highlight_exists().

                method としても使用できる:
                        GetName()->hlexists()

hlget([{name} [, {resolve}]])                           hlget()
                ハイライトグループの全属性のリストを返す。省略可能な引数 {name}
                を指定したときは、指定したハイライトグループの属性だけのリスト
                を返す。ハイライトグループの {name} が無いときは空のリストを返
                す。

                省略可能な引数 {resolve} が v:true に設定され、ハイライトグルー
                プの {name} が他のグループにリンクしているなら、リンクを再帰的
                に解決して解決したハイライトグループの属性を返す。

                返されるリストの各要素は、以下を含む辞書になる:
                        cleared 真偽値フラグ、ハイライトグループがクリアされて
                                いたら v:true に設定され設定があればそうではな
                                い。highlight-clear を参照
                        cterm   cterm 属性。highlight-cterm を参照。
                        ctermbg cterm の背景色。highlight-ctermbg を参照。
                        ctermfg cterm の前面色。highlight-ctermfg を参照。
                        ctermul cterm の下線色。highlight-ctermul を参照。
                        default 真偽値フラグ、ハイライトグループのリンクがデ
                                フォルトへのリンクだと v:true。
                                highlight-default を参照。
                        font    ハイライトグループのフォント。
                                highlight-font を参照。
                        gui     gui 属性。highlight-gui を参照。
                        guibg   gui の背景色。highlight-guibg を参照。
                        guifg   gui の前面色。highlight-guifg を参照。
                        guisp   gui の特殊色。highlight-guisp を参照。
                        id      ハイライトグループの ID。
                        linksto リンクしているハイライトグループ名。
                                :highlight-link を参照。
                        name    ハイライトグループ名。group-name を参照。
                        start   ターミナルの開始コード。highlight-start を参
                                照。
                        stop    ターミナルの終了コード。highlight-stop を参
                                照。
                        term    term 属性。highlight-term を参照。

                上記の辞書の要素 'term''cterm''gui' の値は以下の省略可能な
                真偽値の要素を持つ辞書: 'bold''standout''underline',
                'undercurl''italic''reverse''inverse''strikethrough'

                例:
                        :echo hlget()
                        :echo hlget('ModeMsg')
                        :echo hlget('Number', v:true)

                method としても使用できる:
                        GetName()->hlget()

hlset({list})                                           hlset()
                ハイライトグループのリストの属性を作成もしくは変更する。{list}
                の各要素はハイライトグループの属性を持つ辞書。この辞書内でサ
                ポートされる要素のリストは hlget() を参照。

                hlget() で説明されている要素に追加して、以下の追加の要素が辞
                書内でサポートされる:

                        force           既存の属性のあるハイライトグループへの
                                        リンクを強制的に作成する真偽値。

                ハイライトグループは 'name' 要素によって識別され、'id' 要素
                (提供されていれば) は無視される。ハイライトグループの指定した
                名前が存在しない場合は、作成される。そうでなければ既存のハイラ
                イトグループの属性を変更する。

                'term''cterm''gui' の項については空の辞書が値として使え、
                一致する属性の値をクリアする。'cleared' 要素に v:true を設定し
                た場合、ハイライトグループのすべての属性をクリアする。

                'linksto' 要素はハイライトグループを他のハイライトグループへリ
                ンクさせることができる、:highlight-link を参照。

                成功で0を返し、失敗で-1を返す。

                例:
                        " Visual ハイライトグループに太字属性を追加する
                        :call hlset([#{name: 'Visual',
                                        \ term: #{reverse: 1 , bold: 1}}])
                        :call hlset([#{name: 'Type', guifg: 'DarkGreen'}])
                        :let l = hlget()
                        :call hlset(l)
                        " Search ハイライトグループをクリアする
                        :call hlset([#{name: 'Search', cleared: v:true}])
                        " ハイライトグループの 'term' 属性をクリアする
                        :call hlset([#{name: 'Title', term: {}}])
                        " DiffAdd にリンクした MyHlg グループを作る
                        :call hlset([#{name: 'MyHlg', linksto: 'DiffAdd'}])
                        " MyHlg グループのリンクを削除する
                        :call hlset([#{name: 'MyHlg', linksto: 'NONE'}])
                        " 属性とリンクをクリアする
                        :call hlset([#{name: 'MyHlg', cleared: v:true,
                                        \ linksto: 'NONE'}])

                 method としても使用できる:
                        GetAttrList()->hlset()

                                                        hlID()
hlID({name})    結果は数値で、{name}という名前のハイライトグループのID番号。そ
                のハイライトグループが存在しない場合は0が返される。
                これはハイライトグループについての情報を獲得するために使用され
                る。例えば "Comment" グループの背景色を取得するにはこのように
                する:
        :echo synIDattr(synIDtrans(hlID("Comment")), "bg")
                                                        highlightID()
                以前の名前: highlightID()

                method としても使用できる:
                        GetName()->hlID()

hostname()                                              hostname()
                結果は文字列で、現在Vimが実行されているマシンの名前。名前が256
                文字を超える場合、超えた部分は切り捨てられる。

iconv({string}{from}{to})                           iconv()
                文字列{string}をエンコーディング{from}からエンコーディング{to}
                に変換した文字列を返す。
                変換が完全に失敗したときは空文字列を返す。一部の文字が変換でき
                なかった場合、その文字は "?" に置き換わる。
                エンコーディング名はライブラリ関数iconv()が受け付けるものなら
                なんでもよい。":!man 3 iconv" を参照。
                ほとんどの変換は、Vimが+iconv機能つきでコンパイルされている
                ときのみ利用可能。+iconvつきでないときもUTF-8からlatin1への
                変換とその逆は行える。
                オプション 'encoding' の値に関係なく、特殊な文字を含むメッセー
                ジを表示するために使える。UTF-8でエンコードされたメッセージを
                表示するには次のようにする:
                        echo iconv(utf8_str, "utf-8", &enc)
                Note Vimは全てのUnicodeエンコーディングに対してUTF-8を使う。
                UCS-2との変換を行おうとしても、自動的にUTF-8との変換に変更され
                る。いずれにせよ、UCS-2はNULバイトを含むため、文字列にUCS-2を
                使うことはできない。

                method としても使用できる:
                        GetText()->iconv('latin1', 'utf-8')

                                                        indent()
indent({lnum})  カレントバッファの{lnum}行目のインデント量を数値で返す。この
                インデント量はスペース単位で数えられ、'tabstop' の値が関係する。
                {lnum}getline()の場合と同様に扱われる。
                {lnum}が無効なときは-1を返す。Vim9 script ではエラーになる。

                method としても使用できる:
                        GetLnum()->indent()

index({object}{expr} [, {start} [, {ic}]])                    index()
                {object}が List の場合は、{expr}に等しい要素の最小のインデッ
                クスを返す。自動的な変換は行われないので、文字列の "4" は数値
                の 4 とは異なると判定される。そして数値の 4 は浮動小数点数の
                4.0 とも異なる。'ignorecase' はここでは適用されず、常に大文字・
                小文字は区別される。

                {object}が Blob の場合は、{expr}に等しいバイト値の最小のイン
                デックスを返す。

                {start}が指定された場合はインデックス{start}から要素の検索を始
                める(負数を指定すると末尾からの相対位置となる)。
                {ic}TRUEが指定された場合、大文字・小文字は区別されない。
                そうでない場合は区別される。
                {object}の中に{expr}が見つからない場合は-1を返す。
                例:
                        :let idx = index(words, "the")
                        :if index(numbers, 123) >= 0

                method としても使用できる:
                        GetObject()->index(what)

input({prompt} [, {text} [, {completion}]])             input()
                結果は文字列で、ユーザーがコマンドラインに入力したものが返され
                る。引数 {prompt} にはプロンプト文字列か空文字列を指定する。空
                文字列の場合はプロンプトなしになる。'\n' を使ってプロンプトに
                改行を含めることができる。
                :echohlによるハイライトの設定がプロンプトに適用される。
                入力はコマンドラインと同様に行え、同じ編集コマンドやキーマップ
                が使用できる。input()に入力された文字列には、他の履歴とは独立
                した履歴が与えられる。
                例:
                        :if input("Coffee or beer? ") == "beer"
                        :  echo "Cheers!"
                        :endif

                省略可能な引数{text}が与えられ、空でないならば、それが入力の初
                期値として、ユーザーが入力したのと同じ様に表示される。例:
                        :let color = input("Color? ", "white")

                省略可能な引数{completion}はこの入力において利用できる補完の種
                類を指定する。この引数がないときは補完は行われない。対応してい
                る補完の種類は、ユーザー定義コマンドにおいて引数 "-complete="
                で指定するものと同じである。詳しくは:command-completionを参
                照。
                例:
                        let fname = input("File: ", "", "file")

                NOTE: この関数はGUIモードしか持たないバージョン(例、Win32 GUI)
                のVimでは、スタートアップファイルの中で使用することはできな
                い。
                NOTE: マッピングの中からinput()を呼ぶと、そのマッピングの残り
                の文字が消費される。マッピングは、その文字が入力されたときと同
                じように処理されるためである。
                これを避けるには、input()の前にinputsave()を呼び、input()の
                後にinputrestore()を呼ぶ。もう1つの対策は、:execute
                :normalを使うなどして、そのマッピングでそれ以上文字を続けな
                いようにすることである。

                マッピングと同時に使う例:
                        :nmap \x :call GetFoo()<CR>:exe "/" .. Foo<CR>
                        :function GetFoo()
                        :  call inputsave()
                        :  let g:Foo = input("enter search pattern: ")
                        :  call inputrestore()
                        :endfunction

                method としても使用できる:
                        GetPrompt()->input()

inputdialog({prompt} [, {text} [, {cancelreturn}]])             inputdialog()
                input()と同様。GUIで動作していて、テキストダイアログがサポー
                トされている場合はダイアログを表示してテキストを入力させる。
                例:
                   :let n = inputdialog("value for shiftwidth", shiftwidth())
                   :if n != ""
                   :  let &sw = n
                   :endif
                ダイアログがキャンセルされたときは{cancelreturn}を返す。
                {cancelreturn}が省略されているときは空文字列を返す。
                <Enter>を押すとOKボタンを押すのと同じ動作になる。<Esc>を押すと
                キャンセルボタンを押すのと同じ動作になる。
                NOTE: コマンドライン補完は対応していない。

                method としても使用できる:
                        GetPrompt()->inputdialog()

inputlist({textlist})                                   inputlist()
                {textlist}は文字列のリストListでなければならない。1行につき
                リストの要素を1個表示し、ユーザーに数字を入力するよう促す。入
                力された数字を返す。
                ユーザーは、もしマウスがコマンドラインで有効なら ('mouse' が
                "a" であるか "c" を含む)、マウスで文字列をクリックすることでも
                選択できる。最初の文字列を選択すると0が返る。最初の文字列より
                上をクリックすると負数が返る。プロンプト自身をクリックすると
                {textlist}の長さ+1 が返る。
                {textlist}の要素数はオプション 'lines' の値より少なくなければ
                ならない。そうでないと動作しない。最初の要素にメッセージを書
                き、各文字列の先頭に番号をつけておくとよい。
                例:
                        let color = inputlist(['Select color:', '1. red',
                                \ '2. green', '3. blue'])

                method としても使用できる:
                        GetChoices()->inputlist()

inputrestore()                                          inputrestore()
                前回のinputsave()で保存しておいた先行入力を復元する。
                inputsave()と同じ回数だけ呼ぶようにしなければならない。しかし
                多く呼びすぎても害はない。復元するものがなければ真を、そうでな
                ければ偽を返す。

inputsave()                                             inputsave()
                先行入力(マッピングにより入力された文字も含む)を保存し、クリア
                することにより、これ以降のプロンプトがユーザーからの入力を得る
                ようにする。プロンプトの後で、対応するinputrestore()を呼び出さ
                ねばならない。複数回呼ぶこともできる。ただしその場合は同じ回数
                だけinputrestore()を呼ばなくてはならない。
                メモリ不足のときは真を、そうでなければ偽を返す。

inputsecret({prompt} [, {text}])                        inputsecret()
                input()とほぼ同じだが、以下の2点が異なる:
                a) ユーザーの入力をアスタリスク("*")の列として表示し、入力内容
                を読めないようにする。
                b) ユーザーの入力が入力履歴historyに残らない。
                ユーザーの入力内容を文字列として返す。
                NOTE: コマンドライン補完には対応していない。

                method としても使用できる:
                        GetPrompt()->inputsecret()

insert({object}{item} [, {idx}])                      insert()
                {object}が List か Blob の場合、それの先頭に{item}を挿入す
                る。

                {idx}が指定されたときはインデックス{idx}の要素の前に{item}を挿
                入する。{idx}が0のときは{idx}を省略した場合と同じ様に最初の要
                素の前に挿入する。{idx}は負数でもよい(list-index参照)。-1を
                指定すると最後の要素の前に挿入する。

                挿入した結果の List か Blob を返す。例:
                        :let mylist = insert([2, 3, 5], 1)
                        :call insert(mylist, 4, -1)
                        :call insert(mylist, 6, len(mylist))
                最後の例はadd()を使うともっと簡単に書ける。
                Note {item}がリストの場合は、1個の要素として追加される。リスト
                を連結するにはextend()を使うこと。

                method としても使用できる:
                        mylist->insert(item)

interrupt()                                             interrupt()
                スクリプトの実行を中断する。これは多かれ少なかれ、ユーザーが
                CTRL-C をタイプしたように動作する。多くのコマンドが実行されず、
                制御がユーザーに戻される。これは、自動コマンドの中など下位から
                実行を中断するのに有用である。例:
                :function s:check_typoname(file)
                :   if fnamemodify(a:file, ':t') == '['
                :       echomsg 'Maybe typo'
                :       call interrupt()
                :   endif
                :endfunction
                :au BufWritePre * call s:check_typoname(expand('<amatch>'))

invert({expr})                                          invert()
                ビット反転。引数は数値に変換される。リスト、辞書、浮動小数点数
                を指定するとエラーになる。例:
                        :let bits = invert(bits)
                method としても使用できる:
                        :let bits = bits->invert()

isabsolutepath({directory})                             isabsolutepath()
                結果は数値で、{path} が絶対パスであれば TRUE となる。
                Unix では、'/' から開始するパスが絶対パスと考えられる。
                MS-Windows では、ドライブのプリフィックスから開始し '\' か '/'
                が続くパスが絶対パスと考えられる。UNC パスは常に絶対パスであ
                る。
                例:
                        echo isabsolutepath('/usr/share/')      " 1
                        echo isabsolutepath('./foobar')         " 0
                        echo isabsolutepath('C:\Windows')       " 1
                        echo isabsolutepath('foobar')           " 0
                        echo isabsolutepath('\\remote\file')    " 1

                method としても使用できる:
                        GetName()->isabsolutepath()


isdirectory({directory})                                isdirectory()
                結果は数値で、{directory}という名前のディレクトリが存在すれば
                TRUEとなる。{directory}が存在しないか、存在したとしても
                ディレクトリではなかった場合には、FALSEが返される。文字列と
                して解釈できるのならば{directory}の表現はどのようなもので
                あってもかまわない。

                method としても使用できる:
                        GetName()->isdirectory()

isinf({expr})                                           isinf()
                {expr}が正の無限大の場合は1、負の無限大の場合は-1を返し、それ
                以外の場合は0を返す。
                        :echo isinf(1.0 / 0.0)
                        1
                        :echo isinf(-1.0 / 0.0)
                        -1

                method としても使用できる:
                        Compute()->isinf()

                {+float 機能を有効にしてコンパイルしたときのみ有効}

islocked({expr})                                        islocked() E786
                結果は数値で、{expr} がロックされている変数の名前ならばTRUE
                を返す。
                文字列の引数 {expr} は変数の名前、リスト List の要素、辞書
                Dictionary の要素のいずれかでなければならない。変数そのもの
                を指定しないように注意。
                例:
                        :let alist = [0, ['a', 'b'], 2, 3]
                        :lockvar 1 alist
                        :echo islocked('alist')         " 1
                        :echo islocked('alist[1]')      " 0

                {expr} が存在しない変数のときは-1を返す。
                {expr} が範囲のある、リストか辞書でインデックスが範囲外か要素
                が存在しないならエラーメッセージが表示される。変数の存在を確認
                するには exists() を使う。
                Vim9 script ではローカル関数変数に対しては動作しない。

                method としても使用できる:
                        GetName()->islocked()

isnan({expr})                                           isnan()
                {expr} が NaN の値を持つ浮動小数点数ならば TRUE を返す。
                        echo isnan(0.0 / 0.0)
                        1

                method としても使用できる:
                        Compute()->isnan()

                {+float 機能を有効にしてコンパイルしたときのみ有効}

items({dict})                                           items()
                {dict}の全要素のキー・値のペアからなるリストを返す。戻り値の各
                要素はリストであり、キーと値の2個の要素を持つ。戻り値のリスト
                の要素の順序は不定である。keys() と values() も参照。
                例:
                        for [key, value] in items(mydict)
                           echo key .. ': ' .. value
                        endfor

                method としても使用できる:
                        mydict->items()

job_ 関数群はここに文書化されている: job-functions-details

join({list} [, {sep}])                                  join()
                リスト{list}の要素を連結し、1個の文字列にして返す。
                {sep}が指定されたときは、要素の間にそれを挿入する。{sep}が指定
                されなかったときは1個のスペースが使われる。
                Note 末尾には{sep}がつかない。末尾にもつけたければ以下のように
                する:
                        let lines = join(mylist, "\n") .. "\n"
                {list}の要素が文字列なら、そのまま使われる。リストと辞書は
                string()を使ったときと同じようにして文字列に変換される。
                この逆を行う関数はsplit()である。

                method としても使用できる:
                        mylist->join()

js_decode({string})                                     js_decode()
                json_decode() に似ているが以下が異なる:
                - オブジェクトのキー名はクォートされてなくてもよい。
                - 文字列はシングルクォートでくくることができる。
                - 配列内の(2つのコンマで区切られた)空アイテムが許可され結果と
                  して v:none のアイテムとなる。

                method としても使用できる:
                        ReadObject()->js_decode()

js_encode({expr})                                       js_encode()
                json_encode() に似ているが以下が異なる:
                - オブジェクトのキー名がクォートされない
                - 配列の中のアイテム v:none はコンマで区切られた空のアイテムに
                  なる。
                例えば Vim オブジェクト:
                        [1,v:none,{"one":1},v:none]
                は以下にエンコードされ:
                        [1,,{one:1},,]
                json_encode() であれば以下にエンコードされる:
                        [1,null,{"one":1},null]
                このエンコードは JavaScript では妥当である。特に配列内でオプ
                ショナルアイテムを扱う場合には JSON より能率的である。

                method としても使用できる:
                        GetObject()->js_encode()

json_decode({string})                           json_decode() E491
                これはJSONフォーマットの文字列を解析し、それと同等のVimの値を
                返す。JSONとVimの値の関係はjson_encode()を参照。
                デコードは寛容である:
                - 配列やオブジェクトの末尾コンマは無視される、例えば
                  "[1, 2, ]" と "[1, 2]" は同じである。
                - 整数のキーはオブジェクト内で受け入れられる。例えば、{1:2} は
                  {"1":2} と同じである。
                - 多くの浮動小数点数を認識する。例えば "1." は "1.0" となり、
                  "001.2" は "1.2" となる。特別な浮動小数点の値、"Infinity",
                  "-Infinity" および "NaN" (大文字は無視される) は受け付けられ
                  る。
                - 整数値の先頭に付く 0 は無視される、例えば "012" は "12" とな
                  り、"-012" は "-12" となる。
                - null、true および false の大文字は無視される、例えば "NULL"
                  は "null" となり、"True" は "true" となる。
                - 文字列中でエスケープされない U+0000 から U+001F の制御文字は
                  受け付けられる、例えば "      " (文字列中のタブ文字) は "\t"
                  となる。
                - 空のJSON式、またはスペースのみで構成されているものは受け入れ
                  られ、v:none になる。
                - 無効な 2 文字のシーケンスエスケープ中のバックスラッシュは無
                  視される、例えば "\a" は "a" と解釈される。
                - JSON 文字列中の正しいサロゲートペアは、通常 "\uD834\uDD1E"
                  のような連続した 12 文字でなければならないが、json_decode()
                  は、"\uD834" や "\uD834\u" のような途切れたサロゲートペアを
                  黙って受け付ける。
                                                                E938
                結果は Vim の有効な型でなければならないため、rfc7159 では有効
                なオブジェクト内の重複キーは、json_decode() では受け付けられな
                い、例えばこれは失敗する: {"a":"b", "a":"c"}

                method としても使用できる:
                        ReadObject()->json_decode()

json_encode({expr})                                     json_encode()
                {expr}をJSONフォーマットの文字列にエンコードし、この文字列を返
                す。
                このエンコード方式の詳細はここに記載されている:
                https://tools.ietf.org/html/rfc7159.html
                Vimの値は以下の通りに変換される: E1161
                   数値 Number        10進数
                   浮動小数点数 Float 浮動小数点数
                   浮動小数点数 nan     "NaN"
                   浮動小数点数 inf     "Infinity"
                   浮動小数点数 -inf    "-Infinity"
                   文字列 String      ダブルクォートで括られた文字列(null可)
                   Funcref            不可、エラー
                   リスト List        配列(null可)
                                        再帰的に使用された場合: []
                   辞書 Dict          オブジェクト(null可)
                                        再帰的に使用された場合: {}
                   Blob               個々のバイト配列
                   v:false              "false"
                   v:true               "true"
                   v:none               "null"
                   v:null               "null"
                NaNとInfinityは値として渡されることに注意すること。これはJSON
                標準には存在しないが、いくつかの実装でそれが可能である。そうで
                ない場合、エラーが発生する。
                非対応の文字を含む文字列の場合、0xfffd を使って文字が置換され
                る。

                method としても使用できる:
                        GetObject()->json_encode()

keys({dict})                                            keys()
                {dict}の全キーからなるリスト List を返す。リストの順序は不定
                である。items() と values() も参照。

                method としても使用できる:
                        mydict->keys()

                                                        *len()* *E701*
len({expr})     結果は数値で、引数{expr}の長さ。{expr}が文字列または数値のとき
                はstrlen()と同じようにバイト単位での長さを返す。
                {expr}がリスト List のときは要素数を返す。
                {expr}が Blob の場合、バイト数を返す。
                {expr}が辞書 Dictionary のときは要素数を返す。
                それ以外のときはエラーとなる。

                method としても使用できる:
                        mylist->len()

                                                *libcall()* *E364* *E368*
libcall({libname}{funcname}{argument})
                ランタイムライブラリ{libname}の関数{funcname}を、単一の引数
                {argument}で呼び出す。
                Vimで使うように特別に作ったライブラリの関数を呼ぶために使われ
                る。引数は1個しか指定できないため、普通のライブラリ関数を呼ぶ
                にはかなり制限がある。
                結果には、呼び出した関数から返された文字列が返される。呼び出し
                た関数がNULLを返した場合には、Vimには空文字列 "" が戻される。
                関数の戻り値が数値である場合にはlibcallnr()を使うこと。
                もしも引数が数値ならば、関数にはint型の引数が1つ渡される。引数
                が文字列の場合には、関数にはヌル終端記号を持つ文字列が引数とし
                て渡される。
                restricted-modeの中で呼ぶと失敗する。

                libcall()によってVimを再コンパイルすることなく 'plug-in' と呼
                ばれる独自の拡張を行うことができるようになる。それは (直接) シ
                ステムの関数を呼ぶ、ということではない。システム関数を呼ぶとお
                そらくVimがクラッシュするだろう。

                Win32では、あなたが書いた関数をDLLに置かなければならず、また通
                常のC呼出し規約を使用しなければならない(WindowsのシステムDLLが
                使うPascalではない)。関数は正確に1つのパラメーター、char型ポイ
                ンタもしくはint型を取らなければならず、戻り値としてchar型ポイ
                ンタかNULLを返さなければならない。返されるchar型ポインタは、関
                数終了後も有効なポインタ(例えばDLL内の静的なデータ)を指さなけ
                ればならない。(malloc等で)割り当てられたメモリを保持していた場
                合、それはリークしてしまう。DLL内のスタティックバッファを用い
                る方法は動くかもしれないが、使用済みDLLがメモリから削除される
                と同時に解放されてしまう。

                警告: もしも関数が有効ではないポインタを返すと、Vimはクラッ
                シュしてしまう。関数が数値を返してしまった場合、Vimはそれをポ
                インタとして扱ってしまうので、やはりクラッシュが起こる。
                Win32のシステムでは、{libname}はDLLのファイル名の拡張子 ".DLL"
                を付けてはならない。通常の(パスの通った)場所にDLLがない場合に
                は、フルパスで指定する必要がある。
                Unixでは、独自のプラグインをコンパイルするときはオブジェクト
                コードを位置独立('PIC')としてコンパイルしなければならない。
                {Win32 といくつかの Unix で、+libcall 機能が有効になっている
                ときのみ利用可能}
                例:
                        :echo libcall("libc.so", "getenv", "HOME")

                method としても使用でき、ベースは第3引数として渡される:
                        GetValue()->libcall("libc.so", "getenv")

                                                        libcallnr()
libcallnr({libname}{funcname}{argument})
                libcall()とほぼ同様だが、文字列でなくintを返す関数に使う。
                {Win32と、+libcall機能が有効になっているUnixでのみ利用可能}
                例:
                        :echo libcallnr("/usr/lib/libc.so", "getpid", "")
                        :call libcallnr("libc.so", "printf", "Hello World!\n")
                        :call libcallnr("libc.so", "sleep", 10)

                method としても使用でき、ベースは第3引数として渡される:
                        GetValue()->libcallnr("libc.so", "printf")


line({expr} [, {winid}])                                line()
                結果は数値で、{expr}で与えられた位置のファイル内での行番号。引
                数 {expr} は文字列。受け付けられる位置指定は次の通り:   E1209
                    .       カーソルの位置
                    $       現在のバッファの最後の行
                    'x      マークxの位置(マークが設定されていない場合、0が返
                            る)
                    w0      カレントウィンドウの最上行 (サイレント Ex モードの
                            ように、画面が更新されない場合は 1)
                    w$      カレントウィンドウの最下行 (行が表示されていない場
                            合は "w0" より 1 小さい)
                    v       ビジュアルモードでは: ビジュアル選択領域の開始位置
                            (カーソルが終了位置)。ビジュアルモード以外ではカー
                            ソル位置を返す。すぐに更新される点が '< と違う。
                Note 他のファイルのマークも使える。その場合、戻り値はそのファ
                イルの行番号となる。
                桁番号を取得するにはcol()を使う。両方を取得するには
                getpos()を使う。
                オプションの {winid} 引数を使用すると、カレントウィンドウの代
                わりにそのウィンドウの値が取得される。
                例:
                        line(".")               カーソルの行番号
                        line(".", winid)        ウィンドウ "winid" で同上
                        line("'t")              マークtの位置の行番号
                        line("'" .. marker)     マークmarkerの位置の行番号

                ファイルを開くときに最後の既知の位置にジャンプするには、
                last-position-jump を参照。

                method としても使用できる:
                        GetValue()->line()

line2byte({lnum})                                       line2byte()
                バッファの先頭から、{lnum}行目までのバイト数を返す。これには現
                在のバッファのオプション 'fileformat' に従った、end-of-line(行
                終端)文字も含まれている。最初の行においては1が返る。バイト数は
                'encoding' に基づく。'fileencoding' は無視される。
                次のようにすることで最終行を含むバイトサイズを獲得することがで
                きる:
                        line2byte(line("$") + 1)
                これはバッファの大きさプラス1になる。もし 'fileencoding' が空
                ならその値はファイルの大きさプラス1に等しい。{lnum} は
                getline() と同様に扱われる。{lnum} が無効であるか、
                +byte_offset 機能がコンパイル時に無効にされている場合、-1が
                返される。
                byte2line()go及び:gotoも参照。

                method としても使用できる:
                        GetLnum()->line2byte()

lispindent({lnum})                                      lispindent()
                'lisp' をオンにしたときと同じlisp用のインデント規則に従った場
                合の{lnum}行目のインデント量を返す。
                インデント量はスペースで数えられ、'tabstop' の値は関係ない。
                {lnum}getline()の場合と同様に扱われる。
                {lnum}が無効な値のときや+lispindent機能なしでコンパイルされ
                ているときは-1を返す。Vim9 script ではエラーになる。

                method としても使用できる:
                        GetLnum()->lispindent()

list2blob({list})                                       list2blob()
                Return a Blob concatenating all the number values in {list}.
                {list} にある数値全てを連結したBlobを返す。
                例:
                        list2blob([1, 2, 3, 4]) returns 0z01020304
                        list2blob([])           returns 0z
                エラーの時は空のBlobを返す。1つ以上の数値が負数や255を越えてい
                るときは E1239 エラーが発生する。

                blob2list() は反対のことをする。

                method としても使用できる:
                        GetList()->list2blob()

list2str({list} [, {utf8}])                             list2str()
                {list}の各数値を文字列に変換し、それらすべてを連結する。例:
                        list2str([32])          returns " "
                        list2str([65, 66, 67])  returns "ABC"
                以下で同様のことが(遅く)おこなえる:
                        join(map(list, {nr, val -> nr2char(val)}), '')
                str2list() は反対のことをする。

                {utf8}が省略されているかゼロの場合、現在の 'encoding'が使用さ
                れる。{utf8}が真の場合は、常にUTF-8文字列を返す。
                UTF-8の合成文字は期待通りに動作する:
                        list2str([97, 769])     returns "á"

                method としても使用できる:
                        GetList()->list2str()

listener_add({callback} [, {buf}])                      listener_add()
                バッファ {buf} に変更が加えられたときに呼び出されるコールバッ
                ク関数を追加する。
                {buf} はバッファ名またはバッファ番号を参照する。許容値について
                は、bufname() を参照。{buf}を省略すると、現在のバッファが使
                用される。
                listener_remove() に渡すことができる一意のIDを返す。

                {callback} は 5 つの引数で呼び出される:
                    bufnr       変更されたバッファ
                    start       最初に変更された行番号
                    end         変更された下の最初の行番号
                    added       追加された行数。行が削除された場合は負値
                    changes     変更についての詳細を含む項目のリスト

                例:
            func Listener(bufnr, start, end, added, changes)
              echo 'lines ' .. a:start .. ' until ' .. a:end .. ' changed'
            endfunc
            call listener_add('Listener', bufnr)

                リストは変更できない。"changes" の各項目は、次のエントリを持つ
                辞書である:
                    lnum        変更の最初の行番号
                    end         変更された行の下の行
                    added       追加された行数。行が削除された場合は負値
                    col         変更の影響を受けた "lnum" の最初の桁。不明な場
                                合、または行全体が影響を受けた場合は 1。これは
                                バイトインデックスである。最初の文字の値は 1
                                である。
                行が挿入されたときの値は次のとおり:
                    lnum        上に新しい行が追加される行番号
                    end         "lnum" と同じ
                    added       挿入された行数
                    col         1
                行が削除されたときの値は次のとおり:
                    lnum        最初に削除された行番号
                    end         削除が行われる前の、最初に削除された行の下の行
                    added       負値。削除された行数
                    col         1
                行が変更されたときの値は次のとおり:
                    lnum        最初の変更行
                    end         最後に変更された行の下の行
                    added       0
                    col         変更した最初の桁または 1

                エントリは変更が行われた順になっているため、最新の変更は最後に
                なる。行番号はコールバックが呼び出されたときに有効だが、後の変
                更はそれらを無効にするかもしれない。したがって、後のためにコ
                ピーを保持しても機能しないかもしれない。

                {callback} は、listener_flush() が呼び出されたとき、または、
                行数を変更するような変更が行われ、変更リストの行番号が無効に
                なったときに、画面が更新される直前に呼び出される。

                {callback} はテキストをロックした状態で呼び出される。
                textlock を参照。バッファを変更する必要がある場合は、後でこ
                れを実行するためのタイマー timer_start() を使用すること。

                バッファが最初にロードされた時には {callback} は呼び出されな
                い。BufReadPost 自動コマンドイベントを使用して、バッファの初
                期テキストを処理する。
                {callback} はバッファがアンロードされたときにも呼び出されない。
                そのためには BufUnload 自動コマンドイベントを使用すること。

                method としても使用でき、ベースは第2引数として渡される:
                        GetBuffer()->listener_add(callback)

listener_flush([{buf}])                                 listener_flush()
                バッファ {buf} のリスナーコールバックを呼び出す。保留中の変更
                がない場合は、コールバックは呼び出されない。

                {buf} はバッファ名またはバッファ番号を表す。許容値については、
                bufname() を参照。{buf} を省略すると、カレントバッファが使用
                される。

                method としても使用できる:
                        GetBuffer()->listener_flush()

listener_remove({id})                                   listener_remove()
                以前に listener_add() で追加されたリスナーを削除する。
                {id} が見つからなかった場合は偽、{id} が削除された場合は真を返
                す。

                method としても使用できる:
                        GetListenerId()->listener_remove()

localtime()                                             localtime()
                現在の時刻、1970年1月1日からの経過秒数を返す。strftime(),
                strptime() と getftime() も参照。


log({expr})                                             log()
                {expr} の自然対数 (底e) を浮動小数点数 (Float) で返す。
                {expr} は (0, inf] の範囲の浮動小数点数 (Float) か数値
                (Number) でなければならない。
                例:
                        :echo log(10)
                        2.302585
                        :echo log(exp(5))
                        5.0

                method としても使用できる:
                        Compute()->log()

                {+float 機能を有効にしてコンパイルしたときのみ有効}


log10({expr})                                           log10()
                浮動小数点数 {expr} の 10 を底とする対数を Float で返す。
                {expr} は Float または Number に評価されなければならな
                い。
                例:
                        :echo log10(1000)
                        3.0
                        :echo log10(0.01)
                        -2.0

                method としても使用できる:
                        Compute()->log10()

                {+float 機能つきでコンパイルされたときのみ有効}

luaeval({expr} [, {expr}])                                      luaeval()
                Lua の式 {expr} を評価し、その結果を Vim のデータ構造に変換し
                たものを返す。2番目の {expr} は、最初の {expr} の中では _A と
                してアクセスできる追加の引数を保持する。
                文字列はそのまま返される。
                ブーリアンオブジェクトは数値に変換される。
                数値は、vim が +float つきでコンパイルされたときは Float
                値に変換され、そうでなければ数値に変換される。
                vim.eval() で取得される辞書とリストはそのまま返される。
                それ以外のオブジェクトは 0 が返され、エラーにはならない。
                詳細は lua-luaeval を参照。
                Note :def 関数にあるローカル変数は {expr} からは見えない。

                method としても使用できる:
                        GetExpr()->luaeval()

                {+lua 機能つきでコンパイルされたときのみ有効}

map({expr1}{expr2})                                   map()
                {expr1} はリスト List、文字列 StringBlobまたは辞書
                Dictionary
                {expr1}がリストList もしくは 辞書Dictionary なら、{expr1}
                の各要素を、{expr2}を評価した結果で置き換える。
                Blob の場合、各バイトを置き換える。
                文字列 String の場合、合成文字を含む各文字を置き換える。
                要素の型を変更したい場合は、mapnew() を使って新しいリストか
                辞書を作る。これは、Vim9 script を使用する場合に必要である。

                {expr2}は文字列Stringまたは関数参照Funcrefでなければならな
                い。

                {expr2}が文字列 String の場合、{expr2}の内部ではv:valが現
                在の要素の値を保持している。辞書の場合はv:keyが現在の要素の
                キーを保持している。リストの場合はv:keyが現在の要素のインデッ
                クスを保持している。Blob の場合は v:key が現在のバイトのイ
                ンデックスを保持している。
                例:
                        :call map(mylist, '"> " .. v:val .. " <"')
                これは "mylist" の各要素の前に "> " をつけ、後に " <" をつける。
                Note {expr2}は式を表す文字列である。バックスラッシュを二重に
                しなくても済むようにliteral-stringを使うとよいだろう。ただし
                その場合はシングルクォートを二重にしなければならない。

                {expr2}Funcrefの場合は、2つの引数で呼び出される:
                        1. 現在の要素のキーまたはインデックス。
                        2. 現在の要素の値。
                関数は、その要素の新しい値を返さなければならない。それぞれの値
                を "key-value" に置き換える例:
                        func KeyValue(key, val)
                          return a:key .. '-' .. a:val
                        endfunc
                        call map(myDict, function('KeyValue'))
                lambda を使えばより短く書ける:
                        call map(myDict, {key, val -> key .. '-' .. val})
                "val" を使わない場合は省略できる:
                        call map(myDict, {key -> 'item: ' .. key})
                "key" を使用しない場合は、短い名前が使用できる:
                        call map(myDict, {_, val -> 'item: ' .. val})

                この操作はリスト List と辞書 Dictionary の場合その場で
                (in-place)行われる。リストや辞書を変更したくない場合は最初にコ
                ピーを作ること:
                        :let tlist = map(copy(mylist), ' v:val .. "\t"')

                {expr1}が式を適用した結果のリストまたは辞書、もしくは新規の
                Blob か文字列を返す。
                {expr2}を評価している最中にエラーが発生した場合は、{expr1}内の
                それ以降の要素の処理は行われない。
                {expr2}が関数参照の場合、関数が "abort" フラグつきで定義されて
                いない限り、関数内のエラーは無視される。

                method としても使用できる:
                        mylist->map(expr2)


maparg({name} [, {mode} [, {abbr} [, {dict}]]])                 maparg()
                {dict}が省略されたかゼロのとき: モード{mode}におけるキーマップ
                {name}のrhsを返す。結果の文字列内の特殊文字は、":map" コマンド
                でリスト表示した時のように変換される。
                {dict} が TRUE の場合は辞書が返される。以下を参照。全マッピン
                グのリストを取得するのは maplist() を参照。

                {name} というキーマップが存在しない場合、空文字列が返される。
                {name} というキーマップが空の場合、"<Nop>" が返される。

                {name}には ":map" コマンドで使用可能な、特殊なキー名が指定でき
                る。

                {mode}には次の文字が使用可能:
                        "n"     ノーマル
                        "v"     ビジュアル (選択含む)
                        "o"     オペレータ待機 (Operator-pending)
                        "i"     挿入
                        "c"     コマンドライン
                        "s"     選択
                        "x"     ビジュアル
                        "l"     langmap language-mapping
                        "t"     端末ジョブ
                        ""      ノーマル、ビジュアル、及びオペレータ待機
                {mode}が省略された場合、"" が使用される。

                {abbr}が指定され、TRUEの場合はマッピングでなく短縮入力を対象
                とする。

                {dict} にTRUEが指定されたときはマッピングのすべての情報を含
                んだ辞書が返る:                         mapping-dict
                  "lhs"         マッピングの {lhs} (入力されたまま)
                  "lhsraw"      マッピングの {lhs} (生のバイト値)
                  "lhsrawalt"   マッピングの {lhs} (生のバイト値の代替形式、
                                "lhsraw" と違う場合のみ存在)
                  "rhs"         マッピングの {rhs} (入力されたまま)
                  "silent"      :map-silent マッピングなら 1。そうでなければ
                                0。
                  "noremap"     マッピングの {rhs} が再マップ可能でないなら 1。
                  "script"      マッピングが <script> でなされていたら 1。
                  "expr"        式マッピング (:map-<expr>) なら 1。
                  "buffer"      バッファローカルマッピング (:map-local) なら
                                1。
                  "mode"        マッピングが定義されているモード。上述のモードに
                                加え、次の文字が使用される:
                                " "     ノーマル、ビジュアル、オペレータ待機
                                "!"     挿入、コマンドラインモード
                                        (mapmode-ic)
                  "sid"         <sid> マッピングで使用されるスクリプトローカル
                                ID (<SID>)。
                  "scriptversion"  スクリプトのバージョン番号。999999 は Vim9
                                   script を表す。
                  "lnum"        "sid" 内の行番号。不明の場合はゼロ。
                  "nowait"      他の長いマッピングを待たない。
                                (:map-<nowait>)。

                この辞書は mapset() でマッピングを復元するのに使える。

                まずカレントバッファにローカルなマッピングを探し、次のグローバ
                ルマッピングを探す。
                この関数を使うと、あるキーに対して既にマップがされているとき、
                その動作を行いつつ、再マップすることができる。概要:
                        exe 'nnoremap <Tab> ==' .. maparg('<Tab>', 'n')

                method としても使用できる:
                        GetKey()->maparg('n')

mapcheck({name} [, {mode} [, {abbr}]])                  mapcheck()
                モード{mode}におけるキーマップ{name}が存在するかチェックする。
                {name}に指定できる特殊文字はmaparg()を参照。
                {abbr}が指定され、TRUEの場合はマッピングでなく短縮入力を対象
                とする。
                マッピングが{name}で始まるとき、またはマッピングが{name}のはじ
                めに等しいときマッチすると見なされる。

                        マッチするか    "a"     "ab"    "abc"
                   mapcheck("a")        yes     yes      yes
                   mapcheck("abc")      yes     yes      yes
                   mapcheck("ax")       yes     no       no
                   mapcheck("b")        no      no       no

                maparg()との違いは、mapcheck()は{name}にマッチするマップを見つ
                けるが、maparg()はぴったり{name}に一致するマッピングのみを見つ
                ける。
                {name}にマッチするキーマップが存在しない時には、空文字列が返さ
                れる。結果が一つならばマップされたRHSが返される。{name} で始ま
                るマッピングが複数見つかった場合には、それらのうちどれか一つの
                RHSが返される。RHS が空の場合は "<Nop>" となる。
                まずカレントバッファにローカルなマッピングを探し、次のグローバ
                ルマッピングを探す。
                この関数はマッピングが曖昧にならないかチェックするために使うこ
                とができる。例:
        :if mapcheck("_vv") == ""
        :   map _vv :set guifont=7x13<CR>
        :endif
                これは、"_vv" というマッピングが "_v" とか "_vvv" といったマッ
                ピングと衝突しないように事前にチェックしている。

                method としても使用できる:
                        GetKey()->mapcheck('n')


maplist([{abbr}])                                       maplist()
                全マッピングの List を返す。各リストの項目は Dict
                で、maparg() で返すものと同じになる。mapping-dict を参照。
                {abbr} が存在し TRUE であれば、マッピングの代わりに短縮入力
                を使う。

                'MultiMatch' が rhs に含まれる全マッピングを表示する例:
                        vim9script
                        echo maplist()->filter(
                                (_, m) => match(m.rhs, 'MultiMatch') >= 0)


mapnew({expr1}{expr2})                                        mapnew()
                map() と同様だが、{expr1} の要素を置き換える代わりに、新しい
                リストまたは辞書が作成されて返される。{expr1} は変更されない。
                要素は引き続き {expr2} で変更できるが、そうしたくないなら最初
                に deepcopy() を利用すること。

mapset({mode}{abbr}{dict})                                  mapset()
                maparg() が返す辞書からマッピングを復元する。
                {mode} と {abbr} は maparg() を呼ぶのと同じ値である必要があ
                る。 E460
                {mode} はマッピングをセットするモードを定義するのに使い、{dict}
                の "mode" エントリは使われない。
                マッピングの保存と復元の例:
                        let save_map = maparg('K', 'n', 0, 1)
                        nnoremap K somethingelse
                        ...
                        call mapset('n', 0, save_map)
                Note いくつかのモードのマップを置き換えようとする場合の注意、
                たとえば :map! とともに実施するとき、違いがある可能性がある
                ので、全部のマッピングを保存する必要がある。


match({expr}{pat} [, {start} [, {count}]])                    match()
                {expr}がリストの場合は、{pat}にマッチする最初の要素のインデッ
                クスを返す。各要素は文字列として扱われる。リストと辞書はechoし
                たときと同じように文字列表現に変換される。

                それ以外の場合は、{expr}は文字列として扱われる。{expr}の中で
                {pat}にマッチするインデックス(バイト単位のオフセット)を表す数
                値を返す。

                最初の文字またはリストの最初の要素にマッチしたときは0を返す。
                マッチがないときは-1を返す。

                サブマッチを取得するには matchlist() を参照。
                例:
                        :echo match("testing", "ing")   " 結果は 4
                        :echo match([1, 'x'], '\a')     " 結果は 1
                {pat}の扱われ方についてはstring-matchを参照。
                                                                strpbrk()
                strpbrk()に相当する関数はVimに存在しない。しかし同じことを次の
                ようにしてできる:
                        :let sepidx = match(line, '[.,;: \t]')
                                                                strcasestr()
                strcasestr()に相当する関数はVimに存在しない。しかし正規表現に
                "\c" をつければ大文字・小文字の違いを無視できる:
                        :let idx = match(haystack, '\cneedle')

                {start}が指定されたときは、文字列のバイトインデックス{start}
                位置、またはリストの{start}の要素から検索を始める。
                その場合も戻り値は最初の文字/要素から数えたインデックスである
                ことに注意。例:
                        :echo match("testing", "ing", 2)
                の結果は "4"。
                        :echo match("testing", "ing", 4)
                の結果は "4"。
                        :echo match("testing", "t", 2)
                の結果は "3"。
                文字列の場合、{start} > 0のときは、その文字列が{start}バイト後
                から始まるかのように扱われる。そのため、"^" は{start}の位置に
                マッチする。ただし{count}が指定されたときは、{start}より前にお
                けるマッチを無視しているかのように振る舞う(これは後方互換性を
                保つのを少々複雑にしている)。
                文字列の場合、{start} < 0のときは{start}に0をセットする。リス
                トの場合は、末尾からインデックスを数えるという意味になる。
                {start}が範囲外の場合(文字列で{start} > strlen({expr})となった
                場合、リストで{start} > len({expr})となった場合)は-1を返す。

                {count}が指定されたときは{count}番目のマッチ位置を返す。文字列
                でマッチが見つかったとき、次のマッチングは1文字先から行われる。
                よって次の例は1を返す:
                        echo match("testing", "..", 0, 2)
                リストの場合は次の要素から検索を続ける。
                Note {count}を指定すると、{start}の扱い方が変わってしまう。
                前の段落を参照。

                受け付ける正規表現についてはpatternを参照。
                オプション 'ignorecase' により、大文字・小文字を区別するかどう
                かを設定できる。'smartcase' は適用されない。マッチングは常に
                'magic' をオン、'cpoptions' を空にした状態で行われる。
                Note マッチの開始が一致することが望しく、パターンで "*" (任意
                の数のマッチ) を使う場合、テキストにある次のマッチ数ではなく、
                0になる傾向があるので注意。

                method としても使用できる:
                        GetText()->match('word')
                        GetList()->match('word')

                                matchadd() E290 E798 E799 E801 E957
matchadd({group}{pattern} [, {priority} [, {id} [, {dict}]]])
                カレントウィンドウで強調表示するパターンを定義する。このパター
                ンのことを「マッチ」と呼ぶ。構文グループ {group}で強調する。戻
                り値は、マッチを識別する ID である。この ID はウィンドウに紐付
                けられている。matchdelete() でこの ID を指定してマッチを削除
                することができる。この ID はウィンドウパターンは大文字小文字を
                区別し、magic (/magic) として解釈される ({pattern} の中で明
                示的に変更しない限り)。オプションの 'magic''smartcase'
                'ignorecase' は使用されない。
                Concealは特別であり、マッチを隠す作用がある。

                省略可能な引数 {priority} はマッチの優先度を指定する。優先度が
                高いマッチは、より低いマッチの強調を上書きする。優先度は整数で
                指定する(負の数も可能)。{priority} が指定されない場合は既定の
                優先度 10 となる。'hlsearch' の優先度はゼロで、したがってゼロ
                より大きい優先度のマッチはすべてそれを上書きする。構文ハイライ
                ト('syntax' を参照)は独立したメカニズムであり、優先度がいくつ
                であろうとマッチは構文ハイライトより優先する。

                {id} は特定のマッチ ID を返すことを要求する。指定された ID が
                すでに使われていたら、エラーメッセージが表示され、そのマッチは
                登録されない。ID は正の整数を指定する(ゼロは除く)。ID 1, 2, 3
                は :match:2match:3match 用に予約されている。{id} が
                指定されないか -1 のときは、matchadd() が自動的に空いている
                ID を取得する。

                省略可能な引数 {dict} はより一層カスタマイズ可能な値を許す。
                現在、これはhl-Concealでハイライトされたマッチをconceal文字で
                表示されるのを明示するために使われる。
                この辞書は下記のメンバを持つことができる:

                        conceal     マッチ(hl-Concealのためだけにハイライトさ
                                    れたマッチ、:syn-ccharを参照)の代わりに
                                    表示する特別な文字
                        window      現在のウィンドウの代わりに、この番号もしく
                                    はウィンドウ ID のウィンドウを使用する

                コマンド :match と異なり、マッチの個数に上限はない。

                例:
                        :highlight MyGroup ctermbg=green guibg=green
                        :let m = matchadd("MyGroup", "TODO")
                このパターンを削除するには:
                        :call matchdelete(m)

                matchadd() と :match で定義したマッチのリストは
                getmatches() で取得できる。全てのマッチを削除するのは
                clearmatches() 一発でできる。

                method としても使用できる:
                        GetGroup()->matchadd('TODO')

                                                        matchaddpos()
matchaddpos({group}{pos} [, {priority} [, {id} [, {dict}]]])
                matchadd() と同じだが、パターンを指定するのではなく、位置の
                リスト {pos} を指定する。このコマンドは正規表現を扱う必要もな
                く、画面更新のためにバッファ行の境界を設定するため、
                matchadd() よりも速い。これは、例えば括弧の対応を強調表示す
                るような、マッチの追加と削除を高速に実行したい状況を想定してい
                る。

                {pos} は位置のリストである。各位置は以下のいずれかである:
                - 数値。指定した行全体が強調表示される。最初の行の行番号は 1
                  である。
                - 数値を 1 つ持ったリスト。例 [23]。指定した行全体が強調表示さ
                  れる。
                - 数値を 2 つ持ったリスト。例 [23, 11]。最初の数値は行番号、2
                  番目の数値は列番号である (最初の列は 1 である。値は col()
                  の戻り値と同じようにバイト単位である)。指定した位置の文字が
                  強調表示される。
                - 数値を 3 つ持ったリスト。例 [23, 11, 3]。数値 2 つの場合と同
                  じだが、3 つ目に強調表示する文字の長さ (バイト単位) を指定す
                  る。

                {pos} で指定できる位置は最大で 8 個である。

                例:
                        :highlight MyGroup ctermbg=green guibg=green
                        :let m = matchaddpos("MyGroup", [[23, 24], 34])
                パターンの削除:
                        :call matchdelete(m)

                matchaddpos() で追加されたマッチは getmatches() で取得でき
                る。

                method としても使用できる:
                        GetGroup()->matchaddpos([23, 11])

matcharg({nr})                                                  matcharg()
                :match:2match:3matchによって設定されているマッチパター
                ンの情報を返す。{nr}が1のときは:matchの情報、2のときは
                :2matchの情報、3のときは:3matchの情報を返す。
                戻り値は次の2個の要素を持つリストである:
                        引数で指定したハイライトグループ名
                        引数で指定した検索パターン
                {nr}が1、2、3のどれでもないときは空リストを返す。
                マッチパターンがセットされていないときは['', '']を返す。
                :match を保存し、復元するのに便利である。
                :match を使った強調は 3 個までに限られている。
                matchadd() にはこの制限はない。

                method としても使用できる:
                        GetMatch()->matcharg()

matchdelete({id}, [, {win}])                   matchdelete() E802 E803
                matchadd() または :match で定義したマッチの中で ID が {id}
                であるものを削除する。成功したときは 0、失敗したときは
                -1 を返す。matchadd() の例を参照。すべてのマッチを削除するの
                は clearmatches() 一発でできる。
                {win} が指定されれば、カレントウィンドウではなく指定されたウィ
                ンドウあるいはウィンドウID を対象にする。

                method としても使用できる:
                        GetMatch()->matchdelete()

matchend({expr}{pat} [, {start} [, {count}]])                 matchend()
                match()と同じだが、返されるのはマッチした部分文字列の終了後の
                インデックスである。例:
                        :echo matchend("testing", "ing")
                結果は "7"。
                                                        strspn() strcspn()
                Vimにはstrspn()やstrcspn()に相当する関数はないが、matchend()を
                使えば同じことができる:
                        :let span = matchend(line, '[a-zA-Z]')
                        :let span = matchend(line, '[^a-zA-Z]')
                ただしマッチがないときには-1を返すところが異なる。

                {start}match()の場合と同じ意味を持つ。
                        :echo matchend("testing", "ing", 2)
                結果は "7"。
                        :echo matchend("testing", "ing", 5)
                結果は "-1"。
                {expr}がリストの場合、戻り値は match() と等しくなる。

                method としても使用できる:
                        GetText()->matchend('word')


matchfuzzy({list}{str} [, {dict}])                    matchfuzzy()
                {list} が文字列のリストの場合、{list} 内のすべての文字列につい