@node Library modules - Overview, Library modules - Gauche extensions, Object system, Top
@chapter Library modules - Overview
@c NODE ライブラリモジュール - 概要

@c EN
In the following chapters, we explain library modules bundled with Gauche's
distribution.
These modules should generally be loaded and imported (usually using @code{use}
- @xref{Using modules}, for details), unless otherwise noted.
@c JP
続くいくつかの章で、Gaucheのディストリビューションに含まれる
ライブラリモジュールを解説します。
これらのモジュールを使うにあたっては、特に断りのない限り、
モジュールをロードしてimportすることが必要です
(通常は@code{use}マクロが使えます。@ref{Using modules}参照)。
@c COMMON

@c EN
Some modules are described as "autoloaded".  That means you don't need
to @code{load} or @code{use} the module explicitly; at the first time
the bindings are used in the program, the module is automatically
loaded and imported.  See @ref{Autoload}, for the details of autoloading.
@c JP
いくつかのモジュールは「オートロードされる」と表記されています。
この場合は、そのモジュールを使うにあたってあらかじめモジュールをロードしたり
@code{use}しておく必要はありません。そのモジュールの束縛が使われた時点で、
モジュールが自動的にロードされインポートされます。オートロードの
詳細については@ref{Autoload}を参照してください。
@c COMMON

@c EN
As the number of bundled libraries grows, it becomes harder
to find the one you need.  If you feel lost, check
out the section @ref{Finding libraries you need}, in which
we categorize libraries by their purposes.
@c JP
付属ライブラリの数が増えるにつれ、必要なライブラリを探すのが難しく
なりつつあります。迷ったら、@ref{Finding libraries you need}を
見てみて下さい。目的に合わせてライブラリをカテゴライズしています。
@c COMMON

@c EN
The following three chapters describe bundled modules,
grouped by their names.  
@ref{Library modules - Gauche extensions} contains a description of
@code{gauche.*} modules, which are more or less considered
the core features of Gauche but separated since less frequently used.
(Some modules are rather ad-hoc, but here for historical reasons).
@ref{Library modules - SRFIs} describes the modules which
provide SRFI functionalities.  They have the names beginning
with @code{srfi-}.
Note that some of SRFI features are built in Gauche core and
not listed here.  @xref{Standard conformance}, for the entire list
of supported SRFIs.
@ref{Library modules - Utilities} describes other modules
---including database interface, filesystem utilities,
network protocol utilities, and more.
@c JP
この章に続く3つの章で、各ライブラリについて詳細に記述します。
各章は名前でグループ化されています。
@ref{Library modules - Gauche extensions}では@code{gauche.*}という
名前を持つモジュールを説明します。これらはある意味Gaucheの基本的な
機能なのですが、使われる頻度が少ないために別モジュールになったというものです。
(いくつかのモジュールはもっと付加的なものですが、歴史的理由からここにあります)。
@ref{Library modules - SRFIs}ではSRFIの機能を提供するモジュールを
扱います。@code{srfi-}で始まる名前を持ちます。
いくつかのSRFIについてはGaucheのコアに組み込みになっているため、
この章には現れないことに注意してください。サポートされているSRFIの
完全なリストについては@ref{Standard conformance}を見て下さい。
@ref{Library modules - Utilities}では残りのモジュールに
ついて説明します。データベースインタフェース、ファイルシステム、
ネットワークプロトコル、その他様々なライブラリがあります。
@c COMMON

@c EN
There are a few procedures that help your program to check
the existence of certain modules or libraries at run-time.
See @ref{Operations on libraries}, for the details.
@c JP
実行時にプログラムが特定のモジュールやライブラリの存在を検査できる
手続きがいくつか提供されています。
詳しくは@ref{Operations on libraries}を参照して下さい。
@c COMMON

@menu
* Finding libraries you need::  
* Naming convention of libraries::  
@end menu

@node Finding libraries you need, Naming convention of libraries, Library modules - Overview, Library modules - Overview
@section Finding libraries you need
@c NODE 必要なライブラリの探し方

