en to ja translation catalogue (212 entries)

note: type: Plain text
en: % Jhc User's Manual % John Meacham
ja: % Jhcユーザーズマニュアル
    % John Meacham

note: type: Plain text
en: # Using
ja: # 使い方

note: type: Plain text
en: ## Building Projects
ja: ## プロジェクトをビルドする

note: type: Plain text
en: Jhc does its own dependency chasing to track down source files, you need only provide it with the file containing your 'main' function on the command line.  For instance, if you had a program 'HelloWorld.hs', the following would compile it to an executable named 'hello'.
ja: Jhcはソースコードの依存関係を独自に解析してくれるため、
    コマンドラインから'main'関数を含んだファイルを指定するだけでソースコード全体をコンパイルできる。
    例えばソースコード'HelloWorld.hs'をコンパイルしたければ、次のようにコンパイルすれば'hello'という名前の実行バイナリが生成される。

note: type: Plain text
en: Jhc searches for modules in its search path, which defaults to the current directory. Modules are searched for based on their names. For instance, the module Data.Foo will be searched for in 'Data/Foo.hs' and 'Data.Foo.hs'.  The search path may be modifed with the '-i' command line option, or by setting the 'JHC_PATH' environment variable.
ja: Jhcはサーチパスからモジュールを探す。
    そのサーチパスは既定値ではカレントディレクトリである。
    モジュールは名前にもとづいて検索される。
    例えばData.Fooモジュールは'Data/Foo.hs'もしくは'Data.Foo.hs'のパスから探されることになる。
    このサーチパスは'-i'コマンドラインオプションを使って指定できる。
    また、'JHC_PATH'環境変数を使って指定することもできる。

note: type: Plain text
en: ## Using Libraries
ja: ## ライブラリを使う

note: type: Plain text
en: jhc libraries are distributed as files with an 'hl' suffix, such as 'base-1.0.hl'. In order to use a haskell library you simply need to place the file in a directory that jhc will search for it. For instance, $HOME/lib/jhc.  You may set the environment variable JHC_LIBRARY_PATH to specify alternate locations to search for libraries or specify directory to search with the -L command line option. -L- will clear the search path.
ja: jhcライブラリは、例えば'base-1.0.hl'のような、'hl'という拡張子を持つ単一のファイルである。
    何かHaskellライブラリを使うためには、jhcの検索するディレクトリにこのファイルを置くだけで良い。
    例えば $HOME/lib/jhc などだ。
    JHC_LIBRARY_PATH環境変数を定義することで、別の位置をライブラリのサーチパスとして指定することができる。
    また、-Lコマンドラインオプションを使ってもサーチパスを指定できる。
    さらに-L-オプションを使えばサーチパスの設定を既定値に戻すことさえできる。

note: type: Plain text
en: You can then use libraries with the '-p' command line option, for instance if you had a library 'mylibrary-1.0.hl' in your search path, the following would use it.
ja: 'hl'ファイルが適切な位置に置かれていれば、'-p'コマンドラインオプションを使って使用するライブラリを指定することができる。
    例えば'mylibrary-1.0.hl'を既にサーチパスに配置済みであれば、以下のように使うことができる。

note: type: Plain text
en: You can list all available libraries by passing the --list-libraries option to jhc. If you include '-v' for verbose output, you will get detailed information about the libraries in a YAML format suitable for processing by external tools.
ja: --list-librariesオプションを使えば全ての使用可能なライブラリのリストを得られる。
    さらに'-v'オプションを追加することで、各ライブラリに関する詳細な情報を得ることもできる。
    これらの情報はYAMLフォーマットを使って生成されたものである。

note: type: Plain text
en: ## Environment Variables
ja: ## 環境変数

note: type: Plain text
en: Jhc's behavior is modified by several enviornment variables.
ja: Jhcの挙動はいくつかの環境変数によって制御される。

note: type: Plain text
en: JHC_OPTS : this is read and appended to the command line of jhc invocations.
ja: JHC_OPTS : jhcのコマンドライン直後に挿入されるオプション群

note: type: Plain text
en: JHC_PATH : This specifies the path to search for modules.
ja: JHC_PATH : モジュールの検索パス

note: type: Plain text
en: JHC_LIBRARY_PATH : This specifies the path to search for libraries.
ja: JHC_LIBRARY_PATH : ライブラリの検索パス

note: type: Plain text
en: JHC_CACHE : This specified the directory jhc will use to cache values. having a valid cache is essential for jhc performance. It defaults to ~/.jhc/cache.
ja: JHC_CACHE : jhcがキャッシュとして使用するディレクトリ。キャッシュはjhcのパフォーマンス向上にはかかせない。既定値は~/.jhc/cache。

note: type: Plain text
en: ## Building Haskell Libraries
ja: ## Haskellライブラリをビルドする

note: type: Plain text
en: Libraries are built by passing jhc a file describing the library via the --build-hl option. The library file format is a stadard YAML file.
ja: ライブラリは--build-hlオプションで指定されたライブラリファイルの内容にもとづいてビルドされる。
    このライブラリファイルのフォーマットはYAMLである。

note: type: Plain text
en: ### Library File Format
ja: ### ライブラリファイルのフォーマット

note: type: Plain text
en: The library file is a YAML document, jhc will recognize several fields and ignore unknown ones.
ja: ライブラリファイルはYAMLフォーマットで、jhcは自分の理解できるフィールドだけを解釈し、残りは無視する。

note: type: Plain text
en: Name : The name of your library
ja: Name : ライブラリの名前

note: type: Plain text
en: Version : The version of your library, The version number is used to differentiate different versions of the library passed to the '-p' command line option but is not otherwise special to jhc.
ja: Version : ライブラリのバージョン。バージョン番号は'-p'コマンドラインオプションを使う際に区別するために使われる。しかし、それ以外の用途にはjhcは使わない。

note: type: Plain text
en: Exposed-Modules : A list of modules to be included in the library and exposed to users of the library as its public interface. This may include modules that are part of another library, they will be re-exported by the current library.
ja: Exposed-Modules : ライブラリに含まれ、ライブラリの利用者への公開インターフェイスとなる一連のモジュール。この欄が他のライブラリ内のモジュールを含んでいた場合、再度このライブラリでも公開インターフェイス扱いされることになる。

note: type: Plain text
en: Hidden-Modules : A list of modules that the library may use internally but that should not be exposed to the user. Jhc may optimize based on this information. If this list is not exhaustive jhc will still build your library, but it will print out a warning.
ja: Hidden-Modules : ライブラリ内部で使用されるかもしれないが、公開インターフェイスにはならない一連のモジュール。jhcはこの情報を元にして最適化を行なう。このリストがライブラリのビルドに網羅的でなければ、jhcはワーニングメッセージを出力する。

note: type: Plain text
en: Extensions : A list of extensions which should be enabled during compilation of this module. When possible, jhc will match ghc extensions to their closest jhc counterparts.
ja: Extensions : このモジュールをコンパイルするのに必要な拡張のリスト。jhcはできうるかぎりghc拡張と似た拡張を提供するつもりである。

note: type: Plain text
en: Options : Extra command line options to jhc for this library build.
ja: Options : ライブラリビルド時に使うその他のコマンドラインオプション

note: type: Plain text
en: Build-Depends : libraries to include, in the same format as passed to the '-p' command line option
ja: Build-Depends : ビルドに必要になるライブラリ。'-p'コマンドラインオプションと同じフォーマットで指定する。

note: type: Plain text
en: Hs-Source-Dirs : Directory to search for Haskell source files in, this differs from the '-i' command line option in that the directory in this field is relative to the directory the library description .yaml file is located while the '-i' option is always relative to the current working directory.
ja: Hs-Source-Dirs : Haskellソースコードを探すディレクトリ。'-i'コマンドラインオプションと異なり、この欄にはライブラリ詳細を記載した.yamlファイルからの相対パスを記載する。'-i'オプションを使う際にはカレントワーキングディレクトリからの相対パスを記載すること。

note: type: Plain text
en: Include-Dirs : directories to be included in the preprocessor search path as if via '-I'.  The directories are interpreted relative to the directory that contains the yaml file.
ja: Include-Dirs : プリプロセッサが'-I'オプションで検索するディレクトリ。このディレクトリもyamlファイルが置かれたディレクトリからの相対パスとして指定すること。

note: type: Plain text
en: C-Sources : C files that should be linked into programs that utilize this library.
ja: C-Sources : このライブラリを使うプログラムにリンクされるべきC言語ソースコードファイル群。

note: type: Plain text
en: Include-Sources : files that should be made available for inclusion when compiling the generated C code but don't need to be linked into the executable.
ja: Include-Sources : このライブラリを使ったプログラムのビルドに必要なC言語のヘッダを指定する。これらのヘッダはビルド時にincludeされることはあっても、実行ファイルにリンクされることはない。

note: type: Plain text
en: example library files can be seen in lib/jhc/jhc.yaml and lib/base/base.yaml
ja: ライブラリファイルの例としてlib/jhc/jhc.yamlとlib/base/base.yamlを参考のこと。

note: type: Plain text
en: ## Dependency Information
ja: ## 依存情報

note: type: Plain text
en: Jhc can output dependency information describing how source files and libraries depend on each other while compiling code. The dependency information is generated when the --deps name.yaml option is passed to jhc. It is presented in the standard YAML format and its fields are as described below.
ja: jhcは依存情報を出力できる。
    この依存情報はソースコードとライブラリがコンパイル時にその他の要素にどのように依存しているかを表現している。
    依存情報は--deps name.yamlオプションをjhcに入力するとname.yamlファイルに出力される。
    この依存情報もまたYAMLフォーマットで、各項目な以下のような意味を持っている。

note: type: Bullet: '  - '
en: LibraryDeps: the libraries that are dependend on. It is a hash of library ids to the specific filename of the library used.
ja: LibraryDeps: 依存しているライブラリ。使用しているライブラリのファイル名と同時にハッシュ値も列挙する。

note: type: Bullet: '  - '
en: LibraryDesc: if building a library, this field contains the name of the library description file used.
ja: LibraryDesc: ライブラリをビルドした際、この項目は使っているライブラリファイルの名前を含む。

note: type: Bullet: '  - '
en: ModuleDeps: a hash of module names to the list of modules that are directly dependend on by said module.
ja: ModuleDeps: 直接依存しているモジュール名のリスト

note: type: Bullet: '  - '
en: ModuleSouce: a hash of module name to the haskell source file used.
ja: ModuleSouce: 使用しているソースコードファイル名に対応するモジュール名

