root/docs/nowelium/ioDocs/IoGuide_ja.html @ 15748

Revision 15748, 61.1 kB (checked in by nowelium, 6 years ago)
RevLine 
[8105]1<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
2<html>
3<head>
4<meta http-equiv="Content-Type" content="text/html;charset=utf-8">
[8113]5<title>Io プログラミングガイド</title>
[8105]6<META HTTP-EQUIV="EXPIRES" CONTENT=0>
7<link rel="stylesheet" href="docs.css">
8</head>
9<body>
10
[8113]11<h1>Io プログラミングガイド</h1>
[8105]12<p>
13<br>
14
15<table style="width:47em">
16<tr>
17<td valign=top style="width:33%">
18
[8425]19<div class=indexSection><a href="#Introduction">概要</a></div>
[8424]20<div class=indexItem><a href="#Introduction-Perspective">観点</a></div>
[8113]21<div class=indexItem><a href="#Introduction-Getting-Started">はじめましょう</a></div>
22<div class=indexItem><a href="#Introduction-Downloading">ダウンロード</a></div>
23<div class=indexItem><a href="#Introduction-Installing">インストール</a></div>
24<div class=indexItem><a href="#Introduction-Binaries">バイナリ</a></div>
25<div class=indexItem><a href="#Introduction-Running-Scripts">スクリプトの実行</a></div>
26<div class=indexItem><a href="#Introduction-Interactive-Mode">対話モード</a></div>
[8105]27
[8113]28<div class=indexSection><a href="#Syntax">構文</a></div>
29<div class=indexItem><a href="#Syntax-Expressions">式</a></div>
30<div class=indexItem><a href="#Syntax-Messages">メッセージ</a></div>
31<div class=indexItem><a href="#Syntax-Operators">演算子</a></div>
32<div class=indexItem><a href="#Syntax-Assignment">代入</a></div>
33<div class=indexItem><a href="#Syntax-Numbers">数値</a></div>
34<div class=indexItem><a href="#Syntax-Strings">文字列</a></div>
35<div class=indexItem><a href="#Syntax-Comments">コメント</a></div>
[8105]36
37
[8392]38<div class=indexSection><a href="#Objects">オブジェクト</a></div>
[8424]39<div class=indexItem><a href="#Objects-Overview">概略</a></div>
[8392]40<div class=indexItem><a href="#Objects-Prototypes">プロトタイプ</a></div>
41<div class=indexItem><a href="#Objects-Inheritance">継承</a></div>
42<div class=indexItem><a href="#Objects-Methods">メソッド</a></div>
43<div class=indexItem><a href="#Objects-Blocks">ブロック</a></div>
44<div class=indexItem><a href="#Objects-Forward">転送</a></div>
[14880]45<div class=indexItem><a href="#Objects-Resend">再送</a></div>
46<div class=indexItem><a href="#Objects-Super">スーパー</a></div>
[8392]47<div class=indexItem><a href="#Objects-Introspection">イントロスペクション</a></div>
[8105]48
49
50</td>
51<td valign=top style="width:33%">
52
[8392]53<div class=indexSection><a href="#Control-Flow">制御構造</a></div>
[8424]54<div class=indexItem><a href="#Control-Flow-true-false-and-nil">true, false と nil</a></div>
55<div class=indexItem><a href="#Control-Flow-Comparison">比較</a></div>
[8392]56<div class=indexItem><a href="#Control-Flow-Conditions">条件分岐</a></div>
[8424]57<div class=indexItem><a href="#Control-Flow-Loops">ループ</a></div>
[8105]58
59
[14880]60<div class=indexSection><a href="#Importing">インポート</a></div>
[8105]61
[8392]62<div class=indexSection><a href="#Concurrency">並行動作</a></div>
[8424]63<div class=indexItem><a href="#Concurrency-Coroutines">コルーチン</a></div>
64<div class=indexItem><a href="#Concurrency-Scheduler">スケジューラ</a></div>
65<div class=indexItem><a href="#Concurrency-Actors">アクタ</a></div>
66<div class=indexItem><a href="#Concurrency-Futures">Future</a></div>
[8105]67<div class=indexItem><a href="#Concurrency-Yield">Yield</a></div>
[15479]68<div class=indexItem><a href="#Concurrency-Pause-and-Resume">一時停止と再開</a></div>
[8105]69
[8392]70<div class=indexSection><a href="#Exceptions">例外</a></div>
[14880]71<div class=indexItem><a href="#Exceptions-Raise">例外の発生</a></div>
72<div class=indexItem><a href="#ExceptionsTry-and-Catch">Try と Catch</a></div>
73<div class=indexItem><a href="#Exceptions-Pass">パス</a></div>
[8424]74<div class=indexItem><a href="#Exceptions-Custom-Exceptions">カスタム例外</a></div>
[8105]75
76<div class=indexSection><a href="#Unicode">Unicode</a></div>
77<div class=indexItem><a href="#Unicode-Sequences">Sequences</a></div>
78<div class=indexItem><a href="#Unicode-Source">Source</a></div>
[8424]79<div class=indexItem><a href="#Unicode-Conversion">変換</a></div>
[8105]80
81</td>
82<td valign=top style="width:33%">
83
[8392]84<div class=indexSection><a href="#Primitives">プリミティブ</a></div>
[8424]85<div class=indexItem><a href="#Primitives-Object">オブジェクト</a></div>
86<div class=indexItem><a href="#Primitives-List">リスト</a></div>
[14880]87<div class=indexItem><a href="#Primitives-Sequence">シーケンス</a></div>
88<div class=indexItem><a href="#Primitives-Ranges">範囲</a></div>
[8424]89<div class=indexItem><a href="#Primitives-File">ファイル</a></div>
90<div class=indexItem><a href="#Primitives-Directory">ディレクトリ</a></div>
91<div class=indexItem><a href="#Primitives-Date">日付</a></div>
92<div class=indexItem><a href="#Primitives-Networking">ネットワーク</a></div>
[8105]93<div class=indexItem><a href="#Primitives-XML">XML</a></div>
[14880]94<div class=indexItem><a href="#Primitives-Vector">ベクトル</a></div>
[8105]95
[8392]96<div class=indexSection><a href="#Embedding">組み込み</a></div>
[8105]97<div class=indexItem><a href="#Embedding-Conventions">Conventions</a></div>
98<div class=indexItem><a href="#Embedding-IoState">IoState</a></div>
99<div class=indexItem><a href="#Embedding-Values">Values</a></div>
100
[8392]101<div class=indexSection><a href="#Bindings">バインディング</a></div>
[8105]102
[8424]103<div class=indexSection><a href="#Appendix">付録</a></div>
[8113]104<div class=indexItem><a href="#Appendix-Grammar">文法</a></div>
[8392]105<div class=indexItem><a href="#Appendix-Credits">協力者</a></div>
[8424]106<div class=indexItem><a href="#Appendix-References">参考</a></div>
[8113]107<div class=indexItem><a href="#Appendix-License">ライセンス</a></div>
[8105]108
109</td>
110</tr>
111</table>
112
113<p>
114
[8425]115<h2>概要<a name="Introduction"></a></h2>
[8105]116<div class=indent>
117
118<div class=quote>
[14880]119簡易性は幸福の本質である。<br>
[8105]120- Cedric Bledsoe
121</div>
122
[14880]123<blockquote class="quote">
124Simplicity is the essence of happiness.<br>
125- Cedric Bledsoe
126</blockquote>
127
[8425]128Io はプロトタイプベースの動的言語である。 その着想の大半は Smalltalk (全てがオブジェクトである)、Self[2] (プロトタイプベース), NewtonScript[3] (差分継承), Act1 (アクタとFutureによる並行動作)、Lisp[5] (コードは 検査 / 修正 可能なランタイムツリー) そして Lua[6] (小さい、組み込み可能).
[8105]129
130<a name="Introduction-Perspective"></a>
[8424]131<h3>観点</h3>
[8105]132
133
[14880]134<h4>なぜ別の言語か?</h4>
[8105]135
[14880]136ここ 30 年のプログラミング言語の研究の焦点はほとんど、Smalltalk のような高水準言語の表現力と、Cのような低級言語の性能を融合することにか注意を払うことばかりに進んできました。 その結果、一連の言語はCほど速くないかSmalltalkほど表現力豊かでないものでした。 Io の目的は、動的プログラミングのよる高いレベルでの探査によって、より大きいレベルでのランタイムの柔軟性、および、単純化されたプログラミングの文法と意味による、表現の豊さに再び焦点を当てることでです。
[8105]137
138<p>
139
[14880]140Io は 全ての値はオブジェクト (継承されたメソッド、スロットを含んでいる場合でも、 何でもランタイムに変更可能)、 全てのコードは式 (それはランタイムに操作、変更可能) であり、 全ての式は動的なメッセージを送信 (代入と制御構造を含む)することで成り立っています。 実行コンテキストは、オブジェクトの集まりとメソッド / ブロックによる活性可能なオブジェクト、そしてブロックによる代入可能なスコープに統一された関数だけです。 並行処理は、アクターとスケーラビリティの為にコルーチンを通して、より簡単に操作しやすく作られています。
[8105]141
[14880]142<h4>目標</h4>
[8105]143
[14880]144言語であるために:
[8105]145<p>
146
[14880]147シンプル
[8105]148<ul>
[14880]149<li>概念的にシンプルかつ整合的
150<li>簡単な組み込みと拡張
[8105]151</ul>
[14880]152パワフル
[8105]153<ul>
[14880]154<li>高度なダイナミック性と イントロスペクト(内部構造の検索)
155<li>高度な並行操作(コルーチンおよび非同期 I/O による)
[8105]156</ul>
[14880]157実用的
[8105]158<ul>
[14880]159<li>十分に速い
160<li>マルチプラットフォーム
161<li>非限定的(unrestrictive)な BSD/MIT ライセンス
162<li>広範囲なディストリビューションに渡る標準的なパッケージ
[8105]163</ul>
164
165</div>
166
[8113]167<h2>はじめましょう<a name="Introduction-Getting-Started"></a></h2>
[8105]168<div class=indent> 
169
170<a name="Introduction-Downloading"></a>
[8113]171<h3>ダウンロード</h3>
[8105]172
[8424]173Io の配布は以下から取得できます:
[8105]174<pre>
175<a href="http://iolanguage.com">http://iolanguage.com</a>
176</pre>
177
178<a name="Introduction-Installing"></a>
[8113]179<h3>インストール</h3>
[8105]180
181<h4>VM</h4>
182
[8113]183最初に Io vm をコンパイルします:
[8105]184
185<pre>
186make vm
187sudo make install
188</pre>
189
190
[8424]191<h4>アドオンが依存するライブラリのインストール</h4>
[8105]192
[8424]193いくつかの Io のアドオンは既にあなたのシステム上にインストールされているライブラリを必用とするかもしれません。 それらを自動的にインストールするのは次をタイプしてください:
[8105]194
195<pre>
196su -c "sudo make aptget"
197</pre>
198
[8113]199または:
[8105]200
201<pre>
202su -c "make emerge"
203</pre>
204
[8113]205または:
[8105]206
207<pre>
208sudo make port
209</pre>
210
[8424]211あなたの使用しているパッケージインストーラによって使い分けでください。
[14880]212(<a href="http://macports.org">port</a> is for OSX)
[8105]213
[8113]214<h4>アドオンのコンパイル</h4>
[8105]215
[8424]216ビルドをするには、トップディレクトリで以下を実行:
[8105]217
218<pre>
219make
220</pre>
221
[8424]222バイナリはサブフォルダ _build/binaries に置かれるでしょう。 インストールするには:
[8105]223
224<pre>
225sudo make install
226</pre>
227
[8424]228もしくは、インストールを、単にあなたの開発用フォルダにリンクするようにするには:
[8105]229
230<pre>
231sudo make linkInstall
232</pre>
233
[8424]234そしてすべてのユニットテストを実行するには:
[8105]235
236<pre>
237make test
238</pre>
239
[15748]240いくつかのアドオンがビルドできなくても、そのアドオンがあなたが特別必用としていないなら、それは心配しなくても大丈夫です。 アドオンは任意のライブラリです。
[8105]241
[8424]242<h4>ノート</h4>
[8105]243
[8424]244特定のアドオンのみ make するには、以下のようにしてください:
[8105]245
246<pre>
247make AddonName
248</pre>
249
[8424]250ソースコントロール上のリポジトリから取得してきた後は、必ずしてください:
[8105]251
252<pre>
253make clean; make
254</pre>
255
[8424]256VM のテストのみ実行:
[8105]257
258<pre>
259make testvm
260</pre>
261
[8425]262<a name="Introduction-Binaries"></a>
[8113]263<h4>バイナリ</h4>
[8105]264
[8425]265Io は2つの実行可能形式をビルドし、binaries フォルダに配置します。 それらは以下:
[8105]266
267<pre>
268io_static
269io
270</pre>
271
[15748]272io_static は最小量のセットの基本関数が静的にすべてリンクされている vm を含んでいる実行可能な形式です。 io は実行時に、iovm が動的にリンクされたライブラリをロードすることができます。それは、io のアドオンが参照されたときに動的に組み込まれます。
[8105]273
274
275<a name="Introduction-Running-Scripts"></a>
[8113]276<h3>スクリプトの実行</h3>
[8105]277
[8424]278スクリプトを実行する例:
[8105]279
280<pre>
281io samples/HelloWorld.io
282</pre>
283
[8424]284Io が最初に実行するものに、どんな main() 関数やオブジェクトも必要ありません。 スクリプトはコンパイルされると実行されます。
[8105]285
286<a name="Introduction-Interactive-Mode"></a>
[8113]287<h3>対話モード</h3>
[8105]288
[8424]289実行:
[8105]290
291<pre>
292./_build/binaries/io
293</pre>
294
[8424]295もし Io がインストール済みなら、以下のように実行:
[8105]296
297<pre>
298io
299</pre>
300
[8425]301Io のインタプリタのプロンプトが引かれるでしょう。
[8105]302<p>
[8424]303直接入力する事で、コードを評価することができます。 例:
[8105]304
305<pre>
306Io> "Hello world!" println
307==> Hello world!
308</pre>
309
[8424]310式は Lobby のコンテキストにて評価される :
[8105]311
312<pre>
313Io> print
[8425]314[lobby のコンテンツが出力される]
[8105]315</pre>
316
[8424]317あなたのホームフォルダに .iorc が存在する場合、対話モードのプロンプトが開始される前にそれが評価されます。
[8105]318
319
[8424]320<h4>オブジェクトのインスペクト</h4>
[8105]321
[8424]322このようにしてオブジェクトのスロットのリストを取得することができます:
323
[8105]324<pre>
325Io> someObject slotNames
326</pre>
327
[8424]328それらをソート順にするには:
[8105]329
330<pre>
331Io> someObject slotNames sort
332</pre>
333
[8424]334オブジェクトの記述がうまくフォーマットされた形式においては slotSummary メソッドが便利です:
[8105]335
336<pre>
337Io> slotSummary
338==>  Object_0x20c4e0:
339  Lobby            = Object_0x20c4e0
340  Protos           = Object_0x20bff0
341  exit             = method(...)
342  forward          = method(...)
343</pre>
344
345Exploring further:
346
347<pre>
348Io> Protos
349==>  Object_0x20bff0:
350  Addons           = Object_0x20c6f0
351  Core             = Object_0x20c4b0
352
353Io> Protos Addons
354==>  Object_0x20c6f0:
355  ReadLine         = Object_0x366a10
356</pre>
357
[15748]358他の Addons が組み込まれていないので、RadLine だけが Addons に表示されています。
[8105]359<p>
[15748]360メソッドをインスペクトすると、その時のバージョンで逆コンパイルされたものが表示されるでしょう:
[8105]361
362<pre>
363Io> Lobby getSlot("forward")
364==> # io/Z_Importer.io:65
365method(
366    Importer import(call)
367)
368</pre>
369
[8424]370<h4>doFile と doString</h4>
[8105]371
[8424]372対話モードにて doFile メソッドを使用すると、スクリプトを実行することができる:
[8105]373
374<pre>
375doFile("scriptName.io")
376</pre>
377
[8424]378doFile はレシーバのコンテキストにて評価します。(この場合レシーバは lobby でしょう)。 他のオブジェクトのコンテキストにてスクリプトを評価するには、 doFile メッセージをそれに送信します:
[8105]379
380<pre>
381someObject doFile("scriptName.io")
382</pre>
383
[8424]384文字列を評価するには doString メソッドを使用することができます:
[8105]385
386<pre>
387Io> doString("1+1")
388==> 2
389</pre>
390
[8424]391また、特定のオブジェクトのコンテキストで文字列を評価するには:
[8105]392
393<pre>
394someObject doString("1 + 1")
395</pre>
396
[8392]397<h4>コマンドライン引数</h4>
[8105]398
[8392]399コマンドライン引数を出力する例:
[8105]400
401<pre>
402args foreach(k, v, write("'", v, "'\n"))
403</pre>
404
405<h4>launchPath</h4>
406
[8425]407System の &quot;launchPath&quot; スロットには、実行された最初のソースファイルの位置が格納されている。
[8105]408
409</div>
[8176]410<h2>構文<a name="Syntax"></a></h2>
[8105]411<div class=indent>
412
413<div class=quote>
[15748]414より少ないことは、より豊かなこと<br>
415- Ludwig Mies van der Rohe
416</div>
417
418<div class=quote>
[8105]419Less is more.<br>
420- Ludwig Mies van der Rohe
421</div>
422
423<a name="Syntax-Expressions"></a>
[8176]424<h3>式</h3>
[8105]425
[8425]426Io キーワードや文を持たない。 すべてが完全なメッセージで構成された式であり、そのそれぞれがランタイムにアクセス可能なオブジェクトである。 非公式の BNF 記述:
[8105]427
428<pre>
429exp        ::= { message | terminator }
430message    ::= symbol [arguments]
431arguments  ::= "(" [exp [ { "," exp } ]] ")"
432symbol     ::= identifier | number | string
433terminator ::= "\n" | ";"
434</pre>
435
436For performance reasons, String and Number literal messages have their results cached in their message objects.
437
438<a name="Syntax-Messages"></a>
[8176]439<h3>メッセージ</h3>
[8105]440
[8425]441メッセージ引数はレシーバに式として渡され評価される。 引数の評価の選択は制御構造を実装するために使用できる 例:
[8105]442
443<pre>
444for(i, 1, 10, i println)
445a := if(b == 0, c + 1, d)
446</pre>
447
[8425]448上記コードでの、&quot;for&quot; と &quot;if&quot; は通常のメッセージであり、特殊形式やキーワードでは無い。
[8105]449<p>
450
[8176]451Likewise, dynamic evaluation can be used with enumeration without the need to wrap the expression in a block. 例:
[8105]452
453<pre>
454people select(person, person age < 30)
455names := people map(person, person name)
456</pre>
457
458Methods like map and select will typically apply the expression directly to the values if only the expression is provided:
459
460<pre>
461people select(age < 30)
462names := people map(name)
463</pre>
464
465There is also some syntax sugar for operators (including assignment), which are handled by an Io macro executed on the expression after it is compiled into a message tree. Some sample source code:
466
467<pre>
468Account := Object clone
469Account balance := 0
470Account deposit := method(amount,
471    balance = balance + amount
472)
473
474account := Account clone
475account deposit(10.00)
476account balance println
477</pre>
478
479Like Self[2], Io's syntax does not distinguish between accessing a slot containing a method from one containing a variable.
480
481<a name="Syntax-Operators"></a>
[8176]482<h3>演算子</h3>
[8105]483
[8425]484演算子とは、単に英数字以外の文字による名前をもつメソッドである。例外として、&quot;:&quot;(コロン), &quot;_&quot;(アンダースコア), &apos;&quot;&apos;(ダブルクォート), &quot;.&quot;(ドット) は演算子に使えず、また次のものは英数字による名前だが演算子とする: &quot;and&quot;, &quot;or&quot;, &quot;return&quot;. 例:
[8105]485
486<pre>
4871 + 2
488</pre>
489
[15432]490すなわち次のような通常の形式のメッセージにコンパイルされる:
[8105]491
492<pre>
4931 +(2)
494</pre>
495
[8392]496括弧を使ってまとめることもできる:
[8105]497
498<pre>
4991 +(2 * 4)
500</pre>
501
[8392]502標準の演算子は、C 言語と同じ優先順位で処理される。従って:
[8105]503
504<pre>
5051 + 2 * 3 + 4
506</pre>
507
[8392]508は次のように解析される:
[8105]509
510<pre>
5111 +(2 *(3)) +(4)
512</pre>
513
[8392]514ユーザ定義の演算子 (標準の演算子名は使えない) は、常に左から右に動作する。
[8105]515
516<a name="Syntax-Assignment"></a>
[8176]517<h3>代入</h3>
[8105]518
[8392]519Io は3つの代入演算子を持つ:
[8105]520
521<p>
522<table cellpadding=2 cellspacing=0 border=0 style="margin-left:1em">
523<tr>
524<td style="width:5em">
525<b><i>operator</i></b> 
526</td>
527<td>
528<b><i>action</i></b>
529</td>
530</tr>
531
532<tr>
533<td>
534<i>::=</i>
535</td>
536<td>
[8392]537<i>スロットの生成, setter の生成, 値の代入</i>
[8105]538</td>
539</tr>
540
541<tr>
542<td>
543<i>:=</i>
544</td>
545<td>
[8392]546<i>スロットの生成, 値の代入</i>
[8105]547</td>
548</tr>
549
550<tr>
551<td>
552<i>=</i>
553</td>
554<td>
[8392]555<i>スロットが存在すれば値の代入、もしなければ例外を発生する</i>
[8105]556</td>
557</tr>
558
559</table>
560<p>
561
[8392]562These operators are compiled to normal messages whose methods can be overridden. 例:
[8105]563
564
565<p>
566<table cellpadding=2 cellspacing=0 border=0 style="margin-left:1em">
567<tr>
568<td style="width:5em">
[8425]569<b><i>ソースコード</i></b>    
[8105]570</td>
571<td>
[8425]572<b><i>コンパイル結果</i></b>
[8105]573</td>
574</tr>
575
576<tr>
577<td>
578<i>a ::= 1</i>
579</td>
580<td>
581<i>newSlot("a", 1)</i>
582</td>
583</tr>
584
585<tr>
586<td>
587<i>a := 1</i>
588</td>
589<td>
590<i>setSlot("a", 1)</i>
591</td>
592</tr>
593
594<tr>
595<td>
596<i>a = 1</i>
597</td>
598<td>
599<i>updateSlot("a", 1)</i>
600</td>
601</tr>
602
603</table>
604<p>
605       
606On Locals objects, updateSlot is overridden so it will update the slot in the object in which the method was activated if the slot is not found the locals. This is done so update assignments in methods don't require self to be an explicit target.
607
608<a name="Syntax-Numbers"></a>
[8176]609<h3>数値</h3>
[8105]610
[8425]611以下は、有効な数値フォーマットの例です:
[8105]612
613<pre>
614123
615123.456
6160.456
617.456
618123e-4
619123e4
620123.456e-7
621123.456e2
622</pre>
623
[8424]62416進数もサポートされます(どんなケースでも):
[8105]625
626<pre>
6270x0
6280x0F
6290XeE
630</pre>
631
632<a name="Syntax-Strings"></a>
[8176]633<h3>文字列</h3>
[8105]634
635Strings can be defined surrounded by a single set of double quotes with escaped quotes (and other escape characters) within.
636
637<pre>
638s := "this is a \"test\".\nThis is only a test."
639</pre>
640
641Or for strings with non-escaped characters and/or spanning many lines, triple quotes can be used.
642
643<pre>
644s := """this is a "test".
645This is only a test."""
646</pre>
647
648<a name="Syntax-Comments"></a>
[8176]649<h3>コメント</h3>
[8105]650
[8425]651コメントには //, /**/ と # のスタイルをサポートしています。 例:
[8105]652
653<pre>
654a := b // add a comment to a line
655
656/* comment out a group
657a := 1
658b := 2
659*/
660</pre>
661
[8425]662&quot;#&quot; スタイルは Unix でのスクリプトに役立ちます:
[8105]663
664<pre>
665#!/usr/local/bin/io
666</pre>
667
[8425]668これだけだ! 貴方は Io の文法について知るために必要なこと全てを知っている。 制御構造・オブジェクト・メソッド・例外は 上記で説明した構文で表現されます。
[8105]669
670
671</div>
[8392]672<h2>オブジェクト<a name="Objects"></a></h2>
[8105]673<div class=indent>
674
675<div class=quote>
[15748]676今まで考案された全ての言語 - Fortran, Algol60, Lisp, APL, Cobol, Pascal - では、プログラムは一方に受動的なデータオブジェクトを持ち、もう一方にそれを操作する実行可能なプログラムを持つ構造だった。 この二部構成を同質に塗り替え、それぞれが自身で操作できるデータ系の集合で構成したのが、オブジェクト指向プログラムである。 <br>
677- David Gelernter and Suresh J Jag
678</div>
679
680<div class=quote>
[8105]681In all other languages we've considered [Fortran, Algol60, Lisp, APL, Cobol, Pascal], a program consists of passive data-objects on the one hand and the executable program that manipulates these passive objects on the other. Object-oriented programs replace this bipartite structure with a homogeneous one: they consist of a set of data systems, each of which is capable of operating on itself. <br>
682- David Gelernter and Suresh J Jag
683</div>
684
685<a name="Objects-Overview"></a>
[8424]686<h3>概略</h3>
[8105]687
688Io's guiding design principle is simplicity and power through conceptual unification.
689<p>
690
691<table cellpadding=2 cellspacing=0 border=0 style="margin-left:1em">
692<tr>
693<td style="width:15em">
694<b><i>concept</i></b>  
695</td>
696<td>
697<b><i>unifies</i></b>
698</td>
699</tr>
700
701<tr>
702<td>
703<i>blocks with assignable scope </i>
704</td>
705<td>
706<i>functions, methods, closures, functions</i>
707</td>
708</tr>
709
710<tr>
711<td>
712<i>prototypes</i>
713</td>
714<td>
715<i>objects, classes, namespaces, locals</i>
716</td>
717</tr>
718 
719<tr>
720<td valign=top>
721<i>messages</i>
722</td>
723<td>
724<i>operators, calls, assignment, variable accesses</i>
725</td>
726</tr>
727</table>
728
729<a name="Objects-Prototypes"></a>
[8392]730<h3>プロトタイプ</h3>
[8105]731
[15432]732Io では、(ローカルのブロック記憶領域や名前空間それ自体を含む) 全てがオブジェクトであり、(値の代入を含む) 全ての振舞いはメッセージです。 。オブジェクトはスロットというキーと値のペアのリストと、protos という継承したオブジェクトの内部リストから出来ています。 あるスロットのキーはシンボル(つまり、ユニークな不変の文字列)であり、あらゆる型のオブジェクトをその値に取ります。
[8105]733 
[15432]734新たなオブジェクトの clone と init で、既にあるオブジェクトのクローンを作成します。 あるクローンは、protos のリストにその親を持つ空のオブジェクトです。 新しいインスタンスの init スロットは有効になり、そのオブジェクトを初期化するために使われます。 NewtonScript のように、Io のスロットは create-on-write です。
[8105]735
736<pre>
737me := Person clone
738</pre>
739
[15432]740インスタンスに変数やメソッドを追加するには、単純にセットします:
[8105]741
742<pre>
743myDog name := "rover"
744myDog sit := method("I'm sitting\n" print)
745</pre>
746
[15432]747あるオブジェクトのクローンが作成されると、その init スロットがあれば、それが呼ばれます。
[8105]748
749<a name="Objects-Inheritance"></a>
[8392]750<h3>継承</h3>
[8105]751
[15479]752あるオブジェクトが該当するスロットを探すようなメッセージを受けた場合、見つからなければ、その1階層深い proto へ再帰的に検査を続けます。 検査のループが見つかった場合には、検査は中断されます。 マッチするスロットに実行可能なオブジェクトがあれば、例えば Block や CFunction などの場合、それが実行され、値があればその値を返します。 Io にはグローバルオブジェクトはなく、Lobby という Io 名前空間のルートオブジェクトがあります。
[8105]753<p>
[15479]754クラスがないため、サブクラスとインスタンスの違いはありません。 以下は、サブクラスに相当するものを作成する例です:
[8105]755
756<pre>
757Io> Dog := Object clone
758==> Object_0x4a7c0
759</pre>
760
[15479]761上記のコードでは、Lobby の &quot;Dog&quot; スロットに Object オブジェクトのクローンをセットしています。 そのクローンは Object への参照を含む protos リストのみを持っています。 これで、本質的に Dog は Object のサブクラスとなります。 インスタンスの変数やメソッドはその proto から継承されます。 スロットがセットされた場合、proto は変更されず、作成したオブジェクトに新しいスロットを作成します:
[8105]762
763<pre>
764  Io> Dog color := "red"
765  Io> Dog
766  ==> Object_0x4a7c0:
767    color := "red"
768</pre>
769
[8392]770<h4>多重継承</h4>
[8105]771
[15479]772あるオブジェクトのprotosリストには、protoを幾つでも追加できます。 メッセージへの応答の際、検査構造は1層目の proto チェーンから検査します。
[8105]773
774<a name="Objects-Methods"></a>
[8392]775<h3>メソッド</h3>
[8105]776
[15479]777メソッドは、呼び出された際、生成された際のオブジェクトをローカルに保存し、そのローカルの proto ポインタとそれ自身のスロットをターゲットにメッセージをセットする匿名の関数です。 Object メソッド method() でメソッドを作成することができます。 例:
[8105]778
779<pre>
780method((2 + 2) print)
781</pre>
782
[8424]783オブジェクト内のメソッドを使用する例:
[8105]784
785<pre>
786Dog := Object clone
787Dog bark := method("woof!" print)
788</pre>
789
[15479]790上記コードは、Dog と名の付けられたオブジェクトの &quot;サブクラス&quot; を新たに作成し、&quot;woof!&quot; を出力するブロックである bark スロットを含んでいます。 メソッドを呼び出す例:
[8105]791
792<pre>
793Dog bark
794</pre>
795
[15479]796ブロックのデフォルトの戻り値は、最後の式の結果になります。
[8105]797
[8176]798<h4>引数</h4>
[8105]799
[8392]800メソッドは引数をとるようにも定義できる。 例:
[8105]801
802<pre>
803add := method(a, b, a + b)
804</pre>
805
[8392]806一般的な形式:
[8105]807
808<pre><i>
809method(&lt;arg name 0&gt;, &lt;arg name 1&gt;, ..., &lt;do message&gt;)
810</i></pre>
811
812<a name="Objects-Blocks"></a>
[8392]813<h3>ブロック</h3>
[8105]814
[15748]815ブロックは変数のスコープの違いを除いて、メソッドと同じです。 つまり変数検査は、ブロックが実行されるメッセージのターゲットの代わりに、ブロックが生成された時点での文脈に従います。 ブロックは Object の block() メソッドで生成できます。 ブロックを生成する例:
[8105]816
817<pre>
818b := block(a, a + b)
819</pre>
820
[8425]821<h4>ブロック vs メソッド</h4>
[8105]822
[15748]823混乱の種になりそうなので、詳細を説明します。 両方とも、呼び出されるとローカル領域にオブジェクトを作成するのは同じです。 違いは、ローカル領域のオブジェクト &quot;proto&quot; と &quot;self&quot; に何がセットされるかです。 メソッドでは、それらのスロットには、メッセージのターゲットがセットされる。 ブロックでは、そのブロックが作り出されたときのローカル領域オブジェクトがセットされる。 従ってブロック中では、ローカル領域にない変数は、そのブロックが作成されたときのローカル領域を辿って検索される。 そしてメソッド中では、ローカル領域にない変数は、そのメソッドを呼び出したオブジェクトを辿って検索される。
[8105]824
[15748]825<h4>call と self スロット</h4>
[8105]826
[15748]827ローカル領域にオブジェクトが作られる際、その self スロットには、メソッドの場合はメッセージのターゲット、ブロックの場合は生成時の文脈に沿ってセットされ、call スロットには Call オブジェクトがセットされ、ブロック実行時のアクセス情報が参照できます:
[8105]828
829<p>
830<table cellpadding=2 cellspacing=0 border=0 style="margin-left:1em">
831<tr>
832<td style="width:10em">
833<b><i>slot</i></b>
834</td><td>
835<b><i>returns</i></b>
836</td>
837</tr>
838<tr>
839<td>
840<i>call sender </i>
841</td><td>
[15748]842<i>呼び出し側のローカルオブジェクト</i>
[8105]843</td>
844</tr>
845<tr>
846<td>
847<i>call message </i>
848</td><td>
[15748]849<i>メソッドまたは、ブロックへの呼び出し時に使われたメッセージ</i>
[8105]850</td>
851</tr>
852<tr>
853<td>
854<i>call activated</i>
855</td><td>
[15748]856<i>実行されたメソッドまたはブロック</i>
[8105]857</td>
858</tr>
859<tr>
860<td>
861<i>call slotContext</i>
862</td><td>
[15748]863<i>スロットが見つかった文脈</i>
[8105]864</td>
865</tr>
866<tr>
867<td>
868<i>call target</i>
869</td><td>
[15748]870<i>カレントオブジェクト</i>
[8105]871</td>
872</tr>
873</table>
874
[8392]875<h4>可変長引数</h4>
[8105]876
877The "call message" slot in locals can be used to access the unevaluated argument messages. Example of implementing if() within Io:
878
879<pre>
880myif := method(
881    (call sender doMessage(call message argAt(0))) ifTrue(
882    call sender doMessage(call message argAt(1))) ifFalse(
883    call sender doMessage(call message argAt(2)))
884)
885
886myif(foo == bar, write("true\n"), write("false\n"))
887</pre>
888
889The doMessage() method evaluates the argument in the context of the receiver.
890
891A shorter way to express this is to use the evalArgAt() method on the call object:
892
893<pre>
894myif := method(
895    call evalArgAt(0) ifTrue(
896    call evalArgAt(1)) ifFalse(
897    call evalArgAt(2))
898)
899
900myif(foo == bar, write("true\n"), write("false\n"))
901</pre>
902
903<a name="Objects-Forward"></a>
[8392]904<h3>転送</h3>
[8105]905
906If an object doesn't respond to a message, it will invoke its "forward" method if it has one. Here's an example of how to print the information related lookup that failed:
907
908<pre>
909MyObject forward := method(
910    write("sender = ", call sender, "\n")
911    write("message name = ", call message name, "\n")
912    args := call message argsEvaluatedIn(call sender)
913    args foreach(i, v, write("arg", i, " = ", v, "\n") )
914)
915</pre>
916
917<a name="Objects-Forward"></a>
918<h3>Resend</h3>
919
[8176]920Sends the current message to the receiver's proto with the context of self. 例:
[8105]921
922<pre>
923A := Object clone
924A m := method(write("in A\n"))
925B := A clone
926B m := method(write("in B\n"); resend)
927B m
928</pre>
929
930will print:
931
932<pre>
933in B
934in A
935</pre>
936
937For sending other messages to the receiver's proto, super is used.
938
939<a name="Objects-Super"></a>
940<h3>Super</h3>
941
[8176]942Sometimes it's necessary to send a message directly to a proto. 例:
[8105]943
944<pre>
945Dog := Object clone
946Dog bark := method(writeln("woof!"))
947
948fido := Dog clone
949fido bark := method(
950    writeln("ruf!")
951    super(bark)
952)
953</pre>
954
955Both resend and super are implemented in Io.
956
957<a name="Objects-Introspection"></a>
[8392]958<h3>イントロスペクション</h3>
[8105]959
960Using the following methods you can introspect the entire Io namespace. There are also methods for modifying any and all of these attributes at runtime.
961
962<h4>slotNames</h4>
963
964The slotNames method returns a list of the names of an object's slots:
965
966<pre>
967Io> Dog slotNames
968==> list("bark")
969</pre>
970
971<h4>protos</h4>
972
973The protos method returns a list of the objects which an object inherits from:
974
975<pre>
976Io> Dog protos
977==> list("Object")
978</pre>
979
980<h4>getSlot</h4>
981
982The "getSlot" method can be used to get the value of a block in a slot without activating it:
983
984<pre>
985myMethod := Dog getSlot("bark")
986</pre>
987
988Above, we've set the locals object's "myMethod" slot to the bark method. It's important to remember that if you then want use the myMethod without activating it, you'll need to use the getSlot method:
989
990<pre>
991otherObject newMethod := getSlot("myMethod")
992</pre>
993
994Here, the target of the getSlot method is the locals object.
995
996<h4>code</h4>
997
998The arguments and expressions of methods are open to introspection. A useful convenience method is "code", which returns a string representation of the source code of the method in a normalized form.
999
1000<pre>
1001Io> method(a, a * 2) code
1002==> "method(a, a *(2))"
1003</pre>
1004
1005</div>
[8392]1006<h2>制御構造<a name="Control-Flow"></a></h2>
[8105]1007<div class=indent>
1008
1009<a name="Control-Flow-true-false-and-nil"></a>
[8424]1010<h3>true, false と nil</h3>
[8105]1011
1012Io has predefined singletons for true, false and nil. true and false are used for boolean truth values and nil is typically used to indicate an unset or missing or unavailable value.
1013
1014<a name="Control-Flow-Comparison"></a>
[8424]1015<h3>比較</h3>
[8105]1016
1017The standard comparison operations (==, !=, >=, <=, >, <) return either the true or false.
1018
1019<pre>
1020Io> 1 < 2
1021==> true
1022</pre>
1023
1024The compare() method is used to implement the compare methods and returns -1, 0 or 1.
1025
1026<a name="Control-Flow-Conditions"></a>
[8425]1027<h3>条件分岐</h3>
[8105]1028
1029<h4>if</h4>
1030
1031The Lobby contains the condition and loop methods. A condition looks like:
1032
1033<pre><i>
1034if(&lt;condition&gt;, &lt;do message&gt;, &lt;else do message&gt;)
1035</i></pre>
1036
[8113]1037例:
[8105]1038
1039<pre>
1040if(a == 10, "a is 10" print)
1041</pre>
1042
1043The else argument is optional. The condition is considered false if the condition expression evaluates to false or nil, and is considered true otherwise.
1044<p>
1045The result of the evaluated message is returned, so:
1046
1047<pre>
1048if(y < 10, x := y, x := 0)
1049</pre>
1050
1051is the same as:
1052
1053<pre>
1054x := if(y < 10, y, 0)
1055</pre>
1056
1057Conditions can also be used in this form (though not as efficiently):
1058
1059<pre>
1060if(y < 10) then(x := y) else(x := 2)
1061</pre>
1062
1063Else-if is supported:
1064
1065<pre>
1066if(y < 10) then(x := y) elseif(y == 11) then(x := 0) else(x := 2)
1067</pre>
1068
1069As well as Smalltalk style ifTrue, ifFalse, ifNil and ifNonNil methods:
1070
1071<pre>
1072(y < 10) ifTrue(x := y) ifFalse(x := 2)
1073</pre>
1074
1075Notice that the condition expression must have parenthesis surrounding it.
1076
1077<a name="Control-Flow-Loops"></a>
[8425]1078<h3>ループ</h3>
[8105]1079
1080<h4>loop</h4>
1081
1082The loop method can be used for "infinite" loops:
1083
1084<pre>
1085loop("foo" println)
1086</pre>
1087
1088<h4>while</h4>
1089
1090Like conditions, loops are just messages. while() takes the arguments:
1091
1092<pre><i>
1093while(&lt;condition&gt;, &lt;do message&gt;)
1094</i></pre>
1095
[8113]1096例:
[8105]1097
1098<pre>
1099a := 1
1100while(a < 10,
1101    a print
1102    a = a + 1
1103)
1104</pre>
1105
1106<h4>for</h4>
1107
1108for() takes the arguments:
1109
1110<pre><i>
1111for(&lt;counter&gt;, &lt;start&gt;, &lt;end&gt;, &lt;optional step&gt;, &lt;do message&gt;)
1112</i></pre>
1113
1114The start and end messages are only evaluated once, when the loop starts.
1115
[8113]1116例:
[8105]1117
1118<pre>
1119for(a, 0, 10,
1120    a println
1121)
1122</pre>
1123
1124Example with a step:
1125
1126<pre>
1127for(x, 0, 10, 3, x println)
1128</pre>
1129
1130Which would print:
1131
1132<pre>
11330
11343
11356
11369
1137</pre>
1138
1139To reverse the order of the loop, add a negative step:
1140
1141<pre>
1142for(a, 10, 0, -1, a println)
1143</pre>
1144
1145Note: the first value will be the first value of the loop variable and the last will be the last value on the final pass through the loop. So a loop of 1 to 10 will loop 10 times and a loop of 0 to 10 will loop 11 times.
1146
1147Example of using a block in a loop:
1148
1149<pre>
1150test := method(v, v print)
1151for(i, 1, 10, test(i))
1152</pre>
1153
1154<h4>repeat</h4>
1155
1156The Number repeat method is simpler and more efficient when a counter isn't needed.
1157
1158<pre>
11593 repeat("foo" print)
1160==> foofoofoo
1161</pre>
1162
[8425]1163<h4>break と continue</h4>
[8105]1164
[8425]1165The flow control operations break and continue are supported in loops. 例:
[8105]1166
1167<pre>
1168for(i, 1, 10,
1169    if(i == 3, continue)
1170    if(i == 7, break)
1171    i print
1172)
1173</pre>
1174
[8113]1175出力結果:
[8105]1176
1177<pre>
117812456
1179</pre>
1180
1181<h4>return</h4>
1182
[8425]1183Any part of a block can return immediately using the return method. 例:
[8105]1184
1185<pre>
1186Io> test := method(123 print; return "abc"; 456 print)
1187Io> test
1188123
1189==> abc
1190</pre>
1191
1192</div>
[14880]1193<h2>インポート<a name="Importing"></a></h2>
[8105]1194<div class=indent>
1195
1196The Importer proto implements Io's built-in auto importer feature. If you put each of your proto's in their own file, and give the file the same name with and ".io" extension, the Importer will automatically import that file when the proto is first referenced. The Importer's default search path is the current working directory, but can add search paths using its addSearchPath() method.
1197
1198</div>
[8425]1199<h2>並行動作<a name="Concurrency"></a></h2>
[8105]1200<div class=indent>
1201
1202<a name="Concurrency-Coroutines"></a>
[8425]1203<h3>コルーチン</h3>
[8105]1204
1205Io uses coroutines (user level cooperative threads), instead of preemptive OS level threads to implement concurrency. This avoids the substantial costs (memory, system calls, locking, caching issues, etc) associated with native threads and allows Io to support a very high level of concurrency with thousands of active threads.
1206
1207<a name="Concurrency-Scheduler"></a>
[8425]1208<h3>スケジューラ</h3>
[8105]1209
1210The Scheduler object is responsible for resuming coroutines that are yielding. The current scheduling system uses a simple first-in-first-out policy with no priorities.
1211
1212<a name="Concurrency-Actors"></a>
[8425]1213<h3>アクタ</h3>
[8105]1214
1215An actor is an object with its own thread (in our case, its own coroutine) which it uses to process its queue of asynchronous messages. Any object in Io can be sent an asynchronous message by placing a @ or @@ before the message name. (think of the "a" in @ as standing for "asynchronous")
1216<p>
[8113]1217例:
[8105]1218
1219<pre>
1220result := self foo // synchronous
1221futureResult := self @foo // async, immediately returns a Future
1222self @@foo // async, immediately returns nil
1223</pre>
1224
[8425]1225When an object receives an asynchronous message it puts the message in its queue and, if it doesn't already have one, starts a coroutine to process the messages in its queue. Queued messages are processed sequentially in a first-in-first-out order. Control can be yielded to other coroutines by calling "yield". 例:
[8105]1226
1227<pre>
1228obj1 := Object clone
1229obj1 test := method(for(n, 1, 3, n print; yield))
1230obj2 := obj1 clone
1231obj1 @@test; obj2 @@test
1232while(Scheduler yieldingCoroutines size > 1, yield)
1233</pre>
1234
[8425]1235これは &quot;112233&quot; と出力される.
[8105]1236
1237Here's a more real world example:
1238
1239<pre>
1240HttpServer handleRequest := method(aSocket,
1241    HttpRequestHandler clone @@handleRequest(aSocket)
1242)
1243</pre>
1244
1245<a name="Concurrency-Futures"></a>
[8425]1246<h3>Future</h3>
[8105]1247
1248Io's futures are transparent. That is, when the result is ready, they become the result. If a message is sent to a future (besides the two methods it implements), it waits until it turns into the result before processing the message. Transparent futures are powerful because they allow programs minimize blocking while also freeing the programmer from managing the fine details of synchronization.
1249
[8425]1250<h4>自動デッドロック検知</h4>
[8105]1251
1252An advantage of using futures is that when a future requires a wait, it will check to see if pausing to wait for the result would cause a deadlock and if so, avoid the deadlock and raise an exception. It performs this check by traversing the list of connected futures.
1253
[8425]1254<h4>@ 演算子と @@ 演算子</h4>
[8105]1255
1256The @ or @@ before an asynchronous message is just a normal operator message. So:
1257
1258<pre>
1259self @test
1260</pre>
1261
1262Gets parsed as(and can be written as):
1263
1264<pre>
1265self @(test)
1266</pre>
1267
1268<h4>Futures and the Command Line Interface</h4>
1269
[8425]1270The command line will attempt to print the result of expressions evaluated in it, so if the result is a Future, it will attempt to print it and this will wait on the result of Future. 例:
[8105]1271
1272<pre>
1273Io> q := method(wait(1))
1274Io> @q
1275[1-second delay]
1276==> nil
1277</pre>
1278
[8425]1279To avoid this, just make sure the Future isn't the result. 例:
[8105]1280
1281<pre>
1282Io> @q; nil
1283[no delay]
1284==> nil
1285</pre>
1286
1287<a name="Concurrency-Yield"></a>
1288<h3>Yield</h3>
1289
1290An object will automatically yield between processing each of its asynchronous messages. The yield method only needs to be called if a yield is required during an asynchronous message execution.
1291
[15479]1292<a name="Concurrency-Pause-and-Resume"></a>
[14880]1293<h4>一時停止と再開</h4>
[8105]1294
1295It's also possible to pause and resume an object. See the concurrency methods of the Object primitive for details and related methods.
1296
1297</div>
[8425]1298<h2>例外<a name="Exceptions"></a></h2>
[8105]1299<div class=indent>
1300
1301<a name="Exceptions-Raise"></a>
[14880]1302<h3>例外の発生</h3>
[8105]1303
1304An exception can be raised by calling raise() on an exception proto.
1305
1306<pre>
1307Exception raise("generic foo exception")
1308</pre>
1309
1310<!--
1311<pre><i>
1312exceptionProto raise(&lt;description&gt;)
1313</i></pre>
1314
1315There are three predefined children of the Exception proto: Error, Warning and Notification. Examples:
1316
1317<pre>
1318Exception raise("generic foo exception")
1319Warning raise("No defaults found, creating them")
1320Error raise("Not enough memory")
1321</pre>
1322-->
1323
[14880]1324<a name="ExceptionsTry-and-Catch"></a>
1325<h3>Try と Catch</h3>
[8105]1326
1327To catch an exception, the try() method of the Object proto is used. try() will catch any exceptions that occur within it and return the caught exception or nil if no exception is caught.
1328
1329<pre><i>
1330e := try(&lt;doMessage&gt;)
1331</i></pre>
1332
[8425]1333To catch a particular exception, the Exception catch() method can be used. 例:
[8105]1334
1335<pre>
1336e := try(
1337    // ...
1338)
1339
1340e catch(Exception,
1341    writeln(e coroutine backtraceString)
1342)
1343</pre>
1344
1345
1346The first argument to catch indicates which types of exceptions will be caught. catch() returns the exception if it doesn't match and nil if it does.
1347
1348<a name="Exceptions-Pass"></a>
1349<h3>Pass</h3>
1350
1351To re-raise an exception caught by try(), use the pass method. This is useful to pass the exception up to the next outer exception handler, usually after all catches failed to match the type of the current exception:
1352
1353<pre>
1354e := try(
1355    // ...
1356)
1357
1358e catch(Error,
1359    // ...
1360) catch(Exception,
1361    // ...
1362) pass
1363</pre>
1364
1365
1366<a name="Exceptions-Custom"></a>
[8425]1367<h3>カスタム例外</h3>
[8105]1368
1369Custom exception types can be implemented by simply cloning an existing Exception type:
1370
1371<pre>
1372MyErrorType := Error clone
1373</pre>
1374
1375</div>
[8425]1376<h2>プリミティブ<a name="Primitives"></a></h2>
[8105]1377<div class=indent>
1378
1379Primitives are objects built into Io whose methods are typically implemented in C and store some hidden data in their instances. For example, the Number primitive has a double precision floating point number as its hidden data and its methods that do arithmetic operations are C functions. All Io primitives inherit from the Object prototype and are mutable. That is, their methods can be changed. The reference docs contain more info on primitives.
1380<p>
1381
1382This document is not meant as a reference manual, but an overview of the base primitives and bindings is provided here to give the user a jump start and a feel for what is available and where to look in the reference documentation for further details.
1383
1384<a name="Primitives-Object"></a>
[8425]1385<h3>オブジェクト</h3>
[8105]1386
[8425]1387<h4>? 演算子</h4>
[8105]1388
[8425]1389Sometimes it's desirable to conditionally call a method only if it exists (to avoid raising an exception). 例:
[8105]1390
1391<pre>
1392if(obj getSlot("foo"), obj foo)
1393</pre>
1394
1395Putting a "?" before a message has the same effect:
1396
1397<pre>
1398obj ?foo
1399</pre>
1400
1401<a name="Primitives-List"></a>
[8425]1402<h3>リスト</h3>
[8105]1403
[8425]1404リストは配列の参照であり、すべての標準的な配列操作と列挙のメソッドをサポートします。 例:
[8105]1405<p>
[8113]1406空のリストを生成:
[8105]1407
1408<pre>
1409a := List clone
1410</pre>
1411
[8113]1412list() メソッドを使用することで、任意のリストを生成することができます:
[8105]1413
1414<pre>
1415a := list(33, "a")
1416</pre>
1417
[8113]1418アイテムの追加:
[8105]1419
1420<pre>
1421a append("b")
1422==> list(33, "a", "b")
1423</pre>
1424
[8113]1425リストのサイズを取得:
[8105]1426
1427<pre>
1428a size
1429==> 3
1430</pre>
1431
[8113]1432インデックスを指定し、アイテムの取得(リストのインデックスはゼロから開始されます):
[8105]1433
1434<pre>
1435a at(1)
1436==> "a"
1437</pre>
1438
[8425]1439注: リストのインデックスはゼロから開始されます。また、アクセスしたインデックスが存在しない場合は nil を返します。
[8105]1440<p>
[8113]1441インデックスを指定し、アイテムのセット:
[8105]1442
1443<pre>
1444a atPut(2, "foo")
1445==> list(33, "a", "foo", "b")
1446
1447a atPut(6, "Fred")
1448==> Exception: index out of bounds
1449</pre>
1450
[8113]1451インデックスを指定し、アイテムの削除:
[8105]1452
1453<pre>
1454a remove("foo")
1455==> list(33, "a", "b")
1456</pre>
1457
[8113]1458インデックスを指定し、アイテムの挿入:
[8105]1459
1460<pre>
1461a atPut(2, "foo")
1462==> list(33, "a", "foo", "56")
1463</pre>
1464
1465<h4>foreach</h4>
1466
1467The foreach, map and select methods can be used in three forms:
1468
1469<pre>
1470Io> a := list(65, 21, 122)
1471</pre>
1472
1473In the first form, the first argument is used as an index variable, the second as a value variable and the 3rd as the expression to evaluate for each value.
1474
1475<pre>
1476Io> a foreach(i, v, write(i, ":", v, ", "))
1477==> 0:65, 1:21, 2:122,
1478</pre>
1479
1480The second form removes the index argument:
1481
1482<pre>
1483Io> a foreach(v, v println)
1484==> 65
148521
1486122
1487</pre>
1488
1489The third form removes the value argument and simply sends the expression as a message to each value:
1490
1491<pre>
1492Io> a foreach(println)
1493==> 65
149421
1495122
1496</pre>
1497
1498<h4>map and select</h4>
1499
1500Io's map and select (known as filter in some other languages) methods allow arbitrary expressions as the map/select predicates.
1501
1502<pre>
1503Io> numbers := list(1, 2, 3, 4, 5, 6)
1504
1505Io> numbers select(isOdd)
1506==> list(1, 3, 5)
1507
1508Io> numbers select(x, x isOdd)
1509==> list(1, 3, 5)
1510
1511Io> numbers select(i, x, x isOdd)
1512==> list(1, 3, 5)
1513
1514Io> numbers map(x, x*2)
1515==> list(2, 4, 6, 8, 10, 12)
1516
1517Io> numbers map(i, x, x+i)
1518==> list(1, 3, 5, 7, 9, 11)
1519
1520Io> numbers map(*3)
1521==> list(3, 6, 9, 12, 15, 18)
1522</pre>
1523
1524The map and select methods return new lists. To do the same operations in-place, you can use selectInPlace() and mapInPlace() methods.
1525
1526<a name="Primitives-Sequence"></a>
1527<h3>Sequence</h3>
1528
1529In Io, an immutable Sequence is called a Symbol and a mutable Sequence is the equivalent of a Buffer or String. Literal strings(ones that appear in source code surrounded by quotes) are Symbols. Mutable operations cannot be performed on Symbols, but one can make mutable copy of a Symbol calling its asMutable method and then perform the mutation operations on the copy.
1530Common string operations
1531Getting the length of a string:
1532
1533<pre>
1534"abc" size
1535==> 3
1536</pre>
1537
1538Checking if a string contains a substring:
1539
1540<pre>
1541"apples" containsSeq("ppl")
1542==> true
1543</pre>
1544
1545Getting the character (byte) at position N:
1546
1547<pre>
1548"Kavi" at(1)
1549==> 97
1550</pre>
1551
1552Slicing:
1553
1554<pre>
1555"Kirikuro" slice(0, 2)
1556==> "Ki"
1557
1558"Kirikuro" slice(-2)  # NOT: slice(-2, 0)!
1559==> "ro"
1560
1561Io> "Kirikuro" slice(0, -2)
1562# "Kiriku"
1563</pre>
1564
1565Stripping whitespace:
1566
1567<pre>
1568"  abc  " adMutable strip
1569==> "abc"
1570
1571"  abc  " asMutable lstrip
1572==> "abc  "
1573
1574"  abc  " asMutable rstrip
1575==> "  abc"
1576</pre>
1577
1578Converting to upper/lowercase:
1579
1580<pre>
1581"Kavi" asUppercase
1582==> "KAVI"
1583"Kavi" asLowercase
1584==> "kavi"
1585</pre>
1586
1587Splitting a string:
1588
1589<pre>
1590"the quick brown fox" split
1591==> list("the", "quick", "brown", "fox")
1592</pre>
1593
1594Splitting by others character is possible as well.
1595
1596<pre>
1597"a few good men" split("e")
1598==> list("a f", "w good m", "n")
1599</pre>
1600
1601Converting to number:
1602
1603<pre>
1604"13" asNumber
1605==> 13
1606
1607"a13" asNumber
1608==> nil
1609</pre>
1610
1611String interpolation:
1612
1613<pre>
1614name := "Fred"
1615==> Fred
1616"My name is #{name}" interpolate
1617==> My name is Fred
1618 </pre>
1619
1620Interpolate will eval anything with #{} as Io code in the local context. The code may include loops or anything else but needs to return an object that responds to asString.
1621
1622<a name="Primitives-Ranges"></a>
1623<h3>Ranges</h3>
1624
1625A range is a container containing a start and an end point, and instructions on how to get from the start, to the end. Using Ranges is often convenient when creating large lists of sequential data as they can be easily converted to lists, or as a replacement for the for() method.
1626
1627<h4>The Range protocol</h4>
1628
[8425]1629Each object that can be used in Ranges needs to implement a "nextInSequence" method which takes a single optional argument (the number of items to skip in the sequence of objects), and return the next item after that skip value. The default skip value is 1. The skip value of 0 is undefined. 例:
[8105]1630
1631<pre>
1632Number nextInSequence := method(skipVal,
1633    if(skipVal isNil, skipVal = 1)
1634    self + skipVal
1635)
1636</pre>
1637
1638With this method on Number (it's already there in the standard libraries), you can then use Numbers in Ranges, as demonstrated below:
1639
1640<pre>
16411 to(5) foreach(v, v println)
1642</pre>
1643
1644The above will print 1 through 5, each on its own line.
1645
1646<a name="Primitives-File"></a>
[8425]1647<h3>ファイル</h3>
[8105]1648
[8425]1649The methods openForAppending, openForReading, or openForUpdating are used for opening files. To erase an existing file before opening a new open, the remove method can be used. 例:
[8105]1650
1651<pre>
1652f := File with("foo.txt)
1653f remove
1654f openForUpdating
1655f write("hello world!")
1656f close
1657</pre>
1658
1659<a name="Primitives-Directory"></a>
[8425]1660<h3>ディレクトリ</h3>
[8105]1661
[8425]1662ディレクトリ(directory) オブジェクトの生成:
[8105]1663
1664<pre>
1665dir := Directory with("/Users/steve/")
1666</pre>
1667
[8425]1668ディレクトリ内の全てのファイルのファイルオブジェクトのリストを取得:
[8105]1669
1670<pre>
1671files := dir files
1672==> list(File_0x820c40, File_0x820c40, ...)
1673</pre>
1674
1675Get a list of both the file and directory objects in a directory:
1676
1677<pre>
1678items := Directory items
1679==> list(Directory_0x8446b0, File_0x820c40, ...)
1680
1681items at(4) name
1682==> DarkSide-0.0.1 # a directory name
1683</pre>
1684
1685Setting a Directory object to a certain directory and using it:
1686
1687<pre>
1688root := Directory clone setPath("c:/")
1689==> Directory_0x8637b8
1690
1691root fileNames
1692==> list("AUTOEXEC.BAT", "boot.ini", "CONFIG.SYS", ...)
1693</pre>
1694
1695Testing for existence:
1696
1697<pre>
1698Directory clone setPath("q:/") exists
1699==> false
1700</pre>
1701
1702Getthing the current working directory:
1703
1704<pre>
1705Directory currentWorkingDirectory
1706==> "/cygdrive/c/lang/IoFull-Cygwin-2006-04-20"
1707</pre>
1708
1709<a name="Primitives-Date"></a>
[8425]1710<h3>日付</h3>
[8105]1711
1712Creating a new date instance:
1713
1714<pre>
1715d := Date clone
1716</pre>
1717
1718Setting it to the current date/time:
1719
1720<pre>
1721d now
1722</pre>
1723
1724Getting the date/time as a number, in seconds:
1725
1726<pre>
1727Date now asNumber
1728==> 1147198509.417114
1729
1730Date now asNumber
1731==> 1147198512.33313
1732</pre>
1733
1734Getting individual parts of a Date object:
1735
1736<pre>
1737d := Date now
1738==> 2006-05-09 21:53:03 EST
1739
1740d
1741==> 2006-05-09 21:53:03 EST
1742
1743d year
1744==> 2006
1745
1746d month
1747==> 5
1748
1749d day
1750==> 9
1751
1752d hour
1753==> 21
1754
1755d minute
1756==> 53
1757
1758d second
1759==> 3.747125
1760</pre>
1761
1762Find how long it takes to execute some code:
1763
1764<pre>
1765Date cpuSecondsToRun(100000 repeat(1+1))
1766==> 0.02
1767</pre>
1768
1769<a name="Primitives-Networking"></a>
[8425]1770<h3>ネットワーク</h3>
[8105]1771
1772All of Io's networking is done with asynchronous sockets underneath, but operations like reading and writing to a socket appear to be synchronous since the calling coroutine is unscheduled until the socket has completed the operation, or a timeout occurs. Note that you'll need to first reference the associated addon in order to cause it to load before using its objects. In these examples, you'll have to reference "Socket" to get the Socket addon to load first.
1773<p>
[8425]1774URL オブジェクトの生成:
[8105]1775
1776<pre>
1777url := URL with("http://example.com/")
1778</pre>
1779
1780Fetching an URL:
1781
1782<pre>
1783data := url fetch 
1784</pre>
1785
1786Streaming a URL to a file:
1787
1788<pre>
1789url streamTo(File with("out.txt"))
1790</pre>
1791
1792A simple whois client:
1793
1794<pre>
1795whois := method(host,
1796    socket := Socket clone setHostName("rs.internic.net") setPort(43)
1797    socket connect streamWrite(host, "\n")
1798    while(socket streamReadNextChunk, nil)
1799    return socket readBuffer
1800)
1801</pre>
1802
1803A minimal web server:
1804
1805<pre>
1806WebRequest := Object clone do(
1807    handleSocket := method(aSocket,
1808        aSocket streamReadNextChunk
1809        request := aSocket readBuffer betweenSeq("GET ", " HTTP")
1810        f := File with(request)
1811        if(f exists, f streamTo(aSocket), aSocket streamWrite("not found"))
1812        aSocket close
1813    )
1814)
1815
1816WebServer := Server clone do(
1817    setPort(8000)
1818    handleSocket := method(aSocket,
1819        WebRequest clone @handleSocket(aSocket)
1820    )
1821)
1822
1823WebServer start
1824</pre>
1825
1826<a name="Primitives-XML"></a>
1827<h3>XML</h3>
1828
1829Using the XML parser to find the links in a web page:
1830
1831<pre>
1832SGML // reference this to load the SGML addon
1833xml := URL with("http://www.yahoo.com/") fetch asXML
1834links := xml elementsWithName("a") map(attributes at("href"))
1835</pre>
1836
1837<a name="Primitives-Vector"></a>
1838<h3>Vector</h3>
1839
1840Io's Vectors are built on its Sequence primitive and are defined as:
1841
1842<pre>
1843Vector := Sequence clone setItemType("float32")
1844</pre>
1845
1846The Sequence primitive supports SIMD acceleration on a number of float32 operations. Currently these include add, subtract, multiple and divide but in the future can be extended to support most math, logic and string manipulation related operations.
1847
1848Here's a small example:
1849
1850<pre>
1851iters := 1000
1852size := 1024
1853ops := iters * size
1854
1855v1 := Vector clone setSize(size) rangeFill
1856v2 := Vector clone setSize(size) rangeFill
1857
1858dt := Date secondsToRun(
1859    iters repeat(v1 *= v2)
1860)
1861
1862writeln((ops/(dt*1000000000)) asString(1, 3), " GFLOPS")
1863</pre>
1864
1865Which when run on 2Ghz Mac Laptop, outputs:
1866
1867<pre>
18681.255 GFLOPS
1869</pre>
1870
1871A similar bit of C code (without SIMD acceleration) outputs:
1872
1873<pre>
18740.479 GFLOPS
1875</pre>
1876
1877So for this example, Io is about three times faster than plain C.
1878
1879<!--
1880</div>
1881<h2>Metaprogramming<a name="Metaprogramming"></a></h2>
1882<div class=indent>
1883
1884</i>forthcoming...
1885
1886Object
1887setIsActivatable
1888forward
1889introspection
1890getSlot, slotSummary, docs, namespaces
1891Block
1892setScope()
1893setPassStops()
1894setDoesCatchStops()
1895doesCatchStops
1896setMessage()
1897Message
1898Manipulating Message Trees
1899setNext()
1900setArgumentNames()
1901setCachedResult()
[8425]1902Syntax
[8105]1903squareBrackets()
1904curlyBrackets()
1905operators
1906adding
1907precedence ordering
1908-->
1909
1910</div>
1911<h2>Unicode<a name="Unicode"></a></h2>
1912<div class=indent>
1913
1914<a name="Unicode-Sequences"></a>
1915<h3>Sequences</h3>
1916
1917In Io, symbols, strings, and vectors are unified into a single Sequence prototype which is an array of any available hardware data type such as:
1918 
1919<pre>
1920uint8, uint16, uint32, uint64
1921int8, int16, int32, int64
1922float32, float64
1923</pre>
1924
1925<a name="Unicode-Supported-Encodings"></a>
[8425]1926<h3>サポートしているエンコード</h3>
[8105]1927
1928Also, a Sequence has a encoding attribute, which can be:
1929
1930<pre>
1931number, ascii, ucs2, ucs4, utf8
1932</pre>
1933
1934UCS-2 and UCS-4 are the fixed character width versions of UTF-16 and UTF-32, respectively. A String is just a Sequence with a text encoding, a Symbol is an immutable String and a Vector is a Sequence with a number encoding.
1935<p>
1936UTF encodings are assumed to be big endian.
1937<p>
1938Except for input and output, all strings should be kept in a fixed character width encoding. This design allows for a simpler implementation, code sharing between vector and string ops, fast index-based access, and SIMD acceleration of Sequence operations. All Sequence methods will do automatic type conversions as needed.
1939
1940<a name="Unicode-Source"></a>
1941<h3>Source</h3>
1942
[8425]1943Io source files are assumed to be in UTF8 (of which ASCII is a subset). When a source file is read, it s symbols and strings are stored in Sequences in their minimal fixed character width encoding. 例:
[8105]1944
1945<pre>
1946Io> "hello" encoding
1947==> ascii
1948
1949Io> "π" encoding
1950==> ucs2
1951
1952Io> "∞" encoding
1953==> ucs2
1954</pre>
1955
1956
1957
1958We can also inspect the internal representation:
1959
1960<pre>
1961Io> "π" itemType
1962==> uint16
1963
1964Io> "π" itemSize
1965==> 2
1966</pre>
1967
1968<a name="Unicode-Conversion"></a>
[8425]1969<h3>変換</h3>
[8105]1970
[8425]1971Sequence オブジェクトにはいくつかの変換メソッドがあります:
[8105]1972
1973<pre>
1974asUTF8
1975asUCS2
1976asUCS4
1977</pre>
1978
1979
1980</div>
[8425]1981<h2>組み込み<a name="Embedding"></a></h2>
[8105]1982<div class=indent>
1983
1984<a name="Embedding-Conventions"></a>
1985<h3>Conventions</h3>
1986
1987Io's C code is written using object oriented style conventions where structures are treated as objects and functions as methods. Familiarity with these may help make the embedding APIs easier to understand.
1988
1989<h4>Structures</h4>
1990
1991Member names are words that begin with a lower case character with successive words each having their first character upper cased. Acronyms are capitalized. Structure names are words with their first character capitalized.
1992
[8113]1993例:
[8105]1994
1995<pre>
1996typdef struct
1997{
1998    char *firstName;
1999    char *lastName;
2000    char *address;
2001} Person;
2002</pre>
2003
2004<h4>Functions</h4>
2005
2006Function names begin with the name of structure they operate on followed by an underscore and the method name. Each structure has a new and free function.
2007<p>
2008
[8113]2009例:
[8105]2010
2011<pre>
2012List *List_new(void);
2013void List_free(List *self);
2014</pre>
2015
2016All methods (except new) have the structure (the "object") as the first argument the variable is named "self". Method names are in keyword format. That is, for each argument, the method name has a description followed by an underscore. The casing of the descriptions follow that of structure member names.
2017<p>
[8113]2018例:
[8105]2019
2020<pre>
2021int List_count(List *self); /* no argument */
2022void List_add_(List *self, void *item); /* one argument */
2023void Dictionary_key_value_(Dictionary *self, char *key, char *value);
2024</pre>
2025
2026<h4>File Names</h4>
2027
2028Each structure has its own separate .h and .c files. The names of the files are the same as the name of the structure. These files contain all the functions(methods) that operate on the given structure.
2029
2030<a name="Embedding-IoState"></a>
2031<h3>IoState</h3>
2032
2033An IoState can be thought of as an instance of an Io "virtual machine", although "virtual machine" is a less appropriate term because it implies a particular type of implementation.
2034
2035<h4>Multiple states</h4>
2036
2037Io is multi-state, meaning that it is designed to support multiple state instances within the same process. These instances are isolated and share no memory so they can be safely accessed simultaneously by different os threads, though a given state should only be accessed by one os thread at a time.
2038
2039<h4>Creating a state</h4>
2040Here's a simple example of creating a state, evaluating a string in it, and freeing the state:
2041
2042<pre>
2043#include "IoState.h"
2044
2045int main(int argc, const char *argv[])
2046{
2047    IoState *self = IoState_new();
2048    IoState_init(self);
2049    IoState_doCString_(self, "writeln(\"hello world!\"");
2050    IoState_free(self);
2051    return 0;
2052}
2053</pre>
2054
2055<a name="Embedding-Values"></a>
2056<h3>Values</h3>
2057
2058We can also get return values and look at their types and print them:
2059
2060<pre>
2061IoObject *v = IoState_doCString_(self, someString);
2062char *name = IoObject_name(v);
2063printf("return type is a ‘%s', name);
2064IoObject_print(v);
2065</pre>
2066
2067<h4>Checking value types</h4>
2068
2069There are some macro short cuts to help with quick type checks:
2070
2071<pre>
2072if (ISNUMBER(v))
2073{
2074    printf("result is the number %f", IoNumber_asFloat(v));
2075}
2076else if(ISSEQ(v))
2077{
2078    printf("result is the string %s", IoSeq_asCString(v));
2079}
2080else if(ISLIST(v))
2081{
2082    printf("result is a list with %i elements", IoList_rawSize(v));
2083}
2084</pre>
2085
2086Note that return values are always proper Io objects (as all values are objects in Io). You can find the C level methods (functions like IoList_rawSize()) for these objects in the header files in the folder Io/libs/iovm/source.
2087
2088</div>
[8425]2089<h2>バインディング<a name="Bindings"></a></h2>
[8105]2090<div class=indent>
2091
2092Documentation on how to write bindings/addons forthcoming..
2093
2094</div>
[8425]2095<h2>付録<a name="Appendix"></a></h2>
[8105]2096<div class=indent>
2097
2098<a name="Appendix-Grammar"></a>
[8425]2099<h3>文法</h3>
[8105]2100
2101<h4>messages</h4>
2102<pre>
2103expression ::= { message | sctpad }
2104message ::= [wcpad] symbol [scpad] [arguments]
2105arguments ::= Open [argument [ { Comma argument } ]] Close
2106argument ::= [wcpad] expression [wcpad]
2107symbols
2108symbol ::= Identifier | number | Operator | quote
2109Identifier ::= { letter | digit | "_" }
2110Operator ::= { ":" | "." | "'" | "~" | "!" | "@" | "$" |
2111"%" | "^" | "&" | "*" | "-" | "+" | "/" | "=" | "{" | "}" |
2112"[" | "]" | "|" | "\" | "<" | ">" | "?" }
2113</pre>
2114
2115<h4>quotes</h4>
2116<pre>
2117quote ::= MonoQuote | TriQuote
2118MonoQuote ::= """ [ "\"" | not(""")] """
2119TriQuote ::= """"" [ not(""""")] """""
2120</pre>
2121
2122<h4>spans</h4>
2123<pre>
2124Terminator ::= { [separator] ";" | "\n" | "\r" [separator] }
2125separator ::= { " " | "\f" | "\t" | "\v" }
2126whitespace ::= { " " | "\f" | "\r" | "\t" | "\v" | "\n" }
2127sctpad ::= { separator | Comment | Terminator }
2128scpad ::= { separator | Comment }
2129wcpad ::= { whitespace | Comment }
2130</pre>
2131
2132<h4>comments</h4>
2133<pre>
2134Comment ::= slashStarComment | slashSlashComment | poundComment
2135slashStarComment ::= "/*" [not("*/")] "*/"
2136slashSlashComment ::= "//" [not("\n")] "\n"
2137poundComment ::= "#" [not("\n")] "\n"
2138</pre>
2139
2140<h4>numbers</h4>
2141<pre>
2142number ::= HexNumber | Decimal
2143HexNumber ::= "0" anyCase("x") { [ digit | hexLetter ] }
2144hexLetter ::= "a" | "b" | "c" | "d" | "e" | "f"
2145Decimal ::= digits | "." digits | digits "." digits ["e" [-] digits]
2146</pre>
2147
2148<h4>characters</h4>
2149<pre>
2150Comma ::= ","
2151Open ::= "(" | "[" | "{"
2152Close ::= ")" | "]" | "}"
2153letter ::= "a" ... "z" | "A" ... "Z"
2154digit ::= "0" ... "9"
2155digits ::= { digit }
2156</pre>
2157
2158<a name="Appendix-Credits"></a>
[8425]2159<h3>協力者</h3>
[8105]2160
2161Io is the product of all the talented folks who taken the time and interest to make a contribution. The complete list of contributors is difficult to keep track of, but some of the recent major contributors include; Jonathan Wright, Jeremy Tregunna, Mike Austin, Chris Double, Rich Collins, Oliver Ansaldi, James Burgess, Baptist Heyman, Ken Kerahone, Christian Thater, Brian Mitchell, Zachary Bir and many more. The mailing list archives, repo inventory and release history are probably the best sources for a more complete record of individual contributions.
2162
2163
2164<a name="Appendix-References"></a>
[8425]2165<h3>参考</h3>
[8105]2166
2167
2168<table cellpadding=0 cellspacing=0 border=0>
2169<tr>
2170<td style="width:3em" valign=top>
21711
2172</td>
2173<td>    
2174Goldberg, A et al. <br>
2175Smalltalk-80: The Language and Its Implementation<br>
2176Addison-Wesley, 1983<br>
2177</td>
2178</tr>
2179
2180<tr><td colspan=2 style="height:1em"></td></tr>
2181
2182<tr>
2183<td valign=top>
21842
2185</td>
2186<td>
2187Ungar, D and Smith, <br>
2188RB. Self: The Power of Simplicity<br>
2189OOPSLA, 1987<br>
2190</td>
2191</tr>
2192
2193<tr><td colspan=2 style="height:1em"></td></tr>
2194
2195<tr>
2196<td valign=top>
21973
2198</td>
2199<td>
2200Smith, W. <br>
2201Class-based NewtonScript Programming<br>
2202PIE Developers magazine, Jan 1994<br>
2203</td>
2204</tr>
2205
2206<tr><td colspan=2 style="height:1em"></td></tr>
2207
2208<tr>
2209<td valign=top>
22104
2211</td>
2212<td>
2213Lieberman <br>
2214H. Concurrent Object-Oriented Programming in Act 1<br>
2215MIT AI Lab, 1987<br>
2216</td>
2217</tr>
2218
2219<tr><td colspan=2 style="height:1em"></td></tr>
2220
2221<tr>
2222<td valign=top>
22235
2224</td>
2225<td>
2226McCarthy, J et al. <br>
2227LISP I programmer's manual <br>
2228MIT Press, 1960 <br>
2229</td>
2230</tr>
2231
2232<tr><td colspan=2 style="height:1em"></td></tr>
2233
2234<tr>
2235<td valign=top>
22366
2237</td>
2238<td>
2239Ierusalimschy, R, et al. <br>   
2240Lua: an extensible extension language <br>
2241John Wiley & Sons, 1996 <br>
2242</td>
2243</tr>
2244</table>
2245
2246<a name="Appendix-License"></a>
[8425]2247<h3>ライセンス</h3>
[8105]2248
2249Copyright 2006, 2007, 2008 Steve Dekorte. All rights reserved.
2250<p>
2251Redistribution and use of this document with or without modification, are permitted provided that the copies reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
2252<p>
2253This documentation is provided "as is" and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall the authors be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this documentation, even if advised of the possibility of such damage.
2254
2255</div>
2256<p><br><br><br>
Note: See TracBrowser for help on using the browser.