Pikeは、C言語に似た文法を持つ高水準プログラミング言語です。豊富なライブラリとオブジェクト指向プログラミング機能を備えています。また、高速な実行速度が特徴で、Webアプリケーション、ネットワークプログラミング、データベース処理など、幅広い用途で使用されています。
本チュートリアルでは、Pikeの基本的な文法と機能を初心者向けにわかりやすく解説します。Pikeを学ぶことで、プログラミングの基礎を身につけ、実践的な開発に応用できるようになることを目的としています。本チュートリアルを通して、Pikeの魅力や活用方法を理解し、その可能性を広げることができるでしょう。
__TOC__ 
Pikeは、C言語に似た文法を持つ高水準プログラミング言語です。豊富なライブラリとオブジェクト指向プログラミング機能を備えています。また、高速な実行速度が特徴で、Webアプリケーション、ネットワークプログラミング、データベース処理など、幅広い用途で使用されています。
Pikeは、以下のような特徴を持っています。
高水準かつ強力であるため、非常に複雑なことでもPikeでは簡単に実現できます。
オブジェクト指向であり、大規模なプログラムを小さな部品に分割して記述できるため、プログラム全体を一度に記述するよりもはるかに簡単です。
インタプリター型であるため、プログラムをコンパイルしてリンクする必要がなく、実行するときに待つ必要がありません。
最速のスクリプト言語の1つです。
ガベージコレクションがあり、プログラミングが簡単になるだけでなく、メモリリークやその他のメモリ関連のバグのリスクも除去されます。
拡張性に優れており、PikeだけでなくCやC++で書かれたプラグインを作成し、Pikeの残りと統合することができます。
コンパイラ（インタープリタのフロントエンド）に 2-pass を採用しており、グローバルな変数・関数・クラスの前方参照を自動的に解決します。
Pikeは、小さくシンプルなスクリプトを記述するために使用することもでき、さらには非常に大規模なプログラムにも使用できます。
世界中のWebサーバーであるRoxen WebServerとCaudiumは、どちらもPikeで記述されています。
Pikeの高度なデータ型とソケットの組み込みサポートにより、インターネットアプリケーションでの使用に理想的です。
Pikeは、GNU General Public License（GPL）、GNU Lesser General Public License（LGPL）、およびMozilla Public License（MPL）に基づくフリーソフトウェアです。
UNIX、Linux、Solaris、macOS X、Microsoft Windowsなど、多くのオペレーティングシステムで利用可能です。
Pikeは、Webアプリケーション、ネットワークプログラミング、データベース処理、ゲーム開発など、多岐にわたる用途に利用されています。
具体的には、以下のような場面で活用されています。
C/C++
PikeはC/C++に似た文法を持つ高水準プログラミング言語です。C++よりも簡単で安全に使用できます。また、C++よりも柔軟性があり、柔軟なプログラミングスタイルを許容します。ただし、インタプリタ型であり、C/C++よりも高速ではありません。また、多くの異なるCおよびC++コンパイラが存在する一方で、Pikeの実装は1つしかありません。
C#
PikeはC#に非常に似ています。実際には、PikeはC#の設計に影響を与えた言語の1つであると考えられています。2つの言語の主な違いは、PikeにはC#よりも優れた標準型システムがあり、型変換などの処理にライブラリを必要としないことです。C#に慣れている場合、Pikeは非常に使いやすいと思います。
Java
表面的には Java に似ていますが、Java と同様に、Pikeは中間形式に変換され、それがインタプリタによって実行されます。Java プログラムは通常、この中間形式でユーザーに配信されますが、Pikeではソースコードを使用します。これは、Pikeにおいてコンパイル時間、つまりプログラムを中間形式に変換するのにかかる時間が事実上ゼロであるためです。
Perl
PerlはUnixシステム上でシステム管理ツールとして開始されました。PikeとPerlはどちらも文字列を扱うのに適しており、どちらもウェブサーバーの機能を追加するために使用できます。PerlはPikeよりもはるかに広く使用されています。一部のプログラマーは、Perlの構文がわかりにくいと感じています。
Python
Pythonで書かれたプログラムは、Pikeプログラムとは非常に異なって見えますが、PythonとPikeはアイデアや使用方法において似ています。Pythonはより広く使用されており、より多くのライブラリが利用可能です。一方、Pikeはより高速で、より高度な型システムを持ち、オブジェクト指向プログラミングに対するサポートもより良好です。PikeのよりC++に近い構文は、C++、C、またはJavaを知っているプログラマーにとっては始めやすくなっています。
JavaScript
JavaScriptとPikeはどちらもオブジェクト指向言語です。ただし、いくつかの重要な違いがあります。JavaScriptはプロトタイプベースであり、Pikeはクラスベースです。
Ruby
RubyとPikeは、どちらもスクリプティング言語であり、オブジェクト指向に基づいています。しかし、いくつかの重要な違いがあります。Rubyは動的型付け言語で全てのインスタンスがオブジェクトですが、Pikeは静的型付け言語で一部のインスタンスはプリミティブです。
1994年: Fredrik HübinetteとPer Hedborを含むLysatorのプログラマーたちが、MUD向けに開発された言語であるLPCからPikeの前身であるLPC4を分離し、これをさまざまなアプリケーションのための迅速なプロトタイピング言語として使用します。
1994年: LPCのライセンスが商業目的での使用を許可していないため、新たにGPL実装のµLPC（マイクロLPC）が開発されます。
1996年: µLPCは商業的に有望な名前を提供するためにPikeに改名されます。
1996年: Pikeの開発はRoxen Internet Softwareに引き継がれ、同社のリソースが提供されます。同社はPikeで開発されたWebサーバーであるRoxenを提供します。
2002年: リンシェーピング大学のプログラミング環境研究室が、RoxenからPikeのメンテナンスを引き継ぎます。Opera Softwareのリンシェーピングオフィスでは、PikeプログラマーがOpera Miniアプリケーションのサーバー/ゲートウェイ部分で中心的な役割を果たすために、数名が雇用されました。
Pikeは、UNIX、Linux、Windows、macOSなどの多くのプラットフォームで利用可能です。
Pikeの最新バージョンをダウンロードするには、Pikeの公式ウェブサイト( http://pike.lysator.liu.se/ )を訪問してください。
Linuxユーザーの場合、Pikeは多くのディストリビューションのパッケージリポジトリに含まれています。例えば、DebianやUbuntuの場合、以下のコマンドを使用してPikeをインストールすることができます。
$ sudo apt-get update
$ sudo apt-get install pike8.0
Windowsユーザーの場合、PikeのWindowsバージョンをダウンロードしてインストールする必要があります。
ダウンロードしたファイルを実行して、ウィザードに従ってインストールしてください。
macOSユーザーの場合、Homebrewなどのパッケージマネージャーを使用してPikeをインストールすることができます。
Pikeは、ビルド済みバイナリの他にソースコードも公開されているので、ソースコードからビルドしてインストールすることも可能です。
ここで問題になるのが、現在配布されているソースコードからビルドする過程で pike 自身が使われている点です。
このため、FreeBSDの様なビルド済みバイナリが配布されていないプラットホームでは、ビルドそのものが出来ません。
これを解決するには、ビルドにpike 自身が使われていなかった頃の過去のバージョン（例えば、0.6）をビルドしインストールし、その後、過去のバージョンのpikeを使って新しいバージョン（例えば、8.0）をインストールする二段階のビルドプロセスが有効です。
この方法で、FreeBSD 13.1/amd64 に Pike v8.0 release 1738 をインストールできました。
Pikeをインストールした後は、まずバージョンを確認します。以下のコマンドを使用してPikeのバージョン確認してください。
$ pike --dumpversion
8.0.1738
コマンドラインからPikeを起動することができます。以下のコマンドを使用してPikeを起動してください。
$ pike 
Pike v8.0 release 1738 running Hilfe v3.5 (Incremental Pike Frontend)
> write("Hello world!);
Hilfe Error: Unterminated string "\"Hello world!);\n" at line 1
> write("Hello world!");
Hello world!(1) Result: 12
> quit
Exiting.
$ _
Pikeの対話型シェルが起動し、コードを実行することができます。
quit コマンドで終了し、コマンドラインに戻ります。
また、Pikeで書かれたスクリプトファイルを実行する場合は、以下のようにファイル名を指定して実行してください。
$ cat hello.pike
int main() {
    write("Hello world!\n");
    return 0;
}
$ pike hello.pike
Hello world!
以上のように、Pikeをダウンロードしてインストールし、コマンドラインから起動することができます。
Pikeのオンライン実行環境は、ウェブ上でPikeプログラミング言語のコードを書き、実行できるオンラインツールです。これにより、ユーザーはPikeの構文や機能を試したり、小規模なプログラムを作成したりすることができます。
代表的なPikeのオンライン実行環境:[http://tpcg.io/_YV8Y79 tutorialspoint.com]
一般的に、オンライン実行環境は以下の機能を提供します:
コードの入力エディタ: ユーザーはPikeのコードを直接入力できるテキストエディタが提供されます。
実行ボタン: ユーザーは入力したコードを実行するためのボタンが提供されます。
実行結果の表示: コードの実行結果や出力が、ウェブページ上で表示されます。
エラーメッセージの表示: もしコードにエラーがある場合、エラーメッセージが表示されて、問題点を特定できます。
これにより、Pikeをインストールする必要なく、ウェブブラウザを介してPikeのコードを試したり学習したりすることができます。
前の節で実行したプログラムを解説しましょう。
[http://tpcg.io/_YV8Y79 hello.pike]:
int main() {
    write("Hello world!\n");
    return 0;
}
int main(): この行は、main 関数を宣言しています。C言語と同様に、Pikeのプログラムは、 main 関数から実行が開始されます。int は、main 関数が整数を返すことを示します。
{ と }: これらは、main 関数の本体を定義するために使用されます。
write("Hello world!\n");: この行は、標準出力に "Hello world!" という文字列を出力する write 関数を呼び出しています。\n は改行文字を表します。
return 0;: この行は、 main 関数からプログラムを終了するために、整数値 0 を返しています。
したがって、このプログラムの出力は、"Hello world!" という文字列に改行文字が続いたものになります。
Pikeはインタープリタ言語であるため、変数に宣言が必要ないと思われるかもしれません。
しかし、Pikeでは変数宣言が必須であり、変数の型がコンパイル時に決定されるため、型安定性が高くなります。
変数を宣言する場合、以下のように宣言します。
型名 変数名 = 初期値;
たとえば、整数型の変数xを宣言し、初期値に42を代入する場合、次のようになります。
int x = 42;
Pikeの変数宣言では、型名を省略できませんが、初期値を代入しない場合には、次のように変数宣言をすることができます。
int x;
Pikeにはいくつかの基本的なデータ型があります。以下にそれらを説明します。
整数型（int）: 整数を表現するためのデータ型です。例えば、17や-42などの整数値を表現することができます。
浮動小数点型（float）: 実数を表現するためのデータ型です。整数型とは異なり、小数点以下の部分を持つ数値を表現することができます。例えば、3.14や-0.5などの実数値を表現することができます。
文字列型（string）: 文字列を表現するためのデータ型です。文字列は文字の連続した列です。例えば、"Hello"や"Pike programming"などの文字列を表現することができます。文字列はダブルクォーテーションで囲みます。
任意の型（mixed）: 任意のデータ型を表現するための特殊なデータ型です。mixed型の変数はどのような型の値でも格納することができます。異なる型の値を組み合わせたり、柔軟なデータ構造を表現するために使用されます。
これらの基本的なデータ型は、Pikeプログラムで変数を宣言する際に使用されます。例えば、int number_of_monkeys;は整数型の変数number_of_monkeysを宣言しています。
また、基本的なデータ型の他にもコンテナ型と呼ばれるデータ型があります。コンテナ型は他のデータを格納するためのデータ型であり、配列（array）、マップ（mapping）、マルチセット（multiset）などがあります。これらのコンテナ型は複雑なデータ構造を扱うために使用されますが、基本的なデータ型と同様に変数を宣言して使用することができます。
[http://tpcg.io/_9ME17V types.pike]:
int main() {
    // 基本型 //
    int i = 42;         // 整数型の変数
    float f = -16.2;    // 浮動小数点型の変数
    string s = "Hello"; // 文字列型の変数
    mixed x = 100;      // 任意の型の変数（mixed型）
    int | float n = 0;  // 整数型か浮動小数点型の変数
    write("i = %O, f = %O, s = %O, x = %O, n = %O\n", i, f, s, x, n);
    // コンテナ型 //
    // 配列（Array）
    array(string) fruits = ({ "apple", "banana", "orange" });
    write("%O\n", fruits);
    // マッピング(mapping)
    mapping map = ([ "key1": "value1", "key2": "value2", "key3": "value3" ]);
    write("%O\n", map);
    // マルチセット(multiset)
    multiset mset = (< 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 6 >);
    write("%O\n", mset);
    
    return 0;
}
実行結果:
i = 42, f = -16.2, s = "Hello", x = 100, n = 0
({ /* 3 elements */
    "apple",
    "banana",
    "orange"
})
([ /* 3 elements */
  "key1": "value1",
  "key2": "value2",
  "key3": "value3"
])
(< /* 11 elements */
  1,
  1,
  2,
  3,
  3,
  4,
  5,
  5,
  6,
  6,
  9
>)
まず、基本型の変数が宣言されています。以下のような変数があります:
int: 整数型の変数で、iという名前で宣言されており、値は42です。
float: 浮動小数点型の変数で、fという名前で宣言されており、値は-16.2です。
string: 文字列型の変数で、sという名前で宣言されており、「Hello」という文字列が格納されています。
mixed: 任意の型の値を格納できる変数で、xという名前で宣言されており、値は100です。Pikeでは、mixed型は異なる型の値を格納できる特殊な型です。
int | float: 整数型または浮動小数点型の値を格納できる変数で、nという名前で宣言されており、初期値は0です。このような変数は、Pikeの型ユニオンを使用して宣言されています。
次に、コンテナ型の使用例が示されています。
array(string): 文字列の配列を表す変数で、fruitsという名前で宣言されています。この配列には、"apple"、"banana"、"orange"という3つの文字列が格納されています。
mapping: キーと値のペアのマッピング（連想配列）を表す変数で、mapという名前で宣言されています。このマッピングには、"key1"、"key2"、"key3"という3つのキーと、それぞれに対応する"value1"、"value2"、"value3"という値が含まれています。
multiset: 複数の要素を保持するマルチセットを表す変数で、msetという名前で宣言されています。このマルチセットには、3、1、4、1、5、9、2、6、5、3、6という11個の要素が格納されています。マルチセットは、順序を持たずに要素を格納するデータ構造です。
Pikeでは変数は必ず宣言が必要なことは既に述べましたが、初期化は必須ではありませんでした。
では未初期化の値を参照するとどうなるでしょう？
 答えは、整数の0が返るです。
[http://tpcg.io/_F7E1IC uninitialized.pike]:
int main() {
    int i;
    write("Variable i has type %t and value %O\n", i, i);
    // => Variable i has type int and value 0
    float f;
    write("Variable f has type %t and value %O\n", f, f);
    // => Variable f has type int and value 0
    string s;
    write("Variable s has type %t and value %O\n", s, s);
    // => Variable s has type int and value 0
    array a;
    write("Variable a has type %t and value %O\n", a, a);
    // => Variable a has type int and value 0
    return 0;
}
実行結果:
Variable i has type int and value 0
Variable f has type int and value 0
Variable s has type int and value 0
Variable a has type int and value 0
整数型変数iの未初期化の値が0である点はともかく、他の型の変数も全て整数型の0が入っています。
未初期化の場合、でたらめな値が入ることは問題ですが、それっぽい値が入っていると初期化忘れを発見することが遅れます。
整数の0は比較的容易に検査できるため、初期化の不備を簡単に発見できます。
しかしながら、初期化を必ず行う習慣を身につけることが最も重要です。
またpike-9.x（開発バージョン）では、新しい型名 auto の導入が予定され、型推論を行うことが可能になります。
型推論には初期化が必須なので、初期化忘れが減る事も期待できます。
Pikeにおける列挙型はenumというキーワードを用いて定義されます。以下は、簡単な色の列挙型を定義し、それを使用して文字列を出力するプログラムの例です。
[http://tpcg.io/_7U3VUM enum.pike]:
enum Color {
    RED,
    BLUE,
    GREEN
}
int main() {
    Color color = BLUE;
    switch(color) {
        case RED:
            write("The color is red.\n");
            break;
        case BLUE:
            write("The color is blue.\n");
            break;
        case GREEN:
            write("The color is green.\n");
            break;
        default:
            write("Unknown color.\n");
            break;
    }
    return 0;
}
実行結果:
The color is blue.
上記のプログラムでは、Colorという列挙型を定義し、3つの定数 RED、BLUE、GREEN を定義しています。その後、main()関数内でColor型の変数colorを宣言し、BLUEで初期化しています。switch文を使ってcolorの値によって分岐し、該当する文字列を出力しています。
enum は、Pike 7.2.30 で追加されました。
Pikeにおいて、いくつかの関数はコード中で1文字または2文字で呼び出すことができ、コードを短くすることができます。
これらの関数は演算子と呼ばれ、既にたくさんの例でその動作を見てきました。
演算子は機能に基づいてカテゴリーに分類されますが、注意が必要です。なぜなら、一部の演算子には、それらが属するカテゴリーの範囲を超えた意味があるからです。
以下は整数に関する演算子の例です。
int main() {
// 算術演算子
int a = 10, b = 5;
int c = a + b; // 加算
int d = a - b; // 減算
int e = a * b; // 乗算
int f = a / b; // 除算
int g = a % b; // 剰余
// 比較演算子
int h = 5, i = 10;
bool j = (h == i); // 等しい
bool k = (h != i); // 等しくない
bool l = (h < i); // より小さい
bool m = (h > i); // より大きい
bool n = (h <= i); // 以下
bool o = (h >= i); // 以上
// 論理演算子
bool p = 1, q = 0;
bool r = (p && q); // 論理積（AND）
bool s = (p || q); // 論理和（OR）
bool t = (!q); // 否定（NOT）
// 代入演算子
int u = 5;
u += 10; // 加算して代入
u -= 5; // 減算して代入
u *= 2; // 乗算して代入
u /= 4; // 除算して代入
u %= 3; // 剰余して代入
// ビット演算子
int v = 0b101010, w = 0b110011;
int x = (v & w); // 論理積（AND）
int y = (v | w); // 論理和（OR）
int z = (v ^ w); // 排他的論理和（XOR）
int aa = (~v); // 反転（NOT）
// シフト演算子
int bb = 0b101010;
int cc = (bb << 2); // 左シフト
int dd = (bb >> 2); // 右シフト
// 条件演算子（三項演算子）
int ee = (h > 5) ? 10 : 20;
// その他の演算子
int ii = 5;
ii++; // インクリメント
ii--; // デクリメント
int jj = (ii > 5) ? 10 : 20; // 条件演算子（三項演算子）
    return 0;
}
これらの演算子は、条件式やループ制御などでよく使用されます。
boolはintの別名で、0が偽・0以外が真になります。
以下は文字列に関する演算子の例です。
int main() {
    string s1 = "Hello";
    string s2 = "World";
    // 文字列結合演算子
    write("%O + %O => %O\n", s1, s2, s1 + s2); // => "HelloWorld"
    // 部分文字列演算子
    write("%O[0..2] => %O\n", s1, s1[0..2]); // => "Hello"[0..2] => "Hel"
    // == (等しい)
    write("%O == %O is %d\n", s1, s2, s1 == s2); // => "Hello == World is 0"
    // != (等しくない)
    write("%O != %O is %d\n", s1, s2, s1 != s2); // => "Hello != World is 1"
    // > (より大きい)
    write("%O > %O is %d\n", s1, s2, s1 > s2); // => "Hello > World is 0"
    // >= (以上)
    write("%O >= %O is %d\n", s1, s2, s1 >= s2); // => "Hello >= World is 0"
    // <
    write("%O < %O is %d\n", s1, s2, s1 < s2); // => "Hello < World is 1"
    // <= (以下)
    write("%O <= %O is %d\n", s1, s2, s1 <= s2); // => "Hello <= World is 1"
    return 0;
}
Pikeの演算子の中には、数学的な意味から離れた定義のものもあります。
int main() {
    string str = "The quick brown fox jumps over the lazy dog";
    array(string) ary = str / " "; 
    // => ({ "The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog" })
    string s2 = ary * ", ";
    write("%O\n", s2);
    // => "The, quick, brown, fox, jumps, over, the, lazy, dog"
    return 0;
}
このプログラムでは、Pikeの文字列の/演算子と、配列の*演算子を使っています。
まず、文字列 str を "/" (スペース) で分割して、array(string) 型の変数 ary に代入しています。
この演算により、ary には str を単語ごとに分割した文字列の配列が格納されます。
例えば、ary[0] には "The" が格納されます。
この動作は、多くのスクリプティング言語のsplit()関数に相当します。
次に、ary の各要素を ", " で結合して、新しい文字列 s2 を作成しています。
この演算により、s2 には ary の各要素が ", " で結合された文字列が格納されます。
例えば、s2 には "The, quick, brown, fox, jumps, over, the, lazy, dog" が格納されます。
この動作は、多くのスクリプティング言語のjoin()関数に相当します。
最後に、swrite 関数を使って、s2 の内容を表示しています。
write 関数はsprintf 関数の機能を含んでおり、指定したフォーマットに従って、文字列を生成する関数です。
"%O\n" は、文字列を出力するフォーマット文字列であり、%O は、Pike のオブジェクトを文字列に変換するための変換タイプです。
「Pikeでは演算子も関数」とは、Pikeにおいて演算子 (たとえば +, -, *, / など) が単なる記号ではなく、それぞれが対応する関数として定義されているということを指します。
例えば、+ 演算子は、2つの数値を足し合わせるために使われますが、実際には `+ 関数として定義されています。
以下のように `+ 関数を使って足し算を行うことができます。
int main() {
    int a = 1;
    int b = 2;
    int c = `+(a, b);  // a + b と同じ
    write("`+(%d, %d) -> %d\n", a, b, c);
    // => `+(1, 2) -> 3
    return 0;
}
 
また、* 演算子も同様に `* 関数として定義されています。以下のように、文字列に対して * 関数を使って、指定した回数だけ繰り返した新しい文字列を作ることができます。
 
int main() {
    string str = "hello";
    string new_str = `*(str,3);  // str * 3 と同じ
    write("%O\n", new_str);
    // => "hellohellohello"
    return 0;
}
このように、Pikeでは演算子も単なる記号ではなく、それぞれが対応する関数として定義されています。
このような関数の性質をもつ演算子の型を調べてみましょう。
int main() {
    write("%t\n", `+);
    // => function
    write("%t\n", main);
    // => function
    return 0;
}
`+ の型は、main と同じ function だとわかります。
write の %t は、Pike固有の変換タイプで、引数の型を表示します。
int main() {
    function f = `+;
    write("f = `+\n");
    write("f(%d, %d) -> %d\n", 3, 4, f(3, 4));
    // => f(3, 4) -> 7
    
    f = lambda(int x, int y) {
        int result = 1;
        for (int i = 0; i < y; i++)
            result *= x;
        return result;
    };
    write("f(%d, %d) -> %d\n", 3, 4, f(3, 4));
    // => f(3, 4) -> 81
    return 0;
}
このコードは、Pikeで関数を定義して呼び出す方法を示しています。
最初に、`+ 関数を f という変数に代入しています。ここで + は、加算演算子 "+" に対応する関数です。その後、f に渡す引数を指定して、f 関数を呼び出しています。
次に、f に別の関数を代入しています。ここでは、ラムダ式を使って、与えられた2つの引数を掛け合わせる関数を定義しています。その後、f 関数を再度呼び出して、新しい関数が正しく動作していることを確認しています。
Pikeでは、関数を変数に代入することができるため、動的に関数を切り替えることができます。この機能を使うことで、プログラムの柔軟性を高めることができます。
Pikeにおけるラムダ関数とは、無名の関数を定義するための方法の一つです。ラムダ関数を定義するには、lambda キーワードを使います。
例えば、以下のような lambda 関数を定義してみましょう。
function square = lambda(int x) { return x * x; };
write("square(%d) -> %d\n", 3, square(3));
// => square(3) -> 9
このコードでは、lambda キーワードを使って、引数として整数 x を受け取り、x * x を返す square 関数を定義しています。
その後、square(3) のようにして、引数として整数 3 を渡して square 関数を呼び出しています。
この呼び出しによって、9 が返されます。
配列の要素ごとに操作を行うために、map()には便利な構文があります。この構文を使用することで、コードをより読みやすくすることができます。
int main() {
    array a = ({1,3,5,7,9}), b = ({2,4,6,8,10}), c;
    c = a[*] + b[*];
    write("c ->\n");
    write("\t%O\n", c[*]);
    //=> c ->
    //=> 	3
    //=> 	7
    //=> 	11
    //=> 	15
    //=> 	19
    
    c[*] += 10;
    write("\nc = %O\n", c);
    //=> c = ({ /* 5 elements */
    //=>     13,
    //=>     17,
    //=>     21,
    //=>     25,
    //=>     29
    //=> })
    
    return 0;
}
このプログラムでは、3つの配列a、b、cを使用しています。
配列cは一時的な配列で、結果を格納するために使用されます。
次の行では、automapという構文を使用して、配列aと配列bの要素ごとの和を計算し、結果を配列cに代入しています。
c = a[*] + b[*];
配列cの要素数全てに対し順に関数を適用します。
    write("\t%O\n", c[*]);
次に、配列cの全ての要素に10を加算しています。
最後に、更新された配列cを％O構文で表示しています。
定数は、プログラミングにおいて特定の値に名前を付けるために使われるもので、一度定義されたらその値を変更することができません。
構文は以下のようです。
constant 識別子 = 初期値 ;
Pike言語では、定数は初期値からの型推論を行います。つまり、定数の型は初期値に基づいて自動的に決定されます。変数とは異なり、明示的な型宣言は必要ありません。
Pikeのsprintf()は、文字列をフォーマットするための関数です。
write()もsprintf()と同じ書式文字列を使ってフォーマット出来ます。
int main() {
    // 数値のフォーマット
    write("%d, %f\n", 123, 3.1415926536); //=> 123, 3.142
    // 文字列のフォーマット
    write("Hello, %s!\n", "Alice");       //=> Hello, Alice!
    
    // 文字幅の指定(左詰め)
    write("|%-10sWorld|\n", "Hello");      //=> |Hello     World|
    // 文字幅の指定(中央揃え)
    write("|%|10sWorld|\n", "Hello");      //=> |  Hello   World|
    // 文字幅の指定(右詰め)
    write("|%10sWorld|\n", "Hello");       //=> |     HelloWorld|
    // 符号と修飾子の使用
    int n = 123456;
    write("%+d, %0*d\n", n, 8, n);         //=> +123456, 00123456
    // 配列
    write("%O\n", ({2,3,5,7,11}));
    // ({ /* 5 elements */
    //     2,
    //     3,
    //     5,
    //     7,
    //     11
    // })
    return 0;
}
このプログラムは、Pikeでwrite関数を使用して、数値、文字列、および整数のフォーマットを行う方法を示しています。
最初の例では、%dと%fを使用して、整数と浮動小数点数をフォーマットしています。
%fでは、小数点以下4桁まで表示するように指定されています。
次の例では、%sを使用して、文字列をフォーマットしています。
write関数を使用することで、埋め込む文字列を動的に変更することができます。
次に、文字幅の指定について説明します。文字幅を指定するには、%sの前に%10sのように数字を入れます。
これは、表示する文字列が占める幅を指定するものです。
また、%-10sのように-を付けると、左揃えになります。
%10sでは右揃えになりますが、指定した文字列が占める幅よりも長い場合は、文字列の右端から切り捨てられます。
%|10sでは中央揃えになります。
最後に、符号と修飾子の使用について説明します。%+dを使用すると、符号を付けて整数をフォーマットすることができます。
%0*dを使用すると、整数を指定した桁数になるように0でパディングして表示することができます。
それぞれのwrite関数の使用例を実行した際に得られる出力は、コメントの後に示されています。
sprintf()関数は、書式文字列という特殊な文字列を受け取り、それを解釈して文字列を作成します。
書式文字列は、出力する文字列内で特定の値を置き換えるために使用されます。書式文字列は、%に続く文字で始まり、特定の形式で引数を受け取ることができます。たとえば、%dは整数の書式文字列であり、%sは文字列の書式文字列です。
書式文字列には、変換タイプ( conversion type )に修飾子( params )を追加することができます。修飾子は、書式文字列に対して動作を変更するために使用され、変換タイプは、出力の形式を制御するために使用されます。変換タイプと修飾子は、%の後に続けて指定することができます。
変換タイプは、省略できず必ず１つだけ指定します。
修飾子は省略できます。
Pikeの制御構造は、プログラムの実行フローを制御するための構文や構造のことを指します。これらの制御構造には、条件分岐、ループ、反復などが含まれます。Pikeでは、以下のような主要な制御構造があります：
条件分岐
if: 条件に応じて実行するコードを選択します。条件が真の場合にはifブロックが実行され、偽の場合にはelseブロックが実行されます。
switch: 条件によって複数の選択肢の中から1つを選択します。式の結果に応じて、対応するcase文が実行されます。
ループ: 条件が満たされている間、あるいは特定の回数繰り返し処理を行います。
while:ループの前に条件をテストします。
do-while: ループの後に条件をテストします。
for:ループの開始前に初期化を行い、ループごとに条件をテストし、増加・減少などを行います。
foreach: foreach文は、配列やリストの各要素に対して一連の操作を実行します。foreach構文を使用することで、反復処理が簡潔に記述できます。
これらの制御構造を組み合わせて、複雑なプログラムの制御フローを構築することができます。
これにより、条件に基づいた処理や繰り返し処理を効率的に実装することができます。
条件分岐は、テスト条件を与えられ、実行するコードを選択する制御構造です。
これらは、バイナリの「実行するかしないか」から、入力パラメータに基づいて実行するコードを選択する大規模なコード表まで、さまざまです。
最も単純な条件分岐は、if文です。if文は、文が期待されるどこにでも書くことができ、次のように見えます。
if (条件式)
    文1;
else
    文2;
カッコの後ろやelseの後ろにはセミコロンがないことに注意してください。if文の処理は次のように行われます。
最初に条件式を評価します。
評価結果がfalseの場合、4にジャンプします。
文1を実行します。
5にジャンプします。
文2を実行します。
処理が完了します。
要するに、条件式がtrueの場合は文1が実行され、それ以外の場合は文2が実行されます。
条件式がfalseの場合に何かを実行する必要がない場合は、else部分を全て省略することができます。
if ( 条件式 )
    文1;
逆に、条件式がfalseの場合に何かを評価する必要がない場合は、not演算子を使用して式のtrue/false値を反転する必要があります。
if ( ! 条件式 )
    文2;
ここにある文は、この章の残りの文と同様に、文のブロックである場合があります。ブロックとは、セミコロンで区切られた文のリストで、中括弧 { } で囲まれています。注意点として、ブロックの後ろにはセミコロンをつけないでください。上記の例は次のようになります。
if ( ! 条件式 ) {
    文A;
    文B;
    文C;
}
また、複数のif文を順番に配置して、最初の式がfalseである場合は、次の式、次の式などを続けて、最初のtrue式が見つかるまで続けることもできます。
if ( 式1 )
    文1;
else if ( 式2 )
    文2;
else if ( 式3 )
    文3;
else
    文4;
上記の例の特殊な場合は、各式で1つの変数を異なる値と比較する場合です。
そのようなアプリケーションでは、下記で説明するswitch文を使用してパフォーマンスを向上させ、コードを簡素化することができます。
switch文は、条件に応じて複数の選択肢の中から1つを選択するための、より高度な制御構造です。以下のような形式になります。
switch (式) {
case 定数1:
    文1;
    break;
case 定数2:
    文2;
    break;
case 定数3 .. 定数4:
    文3;
    break;
case 定数5:
case 定数6:
    文4;
    // Fallthrough
default:
    文5;
}
switch文は、if文よりも少し複雑な構造をしていますが、まだかなり単純です。
まず、式を評価し、次のブロック内の全てのcase文を検索します。
式によって返された値と等しいものが見つかれば、Pikeはそのcase文の直後に続くコードを実行し続けます。
breakが出現すると、Pikeはスイッチブロックの残りのコードをスキップし、ブロックの後に続くコードを実行します。
次のcase文の前にbreakがなくても、必ずしも厳密に必要ではありません。
次のcase文の前にbreakがない場合、Pikeは単に実行を続け、そのcase文の直後のコードも実行します。
上記の例のcase文の1つは、範囲であるという点で異なります。
この場合、定数3と定数4の間の任意の値が文3にジャンプするようになります。
範囲は、定数3と定数4の値を含むことに注意してください。
まとめ
int main()
{
    int x = 3;
    int y = 5;
    
    // if文
    if (x < y) {
        write("x is less than y\n");
    }
    else if (x > y) {
        write("x is greater than y\n");
    }
    else {
        write("x and y are equal\n");
    }
    
    // switch文
    switch (x) {
    case 1:
        write("x is 1\n");
        break;
    case 2:
        write("x is 2\n");
        break;
    case 3:
        write("x is 3\n");
        break;
    default:
        write("x is not 1, 2, or 3\n");
        break;
    }
    
    return 0;
}
反復は、コードを0回以上実行するために使用されます。これは、かなり異なる方法で実行できるため、4つの異なる反復制御構造があります。これらはすべて非常に似ているように見えるかもしれませんが、適切な時に適切なものを使用すると、コードは短く、シンプルになります。
whileは、ループ制御構造の中で最もシンプルなものです。elseの部分を除いたif文のように見えます。
while ( 式 )
  文;
動作方法の違いは大きくないため、式が真の場合に文が実行されます。
その後、式が再評価され、真であれば文が再度実行されます。
それから式を再度評価し、繰り返します... 以下は使用例です。
int e = 1;
while (e < 10) {
    show_record(e);
    e = e + 1;
}
これにより、show_recordが1、2、3、4の値で呼び出されます。
forは、単にwhileの拡張です。ループをより短く、コンパクトに書くための方法を提供します。構文は以下のようになります。
for ( 初期化文 ; 条件式 ; 加算式 )
  文 ;
forは、以下の手順を実行します。
初期化文を実行します。初期化文は、ループ変数を初期化するために一度だけ実行されます。
結果がfalseの場合、ループを終了し、ループ後にプログラムを続行します。
文を実行します。
加算式を実行します。
2から再開します。
これにより、whileセクションの例は次のように書くことができます。
for (int e = 1; e < 10; e = e + 1)
  show_record(e);
do-whileは、whileと似ていますが、必ず一度は文が実行されことが異なります。
do 
  文;
while ( 式 ) ;
動作方法の違いは大きくないため、式が真の場合に文が実行されます。
その後、式が再評価され、真であれば文が再度実行されます。
それから式を再度評価し、繰り返します... 以下は使用例です。
int e = 100;
do {
    show_record(e);
    e = e + 1;
} while (e < 10);
これにより、show_recordが100で呼び出されます。
foreachは、ループ内の各反復に対して明示的なテスト式を評価しない点でユニークです。
代わりに、foreachはセット内の各要素について1回だけ文を実行します。foreachには2つの構文があり、最初の構文は次のようになります。
foreach ( 配列式, ループ変数 )
    文;
foreachが行うことは以下の通りです。
配列式を評価します。これは配列を返さなければなりません。
配列が空であれば、ループを終了します。
次に、配列の最初の要素をループ変数に割り当てます。
その後、文を実行します。
配列にさらに要素があれば、次の要素が変数に割り当てられ、それ以外の場合はループを終了します。
4に移動します。
Pike-7.4.10 から foreach に新しい構文が追加されました。
foreach ( 配列式; インデックス変数; ループ変数 )
    文;
// foreachループで配列を反復処理し、インデックスと値を表示する
void example_foreach() {
    array numbers = ({2, 3, 5, 7, 11});
    foreach (numbers; int index; int number) {
        write("Index: %d, Value: %d\n", index, number);
    }
}
// Array.Iteratorを使用して配列を反復処理し、インデックスと値を表示する
void example_iterator() {
    array numbers = ({2, 3, 5, 7, 11});
    Array.Iterator iterator = Array.Iterator(numbers);
    while (iterator) {
        int index = iterator->index();
        int value = iterator->value();
        write("Index: %d, Value: %d\n", index, value);
        iterator += 1;
    }
}
// Mapping.Iteratorを使用してマップを反復処理し、キーと値を表示する
void example_mapping_iterator() {
    mapping data = ([ "a": 1, "b": 2, "c": 3 ]);
    Mapping.Iterator iterator = Mapping.Iterator(data);
    while (iterator) {
        mixed index = iterator->index();
        mixed value = iterator->value();
        write("Index: %O, Value: %O\n", index, value);
        iterator += 1;
    }
}
// foreach、Array.Iterator、Mapping.Iteratorを使用して配列とマップを反復処理する
int main() {
    write("Using foreach:\n");
    example_foreach();
    write("\nUsing iterator on array:\n");
    example_iterator();
    write("\nUsing mapping iterator on mapping:\n");
    example_mapping_iterator();
    return 0;
}
example_foreach関数では、foreach文を使用して配列 numbers の要素を反復処理しています。ループごとに、index に現在のインデックスが、number に対応する要素が割り当てられます。その後、index と number の値を表示します。
example_iterator関数では、Array.Iteratorを使用して配列 numbers のイテレータを作成し、whileループを使用してイテレータを反復処理しています。イテレータが有効な間、現在のインデックスを index に取得し、対応する要素を value に取得します。その後、index と value の値を表示します。
example_mapping_iterator関数では、マッピング data のイテレータを作成し、whileループを使用してイテレータを反復処理しています。イテレータが有効な間、現在のインデックスを index に取得し、対応する値を value に取得します。その後、index と value の値を表示します。
main関数では、上記の関数を使用して、foreach文とイテレータの動作をデモンストレーションしています。それぞれのデモンストレーションの結果が表示されます。
上記のループ制御構文は、すべての問題を解決するのに十分ですが、すべての問題に簡単な解決策を提供するには不十分です。
ループの途中で抜け出すことができる機能が不足しています。これを行う方法は3つあります。
break文は、ループやswitch文の中で使用され、そのブロックから抜け出します。以下は、break文の構文と例です。
while (条件式) {
  // ループ処理
  if (条件式) {
    break;
  }
  // ループ処理
}
条件式が真である限り、ループ処理を繰り返します。しかし、if文の条件式が真になった場合、break文が実行され、whileループから抜け出します。
continue文は、ループ内で使用され、その時点での処理を中断し、次のループ処理を開始します。以下は、continue文の構文と例です。
while (条件式) {
  // ループ処理前半
  if (条件式) {
    continue;
  }
  // ループ処理後半
}
条件式が真である限り、ループ処理を繰り返します。しかし、if文の条件式が真になった場合、continue文が実行され、ループの先頭に戻って、次のループ処理を開始します。
return文は、関数内で使用され、その時点での処理を終了し、関数から値を返します。以下は、return文の構文と例です。
int my_func(int x, int y) {
  if (x == y) {
    return 0;
  }
  // 関数処理
  return x + y;
}
my_func関数内で、xとyを受け取ります。if文の条件式が真の場合、0を返します。それ以外の場合は、xとyの合計値を返します。return文が実行されると、関数内の処理は終了し、関数から値が返されます。
[http://tpcg.io/_DALWWW まとめ]
int main() {
    // whileループ
    int i = 0;
    while (i < 10) {
        write(i + "\n");
        i++;
    }
    // do-whileループ
    int j = 0;
    do {
        write(j + "\n");
        j++;
    } while (j < 10);
    // for(;;)ループ
    for (int k = 0; k < 10; k++) {
        write(k + "\n");
    }
    // foreach(,)ループ
    array fruits = ({ "apple", "banana", "cherry" });
    foreach (fruits, string fruit) {
        write(fruit + "\n");
    }
    // foreach(;;)ループ
    array numbers = ({2, 3, 5, 7, 11});
    foreach (numbers; int index; int number) {
        write("Index: %d, Value: %d\n", index, number);
    }
    // break文
    int l = 0;
    while (l < 10) {
        write(l + "\n");
        l++;
        if (l == 5) {
            break;
        }
    }
    // continue文
    int m = 0;
    while (m < 10) {
        m++;
        if (m == 5) {
            continue;
        }
        write(m + "\n");
    }
    // return文
    int n = my_func(3, 5);
    write(n + "\n");
    return 0;
}
int my_func(int x, int y) {
    if (x == y) {
        return 0;
    }
    // 関数処理
    return x + y;
}
関数は、Pikeプログラムの主要な構成要素の1つであり、複数の操作をまとめて実行するために使用されます。Pikeでの関数の基本的な概念は、他の多くのプログラミング言語と同様に、引数を受け取り、実行可能なコードブロックを定義し、戻り値を返すことです。
Pikeでは、関数の定義の構文は以下のようになります。
関数の定義:
戻値型 関数名(引数リスト) {
    // 関数の処理 
    // return文で値を返す（必要な場合）
}
引数リストは、「仮引数型 仮引数名」のペアを「,」で区切った０個以上のリストです。
関数の呼び出しの構文は以下のようになります。
関数の呼び出し:
戻値型 変数 = 関数名(引数リスト);
引数リストは、実引数アを「,」で区切った０個以上のリストです。
ここでは、変数に戻値を保持していますが、式の中の項に関数を使ったり、そのまま他の関数の実引数にしたりすることも可能です。
int add2(int a, int b) {
    return a + b;
}
int main() {
    int n = add2(2, 3);
    write("n = %d\n", n); // => n = 5
    return 0;
}
上記のコードは、add2という関数を定義し、その関数をmain関数から呼び出しています。
add2関数は、2つの整数 a と b を受け取り、それらの値を足して結果を返す関数です。
main関数では、add2(2, 3)を呼び出して、その結果を変数 n に格納しています。この場合、引数として 2 と 3 を渡しているので、関数内の a には 2、b には 3 が渡されます。結果として、add2(2, 3) の返り値である 5 が変数 n に格納されます。
最後に、write関数を使って変数 n の値を表示しています。出力結果は n = 5 となります。
この例では、関数 add2 を定義して再利用性を高め、main関数からその関数を呼び出しています。関数を使うことで、同じ処理を繰り返し書く必要がなくなり、コードの保守性と可読性を向上させることができます。
Pikeプログラミングでは、引数の配列展開を行うことができます。
配列展開は、f( @({ 2, 3 }) )のように配列に「@」を前置し、この場合はf( 2, 3 )と同じ意味になります。
配列展開を使うと、配列を個々の引数として関数に渡すことができます。以下に例を示します。
 
int add2(int a, int b) {
    return a + b;
}
int main() {
    array(int) pair = ({ 2, 3 });
    // 配列展開を使って関数に引数を渡す
    int n = add2(@pair);
    write("n = %d\n", n); // => n = 5
    return 0;
}
上記のコードは、add2という関数に配列展開を使用して引数を渡し、その結果を変数nに格納しています。
pairというarray(int)型の配列には2つの要素が含まれており、それぞれ2と3です。
add2(@pair)の部分で、@演算子を使用してpairの配列展開を行っています。
これにより、add2関数には2と3の2つの引数が個別に渡されます。
add2関数では、引数aとbを受け取り、それらを足した結果を返しています。
その結果が変数nに格納されます。
最後に、write関数を使用して変数nの値を表示しています。出力結果はn = 5となります。
配列展開を使うことで、配列の要素を個別の引数として関数に渡すことができます。これにより、コードの記述を簡潔にし、柔軟性を高めることができます。
通常の関数は、引数の数は一定ですが、引数の数を可変にすることも出来ます。
可変長引数を持つ関数の定義:
戻値型 関数名(仮引数型 ... 仮引数配列) {
    // 関数の処理 
    // return文で値を返す（必要な場合）
}
仮引数配列は、配列で引数リストと同じ内容が入ります。
なお、配列展開は可変長引数を受け取る関数に対しても使用することができます。
可変長引数を持つ関数に配列を渡す場合も、配列展開を行って可変長引数として渡すことができます。
 
int sum(int ... rest) {
    int x = 0;
    foreach (rest, int n) {
        x+= n;
    }
    return x;
}
int main() {
    array(int) ary  = ({ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
    // 配列展開を使って可変長引数を渡す
    int n = sum(@ary);
    write("n = %d\n", n); // => n = 55
    return 0;
}
上記のコードは、可変長引数を持つsum関数に配列展開を使用して引数を渡し、その結果を変数nに格納しています。aryというarray(int)型の配列には1から10までの整数が含まれています。
sum(@ary)の部分で、@演算子を使用してaryの配列展開を行っています。これにより、sum関数には1から10までの10個の引数が個別に渡されます。
sum関数では、可変長引数restを受け取り、それらの引数を合計しています。foreachループを使用して、可変長引数restの各要素nにアクセスし、それを変数xに加算しています。
最後に、変数xの値が変数nに格納され、write関数を使用して表示しています。出力結果はn = 55となります。
この例では、可変長引数を持つ関数に配列展開を使用することで、配列の要素を個別の引数として関数に渡すことができます。可変長引数を使用することで、引数の数が可変的である場合でも柔軟に対応することができます。
Pikeでは、関数内で自己を呼び出す再帰的な関数を定義することができます。これにより、反復処理を使用せずに問題を解決できる場合があります。
たとえば、次のような再帰的な関数を定義できます。
int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}
この関数は、与えられた整数nの階乗を計算します。再帰的呼び出しを使用して、nが0になるまで、nから1ずつ引いていきます。
たとえば、次のようにこの関数を呼び出すことができます。
int result = factorial(5);
この場合、resultには120が格納されます。
「暗黙のラムダ」は前処理および/または後処理が必要なコードを埋め込む便利な方法です。
関数呼び出しで始まり、直後にブレースブロックが続く文では、ブロックがラムダ関数に変換され、呼び出される関数の最後の引数として渡されます。
int times(int n, function block) {
    for (int i = 0; i < n; i++)
        block();
    return n;
}
int main() {
    int x = 0;
    times(3) {
        write("Hello world! <%d>\n", x++);
    } ;
    // => Hello world! <0>
    // => Hello world! <1>
    // => Hello world! <2>
    return 0;
}
timesという関数を定義して、その関数に引数として実行回数とブロックを渡し、ブロックを指定された回数分実行するという機能を持っています。
main関数では、times関数を呼び出し、第1引数に3を、第2引数に{ write("Hello world! <%d>\n", x++); }という暗黙のラムダを渡しています。この暗黙のラムダは、times関数内でblock()という形式で呼び出されます。block()の中では、write関数を用いて、"Hello world! "というメッセージを表示し、xの値をインクリメントしています。したがって、このプログラムは、"Hello world!"というメッセージと、それに続くxの値を示すメッセージを3回表示します。
times関数から制御が戻った後、main関数は、write("Hello world! <%d>\n", x++);によって、"Hello world! <3>"というメッセージを表示し、xをインクリメントします。したがって、このプログラムは、合計で4回の"Hello world!"メッセージを表示し、xの値は4になります。
このように、関数呼び出しに続くブロックが呼び出し先の関数の隠れた最後の関数引数となる例は、Ruby、Groovy、Kotlinなどに見ることが出来ます。
開発中の Pike-9.0 では、__ARGS__を使って暗黙のラムダへ引数を渡すことが出来るようになります。
void times(int n, function block) {
    for (int i = 0; i < n; i++) {
        block(i);
    }
}
int main() {
    times(3) {
        [mixed x] = __ARGS__;
        write("Hello world! <%d>\n", x);
    };
    // => Hello world! <0>
    // => Hello world! <1>
    // => Hello world! <2>
    return 0;
}
void times(int n, function block): この関数は、引数として整数 n と関数 block を受け取ります。block 関数は整数を引数として受け取り、何らかの処理を行います。times 関数は、block 関数を n 回繰り返し実行します。
int main(): この関数はプログラムのエントリーポイントです。main() 関数の中にプログラムのメインの処理が記述されます。
times(3) {...};: times() 関数を呼び出しています。引数として 3 を渡しており、block 関数の中身を記述しています。
[mixed x] = __ARGS__;: __ARGS__ はPikeの組み込み変数であり、関数の引数を表します。この行では、引数の値を変数 x に代入しています。mixed は変数の型を表し、x は変数名です。
return 0;: main() 関数の最後には、通常は終了コードを返すための return 文があります。ここでは 0 を返しています。
ラムダ式は外部の変数 x をキャプチャし、クロージャーとして機能します。これにより、ラムダ式内で x の値を変更することができます。
クロージャーは、関数内で定義された変数を含む関数オブジェクトであり、関数が終了してもその変数のスコープが維持されます。
この例では、times 関数内で定義された i と main 関数内で定義された x の2つの変数が存在し、ラムダ式が x をキャプチャして変更しています。
これにより、ラムダ式が終了した後でも x の値を保持できます。
まとめ
// 関数定義
int add2(int a, int b) {
    return a + b;
}
// 可変長引数を持つ関数定義
int sum(int ... rest) {
    int x = 0;
    foreach (rest, int n) {
        x+= n;
    }
    return x;
}
// 再帰的呼び出し
int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}
// 暗黙のラムダ
int times(int n, function block) {
    for (int i = 0; i < n; i++)
        block();
    return n;
}
int main() {
    // 関数の呼び出し
    int result = add2(2, 3);
    //=> 実行結果: result = 5
    array(int) ary = ({32, 16});
    result = add2(@ary);
    //=> 実行結果: result = 48
    result = sum(1, 2, 3);
    //=> 実行結果: result = 6
    ary = ({ 1, 2, 4, 8 });
    result = sum(@ary);
    //=> 実行結果: result = 15
    result = factorial(5);
    //=> 実行結果: result = 120
    int x = 0;
    times(3) {
        write("Hello world! <%d>\n", x++);
    };
    //=> 実行結果:
    //=> Hello world! <0>
    //=> Hello world! <1>
    //=> Hello world! <2>
    return 0;
}
Pikeでは、型は2つの異なるコンテキストで使用されます。コンパイル時と実行時です。一部の型はコンパイル時のみ使用されます（void、mixed、およびすべての構造型）、その他のすべての型は実行時にも使用されます。
Pikeには、基本型とポインタ型の2つの種類の実行時データ型があります。基本型は変数に割り当てられたときにコピーされますが、ポインタ型は単にポインタがコピーされるため、同じものを指す2つの変数が得られます。ポインタ型は、array、mapping、multiset、program、object、およびfunctionの6つがあります。これらはすべてポインタ型であり、メモリ上の何かを指します。この「何か」は、それに対するポインタがもうない場合に解放されます。変数にポインタ型の値を割り当てる場合、この「何か」はコピーされません。代わりに、それに対する新しい参照が生成されます。これらの型のいずれかを関数の引数として渡す場合、関数が「何か」を変更する可能性があるため、特別な注意が必要です。この効果を望まない場合は、値を明示的にコピーする必要があります。後述します。
整数を使用する場合は、キーワードintを使用します。
int i = 42;
浮動小数点数を使用する場合は、キーワードfloatを使用します。
float f = 3.1415926536;
文字列を使用する場合は、キーワードstringを使用します。
文字列は、二重引用符で囲まれた文字列リテラルを使用して表します。
string s = "Hello, world!";
この節では、ポインタ型について説明されています。基本型は非常に基本的な型であり、ほとんどのポインタ型は、基本型を格納する興味深い方法です。
ポインタ型には、配列、連想配列、マルチセット、プログラム、オブジェクト、関数があります。
これらはすべて、メモリ内の何かを指すポインタであり、ポインタがなくなると、その「何か」は解放されます。
ポインタ型の値を変数に代入すると、この「何か」がコピーされるのではなく、それに対する新しい参照が生成されます。
関数にこれらの型の値を引数として渡す場合には、特別な注意が必要であり、関数が「何か」を変更する可能性があるため、この効果が望ましくない場合には、明示的に値をコピーする必要があります。
配列 (array): 複数の値を格納するためのデータ構造で、添字を用いて要素にアクセスする。添字は整数でなければならない。例えば、a[0]、a[1]、a[2] などと表記される。
連想配列 (mapping): キーと値のペアを格納するためのデータ構造。添字に任意の型を使うことができる。例えば、m["key"] = value のように表記される。
マルチセット (multiset): 値の集合を格納するためのデータ構造で、同じ値を複数格納することができる。集合に含まれる値は順序関係がなく、一意である必要はない。例えば、s += ({ 1, 2, 3 }) のように表記される。
プログラム (program): Pikeのプログラムを表すための型。ファイルから読み込まれたり、インターネット上からダウンロードされたりする。例えば、p = read_file("program.pike") のように表記される。
オブジェクト (object): Pikeのオブジェクトを表すための型。メソッドや変数を含み、複数のオブジェクトを作成することができる。例えば、o = create_object("MyObject") のように表記される。
関数 (function): Pikeの関数を表すための型。プログラムやオブジェクトに属することができ、変数に代入することができる。例えば、f = lambda( int x ) { return x * x; } のように表記される。
Pikeでは、配列は複数の要素を格納するためのデータ構造です。配列は、コンマで区切られた要素のリストで初期化することができます。
array a = ({2, 3, 7});
このコードでは、aという配列が初期化され、要素として2, 3, 7が格納されます。
配列の要素にアクセスするには、配列名に角括弧を使用して、インデックスを指定します。例えば、a[0]は配列aの最初の要素を表します。a[1]は2番目の要素、a[2]は3番目の要素を表します。
int first_element = a[0];  // 2を取得
int second_element = a[1]; // 3を取得
int third_element = a[2];  // 7を取得
配列の要素に値を代入するには、同様に角括弧を使用して、インデックスを指定し、代入する値を指定します。
a[0] = 4; // a[0]に4を代入
配列に要素を追加するには、配列の最後に新しい要素を追加する += 演算子を使用します。
a += ({ 3.14159 }); // aの末尾に 3.14159 を追加
a += ({ "abc" });   // aの末尾に "abc" を追加
foreach 文を使うと配列要素を順に処理を行うことが出来ます。
foreach(a, mixed e) {
    if (intp(e))
        write("%d ", e);
    else if (floatp(e))
        write("%f ", e);
    else if (stringp(e))
        write("\"%s\" ", e);
    else 
        write("Unknown type");
}
write("\n");
foreach文は、指定された配列の各要素を順番に取り出し、ループを実行するための制御構文です。このプログラムでは、foreach(a, mixed e)という文で、配列aの各要素を取り出して、それをeに代入しています。mixedは、Pikeのデータ型で、任意の型の値を受け入れることができます。
if文は、eの型に応じて、適切な形式で表示するために、条件分岐を行います。intp(e)、floatp(e)、stringp(e)は、それぞれeが整数、浮動小数点数、文字列であるかどうかを判定する関数です。eが整数であれば、"%d "というフォーマット文字列を使用して、その整数を表示します。eが浮動小数点数であれば、"%f "というフォーマット文字列を使用して、その浮動小数点数を表示します。eが文字列であれば、"\"%s\" "というフォーマット文字列を使用して、その文字列をダブルクォーテーションで囲んで表示します。
最後のelse節は、eがどの型にも該当しない場合に実行され、"Unknown type"という文字列を表示します。
[TODO:このコードは要素に配列を含む配列に対応していません。]
Pikeにおける連想配列は、キーと値のペアの集合を表現するデータ型であり、mappingという名前で定義されています。
連想配列は、キーと値のペアを追加することができます。キーには文字列、整数、浮動小数点数、オブジェクトなどを使用することができ、値には任意のデータ型を格納することができます。
以下は、mappingを使用したサンプルコードです。
 
mapping m = ([ "key1": "value1", 2: 3.14, ({1,2}): "value3"]);
m["key2"] = "value2";
foreach ( m; mixed k; mixed v)
    write("%O: %O\n", k, v);
このコードでは、mappingを使用して、キーと値のペアを格納するmを宣言し、キーに文字列、整数、配列などを使用しています。また、mに新しいキーと値のペアを追加するために、m["key2"] = "value2";のように書いています。
foreach文では、mの各要素をkとvに代入して、write関数を用いて、kとvを適切なフォーマットで文字列に変換し、write関数で出力しています。
上記のプログラムは、以下のような出力を生成します。
"key2": "value2"
2: 3.14
({ /* 2 elements */
    1,
    2
}): "value3"
"key1": "value1"
mappingは、連想配列を実装するための主要なデータ型であり、Pikeの様々な機能に使用されます。
Pikeにおけるマルチセットは、要素の重複を許した、要素の集合を表現するデータ型であり、multisetという名前で定義されています。
マルチセットは、要素を追加することができ、同じ要素を複数回追加することもできます。
multiset m = (< 1, 2, 3, 3, "a", "b", "b" >);
m["c"] = 55;
m[3] = false;
foreach (m; mixed k; mixed n) {
    write("%O: %O\n", k, m[n]);
}
実行結果:
1: 1
2: 1
3: 1
"c": 1
"a": 1
"b": 1
"b": 1
このコードは、マルチセットを使った例です。最初に、< 1, 2, 3, 3, "a", "b", "b" >というマルチセットを作成し、変数mに代入しています。
このマルチセットには、整数1、2、および3、文字列"a"と"b"が、それぞれ1回ずつ登録されています。これに加えて、インデックス"c"と値55が追加されています。また、インデックス3に対応する値は、falseに変更されています。
次に、foreachループを使用してマルチセットを反復処理し、各インデックスとその値を出力しています。このループでは、変数kに現在のインデックスが、変数nに現在のインデックスの値が設定されます。マルチセットには、同じインデックスを複数持たせることができるため、出力結果には、インデックス"b"が2回表示されています。
write関数を使用して、各インデックスとその値を出力しています。%Oフォーマット指示子は、値の型に応じてその値を出力します。この場合、インデックスに対応する値は、1になります。
Pikeにおいて、プログラムとはC++におけるクラスに相当します。
プログラムは、そのプログラムに定義された関数や変数がどのように定義されているかの表を保持します。
また、コード自体、デバッグ情報、継承された他のプログラムへの参照も保持します。
ただし、プログラム自体にデータを格納するスペースはありません。
プログラム内の情報は、ファイルまたは文字列がPikeコンパイラを通過したときに収集されます。
次に議論するオブジェクトに格納するために必要な変数スペースは、オブジェクトに格納されます。
プログラムを書くことは簡単で、プログラムをメモリにロードするには、compile_fileやキャスト演算子を使うことができます。
キャスト演算子を使用する場合、プログラムはキャッシュされ、次回以降は同じプログラムが返されます。
また、classキーワードを使用すると、プログラムの中に別のプログラムを書くことができます。
データ領域を作成するには、プログラムをインスタンス化する必要があり、ポインタを使用して、新しいオブジェクトを作成し、そのオブジェクト内のcreate関数を呼び出すことで実現されます。
すべてのプログラムは文字列をコンパイルして生成されます。
このために、compile、compile_file、compile_stringという3つの関数があります。
また、キャスト演算子を使用することもできます。
==や！=を使用することで、2つのプログラムが同じかどうかを確認できます。
また、p[args]やp->identifierのような演算子や関数も重要です。
プログラムはデータを保存する場所を持たず、どのようにデータを保存するかを示しているだけであるため、データを保存するにはオブジェクトが必要です。
オブジェクトは、プログラムから複製されたメモリのチャンクであり、複数のオブジェクトを1つのプログラムから作成できます。
各オブジェクトには、独自の変数があり、そのオブジェクト内の関数がこれらの変数で操作を実行します。
オブジェクト指向プログラミングは非常に柔軟で、データの保存方法を変更しても、オブジェクトの外部に変更を加える必要はありません。
オブジェクトの文字列によるインデックス化で、文字列がオブジェクト内の関数名である場合、関数が返されます。
しかし、その名前にもかかわらず、関数は実際には関数ポインターです。関数ポインターは、他のデータ型と同じように渡すことができます。
関数ポインターは、関数名を引数として受け取り、その関数が指し示すオブジェクトと、その関数を実行するための関数ポインターを返す関数も存在します。
また、関数内で別の関数を定義するために lambda キーワードを使用することもできます。
Pike では関数のオーバーロードはできません。関数ポインターには、関数の呼び出しや関数名の取得、関数が定義されたオブジェクトの取得などの機能があります。
コンパイル時の型には、「void」と「mixed」の2つの型があります。
「void」は、値の存在またはオプション性を示すために使用されます。関数の戻り値として使用されることが多く、関数が値を返さないことを示します。また、関数パラメータの型セットの1つとして使用されることがあり、その場合は、呼び出し元がそのパラメータを省略することができ、その場合は特殊な値UNDEFINEDにデフォルトで設定されます。
「mixed」は、任意の型の値を渡すことができ、実際のランタイムで使用される値の型が完全に不明であることを示すために使用されます。この型は、コンテナクラスを実装する場合（クラス内のコードで実際の値が操作されない場合）、または実際のコンパイル時の型が複雑になりすぎた場合の便宜的なフォールバックとして使用されます。
また、基本型をパラメーターで指定して基本型をサブタイプ化するか、タイプユニオン演算子（|）を使用して複数の代替型を指定することで、より特定のコンパイル時の型を構築することができます。ただし、実行時の型は宣言されたコンパイル時の型と異なる場合があるため、注意が必要です。
変数を宣言する際には、変数がどの種類の変数であるかを指定する必要があります。intやstringなどの多くのタイプに対しては、非常に簡単に指定できます。しかし、より興味深い変数の宣言方法があります。
いくつかの例を見てみましょう。
int x;           // xは整数です
int|string x;    // xは文字列または整数です
array(string) x; // xは文字列の配列です
array x;         // xはmixedの配列です
mixed x;         // xはどのタイプでもかまいません
string *x;       // xは文字列の配列です
// xはintからstringへのマッピングです
mapping(string:int) x;
// xはStdio.Fileを実装しています
Stdio.File x;
// xはStdio.Fileを実装しています
object(Stdio.File) x;
// xは2つの整数引数を取り、文字列を返す関数です
function(int,int:string) x;
// xは何個でもの整数引数を取り、何も返さない関数です。
function(int...:void) x;
// xは...複雑です
mapping(string:function(string|int...:mapping(string:array(string)))) x;
これらの例を見ると、型を指定する興味深い方法があることがわかります。
以下は可能なもののリストです。
mixed
これは、変数が任意のタイプを含んでいること、または関数が任意の値を返すことを意味します。
array(type)
これは、タイプtypeの要素の配列を意味します。
mapping(key type: value type)
これは、キーがkey typeで値がvalue typeであるマッピングです。
multiset(type)
これは、タイプtypeの値を含むマルチセットを意味します。
object(program)
これは、指定されたプログラムを「実装」するオブジェクトを意味します。プログラムはクラス、定数、または文字列であることができます。プログラムが文字列である場合、最初にプログラムにキャストされます。このキャストについての詳細については、inheritのドキュメントを参照してください。コンパイラは、このオブジェクトでアクセスされるすべての関数または変数について、その関数または変数がプログラムで持つ型情報と同じであると仮定します。
program
これも「programを実装するオブジェクト」を意味します。programはクラスまたは定数であることができます。
Pikeコードはコンパイラに送信される前に、プリプロセッサを経由します。
プリプロセッサは、ソースコードをPike内部表現に変換し、いくつかのシンプルな正規化と整合性チェックを実行し、プログラマがファイルに入力した「プリプロセッサディレクティブ」を実行します。
プリプロセッサディレクティブは、単純なコード生成と操作を許容する非常に単純なプログラミング言語のようなものです。
コードプリプロセッサは、Pike内でcpp呼び出しによって呼び出すことができます。
プリプロセッサは、ファイルの文字エンコーディングを決定する必要があるため、最初に2つのバイトを調べ、この表に従って解釈します。
バイト0とバイト1の組み合わせに対して、その他のバイトについては、#charsetディレクティブが見つかるまでiso-8859-1エンコーディングとして扱われます。
EBCDICで書かれたプログラムで#charsetディレクティブが省略されている場合はエラーになります。#charsetディレクティブをエンコードすることも可能です。
プリプロセッサは、文字列以外の連続した空白文字を改行以外は単一の空白文字に変換し、すべての//や/***/コメント、#!行を削除します。
PikeはANSI/DECエスケープシーケンスを空白として扱います。
defineディレクティブは、マクロや定数を定義するために最も使用されるプリプロセッサの機能の1つです。
ifdefおよび#ifndefで使用できる定義が存在することを示すことができます。
定義に特定の値を設定することもでき、この値はソースコード内の定義が置かれた場所に挿入されます。
マクロには最大254個の引数があります。
Pikeはオブジェクト指向プログラミング（OOP）をサポートしており、PikeのOOP機能を使うことでプログラムのモジュール化や再利用性の向上が可能になります。
クラスはオブジェクトの設計図であり、オブジェクトはそのクラスの実体です。クラスは、そのクラスが持つ属性（フィールド）と操作（メソッド）を定義します。オブジェクトは、そのクラスが持つ属性の値と、そのクラスが定義する操作を実行することができます。
この例では、クラス定義の例として、人物のクラスが作成されています。クラス定義は、classキーワードで始まり、波括弧 { } で囲まれたメンバ変数とメソッドの定義を含みます。
[http://tpcg.io/_12ZTNX person.pike]:
class person {
  string name;
  int age;
  void create(string n, int a) {
    name = n;
    age = a;
  }
  void say_hello() { write("Hello, I'm " + name + ".\n"); }
}
int main() {
  person john = person("John", 30);
  
  john->say_hello();
  write("%s is %d year(s) old.\n", john->name, john->age);
  return 0;
}
クラスのメンバ変数は、各オブジェクトに1つずつ存在します。この例では、人物の名前を表す文字列型の変数nameと年齢を表す整数型の変数ageが定義されています。
メソッドは、クラスのオブジェクトに適用できる機能を記述します。この例では、say_helloというメソッドが定義されています。このメソッドは、"Hello, I'm 名前."というメッセージが表示します。
クラスのオブジェクトは、クラス名を呼び出し可能な関数のように使用されます。例えば、john->say_hello();は、johnオブジェクトのsay_helloメソッドを呼び出します。
この例では、createという特別なメソッドが定義されています。このメソッドは、オブジェクトをクローンする際に指定した引数を処理します。
このメソッドは、C++プログラマーがコンストラクタと呼ぶものに相当します。
この例では、クラスにdestroyというメソッドが定義されていませんが、このメソッドを定義することもできます。
このメソッドは、オブジェクトが消える直前に実行されるもので、C++プログラマーがデストラクタと呼ぶものに相当します。
ただし、Pikeは自動ガベージコレクションを備えているため、C++ほどは頻繁にデストラクタが必要になることはありません。
Pikeのクラスは、単なる構造体としても使用できます。例えば、上記のコードの
  write("%s is %d year(s) old.\n", john->name, john->age);
john->name, john->ageのようにインスタンス->メンバ変数の構文でインスタンスのメンバ変数を参照できます。
次の例では、クラスの配列を作りメンバ変数をフリーハンドに扱っています。
address_book.pike:
class address_book_entry {
  string name;
  string address;
  string phone_number;
}
int main() {
  array(address_book_entry) address_book = ({ });
  address_book_entry alice = address_book_entry();
  alice->name = "Alice";
  alice->address = "123 Main St, Anytown USA";
  alice->phone_number = "555-1234";
  address_book_entry bob = address_book_entry();
  bob->name = "Bob";
  bob->address = "456 Elm St, Anytown USA";
  bob->phone_number = "555-5678";
  
  address_book += ({ alice, bob });
  foreach(address_book, address_book_entry entry) {
    write("Name: %s,\tAddress: %s,\tPhone Number: %s\n",
      entry->name,
      entry->address,
      entry->phone_number);
  }
  
  return 0;
}
このコードは、住所録の項目を表すための address_book_entry というクラスを定義し、そのクラスを使用して住所録を作成しています。
まず、address_book_entry クラスは、名前、住所、電話番号の3つのメンバ変数を持っています。
そして、main 関数では、まず空の住所録を表す配列 address_book を作成します。
次に、address_book_entry クラスから2つのエントリー alice と bob を作成し、それぞれの名前、住所、電話番号を設定します。
そして、これらのエントリーを address_book 配列に追加します。
最後に、foreach ループを使用して、address_book 配列に含まれるすべてのエントリーを出力します。
各エントリーの情報は、write 関数を使用して整形され出力されます。
このコードを実行すると、以下のような出力が得られます：
Name: Alice,	Address: 123 Main St, Anytown USA,	Phone Number: 555-1234
Name: Bob,	Address: 456 Elm St, Anytown USA,	Phone Number: 555-5678
 
これは、2つのエントリーが正常に作成され、住所録に追加され、正常に出力されていることを示しています。
Pikeにおいて、プログラムとクラスは同じであることが驚くかもしれません。つまり、Pikeではプログラムとクラスは同義語として使用されることがあります。
ファイル内のPikeプログラムはクラス定義であり、ファイルで定義されたメソッドはそのクラスのメソッドであり、グローバル変数（つまり、メソッドの外で定義された変数）はメンバ変数です。必要であれば、ファイル内のコードに暗黙的に「class {}」があると想像できます。
ただし、細かいクラスごとにそれぞれのファイルを用意しなければならないとなると面倒になるので、「class {}」の表記も用意されています。
person.pike:
string name;
int age;
void create(string n, int a) {
  name = n;
  age = a;
}
void say_hello() { write("Hello, I'm " + name + ".\n"); }
見覚えがあるコードですが、class { } で囲まれていませんね。
Pikeのクラスとプログラムの関係は特異的ですが、類例としてはZigの構造体とプログラムの関係があります。
複素数は実数部と虚数部から成る数の形式ですが、Pikeには組み込みの複素数型がないため、独自のクラスを作成しました。
complex クラスは、実数部と虚数部をメンバ変数として持ち、加算、減算、乗算などの操作を行う演算子を提供しています。また、絶対値や文字列化も実装されています。
[http://tpcg.io/_O0WQDM complex.pike]:
class complex {
    private float _real = 0.0;
    private float _imag = 0.0;
    
    float `real() { return _real; }
    float `imag() { return _imag; }
    void create(mixed real, mixed ... rest) {
        this::_real = (float) real;
        this::_imag = sizeof(rest) ? (float)rest[0] : 0.0;
    }
    // 加算メソッド
    complex `+(complex other) {
        return complex(real + other.real, imag + other.imag);
    }
    mixed ``+(mixed arg) { return complex((float)arg + real, imag); }
    // 減算メソッド
    complex `-(complex other) {
        return complex(real - other.real, imag - other.imag);
    }
    mixed ``-(mixed arg) { return complex((float)arg - real, -imag); }
    // 乗算メソッド
    complex `*(complex other) {
        float r = real * other.real - imag * other.imag;
        float i = real * other.imag + imag * other.real;
        return complex(r, i);
    }
    mixed ``*(mixed arg) {
        arg = (float)arg;
        return complex(arg * real, arg * imag);
    }
    // 絶対値
    float `abs() {
        return sqrt(real * real + imag * imag);
    }
    // 文字列化
    string _sprintf() {
        if (imag == 0.0)
            return sprintf("%O", real);
        if (real == 0.0)
            return sprintf("%Oi", imag);
        if (imag < 0.0)
            return sprintf("(%O - %Oi)", real, -imag);
        return sprintf("(%O + %Oi)", real, imag);
    }
}
int main() {
    complex c1 = complex(3.0, 4.0);
    complex c2 = complex(1.5, -1.0);
    write("complex(999.0, 0.0) = %O\n", complex(999.0, 0.0));
    write("complex(0.0, 999.0) = %O\n", complex(0.0, 999.0));
    write("complex(0.0, 0.0) = %O\n", complex(0.0, 0.0));
    write("%O->real = %O\n", c1, c1->real);
    write("%O->imag = %O\n", c1, c1->imag);
    write("%O + %O = %O\n", c1, c2, c1 + c2);
    write("%O - %O = %O\n", c1, c2, c1 - c2);
    write("%O * %O = %O\n", c1, c2, c1 * c2);
    write("%O.abs = %O\n", c1, c1->abs);
    
    complex i = complex(0.0, 1.0);
    foreach (({ 3.0, 1, -2, "123" }), mixed x) {
        write("\ncomplex(%O) = %O\n", x, complex(x));
        write("\t%O + %O = %O\n", x, i, x + i);
        write("\t%O - %O = %O\n", x, i, x - i);
        write("\t%O * %O = %O\n", x, i, x * i);
    }
    
    return 0;
}
実行結果:
complex(999.0, 0.0) = 999.0
complex(0.0, 999.0) = 999.0i
complex(0.0, 0.0) = 0.0
(3.0 + 4.0i)->real = 3.0
(3.0 + 4.0i)->imag = 4.0
(3.0 + 4.0i) + (1.5 - 1.0i) = (4.5 + 3.0i)
(3.0 + 4.0i) - (1.5 - 1.0i) = (1.5 + 5.0i)
(3.0 + 4.0i) * (1.5 - 1.0i) = (8.5 + 3.0i)
(3.0 + 4.0i).abs = 5.0
complex(3.0) = 3.0
	3.0 + 1.0i = (3.0 + 1.0i)
	3.0 - 1.0i = (3.0 - 1.0i)
	3.0 * 1.0i = 3.0i
complex(1) = 1.0
	1 + 1.0i = (1.0 + 1.0i)
	1 - 1.0i = (1.0 - 1.0i)
	1 * 1.0i = 1.0i
complex(-2) = -2.0
	-2 + 1.0i = (-2.0 + 1.0i)
	-2 - 1.0i = (-2.0 - 1.0i)
	-2 * 1.0i = -2.0i
complex("123") = 123.0
	"123" + 1.0i = (123.0 + 1.0i)
	"123" - 1.0i = (123.0 - 1.0i)
	"123" * 1.0i = 123.0i
このPikeのコードは、complex（複素数）クラスを定義し、複素数の演算や機能を実装しています。以下に各部分の解説をします。
まず、complexクラスの定義です。クラス内で使用されるプライベートな変数 _real と _imag が定義されています。
また、`real() メソッドと `imag() メソッドが定義され、それぞれ _real と _imag の値を返します。
次に、create() メソッドが定義されています。このメソッドは、コンストラクタの役割を果たします。
可変長引数を受け取り、最初の引数を実部 _real に、残りの引数（もし存在する場合）を虚部 _imag に代入します。
 
加算、減算、乗算の演算子メソッドが定義されています。例えば、+演算子に対して complex クラスのインスタンスとの加算を行うと、実部と虚部をそれぞれ足した結果の新しい complex インスタンスが返されます。また、+演算子に対して mixed 型（異なる型の加算も許容する）の引数を受け取る場合は、引数を実部として足し合わせた新しい complex インスタンスが返されます。
 
`absメソッドは、複素数の絶対値を返すためのメソッドです。絶対値は実部の二乗と虚部の二乗の和の平方根として計算されます。
_sprintf メソッドは、複素数を文字列として表示するためのフォーマットを提供します。
最後に、main 関数では、complexクラスのオブジェクトを作成し、それらの各メソッドを呼び出しています。
また、foreachループを使って、配列の各要素について complex オブジェクトを作成し、それらの加算、減算、乗算を計算しています。
継承は、既存のクラスを基盤として、新しいクラスを作成することができる仕組みです。継承により、既存のクラスのすべてのフィールドとメソッドを新しいクラスに引き継ぐことができます。また、新しいクラスには、継承元のクラスには存在しないフィールドやメソッドを追加することができます。これにより、より特化したクラスを作成することができます。
Pikeでは、クラス継承はinheritキーワードを使用して宣言されます。継承元のクラスは、inheritキーワードの後に指定されます。
図形を例にクラスの継承を解説します。
[http://tpcg.io/_QJLFP5 inherit.pike]:
class point(int x, int y) {
  point move(int dx, int dy) {
    x += dx;
    y += dy;
    write("point::move\n");
    return this;
  }
  
  string _sprintf() {
    return sprintf("point(%d, %d)", x, y);
  }
}
class shape {
  point location;
  void create(int x, int y) {
    location = point(x, y);
    write("shape::constructor\n");
  }
  shape move(int x, int y) {
    location.move(x, y);
    write("shape::move\n");
    return this;
  }
  
  string _sprintf() {
    return sprintf("location: %s", location->_sprintf());
  }
}
class rectangle {
  inherit shape;
  int width;
  int height;
  void create(int x, int y, int width, int height) {
    ::create(x, y);
    this.width = width;
    this.height = height;
    write("rectangle::constructor\n");
  }
  
  string _sprintf() {
    return sprintf("rectangle { %s, width: %d, height: %d }",
      ::_sprintf(), width, height);
  }
}
int main() {
  write("Create a rectangle!\n");
  rectangle rct = rectangle(12, 32, 100, 50);
  write("rct = %O\n", rct);
  rectangle rct2 = rectangle(1, 2, 10, 150);
  write("rct = %O\n", rct);
  write("rct2 = %O\n", rct2);
  return 0;
}
まず、pointクラスが定義されています。このクラスは2次元の座標を表します。コンストラクタでx座標とy座標を受け取り、その値を保持します。moveメソッドは、座標を指定した量だけ移動させるためのメソッドです。内部でx座標とy座標を更新し、移動したことを表示します。また、_sprintfメソッドは、オブジェクトの文字列表現を返すための特殊なメソッドです。
次に、shapeクラスが定義されています。このクラスは図形を表すための基本クラスです。shapeクラスはpointオブジェクトを保持しており、その位置を表します。createメソッドは、指定された座標に新しいpointオブジェクトを作成し、locationに代入します。moveメソッドは、locationの座標を指定した量だけ移動させるためのメソッドです。内部でpointオブジェクトのmoveメソッドを呼び出しています。また、_sprintfメソッドは、オブジェクトの文字列表現を返すための特殊なメソッドです。
最後の、rectangleクラスが定義されています。このクラスはshapeクラスを継承しており、矩形を表します。createメソッドでは、親クラスのcreateメソッドを呼び出して位置を設定し、さらに幅と高さも設定します。_sprintfメソッドでは、親クラスの_sprintfメソッドを呼び出して親クラスの情報を表示し、それに続けて矩形固有の情報である幅と高さも表示します。
main関数では、実際にrectangleオブジェクトを作成し、操作結果を表示しています。最初にrctという名前の矩形オブジェクトを作成し、その次にrct2という別の矩形オブジェクトを作成しています。各オブジェクトの情報を表示しています。
時には、2つまたはそれ以上のクラスから継承したい場合があります。これはPike（およびC++）で動作しますが、Javaでは動作しません。ただ、複数の継承を記述すれば良いです。
class B {
  ...
}
class C {
  ...
}
class D {
  inherit B;
  inherit E;
}
の例では、すべてのオブジェクトのすべてのメソッドとメンバ変数に誰でもアクセスできました。
例えば、次のように年齢を減らすことが非常に簡単でした。
john->age -= 50;
あれ？このjohnの年齢は30歳で、今はマイナス20歳になっている？
他のクラスからその変数に触れないように、メンバ変数 age へのアクセスを制御したいと思います。
このような用途のために、メソッドまたはメンバ変数の定義で、データ型の前に書かれるいくつかのアクセス修飾子があります。
例えば、人物の年齢はメンバ変数 age によって表されます。
int age;
これを変更して、
private int age;
とすると、同じクラス内のメソッドのみがその変数にアクセスできるようになります。
次のアクセス修飾子が存在します。
public:これがデフォルトで、任意のメソッドがメンバ変数にアクセスしたり、メソッドを呼び出したりできます。
private:メンバ変数またはメソッドが、同じクラス内のメソッドのみで利用可能であることを意味します。
static:このメンバ変数またはメソッドは、同じクラス内のメソッドおよびサブクラスのメソッドのみが使用できます（Pikeの static は、C++の static とまったく同じ意味ではなく、代わりに C++の protected に似ています）。
local:このメソッドがサブクラスのメソッドによってオーバーライドされていても、このクラスのメソッドはこのメソッドを使用し続けます。
final:サブクラスがこのメソッドを再定義できないようにします。
クラスにコンストラクタ（つまり、create という名前のメソッド）がある場合、これを static に宣言することが良いアイデアです。
それはオブジェクトの構築中にのみ呼び出されるべきであり、static でない場合、継承に関連するいくつかの型の不整合が生じる可能性があります。
Pikeでは、ファイルI/Oに Stdio オブジェクトを使います。
int main() {
    constant fname = "/etc/hosts";
    string|int buff = Stdio.read_file(fname);
    if (intp(buff)) {
        Stdio.perror(fname);
        return 1;
    }
    write(buff);
    return 0;
}
このPikeのコードは、ファイル "/etc/hosts" を読み込み、その中身を標準出力に出力するプログラムです。
まず、string型の変数 fname に "/etc/hosts" というファイルのパスを代入しています。次に、Stdio モジュールの read_file() 関数を使って、fname に指定されたファイルを読み込んでいます。読み込んだ結果は、string|int型の変数 buff に代入されます。
string|int 型とは、string 型または int 型のいずれかの値が代入可能な型です。これは read_file() 関数が、ファイルの読み込みに成功した場合はファイルの内容を string 型で返し、失敗した場合は 0 を返すためです。エラーが発生した場合、intp() 関数を使って buff の型が int 型であることを確認し、Stdio.perror() 関数を使ってエラーの詳細を標準エラー出力に出力した後、プログラムは終了します。
読み込みに成功した場合、write() 関数を使って、buff の内容を標準出力に出力します。最後に、プログラムは終了します。
このコードは、システムファイル "/etc/hosts" の中身を表示するために使用されます。ただし、root権限が必要な場合があるため、注意が必要です。
int main() {
    constant fname = "sample.txt";
    int cnt;
    int|array err = catch {
       cnt = Stdio.write_file(fname, "TEST TEXT");
    };
    if (arrayp(err)) {
        write(err[0]);
        return 2;
    }
    string|int buff = Stdio.read_file(fname);
    if (intp(buff)) {
        Stdio.perror(fname);
        return 1;
    }
    write(buff);
    return 0;
}
このプログラムは、ファイルの書き込みと読み込みを行い、それが正常にできたかどうかをチェックします。
まず、main()関数が定義されています。
次に、string fname = "sample.txt";でファイル名を指定し、int cnt;で書き込んだバイト数を格納する変数を宣言します。
また、エラーが発生した場合のエラーメッセージを格納する変数int|array errを宣言しています。
この変数は、catchによって例外が発生した場合に、理由とスタックトレースが格納されます。
catchのブロック内では、Stdio.write_file関数を使用して、指定されたファイルにテキストを書き込みます。
catchブロックの外側で、arrayp関数を使用して、err変数の型が配列であるかどうかをチェックします。
もし配列であれば、エラーメッセージを出力し、return 2;でプログラムを終了します。
次に、string|int buff = Stdio.read_file(fname);で、指定されたファイルからテキストを読み込んで、読み込んだテキストをstring型の変数buffに格納します。
もし読み込みに失敗した場合は、intp関数を使用して、buff変数の型が整数型であるかどうかをチェックします。
整数型であれば、Stdio.perror(fname);でエラーメッセージを出力し、return 1;でプログラムを終了します。
最後に、読み込んだテキストをwrite(buff);で出力し、return 0;でプログラムを正常に終了します。
array __attribute__ auto break case catch class constant continue default __deprecated__ do else enum extern final float for foreach __func__ function gauge global if import inherit inline int lambda local mapping mixed multiset object optional predef private program protected public return sscanf static _Static_assert string switch typedef typeof __unknown__ __unused__ variant void __weak__ while
エラトステネスの篩を、若干 Pike らしく書いてみました。
エラトステネスの篩:
// eratosthenes関数はエラトステネスの篩を使ってnまでの素数を見つけます。
array(int) eratosthenes(int n) {
    // sieve配列を初期化し、全ての数を素数と仮定します。
    array sieve = allocate(n + 1, true);
    sieve[0] = false;  // 0は素数ではない
    sieve[1] = false;  // 1は素数ではない
    // エラトステネスの篩を実行します。
    foreach (sieve; int i; int prime) {
        if (prime) {
            // 素数iの倍数を篩い落とします。
            for (int j = i * i; j < sizeof(sieve); j += i) {
                sieve[j] = false;
            }
        }
    }
    // 素数を抽出します。
    array(int) primes = ({});
    foreach (sieve; int i; mixed prime) {
        if (prime) {
            primes += ({ i });
        }
    }
    return primes;
}
int main() {
    // eratosthenes関数を使って100までの素数を求めます。
    array(int) primes = eratosthenes(100);
    // 結果を出力します。
    foreach (primes, int prime)
        write(prime + " ");
    write("\n");
}
実行結果:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 
最大公約数と最小公倍数を、若干 Pike らしく書いてみました。
int gcd2(int m, int n) { return n == 0 ? m : gcd2(n, m % n); }
int gcd(int ... ints) {
    return Array.reduce(lambda(int x, int y){ return gcd2(x, y); }, ints); 
}
int lcm2(int m, int n) { return m * n / gcd2(m, n); }
int lcm(int ... ints) { 
    return Array.reduce(lambda(int x, int y){ return lcm2(x, y); }, ints); 
}
int main() {
    write("gcd2(30, 45) => %O\n", gcd2(30, 45));
	write("gcd(30, 72, 12) => %O\n", gcd(30, 72, 12));
	write("lcm2(30, 72) => %O\n", lcm2(30, 72));
	write("lcm(30, 42, 72) => %O\n", lcm(30, 42, 72));
	
	return 0;
}
実行結果:
gcd2(30, 45) => 15
gcd(30, 72, 12) => 6
lcm2(30, 72) => 360
lcm(30, 42, 72) => 2520
二分法を、若干 Pike らしく書いてみました。
二分法:
// bisectionは関数fが0に等しくなる実数xを二分法で検索します。
// lowとhighは関数fの値が0より小さい範囲の下限と上限です。
// xは現在の中点です。
// fxは関数fのxの値です。
float bisection(float low, float high, function(float:float) f) {
    float x = (low + high) / 2.0;
    float fx = f(x);
    if (abs(fx) < 1.0e-10)
        return x;
    if (fx < 0.0)
        low = x;
    else
        high = x;
    return bisection(low, high, f);
}
int main(){
  write("%.16f\n", bisection(0.0, 3.0, lambda(float x) { return x - 1.0; }));
  write("%.16f\n", bisection(0.0, 3.0, lambda(float x) { return x*x - 1.0; }));
}
実行結果:
0.9999999999417923
1.0000000000291038
旧課程(-2012年度)高等学校数学B/数値計算とコンピューター#2分法の例を Pike に移植しました。
Pikeに関する情報やリソースを見つけることは、他の一般的なプログラミング言語と比較して少ないかもしれませんが、いくつかの有用なリソースがあります。
以下は、Pikeに関する情報を見つけるためのいくつかのリソースです：
Pike 公式ウェブサイト: 
Pike言語の公式ウェブサイトには、言語のドキュメントやチュートリアル、リファレンスが提供されています。また、最新のリリースやコミュニティに関する情報も入手できます。
Pikeドキュメント: 
Pikeの公式ウェブサイトには、言語のドキュメントが提供されており、言語の機能や構文に関する詳細な情報を得ることができます。
Pikeソースコードのリポジトリ: 
Pikeのソースコードはオープンソースで、GitHubのリポジトリで利用可能です。ソースコードを調査することで、言語の実装や最新の開発について学ぶことができます。