note: type: Plain text
en: An example tool to processs the deps.yaml file and spit out appropriate Makefile rules is included as 'utils/deps_to_make.prl'.
ja: deps.yamlを扱うサンプルとして'utils/deps_to_make.prl'を参照のこと。

note: type: Plain text
en: # Options
ja: # オプション

note: type: Plain text
en:     Usage: jhc [OPTION...] Main.hs
          -V                --version                 print version info and exit
                            --version-context         print version context info and exit
                            --help                    print help information and exit
                            --info                    show compiler configuration information and exit
                            --purge-cache             clean out jhc compilation cache
          -v                --verbose                 chatty output on stderr
          -z                                          Increase verbosity of statistics
          -d [no-]flag                                dump specified data during compilation
          -f [no-]flag                                set or clear compilation options
          -X ExtensionName                            enable the given language extension
          -o FILE           --output=FILE             output to FILE
          -i DIR            --include=DIR             where to look for source files
          -I DIR                                      add to preprocessor include path
          -D NAME=VALUE                               add new definitions to set in preprocessor
                            --optc=option             extra options to pass to c compiler
          -c                                          just compile the modules, caching the results.
          -C                                          compile to C code
          -E                                          preprocess the input and print result to stdout
          -k                --keepgoing               keep going on errors
                            --cross                   enable cross-compilation, choose target with the -m flag
                            --stop=parse/typecheck/c  stop after the given pass, parse/typecheck/c
                            --width=COLUMNS           width of screen for debugging output
                            --main=Main.main          main entry point
          -m arch           --arch=arch               target architecture options
                            --entry=<expr>            main entry point, showable expression
                            --show-ho=file.ho         Show ho file
                            --noauto                  Don't automatically load base and haskell98 packages
          -p package                                  Load given haskell library package
          -L path                                     Look for haskell libraries in the given directory
                            --build-hl=desc.yaml      Build hakell library from given library description file
                            --annotate-source=<dir>   Write preprocessed and annotated source code to the directory specified
                            --deps=<file.yaml>        Write dependency information to file specified
                            --interactive             run interactivly                                                             ( for debugging only)
                            --ignore-cache            Ignore existing compilation cache entries.
                            --readonly-cache          Do not write new information to the compilation cache.
                            --no-cache                Do not use or update the cache.
                            --cache-dir=JHC_CACHE     Use a global cache located in the directory passed as an argument.
                            --stale=Module            Treat these modules as stale, even if they exist in the cache
                            --list-libraries          List of installed libraries
                            --tdir=dir/               specify the directory where all intermediate files/dumps will be placed.
ja:     Usage: jhc [OPTION...] Main.hs
          -V                --version                 バージョン表示
                            --version-context         バージョン履歴表示
                            --help                    ヘルプメッセージ表示
                            --info                    コンパイラ設定表示
                            --purge-cache             コンパイルキャッッシュの削除
          -v                --verbose                 stderrに冗長なメッセージ表示
          -z                                          冗長な統計情報を表示
          -d [no-]flag                                コンパイルパイプラインの特定の情報をダンプ
          -f [no-]flag                                コンパイルフラグの有効/無効
          -X ExtensionName                            言語拡張の有効化
          -o FILE           --output=FILE             出力ファイル名を指定
          -i DIR            --include=DIR             ソースファイル検索パス
          -I DIR                                      プリプロセッサのインクルードパスを追加
          -D NAME=VALUE                               プリプロセッサに渡すdefineを追加
                            --optc=option             Cコンパイラに渡すその他のオプション
          -c                                          モジュールを単体でコンパイル
          -C                                          C言語コードへコンパイル
          -E                                          ソースコードをプリプロセッサにかけてstdoutへ出力
          -k                --keepgoing               エラーを無視してコンパイルを続行
                            --cross                   クロスコンパイルを有効に、-mオプションでターゲットを指定すること
                            --stop=parse/typecheck/c  parse/typecheck/cの直後で停止する
                            --width=COLUMNS           デバッグ出力のスクリーン幅を変更
                            --main=Main.main          mainエントリポイントを指定
          -m arch           --arch=arch               クロスコンパイルターゲットを指定
                            --entry=<expr>            mainエントリポイントを式を使って指定
                            --show-ho=file.ho         hoファイルの概要をダンプ
                            --noauto                  haskell98パッケージを自動的に読み込まない
          -p package                                  指定したライブラリを使用する
          -L path                                     ライブラリを指定したパスから検索する
                            --build-hl=desc.yaml      指定したライブラリファイルからHaskellライブラリをビルド
                            --annotate-source=<dir>   指定したディレクトリにプリプロセス済みソースコードを出力
                            --deps=<file.yaml>        依存情報を指定したファイルに書き込む
                            --interactive             インタラクティブ実行                                                     (デバッグ用途)
                            --ignore-cache            コンパイルキャッシュを無視する
                            --readonly-cache          コンパイルキャッシュに追加情報を書き込まない
                            --no-cache                コンパイルキャッシュを使わず、書き込みも行なわない
                            --cache-dir=JHC_CACHE     指定したディレクトリをコンパイルキャッシュとして使う
                            --stale=Module            指定したモジュールがコンパイルキャッシュにあっても古い情報として扱う
                            --list-libraries          インストール済みライブラリを表示
                            --tdir=dir/               中間生成物を出力するディレクトリを指定する

note: type: Plain text
en:     valid -d arguments: 'help' for more info
            all-types, aspats, atom, bindgroups, boxy-steps, c, class, class-summary, core, core-afterlift
            core-beforelift, core-initial, core-mangled, core-mini, core-pass, core-steps, datatable
            datatable-builtin, dcons, decls, defs, derived, e-alias, e-info, e-size, e-verbose, exports, grin
            grin-datalog, grin-final, grin-graph, grin-initial, grin-normalized, grin-posteval, grin-preeval
            imports, ini, instance, kind, kind-steps, optimization-stats, parsed, preprocessed, program
            progress, renamed, rules, rules-spec, scc-modules, sigenv, srcsigs, stats, steps, tags, the
            types, verbose, veryverbose
ja:     -dオプションの引数: '-d help'オプションで詳細
            all-types, aspats, atom, bindgroups, boxy-steps, c, class, class-summary, core, core-afterlift
            core-beforelift, core-initial, core-mangled, core-mini, core-pass, core-steps, datatable
            datatable-builtin, dcons, decls, defs, derived, e-alias, e-info, e-size, e-verbose, exports, grin
            grin-datalog, grin-final, grin-graph, grin-initial, grin-normalized, grin-posteval, grin-preeval
            imports, ini, instance, kind, kind-steps, optimization-stats, parsed, preprocessed, program
            progress, renamed, rules, rules-spec, scc-modules, sigenv, srcsigs, stats, steps, tags, the
            types, verbose, veryverbose

note: type: Plain text
en:     valid -f arguments: 'help' for more info
            bang-patterns, boehm, controlled, cpp, debug, default, defaulting, exists, ffi, forall, full-int
            glasgow-exts, global-optimize, inline-pragmas, jgc, lint, m4, monomorphism-restriction, negate
            prelude, profile, raw, rules, standalone, type-analysis, type-families, unboxed-tuples
            unboxed-values, user-kinds, wrapper
ja:     -fオプションの引数: '-f help'オプションで詳細
            bang-patterns, boehm, controlled, cpp, debug, default, defaulting, exists, ffi, forall, full-int
            glasgow-exts, global-optimize, inline-pragmas, jgc, lint, m4, monomorphism-restriction, negate
            prelude, profile, raw, rules, standalone, type-analysis, type-families, unboxed-tuples
            unboxed-values, user-kinds, wrapper

note: type: Plain text
en: ## Code Options
ja: ## コードオプション

note: type: Plain text
en: Various options affecting how jhc interprets and compiles code can be controlled with the '-f' flag, the following options are availible, you can negate any particular one by prepending 'no-' to it.
ja: jhcの解釈やコンパイルは'-f'フラグでコントロールできる。
    これらのオプションを以下に列挙する。また、その効力は'no-'をフラグ名に付けることで無効化できる。

note: type: Plain text
en: Code options              
    ------                    ---------------------------------------------------------------------------
    _bang-patterns_           - bang patterns
    _cpp_                     pass haskell source through c preprocessor
    _exists_                  - exists keyword for existential types recognized
    _ffi_                     support foreign function declarations
    _forall_                  - forall keyword for rank-n types and explicit quantification
    _m4_                      pass haskell source through m4 preprocessor
    _prelude_                 implicitly import Prelude
    _type-families_           type/data family support
    _unboxed-tuples_          allow unboxed tuple syntax to be recognized
    _unboxed-values_          allow unboxed value syntax
    _user-kinds_              user defined kinds
ja: コードオプション
    ------                    ---------------------------------------------------------------------------
    _bang-patterns_           - バン！パターン(強制正格評価パターン)
    _cpp_                     HaskellコードをCプリプロセッサにかけてからコンパイル
    _exists_                  - existsキーワードを存在型の解釈に使う
    _ffi_                     他言語関数インタフェース(FFI)を使う
    _forall_                  - forallキーワードをランクN多相と明白な量化に用いる
    _m4_                      Haskellコードをm4プリプロセッサにかけてからコンパイル
    _prelude_                 Preludeを暗黙の内にimportする
    _type-families_           Type Families(型族)を使う
    _unboxed-tuples_          アンボックス化タプル文法を許容する
    _unboxed-values_          アンボックス化値文法を許容する
    _user-kinds_              ユーザ定義の種を使う

note: type: Plain text
en: Typechecking              
    ------                    ---------------------------------------------------------------------------
    _defaulting_              perform defaulting of ambiguous types
    _monomorphism-restriction_ enforce monomorphism restriction
ja: 型検査
    ------                    ---------------------------------------------------------------------------
    _defaulting_              型のデフォルト化を行なう
    _monomorphism-restriction_ 単相性制限を強制する

note: type: Plain text
en: Debugging                 
    ------                    ---------------------------------------------------------------------------
    _lint_                    perform lots of extra type checks
ja: デバッグ
    ------                    ---------------------------------------------------------------------------
    _lint_                    より多くの型検査を行なう

note: type: Plain text
en: Optimization Options      
    ------                    ---------------------------------------------------------------------------
    _global-optimize_         perform whole program E optimization
    _inline-pragmas_          use inline pragmas
    _rules_                   use rules
    _type-analysis_           perform a basic points-to analysis on types right after method generation
ja: 最適化オプション
    ------                    ---------------------------------------------------------------------------
    _global-optimize_         Eによってプログラム全体を最適化する
    _inline-pragmas_          inlineプラグマを使う
    _rules_                   rulesプラグマを使う
    _type-analysis_           メソッド生成直後に型に対する基本的なpoints-to analysisを適用する