@c EN
Each module is named more or less after what it implements
rather than what it is implemented @emph{for}.  If the module solves
one problem, both are the same.  However, sometimes there
are multiple ways to solve a problem, or one implementation
of an algorithm can solve multiple different problems; thus
it is difficult to name the modules in problem-oriented
(or purpose-oriented) way.
@c JP
各モジュール名は概ね何を実装しているかを示すような名前になっていて、
@emph{何のための}実装になっているかは示していません。モジュールがひと
つの問題を解くためにあるのなら両方は一致しますが、問題の解法が複数ある
こともありますし、ひとつのアルゴリズムの実装が複数の異る問題を解くのに
役立つこともあります。したがって、モジュールに問題指向(あるいは目的指
向)の名前を付けることは困難です。
@c COMMON

@c EN
Because of this, it may not be straightforward for a newcomer
to Gauche to find an appropriate Gauche module to solve her problem,
since there may be multiple algorithms to do the job,
and each algorithm can be implemented in different modules.
@c JP
というわけで、Gaucheにはじめてふれるプログラマにとって問題を解くのに適
切なGaucheモジュールを見つけるのは簡単ではないかもしれません。やるべきことに対
応するアルゴリズムは複数ありえますから、それぞれのアルゴリズムは別々の
モジュールで実装されています。
@c COMMON

@c EN
The modules are also designed in layers; some low-level modules
provide direct interface to the system calls, while some
higher-level ones provide more abstract, easy-to-use interface, possibly
built on top of more than one low-level modules.   Which one
should you use?  Generally you want to use the highest level,
for the very purpose of libraries are to provide easy, abstract
interface.  However there are times that you have to break
the abstraction and to go down to tweak the machinery in
the basement; then you need to use low-level modules directly.
@c JP
モジュールはまた、いくつもの層で実装されています。システムコールへの直接のインタフェース
を提供する低レベルモジュールもあれば、複数の低レベルモジュールを使って
構築された、より抽象化され使いやすい高レベルモジュールもあります。さて
どれを使えばよいでしょう。通常もっとも高レベルのものを使うのがよいでしょ
う。やさしく使える抽象度の高いインタフェースを提供するというのがまさに
ライブラリの目的だからです。とはいうものの、場合によっては抽象の壁をや
ぶってその下にあるメカニズムに触らなければ出来ないこともあります。そ
ういうときには低レベルのモジュールを直接使う必要があります。
@c COMMON

@c EN
The purpose of this section is to group the libraries by
their purposes.  Each category lists relevant modules with
brief descriptions.
@c JP
ここではライブラリをその目的にしたがってグループ分けします。各カテゴリ
ごとに関連するモジュールをあげ、簡単な説明をしています。
@c COMMON

@menu
* Library directory - data containers::  
* Library directory - strings and characters::  
* Library directory - data exchange::  
* Library directory - files::   
* Library directory - processes and threads::  
* Library directory - networking::  
* Library directory - input and output::  
* Library directory - time::    
* Library directory - bits and bytes::  
@end menu

@node Library directory - data containers, Library directory - strings and characters, Finding libraries you need, Finding libraries you need
@subsection Library directory - data containers
@c NODE ライブラリディレクトリ - データコンテナ

@c EN
@subsubheading Generic container operations
@c JP
@subsubheading ジェネリックなコンテナ操作
@c COMMON

@c EN
Some data containers have similar properties; for example,
lists, vectors and hash tables can be seen as a collection
of data.  So it is handy to have generic operators, such
as applying a procedure to all the elements.
@c JP
似たような性質をもつデータコンテナがあります。たとえば、リスト、ベクタ、
ハッシュテーブルはデータのコレクションとして見ることができます。それゆ
え、すべての要素に適用できるようなジェネリックな操作があれば便利です。
@c COMMON

@c EN
Gauche provides such mechanism to a certain degree, mainly using
its object system.
@c JP
Gaucheでは主にオブジェクトシステムで使うためにこのような機構をある程度
用意されています。
@c COMMON