note: type: Plain text
en: Code Generation           
    ------                    ---------------------------------------------------------------------------
    _boehm_                   use Boehm garbage collector
    _debug_                   enable debugging code in generated executable
    _full-int_                extend Int and Word to 32 bits on a 32 bit machine (rather than 30)
    _jgc_                     use the jgc garbage collector
    _profile_                 enable profiling code in generated executable
    _raw_                     just evaluate main to WHNF and nothing else.
    _standalone_              compile to a standalone executable
    _wrapper_                 wrap main in exception handler
ja: コード生成
    ------                    ---------------------------------------------------------------------------
    _boehm_                   Boehm GCを使う
    _debug_                   実行バイナリ中のデバッグコードを有効に
    _full-int_                32bitマシンでIntとWordを32bitに拡張する
    _jgc_                     jgcガーベッジコレクタを使う
    _profile_                 実行バイナリ中のプロファイルコードを有効に
    _raw_                     main関数をWHNFとして評価する
    _standalone_              単独実行可能にコンパイル
    _wrapper_                 main関数を例外ハンドラで包む

note: type: Plain text
en: Default settings          
    ------                    ---------------------------------------------------------------------------
    _default_                 inline-pragmas rules wrapper defaulting type-analysis monomorphism-restriction global-optimize full-int prelude
    _glasgow-exts_            forall ffi unboxed-tuples
ja: 設定既定値
    ------                    ---------------------------------------------------------------------------
    _default_                 inline-pragmas rules wrapper defaulting type-analysis monomorphism-restriction global-optimize full-int prelude
    _glasgow-exts_            forall ffi unboxed-tuples

note: type: Plain text
en: ## Dumping Debugging Information
ja: ## デバッグ情報のダンプ

note: type: Plain text
en: You can have jhc print out a variety of things while running as Controlled by the '-d' flag. The following is a list of possible parameters you can pass to '-d'.
ja: '-d'フラグ付きでjhcを起動することで各種パラメータを出力できる。
    次に挙げるのは'-d'フラグに渡すことができるパラメータのリストである。

note: type: Plain text
en: Front End                 
    ------                    ---------------------------------------------------------------------------
    _defs_                    Show all defined names in a module
    _derived_                 show generated derived instances
    _exports_                 show which names are exported from each module
    _imports_                 show in scope names for each module
    _ini_                     all ini configuration options
    _parsed_                  parsed code
    _preprocessed_            code after preprocessing/deliting
    _renamed_                 code after uniqueness renaming
    _scc-modules_             show strongly connected modules in dependency order
ja: フロントエンド
    ------                    ---------------------------------------------------------------------------
    _defs_                    モジュール内で定義された名前を列挙する(?)
    _derived_                 自動導出されたインスタンスを表示する
    _exports_                 モジュールからエクスポートされている名前を列挙する
    _imports_                 モジュールがインポートしている名前を列挙する
    _ini_                     iniファイルのオプションを表示
    _parsed_                  パース済みコードを出力
    _preprocessed_            プリプロセス後のコードを出力
    _renamed_                 renaming後のコードを出力
    _scc-modules_             強結合したモジュールを依存度順に表示

note: type: Plain text
en: Type Checker              
    ------                    ---------------------------------------------------------------------------
    _all-types_               show unified type table, after everything has been typechecked
    _aspats_                  show as patterns
    _bindgroups_              show bindgroups
    _boxy-steps_              show step by step what the type inferencer is doing
    _class_                   detailed information on each class
    _class-summary_           summary of all classes
    _dcons_                   data constructors
    _decls_                   processed declarations
    _instance_                show instances
    _kind_                    show results of kind inference for each module
    _kind-steps_              show steps of kind inference
    _program_                 impl expls, the whole shebang.
    _sigenv_                  initial signature environment
    _srcsigs_                 processed signatures from source code
    _types_                   display unified type table containing all defined names
ja: 型検査
    ------                    ---------------------------------------------------------------------------
    _all-types_               型検査完了後に型テーブルを表示
    _aspats_                  アズパターンを表示
    _bindgroups_              束縛グループを表示
    _boxy-steps_              型推論の挙動をステップバイステップで表示
    _class_                   個々の型クラスの詳細情報を表示
    _class-summary_           型クラス群の概要を表示
    _dcons_                   データコンストラクタを表示
    _decls_                   処理済みの宣言を表示
    _instance_                インスタンスを表示
    _kind_                    モジュールへの種推論の結果を表示
    _kind-steps_              種推論のステップを表示
    _program_                 プログラム全体の構造
    _sigenv_                  型シグニチャ初期状態の表示
    _srcsigs_                 renaming後の型シグニチャを表示
    _types_                   定義された全ての名前を含んでいる型テーブルを表示

note: type: Plain text
en: Intermediate code         
    ------                    ---------------------------------------------------------------------------
    _core_                    show intermediate core code
    _core-afterlift_          show final core before writing ho file
    _core-beforelift_         show core before lambda lifting
    _core-initial_            show core right after E.FromHs conversion
    _core-mangled_            de-typed core right before it is converted to grin
    _core-mini_               show details even when optimizing individual functions
    _core-pass_               show each iteration of code while transforming
    _core-steps_              show what happens in each pass
    _datatable_               show data table of constructors
    _datatable-builtin_       show data table entries for some built in types
    _e-alias_                 show expanded aliases
    _e-info_                  show info tags on all bound variables
    _e-size_                  print the size of E after each pass
    _e-verbose_               print very verbose version of E code always
    _optimization-stats_      show combined stats of optimization passes
    _rules_                   show all user rules and catalysts
    _rules-spec_              show specialization rules
ja: 中間コード
    ------                    ---------------------------------------------------------------------------
    _core_                    core言語コードを表示
    _core-afterlift_          hoファイルに書き込む直前のcoreコードを表示
    _core-beforelift_         lambda lifting直前のcoreコードを表示
    _core-initial_            E.FromHs転換直前のcoreコードを表示
    _core-mangled_            grinにかける前の型なしcoreコードを表示
    _core-mini_               個々の関数の最適化の詳細を表示
    _core-pass_               コード変形の経過を表示
    _core-steps_              コンパイルパスそれぞれのステップについて表示
    _datatable_               コンストラクタのデータテーブルを表示
    _datatable-builtin_       ビルドイン型のデータテーブルを表示
    _e-alias_                 展開済みエイリアスを表示
    _e-info_                  束縛された値のタグ情報を表示
    _e-size_                  コンパイルパスそれぞれでのEのサイズを表示
    _e-verbose_               Eコードに冗長なメッセージを表示させる
    _optimization-stats_      最適化パスのスタティクスを表示
    _rules_                   ユーザ定義の書き換え規則を表示する
    _rules-spec_              特殊化書き換え規則を表示する

note: type: Plain text
en: Grin code                 
    ------                    ---------------------------------------------------------------------------
    _grin_                    dump all grin to the screen
    _grin-datalog_            print out grin information in a format suitable for loading into a database
    _grin-final_              final grin before conversion to C
    _grin-graph_              print dot file of final grin code to outputname_grin.dot
    _grin-initial_            grin right after conversion from core
    _grin-normalized_         grin right after first normalization
    _grin-posteval_           show grin code just before eval/apply inlining
    _grin-preeval_            show grin code just before eval/apply inlining
    _steps_                   show interpreter go
    _tags_                    list of all tags and their types
ja: Grinコード
    ------                    ---------------------------------------------------------------------------
    _grin_                    grinコードを表示する
    _grin-datalog_            データベースに適したフォーマットでgrinの情報を印字する
    _grin-final_              C言語への変換直前のgrinコードを表示
    _grin-graph_              最終的なgrinコードをdotファイルをoutputname_grin.dotに出力する
    _grin-initial_            core言語から変換された直後のgrinコード
    _grin-normalized_         最初の正規化を行なった直後のgrinコード
    _grin-posteval_           eval/applyインライン化直後のgrinコード
    _grin-preeval_            eval/applyインライン化直前のgrinコード
    _steps_                   インタープリタの実行を表示
    _tags_                    タグと型を列挙する

note: type: Plain text
en: Backend code              
    ------                    ---------------------------------------------------------------------------
    _c_                       don't delete C source file after compilation
ja: バックエンドコード
    ------                    ---------------------------------------------------------------------------
    _c_                       コンパイル時に生成したC言語ソースファイルを削除しない

note: type: Plain text
en: Internal                  
    ------                    ---------------------------------------------------------------------------
    _atom_                    dump atom table on exit
ja: 内部
    ------                    ---------------------------------------------------------------------------
    _atom_                    終了時にatomテーブルをダンプする

note: type: Plain text
en: General                   
    ------                    ---------------------------------------------------------------------------
    _progress_                show basic progress indicators
    _stats_                   show extra information about stuff
    _verbose_                 progress
    _veryverbose_             progress stats
ja: 一般
    ------                    ---------------------------------------------------------------------------
    _progress_                通常のプログレス表示を行なう
    _stats_                   その他の情報を表示する
    _verbose_                 冗長なプログレス表示
    _veryverbose_             スタティクスを含む冗長なプログレス表示

note: type: Plain text
en: # Pragmas
ja: # プラグマ

note: type: Plain text
en: Pragmas are special compiler directives that change its behavior in certain ways. In general, each compiler is free to define its own pragmas however jhc does try to implement the same ones as other compilers when it makes sense.  pragmas appear in source code as {-# PRAGMANAME ... #-}
ja: プラグマは特別なコンパイラへの指示で、コンパイラの挙動に特定の影響を与える。
    一般的には、コンパイラは自由に独自のプラグを定義できる。
    しかしjhcでは他のコンパイラでも使われているものを実装しようと努めている。
    プラグマはソースコード中で {-# PRAGMANAME ... #-} のような形式で使われる。

note: type: Plain text
en: ## Function Properties
ja: ## 関数の属性

note: type: Plain text
en: These must appear in the same file as the definition of a function. To apply one to a instance or class method, you must place it in the where clause of the instance or class declaration.
ja: これらのプラグマは関数定義のあるファイルと同じファイル中に記述すべき。
    インスタンスやクラスの関数に適用するためには、
    これらのプラグマをインスタンスやクラスの宣言の節に配置しなければならない。

note: type: Plain text
en: Pragma
    ------             ----------------------------------------------------
    _NOINLINE_         Do not inline the given function during core transformations. The function _may_ be inlined during grin transformations.
    _INLINE_           Inline this function whenever possible
    _SUPERINLINE_      Always inline no matter what, even if it means making a local copy of the functions body.
    _VCONSTRUCTOR_     Treat the function as a virtual constructor. CPR analysis and the worker/wrapper transforms will treat the function application as if it were a constructor. This implies 'NOINLINE'.
ja: プラグマ
    ------             ----------------------------------------------------
    _NOINLINE_         core変形中のインライン化を抑制する。当該関数はgrin変形中にインライン化される _かもしれない_ 。
    _INLINE_           可能であれば関数をインライン化する
    _SUPERINLINE_      関数本体を単に複製することになったとしても、とにかくインライン化を行なう
    _VCONSTRUCTOR_     関数を仮想コンストラクタとして扱う。CPR解析とworker/wrapper変換は関数をコンストラクタとして扱うことがある。これは'NOINLINE'で実装される。

note: type: Plain text
en: ## Class Pragmas
ja: ## クラスプラグマ

note: type: Plain text
en: Pragma
    ------             ---------------------------------------------------
    _NOETA_            By default, jhc eta-expands all class methods to help enable optimizations. This disables this behavior.
ja: プラグマ
    ------             ---------------------------------------------------
    _NOETA_            デフォルトではjhcは最適化のために全てのクラスメソッドをイータ変換する。このプラグマはこの挙動を無効化する

note: type: Plain text
en: ## Rules/Specializations
ja: ## 書き換え規則と特殊化

note: type: Plain text
en: Pragma
    ------              ---------------------------------------------------
    _RULES_             rewrite rules. These have the same syntax and behave similarly to GHC's rewrite rules, except 'phase' information is not allowed.
    _CATALYST_          A special type of rewrite rule that only fires if it enables the use of another RULE, so a CATALYST may allow optimizations that require passing through a non-optimal intermediate stage.
    _SPECIALIZE_        create a version of a function that is specialized for a given type
    _SUPERSPECIALIZE_   has the same effect as SPECIALIZE, but also places a run-time check in the generic version of the function to determine whether to call the specialized version.
ja: プラグマ
    ------              ---------------------------------------------------
    _RULES_             書き換え規則。GHCの書き換え規則と同様の構文で同様の振舞いをする。ただし、'phase'を使うことはできない。
    _CATALYST_          特殊な書き換え規則で、他のRULESの使用中でのみ発火する。そのためCATALYSTは最良でない中間ステージを要求する最適化を許す。
    _SPECIALIZE_        指定された型で特殊化された関数を生成する
    _SUPERSPECIALIZE_   SPECIALIZEと同じ効力がある。しかし一般化された関数にて特殊化された呼び出しかどうかランタイムでの検査を行なう。

note: type: Plain text
en: ## Type Pragmas
ja: ## 型プラグマ

note: type: Plain text
en: Pragma
    ------             ---------------------------------------------------
    _CTYPE_            Specify the external type that a data or newtype should use for foreign function interfaces.
                       The type must be a newtype or unary data constructor of a type that is already foreignable.
                       Example
                       ~~~
                       data {-# CTYPE "unsigned short" #-} CUShort = CUShort Word16
                       ~~~
ja: プラグマ
    ------             ---------------------------------------------------
    _CTYPE_            FFIでdataもしくはnewtypeを使うたえに、外部の型を指定する。
                       この型はnewtypeかforeign宣言された型の単項コンストラクタでなければならない。
                       例えば
                       ~~~
                       data {-# CTYPE "unsigned short" #-} CUShort = CUShort Word16
                       ~~~

note: type: Plain text
en: ## Header Pragmas
ja: ## ヘッダプラグマ

note: type: Plain text
en: These pragmas are only valid in the 'head' of a file, meaning they must come before the initial 'module' definition and in the first 4096 bytes of the file and must be preceded by and contain only characters in the ASCII character set.
ja: これらのプラグマはファイルの'先頭'でのみ有効である。
    つまりこれらは最初の'module'宣言の前に置かれなければならず、
    ファイルの先頭4096バイト以内に配置されねばらなず、
    そしてASCII文字セットのみしか使ってはならない。

note: type: Plain text
en: OPTIONS_JHC : Specify extra options to use when processing this file. The options available are equivalent to the command line options, though, not all may have meaning when applied to a single file.
ja: OPTIONS_JHC : その他のオプションを指定する。これらのオプションはコマンドラインオプションとしても利用できるが、単一のファイルにのみ影響を与えたい場合に重宝する。

note: type: Plain text
en: LANGUAGE : Specify various language options
ja: LANGUAGE : 言語拡張のオプションを指定する

note: type: Plain text
en: # Extensions
ja: # 拡張

note: type: Plain text
en: ## Module Search Path
ja: ## モジュールのサーチパス

note: type: Plain text
en: Modules in jhc are searched for based on their name as in other Haskell compilers. However in addition to searching for 'Data/Foo.hs' for the module 'Data.Foo', jhc will also search for 'Data.Foo.hs'.
ja: 他のHaskellコンパイラと同じように、jhcでのモジュールはその名前にもとづいて検索される。
    'Data.Foo'モジュールを検索するとjhcは'Data/Foo.hs'ファイルも検索するが、
    'Data.Foo.hs'も同じく検索対象になる。

note: type: Plain text
en: ## extensions to the FFI
ja: ## FFIへの拡張

note: type: Plain text
en: ### foreign imports with multiple return values.
ja: ### 複数の返値をともなうforeign import

note: type: Plain text
en: foreign C imports may return multiple values. To indicate this is the case, use an unboxed tuple as the return value. The first return value will be the value the function directly returns, the rest will be passed as pointers at the end of the functions argument list. Only pure (non IO) functions may return multiple values.
ja: foreign C importは複数の値を返すことがある。
    このような場合、アンボックス化タプルを返値として使う。
    最初の返値は関数から直接返された値であり、
    残りは関数の引数リストの終端へのポインタが返ってくる。
    純粋な(IOではない)関数でのみ複数の値を返値として使うことができる。

note: type: Plain text
en: ~~~~ -- frexp has C prototype -- double frexp(double x, int *exp); -- so it would normally have an import like so, requiring the IO module and -- Storable to call what is otherwise a pure function.
ja: ~~~~
    -- frexpはC言語のプロトタイプ宣言として
    -- double frexp(double x, int *exp);
    -- を持つ。そのため、IOとして通常のimportをすることができ、
    -- 他の純粋な関数へ渡すにはStorableを使うことになる。

note: type: Plain text
en: -- This extension allows it to be declared as so foreign import ccall "math.h frexp" c_frexp2 :: Double -> (# Double, CInt #)
ja: -- この拡張を使うと以下のように宣言できる。
    foreign import ccall "math.h frexp" c_frexp2 :: Double -> (# Double, CInt #)

note: type: Plain text
en: -- The second return value is added as the last 'exp' parameter then read out -- of the allocated memory. The contents of the memory passed into the function -- is undefined.  ~~~~
ja: -- 二番目の返値は最後の'exp'パラメータによって追加されて、アロケートされた
    -- メモリから読み出される。関数に渡されるメモリの内容は未定義である。
    ~~~~

note: type: Plain text
en: ### 'capi' calling convention
ja: ### 呼び出し規約'capi'

note: type: Plain text
en: The 'capi' calling convention may be used instead of 'ccall' for static imports. The convention means that the foreign function may not be addressable as an address, but rather may be implemnted as a macro, builtin, or other compiler specific feature. jhc will ensure that the routine is never used as a pointer and the headers specified in the dependency string are included anywhere the imported function appears. This differs from 'ccall' in that ccall makes no guarentees the given header file will be in scope and that a linker symbol of the exact name is exported.
ja: 呼び出し規約'capi'は'ccall'を使ってたimportのかわりに使われる。
    この規約を使うことで、foreignする対象はアドレス空間に実体がなくても良い。
    マクロやビルドイン関数もしくはその他コンパイラ独自の機能であっても良い。
    jhcはルーチンが決してポインタとしては使用されないこと、依存するヘッダをインクルードすること保証する。
    これは'ccall'と異なる。ccallはヘッダがスコープに入っているか、正しい名前のリンカのためのシンボルがエクスポートされているか、なんの保証もしない。

note: type: Plain text
en: ### package relative dependencies
ja: ### パッケージに関連した依存

note: type: Plain text
en: dependecies in a foreign import may be written as p:foo.c or p:foo.h, this means that the file should be interpreted as part of the internal implementation of the package. jhc willl ensure the files do not clash with those of other packages that may have the same name. The files should be listed in the c-files and c-headers sections of the library config file.
ja: p:foo.c や p:foo.h と書かれたforeign importはそのファイルがパッケージ内部実装の一部として解釈されることを意味している。
    jhcはそれらのファイルが同じ名前を持っていても他のパッケージと衝突しないことを保証する。
    それらのファイルはライブラリファイルのc-filesとc-headersの項目に列挙されるべきである。

note: type: Plain text
en: ## Explicit namespaces in import/export lists
ja: ## import/exportされる名前空間

note: type: Plain text
en: jhc allows explicit namespaces in import and export lists. These may be used to restrict or modiy what is imported/exported by a declaration.
ja: jhcはimportやexportする際の名前空間を持つ。
    これらはimport/export宣言によって制限されたり修正されたりする。

note: type: Plain text
en:     * 'type' - The name is a type, as in something defined by 'type', 'newtype',
           or 'data', or the constructors of a kind declaration.
        * 'class' - Specifies that the name is that of a class.
        * 'data'  - Specifies that the name is a data constructor.
        * 'kind'  - specifies that the name is a user defined kind.
ja:     * 'type' - 名前が型シノニムであり、'type'や'newtype','data',種宣言のコンストラクタで定義されている
        * 'class' - 名前がクラスであることを指定
        * 'data'  - 名前がデータコンストラクタであることを指定
        * 'kind'  - 名前がユーザ定義の種であることを指定

note: type: Plain text
en: In addition, another extension is that classes and types are in independent namespaces, so a type and a class of the same name may be in scope and not conflict.
ja: 型クラスと型シノニムは独立した名前空間にあるので、
    同じ名前の型シノニムと型クラスが同じスコープに存在しても問題ない。

note: type: Plain text
en: ## user defined kinds
ja: ## ユーザ定義された種

note: type: Plain text
en: Jhc allows users to define custom kinds when the -fuser-kinds extension is enabled. The syntax is:
ja: -fuser-kindsオプションが有効な場合、jhcはユーザ定義の種を使用可能にする。
    その文法は:

note: type: Plain text
en: ~~~~ data kind Nat = Z | S Nat ~~~~
ja: ~~~~
    data kind Nat = Z | S Nat 
    ~~~~

note: type: Plain text
en: This will define a new kind 'Nat' and two types 'Z' and 'S' which inhabit it.  The types introduced by kind declarations represent unboxed values with no values, So they have no run-time representation (notably, not even ⊥)
ja: ここでは新しい種'Nat'と、その種に存在する2つの型'Zと'S'を定義している。
    これらの型は値を持たないアンボックス化された値として表現された種の宣言によって定義されている。
    そのためこれらはランタイムでの表現を持たない。(当然、⊥でさえない)

note: type: Plain text
en: ## Standalone deriving
ja: ## 独立deriving

note: type: Plain text
en: Jhc supports a standalone deriving mechanism under certain circumstances.
ja: jhcはある環境下にて独立derivingをサポートする。

note: type: Plain text
en: ## Rank-N Polymorphism
ja: ## ランクN多相性

note: type: Plain text
en: Jhc supports higher ranked polymorphism. jhc will never infer types of higher rank, however when the context unambiguously specifies a higher ranked type, it will be used. For instance, user supplied type annotations and arguments to data constructors defined to by polymorphic will get the correct polymorphic type.
ja: jhcは高ランク多相性をサポートする。
    文脈が高ランク多相型を明確に指定しても、jhcは高ランクの型推論を行なわない。
    例えば、型注釈と多相として定義されたデータコンストラクタへの引数を与えれば、正しい多相型が手に入る。

note: type: Plain text
en: ## Existential types
ja: ## 存在型

note: type: Plain text
en: Jhc supports first class existential types, using the 'exists' keyword. It also supports existential data types in a similar fashion to ghc.
ja: jhcはファーストスラスの存在型をサポートする。
    それは'exists'キーワードで使用できる。
    また存在データ型はghcと似た方法でサポートしている。

note: type: Plain text
en: ## Unboxed Values
ja: ## アンボックス化された値

note: type: Plain text
en: Unboxed values in jhc are specified in a similar fashion to GHC however the lexical syntax is not changed to allow # in identifiers. # is still used in the syntax for various unboxed constructs, but normal Haskell rules apply to haskell identifiers. The convention is to suffix such types with '_' to indicate their status as unboxed. All unboxed values other than unboxed tuples are enabled by the -funboxed-value flag. For compatibility with GHC, the MagicHash extension name also turns on unboxed-values.
ja: jhcでのアンボックス化された値はGHCと同様に指定できる。
    ただし、# をその識別子としては使用しない。
    各種アンボックス化されたコンストラクタのための構文として # はまだ使われているが、
    通常のHaskellのルールをがHaskellの識別子に使われる。
    コンベンションとして'_'の接尾辞の付いた型はアンボックス化された状態にあることを示している。
    アンボックス化タプル以外の全てのアンボックス化された値は、-funboxed-valueフラグによって有効になる。
    GHCとの互換性のため、MagicHash拡張でもアンボックス化型を有効にできる。

note: type: Plain text
en: ### Unboxed Tuples
ja: ### アンボックス化タプル

note: type: Plain text
en: Jhc supports unboxed tuples with the same syntax as GHC, (# 2, 4 #) is an unboxed tuple of two numbers. Unboxed tuples are enabled with -funboxed-tuples.  Unboxed tuples are kind-polymorphic, able to hold both boxed and unboxed values.  (but not another unboxed tuple)
ja: jhcはGHCと同じ文法でアンボックス化タプルをサポートする。(# 2, 4 #) は2つの数値を持つアンボックス化タプルである。
    アンボックス化タプルは-funboxed-tuplesオプションによって有効にできる。
    アンボックス化タプルは種多相であり、ボックス化とアンボックス化の両方おん値を保持することができる。
    (しかし他のアンボックス化タプルを保持することはできない)

note: type: Plain text
en: ### Unboxed Strings
ja: ### アンボックス化文字列

note: type: Plain text
en: Unboxed strings are enabled with the -funboxed-values flag. They are specified like a normal string but have a '#' at the end. Unboxed strings have types 'BitsPtr_'.
ja: アンボックス化文字列は-funboxed-valuesフラグによって有効になる。
    通常の文字列と異なり、その名前は'#'で終わる。
    アンボックス化文字列は'BitsPtr_'型である。

note: type: Plain text
en: ### Unboxed Characters
ja: ### アンボックス化文字

note: type: Plain text
en: Unboxed characters can be expressed by putting a hash after a normal character literal. Unboxed characters are of type Char_ which is a newtype of Bits32_ and defined in Jhc.Prim.Bits
ja: アンボックス化文字は通常の文字リテラルの後に # を付けて表現する。
    アンボックス化文字はChar_型であり、さらにJhc.Prim.Bitsに定義のあるBits32_のnewtypeでもある。

note: type: Plain text
en: ### Unboxed Numbers
ja: ### アンボックス化数値

note: type: Plain text
en: Unboxed numbers are enabled with the -funboxed-values flag. They are postpended with a '#' such as in 3# or 4#. Jhc supports a limited form of type inference for unboxed numbers, if the type is fully specified by the environment and it is a suitable unboxed numeric type then that type is used. Otherwise it defaults to Int__. Whether the type is fully specifed follows the same rules as rank-n types. Unboxed numbers do the right thing for enumerations, so 0# can be used for the unboxed False value and the appropriate type will be infered.
ja: アンボックス化数値は-funboxed-valuesフラグによって有効になる。
    それらは 3# や 4# のように'#'を付けて表現する。
    もし型が環境によって完全に指定されてて、かつそれが適切なアンボックス化数値型であるなら、jhcは型推論を限定的にサポートする。
    そうでない場合にはInt__をデフォルトとして使用する。
    型が完全に指定されているかどうかにかかわらず、ランクN型として同じルールが適用される。
    アンボックス化数値は列挙可能である。
    そのため 0# はアンボックス化されたFalse値として使うことができる。
    そして型推論も行なわれる。

note: type: Plain text
en: ### Operations on unboxed values
ja: ### アンボックス化された値の取り扱い

note: type: Plain text
en: To operate on unboxed vaules you need to bring the appropriate primitive operators into scope. You can do this via the special form of FFI declaration for importing primitives.  Any C-- primitive may be imported as well as a variety of utility routines. the primitive import mechanism is 'smart' in that it will dig through newtypes and take care of boxing/unboxing values as needed.  So you can import a primitive on Char and it will take care of boxing the value up in the 'Char' constructor as well as the Char_ newtype for Bits32_, ultimately choosing the right Bits32_ primitive. imported primitives are normal haskell declarations so may be exported/imported from modules or passed as higher order functions like normal.
ja: アンボックス化値を取り扱うために、適切なプリミティブの演算子をスコープ内に用意する必要がある。
    プリミティブのimportのために特殊なFFI宣言を使うことができる。
    全てのC--プリミティブはユーティリティ関数と同様にimportできる。
    プリミティブimportはのしくみは'スマート'で、newtype宣言を通りぬけ、ボックス化/アンボックス化値が必要か面倒をみてくれる。
    だからあなたがプリミティブをCharにimportしたなら、
    それが'Char'コンストラクタをボックス化されていると認識し、
    Char_がBits32_のnewtypeであることも認識してくれる。
    そして遂には正しいBits32_プリミティブを選択してくれるのだ。
    importされたプリミティブは通常のHaskell宣言である。
    だからモジュールからexport/importできるし、通常の高階関数としても扱える。

note: type: Plain text
en: ## Foreign Primitives
ja: ## Foreignプリミティブ

note: type: Plain text
en: In addition to foreign imports of external functions as described in the FFI spec. Jhc supports 'primitive' imports that let you communicate primitives directly to the compiler. In general, these should not be used other than in the implementation of the standard libraries. They generally do little error checking as it is assumed you know what you are doing if you use them. All haskell visible entities are introduced via foreign declarations in jhc.
ja: FFIの仕様であるforeign importに加えてjhcは'primitive' importをサポートしていて、
    あなたはこれを用いてコンパイラと直接通信することができる。
    一般的にこれらは基盤ライブラリの実装以外の用途に使われるべきではない。
    一般にこれらは少ないエラーチェックしか行なわない。
    jhc内では、すべてのHaskellのエントリはforeign宣言によって形づくられている。

note: type: Plain text
en: They all have the form
ja: それらは以下の形を取る。

note: type: Plain text
en: where "specification" is one of the following
ja: "specification"には以下を選択できる。

note: type: Plain text
en: seq : evaluate first argument to WHNF, then return the second argument
ja: seq : 最初の引数をWHNFとして評価し、二番目の引数を返す

note: type: Plain text
en: zero,one : the values zero and one of any primitive type.
ja: zero,one : 0か1の値をプリミティブ型に使う

note: type: Plain text
en: const.C_CONSTANT : the text following const is directly inserted into the resulting C file
ja: const.C_CONSTANT : constに続くテキストをコンパイル結果のC言語ソースコードに直接埋め込む

note: type: Plain text
en: peek.TYPE : the peek primitive for raw value TYPE
ja: peek.TYPE : TYPE型の値の読み込みプリミティブ

note: type: Plain text
en: poke.TYPE : the poke primitive for raw value TYPE
ja: poke.TYPE : TYPE型の値の書き込みプリミティブ

note: type: Plain text
en: sizeOf.TYPE, alignmentOf.TYPE, minBound.TYPE, maxBound.TYPE, umaxBound.TYPE : various properties of a given internal type.
ja: sizeOf.TYPE, alignmentOf.TYPE, minBound.TYPE, maxBound.TYPE, umaxBound.TYPE : 内部型TYPEの各種属性

note: type: Plain text
en: constPeekByte : peek of a constant value specialized to bytes, used internally by Jhc.String
ja: constPeekByte : 指定したバイト数、定数値を読み込み、Jhc.Stringとして使う

note: type: Plain text
en: box : take an unboxed value and box it, the shape of the box is determined by the type at which this is imported
ja: box : アンボックス化値を取り、それをボックス化する。ボックス化された形はimportされた型によって決まる

note: type: Plain text
en: unbox : take an boxed value and unbox it, the shape of the box is determined by the type at which this is imported
ja: unbox : ボックス化値を取り、アンボックス化する。ボックスの形はimportされた型によいって決まる

note: type: Plain text
en: increment, decrement : increment or decrement a numerical integral primitive value
ja: increment, decrement : 整数のプリミティブ値を増減させる

note: type: Plain text
en: fincrement, fdecrement : increment or decrement a numerical floating point primitive value
ja: fincrement, fdecrement : 浮動小数点のプリミティブ値を増減させる

note: type: Plain text
en: exitFailure__ : abort the program immediately
ja: exitFailure__ : プログラムを即時abortさせる

note: type: Plain text
en: C-- Primitive : any C-- primitive may be imported in this manner.
ja: C-- Primitive : C--プリミティブはこの作法でimportする

note: type: Plain text
en: # Differences
ja: # 差異

note: type: Plain text
en: ## Differences from Haskell 98
ja: ## Haskell 98との違い

note: type: Plain text
en: ### Language Differences
ja: ### 言語差分

note: type: Bullet: '* '
en: Class contexts on data types are silently ignored.
ja: データタイプ内のクラス文脈は単に無視される。

note: type: Bullet: '* '
en: Class methods are fully 'eta expanded' out to the argument count specified by the type. This is often beneficial as instances that need to share partial applications are rare. This behavior can be turned off with the NOETA pragma for specific methods.
ja: クラスメソッドはイータ変換されて引数の数は型によって指定される。
    部分適用することがめったにないインスタンスではこれはしばしば有益だ。
    この挙動はNOETAプラグマによって無効にできる。

note: type: Plain text
en: ### Library Changes
ja: ### ライブラリへの変更

note: type: Plain text
en: In addition to a larger set of base libraries roughly modeled on GHC's base.  Jhc provides a number of extensions/minor modifications to the standard libraries. These are designed to be mostly backwards compatible and most are to the class system.
ja: GHCのbaseにおおざっぱに沿ったbaseライブラリに加えて、
    jhcはいくつかの拡張とマイナーな修正を標準ライブラリに施している。
    これらは大部分は後方互換性とクラスシステムのためにデザインされている。

note: type: Plain text
en: * Data.Bits
        * Num is no longer a super class of Data.Bits. It never should have been.
        * There are new methods logicalShiftR and arithmeticShiftR that do a logical and
          arithmetic shift respectively. shiftR will always map to one of those as
          appropriate.
        * shiftR and shiftL do not check for negative arguments, if you might want
          negative arguments, use the general 'shift' routine. 'shift' also comes
          in logical and arithmetic varieties.
ja: * Data.Bits
        * NumはData.Bitsのスーパークラスではない。
        * logicalShiftRとarithmeticShiftR関数を追加した。それぞれ論理的、算術的なシフトを行なう。
        * shiftRとshiftL関数は負の引数をチェックしない。
          もし負の引数を使うならば一般的な'shift'ルーチンを使うこと。
          'shift'にはまた論理的と算術的なバリエーションがある。

note: type: Plain text
en: ### Library Additions
ja: ### ライブラリの追加

note: type: Plain text
en: There are many other additional libraries provided with jhc, here I list only changes that affect modules that are defined by the haskell 98 or FFI specifications.
ja: jhcはその他多くの追加ライブラリを提供している。
    ここではHaskell98もしくはFFIの仕様で定義されているモジュールに影響する変更だけを挙げるにとどめる。

note: type: Plain text
en: * Data.Int and Data.Word provide WordPtr, WordMax, IntPtr, and IntMax that
       correspond to the C types uintptr_t, uintmax_t, intptr_t, and intmax_t
       respectively.
ja: * Data.IntとData.Wordは左記を提供するWordPtr, WordMax, IntPtr, IntMax。
       これらはそれぞれC言語のuintptr_t, uintmax_t, intptr_t, intmax_t型に該当する。

note: type: Plain text
en: * fromInt,toInt,fromDouble,toDouble have been added
       alongside Integer and Rational routines in their respective classes.
ja: * IntegerとRationalクラスの実装近くのにfromInt,toInt,fromDouble,toDouble
       が追加された。

note: type: Plain text
en: * floating point truncation and rounding functions have varieties that don't
       return an integral type, but rather return something of the same type
       as its argument. These have the same name but end in 'f'.
ja: * 浮動小数点の切り捨てと丸める関数に相違がある。
       それらは整数型を返さず、引数と同じ型をかわりに返す。
       これらの関数名には'f'という接尾辞が付いている。

note: type: Plain text
en: ## Notable Differences from GHC
ja: ## GHCとの注目すべき差異

note: type: Plain text
en: Jhc differs from GHC in certain ways that are allowed by Haskell 98, but might come as a surprise to some.
ja: jhcはHaskell 98には準拠しているがGHCとの差異がある。

note: type: Bullet: ' * '
en: An Int may be only 30 bits and may not observe simple binary truncation on overflow. If you need known bit width and binary semantics for your numbers then use the types in Data.Int and Data.Word. Overflow on Int or Word has undefined results.
ja: Intは30ビットしか保持せず、切り捨ては検知できない。
    もし数値にビット幅とバイナリの意味論が必要な場合、Data.IntかData.Wordの型を使用すること。
    IntやWordがあふれた場合の結果は未定義である。

note: type: Bullet: ' * '
en: A Char may only preserve values within the Unicode range. Storing values greater than 0x10FFFF has undefined results.
ja: 文字はUnicode幅の値しか保持できない。
    そのため0x10FFFFより多きな保存されている値は未定義な結果をもたらす。

note: type: Bullet: ' * '
en: The Int and Word types are at most 32 bits, even on 64 bit architectures.
ja: 例え64ビットアーキティクチャ上でもIntとWord型は最大でも32ビット幅である。

note: type: Bullet: ' * '
en: All text based IO is performed according to the current locale. This means that Unicode works seamlessly, but older programs that assumed IO was performed by simple truncation of chars down to 8 bits will fail. Use the explicit binary routines if you need binary IO.
ja: テキストベースのIOは現在のロケールで実行される。
    つまりUnicodeについてはうまく使用できるが、
    IOが8ビット文字を仮定する古いプログラムは異常なふるまいになる。
    もしバイナリのIOが必要であれば、バイナリのルーチンを明示的に使うこと。

note: type: Plain text
en: ## Differences That are Considered Misfeatures
ja: ## 仕様の欠陥

note: type: Plain text
en: These misfeatures will be fixed at some point.
ja: これらの仕様の欠陥は将来修正される予定である。

note: type: Bullet: ' * '
en: Integer corresponds to IntMax rather than an arbitrary precision type. As soon as a suitable arbitrary precision library emerges, it will be replaced.
ja: Integer型は任意精度型ではなく、IntMax型と同じ精度である。
    適切な任意精度ライブラリが見つかれば、この問題は修正されるだろう。

note: type: Bullet: ' * '
en: Ix is not derivable.
ja: Ix型は自動導出できない。

note: type: Plain text
en: # CrossCompilation
ja: # クロスコンパイル

note: type: Plain text
en: ## Basics
ja: ## 基本

note: type: Plain text
en: Unlike many other compilers, jhc is a native cross compiler. What this means is that every compile of jhc is able to create code for all possible target systems. This leads to many simplifications when it comes to cross compiling with jhc. Basically in order to cross compile, you need only pass the flag '--cross' to jhc, and pass an appropriate '-m' option to tell jhc what machine you are targetting. An example would be
ja: 他の多くのコンパイラと異なり、jhcは生来のクロスコンパイラである。
    これが意味することは、jhcによるコンパイルによって、どんなターゲットシステムのためのコードも生成できるということである。
    これにより、jhcを利用したクロスコンパイルが非常に簡単になる。
    基本的には、クロスコンパイルを行うためにはjhcに '--cross' フラグと、
    ターゲットマシンを指定するオプション '-m'を渡せば良い。
    以下がその例である。

note: type: Plain text
en: The targets list is extensible at run-time via the targets.ini file explained below.
ja: targets.iniファイルに以下のような表記を追加すれば、ターゲットのリストを拡張できる。

note: type: Plain text
en: This file determines what targets are available. The format consists of entries as follows.
ja: このファイルは利用可能なターゲットを列挙する。
    フォーマットは以下のエントリから成り立っている。

note: type: Plain text
en: merge is a special key meaning to merge the contents of another target into the current one. The configuration file is read in order, and the final value set for a given key is the one that is used.
ja: mergeは特別なキーで他のターゲットから現在のターゲットへ内容をマージしていることを意味する。
    設定ファイルは先頭から順に読み込まれ、
    与えられたキーに対応する最後の値が実際に使われる。

note: type: Plain text
en: An example describing how to cross compile for windows is as follows:
ja: 次に示すのはWindowsクロスコンパイルの例である:

note: type: Plain text
en: This sets the compiler to use as well as a few other options then jumps to the generic i686 routine. The special target [default] is always read before all other targets. If '--cross' is specified on the command line then this is the only implicitly included configuration, otherwise jhc will assume you are compiling for the current architecture and choose an appropriate target to include in addition to default.
ja: 上記は一般のi686設定を使って少々の他のオプションをコンパイラに設定している。
    特別なターゲットである[default]は常に他のターゲットより先に読み込まれる。
    もしコマンドラインから'--cross'が指定されたら暗黙にこの設定を読み込む。
    さもなければjhcは現アーキティクチャをコンパイル対象としてみなして、
    defaultに追加して適切なターゲットを選択する。

note: type: Plain text
en: jhc will attempt to read several targets.ini files in order. they are
ja: jhcは複数のtargets.iniファイルを順に読み込もう試みる。
    それらのファイルは以下である。

note: type: Plain text
en: $PREFIX/etc/jhc-\$VERSION/targets.ini : this is the targets.ini that is included with jhc and contains the default options.
ja: $PREFIX/etc/jhc-\$VERSION/targets.ini : このtargets.iniファイルはjhcによって読み込まれ、既定のオプションを含む。

note: type: Plain text
en: $PREFIX/etc/jhc-\$VERSION/targets-local.ini : jhc will read this if it exists, it is used to specify custom system wide configuration options, such as the name of local compilers.
ja: $PREFIX/etc/jhc-\$VERSION/targets-local.ini : jhcは存在すればこのファイルを読み込む。このファイルはローカルのコンパイラのようなシステムグローバルのカスタム設定を含む。

note: type: Plain text
en: $HOME/.jhc/targets.ini : this is where a users local configuration information goes.
ja: $HOME/.jhc/targets.ini : ユーザローカルの設定

note: type: Plain text
en: $HOME/etc/jhc/targets.ini : this is simply for people that prefer to not use hidden directories for configuration
ja: $HOME/etc/jhc/targets.ini : このファイルは隠し属性のディレクトリを嫌う人向けのものである

note: type: Plain text
en: The last value specified for an option is the one used, so a users local configuration overrides the system local version which overrides the built in options.
ja: オプションについて有効とみなされるのは最後の値である。
    ユーザ定義のローカル設定はシステムグローバルのローカル設定を上書きする。
    またシステムグローバルのローカル設定は組み込みのオプションを上書きする。

note: type: Plain text
en: ## Options available
ja: ## 利用可能なオプション

note: type: Plain text
en: Option                    Meaning
    ------                    ---------------------------------------------------------------------------
    _cc_                      what c compiler to use. generally this will be gcc for local builds and something like $ARCH-$HOST-gcc for cross compiles
    _byteorder_               one of *le* or *be* for little or big endian
    _gc_                      what garbage collector to use. It should be one of *static* or *boehm*.
    _cflags_                  options to pass to the c compiler
    _cflags\_debug_           options to pass to the c compiler only when debugging is enabled
    _cflags\_nodebug_         options to pass to the c compiler only when debugging is disabled
    _profile_                 whether to include profiling code in the generated executable
    _autoload_                what haskell libraries to autoload, seperated by commas.
    _executable\_extension_   specifies an extension that should be appended to executable files, (i.e. .EXE on windows)
    _merge_                   a special option that merges the contents of another configuration target into the currrent one.
    _bits_                    the number of bits a pointer contains on this architecture
    _bits\_max_               the number of bits in the largest integral type. should be the number of bits in the 'intmax_t' C type.
    _arch_                    what to pass to gcc as the architecture
ja: オプション                意味
    ------                    ---------------------------------------------------------------------------
    _cc_                      Cコンパイラを指定。一般に手元でのコンパイルにはgccを指定し、クロスコンパイルには$ARCH-$HOST-gccを指定する。
    _byteorder_               リトル/ビッグエンディアンのために *le* もしくは *be* を指定する
    _gc_                      GCを使う。*static* もしくは *boehm* を指定する。
    _cflags_                  Cコンパイラに渡すオプション
    _cflags\_debug_           デバッグが有効な場合のにみCコンパイラに渡すオプション
    _cflags\_nodebug_         デバッグが無効な場合のにみCコンパイラに渡すオプション
    _profile_                 プロファイルコードを実行バイナリに出力する
    _autoload_                自動読み込みされるHaskellライブラリを指定。コンマで区切る。
    _executable\_extension_   実行バイナリファイルの拡張子を指定する (すなわちWindowsでは.EXEとなる)
    _merge_                   他の設定ターゲットの内容を現ターゲットにマージする特別なオプション
    _bits_                    このアーキティクチャでポインタが保有するビット数
    _bits\_max_               整数型の最大値が保有するビット数。これは'intmax_t'のC言語型と同じビット数でなければならない。
    _arch_                    gccに渡すアーキティクチャ名

note: type: Plain text
en: # Internals
ja: # 内部設計

note: type: Plain text
en: ## The Run Time System
ja: ## ランタイムシステム

note: type: Plain text
en: Jhc is very minimalist in that it does not have a precompiled run time system, but rather generates what is needed as part of the compilation process.  However, back ends do have specific run-time representations of data, which can be affected by things like the choice of garbage collector. The following describes the general layout for the C based back-ends, but compiler options such as garbage collection method or whether we do full program analysis, will affect which features are used and whether certain optimized layouts are possible.
ja: jhcは強いミニマリストであり、あらかじめコンパイルされたランタイムを持たない。
    ランタイムはコンパイル時に必要になった際に生成される。
    けれどもバックエンドは、GCの選択のように、ランタイム特定のデータ表現を持つ。
    C言語ベースのバックエンドのための一般レイアウトを次に示す。
    しかしGC種別のようなコンパイラオプションやプログラム全体解析は、どの機能が使われて、最適化されたレイアウトが使用できるかに影響を及ぼす。

note: type: Plain text
en: Unboxed values directly translate to values in the target language, an unboxed Int will translate directly into an 'int' as an argument and an unboxed pointer will be a raw pointer. Unboxed values have no special interpretation and are _not_ followed by the garbage collector. If the target language does not support a feature such as multiple return values, it will have to be simulated.  It would not be wrong to think of Grin code that only deals with unboxed values to be isomorphic to C-- or C augmented with multiple return values.
ja: アンボックス化値はターゲットの言語の値に直接翻訳される。
    アンボックス化Intは引数として直接'int'に翻訳される。
    またアンボックス化ポインタは生のポインタになる。
    アンボックス化値は特別な解釈を持たず、 _GCは面倒をみてくれない_ 。
    もしターゲットの言語が複数返値のような機能をサポートしていない場合、シミュレーションする必要がある。
    grinコードが複数返値が補強されたC--もしくはCへの同型としてのみアンボックス化値を取り扱うのは悪い考えではない。

note: type: Plain text
en: Boxed values have a standard representation and can be followed. Unlike some other implementation, being boxed does not imply the object is located on the heap. It may be on the stack, heap, or even embedded within the smart pointer itself. Being boxed only means that the object may be represented by a smart pointer, which may or may not actually be a pointer in the traditional sense.
ja: ボックス化された値は標準の表現を持っている。
    他の実装と異なり、ボックス化されることがオブジェクトがヒープに配置されることを意味しない。
    それはスタックやヒープに確保されるかもしれない。
    さらにはスマートポインタの中に組み込まれているかもしれない。
    ボックス化されていることはオブジェクトがスマートポインタによって表現されているか、
    実際には伝統的なポインタであるかもしれないのだ。

note: type: Plain text
en: A boxed value in jhc is represented by a 'smart pointer' of c type sptr_t. a smart pointer is the size of a native pointer, but can take on different roles depending on a pair of tag bits, called the ptype.
ja: jhcにおけるボックス化された値はC言語型のsptr_tという'スマートポインタ'である。
    スマートポインタは通常のポインタと同じサイズを持つが、
    1つのペアのタグビットで表わされる別の役割もおっている。
    それはptypeと呼ばれる。

note: type: Plain text
en: smart pointers take on a general form as follows:
ja: スマートポインタは一般に以下の形をしている:

note: type: Plain text
en:       G - if set, then the garbage collector should not treat value as a pointer to be followed
          L - lazy, this bit being set means the value is potentially not in WHNF
ja:       G - セットされると、GCは値をポインタとして取り扱わない
          L - 遅延。このビットがセットされると値はWHNFではないことを示す

note: type: Plain text
en: A sptr_t on its own in the wild can only take on one of the following forms:
ja: sptr_tは以下の形の内どれか一つの状態にある:

note: type: Plain text
en: WHNF stands for 'Weak Head Normal Form' and means that the value is not a suspended function and hence not a pointer to a thunk. It may be directly examined and need not be evaluated. wptr_t is an alias for sptr_t that is guarenteed to be of one of the above forms. It is used to improve safety for when we can statically know that a value is WHNF and hence we can skip the expensive 'eval'.
ja: WHNFは'Weak Head Normal Form'を表わしている。
    さらにその値は中断された関数ではなく、それゆえサンクへのポインタでもない。
    それは直接検査されるかもしれず、また評価される必要がないかもしれない。
    wptr_tはsptr_tの別名で、上記の形式を取っていることを保証するためにある。
    これは安全性を向上させるために使われ、
    値がWHNFであり高価な'eval'をスキップできるかどうかを静的に知ることができる。

note: type: Plain text
en: The difference between the raw value and the whnf location is that the first contains uninterpreted bits, while the second is a pointer to a location on the heap or stack and hence the garbage collector should follow it. The format of the memory pointed to by the whnf location is unspecified and dependent on the actual type being represented.
ja: 生の値とWHNF配置の違いは、
    前者は未解釈のビットを保持しているが、
    後者はヒープやスタックへのポインターであるためにGCが回収する必要があるということだ。
    WHNF配置によって指し示されたメモリのフォーマットは実際の型表現に依存していていちがいに決まってはいない。

note: type: Plain text
en: Partial (unsaturated) applications are normal WHNF values. Saturated applications which may be 'eval'ed and updated are called thunks and must not be pointed to by WHNF pointers. Their representation follows.
ja: 部分適用された関数は通常のWHNF値である。
    'eval'されたか更新された全適用された関数はサンクと呼ばれ、WHNFのポインタから指示されない。
    これらの表現は以下である。

note: type: Plain text
en: A lazy location points to either a thunk, or a redirection to a WHNF value. A lazy location is always a pointer to an allocated block of memory which always begins with a restricted smart pointer. This restricted smart pointer is represented by the C type alias 'fptr_t'. fptr_t's only occur as the first entry in a lazy location, they never are passed around as objects in their own right.
ja: 遅延配置はサンクもしくはWHNFへのリダイレクトトを指し示す。
    遅延配置は必ずアロケートされたメモリ領域を差し、
    その領域の先頭は制限されたスマートポインタである。
    この制限されたスマートポインタはC言語の'fptr_t'型で表現される。
    fptr_tは遅延配置の先頭エントリのためだけに存在し、
    それらはオブジェクトとして流通することはない。

note: type: Plain text
en: A fptr_t may be a whnf value or a code pointer. If a fptr_t is a whnf value (of one of the two forms given above) then it is called a redirection, the lazy location should be treated exactly as if it were the whnf given. This is used to redirect an evaluated thunk to its computed value.
ja: fptr_tはWHNF値もしくはコードへのポインタである可能性がある。
    もしfptr_tが(上図2種類の内の一つのような)WHNF値ならそれはリダイレクションと呼ばれる。
    遅延配置はそれがWHNFによるものだと厳密に取り扱わなければならない。
    これは評価済みサンクへのリダイレクトとして使われる。

note: type: Plain text
en: A fptr_t may also be a 'code pointer' in which case the lazy location is called a thunk. A code pointer is a pointer to executable machine code that evaluates a closure and returns a wptr_t, the returned wptr_t is then generally written over the code pointer, turning the thunk into a redirection. It is the responsibility of the code pointed to to perform this redirection.
ja: fptr_tはまた'コードポインタ'である可能性があり、
    この場合遅延配置はサンクと呼ばれる。
    コードポインタは実行可能な機械語へのポインタで、それはクロージャを評価してwptr_tを返す。
    返却されたwptr_tは通常、サンクをリダイレクションに変更するために、コードポインタを書きつぶす。
    指示されたコードはこのリダイレクションを実行する責任がある。

note: type: Plain text
en: When debugging, the special code pointer BLACK_HOLE is also sometimes stored in a fptr_t to detect certain run-time errors.
ja: デバッグ時には特殊なコードポインタBLACK_HOLEが時々fptr_tに格納されている。
    これはある種のランタイムエラーを検出する。

note: type: Plain text
en: Note that unlike other implementations, a fptr_t may _not_ be another lazy location. you can not have chained redirections, a redirection is always a redirection to a whnf value.
ja: 他の実装と異なりfptr_tは遅延配置の別の形では _ない_ ことに注意すること。
    あなたはリダイレクションをチェーンしてはいけない。
    リダイレクションは常にWHNF値へのリダイレクションでなければならない。

note: type: Plain text
en:     sptr_t - a tagged smart pointer, may contain a whnf value or a lazy location.
        wptr_t - a tagged smart pointer that contains a whnf value (either raw or a location)
        fptr_t - a tagged smart pointer, may contain a whnf value indicating a redirection, or a code pointer indicating a thunk.
ja:     sptr_t - タグ付けされたスマートポインタ。WHNF値か遅延配置を保持する。
        wptr_t - タグ付けされたスマートポインタ。生か配置情報のWNHF値を保持する。
        fptr_t - タグ付けされたスマートポインタ。リダイレクションを示すWHNF値かサンクを示すコードポインタを保持する。

note: type: Plain text
en: ## Jhc Core Type System
ja: ## jhcコア型システム

note: type: Plain text
en: Jhc's core is based on a pure type system. A pure type system (also called a PTS) is actually a parameterized set of type systems. Jhc's version is described by the following.
ja: jhcのコアは純粋なpure type systemにもとづいている。
    pure type system (PTS)は型システムのパラメータ化されたセットである。
    jhcのPTSについて以下で解説する。

note: type: Plain text
en:     Sorts  = (*, !, **, #, (#), ##, □)
        Axioms = (*:**, #:##, !:**, **:□, ##:□)
ja:     種類 = (*, !, **, #, (#), ##, □)
        公理 = (*:**, #:##, !:**, **:□, ##:□)

note: type: Plain text
en:     -- sort kind
        *   is the kind of boxed values
        !   is the kind of boxed strict values
        #   is the kind of unboxed values
        (#) is the kind of unboxed tuples
        -- sort superkind
        **  is the superkind of all boxed value
        ##  is the superkind of all unboxed values
        -- sort box
        □   superkinds inhabit this
ja:     -- 種類kind(種)
        *   ボックス化値の種
        !   ボックス化された正格値の種
        #   アンボックス化された種
        (#) アンボックス化タプルの種
        -- 種類superkind
        **  全てのボックス化値のsuperkind
        ##  全てのアンボックス化値のsuperkind
        -- 種類box
        □   superkindの存在位置

note: type: Plain text
en:     in addition there exist user defined kinds, which are always of supersort ##
ja:     ユーザ定義の種の存在に加えて、supersort ##が存在する。

note: type: Plain text
en: The following Rules table shows what sort of abstractions are allowed, a rule of the form (A,B,C) means you can have functions of things of sort A to things of sort B and the result is something of sort C. _Function_ in this context subsumes both term and type level abstractions.
ja: 次に示すルール表は抽象の種類を表現している。
    (A,B,C)の形をもつルールは種類Aから種類Bへの関数で結果が種類Cであることを意味している。
    この文脈での _関数_ は項と型レベルの抽象を含んでいる。

note: type: Plain text
en: Notice that functions are always boxed, but may be strict if they take an unboxed tuple as an argument.  When a function is strict it means that it is represented by a pointer to code directly, it cannot be a suspended value that evaluates to a function.
ja: アンボックス化タプルを引数に取り正格であるかもしれないが、
    関数はいつもボックス化されていることに注意すること。
    コードを直接指示するポインタによって表現され、関数が正格であるなら、
    関数の評価が中断された値であることはありえない。

note: type: Plain text
en: These type system rules apply to lambda abstractions. It is possible that data constructors might exist that cannot be given a type on their own with these rules, even though when fully applied it has a well formed type. An example would be unboxed tuples. This presents no difficulty as one concludes correctly that it is a type error for these constructors to ever appear when not fully saturated with arguments.
ja: これらの型システムのルールはλ抽象に適用される。
    これらのルールによって、与えられた型を取れないデータコンストラクタが存在してしまうかもしれないが、それは許容できる。
    例としてはアンボックス化タプルがある。
    部分適用された関数であったとしてもそれらのコンストラクタが型エラーであることを正しく推論するのは困難ではない。

note: type: Plain text
en:     as a shortcut we will use *# to mean every combination involving * and #, and so forth.
        for instance, (*#,*#,*) means the set (*,*,*) (#,*,*) (*,#,*) (#,#,*)
ja:     ショートカットとしてここでは *# を * と # の組み合わせをとして使う。
        例えば、 (*#,*#,*) は (*,*,*) (#,*,*) (*,#,*) (#,#,*) のセットを意味している。

note: type: Plain text
en:     Rules =
           (*#!,*#!,*)  -- functions from values to values are boxed and lazy
           (*#!,(#),*)  -- functions from values to unboxed tuples are boxed and lazy
           ((#),*#!,!)  -- functions from unboxed tuples to values are boxed and strict
           ((#),(#),!)  -- functions from unboxed tuples to unboxed tuples are boxed and strict
           (**,*,*)     -- may have a function from an unboxed type to a value
           (**,#,*)
           (**,!,*)
           (**,**,**)  -- we have functions from types to types
           (**,##,##)  -- MutArray_ :: * -> #
           (##,##,##)  -- Complex_ :: # -> #
ja:     ルール =
           (*#!,*#!,*)  -- 値から値への関数で、ボックス化されていて非正格
           (*#!,(#),*)  -- 値からアンボックス化タプルへの関数で、ボックス化されていて非正格
           ((#),*#!,!)  -- アンボックス化タプルから値への関数で、ボックス化されていて正格
           ((#),(#),!)  -- アンボックス化タプルからアンボックス化タプルへの関数で、ボックス化されていて正格
           (**,*,*)     -- アンボックス化型から値への関数を保持している可能性がある
           (**,#,*)
           (**,!,*)
           (**,**,**)  -- 型から型への関数を持てる
           (**,##,##)  -- MutArray_ :: * -> #
           (##,##,##)  -- Complex_ :: # -> #

note: type: Plain text
en:     The defining feature of boxed values is
ja:     ボックス化値の定義は以下である。

note: type: Plain text
en:     This PTS is functional but not injective
ja:     このPTSは関数的であるが単射ではない。

note: type: Plain text
en: The PTS can be considered stratified into the following levels
ja: このPTSは次のレベルに階層化されている。

note: type: Plain text
en:     □                - sort box
        **,##,           - sort superkind
        *,#,(#),!        - sort kind
        Int,Bits32_,Char - sort type
        3,True,"bob"     - sort value
ja:     □               - 種類box
        **,##,           - 種類superkind
        *,#,(#),!        - 種類kind(種)
        Int,Bits32_,Char - 種類type(型)
        3,True,"bob"     - 種類value(値)

note: type: Plain text
en: ### On boxed kinds
ja: ### ボックス化kind(種)について

note: type: Plain text
en: The boxed kinds (* and !) represent types that have a uniform run time representation. Due to this, functions may be written that are polymorphic in types of these kinds.  Hence the rules of the form (**,?,?), allowing taking types of boxed kinds as arguments.
ja: ボックス化kind(* や !)は同型のランタイム表現を持つ型を表現する。
    このため、関数はこれらのkindの型で多相的に記述することができる。
    (**,?,?)という形のルールがあるため、ボックス化されたkindの型を引数として取ることができる。

note: type: Plain text
en: the unboxed kind # is inhabited with types that have their own specific run time representation. Hence you cannot write functions that are polymorphic in unboxed types
ja: アンボックス化されたkind # は独自のランタイム表現を持つ型に存在する。
    アンボックス化型を多相的に使う関数を書くことはできない。

note: type: Plain text
en: ### On sort box, the unboxed tuple, and friends
ja: ### 種類box、アンボックス化タプルとその同類について

note: type: Plain text
en: Although sort box does not appear in the code, it is useful from a theoretical point of view to talk about certain types such as the types of unboxed tuples.  Unboxed tuples may have boxed and unboxed arguments, without sort box it would be impossible to express this since it must be superkind polymorphic. sort box allows one to express this as (in the case of the unboxed 2-tuple)
ja: 種類boxはコード中に現われないけれど、アンボックス化タプルのようなある種の型について理論的な視点から有用である。
    アンボックス化タプルはボックス化/アンボックス化どちらの引数も取れる。
    これを表現することは種類boxなしにそれは不可能だ。
    なぜならsuperkind多相でなければならないから。
    種類boxは次のような表現を許す。
    (これはアンボックス化2タプルのケースである)

note: type: Plain text
en: However, although this is a valid typing of what it would mean if a unboxed tuple were not fully applied, since we do not have any rules of form (##,?,?) or (□,?,?) this type obviously does not typecheck. Which is what enforces the invarient that unboxed tuples are always fully applied, and is also why we do not need a code representation of sort box.
ja: たとえアンボックス化タプルが部分適用されることが妥当な型付けでも (##,?,?) もしくは (□,?,?) の形のルールは許容しないのだから、
    この型は明らかに型検査されない。
    アンボックス化タプルがいつも全適用されるという不変条件が強制されるなら種類boxのコード表現もまた不要になる。

note: type: Plain text
en: #### Do we need a superbox?
ja: #### superboxは必要か？

note: type: Plain text
en: You will notice that if you look at the axioms involving the sorts, you end up with a disjoint graph
ja: 種類の公理を見て接続の不足したグラフになっていることに、あなたは気付くかもしれない。

note: type: Plain text
en:              □             - the box
                / \
              **   ##          - superkind
              /\     \
             *  !     #   (#)  - kind
ja:              □            - box
                / \
              **   ##          - superkind
              /\     \
             *  !     #   (#)  - kind(種)

note: type: Plain text
en: This is simply due to the fact that nothing is polymorphic in unboxed tuples of kind (#) so we never need to refer to any super-sorts of them. We can add sorts (##),(□) and □□ to fill in the gaps, but since these sorts will never appear in code or discourse, we will ignore them from now on.
ja: これは単に、それらのsuper-sort(種類)は本来不要であるが、kind (#) のアンボックス化タプルが多相性を欠如していることにに起因する。
    このギャップを埋めるために(##)と(□)、□□の種類を導入できる。
    これらの種類は決してコードや論文には現われないが、気にしないことにする。

note: type: Plain text
en:                □□            - sort superbox
                  /  \
                 □    (□)        - sort box
                / \      \
              **   ##     (##)   - sort superkind
              /\     \    |
             *  !     #   (#)    - sort kind
ja:                □□          - 種類superbox
                  /  \
                 □    (□)      - 種類box
                / \      \
              **   ##     (##)   - 種類superkind
              /\     \    |
             *  !     #   (#)    - 種類kind(種)