@c EN
@itemize @bullet
@item
@emph{Collection} - Generic functions applicable for unordered
set of values.  @xref{Collection framework}.
@item
@emph{Sequence} - Generic functions applicable for ordered set
of values.  @xref{Sequence framework}.
@item
@emph{Relation} - Generic functions to handle relations
(in a sense of Codd's definition).  @xref{Relation framework}.
@item
@emph{Comprehension} - This is a collection of macros very handy
to construct and traverse collections/sequences in concise code.
@xref{Eager comprehensions}.
@end itemize
@c JP
@itemize @bullet
@item
@emph{コレクション} - 順序付けられていないデータの集合に対するジェネリッ
ク関数。@ref{Collection framework}参照。
@item
@emph{シーケンス} - 順序付けられたデータの集合に対するジェネリック関数。
@ref{Sequence framework}参照。
@item
@emph{リレーション} - (Coddの定義による)リレーションを処理するためのジェ
ネリック関数。@ref{Relation framework}参照。
@item
@emph{内包表記} - コレクションやシーケンスの構築やトラバースを短く便利
に書くためのマクロ集。@ref{Eager comprehensions}参照。
@end itemize
@c COMMON

@c EN
@subsubheading Container implementations
@c JP
@subsubheading コンテナの実装
@c COMMENT

@c EN
@itemize @bullet
@item
@emph{List} - the universal data structure.  You want to check
@ref{Pairs and Lists}, @ref{List library}, 
and @ref{Additional list library}.
@item
@emph{Vector} - a one-dimensional array of arbitrary Scheme values.
See @ref{Vectors} and @ref{Vector library}.
If you need a wide range of index, but the actual data
is sparse, you might want to look at @ref{Sparse vectors}.
@item
@emph{Uniform vector} - a special kind of vectors that can hold
limited types of values (e.g. integers representable in 8bits).
It tends to be used in performance
sensitive applications, such as graphics.  See @ref{Uniform vectors}.
@item
@emph{Array} - multi-dimensional arrays that can hold
arbitrary Scheme values.  See @ref{Arrays}.
@item
@emph{Uniform array} - multi-dimensional arrays that can hold
limited types of values.  This is also supported by @ref{Arrays}.
@item
@emph{String} - a sequence of characters.  See @ref{Strings}
and @ref{String library}.  Gauche handles multibyte strings---
see @ref{Multibyte Strings} for the defatils.
@item
@emph{Character set} - a set of characters.  See @ref{Character set}
and @ref{Character-set library}.
@item
@emph{Hash table} - hash tables.  See @ref{Hashtables}.  There are
also some conversion functions in @ref{Additional list library}.
For very large hash tables (millions of entries), 
@ref{Sparse tables} may provide better memory footprint.
@item
@emph{Queue} - both fast and thread-safe queues are provided in
@ref{Queue}.
@item
@emph{Record} - a simple data structure.  Although Gauche's object
system can be used to define arbitrary data structures, you might
want to look at @ref{Record types} and @ref{SLIB-compatible record type},
for they are more portable and potentially more efficient.
@item
@emph{Stream} - you can implement cool lazy algorithms with it.
See @ref{Stream library}.
@item
@emph{Balanced tree} - Red-black tree implementation is available.
See @ref{Treemaps}.
@item
@emph{Trie} - Another tree structure for efficient common-prefix
search.  See @ref{Trie}.
@item
@emph{Database interface} - dbm interface can be used as a
persistent hash table; see @ref{Generic DBM interface}.
For generic RDBMS interface, see @ref{Database independent access layer}.
@end itemize
@c JP
@itemize @bullet
@item
@emph{リスト} - もっともよく使うデータ構造。
@ref{Pairs and Lists}、@ref{List library}、
@ref{Additional list library}をチェックしましょう。
@item
@emph{ベクタ} - 任意のSchemeの値を格納する一次元配列。@ref{Vectors}お
よび@ref{Vector library}を見ましょう。
広い範囲のインデックスが必要で、しかし実際に格納されるデータが疎である場合は
@ref{Sparse vectors}が使えるかもしれません。
@item
@emph{ユニフォームベクタ} - 制限された型の値(たとえば8ビット整数)を保
持する特別なベクタ。グラフィックなどパフォーマンスが要求されるアプリケー
ション用。@ref{Uniform vectors}参照。
@item
@emph{配列} - 任意のScheme値を保持できる多次元配列。@ref{Arrays}参照。
@item
@emph{ユニフォーム配列} - 制限された型の値を保持する多次元配列。これも
@ref{Arrays}でサポートされている。
@item
@emph{文字列} - 文字のシーケンス。@ref{Strings}および
@ref{String library}参照。Gaucheではマルチバイト文字列を扱えます。詳細
については@ref{Multibyte Strings}を見てください。
@item
@emph{文字集合} - 文字の集合。@ref{Character set}および
@ref{Character-set library}参照。
@item
@emph{ハッシュテーブル} - ハッシュテーブル。 @ref{Hashtables}参照。い
くつかの変換関数は@ref{Additional list library}にもあります。
非常に大きなハッシュテーブル(数百万エントリ)の場合、
@ref{Sparse tables}の方がメモリ効率が良い可能性もあります。
@item
@emph{キュー} - 高速なキュー、およびスレッドセーフなキューが@ref{Queue}で用意されています。
@item
@emph{レコード} - 単純なデータ構造。Gaucheのオブジェクトシステムをつかっ
て任意のデータ構造を定義できますが、@ref{Record types}および
@ref{SLIB-compatible record type}を検討するのもいいでしょう。こちらの
方がポータブルで高効率です。
@item
@emph{ストリーム} - これを使うと遅延アルゴリズムをスマートに実装できま
す。@ref{Stream library}参照。
@item
@emph{平衡木} - 赤黒木が利用できます。@ref{Red black tree}参照。
@item
@emph{トライ} - 共通接頭辞検索用の効率のよい木構造です。@ref{Trie}参照。
@item
@emph{データベースインタフェース} - dbmインタフェースが永続的ハッシュ
テーブルとして利用できます。@ref{Generic DBM interface}参照。ジェネリッ
クなRDBMSへのインタフェースについては、
@ref{Database independent access layer}を見てください。
@end itemize
@c COMMON

@node Library directory - strings and characters, Library directory - data exchange, Library directory - data containers, Finding libraries you need
@subsection Library directory - string and character
@c NODE ライブラリディレクトリ - 文字列と文字

@c EN
Basic string operations are covered in
@ref{Strings} and @ref{String library}.
A string is also a sequence of characters, so you can
apply methods in @ref{Collection framework} and
@ref{Sequence framework}.
@c JP
文字列の基本操作は@ref{Strings}および@ref{String library}でカバーされ
ています。文字列は文字のシーケンスでもありますので、
@ref{Collection framework}および@ref{Sequence framework}のメソッドを適
用可能です。
@c COMMON

@c EN
Character and character set operations are covered in
@ref{Characters}, @ref{Character set}, and @ref{Character-set library}.
@c JP
文字および文字集合の操作は
@ref{Characters}、@ref{Character set}、@ref{Character-set library}がカ
バーしています。
@c COMMON

@c EN
If you scan or build strings sequentially, do not use index
access.  String ports (see @ref{String ports}) provides more efficient,
and elegant way.
@c JP
文字列を先頭から順に操作したり構築したりする場合にはインデックスによる
アクセスはおこないません。文字列ポート(@ref{String ports}参照)はさらに
効率のよいエレガントな方法を提供しています。
@c COMMON

@c EN
You can use regular expressions to search and extract
character sequences from strings; see @ref{Regular expressions}.
@c JP
文字列から文字のならびを検索したり、とりだしたりするのに正規表現が使え
ます。@ref{Regular expressions}参照。
@c COMMON

@c EN
If you need to deal with low-level (i.e. byte-level)
representation of strings, @ref{Uniform vectors} has some
tools to convert strings and byte vectors back and forth.
@c JP
文字列の低レベル(たとえばバイトレベル)表現を扱う必要があるなら
@ref{Uniform vectors}に文字列とバイトベクタ相互の変換をおこなうツール
があります。
@c COMMON

@c EN
Are you dealing with a structure higher than a mere sequence
of characters?  Then take a look at  @code{text.*} modules.
@ref{Parsing input stream} has some basic
scanners.  @ref{Transliterate characters} implements a
feature similar to Unix's @code{tr(1)}.  
You can take @code{diff} of two texts; see
@ref{Calculate difference of text streams}.
And if you want to construct large text from string fragments,
do not use @code{string-append}---see @ref{Lazy text construction}.
@c JP
文字の単なるシーケンスよりも高次の構造を扱いたいのですか。それなら
@code{text.*}モジュールを見てください。@ref{Parsing input stream}には
基本的なスキャナの実装が用意されています。
@ref{Transliterate characters}はUnixの@code{tr(1)}に似た機能を実装して
います。2つのテキストの@code{diff}をとることもできます。これについては
@ref{Calculate difference of text streams}を見てください。文字列の断片
から大きな文字列を構成したいのなら、@code{string-append}を使ってはいけ
ません。@ref{Lazy text construction}参照。
@c COMMON

@c EN
Last but not least, Gauche has support of various character
encoding schemes.  See @ref{Character code conversion} for
the basic utilities.  Most higher-level functions such as
@code{open-input-file} can take @code{:encoding} keyword argument
to perform character conversion implicitly.  Also see 
@ref{Multibyte scripts} if you write Scheme program in
non-ASCII characters.  If you want to process Gauche source code
which may contain "encoding" magic comment, see @ref{Coding-aware ports}.
Gauche also has GNU gettext compatible module (@ref{Localized messages})
if you need localization.
@c JP
大事なことを言い忘れました。Gaucheはさまざまな文字エンコーディングをサ
ポートしています。基本的な関数については
@ref{Character code conversion}を見てください。@code{open-input-file}
のようなもっとも高次の関数のほとんどは、@code{:encoding}キーワード引数
をとり、文字の変換を暗黙におこないます。非ASCII文字でSchemeのプログラ
ムを書きたい場合には@ref{Multibyte scripts}を見てください。encodingと
いうマジックコメントを含むGaucheのソースコードを処理したいなら
@ref{Coding-aware ports}を見てください。地域化が必要なら、Gaucneには
GNU gettext互換のモジュール(@ref{Localized messages})もあります。
@c COMMON


@node Library directory - data exchange, Library directory - files, Library directory - strings and characters, Finding libraries you need
@subsection Library directory - data exchange
@c NODE ライブラリディレクトリ - データ交換

@c EN
Most useful programs need to communicate with outside world
(other programs or humans).  That involves reading the external data
into your program understanding whatever format the data is in, and
also writing the data in the format the others can understand.
@c JP
ほとんどのプログラムでは外界(他のプログラムや人間)とコミュニケーション
する必要があります。ということは外部データを読み込んでそれがどのような
フォーマットで書かれているかを判別したり、他のプログラムが理解できる
フォーマットでデータを書き出したりするということです。
@c COMMON

@c EN
Lots of network-related external formats are defined in RFC,
and there are corresponding @code{rfc.*} module that handle 
some of them.  See @ref{RFC822 message parsing}, for example,
to handle the pervasive RFC2822 message format.
Or, JSON can be handled by @ref{JSON parsing and construction}.
@c JP
ネットワークに関連する外部フォーマットの多くはRFCで規定されており、そ
れらのいくつかに対応するRFCモジュール(@code{rfc.*})があります。たとえ
ばよく知られたRFC2822のメッセージフォーマットを処理するには
@ref{RFC822 message parsing}を見てください。
@c COMMON

@c EN
When you exchange table-formatted data, one of the easiest way
may be the plain text, one row per line, and columns are separeted
by some specific characters (e.g. comma).  See @ref{CSV tables} for
basic parser/writer for them.
@c JP
表形式のデータを交換するのにもっとも便利な方法は表の一行をプレーンテキ
ストの一行に対応させることです。そしてカラムは特定の文字で区切ります。
たとえば、コンマで区切ります。これらの解析と書き出し用の基本手続につい
ては@ref{CSV tables}を見てください。
@c COMMON

@c EN
Oh, and nowadays every business user wants XML, right?  You know
they are just S-expressions with extra redundancy and pointy
parentheses.  So why don't you read XML as if they're S-exprs,
process them with familiar cars and cdrs and maps, then write them
out with extra redundancy and pointy parens?
Module @code{sxml.ssax} (@ref{Functional XML parser})
implements SAX XML parser, with which you
can parse XML and process them on the fly, or convert it to
SXML, S-expression XML.  You can query SXML using
SXPath, an XPath counterparts of S-expression (@ref{SXML Query Language}).
You can output all kinds of XML and HTML using the SXML serializer
(@ref{Serializing XML and HTML from SXML}).
@c JP
今どきのビジネスユーザはXMLを欲しがるというのですか。いいでしょう。まぁ
彼らが欲しいのは尖った括弧のえらい冗長なS式なんですから、XMLをS式と
して読み込んで、自家籠中の car とか cdr とか map でちょちょいと処理し
てえらい冗長な尖った括弧で書き出せばいいですよね。
@code{sxml.ssax}モジュール(@ref{Functional XML parser})はSAX XMLパーザ
の実装です。これを使えば、おてがるにXMLをパーズしたり処理したり、ある
いはまた、SXML(S式XML)に変換することもできます。SXPath(XPathに対応する
S式(@ref{SXML Query Language}))を使ってSXMLクエリを発行することもでき
ます。SXMLシリアライザを使えば、すべての種類のXMLやHTMLをはきだすこと
もできます(@ref{Serializing XML and HTML from SXML})。
@c COMMON

@c EN
(But you know most web services nowadays also talks JSON,
and that's much lighter and handier than XML.
See @ref{JSON parsing and construction}).
@c JP
(でもいまどきのwebサービスならたいていはJSONも話しますし、そっちの方が
手軽だっていうなら、@ref{JSON parsing and construction}を見てみると良いかも
しれません。)
@c COMMON

@c EN
It is planned that various file format handling routines would
be available as @code{file.*} modules, though we have none ready
yet.  If you plan to write one, please go ahead and let us know!
@c JP
さまざまなファイルフォーマットを処理するルーチンを@code{file.*}という
モジュールで使えるようにしようという計画はあるのですが、まだなにも準備
できていません。ひとつ自分で書いてやろうという人がいたら是非おねがいし
たいので、おしらせ下さい。
@c COMMON

@node Library directory - files, Library directory - processes and threads, Library directory - data exchange, Finding libraries you need
@subsection Library directory - files
@c NODE ライブラリディレクトリ - ファイル

@c EN
Files and directories.  Roughly speaking, there are two places
you want to look at.
@c JP
ファイルおよびディレクトリ。おおざっぱに言うと見るべきところは2箇所で
す。
@c COMMON

@c EN
@ref{Filesystems}, in the core, has
routines close to the underlying OS provides.  If you have
experience with Unix system programming you'll find familiar
function names there.   The @code{fcntl} functionality is
splitted to @code{gauche.fcntl} (@ref{Low-level file operations}), FYI.
@c JP
@ref{Filesystems}のコア部分には下位のOSが提供しているに近いルーチンが
あります。Unixのシステムプログラミングの経験があれば、よく知っている関
数名がばかりだと思うでしょう。ちなみに@code{fcntl}の機能は
@code{gauche.fcntl} (@ref{Low-level file operations})にあります。
@c COMMON

@c EN
Also you definitely want to look at @code{file.util}
(@ref{Filesystem utilities}), which implements higher-level
routines on top of system-level ones.
@c JP
まちがいなく@code{file.util}(@ref{Filesystem utilities})を使いたいこと
でしょう。これはシステムレベル上で実装された高次レベルのルーチン群です。
@c COMMON


@node Library directory - processes and threads, Library directory - networking, Library directory - files, Finding libraries you need
@subsection Library directory - processes and threads
@c NODE ライブラリディレクトリ - プロセスとスレッド

@c EN
Process-related routines also come in two levels.
@c JP
プロセス関連のルーチンも2つのレベルで提供されます。
@c COMMON

@c EN
The @code{gauche.process} module provides
high-level routines (@ref{High Level Process Interface}); 
you can pipe the data into and out of child processes easily, for example.
@c JP
@code{gauche.process}モジュールは高レベルのルーチン
(@ref{High Level Process Interface})を提供しています。これを使えば、た
とえば、データを子プロセスとの間でパイプすることが簡単にできます。
@c COMMON

@c EN
Gauche core provides the primitive @code{fork} and @code{exec} interface
as well as the convenient @code{system} call
(see @ref{Process management}).  Use them when you want a precise
control over what you're doing.
@c JP
Gaucheコアはプリミティブな@code{fork}および@code{exec}のインタフェース
を、便利な@code{system}コール(@ref{Process management}参照)同様提
供しています。やりたいことを細かくコントロールしたい場合に使うとよいで
しょう。
@c COMMON

@c EN
Gauche has preemptive threads on most Unix platforms including OSX.
Check out @ref{Threads} for the basic thread support, including
primitive mutexes.  The @code{util.queue} module (@xref{Queue})
provides thread-safe queue that can also be handy for synchronization.
Thread pool is available in @code{control.thread-pool} (@xref{Thread pools}).
@c JP
GaucheはOSXを含む多くのUnixプラットフォームでプリエンプティブなスレッドを
サポートしています。低レベルの排他制御を含む基本的なスレッドのサポートについては
@ref{Threads}を参照してください。@code{util.queue}モジュール
(@ref{Queue}参照)では、スレッド間同期にも使えるスレッドセーフなキューを
提供しています。スレッドプールは@code{control.thread-pool} (@ref{Thread pools}参照)
によって提供されます。
@c COMMON


@node Library directory - networking, Library directory - input and output, Library directory - processes and threads, Finding libraries you need
@subsection Library directory - networking
@c NODE ライブラリディレクトリ - ネットワーク

@c EN
We have multi-layer abstraction here.  At the bottom, we have
APIs corresponding to socket-level system calls.  In the middle,
a convenience library that automates host name lookups, connection
and shutdown, etc.  On top of them we have several modules that
handles specific protocols (e.g. http).
@c JP
これは抽象の層が複数あります。最下層ではソケットレベルのシステムコール
に対応するAPIがあります。中間層ではホスト名の解決、コネクション、シャッ
トダウンなどを自動でやるような便利なライブラリになっています。最上層で
は、たとえばHTTPのような特定のプロトコルを扱うためのモジュールがいくつ
か用意されています。
@c COMMON

@c EN
The @code{gauche.net} module (@ref{Networking}) provides the bottom
and middle layer.  For the top layer, look for @code{rfc.*} modules,
e.g. @code{rfc.http} (@ref{HTTP}).
More protocol support is coming (there are @code{rfc.ftp} and
@code{rfc.imap4} written by users, which are waiting for being
integrated into Gauche---maybe in next release).
@c JP
@code{gauche.net}モジュール(@ref{Networking})は最下層と中間層を提供し
ています。最上層については@code{rfc.*}モジュールを探してみて下さい。
たとえば @code{rfc.http} (@ref{HTTP})です。
その他のプロトコルについてもまもなくサポートされる予定です。
@code{rfc.ftp}や@code{rfc.imap4}はすでにユーザの方々が書いてくれていて、
Gaucheにとりこまれるのを待っている状態にあります。おそらく次のリリース
で統合されるでしょう。
@c COMMON

@c EN
There's a plan of even higher level of libraries, under the name
@code{net.*}, which will abstract more than one network protocols.
The planned ones include sending emails, or
universal resource access by uri.  Code contributions are welcome.
@c JP
さらに複数のプロトコルを抽象化して@code{net.*}という名前のさらに高次レ
ベルのライブラリの計画もあります。emailの送信あるいはURIによるリソース
アクセスなどの計画があります。コードの貢献は歓迎します。
@c COMMON

@node Library directory - input and output, Library directory - time, Library directory - networking, Finding libraries you need
@subsection Library directory - input and output
@c NODE ライブラリディレクトリ - 入出力

@node Library directory - time, Library directory - bits and bytes, Library directory - input and output, Finding libraries you need
@subsection Library directory - time
@c NODE ライブラリディレクトリ - 時間

@node Library directory - bits and bytes,  , Library directory - time, Finding libraries you need
@subsection Library directory - bits and bytes
@c NODE ライブラリディレクトリ - ビットとバイト

@c EN
@subsubheading Binary I/O
@c JP
@subsubheading バイナリ入出力
@c COMMON

@c EN
As the bottom level,
Gauche includes primitive byte I/O (@code{read-byte}, @code{write-byte})
as well as block I/O (@code{read-block!}, @code{write-block}) in its core.
(See @ref{Reading data}, @ref{Output}, and @ref{Uvector block I/O}).
@c JP
最下層としてGaucheはコアに含まれるブロック入出力(@code{read-block!}
、@code{write-block})と同様、バイト入出力のプリミティブ
(@code{read-byte}、@code{write-byte})も含んでいます
(@ref{Reading data}、@ref{Output}、@ref{Uvector block I/O}参照)。
@c COMMON

@c EN
As the middle level, the module @code{binary.io}
(@ref{Binary I/O}) has routines to retrieve specific datatype
with optional endian specification.
@c JP
中間層としては、@code{binary.io}(@ref{Binary I/O})モジュールには
オプションでエンディアンを指定できる特定のデータを取得するルーチンがあ
ります。
@c COMMON

@c EN
And as the top level, the module @code{binary.pack}
(@ref{Packing Binary Data}) allows packing and unpacking structured
binary data, a la Perl's @code{pack}/@code{unpack}.
@c JP
そして最上層としては、@code{binary.pack}(@ref{Packing Binary Data})
モジュールがあって、構造をもつバイナリデータのパック、アンパックを可能
にしています。Perlでいう@code{pack}/@code{unpack}です。
@c COMMON

@c EN
@subsubheading Bit manipulation
@c JP
@subsubheading ビット操作
@c COMMON

@c EN
Gauche core provides bitshift and mask operations. 
See @ref{Bitwise operations}.
@c JP
Gaucheコアはビットシフトおよびマスク操作を提供しています。 
@ref{Bitwise operations}を見てください。
@c COMMON

@node Naming convention of libraries,  , Finding libraries you need, Library modules - Overview
@section Naming convention of libraries
@c NODE ライブラリの命名規則

@c EN
The following table summarizes naming categories of the modules,
including external ones and planned ones.
@c JP
下の表は、モジュールの名前付けの分類を示します。
外部モジュール、及び将来予定されているモジュールも含みます。
@c COMMON

@table @code
@item binary.*
@c EN
Utilities to treat binary data.
@c JP
バイナリデータを扱うためのユーティリティ。
@c COMMON

@item compat.*
@c EN
Provides compatibility layers.
@c JP
互換性のためのレイヤを提供。
@c COMMON

@item dbi.*, dbd.*
@c EN
Database independent interface layer and drivers.
@c JP
データベース独立インタフェース層とドライバー。
@c COMMON

@item dbm.*
@c EN
DBM interface
@c JP
DBMインタフェース
@c COMMON

@item gauche.*
@c EN
Stuffs more or less considered as Gauche core features.
@c JP
Gauche本体の一部として考えられている機能。
@c COMMON

@item gl.*
@c EN
OpenGL binding and related libraries (external package).
@c JP
OpenGLバインディングと関連するライブラリ (外部パッケージ)。
@c COMMON

@item gtk.*
@c EN
GTk+ binding and related libraries (external package).
@c JP
GTk+バインディングと関連するライブラリ (外部パッケージ)。
@c COMMON

@item file.*
@c EN
Manipulating files and directories.
@c JP
ファイルとディレクトリの操作。
@c COMMON

@item lang.*
@c EN
Language-related libraries, artificial and/or natural (planned).
@c JP
言語に関するライブラリ(人工的なものも自然言語関連も)。(予定)
@c COMMON

@item math.*
@c EN
Mathematics.
@c JP
数学。
@c COMMON

@item compat.*
@c EN
Compatibility libraries
@c JP
他の実装とのコンパチビリティに関するライブラリ。 (予定)
@c COMMON

@item rfc.*
@c EN
Implementations of net protocols defined in RFC's.
@c JP
RFCで定義されているデータフォーマットやネットワークプロトコルの実装。
@c COMMON

@item srfi-*
@c EN
SRFI implementations.
@c JP
SRFIの実装
@c COMMON

@item sxml.*
@c EN
SXML libraries.
@c JP
SXMLライブラリ。
@c COMMON

@item text.*
@c EN
Libraries dealing with text data.
@c JP
テキストデータを扱うライブラリ
@c COMMON

@item util.*
@c EN
Generic implementations of various algorithms.
@c JP
汎用的なアルゴリズムの実装。
@c COMMON

@item www.*
@c EN
Implementations of various protocols and formats mainly used in WWW.
@c JP
WWWで主として使われるプロトコルやデータフォーマットの実装。
@c COMMON
@end table

@c Local variables:
@c mode: texinfo
@c coding: utf-8
@c end:
