index
int64 0
16.3k
| text
stringlengths 0
318k
|
|---|---|
2,800 | 前）（次）
（基準の効力）
第16条
労働協約に定める労働条件その他の労働者の待遇に関する基準に違反する労働契約の部分は、無効とする。この場合において無効となった部分は、基準の定めるところによる。労働契約に定がない部分についても、同様とする。
16 |
2,801 | 原文テキストについてはガリア戦記/注解編#原文テキストを参照。 49.
1Ubi eum castris se tenere Caesar intellexit, ne diutius commeatu prohiberetur, ultra eum locum, quo in loco Germani consederant, circiter passus sescentos ab his, castris idoneum locum delegit acieque triplici instructa ad eum locum venit. 2Primam et secundam aciem in armis esse, tertiam castra munire iussit. 3Hic locus ab hoste circiter passus sescentos, uti dictum est, aberat. Eo circiter hominum numero sedecim milia expedita cum omni equitatu Ariovistus misit, quae copiae nostros perterrerent et munitione prohiberent. 4Nihilo setius Caesar, ut ante constituerat, duas acies hostem propulsare, tertiam opus perficere iussit. 5Munitis castris, duas ibi legiones reliquit et partem auxiliorum; quattuor reliquas in castra maiora reduxit.
----
テキスト引用についての注記
整形テキストについてはガリア戦記/注解編#凡例を参照。 XLVIIII.
①Ubi eum castrīs sē tenēre Caesar intellēxit, nē diūtius commeātū prohibērētur, ultrā eum locum, quō in locō Germānī cōnsēderant, circiter passūs sescentōs (DC.) ab hīs, castrīs idōneum locum dēlēgit aciēque triplicī īnstrūctā ad eum locum vēnit. ②Prīmam et secundam aciem in armīs esse, tertiam castra mūnīre iussit. ③Hic locus ab hoste circiter passūs sescentōs (DC.), utī dictum est, aberat. Eō circiter hominum numerō sēdecim (XVI.) mīlia expedīta cum omnī equitātū Ariovistus mīsit, quae cōpiae nostrōs terrērent et mūnītiōne prohibērent. ④Nihilō sētius Caesar, ut ante cōnstituerat, duās aciēs hostem prōpulsāre, tertiam opus perficere iussit. ⑤Mūnītīs castrīs duās ibi legiōnēs relīquit et partem auxiliōrum, quattuor reliquās legiōnēs in castra māiōra redūxit.
----
注記
sescentōs : Constans は sexcentōs と表記する（2か所）。
hic : α系写本の記述で、Pontet, Constans, Seel らは、これを支持する。
is : β系写本の記述で、Klotz, Hering らは、こちらを支持する。
terrērent : α系写本などの記述で、Constans, Klotz, Seel, Hering らは、こちらを支持する。
perterrērent : β系写本の記述で、Pontet らは、こちらを採る。
legiōnēs : β系写本などの記述で、Klotz, Seel, Hering らは、これを支持する。α系写本では legiōnēs を省き、Pontet, Constans らは、こちらを支持する。
語釈 |
2,802 | 法学＞民事法＞コンメンタール民法＞第3編 債権 (コンメンタール民法)
（買戻しの特約の対抗力）
第581条
前項の登記がされた後に第605条の2第1項に規定する対抗要件を備えた賃借人の権利は、その残存期間中1年を超えない期間に限り、売主に対抗することができる。ただし、売主を害する目的で賃貸借をしたときは、この限りでない。
2017年改正により、以下の改正がなされた。
第1項
(改正前)第三者に対しても、その効力を生ずる。
(改正後)第三者に対抗することができる。
第2項
買戻の特約を登記しなかつた場合、不動産買戻権は売主の地位と共にのみ譲渡することができる。
買戻の特約を登記しなかつた場合における不動産買戻権の譲渡を買主に対抗するには、これに対する通知またはその承諾を必要とし且つこれをもつて足りる。
買主が買戻の特約を登記した不動産を第三者に転売した場合における買戻権を行使すべき相手方。
買主が買戻の特約を登記した不動産を第三者に転売しその登記を経由した場合は、最初の売主は転得者に対し買戻権を行使すべきである。
----
{{前後
|民法
|第3編 債権
第2章 契約
第3節 売買
|民法第580条（買戻しの期間）
|民法第582条（買戻権の代位行使）
581
581 |
2,803 | 前）（次）
（区分所有法 の規約とみなす部分）
第72条
72 |
2,804 | 物理数学II > フーリエ解析
----
フーリエ級数とは\frac{1}{2}a_0 + \sum_{k=1}^\infty (a_k\cos kx+b_k\sin kx),(-\piのようにある関数f(x)を三角関数の無限和で表したものである。
''x''の定義域を(-\piと定義したとき、フーリエ級数は
で表される。このときa_nとb_nは
で表される。
f(x)=x,(-\piのフーリエ級数
f(x)=xは奇関数なのでa_nは
となる。またb_nは
{n}
となる。よってf(x)=x,(-\piのフーリエ級数は
となる。 |
2,805 | 法学＞民事法＞商法＞コンメンタール会社法＞第7編 雑則 (コンメンタール会社法)
（社債発行会社の弁済等の取消しの訴え）
第865条
社債を発行した会社が社債権者に対してした弁済、社債権者との間でした和解その他の社債権者に対してし、又は社債権者との間でした行為が著しく不公正であるときは、社債管理者は、訴えをもって当該行為の取消しを請求することができる。
前項の訴えは、社債管理者が同項の行為の取消しの原因となる事実を知った時から6箇月を経過したときは、提起することができない。同項の行為の時から1年を経過したときも、同様とする。
第1項に規定する場合において、社債権者集会の決議があるときは、代表社債権者又は決議執行者（第737条第2項に規定する決議執行者をいう。）も、訴えをもって第1項の行為の取消しを請求することができる。ただし、同項の行為の時から1年を経過したときは、この限りでない。
第424条の5、第424条の7第2項及び第425条から第425条の4までの規定は、第1項及び前項本文の場合について準用する。この場合において、同法第424条第1項ただし書中「その行為によって」とあるのは「会社法第865条第1項に規定する行為によって」と、「債権者を害すること」とあるのは「その行為が著しく不公正であること」と、同法第424条の5各号中「債権者を害すること」とあるのは「著しく不公正であること」と、同法第425条中「債権者」とあるのは「社債権者」と読み替えるものとする。
----
{{前後
|会社法
|第7編 雑則
第2章 訴訟
第7節 社債発行会社の弁済等の取消しの訴え
|会社法第864条（被告）
|会社法第866条（被告）
865 |
2,806 | （あへん煙輸入等）
第136条
あへん煙を輸入し、製造し、販売し、又は販売の目的で所持した者は、6月以上7年以下の拘禁刑に処する。
2022年、以下のとおり改正（施行日2025年6月1日）。
あへん煙:吸食用として製造されたあへん煙膏をいい、その原料である生あへんを含まない。生あへんについてはあへん法によって取り締まられる。
原料あへんについては、特別法あへん法において、詳細に取り扱い他が規定されており、本章は将来的にそれら特別法（薬物4法参照）に吸収される方向である（改正刑法草案など）。
あへん煙に関する罪
未遂は、罰する。
薬物4法
----
{{前後
|刑法
|第2編 罪
第14章 あへん煙等に関する罪
|刑法第135条（親告罪）
|刑法第137条（あへん煙吸食器具輸入等） |
2,807 | コンメンタール食品安全基本法
食品安全基本法(最終改正：平成二一年六月五日法律第四九号)の逐条解説書。 |
2,808 | 前）（次）
（被保険者の資格喪失の届出）
第22条
22 |
2,809 | 法学＞民事法＞商法＞コンメンタール会社法＞第2編 株式会社 (コンメンタール会社法)＞第2編第2章 株式 (コンメンタール会社法)
（株主名簿の記載等）
第148条
株式に質権を設定した者は、株式会社に対し、次に掲げる事項を株主名簿に記載し、又は記録することを請求することができる。
----
{{前後
|会社法
|第2編 株式会社
第2章 株式
第3節 株式の譲渡等
第3款 株式の質入れ
|会社法第147条（株式の質入れの対抗要件）
|会社法第149条（株主名簿の記載事項を記載した書面の交付等）
148 |
2,810 | 法学＞民事法＞コンメンタール民法＞第3編 債権 (コンメンタール民法)
(指図証券の譲渡)
第520条の2
指図証券の譲渡は、その証券に譲渡の裏書をして譲受人に交付しなければ、その効力を生じない。
2017年改正にて新設。
改正前、「指図債権」として以下の条項を定め取り扱われていたものについては、有価証券である「指図証券」として概念することとし、譲渡の裏書は対抗要件ではなく効力要件となった。
（指図債権の譲渡の対抗要件）
第469条
指図債権の譲渡は、その証書に譲渡の裏書をして譲受人に交付しなければ、債務者その他の第三者に対抗することができない。
指図証券の譲渡は、「裏書」及び「証券の交付」が効力要件である。
次の場合を考える。譲渡人G1が指図債権をG2とG3に二重譲渡した。このうちG1はG2に債権譲渡したことを債務者Sに通知したが、G3に債権譲渡したことは通知せず、G3は、「Sが債務を負担する」という文句のあるG1の裏書きのある指図証券を所持している。履行期にG3が証券を呈示して弁済を請求し、G2も履行を催告した。Sはどうすればよいか。
事例の場合G2への指図債権の債権譲渡は無効である。
裏書の効力は権利移転的効力・資格授与的効力・担保的効力があるが、改正民法には資格授与的効力（第520条の4）が定められている。ただし残り二つは解釈上認められる（はずである）。資格授与的効力は裏書の連続により所持人に証券上の権利があることが法律上の推定を受けることをいう。
次の場合を考える。裏書が連続していない証券の所持人がその証券を呈示して債務者が「不連続の裏書に資格授与的効力がない」ことを理由に弁済を拒絶した。
この場合所持人は裏書の実質的な連続を立証すれば債務者に債務の履行を求めることができる。
次の場合を考える。Sが債務を負担する証券がGに裏書きされた。しかしGは紛失してしまい、Iが所持しており裏書人欄にはG・Hによる裏書の連続があった。Gは証券を呈示しなければSからの弁済を受けることができない。そこでGは証券の紛失を主張して指図債権譲渡の事実を否定しIに証券の返還を請求した。
この場合資格授与的効力があるのでIはGへの返還義務を負わない。ただしGはIがHが無権利者であったことを知っていたか知らなかったことについて重過失があったことを立証すれば返還してもらえる。
----
{{前後
|民法
|第3編 債権
第1章 総則
第7節 有価証券
|民法第520条（混同）
|民法第520条の3 （指図証券の裏書の方式）
520の02
520の02 |
2,811 | 前）（次）
（選任及び解任）
第25条
25 |
2,812 | 法学＞行政法＞コンメンタール行政不服審査法
（審理手続の併合又は分離）
第39条
審理員は、必要があると認める場合には、数個の審査請求に係る審理手続を併合し、又は併合された数個の審査請求に係る審理手続を分離することができる。
----
{{前後
|行政不服審査法
|第2章 審査請求
第3節 審理手続
|第38条（審査請求人等による提出書類等の閲覧等）
|第40条（審理員による執行停止の意見書の提出）
39 |
2,813 | 法学＞コンメンタール＞コンメンタール刑事訴訟法=コンメンタール刑事訴訟法/改訂
（訴訟記録の閲覧）
第53条
何人も、被告事件の終結後、訴訟記録を閲覧することができる。但し、訴訟記録の保存又は裁判所若しくは検察庁の事務に支障のあるときは、この限りでない。
弁論の公開を禁止した事件の訴訟記録又は一般の閲覧に適しないものとしてその閲覧が禁止された訴訟記録は、前項の規定にかかわらず、訴訟関係人又は閲覧につき正当な理由があって特に訴訟記録の保管者の許可を受けた者でなければ、これを閲覧することができない。
日本国憲法第82条第2項但書に掲げる事件については、閲覧を禁止することはできない。
訴訟記録の保管及びその閲覧の手数料については、別に法律でこれを定める。
----
{{前後
|刑事訴訟法
|第1編 総則
第6章 書類及び送達
|第52条（公判調書の証明力）
|第53条の2（情報公開法の適用除外）
053 |
2,814 | __TOC__
Chromebrewは、ChromeOSで動作するソースビルド指向のパッケージ管理システムです。
ChromeOSは、Linuxカーネルの上にChromeウェブブラウザーを中心としてネットワーククライアント機能を提供します。
ですが、所謂GNU/Linuxのディストリビューションに観られるパッケージマネージャーを含まず、GNU/Linuxの環境を手に入れるには…
LXCコンテナー上で、GNU/Linuxディストリビューションを実行します（設定 > “Linux (Beta)” として知られます）
chroot 環境で、GNU/Linuxディストリビューションを実行します（サポート終了しました）
デベローパーモードのシェル環境に独自バイナリーをインストールします（GNU/Linuxディストリビューションとのパッケージ互換性はないです）
の３つなどがあります。
Chromebrewは、その名の通りHomebrewの影響を受けていますが、完全にRubyで記述され（Homebrewは一部 bash スクリプト）、ChoromeOS固有の事情（ユーザーが書込みも実行もできるファイルシステムは /usr/local に限られるなど）に適応しています。
Chromebrewは、仮想環境やchrootのオーバーヘッドはなく、ユーティリティーや共有ライブラリーなどChromeOSのものを使えるのでフットプリントは、この中で一番小さくなります。
Chromebrewは、BSD Unixの package source や ports collection の様にソースコードからのビルドをユーザーが気軽に行え、たとえばCコンパイラーに -march=native オプションを与えホスト環境のプロセッサーで実行可能な命令セットからコード生成をすることができるなど、資源の少ない環境にも好適です。
インストールする前に、Chromebook をデベロッパーモードにする必要があります。
Chromebook をデベロッパーモードにすると、工場出荷時の設定に戻されます。
Chromebook をデベロッパーモードにすると、工場出荷時の設定に戻されます。
大切なので二回言いました。
Chromebookを「デベロッパーモード''Developer mode'' を「開発者モード」とする資料もありますが、定訳がないので「デベロッパーモード」とカタカナ表記にしました。」にすると、Chromebookのシステムファイルを変更できるなど、完全なルートアクセスを取得できます。
デベロッパーモードには、一部のファイルを変更したり、外部USBデバイスからChromebookを起動したりするなど他の使い道もあります。
デベローパーモードへ切替える方法
ESC + 更新（F3）ボタンを押しながら、電源ボタンを押します。その後、電源ボタンを離します。
リカバリー画面が表示されます。ここで、Ctrl + Dキーを押して開発者モードをオンにします。その後、数分待ちます。
まず、 https://chromebrew.github.io/ にアクセスして、インストール方法が変わっていないか確認してください。
crosh を開きます。
Chrome で、ctrl+alt+T で crosh を開きます。
Welcome to crosh, the Chrome OS developer shell.
If you got here by mistake, don't panic! Just close this tab and carry on.
Type 'help' for a list of commands.
If you want to customize the look/behavior, you can use the options page.
Load it by using the Ctrl-Shift-P keyboard shortcut.
crosh>
Chrome に新しいタブが開き、上のような表示が現れます。
crosh> shell
[ERROR:src/main.rs:184] ERROR: unknown command: shell
と表示された場合は、デベローパーモードになっていません。デベローパーモードへの切替え手順を確認しましょうChromeOS Flex の場合、grubの設定ファイルに cros_debug を追加します。。
shellの起動。
crosh> shell
chronos@localhost / $
shell が、開きました。初期状態では bash です。
インストールスクリプトのオンザフライ実行。
chromebrew のインストールスクリプトをファイルに落とさず、そのまま bash の標準入力に流します。
chronos@localhost / $ curl -Ls git.io/vddgY | bash
Welcome to Chromebrew!
Please enter the developer mode password
We trust you have received the usual lecture from the local System
Administrator. It usually boils down to these three things:
#1) Respect the privacy of others.
#2) Think before you type.
#3) With great power comes great responsibility.
Password:
Doing initial setup for install in /usr/local.
This may take a while if there are preexisting files in /usr/local...
Downloading information for Bootstrap packages...
[1/15]: https://raw.githubusercontent.com/chromebrew/chromebrew/master/packages/musl_zstd.rb --> musl_zstd.rb
--_curl_--https://raw.githubusercontent.com/chromebrew/chromebrew/master/packages/musl_zstd.rb
[2/15]: https://raw.githubusercontent.com/chromebrew/chromebrew/master/packages/pixz.rb --> pixz.rb
--_curl_--https://raw.githubusercontent.com/chromebrew/chromebrew/master/packages/pixz.rb
:
:
:
. .
..,:;;;::'..
.':lllllllool,.
...cl;..... ,::;'.
.'oc...;::::..0KKo.
.'od: .:::::, lolc.
.'lNMMMO ;ooc.,XMMWx;:;.
.dMMMMMMXkMMMMxoMMMMMMMMO.
.:O0NMMMMMMMMMM0MMMMMN0Oc.
.:xdloddddddoXMMMk:x:....
.xMNOKX0OOOOxcodlcXMN0O0XKc.
.OMXOKXOOOOOk;ol:OXMK...;N0.
'XMKOXXOOOOOk:docOKMW, .kW;
.cMMKOXXOOOOOOOOOOO0MM; .lMc.
.cMM00XKOOOOkkkkkkOOWMl. .cMo.
.lMWO0XKOOOkkkkkkkkONMo. ;Wk.
.oMNO0X0OOkkkkkkkkkOXMd..,oW0'
.xMNO0X0OOkkkkkkkkkkXMWKXKOx;.
.0MXOOOOOOkkkkkkkkkOKM0..
'NMWNXXKK000000KKXNNMMX.
.;okk0XNWWMMMMWWNKOkdc'.
.....'cc:cc:''...
___ _ _
/ (_)|\ |\\
| ||__ ,_ __ _ _ _ __ |/_ ,_ __ _ _ _
| |/ | / | / \/ |/ |/ | |_/ | \/ | |_/ /| | |\_
\___/| |_/ |_/\__/ | | |_/|__/\__/ |_/|__/ \_/ \_/
Edit /usr/local/etc/env.d/02-pager to change the default PAGER.
more is used by default
You may wish to edit the /usr/local/etc/env.d/01-editor file for an editor default.
Chromebrew provides nano, vim and emacs as default TUI editor options.
Chromebrew installed successfully and package lists updated.
chronos@localhost / $
のようなアスキーアートとメッセージが表示されたら chromebrew のインストールは完了です。
chromebrew のインストールが終わったら、基本的な動作を確認します。
chronos@localhost / $ crew
Usage:
crew autoremove [options]
crew build [options] [-k|--keep] ...
crew const [options] [ ...]
crew deps [options] [-t|--tree] [-b|--include-build-deps] [--exclude-buildessential] ...
crew download [options] ...
crew files [options] ...
crew help []
crew install [options] [-k|--keep] [-s|--build-from-source] [-S|--recursive-build] ...
crew list [options] (available|installed|compatible|incompatible)
crew postinstall [options] ...
crew reinstall [options] [-k|--keep] [-s|--build-from-source] [-S|--recursive-build] ...
crew remove [options] ...
crew search [options] [ ...]
crew sysinfo [options]
crew update [options] []
crew upgrade [options] [-k|--keep] [-s|--build-from-source] [ ...]
crew whatprovides [options] ...
chronos@localhost / $ crew sysinfo
- Architecture: `x86_64` (`x86_64`)
- Kernel version: `4.14.282-19192-g19e8c55302db`
- Chromebrew version: `1.24.0`
- Chromebrew prefix: `/usr/local`
- Chromebrew libdir: `/usr/local/lib64`
- Last update in local repository: `e01f130: Edge 103.0.1264.77-1 => 104.0.1293.47-1 (#7254)`
- OS variant: `Chrome OS`
- OS version: `octopus-release/R104-14909.100.0`
- OS channel: `stable-channel`
サブコマンドとオプションの一覧が表示されます。
sysinfo サブコマンドは、OSとchromebrew自身の情報を表示します。
内容はバージョンによって異なります。
tree コマンドをインストールしてみます。
$ crew install tree
tree: Tree is a recursive directory listing command that produces a depth indented listing of files, which is colorized ala dircolors if the LS_COLORS environment variable is set and output is to tty.
http://mama.indstate.edu/users/ice/tree/
Version: 2.0.2
License: GPL-2
Performing pre-flight checks...
Precompiled binary available, downloading...
Cannot find cached archive. 😔 Will download.
[####################################################################################################################################] 51.52 KB 100%
Tree archive downloaded.
Unpacking archive using 'tar', this may take a while...
Performing pre-install...
Performing install...
Using rdfind to convert duplicate files to hard links.
Now scanning ".", found 2 files.
Now have 2 files in total.
Removed 0 files due to nonunique device and inode.
Total size is 177860 bytes or 174 KiB
Removed 2 files due to unique sizes from list. 0 files left.
Now eliminating candidates based on first bytes: removed 0 files from list. 0 files left.
Now eliminating candidates based on last bytes: removed 0 files from list. 0 files left.
Now eliminating candidates based on sha1 checksum: removed 0 files from list. 0 files left.
It seems like you have 0 files that are not unique
Totally, 0 B can be reduced.
Now making hard links.
Making 0 links.
Tree installed!
chronos@localhost ~ $ tree -d /usr/local/lib/crew/
/usr/local/lib/crew/
├── bin
├── lib
├── packages
└── tools
4 directories
chronos@localhost ~ $
treeはディレクトリー構造をツリー表示するコマンドで、階層構造の把握の役に立ちます。
crew install パッケージ名
の形式では、バイナリーパッケージがインストールされますが、chromebrew では同程度の手間でソースからインストールすることができます。
chronos@localhost ~ $ crew reinstall -s tree
tree: Tree is a recursive directory listing command that produces a depth indented listing of files, which is colorized ala dircolors if the LS_COLORS environment variable is set and output is to tty.
Performing pre-flight checks...
Downloading source...
Archive found in cache
Unpacking archive using 'tar', this may take a while...
Building from source, this may take a while...
gcc -ggdb -pedantic -Wall -DLINUX -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -c -o tree.o tree.c
gcc -ggdb -pedantic -Wall -DLINUX -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -c -o unix.o unix.c
gcc -ggdb -pedantic -Wall -DLINUX -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -c -o html.o html.c
gcc -ggdb -pedantic -Wall -DLINUX -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -c -o xml.o xml.c
gcc -ggdb -pedantic -Wall -DLINUX -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -c -o json.o json.c
gcc -ggdb -pedantic -Wall -DLINUX -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -c -o hash.o hash.c
gcc -ggdb -pedantic -Wall -DLINUX -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -c -o color.o color.c
gcc -ggdb -pedantic -Wall -DLINUX -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -c -o file.o file.c
gcc -o tree tree.o unix.o html.o xml.o json.o hash.o color.o file.o
Preconfiguring package...
install -d /usr/local/tmp/crew/dest/usr/local/bin
install -d /usr/local/tmp/crew/dest/usr/local/share/man/man1
if [ -e tree ]; then \
install tree /usr/local/tmp/crew/dest/usr/local/bin/tree; \
fi
install doc/tree.1 /usr/local/tmp/crew/dest/usr/local/share/man/man1/tree.1
Rename all *.la_tmp files back to *.la
Checking for FHS3 compliance...
Checking for conflicts with files from installed packages...
Stripping libraries...
Stripping binaries...
Running patchelf
Running patchelf to patch binaries for library paths
Using rdfind to convert duplicate files to hard links.
Now scanning ".", found 4 files.
Now have 4 files in total.
Removed 0 files due to nonunique device and inode.
Total size is 95387 bytes or 93 KiB
Removed 4 files due to unique sizes from list. 0 files left.
Now eliminating candidates based on first bytes: removed 0 files from list. 0 files left.
Now eliminating candidates based on last bytes: removed 0 files from list. 0 files left.
Now eliminating candidates based on sha1 checksum: removed 0 files from list. 0 files left.
It seems like you have 0 files that are not unique
Totally, 0 B can be reduced.
Now making hard links.
Making 0 links.
Removing since upgrade or reinstall...
Tree removed!
Performing pre-install...
Performing install...
Using rdfind to convert duplicate files to hard links.
Now scanning ".", found 2 files.
Now have 2 files in total.
Removed 0 files due to nonunique device and inode.
Total size is 95236 bytes or 93 KiB
Removed 2 files due to unique sizes from list. 0 files left.
Now eliminating candidates based on first bytes: removed 0 files from list. 0 files left.
Now eliminating candidates based on last bytes: removed 0 files from list. 0 files left.
Now eliminating candidates based on sha1 checksum: removed 0 files from list. 0 files left.
It seems like you have 0 files that are not unique
Totally, 0 B can be reduced.
Now making hard links.
Making 0 links.
Tree installed!
chronos@localhost ~ $
また、 -s オプションがついていることが違います。これが「ソースからビルドしてインストールする」指示で、依存パッケージのインストールやソースコードの取得を（必要であれば）確認を求めつつ実行します。
短所:ネットワークから取得し展開するだけのバイナリーパッケージより、コンパイルなどが必要な分、メモリー・ストレージ・時間などの資源の使用が多い。
長所
バイナリーパッケージが作られた時より新しいコンパイラでコンパイルされるので、生成されるコードの質が高い。
コンパイル条件を変えることで、LTOやPGOを使ったり、ターゲットCPUの命令セットに最適化することなどができます。
crewを更新すると自分で行った /usr/local/lib/crew 以下の変更が書き戻されるので、変更を行っている場合は、事前にバックアップを取りv git diff の差分を保存するようにしてください。
crew 自身のアップデート:
chronos@localhost ~ $ crew update
crewを更新します。
これはcrew本体のみをアップデートします。
パッケージのアップデート:
chronos@localhost ~ $ crew upgrade
パッケージのアップデートを行います。
パッケージが省略された場合、全てのパッケージが更新されます。 そうでなければ、特定のパッケージが更新されます。
-s または --build-from-source を指定すると、パッケージはバイナリでアップグレードされるのではなく、コンパイルされます。
-v または --verbose を指定すると、より多くの情報が表示されます。
crew のパッケージのレシピは、/usr/local/lib/crew/packages/ にある1つのrubyスクリプトです。
Crystal言語のパッケージが crew になかったので作ってみました。
/usr/local/lib/crew/packages/crystal.rb:
require 'package'
class Crystal < Package
description 'Programming language Crystal official binary'
homepage 'https://crystal-lang.org/'
version '1.6.0-dev-cd3081f3b'
license 'Apache License 2.0'
compatibility 'x86_64'
source_url 'https://github.com/crystal-lang/crystal/releases/download/1.5.0/crystal-1.5.0-1-linux-x86_64.tar.gz'
source_sha256 '627360f0fc805202d80310007d503c7a2fc0745b1db2211537d7f54e9a994347'
def self.build
system 'git clone https://github.com/crystal-lang/crystal'
Dir.chdir 'crystal' do
system 'git checkout cd3081f3b87ef6c777255197d35e140b8249c534'
system "sed -i 's@^@15.0 @' src/llvm/ext/llvm-versions.txt"
system %(SHELL=sh PATH=../bin/:$PATH \
FLAGS="--release --no-debug --progress --threads=1" \
CRYSTAL_CACHE_DIR="#{Dir.getwd}/cache" \
make interpreter=true verbose=true)
end
end
def self.install
Dir.chdir 'crystal' do
system 'make', "DESTDIR=#{CREW_DEST_DIR}", 'install'
end
end
def self.postinstall
puts "\nType 'crystal' to get started.\n".lightblue
end
end
class Package とユーティリティ関数を定義した 'package' を読み込みます。
class パッケージ名 < Packageの「パッケージ名」は、レシピファイルから拡張子を取り先頭を大文字にしたものになります。
逆に言うと、レシピファイル名にはRubyの識別子に使えない - を含めたり、数字で始めることが出ません。
このため - は _ に置換え、数字で始まる場合は pkg を前置します。
description、パッケージの説明。crew search などで参照されます。
homepage、ホームページのURL文字列。
version、バージョンを表す文字列。スクリプトの中で @version で参照できます。
license、ライセンスを表す文字列。
compatibility、対応しているアーキテクチャーを表す文字列。'aarch64' 'armv7l' 'i686' 'x86_64' または 'all'。複数の場合は , で区切ります。
Scala言語のパッケージも crew になかったので作ってみました。
/usr/local/lib/crew/packages/scala.rb:
require 'package'
class Scala < Package
description 'The Scala 3 compiler, also known as Dotty.'
homepage 'https://dotty.epfl.ch/'
version '3.2.0'
license 'Apache-2.0'
compatibility 'all'
source_url "https://github.com/lampepfl/dotty/releases/download/3.2.0/scala3-3.2.0.tar.gz"
source_sha256 '194bd030808f6fc7de083bfd7c75230d719aedc20f3cb7562dc65d18b4a17278'
depends_on 'jdk18'
no_compile_needed
no_patchelf
def self.install
system "mkdir -p #{CREW_DEST_DIR}/usr/local/share/scala/ #{CREW_DEST_DIR}/usr/local/bin/"
system "mv bin lib #{CREW_DEST_DIR}/usr/local/share/scala/"
%w(scala scalac scaladoc).each do | cmd |
system "( cd #{CREW_DEST_DIR}/usr/local/bin/ && ln -s ../share/scala/bin/#{cmd} )"
end
end
end
自分の作ったレシピを有効にするには、/usr/local/lib/crew/packages/ にスクリプトを用意したあと
パッケージリストの更新:
$ crew update ''
を実行します。 |
2,815 | 前）（次）
（委員の欠格条項）
第19条の4
禁錮以上の刑に処せられ、その執行を終わるまで、又は執行を受けることがなくなるまでの者は、委員となることができない。
次の各号のいずれかに該当する者は、公益委員となることができない。
19の4 |
2,816 | 前）（次）
（双務契約についての破産法の準用）
第51条
第58条及び第59条の規定は、再生手続が開始された場合について準用する。この場合において、同法第56条第1項 中「第53条第1項 及び第2項 」とあるのは「同法第54条第1項中「破産債権者」とあるのは「再生債権者」と、同法第59条第1項中「破産手続」とあるのは「再生手続」と、同条第2項中「請求権は、破産者が有するときは破産財団に属し」とあるのは「請求権は」と、「破産債権」とあるのは「再生債権」と読み替えるものとする。
第53条第1項及び第2項の規定は、賃借権その他の使用及び収益を目的とする権利を設定する契約について破産者の相手方が当該権利につき登記、登録その他の第三者に対抗することができる要件を備えている場合には、適用しない。
双務契約について破産者及びその相手方が破産手続開始の時において共にまだその履行を完了していないときは、破産管財人は、契約の解除をし、又は破産者の債務を履行して相手方の債務の履行を請求することができる。
前項の場合には、相手方は、破産管財人に対し、相当の期間を定め、その期間内に契約の解除をするか、又は債務の履行を請求するかを確答すべき旨を催告することができる。この場合において、破産管財人がその期間内に確答をしないときは、契約の解除をしたものとみなす。
前項に規定する場合には、相手方の有する請求権は、財団債権とする。
民事再生法第49条第1項及び第2項の規定は、賃借権その他の使用及び収益を目的とする権利を設定する契約について再生債務者の相手方が当該権利につき登記、登録その他の第三者に対抗することができる要件を備えている場合には、適用しない。
前項に規定する場合には、相手方の有する請求権は、共益債権とする。
取引所の相場その他の市場の相場がある商品の取引に係る契約であって、その取引の性質上特定の日時又は一定の期間内に履行をしなければ契約をした目的を達することができないものについて、その時期が破産手続開始後に到来すべきときは、当該契約は、解除されたものとみなす。
前項の場合において、損害賠償の額は、履行地又はその地の相場の標準となるべき地における同種の取引であって同一の時期に履行すべきものの相場と当該契約における商品の価格との差額によって定める。
第54条第1項の規定は、前項の規定による損害の賠償について準用する。
前条第1項又は第2項の規定により契約の解除があった場合には、相手方は、損害の賠償について破産債権者としてその権利を行使することができる。
第1項又は第2項に定める事項について当該取引所又は市場における別段の定めがあるときは、その定めに従う。
第1項の取引を継続して行うためにその当事者間で締結された基本契約において、その基本契約に基づいて行われるすべての同項の取引に係る契約につき生ずる第2項に規定する損害賠償の債権又は債務を差引計算して決済する旨の定めをしたときは、請求することができる損害賠償の額の算定については、その定めに従う。
取引所の相場その他の市場の相場がある商品の取引に係る契約であって、その取引の性質上特定の日時又は一定の期間内に履行をしなければ契約をした目的を達することができないものについて、その時期が再生手続開始後に到来すべきときは、当該契約は、解除されたものとみなす。
前項の場合において、損害賠償の額は、履行地又はその地の相場の標準となるべき地における同種の取引であって同一の時期に履行すべきものの相場と当該契約における商品の価格との差額によって定める。
第54条第1項の規定は、前項の規定による損害の賠償について準用する。
前条第1項又は第2項の規定により契約の解除があった場合には、相手方は、損害の賠償について再生債権者としてその権利を行使することができる。
第1項又は第2項に定める事項について当該取引所又は市場における別段の定めがあるときは、その定めに従う。
第1項の取引を継続して行うためにその当事者間で締結された基本契約において、その基本契約に基づいて行われるすべての同項の取引に係る契約につき生ずる第2項に規定する損害賠償の債権又は債務を差引計算して決済する旨の定めをしたときは、請求することができる損害賠償の額の算定については、その定めに従う。
交互計算は、当事者の一方について破産手続が開始されたときは、終了する。この場合においては、各当事者は、計算を閉鎖して、残額の支払を請求することができる。
前項の規定による請求権は、破産者が有するときは破産財団に属し、相手方が有するときは破産債権とする。
交互計算は、当事者の一方について再生手続が開始されたときは、終了する。この場合においては、各当事者は、計算を閉鎖して、残額の支払を請求することができる。
前項の規定による請求権は、破産者が有するときは破産財団に属し、相手方が有するときは再生債権とする。
051 |
2,817 | 中学校書写では、行書が始まります。
要点を押さえつつ、行書の発祥や楷書との違いを押さえておくと、行書の書き方や面白さが分かると思いますので、自らでも調べてみて下さい。
楷書(かいしょ)は、普段私たちが使う字のことです。
硬筆などで扱われ、小学校での書写で教わった書き方です。
一方、行書は以下に述べるように、いかにも人間の書く自然に見える字です。
小学校との大きな違いは、個性を表現して、ルールがなく伸びやかにかけるところです。
行書(ぎょうしょ)が中学校から始まるわけですが、「行書」と聞くと難しそうだなぁというイメージがあるかもしれません。
しかし、ルールや決まりの多い楷書に比べれば簡単です。
中国の後漢時代にできましたが、筆を使えることができたら誰でもかける字体となっています。
行書では、一筆書きのような滑らかな字を書くことができ、特にこれといった決まりがありません。
したがって、どこを繋げるかなど、自分で工夫することができ、人によって個性が現れます。
街などに行くとよく看板などで見る(例:飲食店や古道具売りなど)文字ですが、とても読みやすいというメリットがあります。
手紙やメッセージなどに使うことによって、自然体の柔らかい印象を持たすことができます。
行書は生活にてとても重宝されている字体なのです。
先程述べたように、これといった書き方はありません。しかし、綺麗に見える文字の形や書き方というのは自然と出てくるものです。
道具は、筆を柔らかくほぐしたものが最適です。
「崩そう」という意識を持たず、筆の流れを意識して書くと効率的に行書に味を持たせることができます。
書く姿勢も大事です。
体の重心を中央に持ってきて、背中をピンと伸ばす。(これは小学校で習ったものかもしれません。)書道の基本を押さえつつ自分の書きたい文字を書いたら上手く行きます。 |
2,818 | 法学＞民事法＞コンメンタール＞コンメンタール民事保全法
（審理の終結）
第31条
裁判所は、審理を終結するには、相当の猶予期間を置いて、審理を終結する日を決定しなければならない。ただし、口頭弁論又は当事者双方が立ち会うことができる審尋の期日においては、直ちに審理を終結する旨を宣言することができる。
----
{{前後
|民事保全法
|第2章 保全命令に関する手続
第3節 保全異議
|民事保全法第29条（保全異議の審理）
|民事保全法第32条（保全異議の申立てについての決定）
31 |
2,819 | 動詞は、物の動きを表す言葉で、以下の9種類がある。 |
2,820 | 前）（次）
（国の施策）
第4条
004 |
2,821 | ※県外会場には東京、東海、岡山があります。本校とは入試問題が異なります。ただし、英語重視型は東京のみ、21世紀型は本校のみです。
独特な図形問題が出題される。
※以下2つは独特な入試の型への対応です。普通に受験される方は見なくてかまいません。
問題文も英語です。
[http://www.nishiyamato.ed.jp/ny/admission/dl_q.html 前年度問題ダウンロード(公式)] |
2,822 | （期間経過後の債権の申出）
第49条の12の8
前条第1項の期間の経過後に申出をした債権者は、税理士会の債務が完済された後まだ権利の帰属すべき者に引き渡されていない財産に対してのみ、請求をすることができる。
本条は、清算人による債権の申出の催告に係る公告の期間の経過後に申し出をした債権者は、税理士会の債務が完済され後まだ権利の帰属すべき者に引き渡されていない財産に対してのみ、請求をすることができることを規定している。 |
2,823 | C · IVLII · CAESARIS · COMMENTARIORVM · BELLI · GALLICI
LIBER · QVINTVS
__notoc__
原文テキストについてはガリア戦記/注解編#原文テキストを参照。 28. 1Arpineius et Iunius quae audierunt ad legatos deferunt. Illi repentina re perturbati, etsi ab hoste ea dicebantur, tamen non neglegenda existimabant, maximeque hac re permovebantur, quod civitatem ignobilem atque humilem Eburonum sua sponte populo Romano bellum facere ausam vix erat credendum. 2Itaque ad consilium rem deferunt magnaque inter eos exsistit controversia. 3L. Aurunculeius compluresque tribuni militum et primorum ordinum centuriones nihil temere agendum neque ex hibernis iniussu Caesaris discedendum existimabant; 4quantasvis magnas etiam copias Germanorum sustineri posse munitis hibernis docebant: 5rem esse testimonio, quod primum hostium impetum multis ultro vulneribus inlatis fortissime sustinuerint; 6re frumentaria non premi; interea et ex proximis hibernis et a Caesare conventura subsidia; 7postremo quid esset levius aut turpius quam auctore hoste de summis rebus capere consilium?
----
テキスト引用についての注記
exsistit : existit という別表記を用いる校訂版もある。
整形テキストについてはガリア戦記/注解編#凡例を参照。 XXVIII.
①Arpinēius et Iūnius quae audiērunt ad lēgātōs dēferunt. Illī repentīnā rē perturbātī, etsī ab hoste ea dīcēbantur, tamen nōn neglegenda exīstimābant, maximēque hāc rē permovēbantur, quod cīvitātem ignōbilem atque humilem Eburōnum suā sponte populō Rōmānō bellum facere ausam vix erat crēdendum. ②Itaque ad cōnsilium rem dēferunt magnaque inter eōs exsistit contrōversia. ③Lūcius Aurunculēius complūrēsque tribūnī mīlitum et prīmōrum ōrdinum centuriōnēs nihil temere agendum neque ex hībernīs iniussū Caesaris discēdendum exīstimābant; ④quantāsvīs magnās etiam cōpiās Germānōrum sustinērī posse mūnītīs hībernīs docēbant: ⑤rem esse testimōniō, quod prīmum hostium impetum multīs ultrō vulneribus inlātīs fortissimē sustinuerint; ⑥rē frūmentāriā nōn premī; intereā et ex proximīs hībernīs et ā Caesare conventūra subsidia; ⑦postrēmō quid esset levius aut turpius quam auctōre hoste dē summīs rēbus capere cōnsilium?
----
注記
語釈 |
2,824 | 前）（次）
（積立金の運用）
第76条
積立金の運用は、厚生労働大臣が、前条の目的に沿つた運用に基づく納付金の納付を目的として、年金積立金管理運用独立行政法人に対し、積立金を寄託することにより行うものとする。
厚生労働大臣は、前項の規定にかかわらず、同項の規定に基づく寄託をするまでの間、財政融資資金に積立金を預託することができる。
76 |
2,825 | 法学＞民事法＞コンメンタール民事訴訟法
（直接主義）
第249条
単独の裁判官が代わった場合又は合議体の裁判官の過半数が代わった場合において、その前に尋問をした証人について、当事者が更に尋問の申出をしたときは、裁判所は、その尋問をしなければならない。
----
{{前後
|民事訴訟法
|第2編第一審の訴訟手続
第5章 判決
|第248条（損害額の認定）
|第250条（判決の発効）
249 |
2,826 | 法学＞民事法＞商法＞コンメンタール会社法＞第2編 株式会社 (コンメンタール会社法)＞第2編第4章 機関 (コンメンタール会社法)
（会計監査人の任期）
第338条
会計監査人の任期は、選任後1年以内に終了する事業年度のうち最終のものに関する定時株主総会の終結の時までとする。
会計監査人は、前項の定時株主総会において別段の決議がされなかったときは、当該定時株主総会において再任されたものとみなす。
前二項の規定にかかわらず、会計監査人設置会社が会計監査人を置く旨の定款の定めを廃止する定款の変更をした場合には、会計監査人の任期は、当該定款の変更の効力が生じた時に満了する。
----
{{前後
|会社法
|第2編 株式会社
第4章 機関
第3節 役員及び会計監査人の選任及び解任
|会社法第337条（会計監査人の資格等）
|会社法第339条（解任）
338 |
2,827 | 日本国内でクリーニング所において洗濯物の処理を行うのに必要な免許を試験に合格し取得する方法である。受験資格は中卒以上並びにそれと同等の知識を有する者ならば誰でも受験可能である。 |
2,828 | /*解析・分析ツール*/ 解析・分析ツールは、ソフトウェアのコードや関連するリソースを解析し、情報を収集し、利用可能な形式で提供するツールです。これらのツールは、ソフトウェアの理解、デバッグ、品質管理、および開発プロセスの改善に役立ちます。オープンソースの視点で、いくつかの解析・分析ツールを例に挙げると、以下のようなものがあります。 |
2,829 | 法学＞民事法＞コンメンタール民法＞第1編 総則 (コンメンタール民法)
（条件の成就の妨害等）
第130条
条件が成就することによって不利益を受ける当事者が故意にその条件の成就を妨げたときは、相手方は、その条件が成就したものとみなすことができる。
条件が成就することによって利益を受ける当事者が不正にその条件を成就させたときは、相手方は、その条件が成就しなかったものとみなすことができる。
2017年改正により、第2項を追加。
信義則の観点から、条件が成就することにより不利益を受ける当事者の一方が、当該条件の成就を妨害することにより、条件不成就となった場合、相手方は、条件が成就したものとみなして（擬制）、法的効果を主張することができることを定める。
【適用例】
Aは土地の購入を、不動産業者Bに、その報酬につき売買契約締結を停止条件として仲介委託していたが、Bが探した売主Cと直接契約を締結し、報酬金を支払わなかった事案について、本条（第1項）を適用し、仲介委託契約が成就したものとみなして、同契約に定める報酬の支払いを命じた。
「故意に」の意味としては、①民法第709条における「故意」同様、結果の認識で足りるとするのが多数説であるが、信義則の観点から、②相手方の権利を害する目的とする説や、③不利益を免れる意思とする説がある。
本条項は、信義則の観点から定められているものなので、総合的に評価する必要があり、上記の故意があっても信義則に反するものでなければ本条の適用は避けるべきである一方で、信義則に反するものである場合には、行為者の主観態様が過失程度のものであっても適用することが適当である。
元々条文上、「条件成就妨害時の成就擬制」を定めていたが、逆に、条件が成就することにより利益を受ける者が、「不正に」成就させた場合、類推適用し逆に成就しないものとみなすべきではないかとの議論は古くからなされ学説上は通説となり、判例上も認められていたものであり（最高裁判決 平成6年5月31日）、2017年改正において取り入れられた。
知事の許可を得ることを条件として農地の売買契約をしたとしても、いわゆる停止条件を附したものということはできない。
知事の許可は右法律行為の効力発生要件、すなわち法定条件であり任意の条件とは異なる。
農地の売主が故意に知事の許可を得ることを妨げたとしても、買主は条件を成就したものとみなすことはできない。
法定条件に、本条は類推適用されない。
土地等の買受人が、その買受につき宅地建物取引業者に仲介を依頼し、買受契約の成立を停止条件として一定額の報酬を支払う旨を約したのに、買受人が右業者を排除して直接売渡人との間に契約を成立させた場合において、右契約の成立時期が業者の仲介活動の時期に近接しているのみならず、当時その仲介活動により買受人の買受希望価額にあと僅かの差が残つているだけで間もなく買受契約が成立するに至る状態にあつたのであり、しかも、買受契約における買受価額が業者と買受人が下相談した価額を僅かに上廻る等の事情のあるときは、買受人は、業者の仲介によつて間もなく買受契約の成立に至るべきことを熟知して故意にその仲介による契約の成立を妨げたものというべきであり、業者は、停止条件が成就したものとみなして、買受人に対し、約定報酬の請求をすることができる。
条件の成就によって利益を受ける当事者が故意に条件を成就させたときは、民法130条の類推適用により、相手方は条件が成就していないものとみなすことができる。
XとYは、①Yは仕様αである製品を作らない、②Yが仕様αである製品を製造した場合、定額の損害賠償をXにする旨の和解契約を締結していた。
Xは、取引関係者であるAに指示し、Yの従業員であるBに仕様βで発注し、製造が進んだ段階で仕様αとしなければ解約すると強要し、仕様αの製品を供給させた。
Xは、②の支払い条件が成就したとして、損害賠償の支払いを求めた。
Yの行為は本件和解条項①に違反する行為に当たるものであることは否定できないけれども、Xは、単に本件和解条項違反行為の有無を調査ないし確認する範囲を超え、Aを介して積極的にYを本件和解条項①に違反する行為をするよう誘引したものであって、これは、条件の成就によって利益を受ける当事者であるXが故意に条件を成就させたものというべきであるから、民法130条の類推適用により、Yらは、本件和解条項②の条件が成就していないものとみなすことができると解するのが相当である。
----
{{前後
|民法
|第1編 総則
第5章 法律行為
第5節 条件及び期限
|民法第129条（条件の成否未定の間における権利の処分等）
|民法第131条（既成条件）
130
130 |
2,830 | 法学＞民事法＞商法＞会社法＞コンメンタール会社法＞第2編 株式会社 (コンメンタール会社法)＞第2編第9章 清算 (コンメンタール会社法)
（役員等の責任の免除の禁止）
第543条
裁判所は、特別清算開始の命令があった場合において、清算の監督上必要があると認めるときは、債権者、清算人、監査役若しくは株主の申立てにより又は職権で、対象役員等の責任の免除の禁止の処分をすることができる。
----
{{前後
|会社法
|第2編 株式会社
第9章 清算
第2節 特別清算
第7款 清算の監督上必要な処分等
|会社法第542条（役員等の財産に対する保全処分）
|会社法第544条（役員等の責任の免除の取消し）
543 |
2,831 | 法学＞民事法＞民法＞コンメンタール民法＞第1編 総則 (コンメンタール民法)
（単独行為の無権代理）
第118条
単独行為については、その行為の時において、相手方が、代理人と称する者が代理権を有しないで行為をすることに同意し、又はその代理権を争わなかったときに限り、第113条から前条までの規定を準用する。代理権を有しない者に対しその同意を得て単独行為をしたときも、同様とする。
相手方のいない単独行為の無権代理については、行為の相手方の保護を考慮する必要がないため、絶対的無効と解されている。
相手方のある単独行為の無権代理についても、相手方や無権代理人に何らかの不利益が生ずると考えられるため、やはり絶対的無効と解されているが、上記の要件を満たす場合には、一定の規定が準用され、本人や相手方の利益の保護が図られることとなる。前段は能動代理、後段は受動代理の場合の規定である。
準用される条文は、以下の通りである。
----
{{前後
|民法
|第1編 総則
第5章 法律行為
第3節 代理
|民法第117条（無権代理人の責任）
|民法第119条（無効な行為の追認）
118 |
2,832 | 特許法第105条の3
特許権侵害訴訟における相当な損害額の認定について規定する。本条は実用新案法、意匠法、商標法において準用されている。
（相当な損害額の認定）
第105条の3 特許権又は専用実施権の侵害に係る訴訟において、損害が生じたことが認められる場合において、損害額を立証するために必要な事実を立証することが当該事実の性質上極めて困難であるときは、裁判所は、口頭弁論の全趣旨及び証拠調べの結果に基づき、相当な損害額を認定することができる。
特許権侵害訴訟における損害額の立証負担を軽減するための規定である。
特許権侵害による損害は、経済活動を通じて発生するため、損害の範囲およびその額を立証することは困難な場合がある。
従来、特許法上、102-104条、105条の規定により立証負担の軽減が図られていた。また、平成8年の民訴法の全面改正時には、民事一般の原則として、民訴248条においてその立証負担を軽減する措置が定められた。
しかし、たとえば、102条1項の規定により損害額を立証しようとしても、安価な侵害品の存在により商品の値下げを余儀なくされたときには、被侵害者の逸失利益の額の計算が複雑となる。また、同条2項の規定により損害額を立証しようとしても、他の特許権、製品のデザイン、商標など他の要因も顧客吸引力を発揮するから、特許権の寄与度の立証は困難である。
これらの場合のように計算式を立てることが困難であっても計算が不可能であるとまでは言えず、このため一義的に「損害の性質上……極めて困難」（民訴248条、太字による強調は筆者）であるとは言えず、同条の適用が困難であるとの指摘がなされていた。また、その販売数量を立証するには法外な費用がかかり、そのすべてを証明することが現実的ではない場合も想定される。
そこで、損害額を立証するために必要な事実を立証することが当該事実の性質上極めて困難であるときは、裁判所が口頭弁論の全趣旨および証拠調べの結果に基づいて相当な損害額を認定することができることとした。
いわゆる間接侵害（101条）は特許権または専用実施権の侵害とみなされる（同条柱書）。したがって、いわゆる間接侵害に基づく損害賠償請求の場合にも本条の趣旨から、本条の規定への適用があると考えられる民709条の規定に従って損害賠償を請求できる以上、仮に、いわゆる間接侵害の場合に、102条や103条の規定の適用が受けられないと解されるとしても、このことは何ら本条の適用の可否の解釈について影響を及ぼすとは考えにくい。。また、明文上、独占的通常実施権者に本条の適用を認めてはいないが、少なくとも固有の損害賠償請求権は認められる上（民709条）独占状態が「法律上保護される利益」にあたるため。平成16年改正前にはこの文言はなかったが、民709条の適用があるものと考えられていた。、特許権（専用実施権の設定範囲内であれば専用実施権も）を侵害していることには変わらず、また本条の趣旨は特許権侵害訴訟における損害額の立証負担の軽減にあることから、適用があるものと解すべきであろう（東京地方裁判所平成10年5月29日判決参照）。
なお、「損害額」の文言からすると、本条は本来損害賠償の請求を行う場合に適用されるものと考えられるが、不当利得返還請求の場合に類推適用を認めた例がある（東京地方裁判所平成21年2月18日判決、コンクリート構造物の機械施工方法事件）。 |
2,833 | 公認会計士法に関する次の記述のうち，正しいものの組合せとして最も適切な番号を一つ選びなさい。（5点）
ア．公認会計士は，やむを得ない事情があると認められるなどの例外的な場合を除き，監査証明業務を行った翌会計期間の終了日まで，被監査会社の親会社，連結子会社，持分法適用の非連結子会社，関連会社及び親会社の他の連結子会社の役員になることはできない。
イ．公認会計士法に定める大規模監査法人では，業務執行社員のみではなく，監査証明業務の審査に関与し，最も重要な責任を有する者もローテーションの対象となる。
ウ．公認会計士は，大会社等の財務書類について監査証明業務を行う際に監査法人と共同監査を行っている場合において，当該監査法人が解散したことにより共同で当該業務を行うことができなくなったときには，新たに公認会計士又は監査法人を選任して，共同監査を行わなければならない。
エ．全ての有限責任監査法人は，計算書類を作成しなければならず，当該計算書類については，特別の利害関係のない公認会計士又は監査法人の監査報告書を添付しなければならない。
1
ア．公認会計士は，やむを得ない事情があると認められるなどの例外的な場合を除き，監査証明業務を行った翌会計期間の終了日まで，被監査会社の親会社，連結子会社，持分法適用の非連結子会社，関連会社及び親会社の他の連結子会社の役員になることはできない。公認会計士法28条の2，同施行規則13条1項
イ．公認会計士法に定める大規模監査法人では，業務執行社員のみではなく，監査証明業務の審査に関与し，最も重要な責任を有する者もローテーションの対象となる。公認会計士法34条の11の4，同施行規則23条2号
ウ．公認会計士は，大会社等の財務書類について監査証明業務を行う際に監査法人と共同監査を行っている場合において，当該監査法人が解散したことにより共同で当該業務を行うことができなくなったときには，新たに公認会計士又は監査法人を選任して，共同監査を行わなければならない。やむを得ない事情に該当するため，単独監査を行うことができる。公認会計士法24条の4，同施行規則11条4号
エ．全ての有限責任監査法人は，計算書類を作成しなければならず，収益の額が10億円以上の場合，当該計算書類については，特別の利害関係のない公認会計士又は監査法人の監査報告書を添付しなければならない。公認会計士法34条の32第1項，同施行令24条 |
2,834 | 密接に関連した複数の代数的な抽象(数)を単一の汎用的な抽象に隠蔽し、汎用的なインタフェースを提供する。
Smalltalk のような純粋なオブジェクト指向言語では、変数は、オブジェクトへの実行時の束縛であり、ラベルのように働く。
変数をあるオブジェクトに束縛するということは、オブジェクトにラベルを貼り付けるようなものである。
これらの言語における代入は、ラベルをあるオブジェクトからはがして、別のオブジェクトに貼り付けることに例えられる。
一方、C/C++ では、変数は、オブジェクトに対するラベルではなく、アドレスやオフセットの別名である。代入はラベル付けし直すことではなく、古い内容を新しい内容で上書きすることを意味する。代数的階層(Algebraic Hierarchy)イディオムは、C++ でオブジェクトへの束縛を示す弱い変数をシミュレートするため委譲された継承(delegated polymorphism)を用いる。
代数的階層(Algebraic Hierarchy)イディオムはまた、その実装で封筒・便箋(Envelope Letter)イディオムを使用する。
以下のようなコードを書けるようにすることが、このイディオムの背景にある動機である。
Number n1 = Complex (1, 2); // 複素数用のラベル n1
Number n2 = Real (10); // 実数用のラベル n2
Number n3 = n1 + n2; // 加算の結果を n3 としてラベル付け
Number n2 = n3; // ラベル付けし直す
以下が、代数的階層(Algebraic Hierarchy)イディオムの実装を示す完全なコードである。
using namespace std;
struct BaseConstructor { BaseConstructor(int=0) {} };
class RealNumber;
class Complex;
class Number;
class Number
{
friend class RealNumber;
friend class Complex;
public:
Number ();
Number & operator = (const Number &n);
Number (const Number &n);
virtual ~Number();
virtual Number operator + (Number const &n) const;
void swap (Number &n) throw ();
static Number makeReal (double r);
static Number makeComplex (double rpart, double ipart);
protected:
Number (BaseConstructor);
private:
void redefine (Number *n);
virtual Number complexAdd (Number const &n) const;
virtual Number realAdd (Number const &n) const;
Number *rep;
short referenceCount;
};
class Complex : public Number
{
friend class RealNumber;
friend class Number;
Complex (double d, double e);
Complex (const Complex &c);
virtual ~Complex ();
virtual Number operator + (Number const &n) const;
virtual Number realAdd (Number const &n) const;
virtual Number complexAdd (Number const &n) const;
double rpart, ipart;
};
class RealNumber : public Number
{
friend class Complex;
friend class Number;
RealNumber (double r);
RealNumber (const RealNumber &r);
virtual ~RealNumber ();
virtual Number operator + (Number const &n) const;
virtual Number realAdd (Number const &n) const;
virtual Number complexAdd (Number const &n) const;
double val;
};
/// (封筒・便箋(Envelope Letter)イディオムにおける)便箋(letters)によってのみ使用される
Number::Number (BaseConstructor)
referenceCount (1)
{}
/// ユーザと静的ファクトリ関数によって使用される
Number::Number ()
: rep (0),
referenceCount (0)
{}
/// ユーザと静的ファクトリ関数によって使用される
Number::Number (const Number &n)
referenceCount (0)
{
cout << "Number::Number による Number の生成\n";
if (n.rep)
n.rep->referenceCount++;
}
Number Number::makeReal (double r)
{
Number n;
n.redefine (new RealNumber (r));
return n;
}
Number Number::makeComplex (double rpart, double ipart)
{
Number n;
n.redefine (new Complex (rpart, ipart));
return n;
}
Number::~Number()
{
if (rep && --rep->referenceCount == 0)
delete rep;
}
Number & Number::operator = (const Number &n)
{
cout << "Number::operator= による Number の代入\n";
Number temp (n);
this->swap (temp);
return *this;
}
void Number::swap (Number &n) throw ()
{
std::swap (this->rep, n.rep);
}
Number Number::operator + (Number const &n) const
{
return rep->operator + (n);
}
Number Number::complexAdd (Number const &n) const
{
return rep->complexAdd (n);
}
Number Number::realAdd (Number const &n) const
{
return rep->realAdd (n);
}
void Number::redefine (Number *n)
{
if (rep && --rep->referenceCount == 0)
delete rep;
rep = n;
}
Complex::Complex (double d, double e)
: Number (BaseConstructor()),
rpart (d),
ipart (e)
{
cout << "Complex の生成\n";
}
Complex::Complex (const Complex &c)
: Number (BaseConstructor()),
rpart (c.rpart),
ipart (c.ipart)
{
cout << "Complex::Complex による Complex の生成\n";
}
Complex::~Complex()
{
cout << "Complex::~Complex() 内部\n";
}
Number Complex::operator + (Number const &n) const
{
return n.complexAdd (*this);
}
Number Complex::realAdd (Number const &n) const
{
cout << "Complex::realAdd\n";
RealNumber const *rn = dynamic_cast (&n);
return Number::makeComplex (this->rpart + rn->val,
this->ipart);
}
Number Complex::complexAdd (Number const &n) const
{
cout << "Complex::complexAdd\n";
Complex const *cn = dynamic_cast (&n);
return Number::makeComplex (this->rpart + cn->rpart,
this->ipart + cn->ipart);
}
RealNumber::RealNumber (double r)
: Number (BaseConstructor()),
val (r)
{
cout << "RealNumber の生成\n";
}
RealNumber::RealNumber (const RealNumber &r)
: Number (BaseConstructor()),
val (r.val)
{
cout << "RealNumber::RealNumber による RealNumber の生成\n";
}
RealNumber::~RealNumber()
{
cout << "RealNumber::~RealNumber() 内部\n";
}
Number RealNumber::operator + (Number const &n) const
{
return n.realAdd (*this);
}
Number RealNumber::realAdd (Number const &n) const
{
cout << "RealNumber::realAdd\n";
RealNumber const *rn = dynamic_cast (&n);
return Number::makeReal (this->val + rn->val);
}
Number RealNumber::complexAdd (Number const &n) const
{
cout << "RealNumber::complexAdd\n";
Complex const *cn = dynamic_cast (&n);
return Number::makeComplex (this->val + cn->rpart, cn->ipart);
}
namespace std
{
template <>
void swap (Number & n1, Number & n2)
{
n1.swap (n2);
}
}
int main (void)
{
Number n1 = Number::makeComplex (1, 2);
Number n2 = Number::makeReal (10);
Number n3 = n1 + n2;
cout << "終了\n";
return 0;
}
Advanced C++ Programming Styles and Idioms by James Coplien, Addison Wesley, 1992.
More C++ Idioms/Algebraic Hierarchy
|たいすうてきかいそう]] |
2,835 | 公式ドキュメントは以下のサイトで参照できる。
Fedora の場合、dnf コマンド
sudo dnf install postgresql
sudo dnf install postgresql-server
で入る。
それぞれ、クライアント側(postgresql)とサーバー側(postgresql-server)である。この両方を入れないといけない。片方だけだと、後述の sytemctl が失敗する。データベースサーバーとして postgresql-server を起動して使う仕組みである。
インストールできたと思ったら、とりあえず下記コマンドでバージョン確認をできる。
psql -V
または
psql --version
である。
なお、ヘルプ一覧を見るにはpsql --helpである。hだけだとホスト("host")に「h」が使われているので、ヘルプの意味にならないので、きちんと help と指定しよう。
初期設定
データベースとしての使用の前には、さらに後述のsytemctlの前に、初期化の設定を下記コマンドで行わないといけない。（そうしないとエラーで失敗する）
sudo postgresql-setup --initdb
起動方法
上記のコマンドがすべて終わったら、ようやく、postgresql-server を起動できる。コマンド名にはserver とないが、しかし下記コマンドで起動されるのはデータベースサーバーのほうである。
sudo systemctl start postgresql
なお、sytemctl start は Fedora側のコマンドである。単にそのコマンドを使って postgresql を起動せよ、という命令を上記コマンドでは実行しているにすぎない。
終了方法
postgresqlサーバー終了は
sudo systemctl stop postgresql
である。
状態確認コマンド
起動状態の確認コマンドは、起動中（systemctl start postgresql を実行したあとの状態）に、
sudo systemctl status postgresql
である。これを押すと、ターミナル（コマンド端末）画面に、確認結果の情報が列記される。
なお、確認画面の終了方法は q ボタン である。
接続方法
postgres を使用するためには、インストールしたpostgresのシステムに接続しなければならないが、その際にアカウントが必要になるのだが、当然、あなた個人用のアカウントなんて作成されておらず、「 postgres 」という名のアカウントだけが事前に用意されているので、これを使うことになる。
なので、まずLinux のターミナルのアカウントを変更する必要がある。下記コマンド
sudo su - postgres
でアカウント「postgres」に変更できる。これをしないと、手元のパソコンで通常使用しているユーザー名でpostgresシステムにログインしようとするが、当然ながらそんなアカウント名はインストールしたばかりのpostgresシステムでは作成されていないので、（アカウント名を postgres に切り替えないと）ログインに失敗してしまう。
アカウント名を切り替え終わったら、コマンド
psql -U postgres
でログインできる。
[postgres@fedora ~]$ psql -U postgres
psql (14.3)
"help"でヘルプを表示します。
postgres=#
のような結果になれば、とりあえず成功である。
なお、終了するには、コマンド
\q
である。つまり、
postgres-# \q
のような入力画面でエンターすることになる。
これはまだpostgresqlとの接続を終了しただけなので、まだlinuxのアカウントはpostgreのままである。
なので、普段使用している元のアカウントに戻るなら、単に exit コマンドで良い。
exit
インストールや初期設定の終わったあとなら、
sudo su - postgres
のあとで、
下記コマンドを実行するだけで、まだなにもデータベースを作成しなくても、データの一覧が表示されます。
psql -l
Fedora 36 にインストールした psql (PostgreSQL) 14.3 での例は、下記のようなデータでした。
データベース一覧
名前 | 所有者 | エンコーディング | 照合順序 | Ctype(変換演算子) | アクセス権限
-----------+----------+------------------+-------------+-------------------+-----------------------
postgres | postgres | UTF8 | ja_JP.UTF-8 | ja_JP.UTF-8 |
template0 | postgres | UTF8 | ja_JP.UTF-8 | ja_JP.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
template1 | postgres | UTF8 | ja_JP.UTF-8 | ja_JP.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
(3 行)
たとえば、
sudo su - postgres
で、まず接続する。
そのあと、まず、所有者になるユーザーを専用コマンドcreateuser で作る。たとえばユーザー名を yamada とするならコマンドは
createuser yamada
となる。
その後、そのユーザー名を、これから作成するデータベースの所有者(owner)名としてデータベース登録を始める。とりあえずデータベース名を testdb とするなら、コマンドは
createdb -O yamada testdb
のようになる。
確認のため、
psql -l
コマンド。すると、下記のように表示される。
データベース一覧
名前 | 所有者 | エンコーディング | 照合順序 | Ctype(変換演算子) | アクセス権限
-----------+----------+------------------+-------------+-------------------+-----------------------
testdb | yamada | UTF8 | ja_JP.UTF-8 | ja_JP.UTF-8 |
postgres | postgres | UTF8 | ja_JP.UTF-8 | ja_JP.UTF-8 |
template0 | postgres | UTF8 | ja_JP.UTF-8 | ja_JP.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
template1 | postgres | UTF8 | ja_JP.UTF-8 | ja_JP.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
(4 行)
のように、作成したデータベースが追加されて
testdb | yamada | UTF8 | ja_JP.UTF-8 | ja_JP.UTF-8 |
という行が加わり、また最後が「4 行」になっているのが分かる。
このtestdb にログインするには、単に、上記の表示などが見られる postgresQL接続状態にて、コマンド
psql testdb
を実行するだけでいい。
psql (14.3)
"help"でヘルプを表示します。
のように表示されれば、とりあえずの成功である。
先に
sudo su - postgres
psql mydb
をしておく。
すると、下記の状態になる。
psql (14.3)
"help"でヘルプを表示します。
postgres=#
CREATE TABLE コマンドで、テーブルを作成できる。
書式は、
CREATE TABLE テーブル名 (
列名1 データ型1 補足1,
列名2 データ型2 補足2
);
である。「補足」の部分は無くても良く、たとえばNULL値を許容するかどうかの指定などに使う。 NOT NULL などが「補足」にくる。
コード例
mydb=# CREATE TABLE test1 (
id integer,
name varchar(30)
);
末尾にセミコロンが必要なのを注意。セミコロンを忘れると作成できない。
上記コードを入力すると、自動的に下記のように「CREATE TABLE」という反応が最終行の下に追記され、また入力待ちになるので、下記のような画面になる。
画面
mydb=# CREATE TABLE test1 (
id integer,
name varchar(30)
);
CREATE TABLE
mydb=#
とりあえず、この画面になれば成功である。
この状態で、入力したテーブルの内容を確認するには\dで可能である。
mydb=# CREATE TABLE test1 (
id integer,
name varchar(30)
);
CREATE TABLE
mydb=# \d
リレーション一覧
スキーマ | 名前 | タイプ | 所有者
----------+-------+----------+----------
public | test1 | テーブル | postgres
(1 行)
なお、データベース名が「mydb」に変わってるが、単にwiki著者がネット情報を参考にそのデータベース名で作ってしまったから、そうなってる。
これだけだと、まだデータの列名だけを決めただけなので、具体的な中身がない。中身はコマンド insertで入力できる。
つづけて、
リレーション一覧
スキーマ | 名前 | タイプ | 所有者
----------+-------+----------+----------
public | test1 | テーブル | postgres
(1 行)
mydb=# insert into test1 values (1, 'tanaka' );
INSERT 0 1
のようにinsert コマンド「 insert into test1 values (1, 'tanaka' ); 」を入力すると、
反応「 INSERT 0 1 」が返ってくる。
構文は、
INSERT INTO テーブル名 VALUES (値1, 値2) ;
である。
作成したテーブルの中身を確認したいなら、コマンドselectであり、上記の場合なら具体的には
select * from test1;
である。
結果
mydb=# select * from test1;
id | name
----+--------
1 | tanaka
(1 行)
のようになれば、成功。
つづけて、今後のコマンドの勉強のため、読者には
insert into test1 values (2, 'itoh' );
をしてもらいたい。（あとでこれの消しかたを教える）
つづけて
select * from test1;
をすれば、
結果
mydb=# select * from test1;
id | name
----+--------
1 | tanaka
2 | itoh
(2 行)
のようになる。
では、 idが1のtanaka を消そう。delete で消せる。上記の例なら、
delete from test1 where id=1 ;
で消せる。
構文は
DELETE FROM テーブル名 WHERE 条件式
である。
ともかくdeleteコマンドを実行したら、つづけて確認のため、
select * from test1;
すれば、結果
mydb=# select * from test1;
id | name
----+------
2 | itoh
(1 行)
となる。たしかに yamada が正しく消せた。 |
2,836 | コンメンタール＞コンメンタール行政手続＞コンメンタール独立行政法人等の保有する個人情報の保護に関する法律
独立行政法人等の保有する個人情報の保護に関する法律(最終改正：平成一九年七月六日法律第一〇九号)の逐条解説書。 |
2,837 | 法学＞民事法＞コンメンタール農地法
（調停）
第36条
前条第2項の規定による協議が調わず、又は協議を行うことができないときは、同条第1項の規定による指定を受けた農地保有合理化法人等は、同項の規定による通知があつた日から起算して二月以内に、農林水産省令で定めるところにより、都道府県知事に対し、その協議に係る所有権の移転等につき必要な調停をなすべき旨を申請することができる。
都道府県知事は、前項の規定による申請があつたときは、速やかに調停を行うものとする。
都道府県知事は、前項の規定により調停案を作成したときは、これを当事者に示してその受諾を勧告するものとする。
----
{{前後
|農地法
|第4章 遊休農地に関する措置
|農地法第35条（所有権の移転等の協議）
|農地法第37条（裁定の申請）
36 |
2,838 | １９３９年９月１日、ドイツがポーランドに攻め入りました。その２日後、イギリスとフランスがドイツに宣戦布告し、第二次世界大戦が始まります。開戦当初、ドイツは破竹の勢いで勝ち進んでいきました。１年足らずのうちに、イギリスを除く西ヨーロッパのほぼ全体を制覇したのです。１９４０年６月、イタリアが、イギリスやアメリカに対して宣戦布告。戦場は、バルカン半島や北アフリカにも広がりました。また、アジアでは日本が、フランスの植民地となっていたインドシナ半島に軍を進めていました。日本、ドイツ、イタリアは、１９４０年９月に「三国同盟」を結び、つながりを強めていきます。第二次世界大戦は、南北アメリカ大陸を除くほとんどの地域を戦場とする、史上最大の戦争へと広がっていくのです。 |
2,839 | 数学演習 中学校2年生
中学校数学 2年生-数量/連立方程式
問題はこちらにあります。
(1)(x,y) = (2,-2)
上の式を下のyに代入する。
となり2x=4、つまりx=2が求められる。上の式に戻りx=2を代入するとy=-2となる。
(2)(x,y) = (1,3)
ここでも上の式を下のyに代入する。
となり7x=7、つまりx=1が求められる。上の式に戻りx=1を代入するとy=3となる。
(3)(x,y) = (-6,3)
x=...という形になっているため下のxに入れたほうが楽。
となり-3y=-9、つまりy=3が求められる。上の式に戻りy=3を代入するとx=-6となる。
(4)(x,y) = (\frac{1}{3},\frac{1}{9})
上の式の両辺3倍して3y=xとし下のxに代入してもよいが、ここでは素直に下のyに代入してみる。
となり3x=1、つまりx = \frac{1}{3}が求められる。上の式に戻りx = \frac{1}{3}を代入するとy = \frac{1}{9}となる。
(5)(x,y) = (2,7)
上の式を下のyに代入する。
となり7x=14、つまりx=2が求められる。上の式に戻りx=2を代入するとy=7となる。
(1)(x,y) = (7,-2)
上の式と下の式を足すとyが消去できる。また、上の式から下の式を引くとxが消去できる。好きなほうを消去してよいが、ここではyを消去する。
(x+y)+(x-y) &=& 5+9 \\
2x &=& 14 \\
x &=& 7
\end{matrix}
xが求まったので元の上下どちらかの式にx=7を代入するとy=-2となる。
(2)(x,y) = (5,3)
係数が合っている場合はその文字を消去すると簡単。上の式から下の式を引いてyを消去する。
(x+3y)-(3x+3y) &=& 14-24 \\
-2x &=& -10 \\
x &=& 5
\end{matrix}
xが求まったので元の上の式か下の式のどちらか（上の式のほうが簡単)にx=5を代入するとy=3となる。
(3)(x,y) = (-2,3)
上下の式を足したり引いたりするだけでは文字を消去できないので、この場合はどちらかの式を整数倍して係数を揃える。ここでは下の式を2倍する。
ここで上の式と下の式を足すことで文字を消去できる形になった。ここまで来れば(2)までの解き方と同様。x=-2、y=3となる。
(4)(x,y) = (-4,7)
これはどちらかの式を整数倍しても係数が合わない形である。xを\frac{3}{2}倍もしくはyを\frac{5}{2}倍すればどちらかを消去できるが式に分数が入り面倒な形になるのでおすすめはしない。この場合は上の式を3倍、下の式を2倍にしxの係数を揃える。
ここで上の式から下の式を引くことで文字を消去できる形になった。ここまで来れば(2)までの解き方と同様。x=-4、y=7となる。
ごく一部の例外を除けば以下の法則が成り立つ。
式の本数と未知数の数が等しいならば解は一意に定まる。
未知数の数が式の本数より多ければ解は複数存在する。
式の本数が未知数の数より多ければ解は存在しない。
ごく一部の例外は連立されている式のうち少なくとも2式が、グラフを書いた際同一の直線であることを示す場合である。例えば以下のようなものは上記の例外で式が複数存在する連立方程式となる。解は x+2y=6 を満たす(x,y)の組全てである。
(1)(x,y,z) = (4,-1,3)
文字と式が3組以上になっても行うことは変数を1つずつ消去していくことである。この場合は上の式がx+y=zとなっているので代入法を用いて中央の式と下の式のzを消去する。
この2式を更に連立して解く。元の3式と区別するために連立させた2式を上’、下’とする。
下’の式を2倍する。
ここで上’の式から下’の式を引くことでyを消去できる形になった。11y=-11なのでy=-1、2式の連立の場所まで戻ってx=4、元の3式まで戻ってz=3となる。
(2)(x,y,z) = (-5,7,2)
代入法で解くには分数が出てくることから少々苦しいので、加減法を利用する。式をうまくいじって文字を1つ消去する。ここではyを消去することを考えてみる。上の式を4倍したものと中央の式を3倍したものを足す式が1つ目、中央の式から下の式の2倍したものを引く式が2つ目である。この2つの式を計算してyを消去した2式を作る。
この2式を更に連立して解く。元の3式と区別するために連立させた2式を上’、下’とする。
上’の式を4倍、下’の式を7倍する。
ここで上’の式と下’の式を足すことでzを消去できる形になった。169x=-845なのでx=-5、2式の連立の場所まで戻ってz=2、元の3式まで戻ってy=7となる。
(1)(答)毎分8リットルで入れた時間は26分、毎分12リットルで入れた時間は6分
毎分8リットルで入れた時間をx分、毎分12リットルで入れた時間をy分として連立方程式を立てる。
まずは時間で式を作る。x分とy分の時間の合計が32分なので、
である。
続いて流量で式を作る。毎分8リットルでx分、毎分12リットルでy分流して280リットルの浴槽が満杯となったとあるから、
となる。これらの式を連立して解く。ここでは時間の式をx = 32-yに変形してから代入法を用いる。
8(32-y)+12y &=& 280 \\
256-8y+12y &=& 280 \\
4y &=& 280-256 \\
4y &=& 24 \\
y &=& 6
\end{matrix}
となり、y = 6である。時間の式に戻ればx = 26と求められる。
(2)解答:食塩水Aが300グラム、食塩水Bが200グラム
解説:(ここでは食塩水Aの量を x グラム、食塩水Bの量を y グラムとする。ただし、問題文に規定がないため、これらの文字を読みかえてほしい。)まず、「10%の食塩水Aに含まれる食塩の量xグラム」を「0.1x」とし、「15%の食塩水Bに含まれる食塩の量yグラム」を「0.15y」とする。次に、これらを足すと「12%の食塩水500グラムに含まれる食塩の量」を「12\times 5」、計算して60とする。さらに、このxとyは合計すると500グラムになることが分かるので「x+y=500」とできる。この2つの式で連立方程式を立てて計算することによりそれぞれが求まる。
\begin{cases} 0.1x+0.15y=60 \\ x+y=500 \end{cases}
\begin{array}{lcl}
\rightarrow 5000 - 10y + 15y & = & 6000 \\
5y & = & 1000 \\
y & = & 200
\end{array}
以上より、Bの量は200グラムであると分かる(誤ってAの量にしないように注意)。さらに計算すると
x=300
と分かる。この場合は代入法で求めたが、加減法を使用したり、先に食塩水Bの量を求めても連立方程式の性格上同じ答えになる。
(3)
解説:大人2人と子ども5人の班をx班、大人3人と子ども7人の班をy班として連立方程式を作るには、大人と子供の数に注目すればいい。
大人2人と子ども5人の班の大人の人数の合計と、大人3人と子ども7人の班の大人の人数の合計の和は、55人である。
また、大人2人と子ども5人の班の子どもの人数の合計と、大人3人と子ども7人の班の子どもの人数の合計の和は、133人である。
このことから連立方程式をつくると、
\begin{cases} 2x+5y=55 \\ 3x+7y=133 \end{cases}
となる。
(4)
(5)
なお、100y+10x+xは百の位と十の位を入れ替えた数である。
このようにして、xが6であることを求めることができる。また、同様にするか、代入するかしてyが8であることも求められる。元の自然数は10x+10y+xであるので、この自然数は686であると分かる。 |
2,840 | JavaScriptを使用してクッキー（Cookie）を操作することは一般的です。クッキーは、ウェブサイトがユーザーのブラウザに保存する小さなデータの塊で、サイトの動作を追跡するためやユーザーエクスペリエンスを向上させるために使用されます。以下は、JavaScriptを使用してクッキーを設定、取得、削除する基本的な方法です。 |
2,841 | 物理数学I > ベクトル解析
ここでは、ベクトル解析について解説を行なう。
ベクトル解析は、主に多変数関数の微積分と関連しているが、
特にそれらのうちには計算自体に明確な物理的意味を
持つものがいくつか見られる。歴史的にもこの分野は
数学と物理の間のフィードバックを通して発展して来た。
そのため、計算においては物理的な意味を強調していきたい。
また、特にいくつかの定理は数学的に厳密な証明をすることが
難しい。その様なときには常識的に古典的な物理学の範囲で
起こる現象で適用できる程度に、一般的に
書くことにしたいと思う。
また、現代的にはこの分野は微分形式を用いて書かれることが多いが、
ここではまず最初に古典的な計算法を扱う。
これは、特に物理を専攻としない学習者に配慮するためである。
例えば、電気技術者や機械技術者もベクトル解析は依然として学ばねば
ならず、彼らに取っては微分形式の理論はそれほど有用とはいえないものと
思われる。
ベクトル解析の理論は特に電磁気学と関連が深いが、これらの結果は
流体力学や量子力学など、様々な分野で登場する物理の根幹を成す計算法であり、
学習者は十分これらの手法に習熟することが求められる。
なお、ベクトル自体の性質については線型代数学/ベクトルを参照していただきたい。
例えば3次元ベクトルで
\vec r = (x,y,z)
とするとき、ある変数tについて
x,y,z が、
(x,y,z) = (x(t),y(t),z(t))
で表わされるとき、
\vec r
を、ベクトルの関数と呼ぶ。
これは、tを時間と見なすときにはある3次元空間中を
物体が動いて行く軌跡の値と見なすことが出来る。
例えば、
x= t, y=0,z = 0
という軌跡を与えたとき、この値は
物体がxの方向に速度1で等速直線運動しているものとみなすことが
できる。
ただし、この定義自体は3次元にとどまらず容易にn次元に拡張することが
出来る。
例えば、
(x _1,x _2,\cdots ,x _n) = (x _1(t),x _2(t),\cdots ,x _n(t))
のようにn次元のベクトルを取ったときに、そのうちの各要素が
ある独立変数tだけに依存すると考えることが出来るとき
これは、n次元空間の中の物体の軌跡と考えることが出来る。
ここでは、ベクトルの微分を定義する。
例えば、1次元においては、物体の速度は
\dot x = \frac {x(t+dt) - x(t)}{dt}
で与えられた。この値はある時間における物体の
位置の変化率という直接的な物理的意味を持っている。
これらの自然な拡張として一般的な次元において、
\dot r = \frac {\vec r(t+dt) - \vec r(t)}{dt}
によって、ベクトルの微分を定義する。
例えば、1次元空間に限ったときにはこの結果は上の式と一致することが分かる。
このことによって、例えば
(x,y) = (x(t), y(t))
という2次元ベクトルを取ったとき、
物体の速度のx方向成分は
\dot x = \frac {x(t+dt) - x(t)}{dt}
によって与えられ、物体の位置のx方向成分のみによることが示唆される。
同様に
物体の速度のy方向成分は
物体の位置のy方向成分のみによっている。
このことは一見当然のように思えるが、実際にはそうではなく
我々が用いている座標系によっている。
例えば、2次元の極座標を用いてみると、
\vec x = x \vec e _x + y \vec e _y = r \vec e _r
と書けるが、
この式を正しく微分すると、
\vec v = \dot r \vec e _r + r \dot \theta \vec e _\theta
が得られ、速度の\theta成分は、物体のr成分にも依存している。
このことは、直接的には\vec e _r自身が時間依存性を持っている。
我々が通常用いる(x,y,z)という座標系は
通常直交座標系と呼ばれるが、(デカルト座標系と呼ばれることも多い。)
これらの座標軸の方向は時間的に変わることが無いので、
微分の性質が非常に簡単になっている。
しかし、実際にある物体の動きを記述するとき、直交座標系を用いるより、
その動きに特徴的な量をパラメーターとして用いた方が記述が簡明に
なることがある。例えば、太陽のまわりを円運動する惑星の
動きを記述するには、極座標を用いると、物体の運動がもっとも簡潔に記述される。
この様に、運動の種類によって用いるべき座標系が変わって来るため、
それぞれの間の緒量の変化、つまり微分や積分の性質を調べることが重要に
なる。
ここまでで一般的な微分の方法を見た。
ここでは、特に物理的に重要なベクトルの作り方を
見る。
ある関数f(x,y,z)
があるものとする。
このとき、
)
をfの勾配と呼ぶ。
また、同様にしてn次元では
})
によって定義される。
ここで、勾配はこの式の意味によって付けられた名前である。
例えば、
y= z = 0
に限ってこの式を書いてみる。
このとき、
, 0, 0)
となるが、これはこの関数fのx方向の傾きに等しい。
つまり、この式は傾きを求める式の複数の方向を用いた場合への一般化と
なっている。
より一般的な例として2次元の場合の
例を考えてみる。ここでは
f(x,y) = x^2 + y^2
とおく。
このときこの式の勾配は簡単に計算でき、
\textrm{grad} f = ( 2 x, 2y, 0)
となる。例えば、この式を
x = a, y=0
(aはある定数。)
について考えてみる。
このとき、勾配の値は
\textrm{grad} f = ( 2 a, 0, 0)
となるが、これはxが正のとき正であり、負のときには負となっている。
つまり、この式はこの関数のx座標軸上で見たときに、
x=0を極少としたすり鉢形のグラフとなっており、更に
原点から離れれば離れるほど、グラフの傾きが増すことを示唆している。
実際この式を数値的にプロットすると、この主張が確かめられる。
プロットを作製。
次に、この式を
x = 0, y=b
(bはある定数。)
について考えてみる。
このときにも全く同じ主張が出来、y方向に見ても
このグラフはすり鉢状になっている。
また、この式を
x = y= \frac c {\sqrt 2}
について考えてみる。このときには
\textrm{grad} f = 2(\frac c {\sqrt 2},\frac c {\sqrt 2})
が得られ、この点では勾配はx軸から\pi/4の方向を向いていることが分かる。
一般に勾配は、関数fが、最も大きな傾きで増加する方向を
向いており、その絶対値はその点でそちらへの微分を取った値に等しい。
また、ある点でのある方向への微分を求めたいときには、
求めたい方向の単位ベクトルを
\vec n
としたとき、
\textrm{grad} f \cdot \vec {n}
を計算することで、求めることが出来る。
勾配の計算では、全ての独立変数に対する微分を求めており、
これらの微分を組み合わせることであらゆる方向への微分を
作ることが出来ることが期待される。
微分の最も低いオーダーでは、それぞれの方向への微分は
それぞれの方向の単位ベクトルにそちらの方向への微分の大きさを
かけたものに等しいので、ある方向に対する微分を
計算するにはそれらを適切な方向への重みをつけて足し合わせることが
求められる。このとき、ある方向に対する単位ベクトルと
ある軸の方向に対する単位ベクトルは、2つの方向の重みを表わしていると
考えられるので、確かにこの値は、そちらの方向への微分となっている。
例えば、
x = a,y=0
でのy方向の傾きは、
\textrm{grad} f \cdot \vec {n}= (2a,0)\cdot (0,1)=0
となるが、
これは、この関数の等高線が円形になっていることを考えると
確かにこの点ではy方向の傾きは0になっていなくてはいけない。
次には逆にあるベクトルを取ったとき、
あるスカラー量を作りだす計算を導入する。
後に示される通り、この量はある点から流れ出す
粒子や場の束の和という物理的意味を持っており、
電磁気学や流体力学で頻繁に用いられる。
実際前者では磁束や電束についての計算に用いられ、
後者では流体中のわきだしや吸い込みなどのまわりで
流体の性質を表わすベクトルがnon-zeroになることが
知られている。
あるベクトルの関数
\vec a
があるとき、
を、\vec aの発散と呼ぶ。
また、この量もn次元で定義することが出来、そのときの定義は、
}
で与えられる。
ただし
a _i
はベクトル
\vec a
の第i成分である。
この式の物理的意味は上で述べた通りだが、そのことの導出は
ガウスの定理の導出によって与えられるため、ここでは扱わない。
ここでもう1つ、物理的に重要な演算を導入する。
この量も電磁気学や流体力学で使われており、
ある経路に沿って積分した値がその経路の中の
ある量の積分によって与えられるという定理である。
実際には電磁気学では古典的にある回路を突き抜ける磁束の時間変化が
、その回路内に電流を引き起こすことがレンツの法則として知られている。
この法則は、このようなベクトルの演算によってうまく記述される現象の
例である。
流体力学では、この量は流体中に巻き起こる渦に対応している。
つまり、渦が流れるルートに沿って、流体の速度を積分していけば
0でない値が得られることが期待される。一方、そうでない場合
この値は全ての寄与が打ち消し合い、0になると思われる。
つまり、この量を用いることで、流体中の渦を記述する方法が得られるわけである。
ただし、実際には流体の運動を考えるときには渦が一切発生しないと
した方が計算が簡単になることも多い。このような流れは渦無しの流れと
呼ばれ、その性質はよく知られている。
ここからはベクトルの回転の定義を述べる。
あるベクトルの関数
\vec a
があるとき、
\begin{matrix}
\textrm{rot} \vec a = \\
\begin{pmatrix}
\end{pmatrix}\\
\begin{vmatrix}
\vec e _x &\vec e _y&\vec e _z\\
}\\
a _1&a _2&a _3
\end{vmatrix}
\end{matrix}
を
\vec a
の回転と呼ぶ。
ここでは、ベクトル解析の公式を証明する。これらの公式はベクトルを成分表示して単純に計算することでも証明できるが、この方法ではあまりにも煩雑になってしまうためレヴィ・チヴィタ記号を導入して証明する。
クロネッカーのデルタ \delta_{ij}を
で定義する。
レヴィ・チヴィタ記号 \varepsilon_{ijk} を
{{式番号|\varepsilon_{ijk} = \begin{cases}
1 & \, (i, j, k) = (1, 2, 3), (2, 3, 1), (3, 1, 2) \\
-1 & \, (i, j, k) = (1, 3, 2), (3, 2, 1), (2, 1, 3) \\
0 & \mathrm{otherwise}
と定義する。すなわち、置換 \sigma=\begin{pmatrix}
1 & 2 & 3 \\
i & j & k \end{pmatrix} （ただし i,j,k は互いに異なる）が偶置換のとき、\varepsilon_{ijk} = 1、奇置換のとき\varepsilon_{ijk} = -1 である。また、レヴィ・チヴィタ記号 \varepsilon_{ijk} は \varepsilon_{123} = 1 であり、2つの添字を入れ替えると -1 倍される（反対称）もの (e.g. \varepsilon_{213} = -\varepsilon_{123} = -1 ,\,\varepsilon_{231} = -\varepsilon_{213} = 1 )と理解できる。添字に同じ数字があるときはレヴィ・チヴィタ記号は 0 である（e.g. \varepsilon_{111} = 0,\,\varepsilon_{322} = 0）。
基本ベクトル \boldsymbol e_i を \boldsymbol e_i = \begin{pmatrix} \delta_{1i} \\ \delta_{2i} \\ \delta_{3i} \end{pmatrix} とする。すなわち、\boldsymbol e_1 = \begin{pmatrix} 1 \\ 0 \\ 0 \end{pmatrix},\boldsymbol e_2 = \begin{pmatrix} 0 \\ 1 \\ 0 \end{pmatrix},\boldsymbol e_3 = \begin{pmatrix} 0 \\ 0 \\ 1 \end{pmatrix} である。
\nabla =
\begin{pmatrix}
\frac{\partial}{\partial x} \\
\frac{\partial}{\partial y} \\
\frac{\partial}{\partial z}
\end{pmatrix} をナブラという。
ナブラを通常のベクトル演算と同じように扱うと、grad,div,rotは簡単に
\textrm{grad } f = \nabla f
\textrm{div} \vec a = \nabla \cdot \vec a
\textrm{rot} \vec a = \nabla \times \vec a
と書くことが出来る。
ベクトルの成分に微分演算子が入っていることにびっくりするかもしれないが、形式的なものだと思っても良い。
\Delta := \nabla \cdot \nabla = \frac{\partial^2}{\partial x^2} + \frac{\partial^2}{\partial y^2} + \frac{\partial^2}{\partial z^2}
をラプラシアンという。スカラー関数 f
について \Delta f =\frac{\partial^2f}{\partial x^2} + \frac{\partial^2f}{\partial y^2} + \frac{\partial^2f}{\partial z^2}
であり、ベクトル関数 \boldsymbol A
について \Delta \boldsymbol A = \begin{pmatrix}
\frac{\partial^2A_x}{\partial x^2} + \frac{\partial^2A_x}{\partial y^2} + \frac{\partial^2A_x}{\partial z^2} \\
\frac{\partial^2A_y}{\partial x^2} + \frac{\partial^2A_y}{\partial y^2} + \frac{\partial^2A_y}{\partial z^2} \\
\frac{\partial^2A_z}{\partial x^2} + \frac{\partial^2A_z}{\partial y^2} + \frac{\partial^2A_z}{\partial z^2}
\end{pmatrix}
である。
以下では、簡単のためにベクトル \boldsymbol Aの x 成分 A_x を A_1、 y 成分 A_y を A_2、 z 成分 A_z を A_3 と書く。偏微分についても \frac{\partial}{\partial x} = \partial_x = \partial_1 などとする。ベクトル \boldsymbol A の 第i成分 A_i を [\boldsymbol A]_i と書く。
ベクトルの外積 \boldsymbol A \times \boldsymbol B の第i成分 [\boldsymbol A \times \boldsymbol B]_i は
[\boldsymbol A \times \boldsymbol B]_i = \sum_{j,k}\varepsilon_{ijk}A_jB_k
と書ける。ここで \Sigma の添字はそれぞれ1から3までの整数値を動くものとする。この規約は以下の文章にも適用する。
実際に、展開して確認すると、
\begin{align}\sum_{j,k}\varepsilon_{1jk}A_jB_k
&= \varepsilon_{123}A_2B_3 + \varepsilon_{132}A_3B_2 \\
&= A_2B_3 - A_3B_2 \\
&= [\boldsymbol A \times \boldsymbol B]_1
\end{align}
\begin{align}\sum_{j,k}\varepsilon_{2jk}A_jB_k
&= \varepsilon_{213}A_1B_3 + \varepsilon_{231}A_3B_1 \\
&= A_3B_1 - A_1B_3 \\
&= [\boldsymbol A \times \boldsymbol B]_2
\end{align}
\begin{align}\sum_{j,k}\varepsilon_{3jk}A_jB_k
&= \varepsilon_{312}A_1B_2 + \varepsilon_{321}A_2B_1 \\
&= A_1B_2 - A_2B_1 \\
&= [\boldsymbol A \times \boldsymbol B]_3
\end{align}
となる。上の式において、 \sum_{j,k}\varepsilon_{1jk}A_jB_k を展開すると9つの項が出てくるが、その内の7つの \varepsilon_{1jk} が0となるため、2つの項だけが残る。すなわち、j=2,j=3 に対応する項(対応する k は \{1,2,3\} のうち1でも j でもないもの)、 \varepsilon_{123},\varepsilon_{132} の項のみが残る。\varepsilon_{2jk},\varepsilon_{3jk} についても同様である。
定理
\varepsilon_{ijk} = |\boldsymbol e_i \,\boldsymbol e_j \, \boldsymbol e_k| = \boldsymbol e_i\cdot(\boldsymbol e_j \times \boldsymbol e_k) = \begin{vmatrix}
\delta_{1i} & \delta_{1j}& \delta_{1k}\\
\delta_{2i} & \delta_{2j}& \delta_{2k}\\
\delta_{3i} & \delta_{3j}& \delta_{3k}
\end{vmatrix} が成り立つ。
証明
|\boldsymbol e_1 \, \boldsymbol e_2 \, \boldsymbol e_3| = \begin{vmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{vmatrix} = 1 = \varepsilon_{123} である。
これと、行列式の性質より、|\boldsymbol e_i \,\boldsymbol e_j \, \boldsymbol e_k| は反対称であることから、\varepsilon_{ijk} = |\boldsymbol e_i \, \boldsymbol e_j\, \boldsymbol e_k| を得る。
|\boldsymbol e_i \,\boldsymbol e_j \, \boldsymbol e_k| = \boldsymbol e_i\cdot(\boldsymbol e_ j \times \boldsymbol e_k) については直接計算すればよい。
基本ベクトルの定義 \boldsymbol e_i = \begin{pmatrix} \delta_{1i} \\ \delta_{2i} \\ \delta_{3i} \end{pmatrix} を代入して、|\boldsymbol e_i \,\boldsymbol e_j \, \boldsymbol e_k| = \begin{vmatrix}
\delta_{1i} & \delta_{1j}& \delta_{1k}\\
\delta_{2i} & \delta_{2j}& \delta_{2k}\\
\delta_{3i} & \delta_{3j}& \delta_{3k}
\end{vmatrix} を得る。
定理
\varepsilon_{ijk}\varepsilon_{lmn} = \begin{vmatrix}
\delta_{il} & \delta_{im}& \delta_{in}\\
\delta_{jl} & \delta_{jm}& \delta_{jn}\\
\delta_{kl} & \delta_{km}& \delta_{kn}
\end{vmatrix}
= \delta_{il}\left( \delta_{jm}\delta_{kn} - \delta_{jn}\delta_{km} \right)
+ \delta_{im}\left( \delta_{jn}\delta_{kl} - \delta_{jl}\delta_{kn} \right)
+ \delta_{in}\left( \delta_{jl}\delta_{km} - \delta_{jm}\delta_{kl} \right) である。
証明
\varepsilon_{ijk} = |\boldsymbol e_i \,\boldsymbol e_j \, \boldsymbol e_k|,\, \varepsilon_{lmn} = |\boldsymbol e_l \,\boldsymbol e_m \, \boldsymbol e_n| より
\varepsilon_{ijk}\varepsilon_{lmn} = |\boldsymbol e_i \,\boldsymbol e_j \, \boldsymbol e_k||\boldsymbol e_l \,\boldsymbol e_m \, \boldsymbol e_n| = \begin{vmatrix}\boldsymbol e_i^T \\ \boldsymbol e_j^T \\ \boldsymbol e_k^T \end{vmatrix}|\boldsymbol e_l \, \boldsymbol e_m \, \boldsymbol e_n| = \begin{vmatrix}
\boldsymbol e_i^T\boldsymbol e_l & \boldsymbol e_i^T\boldsymbol e_m& \boldsymbol e_i^T\boldsymbol e_n\\
\boldsymbol e_j^T\boldsymbol e_l & \boldsymbol e_j^T\boldsymbol e_m& \boldsymbol e_j^T\boldsymbol e_n\\
\boldsymbol e_k^T\boldsymbol e_l & \boldsymbol e_k^T\boldsymbol e_m& \boldsymbol e_k^T\boldsymbol e_n
\end{vmatrix} = \begin{vmatrix}
\delta_{il} & \delta_{im}& \delta_{in}\\
\delta_{jl} & \delta_{jm}& \delta_{jn}\\
\delta_{kl} & \delta_{km}& \delta_{kn}
\end{vmatrix}.
また、 余因子展開をして、 \begin{vmatrix}
\delta_{il} & \delta_{im}& \delta_{in}\\
\delta_{jl} & \delta_{jm}& \delta_{jn}\\
\delta_{kl} & \delta_{km}& \delta_{kn}
\end{vmatrix}
= \delta_{il}\left( \delta_{jm}\delta_{kn} - \delta_{jn}\delta_{km} \right)
+ \delta_{im}\left( \delta_{jn}\delta_{kl} - \delta_{jl}\delta_{kn} \right)
+ \delta_{in}\left( \delta_{jl}\delta_{km} - \delta_{jm}\delta_{kl} \right) を得る。
定理
が成り立つ。ここでも \sum のそれぞれの添字は1,2,3を歩くという規約を採用している。
証明
\varepsilon_{ijk}\varepsilon_{ilm} = \begin{vmatrix}
1 & \delta_{il}& \delta_{im}\\
\delta_{ji} & \delta_{jl}& \delta_{jm}\\
\delta_{ki} & \delta_{kl}& \delta_{km}
\end{vmatrix} = (\delta_{jl}\delta_{km} - \delta_{jm}\delta_{kl}) - \delta_{il}(\delta_{ji}\delta_{km} - \delta_{jm}\delta_{ki}) + \delta_{im}(\delta_{ji}\delta_{kl} - \delta_{jl}\delta_{ki}) より
\begin{align}\sum_i \varepsilon_{ijk}\varepsilon_{ilm} &= \sum_i [(\delta_{jl}\delta_{km} - \delta_{jm}\delta_{kl}) - \delta_{il}(\delta_{ji}\delta_{km} - \delta_{jm}\delta_{ki}) + \delta_{im}(\delta_{ji}\delta_{kl} - \delta_{jl}\delta_{ki})] \\
&= 3(\delta_{jl}\delta_{km} - \delta_{jm}\delta_{kl}) - (\delta_{jl}\delta_{km} - \delta_{jm}\delta_{kl}) + (\delta_{jm}\delta_{kl} - \delta_{jl}\delta_{km}) \\
&= \delta_{jl}\delta_{km} - \delta_{jm}\delta_{kl} \end{align}
\sum_{i,j} \varepsilon_{ijk}\varepsilon_{ijl} = \sum_j \sum_i \varepsilon_{ijk}\varepsilon_{ijl} = \sum_j (\delta_{jj}\delta_{kl} - \delta_{jl}\delta_{kj}) = 3\delta_{kl} - \delta_{kl} = 2\delta_{kl}
\sum_{i,j,k} \varepsilon_{ijk}\varepsilon_{ijk} = \sum_{k} \sum_{i,j} \varepsilon_{ijk}\varepsilon_{ijk} = \sum_{k} 2\delta_{kk} = 6
定理
次の式が成り立つ。
= [(\boldsymbol A \times \boldsymbol B) \cdot \boldsymbol D] \boldsymbol C - [(\boldsymbol A \times \boldsymbol B) \cdot \boldsymbol C] \boldsymbol D
証明
スカラー三重積の証明
\begin{align}\boldsymbol A \cdot (\boldsymbol B \times \boldsymbol C) &= \sum_i A_i[\boldsymbol B \times \boldsymbol C]_i \\
&= \sum_{i,j,k}\varepsilon_{ijk}A_iB_jC_k. \\
\boldsymbol B \cdot (\boldsymbol C \times \boldsymbol A) &= \sum_jB_j[\boldsymbol C \times \boldsymbol A]_j\\
&= \sum_{i,j,k}B_j\varepsilon_{jki}C_kA_i \\
&= \sum_{i,j,k}\varepsilon_{ijk}A_iB_jC_k.\\
\boldsymbol C \cdot (\boldsymbol A \times \boldsymbol B) &= \sum_kC_k[\boldsymbol A \times \boldsymbol B]_k \\
&= \sum_{i,j,k}C_k\varepsilon_{kij}A_iB_j \\
&= \sum_{i,j,k} \varepsilon_{ijk}A_iB_jC_k.
\end{align}
ベクトル三重積の証明
\begin{align}
{[}\boldsymbol A \times (\boldsymbol B \times \boldsymbol C)]_i &= \sum_{j,k}\varepsilon_{ijk}A_j[\boldsymbol B \times \boldsymbol C]_k \\
&= \sum_{j,k,l,m}\varepsilon_{ijk}A_j\varepsilon_{klm}B_lC_m \\
&= -\sum_{j,k,l,m}\varepsilon_{kji}\varepsilon_{klm}A_jB_lC_m \\
&= -\sum_{j,l,m}(\delta_{jl}\delta_{im}-\delta_{jm}\delta_{il})A_jB_lC_m\\
&= \sum_{j,l,m}\delta_{jm}\delta_{il}A_jB_lC_m - \sum_{j,l,m}\delta_{jl}\delta_{im}A_jB_lC_m\\
&= \sum_jA_jB_iC_j - \sum_jA_jB_jC_i\\
&= (\boldsymbol A \cdot \boldsymbol C)B_i - (\boldsymbol A \cdot \boldsymbol B)C_i
\end{align}
スカラー四重積の証明
スカラー三重積及びベクトル三重積を使うと
(\boldsymbol A \times \boldsymbol B) \cdot (\boldsymbol C \times \boldsymbol D)
= \boldsymbol C \cdot [\boldsymbol D \times (\boldsymbol A \times \boldsymbol B)] = \boldsymbol C \cdot [(\boldsymbol D \cdot \boldsymbol B ) \boldsymbol A - (\boldsymbol D \cdot \boldsymbol A) \boldsymbol B]
= (\boldsymbol A \cdot \boldsymbol C)\boldsymbol B - (\boldsymbol A \cdot \boldsymbol B)\boldsymbol C.
ベクトル四重積の証明
ベクトル三重積よりほとんど自明である。
ヤコビ恒等式の証明
ベクトル三重積の公式を代入して計算するだけである。
上の表式を用いると、複雑な微分の計算を簡便に行なうことが出来る。
定理
\nabla \times (\nabla f) = 0
\nabla \cdot (\nabla \times \boldsymbol A)=0
が成り立つ。
証明
\begin{align}
{[\nabla \times (\nabla f)]}_i &= \sum_{j,k} \varepsilon_{ijk}\partial_j[\nabla f]_k \\
&= \sum_{j,k} \varepsilon_{ijk}\partial_j\partial_kf
\end{align}
ここで、\varepsilon_{ijk}\partial_i \partial_jf について、i>j の項は、 \varepsilon_{jik}\partial_j \partial_if = -\varepsilon_{ijk}\partial_i \partial_jf と打ち消し合う(\varepsilon_{ijk}\partial_i \partial_jf + \varepsilon_{jik}\partial_j \partial_if = 0 )。 i=j の項は \varepsilon_{ijk}\partial_i \partial_jf = \varepsilon_{iik}\partial_i \partial_if = 0 となるので、結局最後の式は 0 である。
すなわち、\nabla \times (\nabla f) = 0 を得る。
\begin{align}\nabla \cdot (\nabla \times \boldsymbol A) &= \sum_{i} \partial_i[\nabla \times \boldsymbol A]_i \\
&= \sum_{i,j,k} \partial_i \varepsilon_{ijk}\partial_jA_k \\
&= \sum_{i,j,k} \varepsilon_{ijk}\partial_i \partial_jA_k \\
\end{align}
ここで、\varepsilon_{ijk}\partial_i \partial_jA_k について、i>j の項は、 \varepsilon_{jik}\partial_j \partial_iA_k = -\varepsilon_{ijk}\partial_i \partial_jA_k と打ち消し合う(\varepsilon_{ijk}\partial_i \partial_jA_k + \varepsilon_{jik}\partial_j \partial_iA_k = 0 )。 i=j の項は \varepsilon_{ijk}\partial_i \partial_jA_k = \varepsilon_{iik}\partial_i \partial_iA_k = 0 となるので、結局最後の式は 0 である。
すなわち、\nabla \cdot (\nabla \times \boldsymbol A)=0 を得る。
定理
\nabla \cdot (\boldsymbol A \times \boldsymbol B ) =
(\nabla \times \boldsymbol A) \cdot \boldsymbol B - \boldsymbol A \cdot (\nabla \times \boldsymbol B)
\nabla \times ( \boldsymbol{A} \times \boldsymbol{B} ) = ( \boldsymbol{B} \cdot \nabla ) \boldsymbol{A} - ( \boldsymbol{A} \cdot \nabla ) \boldsymbol{B} + \boldsymbol{A} ( \nabla \cdot \boldsymbol{B} ) - \boldsymbol{B} ( \nabla \cdot \boldsymbol{A} )
\nabla(\boldsymbol A \cdot \boldsymbol B) = \boldsymbol A \times (\nabla \times B) + \boldsymbol B \times (\nabla \times \boldsymbol A) + (\boldsymbol A \cdot \nabla)\boldsymbol B + (\boldsymbol B \cdot \nabla)\boldsymbol A
が成り立つ。
証明
\begin{align}
\nabla \cdot (\boldsymbol A \times \boldsymbol B ) &= \sum_{i,j,k} \partial_i (\varepsilon_{ijk} A _j B _k) \\
&= \sum_{i,j,k}\varepsilon_{ijk}(\partial _i A _j) B _k + \sum_{i,j,k} \varepsilon_{ijk} A _j (\partial _i B _k)\\
&= (\nabla \times \boldsymbol A)\cdot \boldsymbol B - \boldsymbol A \cdot (\nabla \times \boldsymbol B) .
\end{align}
\begin{align}
{[\nabla \times ( \boldsymbol{A} \times \boldsymbol{B} )}]_i &= \sum_{j,k} \varepsilon_{ijk}\partial_j[ \boldsymbol{A} \times \boldsymbol{B}]_k \\
&= \sum_{j,k,l,m} \varepsilon_{ijk}\varepsilon_{klm}\partial_j(A_lB_m) \\
&= - \sum_{j,k,l,m} \varepsilon_{kji}\varepsilon_{klm}\partial_j(A_lB_m) \\
&= - \sum_{j,l,m} (\delta_{jl}\delta_{im} - \delta_{jm}\delta_{il})\partial_j(A_lB_m) \\
& = \sum_{j,l,m}\delta_{jm}\delta_{il}\partial_j(A_lB_m)-\sum_{j,l,m} \delta_{jl}\delta_{im}\partial_j(A_lB_m)\\
&= \sum_{j} \partial_j(A_iB_j) -\sum_j \partial_j(A_jB_i) \\
&= \sum_{j} B_j\partial_jA_i + \sum_{j} A_i\partial_jB_j - \sum_j B_i\partial_jA_j - \sum_j A_j\partial_jB_i \\
&= (\boldsymbol B \cdot \nabla)A_i + A_i(\nabla \cdot \boldsymbol B) - (\boldsymbol A \cdot \nabla)B_i - B_i(\nabla \cdot \boldsymbol A)
\end{align}
より、\nabla \times ( \boldsymbol{A} \times \boldsymbol{B} ) = ( \boldsymbol{B} \cdot \nabla ) \boldsymbol{A} - ( \boldsymbol{A} \cdot \nabla ) \boldsymbol{B} + \boldsymbol{A} ( \nabla \cdot \boldsymbol{B} ) - \boldsymbol{B} ( \nabla \cdot \boldsymbol{A} ) が成り立つ。
\begin{align}{[\nabla(\boldsymbol A \cdot \boldsymbol B)]}_i &= \sum_j \partial_i(A_jB_j)\\
&= \sum_j B_j\partial_iA_j + \sum_j A_j\partial_iB_j.\\
\end{align}
ここで、[\boldsymbol A \times(\nabla \times \boldsymbol B)]_i = \sum_j A_j \partial_iB_j - (\boldsymbol A \cdot \nabla) \boldsymbol B_i が成り立つのでこの式の導出に困ったらベクトル三重積の導出を参考すること。ただし、微分の扱いに注意すること。ベクトル三重積の導出の六行目までは、Bを∇に読み替えても成立するが、七行目の式変形は成立しない。なぜなら、偏微分とベクトルの成分を入れ替えて \partial_i C_j=C_j \partial_i とすることは当然不可能だからである。、これを第二項に代入する。第一項についても同様の式が成り立つため、これを代入すると結局、 \nabla(\boldsymbol A \cdot \boldsymbol B) = \boldsymbol A \times (\nabla \times B) + \boldsymbol B \times (\nabla \times \boldsymbol A) + (\boldsymbol A \cdot \nabla)\boldsymbol B + (\boldsymbol B \cdot \nabla)\boldsymbol A が得られる。
定理
\nabla \cdot(f\boldsymbol A )= \nabla f \cdot \boldsymbol A + f \nabla \cdot \boldsymbol A
\nabla \times(f\boldsymbol A) = \nabla f \times \boldsymbol A + f\nabla \times \boldsymbol A
が成り立つ。
証明
\begin{align}
\nabla \cdot (f \boldsymbol A) &= \sum_i\partial _i (fA _i)\\ &= \sum_i(\partial _i f ) A _i + \sum_if (\partial _i A _i)\\ &= \nabla f \cdot \boldsymbol A + f\nabla \cdot \boldsymbol A
\end{align}
\begin{align}
{[\nabla \times f \boldsymbol A]}_i &= \sum_{j,k} \varepsilon_{ijk}\partial_j(fA_k)\\
&= \sum_{j,k} \varepsilon_{ijk}\partial_jf \,A_k + \sum_{j,k} \varepsilon_{ijk}f\partial_j \,A_k \\
&= {[\nabla f \times \boldsymbol A]}_i + {[f\nabla \times \boldsymbol A]}_i
\end{align}
定理
\nabla \times (\nabla \times \boldsymbol{A} ) = \nabla (\nabla \cdot \boldsymbol{A} ) - \Delta \boldsymbol{A} が成り立つ。
証明
\begin{align} {[}\nabla \times (\nabla \times \boldsymbol{A}){]}_i &= \sum_{j,k}\varepsilon_{ijk}\partial_j[\nabla \times \boldsymbol A]_k \\
&= \sum_{j,k,l,m}\varepsilon_{ijk}\partial_j\varepsilon_{klm}\partial_l{ A}_m \\
&= \sum_{j,k,l,m}\varepsilon_{kij}\varepsilon_{klm}\partial_j\partial_lA_m \\
&= \sum_{j,l,m}(\delta_{il}\delta_{jm} - \delta_{im}\delta_{jl})\partial_j\partial_lA_m \\
&= \sum_{j,l,m}\delta_{il}\delta_{jm}\partial_j\partial_lA_m -\sum_{j,l,m}\delta_{im}\delta_{jl}\partial_j\partial_lA_m \\
&= \sum_{j}\partial_i\partial_jA_j - \sum_{j}\partial_j\partial_jA_i
\end{align}
それぞれの成分について展開すると
{[}\nabla \times (\nabla \times \boldsymbol{A}){]}_1 = \partial_1(\partial_1A_1+\partial_2A_2+\partial_3A_3) - (\partial_1^2+\partial_2^2+\partial_3^2)A_1
{[}\nabla \times (\nabla \times \boldsymbol{A}){]}_2 = \partial_2(\partial_1A_1+\partial_2A_2+\partial_3A_3) - (\partial_1^2+\partial_2^2+\partial_3^2)A_2
{[}\nabla \times (\nabla \times \boldsymbol{A}){]}_3 = \partial_3(\partial_1A_1+\partial_2A_2+\partial_3A_3) - (\partial_1^2+\partial_2^2+\partial_3^2)A_3
である。これは \nabla \times (\nabla \times \boldsymbol{A} ) = \nabla (\nabla \cdot \boldsymbol{A} ) - \Delta \boldsymbol{A} であることを意味する。
これらの計算は、電磁気学等で頻繁に用いられるので、よく練習しておかねばならない。
定理
位置ベクトル
\boldsymbol r
について
r = |\boldsymbol r| =\sqrt{x^2+y^2 + z^2}
とすると、
\nabla r^n = n r^{n-2}{\boldsymbol r}
である。
証明
\frac{\partial}{\partial x}r^n = nr^{n-1}\frac{\partial}{\partial x}\sqrt{x^2 + y^2 + z^2} = nr^{n-1} \frac x r = nr^{n-2}x
y,z
についても同様である。
すなわち、
\nabla r^n = \begin{pmatrix} nr^{n-2}x \\nr^{n-2}y \\nr^{n-2}z\end{pmatrix} = nr^{n-2}\boldsymbol r.
ここでは、極座標での勾配、発散、ラプラシアンを求める。
極座標では、位置ベクトルは \boldsymbol r = \begin{pmatrix} x\\ y\\ z \end{pmatrix} = \begin{pmatrix} r\sin\theta\cos\varphi\\ r\sin\theta\sin\varphi\\ r\cos\theta \end{pmatrix}
{\left|\frac{\partial \boldsymbol r}{\partial r}\right|} = \begin{pmatrix}\sin\theta\cos\varphi\\ \sin\theta\sin\varphi\\ \cos\theta\end{pmatrix}
,\boldsymbol e_\theta
{\left|\frac{\partial \boldsymbol r}{\partial \theta}\right|}
= \frac 1 r \begin{pmatrix}r\cos\theta\cos\varphi\\ r\cos\theta\sin\varphi\\ -r\sin\theta\end{pmatrix}
=\begin{pmatrix}\cos\theta\cos\varphi\\ \cos\theta\sin\varphi\\ -\sin\theta\end{pmatrix}
,\boldsymbol e_\varphi
{\left|\frac{\partial \boldsymbol r}{\partial \varphi}\right|}
= \frac{1}{r\sin\theta}\begin{pmatrix}-r\sin\theta\sin\varphi\\ r\sin\theta\cos\varphi\\ 0 \end{pmatrix}
=\begin{pmatrix}-\sin\varphi\\ \cos\varphi\\ 0 \end{pmatrix}
である。
微小変位ベクトル d\boldsymbol r = dx\boldsymbol e_x + dy\boldsymbol e_y + dz\boldsymbol e_z
は極座標では、
\begin{align}d\boldsymbol r &= \frac{\partial \boldsymbol r}{\partial r}dr + \frac{\partial \boldsymbol r}{\partial \theta}d\theta + \frac{\partial \boldsymbol r}{\partial \varphi}d\varphi\\
&= \left|\frac{\partial \boldsymbol r}{\partial r}\right|\boldsymbol e_r dr +\left|\frac{\partial \boldsymbol r}{\partial \theta}\right|\boldsymbol e_\theta d\theta + \left|\frac{\partial \boldsymbol r}{\partial \varphi}\right|\boldsymbol e_\varphi d\varphi\\
&= \boldsymbol e_r dr + r\boldsymbol e_\theta d\theta + r\sin\theta\boldsymbol e_\varphi d\varphi
\end{align}
と書ける。
関数 f
の全微分 df
は df = \frac{df}{dx}dx + \frac{df}{dy}dy + \frac{df}{dz}dz = \nabla f \cdot d\boldsymbol r
となる。
極座標での発散を \nabla f = \nabla_r f \, \boldsymbol e_r + \nabla_\theta f \, \boldsymbol e_\theta + \nabla_\varphi f \, \boldsymbol e_\varphi
とすると、\begin{align}df &= \nabla f \cdot d\boldsymbol r \\
&= (\nabla_r f \, \boldsymbol e_r + \nabla_\theta f \, \boldsymbol e_\theta + \nabla_\varphi f \, \boldsymbol e_\varphi)\cdot (\boldsymbol e_r dr + r\boldsymbol e_\theta d\theta + r\sin\theta\boldsymbol e_\varphi d\varphi)\\
&=\nabla_r f\, dr + r\nabla_\theta f \, d\theta + r\sin\theta\nabla_\varphi f \, d\varphi
\end{align}
である。これと極座標での全微分 df = \frac{\partial f}{\partial r}dr + \frac{\partial f}{\partial \theta}d\theta + \frac{\partial f}{\partial \varphi}d\varphi
と比較すると、
\nabla_r f = \frac{\partial f}{\partial r},\nabla_\theta f = \frac{1}{r}\frac{\partial f}{\partial \theta},\nabla_\varphi f = \frac{1}{r\sin\theta}\frac{\partial f}{\partial \varphi}{}
を得る。
すなわち、極座標での発散は \nabla f =\frac{\partial f}{\partial r} + \frac{1}{r}\frac{\partial f}{\partial \theta} + \frac{1}{r\sin\theta}\frac{\partial f}{\partial \varphi}{}
である。
基底ベクトルの微分は、
\frac{\partial \boldsymbol e_r}{\partial r} = 0,\frac{\partial \boldsymbol e_r}{\partial \theta} = \boldsymbol e_\theta,\frac{\partial \boldsymbol e_r}{\partial \varphi} = \sin\theta \boldsymbol e_\varphi
\frac{\partial \boldsymbol e_\theta}{\partial r} = 0,\frac{\partial \boldsymbol e_\theta}{\partial \theta} = -\boldsymbol e_r,\frac{\partial \boldsymbol e_\theta}{\partial \varphi} = \cos\theta\boldsymbol e_\varphi
\frac{\partial \boldsymbol e_\varphi}{\partial r} = 0,\frac{\partial \boldsymbol e_\varphi}{\partial \theta} = 0,\frac{\partial \boldsymbol e_\varphi}{\partial \varphi} = -\cos\theta\boldsymbol e_r - \sin\theta \boldsymbol e_\theta
であることを使って極座標でのベクトル \boldsymbol A
の発散を計算すると、
\begin{align}\nabla \cdot A
&= \left(\boldsymbol e_r\frac{\partial f}{\partial r} + \boldsymbol e_\theta \frac{1}{r}\frac{\partial }{\partial \theta} + \boldsymbol e_\varphi \frac{1}{r\sin\theta}\frac{\partial f}{\partial \varphi}\right)\cdot (A_r\boldsymbol e_r + A_\theta \boldsymbol e_\theta + A_\varphi \boldsymbol e_\varphi)\\
&= \boldsymbol e_r \cdot \left(\frac{\partial A_r}{\partial r}\boldsymbol e_r\right) + \frac 1 r \boldsymbol e_\theta \cdot \left( \frac{\partial A_\theta}{\partial \theta}\boldsymbol e_\theta + A_r\boldsymbol e_\theta\right) + \frac{1}{r\sin\theta}\boldsymbol e_\varphi \cdot \left( \frac{\partial A_\varphi}{\partial \varphi}\boldsymbol e_\varphi + A_r\sin\theta \boldsymbol e_\varphi + A_\theta\cos\theta\boldsymbol e_\varphi\right)\\
&= \frac{1}{r^2}\frac{\partial (r^2 A_r)}{\partial r} + \frac{1}{r\sin\theta}\frac{\partial (\sin\theta A_\theta)}{\partial \theta} + \frac{1}{r\sin\theta}\frac{\partial A_\varphi}{\partial \varphi}
\end{align}
となる。
また、ラプラシアンに極座標での勾配と発散を代入すると、
\Delta f = \nabla \cdot \nabla f =\frac{1}{r^2}\frac{\partial }{\partial r}\left(r^2 \frac{\partial f}{\partial r}\right) + \frac{1}{r^2\sin\theta}\frac{\partial }{\partial \theta}\left(\sin\theta\frac{\partial f}{\partial \theta}\right) + \frac{1}{r^2\sin^2\theta}\frac{\partial^2 f}{\partial \varphi^2}
となり、ラプラシアンの極座標表示が得られた。
物理の計算においては、テンソルと呼ばれる量が
頻繁に用いられる。これは3次元における電磁気学の計算や、
古典力学における慣性モーメントなどで用いられるが、
特殊相対論、一般相対論においても用いられる。
ただし、特に一般相対論においては、計量テンソルと呼ばれる
特殊なテンソルが導入されるため、計算が非常に複雑になる。
ここでは、主に3次元のテンソル計算を扱うが、
特殊相対論における計算も少し扱う。
まずは、テンソルを定義する。
あるn次元のベクトルを考える。
このベクトルに対して、一般にあるベクトルからそれと同じ
次元のベクトルに変換するような線形変換を考えることが出来る。
この変換は、そのベクトルを同じ次元のベクトルに変換することから、
n*nの行列で書けることが分かる。
さて、次にこれらのベクトルのいくつかの(m個とする。)直積を取って、
mn個の要素を含む列ベクトルを作ることを考える。
直積の取り方については、物理数学Iを参照。
V \times V \times \cdots \times V
この操作によってできたmnベクトルは、上の行列によって表わされる
n行のベクトルから出来たm次のテンソルの一種となっている。
ただし、一般のテンソルはもう少し複雑で、
既に上で得たベクトルとのつながりを忘れてしまったmn次元のベクトルが
上と同じ様な変換性を持つとき、これを上のベクトルに対する
m次のテンソルと呼ぶ。
ここでは、さらにこれらのテンソルが従う変換の行列を
構成することを考える。
ここで、先ほど定めたmn行のベクトルの成分のうち、直積を取られる前は別の
ベクトルだった部分のそれぞれが、直積を取られる前と同じように変換するような
mn*mn次の変換行列を作りたい。
このためには、先ほど定めたn*nの行列による変換のm回の直積を取って、
mn*mnの行列を作ればよい。
このとき行列の直積の性質
(A _1 \times B _1) \cdot (A _2 \times B _2 ) =
A _1 A _2 \times B _1 B _2
から、
この行列が先ほどの性質を満たすことが分かる。
ここで、これらの行列やベクトルは添字をうまくつけることによって
書き表すことが出来る。
先ほど述べたうち、元々のベクトルを
A^\mu
と書く。
次に、元々のベクトルを変換する行列を
\Lambda ^{\mu\nu}
と書くと、この行列により変換された後のベクトルは、
\Sigma _{\nu = 1}^{n} \Lambda ^{\mu\nu} A^\nu
で表わされる。
ここで、行列を添字を用いて計算する方法を使った。
ただし、物理の計算においては、
"同じ式の中に同じ添字が2回出て来たとき、この2つの添字を
足し合わせる"という規約を用いることが多い。
これをEinsteinの規約と呼び、一般相対論でEinsteinが用いてから
よく使われるようになった。
この規約を用いると、上の式は簡単に、
\Lambda ^{\mu\nu} A^\nu
と書かれる。以下の計算では、常にこの規約を用い、
この規約が適用されないところでは、注意書きを行なうこととする。
さらに、元々のベクトルの直積は、
A^\mu A^\nu
となる。
ただし、ここでは、簡単にするためm=2と定めた。
これらを変換するmn*mn行列は
\Lambda ^{\mu\rho} \Lambda ^{\nu\sigma}
となる。
また、これらの行列によって変換されたベクトルは、
\Lambda ^{\mu\rho} \Lambda ^{\nu\sigma} A^\rho A^\sigma
で表わされる。
これらの変換則から一般的なテンソルを構成することが出来る。
例えば、ここでもm =2と定める。上の議論からこの量は
2つの添字を用いて、
T^{\mu\nu}
と書くことが出来、この量が従う変換則は、
\Lambda ^{\mu\rho} \Lambda ^{\nu\sigma}
T^{\rho\sigma}
となることがわかる。この量をある変換\Lambda に対する、
2次のテンソルと呼ぶ。
ここでは、テンソルの代数を定義した。このことを用いて、
ここからはより複雑な微分を見て行く。
多変数関数の積分は1変数の場合の拡張によって定義される。
特に、いくつかの計算は物理的な意味が明確であるので
物理数学においても扱われることが多い。
ここで直交座標系を用いた場合について、
ある定理を導出する。
この定理は、ベクトルの発散という量の物理的意味を
与えてくれる点で重要である。
\iiint _V dxdydz \textrm{div} \vec A = \iint d\vec s \vec A
が成り立つ。
ここで、左辺の体積積分はある領域について行なわれ、
右辺の表面積分は、その領域を囲む面積全体に対して
行なわれる。
この定理をガウスの定理と呼ぶ。
ガウスは19世紀の非常に有名な数学者の名前である。
導出に移る前に、この定理の意味を述べる。
まずは右辺に注目する。右辺の被積分関数
d\vec s \vec A
は、ある点での面積要素に垂直な
\vec A
の値を表わしている。これは例えば、
\vec A
が、流体力学でいう流体の流れる速度を表わすベクトルだったとするなら、
その流れのうちで今定めた面積要素から流れだす流量を表わしている。
この量を領域Vを囲む表面全体で足し合わせることから、この量は
領域Vから流れ出す流体の流量の和に等しいことが分かる。
ここで、領域Vの中に流体がわきだして来るような場所が合ったとすると、このとき
領域Vから流れ出す流量は、有限になると考えられる。
このためには、左辺で
\textrm{div} \vec A
が流体のわきだしの回りで有限になっていなければならない。
これらのことからベクトルの発散は、
\textrm{div} \vec A
の意味は、ベクトルAのわきだしに対応していることが分かる。
発散という名前は、ベクトルAがどこからか現われて、回りに広がって行く
様子から来ている。
ここからは、この定理の導出に移る。ただし、ここでの導出は直観的なものであり、
局限移行等については数学的に厳密なものではないことを注意しておく。
まず、ある領域Vを非常に小さい立方体の領域v _iに分割する。
領域Vがどんな形であっても、このことは常に可能だと期待される。
ここで、ある互いに接し合う2つの小さい領域v _1とv _2について
この定理が示されたとする。
このとき、領域v _1と領域がv _2接している面を考える。
それぞれの領域からの寄与は、その点でのベクトルの大きさと
その面積要素の大きさが同じであることから同じであると考えられ、
また、それらは互いに接しているので、面積分の性質から見て、
それらの寄与は互いに異なった符合を持っている。
ここで、今考えている領域2つを張りつけて新しい領域
v _3を作り、この領域について元の式の左辺を計算すると、
その量は、
\iiint _{v _1+v _2} dxdydz \textrm{div} \vec A
となる。ここで、右辺についても互いに重なった部分の寄与が打ち消し合うことから、
\iint _{\partial v _3} d\vec s \vec A
のようにv _3の回りについて元の式の表式が成り立っている。
ここでv _3の囲む領域の表面として
\partial v _3
という表式を導入した。実際にはこの表式は数学の本から来ており、
物理の本でも割合よく用いられる。
結局、小さい立方体についてこの定理が示されれば、元の領域についても
この定理が正しいことが分かった。
次にこのことが実際小さい立方体について正しいことを見る。
立方体の辺の長さを\epsilonとする。
このとき、元の式について
\begin{matrix}
\textrm{lhs} = \int _v \textrm{div} \vec A\\
= \epsilon^3 \textrm{div} \vec A
\end{matrix}
となる。
更に、右辺については
\begin{matrix}
\textrm{rhs} = A _x(x+\epsilon,y+\epsilon /2,z+\epsilon /2) \epsilon^2 - A _x(x,y+\epsilon /2,z+\epsilon /2) \epsilon^2\\
+A _y(x+\epsilon/2, y+\epsilon,z+\epsilon/2) \epsilon^2 - A _y(x+\epsilon /2,y+\epsilon,z+\epsilon/2) \epsilon^2\\
+A _z(x+\epsilon/2, y+\epsilon/2,z+\epsilon) \epsilon^2 - A _z(x+\epsilon/2, y+\epsilon/2,z) \epsilon^2
\end{matrix}
のような表式が得られる。この式は、それぞれの面に対する面積分をあからさまに
積分したものである。ここで、特にそれぞれの面の中心を通るように
積分の点を選んでいる。これは、局限移行をうまく行なうためだが、
もう少し違った点を選んでも結果を得ることは出来る。
次に、上の表式を\epsilonについてテイラー展開する。このとき、
))
))
))
が得られる。
これをまとめると、
= \epsilon^3 \textrm{div} \vec A
が得られるが、これはちょうど左辺からの式と一致している。
よって、小さい立方体についてはこの定理は正しい。
次にベクトルの回転の物理的意味を特徴づける定理を扱う。
まずは定理を述べる。
\iint dS \textrm{rot} \vec A = \int d\vec l \vec A
が成り立つ。
ここで、この式の左辺はある面積Sについて積分し、
この式の右辺は、その面積の外周についての線積分を行なう。
ここでも、ある面積Sの外周のことを、
\partial S
と書くことがある。
この定理をストークスの定理と呼ぶ。
例えば、
\vec A
を流体の速度ベクトルとしてみる。このとき、速度ベクトルをある面積の
外周について積分したとき、その値はその面積内の速度の回転の積分に
等しい。このことは、速度ベクトルの回転が、これらの流体の渦のような
ものに対応していることを示している。
実際、流体力学では
\textrm{rot} \vec u
のことを渦度と呼び、流体中の渦の様子を示す重要な量となっている。
この様に、ベクトルの回転はそのベクトルについてある閉じた経路について
積分したものに対応している。
\textrm{rot} \vec A
が全ての点で成り立つ場合、全ての閉経路に対する線積分は0に等しくなる。
これは、流体でいうと渦無しの流れに対応している。
また、この結果は複素解析の線積分の定理の1つに対応しており、その面からも
重要である。複素解析については、物理数学IIで扱う予定である。
まず、ある面積Sを辺の長さが\epsilonに等しい小さな正方形に分ける。
正方形の大きさが十分小さいとき、このことは常に可能であると期待できる。
ここで、互いに接している小さい正方形についてそれぞれの辺からの線積分の寄与は、
大きさが等しく、符合が反対であることが分かる。このことは、線積分の
経路を反時計回りに取るというきまりを守っていると、その辺で接するためには
積分の向きが逆になっていなくてはいけないということによる。
ここで、今挙げた小さな2つの正方形を張り付けた長方形について
同じ計算を行なう。このとき、互いに張りついた1つの辺からの寄与は打ち消し
あうので、同じ計算が張りつけた後の長方形についても成り立つ。
このことを繰りかえせば、小さな正方形についてこの定理が成り立ったとき、
元々の領域についてもこの定理が成り立つと期待できる。
さて、ここで、辺の長さが\epsilonに等しい正方形についてこの定理が
成り立っていることを示す。
これらの正方形の各辺に平行になるように、x,y軸を取って
\iint dS \textrm{rot} \vec A = \int d\vec l \vec A
の左辺を計算すると、
(\textrm{lhs}) = \epsilon ^2 \textrm{rot} \vec A (x+ \epsilon/2,y+\epsilon/2)
が成り立つ。
次に右辺について、
\begin{matrix}
(\textrm{rhs}) =\epsilon \{A _x(x+\epsilon/2,y ) - A _x(x+\epsilon/2,y+\epsilon) \}\\
+ \epsilon \{A _y(x+\epsilon ,y+\epsilon/2 ) - A _y(x,y+\epsilon/2) \} \\
\} \\
= \epsilon^2 \textrm{rot } \vec A
\end{matrix}
が得られるが、これは右辺の表式と等しい。
よって、小さい正方形についてこの定理は示された。
また、以前の議論からこのとき元の領域についてもこの定理は正しいことが
分かっている。よって、全ての領域について、この定理は正しいことが
示された。
直交座標系でないときにも
grad,div,rotを計算することが出来る。
ここではまず、座標系の定義を行なうことから始める。
また、上の議論からこのことは全ての領域Vに対してもこの定理が正しいことを
示している。
この定理は電磁気学で頻繁に用いられる重要な定理である。
---- |
2,842 | （虚偽表示）
第94条
前項の規定による意思表示の無効は、善意の第三者に対抗することができない。
相手方と通謀してした虚偽の意思表示は「119条に規定されるとおり、「効力を生じない」し追認もできない。
法律行為の無効の立証責任は意思表示をした者が負う。
通謀虚偽表示の無効は善意の第三者には対抗できないと規定する。したがって、94条1項の意思表示は、当事者間及び第三者との関係では無効だが、善意の第三者との関係では有効であるとみなされることになる。
たとえば、AとBが通謀してA所有の不動産をBに売却し、所有権移転登記も済ませたとする。この売買契約はAB間では無効である（94条1項）。しかし、Bが事情を知らないCにこの不動産をさらに転売した場合、Aは、AB間の売買契約が無効であることをCに対して主張できない。これをCの側から見ると、AB間では無効であるはずの売買契約が、善意のCにとっては有効であるとみなされ、A→B→Cという物権変動が生じることになる。（AもBも、Cに対してはA→Bの物権変動の無効を主張できない、というのが、94条2項の意味）
「第三者」の意味を文理解釈すると、「当事者以外のすべての者」であるということになる。しかし、94条2項の趣旨が真の所有者の犠牲において虚偽の外観を信頼した者を保護する点にある以上、それではあまりに広すぎることになる。よって「第三者」の範囲は限定的に解釈されている。
典型的には、上記の例でいうCのように、仮装売買の目的物の転得者が「第三者」であるとされる。
悪意の第三者からの善意の転得者は、「善意の第三者」に当たるとされる（最高裁判所第二小法廷判決 昭和45年07月24日）。たとえば、AB間に虚偽の売買があり、Bから目的物を譲渡されたCが悪意だったとすれば、Cは保護されないが、Cからさらに目的物を譲渡されたDは、善意であれば保護される。
代理行為で代理人と相手方での通謀虚偽表示の場合は、本人は善意であっても「第三者」の地位を取得しない（101条1項）。
「善意」とは、消極的不知を意味する語であるが、ここでは虚偽表示を知らないことである。「善意」の立証責任は虚偽表示による無効を争う者がおう。
しかし、有力説は無過失を要求する。この説は、信頼した外観の存在を第三者が証明すれば無過失が推定される（事実上の推定）とする。
94条2項は、当事者間に虚偽の意思表示があったことを前提とする。しかし、判例によって、当事者間に虚偽の意思表示がなかった場合にもこの条文を類推適用する判例法理が生まれている。
94条2項の類推適用が必要になる理由は、不動産には動産と異なり即時取得（192条）の規定がないからである。すなわち、動産には取引の安全を確保するため、192条によって、権利の外観を信頼した者には、取引行為によって所有権を有効に取得させるという規定が置かれている。これと同様の保護を不動産の場合にも与える必要から、94条2項を類推適用する法理が生まれた。
ただし、94条2項の類推適用で保護される「第三者」と認められるためには、通謀虚偽表示の第三者の場合とは異なる要件が必要とされるのが一般的であり、またその要件も学説上対立がある。
善意・悪意：第三者は「善意」であることを必要とする説が一般的である。
過失の有無：第三者は「無過失」であることを要するとする説と、過失があっても保護されるとする説がある。「無過失」を主張する説は192条の要件とのバランスを根拠とする。
登記の有無：第三者は登記を要するとする説と、ACの関係は前主・後主の関係だから必要ないとする説がある。
仮装譲渡人の主観的要件：意思表示がないことを前提にしているが、虚偽の意思表示に等しい何らかの帰責性を要求する説が一般的である。
未登記の建物の所有者甲が、乙にその所有権を移転する意思がないのに、乙の承諾を得て、右建物について乙名義の所有権保存登記を経由したときは、民法第94条第2項を類推適用して、甲は、乙が右建物の所有権を取得しなかつたことをもつて、善意の第三者に対抗することができないものと解すべきである。
甲が乙に不動産を仮装譲渡し、丙が善意で乙からこれを譲りうけた場合であつても、丙が所有権取得登記をする前に、甲からの譲受人丁が乙を債務者とし該不動産について処分禁止の仮処分登記を経ていたときは、丙はその所有権取得を丁に対抗することができない。
甲が乙の承諾のもとに乙名義で不動産を競落し、丙が善意で乙からこれを譲り受けた場合においては、甲は、丙に対して、登記の欠缺を主張して右不動産の所有権の取得を否定することはできない。
不動産の所有者甲が、乙にその所有権を移転する意思がないのに、乙名義を使用して他からの所有権移転登記を受けたときは、右登記について乙の承諾がない場合においても、民法94条2項を類推適用して、甲は、乙が不動産の所有権を取得しなかつたことをもつて、善意の第三者に対抗することができないものと解すべきである。
民法94条2項にいう第三者とは、虚偽表示の当事者またはその一般承継人以外の者であつて、その表示の目的につき法律上利害関係を有するに至つた者をいい、甲乙間における虚偽表示の相手方乙との間で右表示の目的につき直接取引関係に立つた丙が悪意の場合でも、丙からの転得者丁が善意であるときは、丁は同条項にいう善意の第三者にあたる。
不動産の所有者甲が、その不知の間に甲から乙に対する不実の所有権移転登記の経由されたことを知りながら、経費の都合や、のちに乙と結婚して同居するようになつた関係から、抹消登記手続を四年余にわたつて見送り、その間に甲において他から金融を受けた際にもその債務を担保するため乙所有名義のまま右不動産に対する根抵当権設定登記が経由されたような事情がある場合には、民法94条2項を類推適用し、甲は、不動産の所有権が乙に移転していないことをもつて、その後にこれを乙から買受けた善意の第三者丙に対抗することができないものと解すべきである。
未登記建物の所有者は、その建物が固定資産課税台帳上他人の所有名義で登録されていることを知りながら、これを明示または黙示に承認していた場合には、民法94条2項の類推適用により、右名義人が所有権を有しないことを善意の第三者に対抗することができない。
民法94条にいう第三者とは、虚偽表示の当事者又はその一般承継人以外の者であつて、その表示の目的につき法律上利害関係を有するに至つた者をいい、甲乙間における虚偽表示の相手方乙との間で右表示の目的につき直接取引関係に立つた丙が悪意であつても、丙からの転得者丁が善意であるときは、丁は同条項にいう善意の第三者にあたる。
民法第94条2項所定の第三者の善意の存否は、同条項の適用の対象となるべき法律関係ごとに当該法律関係につき第三者が利害関係を有するに至つた時期を基準として決すべきである。
不動産の所有者であるＸから当該不動産の賃貸に係る事務や他の土地の所有権移転登記手続を任せられていた甲が，Ｘから交付を受けた当該不動産の登記済証，印鑑登録証明書等を利用して当該不動産につき甲への不実の所有権移転登記を了した場合において，Ｘが，合理的な理由なく上記登記済証を数か月間にわたって甲に預けたままにし，甲の言うままに上記印鑑登録証明書を交付した上，甲がＸの面前で登記申請書にＸの実印を押捺したのにその内容を確認したり使途を問いただしたりすることなく漫然とこれを見ていたなど判示の事情の下では，Ｘには，不実の所有権移転登記がされたことについて自らこれに積極的に関与した場合やこれを知りながらあえて放置した場合と同視し得るほど重い帰責性があり，Ｘは，民法94条2項，110条の類推適用により，甲から当該不動産を買い受けた善意無過失のＹに対し，甲が当該不動産の所有権を取得していないことを主張することができない。
----
{{前後
|民法
|第1編 総則
第5章 法律行為
第2節意思表示
|民法第93条（心裡留保）
|民法第95条（錯誤） |
2,843 | 本項は、弘前大学の入学試験対策に関する事項である。
弘前大学は青森県にある総合大学である。北海道からの受験生も多く集まる。医学部医学科は難易度が非常に高いので医学部受験生はしっかり勉強すること。
6割5分以上の得点が必須。
医学部医学科に関しては8割5分以上は欲しい。
地方大学に特有の「クセ」があり、意外に難しい問題が出題されるので、赤本で過去問の傾向をしっかりつかんでおきたい。
大学への数学にも出題されるような問題も出るため、油断大敵である。
かといって難問奇問ではなく、基礎を完全に基盤にしておけば、ちょっと頭をひねれば解ける問題であり、日頃の練習が合格へと繋がる。
ただし、医学部医学科に関しては別格であり、センターを含めて非常に高い得点での争いとなる。
このため、特別なテクニックが必要なわけではないが、基本問題や標準問題でミスなく確実に得点することが求められる。 |
2,844 | 法学＞民事法＞商法＞会社法＞コンメンタール会社法＞第2編 株式会社 (コンメンタール会社法)＞第2編第4章 機関 (コンメンタール会社法)
（忠実義務）
第355条
取締役は、法令及び定款並びに株主総会の決議を遵守し、株式会社のため忠実にその職務を行わなければならない。
株式会社の取締役の、会社に対して負う義務についての規定である。
法令等の遵守義務（コンプライアンス等）、忠実義務につき規定する。
忠実義務とは何かについては、商法旧会社編における議論がそのまま引き継がれる。 |
2,845 | 法学＞コンメンタール＞コンメンタール刑事訴訟法=コンメンタール刑事訴訟法/改訂
（開示方法等の指定）
第316条の25
裁判所は、証拠の開示の必要性の程度並びに証拠の開示によって生じるおそれのある弊害の内容及び程度その他の事情を考慮して、必要と認めるときは、第316条の14第1項（第316条の21第4項において準用する場合を含む。）の規定による開示をすべき証拠については検察官の請求により、第316条の18（第316条の22第4項において準用する場合を含む。）の規定による開示をすべき証拠については被告人又は弁護人の請求により、決定で、当該証拠の開示の時期若しくは方法を指定し、又は条件を付することができる。
裁判所は、前項の請求について決定をするときは、相手方の意見を聴かなければならない。
第1項の請求についてした決定に対しては、即時抗告をすることができる。
2016年改正により、第316条の14の項数改正に伴い以下のとおり改正。
----
{{前後
|刑事訴訟法
|第2編 第一審
第3章 公判
第2節 争点及び証拠の整理手続
第1款 公判前整理手続
第3目 証拠開示に関する裁定
|第316条の24（争点及び証拠の整理結果の確認）
|第316条の26（開示命令）
316の25
316の25 |
2,846 | （汽車転覆等及び同致死）
第126条
現に人がいる汽車又は電車を転覆させ、又は破壊した者は、無期又は3年以上の拘禁刑に処する。
現に人がいる艦船を転覆させ、沈没させ、又は破壊した者も、前項と同様とする。
前二項の罪を犯し、よって人を死亡させた者は、死刑又は無期拘禁刑に処する。
2022年、以下のとおり改正（施行日2025年6月1日）。
第1項及び第2項の罪の未遂は、罰する。
汽車または電車の「破壊」とは、汽車または電車の実質を害してその交通機関としての機能の全部または一部を失わせる程度の損壊をいう。
爆発物の爆発により、横須賀線電車5号車両の屋根、天井に張られた鉄板および合金板4枚、座席7個、網棚、窓ガラス4枚のほか、車体付属品8点が損壊され、爆発物の破片等が床上いつぱいに散乱して、乗客を乗せて安全な運転を続けることができないような状態になつたときは、刑法126条1項にいう電車の「破壊」にあたる。
人の現在する漁船（267総トン、鋼質船）の船底部約3分の1を厳寒の千島列島ウルツプ島海岸の砂利原に乗り上げさせて坐礁させたうえ、同船機関室内の海水取入れパイプのバルブを開放して同室内に約19.4トンの海水を取り入れ、自力離礁を不可能ならしめて、同船の航行能力を失わせた等の事実関係のもとにおいては、船体自体に破損が生じていなくても、右所為は刑法126条2項にいう艦船の「破壊」にあたる。
本件覆没行為の当時船舶法第1条第3号の要件を備えていたものと認められる本件船舶は、刑法第1条第2項にいう「日本船舶」にあたる。
公海上で、日本船舶の乗組員が同船舶の船底弁を引き抜き海水を船内に浸入させて人の現在する船舶を覆没させた行為については、刑法第1条第2項により同法第126条第2項の規定の適用がある。
----
{{前後
|刑法
|第2編 罪
第11章 往来を妨害する罪
|刑法第125条（往来危険）
|刑法第127条（往来危険による汽車転覆等） |
2,847 | 前）（次）
（産業医の選任）
第13条
法第13条第1項の規定による産業医の選任は、次に定めるところにより行なわなければならない。
産業医を選任すべき事由が発生した日から14日以内に選任すること。
常時1,000人以上の労働者を使用する事業場又は次に掲げる業務に常時500人以上の労働者を従事させる事業場にあっては、その事業場に専属の者を選任すること。
常時3,000人をこえる労働者を使用する事業場にあっては、2人以上の産業医を選任すること。
第8条の規定は、産業医について準用する。この場合において、同条中「前条第1項」とあるのは、「第13条第1項」と読み替えるものとする。
第1項第1号の「選任すべき事由が発生した日」とは、当該事業場の規模が、政令で定める規模に達した日、産業医に欠員が生じた日を指すものであること。
第1項第2号は、専属の産業医の選任について規定したものであるが、専属の産業医の選任を要しない事業場においても比較的多数の労働者の勤務するところについては、労働者の健康管理に資するため、衛生管理者の免許を有する保健婦の活用等を行なうよう指導すること。
第1項第2号および第3号は、専属の産業医を選任すべき事業場および数を規定したものであるが、その基準は旧規則第11条および第13条と同様なものであること。
第1項第3号は、大規模事業場における産業医の選任を規定したものであるが、たとえば常時使用する労働者数が3,000人を大巾にこえるごとき場合などには、衛生管理が円滑に行なわれるよう産業医の増員、衛生管理者の免許を有する保健婦の活用等について必要に応じ指導すること。
第2項において、産業医の選任手続きが規定されているが、旧規則に基づき医師である衛生管理者を選任してある場合には、その変更がない限り改めて「報告書」を提出する必要がないこと。
第2項ただし書は、学校にあっては、学校保健法により学校医の選任とこれによる学校職員の健康管理の義務が規定されていることにかんがみ、本条の報告を要しないことを規定したものであること。
第3項は、産業医の選任の特例を規定したもので、その具体的運用に関しては、おって通達する予定があるが、当面、本条第1項第2号または第3号に該当する場合であって、専属の者の退職等やむをえない事由で専属の産業医がえられないときには、嘱託の産業医を選任し、専属の産業医の選任に相当する業務を行なわせるとともに、当該事業場内の診療所等に保健婦、看護婦、衛生検査技師等をおくことにより衛生管理が円滑に行なわれることを条件とし、かつ、期間を限って許可すること。
----
第1項第2号のカ「その他厚生労働大臣が定める業務」は、定められていない。
----
事業場の考え方は、労働安全衛生法施行令第2条と同様であること。 |
2,848 | 小学校・中学校・高等学校の学習>高等学校の学習>高等学校理科>高等学校地学>高等学校 地学>惑星の運動
{{コラム|観測から理論へ|１６０９年、ガリレオ・ガリレイが望遠鏡を作って星を見ましたが、人々はまだ地球が宇宙の中心で、太陽や星はその周りを回っていると考えていました。同じ頃、ティコ・ブラーエは大きな分度器のような天文具を使って、星を見ただけでどこにあるのかがわかるようにしました。ヨハネス・ケプラーは、ティコ・ブラーエのデータを参考に、それまで考えられなかったような正確さで、惑星の軌道の動き方を研究しました。そして、ヨハネス・ケプラーの法則を考え出しました。これらの法則は、惑星がどのように動くかを正確に記述出来たとしても、基本法則が何なのかを明らかにしたわけではありません。
１６６６年から１６８７年まで生きたイギリス出身のアイザック・ニュートンは、それが万有引力の法則だと発見しました。アイザック・ニュートンは、「慣性の法則」「運動の法則」「作用・反作用の法則」という力と運動の３つの法則を提唱して、近代力学の基礎としました。これにヨハネス・ケプラーの法則を組み合わせて、「あらゆる２つの物体の間には万有引力が働き、その大きさは２つの物体の質量の積に比例して、物体間の距離の２乗に反比例する」という万有引力の法則を考え出しました。 |
2,849 | 法学＞民事法＞不動産登記法＞コンメンタール不動産登記法
（行政機関の保有する個人情報の保護に関する法律の適用除外）
第155条
登記簿等に記録されている保有個人情報（[http://law.e-gov.go.jp/htmldata/H15/H15HO058.html#1000000000000000000000000000000000000000000000000200000000000000000000000000000 行政機関の保有する個人情報の保護に関する法律（平成十五年法律第五十八号）第二条第三項]に規定する保有個人情報をいう。）については、[http://law.e-gov.go.jp/htmldata/H15/H15HO058.html#1000000000004000000000000000000000000000000000000000000000000000000000000000000 同法第四章]の規定は、適用しない。
----
155 |
2,850 | 経営学
経営学の教科書です。 |
2,851 | 法学＞コンメンタール＞コンメンタール刑事訴訟法=コンメンタール刑事訴訟法/改訂
（捜査記録の一部について証拠調べの請求）
第302条
第321条乃至第323条【第321条、第321条の2、第322条、第323条】又は第326条の規定により証拠とすることができる書面が捜査記録の一部であるときは、検察官は、できる限り他の部分と分離してその取調を請求しなければならない。
----
{{前後
|刑事訴訟法
|第2編 第一審
第3章 公判
第1節 公判準備及び公判手続き
|第301条（自白の取調べ請求の時期）
|第303条（公判準備の結果と証拠調べの必要）
302 |
2,852 | 社会調査（しゃかいちょうさ）とは、社会にいる人々の意識や実態などを図る方法である。社会学だけではなく、様々な分野で活用できる。このページでは、社会調査の概要および社会調査士(過程)についても説明する。各分野の詳細な内容は、サブページを参照してほしい。なお、このページおよびこのページのサブページでは、社会調査士課程の内容に準ずることにする。
社会調査では、社会の実態や行動を調査する方法を調査の計画から報告書の作成までを体系的に学ぶ学問である。社会調査の種類は、アンケート(調査票調査)やインタビューなどの聞き取り調査はもちろん含まれるが、文章や過去の映像などのメディアを分析する方法も含まれる。
社会調査士（しゃかいちょうさし）とは、社会調査協会が認定している資格である。この資格を取得するには、社会調査協会からカリキュラムの認定を受けている大学で所定の科目(後述)を修得することで取得できる。具体的には、A～G科目があり、A・B・C・D・G科目は必修、E・F科目はどちらか片方を選択する。下記に各科目の内容を示す。 |
2,853 | 法学＞民事法＞商法＞コンメンタール会社法＞第3編 持分会社 (コンメンタール会社法)＞会社法第589条
（社員であると誤認させる行為をした者の責任）
第589条
合名会社又は合資会社の社員でない者が自己を無限責任社員であると誤認させる行為をしたときは、当該社員でない者は、その誤認に基づいて合名会社又は合資会社と取引をした者に対し、無限責任社員と同一の責任を負う。
----
{{前後
|会社法
|第3編 持分会社
第2章 社員
第3節 誤認行為の責任
|会社法第588条（無限責任社員であると誤認させる行為等をした有限責任社員の責任）
|会社法第590条（業務の執行）
589 |
2,854 | 前）（次）
（破産者の居住に係る制限）
第37条
37 |
2,855 | 次の〔資料〕に基づき，当期末の固定資産の貸借対照表価額の合計額として最も適切なものの番号を一つ選びなさい。なお，計算過程で端数が生じる場合，小数点第1位をその都度四捨五入すること。（8点）
〔資料〕
1．当期首の当社の全固定資産
これらは全て前期第3 四半期期首に取得し，同時に使用を開始している。
2．当期において，鉱業権61,875,000円と機械（鉱業用設備）34,375,000円を取得し，当期第4 四半期期首から使用を開始している。採掘予定総量は2,750トンであり，当期の採掘量は125トンであった。
3．減価償却方法として，定額法を採用しており，生産高比例法を適用できる場合には，生産高比例法を採用している。また，残存価額はゼロとしている。
4
前期第3四半期に取得しているため，減価償却累計額は半年分の減価償却費に等しい。
建物の減価償却費
備品の減価償却費
建物簿価
備品簿価
生産高比例法については企業会計原則注解#注20_減価償却の方法についてを参照。
鉱業権の減価償却費
機械の減価償却費
鉱業権簿価
機械簿価 |
2,856 | 法学＞コンメンタール＞コンメンタール刑事訴訟法=コンメンタール刑事訴訟法/改訂
（証拠調べ）
第292条
証拠調べは、第291条の手続が終った後、これを行う。ただし、次節第1款に定める公判前整理手続において争点及び証拠の整理のために行う手続については、この限りでない。
----
{{前後
|刑事訴訟法
|第2編 第一審
第3章 公判
第1節 公判準備及び公判手続き
|第291条の3（決定の取消し）
|第292条の2（被害者等の意見陳述）
292 |
2,857 | 法学＞民事法＞コンメンタール＞コンメンタール民事執行法
（債務者が死亡した場合の強制執行の続行）
第41条
強制執行は、その開始後に債務者が死亡した場合においても、続行することができる。
民事訴訟法第35条第2項 及び第3項 の規定は、前項の特別代理人について準用する。
----
{{前後
|民事執行法
|第2章 強制執行
第1節 総則
|民事執行法第40条（執行処分の取消し）
|民事執行法第42条（執行費用の負担）
041 |
2,858 | （※ 連帯保証人については、この科目「経済活動と法」の範囲内です。検定教科書で説明の記載があるのを確認済。）
他人の借金の保証人になると、他人の借金を背負わされます。
保証人になるという事は、万が一の場合、その借金を、自分が払う覚悟があるという事である。
なので、保証する相手が特別に信頼できる相手方でないかぎり、保証人には、ならないほうが良いだろう。（※ 保証人になる場合の注意喚起は、検定教科書の範囲内である。実況出版の教科書の112ページに、「慎重でなければならない」注というふうな意喚起がある。）
「保証人」とは、必ずしも借金だけの保証人とは限らないが、本書では、まず、借金の保証人について説明する。
特に、借金の連帯保証人（れんたい ほしょうにん）には、まず、ならないほうが良い。
ふつうの保証人は、借金をした本人が優先的に借金取りから取り立てをされる。仮に借金をした本人が取り立てられるよりも先に、（普通の）保証人のところに借金取りが来ても、保証人は「まず、借金をした本人を探して、その本人に取り立ててください。」と反論でき、また、借金取りの側も、まず先に借金取りをした本人から取り立てる努力をしなければならない。
----
たとえば、900万円の借金の連帯保証人として、A,B,Cの3人が、連帯保証人になってたとする。
この場合、Aが900万円を請求される場合もあるし、Bが900万円を請求される場合もあるし、Cが900万円を請求される場合もある。
けっして、「3人で分担して、Aが300万円の負担、Bが300万円の負担、Cが300万円の負担」とかいうふうにはならない。
----
しかし、連帯保証人の場合だと、連帯保証人は借金をした人と同様の責任を負い、借金をした人と同様の責任で連帯保証人も借金取りから取り立てられる。
たとえ連帯保証人が、「私に取り立てるよりも前に、まず、借金を借りてる本人に、取り立ててください」などと反論しても、法的効力が無い。
つまり、連帯保証は、借金をしているのと同じ法的責任である。「連帯保証人」の「連帯」とは、このように、自身が借金をしているのと同じ扱いを受けます、という意味である。
※ 検定教科書には書かれてないが、この連帯保証制度を悪用した詐欺で、借金を負わせる詐欺がある。注意しなければならない。
2020年度の民法改正の内容 （※ いまのところ範囲外 :）情報提供の義務の新設
連帯保証人に対して、主債務者は、主債務者の財産などの状況についての情報提供を、連帯保証人に対して情報提供しなければならない義務（改正民法458条の2）が、2020年4月からの改正民法で新設で追加された。（※ ただし、条文では連帯保証人からの要請があった場合の規定であるので、まだ抜け穴がある。）
この義務の意義は、詐欺などを防止するためである。詐欺の手口で、詐欺師の債務者と債権者がグルになって、債務者があたかも財産があるかのように振舞って安心させたあと、計画的に債務者が破産して、保証金を連帯保証人から取る手口の詐欺が、連帯保証を悪用した詐欺の典型例として、よく知られてていた。
このような典型的な詐欺を未然に防止するため、改正民法では、主債務者の財産状況の情報提供の義務が追加されることになった。
債務者の提供する情報は、財産以外にも、契約対象以外の債務の有無と債務金額やその返済状況についても、情報提供の義務がある。（抜け道を防いでいる。）
この他、債権者の側にも義務が追加され、連帯保証人への、返済状況などの情報提供の義務が追加された。
※ （分割保証も検定教科書の範囲内。東京法令出版の教科書で、保証人の章節での傍注にて言及されている。）
「900万円を3人で分担するので、Aが300万円の負担、Bが300万円の負担、Cが300万円の負担です。」とか仕組みの保証の場合は「分割保証」という。分割保証も合法である。 分割保証は、連帯保証ではない。 なので、もし仮に、あなたが連帯保証人を頼まれた時、相手がもし「1000万円の債務を10人で分担して保証してるので、１人あたりは、たったの100万円の保証金額で済みます。」なんて頼んできたら、そいつは単なる詐欺師なので（なぜなら連帯保証の債務額は分割できないので）、そいつを相手にしないか、または警察か弁護士に相談したほうが良いだろう。
※ 検定教科書の範囲内。
詐欺などに悪用される危険な保証人の種類と言うと「連帯保証人」が有名であるが、他にも「根保証」（ねほしょう）というのも危険である。
もともとは、根保証（ねほしょう）とは、企業どうしの継続的な融資では、取引のたびに債務金額が増減したりするので、具体的な債務金額は決めずに、カネを貸したり借りたりするなどの契約である。
だが、この根保証を悪用した詐欺として、たとえば借り主が保証人には少額の借金額で安心させて、たとえば30万円の借金で「この借金の保証人になってほしい。」と言われて引き受けたら、じつは限度額が1000万円の根保証で、借り主が知人に保証人を引き受させた後に限度額まで借りて、そのまま逃げるというトラブルや詐欺が知られてる。
このような民法改正の背景として、上記のようなトラブルや詐欺があったからである。
保証人には、借金の保証人以外にも、就職時の身元保証人とか、私立学校への進学時の保証人とかもある。上記の説明で学んだように、保証人は、その法的責任が重い。「私の保証人になってくれ」と頼んできた相手が信用できない相手の場合は、断ったほうが良いだろう。
特に、借金の連帯保証人には、まず、なってはいけない、と考えたほうが、安全だろう。保証相手がよほど信頼できる相手でないかぎり、借金の連帯保証人には、なってはいけない、と考えるのが安全だろう。
※ 検定教科書には「借金の連帯保証人になってはいけない」とまでは書かれてないが、しかし、世間一般の家庭では、そう教育するのが一般的だろうし、書店などで販売されてる保証人についての実用書などにも、そう説明されているだろう。
それでも、どうしても他人の借金などの保証人・連帯保証人にならないといけない場合、詐欺に気をつけた上で、じっくり契約書を読んで内容を理解してから、借金をする当人が信頼できる場合のみ、保証人・連帯保証人になるべきだろう。
※ 検定教科書に書かれている内容。
保証人制度は、かならずしも借金だけの制度ではないが、借金で説明するのが分かりやすいので、当Wikibooks「経済活動と法」では用語説明などを、借金を例に説明する。
保証人のところに借金取りが来たとき、保証人が「まず、借金をした本人を探して、その本人に取り立ててください。」というふうに反論するなどして、借金取りに、借金をした本人を取り立てるように、カネを貸した側（借金取りや、その雇い主など）に請求することを、「催告の抗弁」（さいこく の こうべん）という。
また、このように、借金取り側は抗弁をされたら、借金をした本人から先に取り立てに行かなければならない、という保証人にとっての権利のことを催告の抗弁権（さいこく の こうべんけん）という。（民452）
しかし、連帯保証人には、催告の抗弁権が無い。（民454） ふつうの保証人には、催告の抗弁権がある。
連帯保証人には「催告の抗弁権」などの権利が無いので、実質的には、連帯保証人が借金をした本人とほぼ同等の法的責任を負っているのである。
また、ふつうの保証人の場合、かりに借金取りが財産を差し押さえようと強制執行する場合、まず、借金をした本人の財産から先に強制執行しなければならない。（民453）
※ 「差し押さえ」とは、国家権力によって、私人がその財物を許可なく処分できないように、その財物を国・公共機関の管理下に置くこと。
ここでいう借金取りによる差し押さえとは、債務者が返済の債務をまぬがれようとして、財産を回収できないような形で処分するのを防ぐために、裁判所などに債務者への強制執行をしてもらおうとすること。
ふつうの保証人の場合なら、借金をした本人の財産が強制執行されてないのに、保証人の財産が強制執行される事はなく、もし、そのような強制執行が行われても、これに抵抗できる。
このように、保証人の財産への強制執行よりも先に、まず先に借金をした本人の財産を強制執行せよ、と請求する権利を検索の抗弁権という。
しかし、連帯保証人には、この「検索の抗弁権」が無い。（民454） ふつうの保証人には、「検索の抗弁権」がある。
ふつうの保証人の場合、保証人が代わりに借金の返済額を支払った場合でも、保証人はあとから借金をした本人に、保証人の支払ったぶんの支払え、と請求できる。
これを「保証人の求償権」（ほしょうにん の きゅうしょうけん）という。（民459〜462）
しかし、連帯保証人には、「保証人の求償権」が無い。（民454）
なお、保証人が代わりに借金の返済額を支払うことを弁済（べんさい）という。
つまり、先ほどの「保証人の求償権」の説明を「弁済」という言葉で言い換えると
ふつうの保証人の場合、保証人が代わりに弁済した場合、保証人はあとから借金をした本人に、保証人の弁済したぶんと同等の金額を支払え、と請求できる。
のようになる。
----
以上の3つの権利をまとめると、
ふつうの保証人には、「催告の抗弁権」「検索の抗弁権」「保証人の求償権」がある。
しかし、連帯保証人には、「催告の抗弁権」「検索の抗弁権」「保証人の求償権」が無い。
借金の契約の場合、借金をした本人は、主たる債務者（しゅたる さいむしゃ） である。
なお「債務」（さいむ）とは、契約などの結果により、「○○しなければならない」と義務を負うことである。（要 確認）
一方、金を貸した側は、債権者（さいけんしゃ）である。債権（さいけん）とは、例えば「貸したカネの返還を、借りた側（債務者など）に請求してもよい」のように、契約などの結果により、相手方に義務をおわせてもいい権利である。（要 確認）
たとえば先ほどの「催告の抗弁権」について、「主たる債務者」「債権者」などの用語を用いて言い換えてみれば、次のようになる。
保証人のところに債権者（借金取りや、その雇い主など）からの請求が来たとき、保証人は、まず主たる債務者（借金をした本人）から先に取り立てるように、保証人が債権者に請求できる権利を「催告の抗弁権」（さいこく の こうべんけん）という。
のような説明になる。
保証人も、契約によって、いろいろな義務を負ったのであるから、保証人も債務を負ってる。
保証人制度における保証人の債務のように、主たる債務者の代わりにカネを払うかもしれない債務のことを保証債務（ほしょう さいむ）という。
そもそも「保証人」とは、民法第446条によると、民法第446条「保証人は、主たる債務者がその債務を履行しないときに、その履行をする責任を負う。」である。
そして「保証債務」とは、「主たる債務者がその債務を履行しないときに、その履行をする責任」のことである。（要 確認）
保証人の資格として （1） 行為能力者であること、(2) 弁済の能力を持つこと、 が必要である。（民450）（※ 高校の範囲内。実教出版の教科書に記述あり。）
ひとつの債務について、その債務の連帯保証人が複数いるとき、債権者（金貸しの側）は、どの連帯保証人にも、保証債務の全額を請求できる。なので、とにかく連帯保証人は、自己破産などをしないかぎり、債権者に弁済を要求されたら、保証額をいったん全額を払うハメになる。（ここまでは、すでに説明した通り。）で、複数の連帯保証人がいる場合、連帯保証人どうしでは保証額を分担するように請求できる。（※ 検定教科書の範囲内。 東京法令出版の教科書に解説あり。）
たとえば、Aが300万円の借金をして、Aの連帯保証人としてBとCとDの3人が連帯保証人なっているとする。
債権者は、BとCとDの誰に対しても、300万円を請求できる。
で、とりあえず債権者がBに300万円を請求して、その結果、Bが300万円を払ったとしよう。
すると、Bは100万円のCとDに求償を請求できる。（300万円÷3人＝100万円/人 なので、他の連帯保証人1人あたり100万円を請求できる）
保証契約は、書面でしなければならない。（民446の2）（※ 高校の範囲外）この保証契約を書面で行う規定は、2004年（平成16年）の民法改正による。電子メールなどの電磁的記録で保証契約がされた場合、その保証契約は有効である。（民446の3）（※ 参考文献: 有斐閣『債権 エッセンシャル民法＊3』、永田眞三郎ほか、2010年初版、84ページ）
商取引における保証については、「連帯保証にする」などの特約がなくとも、連帯保証になる。（商511の2） （※ 検定教科書の範囲。実教出版の教科書に記述あり。）（※ 参考文献: 自由国民社『保証・連帯保証のトラブルを解決するなら、この1冊』、石原豊昭、第2版、70ページ） 正確に言うと、主たる債務者の債務が商取引から生じたものである場合、法律上当然に連帯保証と見なされる。（商511の2）（※ 検定教科書では、こういう言い回し（「主たる債務者の債務が〜（以下略）」）で説明している。）
夫婦の一方が日常の買い物（たとえば、日常の食料品を買う、など）として行った債務（その食料品の代金を払う、など）は、その夫婦の連帯債務になる。（民761） （※ 実教出版の教科書では、発展項目として家族法（民法内にある）について習う単元がある。その単元で、夫婦の日常の買い物の連帯債務についても書いてある。） |
2,859 | 平行とは、複数の線の状態のことをいいます。
2つの直線AとBがあるとします。このAとBをどこまで伸ばしてもずっと交わらないとき、AとBは平行であるといえます。これは直線がいくつあっても同じです。（例:直線AとBとCは平行である。） |
2,860 | クリエイターの中には、犯罪者またはグレーな行為または詐欺的な人物もいます。それこそ、テレビや雑誌などで取り上げられたことのある新人クリエイターや若手～中堅クリエイターなどの中にも、犯罪・詐欺・グレー行為を行っている人物はいます。
「まさか！？」とはお思いでしょうが、しかし小規模が民間の一般人などで小規模だと、被害者の一般人が泣き寝入りする場合もあるのです。
例を挙げると、商標でも何でもない一般的なワードを、クリエイターが登録したわけでもないのに勝手に言い回しを占有していて、SNS上で同じワードを使った一般の人に「誰の許可を取ってんだよ！」とまるでヤクザのショバ代みたいに畏怖行為をしてくるクリエイターおよびそのクリエイターのファンもいます。
そういう人であっても、クリエイターとは作品を作って有料で販売して、それにそこそこの売上がついてしまえば、そういう社会的にグレーな人でもテレビや雑誌などに「作家」とか「クリエイター」などとして取り上げられてしまうのです。
しかも困ったことに、そのクリエイター本人およびファンたちは、自分たちが知的財産権を遵守しているつもりになっていますし、日本のポップカルチャー文化を高めているつもりです。
つまり、大人の中には、民法や著作権法や知的財産権などの基本を理解してないで好き勝手にとらえている作家もいます。
そういう作家の違法な行為でも、被害者が小規模な一般人だと、そのクリエイターの所属する芸能事務所だの何だのは放置します。
このように、「カタギに迷惑を掛けない」というルールが守れない作家もいます。
他にも、音楽ロックコンサートなどでは、麻薬などの売買が行われたりしました。ディスコ会場などで麻薬の売買が行われることもありました。
そういう人でも有料の作品商売に成功してファンがついている場合もありますし、テレビや雑誌などに紹介されることもあります。
法律を守れない業界からは、なるべく距離を置きましょう。
なにもロック音楽だとかそういうカウンターカルチャーの業界に限らず、残念ながらマンガやアニメなどのファンでも著作権法などの法律を守れない、社会のルールの基本が分かってない幼稚な大人も多くいます。引用のルールを守れない人とか、SNSなどにも普通にいます（今どき中学校の技術家庭科とかの教科でも著作権法を習っているのに）。
残念なことなのですが、ロック音楽とかマンガ・アニメとか、ああいう子供や低学歴でも分かる文化というのは、法律などを守れない人も寄せ付けてしまいます。
よく、作家などは「先生」などと出版社に言われたりするので、世間の人はクリエイターをついつい弁護士や医師のように信用の高い職業かと誤解しがちですが、どちらかというと宗教家のような人もいるのが作家でしょう。
クラシック音楽系の人だと、音楽で食っていかない事を考えている人も多くいますが（たまの休日などに趣味で演奏する人もいます）、しかし美術系の人だと「美術で食っていこう」とするのを当然とする人も多くいます。べつに美術の仕事を目指す事自体は構わないのですが、勝手に子供時代に「自分は美術家（または画家など）になれるはずだ」と思い込んで、その夢がかなわなくてコンビニバイト暮らしなどで勝手にウツ病か何かになる頭のおかしい人も少なくないのが美術界隈です。プロ野球などのスポーツ系ではそういう勝手な夢を期待した人は相手されませんが（多くの高校球児はプロ野球選手にはなれません）、クラシック音楽でもそういう勝手な期待をした人は基本的には相手されないのですが、しかし美術界隈だとそういう人にも少数のファンがつく場合もあります。
このように、まあ、世間の常識から外れたという意味で、ある種のクリエイターとその自称ファンはまさに宗教家のような人たちです。日本国憲法には宗教の自由があるので、禁教は出来ませんが、しかしだからと言って私たちが芸術を媒介にしたヘンな宗教に入信する必要もありません。
まして、「世間はもっと美術に金を払うべきだ（もちろん美術家である私にもカネを払うべきだ）」などと売れない美術家が政治運動を起こそうものなら、これはもはやカルト新興宗教が「世間はわが教団に入信すべきだ。そしてお布施を払うべきだ」と主張しているのと変わらないので、これはもはや信教の強制によって我が国の国民を奴隷化しようとするテロ思想と同じ発想であるので、私たちはそのような反社会な侵略テロ思想とは戦わないといけません。
美術Iやら音楽Iだのの芸術の教科書を読んでると、基本的に教科書は現代の作家を紹介しているので、ついつい読者は画集などの作品の購入意欲をそそられがちです。
しかし教科書は一言も「その作家の作品を買え」なんて言ってません。だいたい、たとえば社会科の地理の教科書だって海外を紹介していますが、一言も「海外旅行してくれ」なんて言ってません。
芸術教科書は単に最近の一部の作品を紹介しているだけです。美術や音楽の教科書の作品は基本、大学入試には出ませんし、少なくとも大学入試新共通テスト（昔のセンター試験に相当）には美術も音楽もありません。
「芸術」と言うのは、理由が決して経済学的・法学的などには説明できず、ふつうの学問的には説明できません。だから、日本の教育でも通常の「学問」とは切り離されているのは当然でしょう。
少なくとも大衆相手には「芸術」は美しさの理由を客観的には証明できず（説明はあっても、決して数学のように「証明」はされない）、なのに「この名画は価値があるとされる」とされるものが、中学あたりの美術教科書などの美術史では紹介されているわけです。非・民主的であり、ある種、貴族的ではあります。
ただし、その美術の理論を学んだり模写・模倣したり練習したからといって、決してアナタが貴族的に尊敬される人物として社会に認められるわけではありません。
日本史の勉強にたとえれば、平安時代の貴族について勉強したからといって自身が貴族になれるわけでもないのと同様ですが、しかし、なぜか美術界隈ではときどき勘違いして奇行をしている人がいます。戦国時代を天下統一した豊臣秀吉や徳川家康について勉強したからといって天下取りをできるわけではないのに。 |
2,861 | 純水の製造や、溶液中の成分の濃縮に、イオン交換樹脂（ion-exchange resin）が用いられている。イオン交換樹脂とは、溶液中のイオンを、べつのイオンに交換する樹脂である。
純水の製造には、海水の淡水化（塩水から、真水にすること。）や、他には工業用の純水化がある（※ 範囲外: たとえばボイラーに使う水からカルシウムなど硬水成分を除去するのに、イオン交換樹脂が使われている。 参考文献: 工業高校用の教科書『工業材料』平成16年発行版）。
thumb|500px|陽イオン交換樹脂の構造
スチレンC6H5-CH=CH2 とp-ジビニルベンゼン CH2=CH-C6H5-CH=CH2 を共重合化させると、立体網目状で、水には不溶の高分子が得られる。これを濃硫酸でスルホン化すると、スチレンのベンゼン環にスルホ基-SO3Hが導入される。
この樹脂は、水溶液中では水素イオンを放出し、代わりに溶液中の他の陽イオンと結合する事ができる。このような、水溶液中では水素イオンを放出し、代わりに溶液中の他の陽イオンと結合する事ができる 樹脂を陽イオン交換樹脂という。
このスチレンとp-ジビニルベンゼンを共重合化させたものを濃硫酸でスルホ化させた樹脂は、陽イオン交換樹脂の代表的なものとして、よく用いられる。
使用して、陽イオンが水素以外と交換したものは、そのままでは交換能力を失っているが、この樹脂に希塩酸や希硫酸などの酸性の溶液を通すと、ふたたびスルホ基-SO3 に水素分子Hが結合した状態-SO3Hに戻り、陽イオンの交換能力を取り戻す。
使用済みの陽イオン交換樹脂が、陽イオンの交換能力を取り戻すことを、イオン交換樹脂の再生という。
ポリスチレン分子中に、トリメチルアンモニウム基-N+(CH3)3などの塩基性の基を導入し、さらに強塩基でアルカリ化して基を-N+(CH3)3OH- にしておく。
この基は、溶液中の陰イオンとOH- を交換する能力を持つ。このような樹脂を、陰イオン交換樹脂と呼ばれる。
使用済みの陰イオン交換樹脂は、水酸化ナトリウム溶液などの強塩基を通すことで、イオン交換が再生する。
医療でもちいる人工透析でも、イオン交換膜が用いられている。（啓林館の検定教科書で確認。）
なお、半導体の製造に使う「超純水」は、じつは純粋な水ではなく、半導体製造用に成分のコントロールされた水である。この超純水の製造も、水道水をもとにイオン交換樹脂で純度を上げた水が、使われているらしい。 |
2,862 | 法学＞民事法＞コンメンタール＞コンメンタール民事執行法
（債務者の占有する動産の差押え）
第123条
債務者の占有する動産の差押えは、執行官がその動産を占有して行う。
執行官は、前項の差押えをするに際し、債務者の住居その他債務者の占有する場所に立ち入り、その場所において、又は債務者の占有する金庫その他の容器について目的物を捜索することができる。この場合において、必要があるときは、閉鎖した戸及び金庫その他の容器を開くため必要な処分をすることができる。
執行官は、前項の規定により債務者に差押物を保管させる場合において、相当であると認めるときは、その使用を許可することができる。
執行官は、必要があると認めるときは、第3項の規定により債務者に保管させた差押物を自ら保管し、又は前項の規定による許可を取り消すことができる。
----
{{前後
|民事執行法
|第2章 強制執行
第2節 金銭の支払を目的とする債権についての強制執行
第3款 動産に対する強制執行
|民事執行法第122条（動産執行の開始等）
|民事執行法第124条（開始決定等）
123 |
2,863 | 法学＞コンメンタール＞コンメンタール刑事訴訟法=コンメンタール刑事訴訟法/改訂
（整理手続き終了後の証拠調べ請求の制限）
第316条の32
公判前整理手続又は期日間整理手続に付された事件については、検察官及び被告人又は弁護人は、第298条第1項の規定にかかわらず、やむを得ない事由によって公判前整理手続又は期日間整理手続において請求することができなかったものを除き、当該公判前整理手続又は期日間整理手続が終わった後には、証拠調べを請求することができない。
前項の規定は、裁判所が、必要と認めるときに、職権で証拠調べをすることを妨げるものではない。
----
{{前後
|刑事訴訟法
|第2編 第一審
第3章 公判
第2節 争点及び証拠の整理手続
第3款 公判手続の特例
|第316条の31（整理手続き結果の顕出）
|第316条の33（被告事件の手続きへの被害者参加）
316の32 |
2,864 | 法学＞コンメンタール＞コンメンタール刑事訴訟法=コンメンタール刑事訴訟法/改訂
（通訳2）
第176条
耳の聞えない者又は口のきけない者に陳述をさせる場合には、通訳人に通訳をさせることができる。
----
{{前後
|刑事訴訟法
|第1編 総則
第13章 通訳及び翻訳
|第175条（通訳1）
|第177条（翻訳）
176 |
2,865 | 民事訴訟法＞民事訴訟規則
（手形判決の表示）
第216条
手形訴訟の判決書又は判決書に代わる調書には、手形判決と表示しなければならない。
----
{{前後
|民事訴訟規則
|第5編 手形訴訟及び小切手訴訟に関する特則
|民事訴訟規則第215条（期日の変更又は弁論の続行）
|民事訴訟規則第217条（異議申立ての方式等・法第357条） |
2,866 | 法学＞民事法＞商法＞コンメンタール商法＞第2編 商行為 (コンメンタール商法)
（利益の配当の制限）
第537条
出資が損失によって減少したときは、その損失をてん補した後でなければ、匿名組合員は、利益の配当を請求することができない。
----
{{前後
|商法
|第2編 商行為
第4章 匿名組合
|商法第537条（自己の氏名等の使用を許諾した匿名組合員の責任）
|商法第539条（貸借対照表の閲覧等並びに業務及び財産状況に関する検査）
538 |
2,867 | 法学＞社会法＞労働保険の保険料の徴収等に関する法律＞労働保険の保険料の徴収等に関する法律施行令＞労働保険の保険料の徴収等に関する法律施行規則
労働保険の保険料の徴収等に関する法律施行令(最終改正：平成一九年四月二三日政令第一六一号)の逐条解説書。 |
2,868 | 英語が分からないと言っている人の大半は英語がわからないのではなく英単語が分からないのである。
英単語が分からなければ、何も始まらない。
まずは、英単語の勉強から始めてからこの続きを読んでもらいたい。
それから、英文法である。
前文に述べた通り、英単語から始めその次のステップが英文法である。
英単語をマスターした段階で、ある程度の良い結果が点数として現れる。
しかし、それだけでは英語に対して自信を持つことは難しい。
なぜなら、短文や長文を読解しようとすると、ある程度流れをつかむことができるが
訳としてみたとき、意味不明となるはずである。
それは、英語と日本語の文法の違いによって生じることである。
なので、英単語を習得した後、英文法を習得する必要がある。
英文法は英単語と比べ暗記暗記と徹底的にするような学習ではない。
参考書を読み、それから問題演習である。
英文法は英単語みたいに覚えれば良いというわけではなく、
数学の公式のように何度も何度も反復する必要がある。数学の知識を心得ている人なら実感できるだろうが、
何度も何度も反復することによって自然と体に身についている。
なので、問題を繰り返し繰り返し解くことに尽きる。この段階である程度英語というものを熟知できている。
もちろん、英語圏で生活できる程の熟知ではなく、試験問題としてある程度解くことができる又は苦手意識がなくなるということである。
ここからが、英語を本格的に学ぶことになるのだが、英熟語、特に入れ替え問題が入試では特に重要視されてくる。
そのほかにも、イディオム、アクセントがある。
これらのものはとにかく英文法と同様、問題演習が何よりの近道なのである。
そのことは、英文法の問題演習をやっているときに自然に気がつくことであって、別にここで述べる必要はない。
もしも、ここまで読んで「なるほど、そうか」と気づくようでは、まじめに学習しているとはいえない。
塾や参考書を頼りにしていればいいと誤解している人が多いようである。
中でも、無意識の人の割合が多い。
とりあえず勉強しなければならないから、参考書を開いて問題演習をして終わり。
こんなパターンをしているようでは、定期テストはできても入試実力テストでは全く通用しない。
このことを理解してもらいたい。
それにより、前回の学習と今回の学習では量は同じでも質が違うのは一目瞭然、本人が驚くであろう。
これまで述べてきたことを実践し習得すれば、もうここで言うことは無いだろう。
もちろんこれで完璧ではないが、この先はあなた独自のやり方で突き進むしかない。
健闘を祈る。
__インデックス__
__新しい節リンク__ |
2,869 | ]]) は、標準的な応急手当のコースに必要なあらゆるトピックスをカヴァーし、初歩的な内容から高度な内容までもが含まれます。カヴァーされる基礎には、次のようなものがあります。
高度なトピックスの章では、酸素投与や気道確保、AEDの取扱いや原生地域での技術、さらなる病状評価やトリアージについての情報をご覧いただけます。応急処置のコースで対象とする読者は、有資格のインストラクターから高校生程度としますが、一部の初歩的な内容では小学校高学年から中学生でも可能なものとなるでしょう。
なお、議論のある怪我や病気の画像がありますのでご了解ください。
これはウィキですので、あなたはこの本を編集できます。もし間違いを見つけたら、大胆になって修正してください。もしコメントを残したければ、そのコンテンツのトーク・ページにお越しください。もしもっと援助したければ、あなたが出くわした作業から何でも始めてください。 |
2,870 | この本は、プログラミング言語Rustについての初心者向けの完全な入門書です。Rustは、速度と安全性の両方を兼ね備えたシステムプログラミング言語であり、コンパイラによるメモリ管理によってセグメンテーションフォールトやダングリングポインタなどの危険なエラーを防止します。この本では、Rustの基礎から始めて、データ型、関数、所有権、トレイト、マクロなどの重要なトピックをカバーしています。また、Rustの機能を実際のコード例を交えて説明し、読者が自分自身でコードを書き始めるための準備を整えます。本書を読み進めることで、Rustで安全で高速なシステムプログラミングを行うための基礎を身につけることができます。
__TOC__
Rust（ラスト）は、高性能かつ安全な並行処理を実現するために設計されたマルチパラダイム汎用プログラミング言語です{{cite web
|url=https://graydon2.dreamwidth.org/247406.html
|title=Rust is mostly safety
|last=Hoare
|first=Graydon
|date=2016-12-28
|website=Graydon2
|publisher=Dreamwidth Studios
|access-date=2021-12-03
|archive-date=2019-05-02
|archive-url=https://web.archive.org/web/20190502181357/https://graydon2.dreamwidth.org/247406.html
。
Rustの構文はC++に似ていますが、ボローチェッカーを使用して参照を検証し、メモリ安全性を保証することができます。Rustのボローチェッカーは、Rustコンパイラによって提供される静的解析ツールであり、所有権システムに基づいて、コード内の不正なボロー（借用）を検出するために使用されます。
Rustは、ガベージコレクターを使用せずにメモリ安全性を実現し、オプションでリファレンスカウントによる管理も可能です。
Rustは、システムプログラミング言語と呼ばれ、関数型プログラミングの要素を取り入れつつ、低レベルのメモリ管理メカニズムも提供しています。
そのため、高度な制御を必要とするアプリケーションの開発に最適です。Rustを使うことで、実行時にエラーを発生させることなく、安全で信頼性の高いコードを作成することができます。
{{コラム|セルフホスティング|2=セルフホスティングとは、あるソフトウェアが自分自身をコンパイルできることを指します。つまり、そのソフトウェアをコンパイルするために、あらかじめ別のコンパイラーが必要ではなく、そのソフトウェア自体が自分自身をコンパイルできることです。
コンパイラーにおいてセルフホスティングは、最初にコンパイルされたコンパイラーを使用して、同じ言語で書かれたソースコードをコンパイルすることで実現されます。そして、その新しいコンパイラーを使用して、さらに新しいソースコードをコンパイルし、それを繰り返すことで、より新しいバージョンのコンパイラーを作成することができます。
Rustはメモリ安全性、並行性、パフォーマンスの向上に焦点を当てたモダンなプログラミング言語です。
以下のRustのクイックツアーで、基本的な概念とコード例を紹介します。
Rustプログラムはmain関数から始まります。println! マクロを使って標準出力に文字列を出力できます。
fn main() {
println!("Hello, world!");
}
Hello, world!
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=65f8e3b00b49ca5c691cd61bfc32d1b7 hello.rs]は、[https://play.rust-lang.org/ Playground]に作った、このプログラムへのリンクになっています。
Rustには整数、浮動小数点数、真偽値などの基本データ型があります。
let age: i32 = 25;
let salary: f64 = 50000.50;
let is_rust_fun: bool = true;
let message: &str = "Hello, Rust!";
if、else if、else 文で条件分岐ができます。
while ループや for ループで繰り返し処理ができます。
let num = 10;
if num > 0 {
println!("Positive");
} else if num < 0 {
println!("Negative");
} else {
println!("Zero");
}
for i in 0..5 {
println!("Iteration {}", i);
}
関数は fn キーワードを使って宣言します。
fn add(a: i32, b: i32) -> i32 {
a + b
}
fn main() {
let result = add(5, 3);
println!("Sum: {}", result);
}
Rustは所有権ベースのメモリ管理を採用しており、値の所有権が明確に定義されています。
fn main() {
let s1 = String::from("Hello");
let s2 = s1; // s1の所有権がs2に移動する（所有権の転送）
// println!("{}", s1); // エラー！s1はもう有効ではない
println!("{}", s2); // 正常に動作
}
構造体はデータをまとめるためのカスタム型で、メソッドを持つことができます。
struct Car {
model: String,
year: u32,
}
impl Car {
fn display_info(&self) {
println!("Model: {}, Year: {}", self.model, self.year);
}
}
fn main() {
let my_car = Car {
model: String::from("Toyota"),
year: 2022,
};
my_car.display_info();
}
ここでは、Rustの基本的な構文とコンセプトを簡単に紹介しました。
やや力技ですが、Rustのコンパイラ rustc のバージョンをコードから確認できます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=db39d32bceac679dd79591501075d7f6 version.rs]:
fn main() {
let version = std::process::Command::new("rustc")
.arg("--version")
.output()
.expect("Failed to get Rust version");
if version.status.success() {
let stdout = String::from_utf8_lossy(&version.stdout);
println!("Rust version: {}", stdout);
} else {
eprintln!("Failed to retrieve Rust version information");
}
}
実行結果:
Rust version: rustc 1.76.0-nightly (21cce21d8 2023-12-11)
このコードは、Rustのプログラム内でrustc --versionコマンドを実行し、その結果（Rustコンパイラのバージョン情報）を取得しています。
std::process::Command::new("rustc"): Command構造体を使って新しいコマンドを作成しています。ここではrustcというコマンドを実行するよう指定しています。
.arg("--version"): rustcコマンドに--version引数を渡しています。これにより、Rustコンパイラのバージョン情報を取得するよう指示しています。
.output(): Commandを実行して、その結果を取得します。ここでは--versionを指定したrustcコマンドを実行し、その出力を取得しています。
.expect("Failed to get Rust version"): コマンドの実行が失敗した場合にエラーメッセージを表示します。
if version.status.success() { ... } else { ... }: 実行結果のstatusをチェックして、コマンドが正常に終了したかどうかを確認します。もし成功していた場合は、コマンドの出力結果（Rustコンパイラのバージョン情報）を取得し、それを標準出力に表示します。もし失敗していた場合は、エラーメッセージを標準エラー出力に表示します。
このコードは、Rustのプログラム内で外部コマンドを実行してその出力を取得する方法を示しています。具体的には、Rustコンパイラのバージョン情報を取得してそれを表示する例です。
Rustのコメントには、C言語/C++と同じく一行コメントと範囲コメントがあります。
一行コメント: //から行末までがコメントと見なされます。
範囲コメント
/*から*/までがコメントと見なされます。
ネストは許されません。
コメントの例:
/*
* プログラムのエントリーポイントは、main 関数です。
* 関数定義は fn から始まります。
*/
fn main() {
println!("Hello, world!"); // println! は関数ではなくマクロで、マクロは識別子の末尾に ! が付きます。
}
Rustでは、変数を宣言する際にはデフォルトでimmutable（不変）です。変更可能な変数を宣言するには、mut キーワードを使用します。変数の型はコンパイラによって推論されることが一般的ですが、型を明示的に指定することもできます。
例えば、変数の宣言と型指定は以下のようになります：
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=8cddaf15c8b53acb5e0a2013a5cb8cc2 decl.rs]:
fn main() {
// 型推論による変数の宣言
let x = 5; // 整数型 i32 として推論される
let y = 3.14; // 浮動小数点型 f64 として推論される
println!("x = {x}, y = {y}");
// 型を明示的に指定する
let z: i64 = 100; // 64ビット整数型 i64
println!("z = {z}");
}
Rustの基本的なデータ型には以下があります：
Rustは静的型付け言語であり、変数の型はコンパイル時に確定されます。型の安全性に対する厳格なチェックを行うため、コンパイル時に型の整合性が確認されます。これにより、メモリの安全性やスレッドセーフなコードを書く際の支援が期待できます。
Rustでは、変数を宣言するにはキーワード letを使います。
ディフォルトではイミュータブル（''Immutable''；宣言後には代入不能）な変数が宣言されます。
ミュータブル（''Mutable''；宣言後に代入可能）な変数を宣言するには、追加のキーワード mut を使います。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=9032ae8999c6cb3bf5412988320e50d7 hello-variables.rs]:
fn main() {
let hello : &str = "Hello, world!";
println!("{}", hello);
}
実行結果:
Hello, world!
２行目のlet hello : &str = "Hello, world!";が変数宣言です文字リテラルであることを強調するならlet hello : &'static str = "Hello, world!";とすべきだったかもしれません。。
&str（文字列のスライスのリファレンス）を型とする変数 hello を宣言し、"Hello, world!"で初期化しています。
Rustには強力な型推論があり多くの場合不要ですが、let 変数名 : 型名の書式で型を伴い変数宣言することも出来ます。
mut をつけない場合には変数に「代入不能」と聞くと、C言語などを知っている人は「定数」を思い浮かべるかもしれませが、
Rustにおいて「定数」は, const 宣言された定数や, static 宣言されかつ mut で修飾されていない変数が相当します。
Rust では、変数宣言が初期値を伴っていた場合、変数の型を省略することができ、初期値の型が変数の型になります。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=ac2b2d100ee8ea175178ebe9b1e26c61 hello-type-inference.rs]:
fn main() {
let hello = "Hello, world!";
println!("{hello}");
}
実行結果:上に同じ
Rust では、値が一度変数に let で束縛されると変更できません。これをイミュータブルと言います。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=d13ccba2d1b5efef4ca929012eece549 hello-immutable.rs]:
fn main() {
let hello : &str = "Hello, world!";
println!("{hello}");
hello = "Hello, rust!";
println!("{hello}");
}
コンパイル結果:
error[E0384]: cannot assign twice to immutable variable `hello`
--> src/main.rs:4:5
|
2 | let hello : &str = "Hello, world!";
| -----
| |
| first assignment to `hello`
| help: consider making this binding mutable: `mut hello`
3 | println!("{hello}");
4 | hello = "Hello, rust!";
| ^^^^^^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable
For more information about this error, try `rustc --explain E0384`.
error: could not compile `playground` (bin "playground") due to 1 previous error
イミュータブルな変数には、代入できないというコンパイルエラーです。
代入可能、すなわちミュータブルにするためには、変数宣言にあたり let に続けて mut をつけます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=6bbb520249ebc44f7e341988dfad92a3 hello-mutable.rs]:
fn main() {
let mut hello : &str = "Hello, world!";
println!("{hello}");
hello = "Hello, rust!";
println!("{hello}");
}
実行結果:
Hello, world!
Hello, rust!
同一スコープで同じ変数名での宣言は可能です。
同じ型である必要はありません。ミュータブルであるかイミュータブルであるかも問いません。
同じ変数名での宣言によって、それまで変数に束縛されていた値への参照がなくなります。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=0604ce8c08449bba14b64f80c405815d 同じ変数名での宣言]:
fn main() {
let hello : &str = "Hello, world!";
println!("{}", hello);
let hello = 154649;
println!("{}", hello);
}
実行結果:
Hello, world!
154649
Rustには2種類の定数があり、どちらもグローバルスコープを含む任意のスコープで宣言することができます。また、どちらも明示的な型を持っている必要があります。
static: 静的寿命を持つミュータブルな値 静的寿命は推論されるので、指定する必要はありません。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=901ef30e5d150a91c9fed78d63a4971d ２種類の定数]:
const HELLO : &str = "Hello, world!";
static LANGUAGE: &str = "Rust";
fn main() {
println!("{HELLO}");
println!("{LANGUAGE}");
}
実行結果:
Hello, world!
Rust
コードを書き換えてconst宣言や（ミュータブルな）static宣言された変数に代入をしようとすると、エラーになります。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=9e938e1309c6ba12f760a6c6f0c9d210 pattern.rs]:
fn main() {
let (mut x, mut y) = (5, 29);
println!("x={x} y={y}");
(x, y) = (y, x);
println!("x={x} y={y}");
}
実行結果:
x=5 y=29
x=29 y=5
このコードは、x と y の値を交換するRustの機能を示しています。
最初の行では、x に 5 を、y に 29 を代入しています。
次の行では、println! マクロでは、交換後の x と y の値を表示しています。
次の行では、(x, y) = (y, x); という操作を行っています。これは、タプルを使って複数の変数に同時に値を代入しています。この場合、(y, x) というタプルの中身を (x, y) に順番に代入しています。これにより、x の値に y の値が入り、y の値に x の値が入ります。これによって x と y の値が交換されます。
最後の println! マクロでは、交換後の x と y の値を表示しています。
このコードは、Rustのタプルを使った多値代入の機能を示しています。
Restには豊富なデータ型(''Data Types'')があり、それらを組み合わせて新しい型を作ることができます{{Cite web
|url=https://doc.rust-lang.org/book/ch03-02-data-types.html
|title=Data Types - The Rust Programming Language
|accessdate=2021/12/08
。
スカラー型は単一の値を表します。Rustには、整数、浮動小数点数、論理値、文字という4つの主要なスカラ型があります。
Rustの整数型は、符号の有無とビット幅から12種類のバリエーションがあります。
isizeとusizeのビット幅はプロセッサーのアーキテクチャーによって定義され、32ビットプロセッサーならば32、64ビットプロセッサーならば64です。
リテラル(''Literals'')とは、プログラミングのソースコードで使用される、数値や文字列などのデータを直接表現したものです。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=9c41862df3833ee7bd16169631d74de7 例]:
fn main() {
println!("{:?}", 19_800);
println!("{:x}", 0xbadbeef);
println!("{:o}", 0o777);
println!("{:b}", 0b101_111_011);
println!("{}", b'Q');
}
実行結果:
19800
badbeef
777
101111011
81
数値リテラルには、123u8 の様に型名をタイプサーフィックス(''type suffix'')として補うことで、ビット幅を明記できます（オプショナル）。
指定されない場合は（バイト以外は）i32が仮定されます（isizeではありません）。
数値リテラルには、読みやすさのため 9_281_636 のように、アンダースコア _ を補うことができます（オプショナル）。
なお、{:x}の{x}部分はプレースホルダーのファーマッティング・トレイツです。「x」なら16進数、oなら8進数、bなら2進数で出力します。
Rustには、浮動小数点数を表現するための2つの主要な型があります。それぞれの型は、IEEE-754規格に従っています。
f32: 32ビットの単精度浮動小数点数型です。精度は約6桁です。
f64: 64ビットの倍精度浮動小数点数型です。精度は約15桁です。
Rustでは、浮動小数点数リテラルを書く場合、デフォルトで f64 型になります。例えば、3.14 という浮動小数点数リテラルは、f64 型の数値になります。
以下は、f32 型と f64 型の浮動小数点数の使用例です。
fn main() {
// デフォルトでは f64 型になる浮動小数点数
let my_float1 = 3.14; // f64 型
// サイズを明示して f32 型にする
let my_float2: f32 = 2.718; // f32 型
// 浮動小数点数同士の計算
let sum = my_float1 + f64::from(my_float2); // f64 型にキャストして計算
println!("Sum: {}", sum); // f64 型の結果が出力される
}
実行結果:
Sum: 5.857999935150147
浮動小数点数は、数値計算や科学的な計算など、精度が求められる場面で使用されます。しかし、浮動小数点数の性質や精度による注意が必要な場面もありますので、注意深く扱う必要があります。
Rustにおける論理値型の型名は bool で、真の値は true、偽の値は false です。この型は非常に基本的で、条件分岐やブール演算などで使用されます。
以下は bool 型の使用例です。
fn main() {
let is_rust_cool = true; // 真の値を持つ変数
let is_java_cool = false; // 偽の値を持つ変数
if is_rust_cool {
println!("Rust is cool!"); // 条件が true の場合に実行される
} else {
println!("Rust is not cool."); // 条件が false の場合に実行される
}
// 論理演算
let result = is_rust_cool && is_java_cool; // 論理積 (AND) の例
println!("Result of logical AND: {}", result); // false が出力される
}
実行結果:
Rust is cool!
Result of logical AND: false
bool 型は条件式の評価や論理演算に広く使用され、プログラムの流れを制御するための基本的な手段として重要な役割を果たします。
Rustの文字型 char はUnicodeの単一の文字を表し、32ビットで符号化されます。Unicodeのサロゲートペアを含む広範な範囲の文字を表現できます。
以下のコードは、char型を使用してUnicode文字やサロゲートペアを扱う例です。
fn main() {
// 単一のUnicode文字の表現
let unicode_char = '😊'; // 笑顔の絵文字 (U+1F60A)
println!("Unicode char: {}", unicode_char);
// サロゲートペアの表現
let surrogate_pair = '\u{1F601}'; // 涙の絵文字 (U+1F601)
println!("Surrogate pair: {}", surrogate_pair);
// char型のサイズを取得
println!("Size of char: {} bytes", std::mem::size_of::());
}
実行結果:
Unicode char: 😊
Surrogate pair: 😁
Size of char: 4 bytes
ここでは、'😊' という絵文字や \u{1F601} というサロゲートペアを char型として表現しています。絵文字やサロゲートペアも正しく表示されることを確認できます。また、std::mem::size_of::() を使って char型のサイズを表示しています。
Rustには2つの主要な文字列型があります。
メモリ内のデータへの不変の参照を表します。
UTF-8でエンコードされた文字列を参照します。
文字列リテラルや他のデータ構造の一部として使用されます。
let string_slice: &str = "Hello, Rust!"; // 文字列リテラルから作成された文字列スライス
ヒープ上に確保された可変の文字列データを持ちます。
let mut string_object = String::from("Hello"); // String型のインスタンスを生成
string_object.push_str(", Rust!"); // 文字列を追加
これらの型は互いに相互変換できます。例えば、&strからStringへの変換はto_string()メソッドを使用できます。
let my_string: String = "Hello".to_string(); // &strからStringへの変換
また、Stringから&strへの変換は、&演算子を使用して参照を取得します。
let my_string: String = String::from("Hello");
let string_ref: &str = &my_string; // Stringから&strへの変換
文字列操作に関しては、String型が動的に変更可能で柔軟性があり、&str型は主に静的な文字列の参照として使用されます。
様々な文字列リテラル
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=9c41862df3833ee7bd16169631d74de7 string.rs]:
fn main() {
println!("{:?}", "hello"); // エスケープされた文字列
println!("{:?}", r#"hello"#); // エスケープされないraw文字列
println!("{:?}", b"hello"); // エスケープされたバイト文字列
println!("{:?}", br#"hello"#); // エスケープされないrawバイト文字列
}
実行結果:
"hello"
"hello"
[104, 101, 108, 108, 111]
[104, 101, 108, 108, 111]
"{:?}" はデバッグ用のフォーマット指定子で、デバッグ表示用の形式で出力します。
r#"..."# はエスケープされない raw 文字列リテラルで、内部のエスケープが無視されます。
b"..." はバイト文字列リテラルで、ASCII文字のバイト値の配列を示します。
br#"..."# はエスケープされない raw バイト文字列リテラルです。
これらのリテラルは、異なる用途で利用されることがあり、それぞれの特性や振る舞いが異なります。
Rustにおけるユニット型は()で表されます。ユニット型は特別な型であり、単一の値 () だけから成り立ちます。主に2つの用途があります：
fn do_something() {
// 何らかの処理
}
fn main() {
let result = do_something(); // 戻り値は () になる
println!("result = {:?}", result);
}
struct MarkerUnit;
fn main() {
let marker = MarkerUnit; // ユニット型を持つ構造体のインスタンス化
println!("marker = {:?}", marker);
}
ユニット型は一見すると何も持たない型ですが、プログラムの構造を表現するために重要な役割を果たしています。特に関数の戻り値として使用されることが多いです。
複合型(''Compound Types'')は、複数の値を1つの型にまとめることができます。
Rustにはタプルとアレイという2つのプリミティブな複合型があります。
タプル(''The Tuple'')は、さまざまな型の値を1つの複合型にまとめる一般的な方法です。
タプルの長さは固定されており、一度宣言すると大きくしたり小さくしたりすることはできません。
複数の値の集まりを持つもう一つの方法として、配列(''The Array'')があります。
タプルとは異なり、配列の各要素は同じ型でなければなりません。
Rustの配列は、タプルと同じく長さが固定されています。
println! マクロなどの文字表示マクロでは、文字列中の { } の位置に指定された書式で展開します[https://doc.rust-lang.org/std/fmt/ Module std::fmt]。
C言語の標準関数 printf() と機能は似ていますが書式は大きく異なり、Pythonのf文字列との共通点が多いです。
のプレースホルダー{}を指定すればその型の自然なフォーマット（[https://doc.rust-lang.org/std/fmt/trait.Display.html fmt::Display]; 100 ならば "100"）で文字列化されます。
しかし、基数を変えた16進数や8進数や2進数などでフォーマットをしたいときはフォーマッティング・トレイツ(Formatting traits)を使います[https://doc.rust-lang.org/std/fmt/#formatting-traits Formatting traits]。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=81cb5a55fcae676c094f2b74929f09b3 Formatting traits]:
fn main() {
println!("{:?}", 100);
println!("{:x}", 100);
println!("{:o}", 100);
println!("{:b}", 100);
println!("{}", 100);
}
実行結果:
100
64
144
1100100
100
フォーマッティング・トレイツは、Rustプログラミング言語におけるデータのフォーマット（整形）方法を定義するためのトレイト（trait）です。これらのトレイトは、std::fmtモジュールに定義されており、std::fmt::Displayやstd::fmt::Debugなど、様々なフォーマット方法を提供します。
一般的なフォーマッティング・トレイツは以下のようになります：
Display: std::fmt::Displayトレイトは、{}（中括弧）を使ったシンプルな人間が読みやすい形式での表示を提供します。これは、println!マクロやformat!マクロで使われます。
Debug: std::fmt::Debugトレイトは、{:?}を使ったデバッグ目的の表示を提供します。これは、デバッグ情報を表示する際に便利で、println!("{:?}", variable)のように使用されます。
Binary: std::fmt::Binaryトレイトは、{:#b}を使ってバイナリ表現での表示を提供します。
Octal: std::fmt::Octalトレイトは、{:#o}を使って8進数表現での表示を提供します。
LowerHex / UpperHex: std::fmt::LowerHexおよびstd::fmt::UpperHexトレイトは、それぞれ{:#x}および{:#X}を使って16進数表現での表示を提供します。
これらのトレイトは、カスタム型をフォーマットする方法を指定するために、対応するメソッドを実装することで利用されます。
例えば、Displayトレイトを実装することで、自分で定義した型を{}を使って表示することができます。
以下は、簡単な構造体PersonにDisplayトレイトを実装して、{}を使ってカスタム型を表示する例です。
use std::fmt;
// 構造体を定義
struct Person {
name: String,
age: u32,
}
// Displayトレイトの実装
impl fmt::Display for Person {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// カスタムフォーマットを定義する
write!(f, "Name: {}, Age: {}", self.name, self.age)
}
}
fn main() {
let person = Person {
name: String::from("Alice"),
age: 30,
};
// {}を使ってPerson型を表示
println!("Person Details: {}", person);
}
実行結果:
Person Details: Name: Alice, Age: 30
この例では、Personという構造体を定義し、fmt::Displayトレイトを実装しています。fmtモジュール内のFormatter型を利用して、write!マクロを呼び出しています。main関数内でprintln!マクロを使ってPerson型を表示しています。これにより、Person型を{}を使って表示する方法が示されています。
Rustの所有概念や借用、参照などは、安全性と並行性を重視したユニークな特徴を持っています。それぞれの概念をコードとともに解説してみましょう。
Rustの所有概念は、言語の中核的な概念であり、メモリ管理とリソースの安全な取り扱いを実現するための重要な要素です。所有概念は、変数がリソースの所有権を持ち、そのリソースはスコープを抜ける際に自動的に解放されるという原則に基づいています。
Rustのコピーとムーブの動作は、変数がスタック上のデータかヒープ上のデータを参照しているかによって異なります。プリミティブ型のようなスタック上のデータはコピーされますが、ヒープ上のデータは所有権がムーブされます。
コピー可能なデータ
fn main() {
let x = 5;
let y = x; // xの値がコピーされる（コピー）
println!("x: {}, y: {}", x, y); // 正常に出力される
}
この例では、xは整数型（i32）などのプリミティブ型で、スタック上に格納されます。xの値は単純なコピーが作成され、yにも同じ値が代入されます。そのため、両方の変数を利用できます。
ムーブされるデータ
fn main() {
let s1 = String::from("Hello");
let s2 = s1; // s1の所有権がs2に移動（ムーブ）
// println!("{}", s1); // コンパイルエラー！所有権が移動したためs1は利用できない
println!("{}", s2); // 正常に出力される
}
この例では、String::from("Hello")で作成した文字列はヒープ上にあり、s1の所有権はs2にムーブされます。そのため、s1を参照しようとするとコンパイルエラーが発生しますが、s2は正常に出力できます。
この違いは、スタック上のデータの単純なコピーと、ヒープ上のデータの所有権のムーブの挙動に起因しています。スタック上のデータは安価にコピーできますが、ヒープ上のデータは所有権が移動されます。
理解を助けるために、コピーとムーブの違いを表にまとめてみましょう。
コピー（Copy）: スタック上に配置されるデータや、Copyトレイトを実装した型のデータは、単純な代入などでコピーされます。元の変数が保持する値が複製され、両方の変数が別々の値を持ちます。
ムーブ（Move）: ヒープ上に配置されるデータや、Copyトレイトを実装していない型のデータは、所有権がムーブされます。変数間での代入などで、所有権が移動された後は、元の変数はその値を参照できなくなります。
これらの違いは、Rustの所有概念において重要です。特に、ムーブによってデータの所有権が移動することで、メモリ安全性と競合を回避することが可能になります。
所有権を移動させずにデータを利用するために、借用と参照が利用されます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=91624181f640bfff93914d318547bfae 借用と参照の例]:
fn main() {
let s1 = String::from("Hello");
// s1を借用する（イミュータブルな参照）
let len = calculate_length(&s1);
println!("The length of '{}' is {}.", s1, len); // 正常に出力される
}
fn calculate_length(s: &String) -> usize {
s.len() // sを参照して長さを返す
}
calculate_length関数では、&String型の引数を受け取り、Stringへの参照（イミュータブルな参照）を使用しています。そのため、s1の所有権を関数に渡すことなく、値を参照しています。
また、ミュータブルな参照を使って可変の値を変更できます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=1ef888bfe58461858b4cefe84d3b6fa6 ミュータブルな参照の例]:
fn main() {
let mut s = String::from("Hello");
change_string(&mut s);
println!("{}", s); // "Hello, goodbye"が出力される
}
fn change_string(s: &mut String) {
s.push_str(", goodbye");
}
&mut String型のミュータブルな参照を使って、change_string関数で文字列を変更しています。
これらのコード例は、Rustの所有概念や借用、参照についての基本的な概念を示しています。これらの機能は、安全性と並行性を強調したプログラミングを実現するための強力なツールです。
関数のパラメータに渡された変数は、所有権（Ownership）がその関数にムーブ（Move）されることがRustの所有権システムにおいて基本的な挙動です。このことを以下のコードを用いて詳しく説明しましょう。
fn main() {
let original = String::from("Hello, Rust!"); // String型の変数originalを作成
let moved = move_ownership(original); // originalがmove_ownership関数にムーブ
// コンパイルエラー! originalはもう有効でない
println!("original: {}", original);
// 正常に動作! movedはmove_ownership関数から返された値
println!("moved: {}", moved);
}
fn move_ownership(input: String) -> String {
// inputの処理を行う（ここでは何もしない）
input
}
このコードで示されているポイントは以下です：
main 関数内で、 String 型の変数 original を生成し、その所有権を保持しています。
move_ownership 関数を呼び出す際、変数 original が関数の引数として渡されます。このとき、original の所有権は move_ownership 関数にムーブされ、もはや main 関数内で original を使用することはできません。
move_ownership 関数内で、input パラメータ（ここでは String 型）の処理が行われ、その値が input を含むスコープからムーブされずに、move_ownership 関数から返されます。
main 関数内で、original を使用しようとすると、コンパイルエラーが発生します。それに対して、moved 変数は move_ownership 関数から返された値であり、その所有権はムーブされていないため、正常に使用できます。
この挙動は、Rustの所有権システムの一部であり、変数を関数に渡すと、所有権がムーブされることで、データ競合や予測不能な挙動を防ぐのに役立ちます。つまり、Rustはコピーが高コストなデータ（例: String やファイルハンドル）の二重所有権を防ぎ、メモリ安全性を確保するために所有権のムーブを使用します。
所有権を共有するために、cloneメソッドを使用してデータの複製を作成できます。
この複製は新しい所有者を持ち、元のデータを変更しても影響を受けません。
fn main() {
let data1 = vec![1, 2, 3];
let data2 = data1.clone(); // データの複製
println!("{:?}", data1); // data1は所有権を保持
println!("{:?}", data2); // data2も所有権を持つ
}
{{コラム|Rustの所有権システムについてのまとめ|2=Rustの所有権システムは、言語の最も特徴的な概念の一つで、メモリ管理とプログラムの安全性を向上させる役割を果たします。
各値は所有者（Owner）を持ちます。
各値はいつかは所有者からスコープを抜けて消去されます。
各値の所有権は、1つの所有者にしか属しません。
所有権は値の転送として理解され、変数の代入時に所有権が移動します。これにより、元の変数は無効になり、新しい変数が所有権を持つことになります。
cloneメソッドを使用してデータのコピーを作成し、所有権を共有できます。これにより、複数の変数が同じデータを持つことが可能となります。
所有権を譲渡せずにデータにアクセスするための仕組みで、不変な借用（immutable borrowing）と可変な借用（mutable borrowing）があります。借用は所有権を一時的に保持し、データへのアクセスを提供します。
関数に値を渡すと、所有権が関数にムーブされます。関数が所有権を持つと、元の変数は無効になり、関数内で変数を使用できます。これにより、データの複製やコピーを回避できます。
所有権システムはメモリ安全性と競合の防止に役立ち、コンパイル時のエラーを通じてプログラムの安全性を確保します。データ競合やメモリリークを防ぎ、プログラマに信頼性の高いコードを書かせます。
所有権システムと関連するライフタイムの概念は、借用や参照のスコープを制御し、メモリリークを防止します。ライフタイム注釈（lifetime annotations）を使用して、データの有効な範囲を指定します。
Rustの所有権システムは、高度なメモリ管理とプログラムの安全性を提供し、プログラマに信頼性の高いシステムソフトウェアを開発する手助けをします。一度理解するのに時間がかかるかもしれませんが、その代償として、高いレベルのセキュリティとパフォーマンスを得ることができます。
Rustの変数の識別子（Identifier）について説明します。識別子は変数、関数、モジュール、および他のRustプログラムの要素に名前を付けるために使用される名前です。
Rustの識別子にはいくつかの規則があります：
識別子はアルファベット、数字、アンダースコア（_）の組み合わせからなります。
識別子はアルファベット（大文字または小文字）またはアンダースコアで始まる必要があります。数字で始まることはできません。
識別子はキーワード（予約語）として定義されている単語を使用できません。たとえば、let、fn、match などのキーワードは識別子として使用できません。
識別子は大文字と小文字を区別します。つまり、my_variable と My_Variable は異なる識別子です。
一般的な識別子の例:
Rustの識別子はわかりやすく、意味のある名前を使うことが推奨されます。また、Rustのコーディング規約に従うことも重要です。識別子はプログラムの可読性と保守性に影響を与えるため、適切な名前を選択することが重要です。
Rustにおいて、スコープ（Scope）は変数やリソースの有効な範囲を指します。スコープ内で定義された変数は、そのスコープ内でのみアクセス可能であり、スコープを抜けると変数は自動的に解放されます。スコープの概念は、メモリリークや予期しない副作用を防ぐために非常に重要です。
Rustには主にブロックスコープと関数スコープの2つのタイプのスコープがあります。
ブロックスコープは、一連のコードが中括弧 {} で囲まれた場合に発生します。中括弧内の変数は、そのブロックスコープ内でのみ有効です。
以下はブロックスコープの例です：
fn main() {
let outer_variable = 42;
{
let inner_variable = 10;
println!("inner_variable: {}", inner_variable);
} // inner_variableのスコープはここで終了
// inner_variableにはアクセスできない
// println!("inner_variable: {}", inner_variable);
println!("outer_variable: {}", outer_variable);
}
この例では、inner_variable は中括弧内でのみ有効であり、外部からアクセスできません。しかし、outer_variable は中括弧の外部でもアクセス可能です。
関数スコープは、関数内で定義された変数がその関数内でのみ有効であることを示します。
以下は関数スコープの例です：
fn main() {
let outer_variable = 42;
fn inner_function() {
let function_variable = 5;
println!("function_variable: {}", function_variable);
}
inner_function(); // inner_function内での変数にアクセスできる
// function_variableにはアクセスできない
// println!("function_variable: {}", function_variable);
println!("outer_variable: {}", outer_variable);
}
function_variable は inner_function 内でのみ有効で、inner_functionを呼び出すことでアクセスできます。
Rustの所有権システムは、スコープと密接に関連しています。変数が特定のスコープ内で有効である場合、そのスコープを抜けると変数の所有権は無効になります。これにより、リソースの安全な解放が保証され、メモリリークやダングリングポインタの問題が回避されます。
スコープと所有権の組み合わせは、Rustのプログラムの安全性と信頼性を高める重要な要素です。スコープをうまく活用し、不要な変数の寿命を短くしてリソースを効率的に管理できるようにしましょう。
Rustのライフタイムは、Dangling Reference（無効な参照）を防ぐための重要な概念です。これは、参照が有効なデータを参照している間、そのデータが存在していることを保証するために導入されています。
Rustのライフタイムは、参照が指すデータが存在するスコープを表現し、コンパイラによって所有権やライフタイムのルールに違反しないように検証されます。これにより、コンパイラがコードを解析し、参照が有効な間のみデータにアクセスできることを保証します。
Dangling Referenceは、プログラムが無効なメモリ領域を参照しようとすることで発生する問題です。例えば、参照が指すデータがスコープを抜けた後に破棄されてしまった場合、その参照は無効なものとなります。Rustのライフタイムは、このような問題を静的に（コンパイル時に）検出し、Dangling Referenceを防ぐための仕組みとして機能します。
ライフタイムの概念により、コンパイラは参照の寿命をトラッキングし、参照が有効なデータを参照していることを保証します。これにより、実行時にDangling Referenceが発生する可能性を排除し、メモリの安全性を確保します。
ライフタイムを使用してDangling Referenceを回避する例を示します。以下の例では、ライフタイムを使用して参照が有効な間のみデータにアクセスできるように制御しています。
struct MyStruct<'a> {
data: &'a str,
}
fn main() {
let string_data = String::from("Hello, Rust!");
{
let my_struct; // my_structのスコープを新たに定義
{
// `string_data`の参照を`MyStruct`に渡す
my_struct = MyStruct { data: &string_data };
// `my_struct`が有効なスコープ内でデータを表示
println!("{}", my_struct.data);
} // ここで`my_struct`のスコープが終了する
// この時点で`my_struct`の参照はスコープ外になるため、
// `string_data`が無効になる前に`my_struct`が使用されることはない
} // `string_data`のスコープが終了する
// ここで`string_data`はスコープ外になる
// したがって、`my_struct`の参照も同時に無効になる
}
この例では、MyStructにstring_dataへの参照を渡し、my_structが有効なスコープ内でデータを使用しています。その後、my_structが有効なスコープを抜ける前にstring_dataのスコープが終了するため、Dangling Referenceが発生することはありません。
Rustのライフタイムシステムは、このようにスコープと参照の寿命をトラッキングし、参照が有効な間のみデータへのアクセスを許可します。これにより、Dangling Referenceをコンパイル時に防ぐことができます。
有効性の保証: ライフタイムは、参照が有効である期間を定義します。これにより、コンパイラは参照が無効化されたり、有効でないメモリを参照しようとする問題を検知できます。
参照のスコープ: ライフタイムは、参照が使用可能なスコープを定義します。参照はそのスコープ内でのみ有効であり、スコープ外では無効になります。
引数や返り値: 関数の引数や返り値にライフタイム注釈を追加することで、参照の有効期間を示します。
構造体とメソッド: 構造体やメソッドの定義でライフタイムを使うことがあります。特に、参照を持つ構造体の定義においてライフタイムは重要です。
struct MyStruct<'a> {
data: &'a str,
}
impl<'a> MyStruct<'a> {
fn get_data(&self) -> &'a str {
self.data
}
}
Rustでは、ライフタイムの一部は省略されることがあります。コンパイラが推論可能な場合は、ライフタイムの注釈を省略できます。ただし、省略ルールには厳密な規則があります。
'staticはプログラム全体のライフタイムを示します。プログラムの実行中に常に存在し続けるデータやリソースに使用されます。
static GLOBAL_VALUE: i32 = 100;
fn main() {
let local_value: &'static i32 = &GLOBAL_VALUE;
}
ライフタイムはRustの主要な安全性の一部であり、メモリ安全性を保証するための強力なツールです。適切に理解して利用することで、メモリリークや無効な参照による問題を防ぐことができます。
スコープは、Rustにおけるライフタイム概念に密接に関連しています。ライフタイムは基本的には参照の有効期間を表し、その有効期間はスコープによって定義されます。
スコープ: コード内の特定の部分で変数が有効である期間を示します。変数がスコープに入ると有効になり、スコープを抜けると無効になります。スコープは波括弧 {} で囲まれたブロックや、関数の本体などで定義されます。
{
let variable = 10; // 変数のスコープ開始
// ... ここで variable が有効 ...
} // 変数のスコープ終了
ライフタイム: 参照が有効な期間を示します。変数への参照を作成する際にそのライフタイムが重要になります。参照はそのライフタイム内でのみ有効であり、スコープを抜けると無効になります。
fn print_string(s: &str) {
println!("{}", s);
}
fn main() {
let string = String::from("Hello");
print_string(&string); // string の参照が関数のスコープ内で有効
} // string のスコープ終了、参照も無効になる
ライフタイムとスコープは互いに関連しており、変数が有効な期間がスコープによって定義されると、その変数への参照の有効期間も同様にスコープによって制限されます。このようにして、Rustのコンパイラは参照の有効性を追跡し、安全性を確保します。
所有権とライフタイムは、Rustのメモリ管理における重要な概念ですが、やや異なる側面を持っています。
所有権:
Rustの所有権システムは、変数に対するデータの所有権を定義します。変数が特定のデータを所有している場合、その変数がスコープを抜けるとデータも解放されます。
所有権ルールにより、特定のデータは同時に複数の所有者を持つことができません。一つのデータに対する所有権は一つの変数にしか与えられません。
fn main() {
let s1 = String::from("Hello");
let s2 = s1; // s1の所有権がs2にムーブ（転送）される
// s1は所有権を失い、スコープを抜けることができる
println!("{}", s2); // s2は有効
} // s2のスコープ終了、s2の所有権が終了しデータが解放される
ライフタイム:
ライフタイムは、参照が有効である期間を示します。参照はそのライフタイム内でのみ有効であり、スコープ外では無効になります。
所有権とライフタイムは密接に関連しており、所有権が終了した後は、そのデータへの参照も無効になります。
fn print_string(s: &str) {
println!("{}", s);
}
fn main() {
let string = String::from("Hello");
print_string(&string); // stringの参照が関数のスコープ内で有効
} // stringのスコープ終了、参照も無効になる
所有権とライフタイムは共に、Rustがメモリの安全性を確保するための要素です。所有権システムはメモリの解放を自動的に行い、ライフタイムは参照の有効性を管理し、無効な参照が存在しないようにします。両者が組み合わさることで、Rustはメモリリークやダングリングポインタ（無効な参照）を防止し、安全で信頼性の高いコードを作成することができます。
などの制御構造も式です。
Rust は、if と match の2つの分岐構文を持ちます。
ifは、条件式に基づき分岐し、分岐先の式を評価します。
ifの値は、分岐先の式の値です。
elseを省略し条件式が偽であった場合のifの値は () です。
構文:
if-expr := if 条件式 '{' 式1 '}' [ else '{' 式2 ] '}'
fn main() {
let i = 0;
if i {
println!("zero");
}
}
error[E0308]: mismatched types
--> src/main.rs:4:8
|
4 | if i {
| ^ expected `bool`, found integer
For more information about this error, try `rustc --explain E0308`.
Rustでは、ifに限らず、条件式は、bool 型でなければいけません。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=2c8960df447a87aaeaecced963d20cde if.rs]:
fn main() {
let i = 0;
if i == 0 {
println!("零");
} else {
println!("非零");
}
let s = if i == 0 {
"ゼロ"
} else {
"非ゼロ"
};
println!("{}", s);
}
実行結果:
零
ゼロ
気をつけたいのは、式の値が参照されるifでは、それぞれの式（ここでは "ゼロ" と "非ゼロ"）にセミコロン ; を付けてはいけない点です。
もし セミコロン ; をつけると、ブロックの値は、Unit 型 () になります。
ifの、分岐先の2つの式の型は同じでなければいけません。
else節が省略された場合は、Unit 型を返さなければいけません。
式の最後に、セミコロン}; が必要ということですC言語系では、式を文にする為いに}; が必要です。Rustもそう説明されている場合がありますが、Rustでは式の型の一致が目的です。。
また、let s = if i == 0 {の文末の}; のセミコロンも忘れがちです。
Rust では if に限らず、コードブロックは式の一種で値を返しますコードブロックが値を持つプログラミング言語としては、BCPL, Ruby, ScalaやKotlinがあります。。その場合、コードブロックの最後の式がコードブロックの値となりセミコロン ; は不要で、もし、 ; をつけると ; の次の式（＝空文）の値 () がコードブロックの値になります。
この特徴は、関数型プログラミングを意識したものですが、同時に後に説明する所有権の移譲で重要な役割を果たします。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=e3c9a903bc6baab687f697a83bde8928 if-else.rs]:
fn main() {
let n = 0.0 / 0.0;
if n < 0.0 {
println!("負の数");
} else if n > 0.0 {
println!("正の数");
} else if n == 0.0 {
println!("零");
} else {
println!("{n}");
}
}
実行結果:
NaN
このコードの中で、次のことが行われています：
n に NaN（Not a Number）を代入しています。0.0 / 0.0 は浮動小数点数のゼロで割り算を表し、NaN を返します。
if 文で n の値に応じて条件分岐しています。
n が負の数より小さい場合は、"負の数" と出力します。
n が正の数より大きい場合は、"正の数" と出力します。
n がゼロと等しい場合は、"零" と出力します。
それ以外の場合は、n の値を {n} という形式で出力します。
しかし、Rustの浮動小数点数型では、NaN は < や > 、== などの比較演算子によって、他の数値との大小や等価性を比較することはできません。なぜなら NaN は "not a number" であり、数値としての大小関係が定義されていないためです。
そのため、このコードでは n が NaN である場合、どの条件にも合致せず、最後の else ブロックが実行されることになります。このブロックでは、n の値そのものを {n} という形式で出力しようとしています。
Rustでは、C言語のNULLに相当する値は None です。
通常の変数は None の代入は受付けませんが、Some() を使うと None を取り得る変数が宣言できます[https://doc.rust-lang.org/stable/std/option/enum.Option.html Option in std::option - Rust]。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=afb9193c50a316090b6e3119f994f8cf some.rs]:
fn main() {
let mut x = Some(0);
println!("{:?}({})", x, type_of(x));
x = None;
println!("{:?}({})", x, type_of(x));
}
fn type_of(_: T) -> &'static str {
std::any::type_name::()
}
実行結果:
Some(0)(core::option::Option)
None(core::option::Option)
Some() 及び None は、標準ライブラリ std::option で定義されていますが、初期化済みなので Use することなく、接頭辞Option::なしで使えます。
Rustには、if letという特別な制御構造があります。if letは、match式を簡略化するために使用されます。if let式は、単一のパターンを使用して、変数が指定された値にマッチした場合にのみ式を実行します。if letを使用すると、冗長なマッチングのコードを削減できます。
以下は、if letを使用した例です。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=0614af1127dbc6ec0d871443b16e6a67 if-let.rs]:
fn main() {
let mut v = vec![2, 3, 5];
if let Some(x) = v.pop() {
println!("x = {}", x)
} else {
println!("done!")
}
if let Some(x) = v.pop() {
println!("x = {}", x)
} else {
println!("done!")
}
if let Some(x) = v.pop() {
println!("x = {}", x)
} else {
println!("done!")
}
if let Some(x) = v.pop() {
println!("x = {}", x)
} else {
println!("done!")
}
if let Some(x) = v.pop() {
println!("x = {}", x)
} else {
println!("done!")
}
}
実行結果:
x = 5
x = 3
x = 2
done!
done!
.pop()メソッドは、ベクターから最後の要素を取り出し、それを返します。ただし、ベクターが空である場合はNoneを返します。
最初の行では、vec![2, 3, 5]という3つの要素を持つベクターを作成しています。
その後、5回のif let式を使用して、ベクターから要素を取り出し、それを表示するか、ベクターが空の場合にはdone!と表示します。
各if let式では、変数xを定義しています。
v.pop()の返り値がSomeであれば、ベクターの最後の要素が変数xに束縛され、println!マクロを使用してxを表示します。
そうでない場合、すなわち、ベクターが空である場合は、else節が実行されて、done!が表示されます。
Rustにおけるmatchは、値が複数のパターンのいずれかにマッチする場合に、それぞれに対応する処理を実行する制御構文です。構文は以下の通りです。
構文:
match_expr ::= 'match' expr '{' match_arm* '}'
match_arm ::= pattern '=>' expr (',' | ';')?
pattern ::= '_' | literal | identifier | ref_pattern | mut_pattern | struct_pattern | tuple_pattern | range_pattern | slice_pattern | box_pattern | '(' pattern '|' pattern ')' | '&' pattern | '@' pattern | refutable_pattern
ref_pattern ::= '&' (mut)? identifier
mut_pattern ::= 'mut'? identifier
struct_pattern ::= path '{' field_pattern (',' field_pattern)* ','? '}'
field_pattern ::= identifier ':' pattern
tuple_pattern ::= '(' (pattern (',' pattern)*)? ')'
range_pattern ::= literal '..' literal
slice_pattern ::= '[' (pattern (',' pattern)* ','?)? ']'
box_pattern ::= 'box' pattern
refutable_pattern ::= pattern ('@' identifier)?
ここで、exprは任意の式を表し、literalはリテラルを表します。また、pathはパスを表し、identifierは識別子を表します。mutはミュータビリティを表し、','と';'はそれぞれ,と;を表します。|はOR演算子を表し、'&'は参照を表し、'@'はパターンの変数名を表します。また、refutable_patternはマッチングが失敗する可能性のあるパターンを表します。
パターンは様々なものを指定することができますが、ここではいくつか代表的なものを説明します。
値を直接指定する: 3のように、具体的な値を指定します。
ワイルドカードを使う: _のように、どの値にもマッチするパターンです。
変数をバインドする: xのように、パターンに変数を書くことで、マッチした値を変数に束縛することができます。
ガード条件を指定する: x if x > 0のように、マッチした値に対して条件を指定することができます。
以下に、具体的な例を示します。
コード例:
let x = 42;
match x {
0 => println!("zero"),
1 => println!("one"),
2..=10 => println!("two to ten"),
_ => println!("something else"),
}
let mut v = vec![1, 2, 3];
match v.pop() {
Some(x) => println!("popped value: {}", x),
None => println!("no value"),
}
let x = Some(42);
match x {
Some(y) if y > 0 => println!("positive value: {}", y),
Some(_) => println!("zero or negative value"),
None => println!("no value"),
}
実行結果:
最初の例は、変数xに対してmatch式を使用して、xが異なる値を持つ場合に異なる処理を実行する方法を示しています。xが0の場合、println!("zero")が実行されます。同様に、xが1の場合、println!("one")が実行され、xが2から10までの範囲にある場合、println!("two to ten")が実行されます。それ以外の場合は、println!("something else")が実行されます。この例では、_はワイルドカードパターンとして使用され、どの値にも一致するようになっています。
2番目の例は、match式を使用して、vecの最後の値を取得する方法を示しています。v.pop()がSome(x)を返す場合、println!("popped value: {}", x)が実行され、Noneを返す場合は、println!("no value")が実行されます。
3番目の例では、match式を使用して、Option型の値に対してパターンマッチングを行う方法を示しています。xがSome(y)を返し、yが0より大きい場合、println!("positive value: {}", y)が実行されます。yが0以下の場合、println!("zero or negative value")が実行されます。また、xがNoneの場合、println!("no value")が実行されます。この例では、ifを使用して、Some(y)の条件を更に厳密化しています。この機能をガードと呼びます。
C言語のswitch文と異なり、Rustのmatch式は、すべてのパターンをカバーしていない場合は、コンパイル時に警告を出します。これにより、プログラムにエラーが含まれている可能性がある場合に、それを事前に検出することができます。
Rustには、以下のような反復構文があります。
それぞれの構文について、詳しく解説していきます。
Rust の for は、指定された範囲内の値を反復処理するために使用されます。通常、配列、ベクトル、範囲、またはイテレータなどの反復可能オブジェクトに対して使用されます。
構文:
for_expression = "for" loop_variable "in" expression "{" statement* "}";
loop_variable = pattern;
expression = (expression_binop | expression_unop | expression) ;
pattern = identifier | "_" | literal ;
for_expressionはforループを表し、 loop_variableは反復処理のために使用される変数、 expressionは反復処理の対象となるデータのソース、 statementはループ内で実行される文を表します。 patternは、ループ変数の型と一致するパターンを表します。
identifierは、識別子の名前を表します。 literalは、文字列、数値、真偽値などのリテラル値を表します。
forループは、 loop_variableによって定義された変数に expressionで指定されたデータソースの値を順番に割り当て、それぞれの値に対して statementを実行します。
identifierは識別子を、literalはリテラルをしめします。
Rustにおけるrangeは、範囲を表す型です。範囲の生成には2つの主要な方法があります。
..（半開区間）
start..endの形式で使用され、startからendの手前（endは含まれない）までの範囲を生成します。
例えば、1..5は1から4までの範囲を生成します。
..= （閉区間）
start..=endの形式で使用され、startからendまでの閉区間を生成します（endも含まれます）。
例えば、1..=5は1から5までの範囲を生成します。
これらの範囲はforループの反復やイテレータの作成など、さまざまな場面で使用されます。例えば、forループやイテレータを使って範囲内の要素を処理することができます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=a3cd190fbd860ce8efb0d6276fb0858a for-in-range.rs]:
fn main() {
// 半開区間の使用例
for i in 1..5 {
println!("{i}"); // 1, 2, 3, 4が出力される
}
// 閉区間の使用例
for i in 1..=5 {
println!("{i}"); // 1, 2, 3, 4, 5が出力される
}
}
範囲は整数や文字など、多くの型で使用できます。範囲の使用はイテレーションや特定の範囲内の操作を行う際に便利です。
Rustにおけるiter()は、コレクション（ベクター、配列、ハッシュマップなど）をイテレート可能な形に変換するメソッドです。イテレータは、コレクション内の要素を1つずつ処理するための仕組みを提供します。
基本的な使い方は以下のようになります:
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=d45c8c0ad55adb01e50456dd7270983c iter.rs]:
fn main() {
let vec = vec![1, 2, 3, 4, 5];
// ベクターのイテレータを作成する
let mut iter = vec.iter();
// イテレータを使って要素に順番にアクセスする
while let Some(value) = iter.next() {
println!("{value}");
}
}
実行結果:
1
2
3
4
5
iter()メソッドは、イテレータを作成するための最も基本的な手段ですが、さまざまな応用もあります。
.map(): イテレータを他の形に変換する場合に使われます。たとえば、各要素に対して関数を適用して新しいイテレータを作成します。
fn main() {
let vec = vec![1, 2, 3, 4, 5];
// 各要素を2倍する新しいイテレータを作成する
let doubled_iter = vec.iter().map(|x| x * 2);
for value in doubled_iter {
println!("{value}");
}
}
.filter(): 条件に一致する要素のみを含む新しいイテレータを作成します。
fn main() {
let vec = vec![1, 2, 3, 4, 5];
// 偶数の要素だけを含む新しいイテレータを作成する
let even_iter = vec.iter().filter(|&x| x % 2 == 0);
for value in even_iter {
println!("{value}");
}
}
.fold(): イテレータ内の要素を畳み込んで単一の値に集約します。
fn main() {
let vec = vec![1, 2, 3, 4, 5];
// 要素の合計を計算する
let sum = vec.iter().fold(0, |acc, &x| acc + x);
println!("合計: {sum}");
}
.reduce(): イテレータ内の要素を畳み込んで単一の値に集約します。
fn main() {
let vec = vec![1, 2, 3, 4, 5];
// 要素の合計を計算する
let sum = vec.into_iter().reduce(|acc, x| acc + x);
println!("合計: {:?}", sum);
}
これらはiter()を基盤として利用する機能の一部です。Rustのイテレータは非常に強力で、関数型プログラミングの概念を取り入れながら、効率的で安全なコードを記述するための重要な手段となっています。
iter()メソッドに加えて、rev()メソッドを使用すると、要素を逆順で取り出すこともできます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=83d50bb12645221a766052413a9d73b8 iter-rev.rs]:
fn main() {
let v = vec![1, 3, 5, 7, 11];
for x in v.iter().rev() {
println!("x = {}", x)
}
}
実行結果:
x = 11
x = 7
x = 5
x = 3
x = 1
このRustのコードは、 forループを使用して、ベクトル vの要素を反復処理し、各要素の値を出力するものです。ただし、 vの要素を逆順に処理します。
v.iter().rev()は、 vのイテレータを取得し、そのイテレータを逆順にするためのメソッドです。これにより、ベクトルの最後の要素から始まり、最初の要素まで逆順に反復処理します。
forループの本体では、 println!マクロを使用して、現在の xの値を表示しています。 {}はプレースホルダーであり、その場所に変数の値が挿入されます。この例では、 {}の中に xを指定して、ループの反復ごとに変化する xの値を表示しています。
enumerate()メソッドを使用すると、要素のインデックスと値を同時に取り出すこともできます。
コード例:
let v = vec![1, 2, 3];
for (i, val) in v.iter().enumerate() {
println!("{}: {}", i, val);
}
このコードでは、v.iter().enumerate()メソッドを使用して、vのイテレータを作成し、各要素のインデックスと値を同時に反復処理しています。forループの本体では、変数iを使ってインデックス、valを使って値を表示しています。
zip()メソッドを使用すると、複数のイテレータを同時に取り出すことができます。
コード例:
let v1 = vec![1, 2, 3];
let v2 = vec!["one", "two", "three"];
for (i, val) in v1.iter().zip(v2.iter()) {
println!("{}: {}", i, val);
}
このコードは、zip()メソッドを使用して、2つのベクトルを同時に反復処理する方法を示しています。
最初の行で、整数のベクトルv1と文字列のベクトルv2を定義しています。
次に、forループを使用して、v1.iter()とv2.iter()のイテレータを同時に取り出します。このとき、(i, val)というタプルの形式で、それぞれのイテレータから次の要素を取り出します。
println!マクロの中で、{}にiとvalをそれぞれ表示しています。{}の中にある:は区切り文字で、iとvalを区別するために使用されています。
Rustにおいて、whileは指定した条件式がtrueである限り、ブロック内のコードを繰返し実行する制御構文です。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=47dc5b7c9d866b3f5913a77b9a55988e while.rs]:
fn main() {
let mut i = 0;
while i < 5 {
println!("i = {}", i);
i += 1
};
}
実行結果:
i = 0
i = 1
i = 2
i = 3
i = 4
このプログラムは、0から4までの数字を順番に表示するプログラムです。whileループを使用して、条件式i < 5がtrueである間、ループを継続します。ループの各イテレーションでは、println！マクロを使用して、変数iの現在の値を表示します。iの値は、ループ本文の最後でi += 1によって1ずつ増加します。条件式i < 5がfalseになったとき、ループが終了します。最終的に、0から4までの数字が順番に表示されます。
Rustのwhile letは、ループ処理の一種で、パターンマッチングを行い、パターンにマッチする値をループ内で取り出しながらループを繰り返します。
while letは、match構文の糖衣構文で、一つの値を取り出してパターンマッチングを行い、パターンにマッチする場合は値を取り出し、マッチしない場合はループを終了します。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=0764d8389e3afc0854b4223b8db5a32b while-let.rs]:
fn main() {
let mut n = Some(0);
while let Some(i) = n {
n = if i > 5 {
None
} else {
println!("i = {}", i);
Some(i + 1)
}
}
}
実行結果:
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
このコードは、n という Option 型の変数を定義し、初期値を Some(0) として設定します。そして、while ループを使って n の値を取り出しながら、それが None でなければループを続けます。
while let の条件式では、n が Some(i) とパターンマッチされ、i に値がバインディングされます。このパターンマッチにより、n が Some(i) でなければループは終了します。
ループ本体では、i が 5 を超える場合は、n を None に更新してループを終了します。そうでなければ、i を表示して、Some(i + 1) を n に代入してループを継続します。
このプログラムの出力は、0 から 5 までの数値が順番に表示されます。最後に None が表示されます。
Rustのwhile letは、反復可能な値に対して、パターンマッチングを行いながら反復処理を行うことも出来ます。ベクトルに対してwhile letを使うと、ベクトルの末尾から要素を取り出しながら反復処理を行うことができます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=6b252d13f67df88f533e55dab5d3397c while-let-again.rs]:
fn main() {
let mut v = vec![1, 3, 5, 7, 11];
while let Some(x) = v.pop() {
println!("x = {}", x)
}
}
実行結果:
x = 11
x = 7
x = 5
x = 3
x = 1
このコードは、可変長配列vに値を追加し、whileループでその配列から値を取り出し、それを表示するものです。
まず、可変長配列vにvec![1, 3, 5, 7, 11]という値を設定しています。その後、while let式を使って、v.pop()の戻り値がSome(x)である限り、ループが継続されます。v.pop()は、vの最後の要素を取り出し、その要素があればSomeで包んで返し、なければNoneを返します。
while let式では、取り出した値がSome(x)である場合に、println!("x = {}", x)を実行してxの値を表示します。
つまり、このコードはvの末尾から要素を取り出しながら、取り出した要素の値を表示するという処理を続け、最後に配列が空になったらループを終了します。
{{コラム|Rustにdo-whileはありません|2=
Rustにdo-whileはありません。while の条件式に do のブロックを詰め込むことで同じことが実現できます。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=534d7cfaf805c7e8d99d4c1ba95ed3ab pseudo-do-while.rs]:
fn main() {
let mut i = 100;
while {
println!("{}", i);
i += 1;
i < 10
} {}
}
実行結果:
100
whileの条件式が省略されたかのように見えますが、4,5,6行目を含むブロックが、while の条件式となり値はブロックの最後の6行目の式の値です。
7行目の {} がループ本体です。
loopを使った例:
fn main() {
let mut i = 100;
loop {
println!("{}", i);
i += 1;
if !(i < 10) {
break;
}
}
}
loop のブロックの最後に脱出条件を書いた方がわかりやすいかもしれません。
loopは、明示的な条件式の指定がない限り、無限に繰り返されます。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=9349b3eff79e311c70c87d20942cf8f2 loop-and-break.rs]:
fn main() {
let mut i = 0;
let result = loop {
if i > 3 {
break 100;
}
println!("i = {}", i);
i += 1;
};
println!("result = {}", result);
}
実行結果:
i = 0
i = 1
i = 2
i = 3
result = 100
最初に、変数iを0に初期化します。そして、loop構文で、iが3より大きくなるまで繰り返します。
各反復中に、if文が使用されています。ifの条件式は、iが3より大きくなった場合にはbreak 100;が実行され、loopから脱出します。そうでない場合は、println!()関数を使用して、iの値を出力し、iを1増やします。
最後に、loopから脱出した後にresult変数に格納される値は、break文の引数で指定された100です。そして、println!()関数を使用して、resultの値を出力します。
つまり、このコードは、iを0から3まで順に増やしながら、各値を出力し、iが3より大きくなったら100を返し、その後にresultの値を出力するという処理を行っています。
continue を実行すると、ループのブロック内の残りの処理がスキップされ、反復処理が続行されます。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=49f7412cec92162b9d77881e08f43138 continue.rs]:
fn main() {
let mut i = 0;
let result = loop {
if i > 10 {
break 100;
}
if i % 2 == 0 {
i += 1;
continue;
}
println!("i = {}", i);
i += 1;
};
println!("result = {}", result);
}
実行結果:
i = 1
i = 3
i = 5
i = 7
i = 9
result = 100
このコードは、0から10までの奇数を出力するプログラムです。
まず、i変数を定義して0で初期化し、result変数を宣言しています。次に、loopキーワードでループを開始します。
ループ本体では、if文を使ってiが10より大きくなったら、breakキーワードを使ってループを抜けます。これにより、11以上の奇数が出力されることはありません。
次に、iが偶数である場合は、continueキーワードを使ってループの先頭に戻ります。これにより、偶数はスキップされます。
最後に、println!マクロを使って現在のiの値を出力し、iを1増やします。
ループが終了したら、最後にresultの値を出力します。breakキーワードが値を返すため、このループはresultに100を設定します。
{{コラム|Rustのプログラミングでつまづきやすいところ|2=Rustはセーフティ、パフォーマンス、そしてエクスプレッションの柔軟性を組み合わせた高度なプログラミング言語です。初めてRustを使う場合、以下のようなトピックでつまづくことがよくあります。
所有権と借用: Rustでは、各値には所有者があり、値のライフサイクルを追跡する必要があります。また、他のコードに値を渡すときは、その値を一時的に借りる必要があります。これらの概念が理解しづらい場合があります。
ライフタイム: Rustでは、各値にはライフタイムがあり、その値が使用される期間を決定します。ライフタイムの概念が不明瞭になりがちで、特に複雑なデータ構造を扱う場合に問題が発生することがあります。
パフォーマンスの最適化: Rustは高速な実行時パフォーマンスを提供しますが、それを達成するためには、手動でメモリ管理や最適化を行う必要があります。これらの最適化は、Rustの型システムと他の言語との違いを理解する必要があります。
コンパイラエラー: Rustのコンパイラは非常に厳格で、コードがコンパイルできない場合があります。エラーメッセージは詳細で役に立ちますが、初めて見た場合は驚くかもしれません。
本書では、これらのトピックについて順次取り上げてゆきます。
Rustのマクロは、macro_rules!を使ったマクロとproc_macroを使ったプロシージャマクロの2種類があります。macro_rules!を使ったマクロはパターンマッチングを用いて簡易的なマクロを定義します。一方、proc_macroを使ったプロシージャマクロは、Rustのコードを受け取り、変換したり、新しいコードを生成するためのより柔軟なマクロです。
macro_rules!は、パターンに基づいてマッチングし、そのパターンに一致した場合に指定されたコードを生成する簡易なマクロを定義します。
例えば、vec!マクロは、可変長のベクタを生成するマクロです。これはmacro_rules!を使って次のように実装されています。
macro_rules! vec {
// パターンマッチで要素を取得して新しいベクタを生成
( $( $x:expr ),* ) => {
{
let mut temp_vec = Vec::new();
$(temp_vec.push($x);)*
temp_vec
}
};
}
fn main() {
// `vec!`マクロを使ってベクタを生成
let my_vec = vec![1, 2, 3, 4];
// 生成されたベクタを表示
println!("{:?}", my_vec);
}
これは、vec![1, 2, 3]を使うと、[1, 2, 3]というベクタを生成します。このマクロは、$( $x:expr ),*のパターンに一致して、指定された式（$x）をベクタに挿入するコードを生成します。
macro_rules!を使わずにマクロを定義する方法もあります。これは、プロシージャマクロ（proc_macro）を使用した方法です。proc_macroは、macroキーワードによって定義される関数の一種で、Rustのコードを受け取り、そのコードを操作して変換することができます。
例えば、vec!マクロをmacro_rules!ではなく、プロシージャマクロとして定義する場合は、proc_macroを使います。
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Expr, parse_quote};
pub fn my_vec(input: TokenStream) -> TokenStream {
// 入力をパース
let input_expr: Expr = parse_macro_input!(input);
// 入力を取得して新しいベクタを生成するコードを生成
let expanded = quote! {
{
let mut temp_vec = Vec::new();
temp_vec.push(#input_expr);
temp_vec
}
};
// TokenStreamに変換して返す
TokenStream::from(expanded)
}
この例では、proc_macroとしてmy_vecという新しいマクロを定義しています。my_vecは、proc_macroの関数として定義され、Rustのコードを受け取り、それを操作して新しいコードを生成します。
このプロシージャマクロを使うと、次のようにマクロを呼び出すことができます。
fn main() {
let my_vec = my_vec!(42);
println!("{:?}", my_vec); // [42]
}
この例では、my_vec!マクロを使用して、引数として42を渡しています。このマクロは、引数を含むベクタを生成するもので、my_vec!(42)は[42]というベクタを生成します。
この方法では、proc_macroを使用して、macro_rules!を使わずに独自のマクロを定義できます。ただし、この方法ではproc_macroと関連するライブラリ（syn、quoteなど）を使用する必要があります。
マクロ関数は、macro_rules!マクロを使って定義されます。
これは、マクロのパターンとそれに対する置換を定義するマクロです。
マクロの呼び出し元は、パターンにマッチする式を渡し、置換が適用されたコードが生成されます。
マクロ関数の例:
macro_rules! say_hello {
() => {
println!("Hello, world!");
};
}
fn main() {
say_hello!();
}
実行結果:
Hello, world!
解説
上記の例では、say_hello!()マクロを定義しています。これは、空の引数リストに対してprintln!("Hello, world!")を生成するマクロです。
マクロ属性はRustのコンパイル時にコードを修飾するために使用されます。
通常は、関数や構造体、列挙型、フィールドなどに適用されます。
マクロ属性を使用することで、コンパイル時に生成されるコードに追加の情報を提供できます。
マクロ属性の例:
struct MyStruct {
my_field: i32,
}
fn main() {
let my_struct = MyStruct { my_field: 42 };
println!("{:?}", my_struct);
}
実行結果:
MyStruct { my_field: 42 }
解説
上記の例では、#[derive(Debug)]マクロ属性を使用しています。これは、MyStructにDebugトレイトを実装するために必要なコードを生成するマクロ属性です。println!マクロでmy_structを表示する際に、Debugトレイトのメソッドを呼び出して情報を表示することができます。
Rustのパッケージ単位: Rustでは、コードのパッケージングや再利用のために「クレート」(Crate)という単位が使われます。1つのクレートには、1つ以上の関連するモジュールやデータ型が含まれます。
Cargoによる管理: クレートは、RustのパッケージマネージャであるCargoによって管理されます。Cargoは、クレートの作成、ビルド、依存関係の解決などを自動化するツールです。
典型的なRustのクレートは、次のような構造を持ちます：
my_crate/
├── src/
│ ├── main.rs
│ ├── lib.rs
│ └── other_module.rs
├── Cargo.toml
└── README.md
src/: クレートのソースコードを含むディレクトリ。
src/main.rs: クレートを実行するためのエントリポイント。
src/lib.rs: ライブラリとしてコンパイルされる場合に使用されるエントリポイント。
src/other_module.rs: 他のモジュール。
Cargo.toml: クレートのメタデータ、依存関係、ビルド構成などを含むファイル。
README.md: クレートのドキュメント。
新しいクレートを作成する手順は以下の通りです：
cargo newコマンドを使用して新しいクレートのディレクトリを作成します。
Cargo.tomlファイルを編集して、クレートのメタデータを定義します。
必要に応じて、src/main.rsや他のモジュールを編集して、クレートのコードを実装します。
cargo runコマンドを使用してクレートをビルドして実行します。
クレートを他の開発者と共有するためには、それをcrates.ioという公式のクレートレジストリに公開する必要があります。公開手順は以下の通りです：
crates.ioにアカウントを作成します。
cargo loginコマンドを使用してcrates.ioにログインします。
クレートのバージョン番号を更新します。
cargo publishコマンドを使用してクレートを公開します。
Rustのクレートは、コードのパッケージングや再利用を容易にする重要な概念です。Cargoを使用してクレートを管理し、必要に応じてcrates.ioに公開することで、他の開発者とクレートを共有することができます。
Rustにおいて、パッケージはクレートと呼ばれます。クレートは、Rustのコードやライブラリをパッケージ化して共有できるようにするための仕組みです。クレートは、依存関係を解決するためのメタデータと、コードとその他のファイルから構成されています。
Rustには、crates.ioという公式のクレートレジストリがあり、開発者はそこでクレートを共有したり、他の開発者が作成したクレートを使用したりできます。
Rustにおける代数的データ型は、構造体（struct）と列挙型（enum）を指します。これらは複雑なデータ構造を表現するのに役立ちます。
構造体は異なる型のフィールドを持つことができ、それぞれのフィールドは名前を持ちます。例えば：
struct Point {
x: i32,
y: i32,
}
impl Point {
fn new(x: i32, y: i32) -> Self {
Self { x, y }
}
fn print(&self) {
println!("x: {}, y: {}", self.x, self.y);
}
}
fn main() {
let origin = Point::new(0, 0);
origin.print();
}
列挙型は、いくつかの異なるバリアント（variant）の中から選択することができます。それぞれのバリアントはデータを持つことができます。
enum Shape {
Circle(f64), // 半径を持つ
Rectangle(f64, f64), // 幅と高さを持つ
Square(f64), // 1辺の長さを持つ
}
impl Shape {
fn area(&self) -> f64 {
match self {
Shape::Circle(radius) => std::f64::consts::PI * radius * radius,
Shape::Rectangle(width, height) => width * height,
Shape::Square(side) => side * side,
}
}
}
fn main() {
let shapes = vec![
Shape::Circle(5.0),
Shape::Rectangle(10.0, 20.0),
Shape::Square(15.0),
];
for shape in &shapes {
println!("Area: {}", shape.area());
}
}
これらの代数的データ型は、Rustで柔軟なデータ構造を表現する際に役立ちます。
Rustの属性（Attribute）は、コンパイラに対してコードに対する追加情報や指示を提供するための注釈です。コードに直接書かれる特殊な構文であり、#[...]の形式で記述されます。これらの属性は、コンパイラやコードの振る舞い、コード生成、最適化、データのレイアウトなどを変更したり、制御したりするために使われます。
以下は、よく使用される属性のいくつかとその目的です：
#[derive(...)]: 自動導出（Derive Attribute）は、コンパイラに対して構造体や列挙型が特定のトレイトを自動的に実装するよう指示するために使われます。#[derive(Debug)]などがその例で、Debugトレイトを自動的に実装するよう指示します。
#[cfg(...)]: コンパイル時の条件を指定します。例えば、#[cfg(target_os = "linux")]はLinux環境のみで有効にするために使われます。
#[allow(...)] / #[deny(...)] / #[warn(...)]: コンパイラの警告レベルを変更します。allowは特定の警告を許可し、denyはエラーにするよう指示し、warnは警告として表示します。
#[repr(...)]: データのレイアウトや表現方法を制御します。例えば、#[repr(C)]はC言語のレイアウトに合わせることを示し、#[repr(align(N))]は特定のアライメントを指定します。
#[inline] / #[noinline]: インライン展開を制御します。inlineは関数をインライン展開可能として指定し、noinlineは展開を禁止します。
#[test] / #[bench]: ユニットテストやベンチマークテスト用の関数をマークします。テストランナーがこれらの関数を見つけて実行します。
#[derive(...)]、#[macro_use]、#[crate_name = "some_name"]、**#[feature(...)]**など、他にも多くの属性が存在します。
属性は様々な目的に使用され、Rustの柔軟性やコードの特定の振る舞いを制御するための重要なツールです。それぞれの属性は特定のコンテキストで役割を果たし、コードの意図をコンパイラに伝えるのに役立ちます。
// テスト用の関数を定義し、テスト用の属性を追加
fn test_addition() {
assert_eq!(2 + 2, 4);
}
// main関数を含むコード例
fn main() {
println!("Hello, Rust!");
// インライン展開のための属性を持つ関数
#[inline(always)]
fn add(a: i32, b: i32) -> i32 {
a + b
}
// インライン展開を促進する属性を持つ関数
#[inline(always)]
fn multiply(a: i32, b: i32) -> i32 {
a * b
}
// インライン展開される関数の呼び出し
let result_add = add(3, 5);
println!("Addition result: {}", result_add);
// インライン展開される関数の呼び出し
let result_multiply = multiply(4, 6);
println!("Multiplication result: {}", result_multiply);
}
#[test]属性: test_addition関数に付与された#[test]属性は、この関数をテスト用の関数としてマークしています。この関数は、assert_eq!(2 + 2, 4);を使って2 + 2が4と等しいかテストします。
#[inline(always)]属性: add関数とmultiply関数に付与された#[inline(always)]属性は、インライン展開を促進するための指示です。インライン展開は、関数呼び出しのオーバーヘッドを削減し、効率的なコード生成を促進します。しかし、alwaysの指定は、常にインライン展開されるというわけではなく、コンパイラの判断に依存します。
main関数: main関数はプログラムのエントリーポイントです。この関数内でprintln!を使って"Hello, Rust!"を表示し、add関数とmultiply関数を呼び出しています。それぞれの関数では、インライン展開の指示が付与されています。
このコード例は、属性を使って関数をテスト対象としてマークし、またインライン展開を促進する方法を示しています。ただし、実際にコードを実行する場合は、main関数内のコードが実行されるため、test_addition関数はテストコードとして実行されることになります。
Debugトレイトは、println!マクロで構造体や列挙型の内容を表示するために使用されます。以下は、Debugトレイトを実装することでprintln!で構造体の内容を表示する例です。
// Debugトレイトを導出可能にするためにderiveアトリビュートを使用
struct MyStruct {
name: String,
age: u32,
}
fn main() {
let my_data = MyStruct {
name: String::from("Alice"),
age: 30,
};
// 構造体の内容を表示する
println!("My data: {:?}", my_data);
}
実行結果:
My data: MyStruct { name: "Alice", age: 30 }
この例では、MyStruct構造体にDebugトレイトを#[derive(Debug)]で導出しています。そして、main関数内でmy_dataをprintln!で表示する際に、{:?}フォーマットを使ってDebugトレイトを呼び出しています。
Debugトレイトを導出することで、println!で構造体の内容を簡単に表示することができます。#[derive(Debug)]を使うことで、デバッグ情報を出力するためのメソッドの実装を手動で書く必要がなくなります。
Rustにおけるジェネリクスは、特定の型に依存せず、複数の型で動作するコードを作成するための重要な機能です。ジェネリクスを使用することで、同じコードを複数の型で再利用したり、型安全性を保ちながら柔軟性を持たせたりすることができます。
// Tというジェネリックな型を持つ関数
fn print_value(value: T) {
println!("Value is: {}", value);
}
fn main() {
// 使用例
print_value(10); // Tはi32として推論される
print_value(2.73 as f32); // Tはf32として推論される
print_value("Hello"); // Tは&strとして推論される
}
この例では、print_value関数がジェネリックな型Tを持ち、Tはstd::fmt::Displayトレイトを実装している型に制限されています。std::fmt::Displayトレイトは、{}でフォーマット可能な型を表します。
引数valueの型はコンパイル時に推論されます。
// ジェネリックな構造体
struct Pair {
first: T,
second: U,
}
fn main() {
// 使用例
let pair_of_int_and_str = Pair { first: 10, second: "Hello" };
println!("first = {:?}, second = {:?}", pair_of_int_and_str.first, pair_of_int_and_str.second);
}
Pair構造体は2つの異なる型を持つことができます。使用する際に具体的な型を指定することで、ジェネリックな構造体を作成できます。
// ジェネリックなトレイト
trait Printable {
fn print(&self);
}
// TがPrintableトレイトを実装していることを要求する関数
fn print_trait(item: T) {
item.print();
}
// 使用例
struct MyType;
impl Printable for MyType {
fn print(&self) {
println!("Printing MyType");
}
}
fn main() {
let obj = MyType;
print_trait(obj); // Printableトレイトを実装したMyTypeのインスタンスを受け取る
}
ここでは、Printableというジェネリックなトレイトを定義し、print_trait関数でPrintableトレイトを実装した型Tを受け取る方法を示しています。
ジェネリクスは、関数、構造体、列挙型、トレイトなどのRustのさまざまな要素で使用できます。これにより、柔軟性のあるコードを作成し、再利用性を高めることができます。
ジェネリックスにおいて、型制約（type constraint）は、ジェネリックな型パラメータに対して特定の条件やトレイトの制約を課すことを指します。これにより、ジェネリックな型が特定の性質を持つことを保証し、安全性を確保することができます。
Rustでは、traitを使用して型制約を実装します。例えば、std::fmt::Displayトレイトを持つ型に制約を課したい場合、以下のように実装します。
fn print_value(value: T) {
println!("Value is: {}", value);
}
ここではという構文を使用して、Tがstd::fmt::Displayトレイトを実装している必要があることを宣言しています。この制約により、print_value関数はstd::fmt::Displayトレイトを実装した型に対してのみ呼び出しが可能になります。
また、複数のトレイト制約を持つこともできます。例えば、std::fmt::Debugとstd::fmt::Displayトレイトの両方を実装した型を要求する場合は、次のように書きます。
fn print_value(value: T) {
println!("Value is: {:?}", value);
}
struct Point {
x: T,
y: T,
}
// Point型に対するDisplayトレイトの実装
impl std::fmt::Display for Point {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Point({}, {})", self.x, self.y)
}
}
fn main() {
let int_point = Point { x: 5, y: 10 };
print_value(int_point); // `Point`型は`std::fmt::Debug`と`std::fmt::Display`を実装している
let float_point = Point { x: 1.5, y: 3.2 };
print_value(float_point); // 同様に、`Point`型は`std::fmt::Debug`と`std::fmt::Display`を実装している
}
Tがstd::fmt::Debugとstd::fmt::Displayの両方を実装している必要があります。
これにより、ジェネリックなコードをより安全に、かつ特定の条件下で使用できるように制約を課すことができます。
Rustでは、Result型とpanicによる例外処理が一般的です。Result型は成功または失敗を表す列挙型で、Okは成功時の値、Errはエラー時の情報を持ちます。
まず、Result型を使用した例を見てみましょう:
use std::fs::File;
use std::io::{self, Read};
fn read_file_contents(file_path: &str) -> Result {
let mut file = File::open(file_path)?;
let mut contents = String::new();
file.read_to_string(&mut contents)?;
Ok(contents)
}
fn main() {
let file_path = "/etc/hosts";
match read_file_contents(file_path) {
Ok(contents) => println!("File contents: {}", contents),
Err(e) => println!("Error reading file: {:?}", e),
}
}
この例では、read_file_contents関数がResultを返します。これは、成功時には文字列をOkで、エラー時にはio::ErrorをErrで返すことを示しています。ファイルを開いたり、読み込んだりするメソッドの呼び出しには?演算子を使用し、エラーが発生した場合は早期リターンしてエラーを返します。
matchブロックでは、read_file_contentsの戻り値に対してOkとErrの両方の可能性に対処し、それぞれ成功時の振る舞いとエラー時の振る舞いを定義しています。これにより、関数の呼び出し元で適切にエラーハンドリングを行うことができます。
また、Rustにはpanic!マクロを使用してプログラムを異常終了させる方法もあります。これは致命的なエラーが発生した場合に使用されますが、エラーを適切に処理するためにResult型を使うことが推奨されます。
fn main() {
let v = vec![1, 2, 3];
let index = 5;
let value = v.get(index).expect("Failed to get the value at index");
println!("Value at index {}: {}", index, value);
}
この例では、getメソッドはOption型を返し、expectメソッドはSomeの場合は中の値を返し、Noneの場合は指定したメッセージとともにプログラムをpanicさせます。
ただし、expectを使う際には、panicが発生した際に表示されるメッセージは注意深く選ぶ必要があります。
panic!()は通常、予期せぬ状況やプログラムの継続が不可能な状況で使われることがあります。以下はそのような例です。
fn divide(a: i32, b: i32) -> i32 {
if b == 0 {
panic!("Attempted to divide by zero!"); // 0で割ろうとした場合、致命的なエラーとしてpanic!()を呼ぶ
}
a / b // 正常な割り算を行う
}
fn main() {
let dividend = 10;
let divisor = 0;
let result = divide(dividend, divisor); // divide関数を呼び出す
println!("Result of division: {}", result);
}
この例では、divide()関数でbが0の場合にpanic!()が呼ばれています。0で割ることは数学的に定義されていないため、これは致命的なエラーであり、プログラムの実行を中断させます。
panic!()は、このような状況に直面した場合に、プログラムを停止させるための手段として使われます。しかし、このようなエラーは通常、if文やmatch文などの条件分岐を使用して事前にチェックして、エラーハンドリングを行うことが推奨されます。
Resultを使ってエラーハンドリングを行うことで、panic!()に頼らずにエラーを適切に処理できます。
fn divide(a: i32, b: i32) -> Result {
if b == 0 {
Err("Attempted to divide by zero!") // 0で割ろうとした場合、エラーをResultで返す
} else {
Ok(a / b) // 正常な割り算の結果をOkで返す
}
}
fn main() {
let dividend = 10;
let divisor = 0;
match divide(dividend, divisor) {
Ok(result) => println!("Result of division: {}", result),
Err(e) => println!("Error: {}", e), // エラーを適切に処理する
}
}
divide()関数はResultを返し、0で割るエラーの場合にはErrを、正常な計算の場合にはOkを返します。matchブロックでは、OkとErrの両方のケースを処理し、エラーが発生した場合にはエラーメッセージを表示します。
このようにResult型を使用することで、エラーハンドリングを柔軟かつ安全に行うことができます。panic!()に頼るよりも、エラーを予測し、適切に処理する方が望ましいです。
Option型は、何らかの値が存在するかどうかを表現するRustの列挙型です。Option型はSomeとNoneの２つのバリアントを持ち、Someは値が存在することを示し、Noneは値が存在しないことを示します。
Option型は、特定の操作が値を返さない可能性がある場合や、値が存在しない場合にエラーを返す代わりにNoneを返すために使われます。このような状況では、Result型を使用せずに、Option型が利用されることがあります。
以下はOption型の例です：
fn divide(a: i32, b: i32) -> Option {
if b == 0 {
None // 0で割ろうとした場合、Noneを返す
} else {
Some(a / b) // 正常な割り算の結果をSomeで返す
}
}
fn main() {
let dividend = 10;
let divisor = 0;
match divide(dividend, divisor) {
Some(result) => println!("Result of division: {}", result), // Someの場合は値を表示
None => println!("Error: Division by zero!"), // Noneの場合はエラーメッセージを表示
}
}
この例では、divide()関数はOptionを返し、0で割るエラーの場合にはNoneを、正常な計算の場合にはSomeを返します。matchブロックでは、SomeとNoneの両方のケースを処理し、Noneの場合はエラーメッセージを表示します。
Option型は、特に値が存在しないことが普通に起こり得る場面で、エラー処理や結果の取り扱いを行う際に有用です。例外的な状況ではなく、むしろ普通の操作の一部として考えられる「値の有無」を扱う際に利用されることが多いです。
RustのIteratorトレイトは、コレクションやデータのシーケンスを反復処理するための非常に強力な機能です。Iteratorは、next() メソッドを提供し、それを使用して次の要素を返し、シーケンスの終わりに達した場合は None を返します。
基本的な使い方は次のようになります:
イテレータの作成: コレクションやデータからイテレータを作成します。iter()やinto_iter()、iter_mut()などのメソッドを使用して、それぞれイミュータブルな参照、所有権、ミュータブルな参照を使ったイテレータを取得できます。
let numbers = vec![1, 2, 3, 4, 5];
let mut iter = numbers.iter(); // イミュータブルなイテレータ
next()を使用した反復処理: next()メソッドを使って、イテレータから次の要素を取得します。
match iter.next() {
Some(number) => println!("Number: {}", number),
None => println!("End of sequence"),
}
forループを使用した反復処理: 一般的には、forループを使用してイテレータを処理します。
for number in numbers.iter() {
println!("Number: {}", number);
}
Iteratorトレイトは、map()、filter()、fold()などの便利なメソッドも提供しており、これらを組み合わせることでデータを効果的に処理できます。
let numbers = vec![1, 2, 3, 4, 5];
// 各要素を2倍して新しいベクターを作成する
let doubled: Vec = numbers.iter().map(|x| x * 2).collect();
// 偶数のみをフィルタリングする
let evens: Vec = numbers.into_iter().filter(|&x| x % 2 == 0).collect();
// 全要素を合計する
let sum: i32 = numbers.iter().sum();
Iteratorトレイトは、Rustでのデータ処理を非常に柔軟で効率的にします。関数型プログラミングの考え方に基づいた強力な機能を提供しています。
Iteratorトレイトを使用して独自のイテレータを実装する例を示します。
例えば、0から始まり、指定されたステップごとに増加するカウンターを作成するイテレータを実装してみましょう。
struct Counter {
current: u32,
step: u32,
max: Option,
}
impl Counter {
fn new(start: u32, step: u32, max: Option) -> Counter {
Counter {
current: start,
step,
max,
}
}
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option {
match self.max {
Some(max) if self.current >= max => None,
_ => {
let result = self.current;
self.current += self.step;
Some(result)
}
}
}
}
fn main() {
let counter = Counter::new(0, 2, Some(10));
for num in counter {
println!("{}", num);
}
}
この例では、Counter構造体はIteratorトレイトを実装しています。next()メソッドは、現在の値を返し、カウンターを指定されたステップで増分させます。また、max値が設定されており、その値に達するとイテレータは終了します。
main()関数内では、Counterイテレータを使用して0から10まで2ずつ増加する数列を生成しています。
Iteratorトレイトを実装することで、独自のイテレータを作成し、柔軟な反復処理を行うことができます。
implキーワードは、Rustで特定の型に対してメソッドやトレイトを実装するために使用されます。基礎から始めて、応用的な使い方まで見ていきましょう。
メソッドの実装
struct MyStruct {
value: i32,
}
impl MyStruct {
// MyStruct型に対するメソッドの実装
fn new(value: i32) -> MyStruct {
MyStruct { value }
}
fn get_value(&self) -> i32 {
self.value
}
}
fn main() {
let instance = MyStruct::new(42);
println!("Value: {}", instance.get_value()); // メソッド呼び出し
}
implブロック内で、MyStructに対するnewメソッドとget_valueメソッドを実装しています。main関数でこれらのメソッドを使用しています。
トレイトの実装
// 'Printable' という名前の機能を定義しています。
// これは、ある型が特定の振る舞いを持つことを宣言します。
trait Printable {
// 'print' という名前の機能を提供しています。
// これは、任意の型が実装する必要があるメソッドです。
fn print(&self);
}
// 'MyType' という名前のデータ構造を定義しています。
// これは整数値を保持する構造体です。
struct MyType {
value: i32, // 'MyType' 構造体が保持する整数値のフィールドです。
}
// 'Printable' という機能を 'MyType' に実装しています。
// これにより、'MyType' インスタンスは 'Printable' で提供される振る舞いを持ちます。
impl Printable for MyType {
// 'Printable' で要求された 'print' 機能を 'MyType' に実装しています。
fn print(&self) {
// 'MyType' インスタンスが 'print' を実行すると、値が表示されます。
println!("Value: {}", self.value);
}
}
fn main() {
// 'MyType' の新しいインスタンスを作成し、整数値を設定しています。
let obj = MyType { value: 10 };
// 'Printable' で定義された 'print' 機能を呼び出しています。
// これにより、 'MyType' の値が出力されます（この場合は "Value: 10"）。
obj.print();
}
{{コラム|トレイトとインターフェイスやプロトコルとの類似性|2=トレイトは他の言語でのインターフェースやプロトコルに似ています。これらの概念は、異なる型や構造体が共通の振る舞いを持つことを許可し、それによってポリモーフィズム（多様性）を実現します。
インターフェース
共通の振る舞い: インターフェースは、異なるクラスが共通の振る舞いを持つことを保証します。他の言語では、この振る舞いはインターフェースで定義され、クラスはそれを実装します。
メソッドの宣言: インターフェースでは、クラスが実装しなければならないメソッドの宣言が含まれます。
多重継承の代替: インターフェースは多重継承の代替手段としても使われ、クラスは複数のインターフェースを実装することができます。
プロトコル
抽象的な振る舞いの定義: プロトコルは、特定の振る舞いや機能を表す抽象的な規約です。Swiftなどの言語ではプロトコルが使われ、クラスや構造体はそれらを適合させます。
メソッドの要求: プロトコルは、適合する型によって実装されるメソッドやプロパティの要求を定義します。
型の適合性の強化: プロトコルに適合することで、様々な型を同じ抽象的な概念に束縛することができます。
Rustのトレイト
共通の振る舞いの提供: トレイトは、構造体や他の型に共通の振る舞いを提供します。それぞれの型はトレイトを実装することで、その振る舞いを持つことができます。
メソッドの宣言: トレイトではメソッドの宣言が行われ、それを実装することでトレイトが利用できるようになります。
型間の相互運用性と柔軟性: トレイトは型間での相互運用性や柔軟性を提供し、異なる型が同じ振る舞いを共有することができます。
これらの概念は異なる言語で微妙に異なる場合がありますが、トレイト、インターフェース、プロトコルはいずれも多様な型が共通の振る舞いを共有するための仕組みとして機能します。
ジェネリックな構造体に対する実装
// ジェネリックなデータ構造体 'MyGeneric' を定義しています。
// '' は型パラメータであり、任意の型を受け入れます。
struct MyGeneric {
value: T, // 'T' 型の値を保持する 'value' フィールドです。
}
// 'MyGeneric' に対するジェネリックなメソッド実装です。
impl MyGeneric {
// 新しい 'MyGeneric' インスタンスを生成する 'new' メソッドです。
// 渡された値で 'value' フィールドを初期化します。
fn new(value: T) -> MyGeneric {
MyGeneric { value }
}
// 'value' フィールドへの参照を返す 'get_value' メソッドです。
fn get_value(&self) -> &T {
&self.value
}
}
fn main() {
// 'MyGeneric' 型のインスタンスを作成しています。
// 'value' フィールドには整数値 42 が格納されます。
let instance = MyGeneric::new(42);
// 'get_value' メソッドを呼び出して 'value' フィールドの値を取得し、出力しています。
println!("Value: {:?}", instance.get_value()); // ジェネリックなメソッド呼び出し
// 'MyGeneric<&str>' 型のインスタンスを作成しています。
// 'value' フィールドには文字列 "hello" が格納されます。
let instance = MyGeneric::new("hello");
// 'get_value' メソッドを呼び出して 'value' フィールドの値を取得し、出力しています。
println!("Value: {:?}", instance.get_value()); // ジェネリックなメソッド呼び出し
}
このコードは、MyGenericをi32型と&str型の両方でインスタンス化しています。ジェネリックなデータ構造体とそのジェネリックなメソッドを利用して、異なる型に対して同じメソッドを使用する様子を示しています。println!マクロ内の{:?}は、Debugトレイトを実装する型の値を表示するためのフォーマット指定子です。これにより、異なる型の値も出力できます。
----
implを使ったさまざまな例を挙げてみましょう。
// Summaryトレイトを定義します。
trait Summary {
fn summarize(&self) -> String;
}
// Summaryトレイトを実装するBook構造体を定義します。
struct Book {
title: String,
author: String,
}
// BookにSummaryトレイトを実装します。
impl Summary for Book {
fn summarize(&self) -> String {
format!("{} by {}", self.title, self.author)
}
}
// summarize_any関数はSummaryトレイトを実装した任意の型に対して要約を取得します。
fn summarize_any(item: &impl Summary) -> String {
item.summarize()
}
fn main() {
let book = Book {
title: String::from("Harry Potter"),
author: String::from("J.K. Rowling"),
};
println!("Summary: {}", summarize_any(&book));
}
この例では、Summaryトレイトを実装した様々な型に対して共通のsummarize_any関数を使用して、異なる型の値に対して要約を取得できます。このようなジェネリックで柔軟なアプローチは、異なる型に対して一貫した操作を提供する場合に非常に便利です。
// 長方形を表す 'Rectangle' 構造体です。
struct Rectangle {
width: u32, // 長方形の幅を表す 'width' フィールド
height: u32, // 長方形の高さを表す 'height' フィールド
}
// 'Rectangle' 構造体に関するメソッドを実装しています。
impl Rectangle {
// 新しい 'Rectangle' インスタンスを生成する 'new' メソッドです。
fn new(width: u32, height: u32) -> Self {
Rectangle { width, height }
}
}
// 'Area' という名前のトレイトを定義しています。
// このトレイトは 'area' メソッドを持ち、長方形の面積を計算します。
trait Area {
// 長方形の面積を計算する 'area' メソッドです。
fn area(&self) -> u32;
}
// 'Area' トレイトを 'Rectangle' 構造体に実装しています。
// 'Rectangle' には 'Area' トレイトの 'area' メソッドが実装されます。
impl Area for Rectangle {
// 'Rectangle' の面積を計算する 'area' メソッドの実装です。
fn area(&self) -> u32 {
self.width * self.height
}
}
fn main() {
// 幅が5、高さが10の 'Rectangle' インスタンスを作成しています。
let rect = Rectangle::new(5, 10);
// 'Area' トレイトの 'area' メソッドを呼び出して、長方形の面積を出力しています。
println!("Area of rectangle: {}", rect.area());
}
ここでは、Rectangle構造体にnewメソッドを実装し、またAreaトレイトを実装しています。main関数でRectangleのインスタンスを作成し、Areaトレイトのメソッドであるarea()を呼び出しています。
// 同じ型の2つの要素を持つ 'Pair' 構造体です。
struct Pair {
first: T, // ペアの最初の要素を表す 'first' フィールド
second: T, // ペアの2番目の要素を表す 'second' フィールド
}
// 'Pair' 構造体に関するメソッドを実装しています。
impl Pair {
// 新しい 'Pair' インスタンスを生成する 'new' メソッドです。
// 渡された2つの値で 'first' と 'second' フィールドを初期化します。
fn new(first: T, second: T) -> Self {
Pair { first, second }
}
// 'first' フィールドへの参照を返す 'get_first' メソッドです。
fn get_first(&self) -> &T {
&self.first
}
// 'second' フィールドへの参照を返す 'get_second' メソッドです。
fn get_second(&self) -> &T {
&self.second
}
}
fn main() {
// 整数型を持つ 'Pair' インスタンスを作成しています。
let pair = Pair::new(42, 24);
// 'get_first' メソッドを使ってペアの最初の要素を出力しています。
println!("First element: {}", pair.get_first());
// 'get_second' メソッドを使ってペアの2番目の要素を出力しています。
println!("Second element: {}", pair.get_second());
}
Pair構造体に対してT型のジェネリックなメソッドを実装しています。この例ではget_firstメソッドを定義し、main関数でそれを呼び出しています。
// 'Weather' 列挙型です。3つの異なる天気を表します。
enum Weather {
Sunny,
Cloudy,
Rainy,
}
// 'Description' トレイトは、様々な要素に対する説明を提供します。
trait Description {
fn describe(&self) -> &'static str;
}
// 'Description' トレイトを 'Weather' 列挙型に実装しています。
impl Description for Weather {
// 'describe' メソッドは、各 'Weather' の状態に対する説明を提供します。
fn describe(&self) -> &'static str {
match self {
Weather::Sunny => "It's sunny today!",
Weather::Cloudy => "It's cloudy today.",
Weather::Rainy => "It's raining today.",
}
}
}
fn main() {
// 'Weather' 列挙型のすべてのヴァリアントを反復処理します。
for weather in &[Weather::Sunny, Weather::Cloudy, Weather::Rainy] {
// 各天気状況に対する説明を出力します。
println!("{:?}: {}", weather, weather.describe());
}
}
Weather列挙型に対してDescriptionトレイトを実装して、各ヴァリアントに対する説明を返すdescribeメソッドを定義しています。main関数でWeatherのインスタンスを作成し、その説明を表示しています。
これらの例は、implを使って様々なタイプの型に対してメソッドやトレイトを実装する方法を示しています。この機能を利用することで、Rustの柔軟で型安全なコーディングを行うことができます。
Rustでの関数は、プログラム内で再利用可能なコードブロックを定義するために使われます。関数は特定のタスクを実行するための手続きを含み、必要に応じて引数を受け取り、結果を返すことができます。基本的な関数の定義と使用方法を以下に示します。
// 関数の定義
fn add(a: i32, b: i32) -> i32 {
a + b // 最後の式の結果が自動的に返り値になる
}
この例では、addという名前の関数が定義されています。aとbは整数型(i32)の引数を受け取ります。-> i32は関数がi32型の値を返すことを示しています。
let result = add(3, 5);
println!("Result: {}", result); // "Result: 8"が出力される
add関数は3と5を引数に取り、それらを足して8を返します。println!マクロを使ってその結果を出力しています。
引数: 関数に渡す値。関数の定義において、引数は型を指定する必要があります。
戻り値: ->演算子を使って関数が返す値の型を指定します。Rustでは最後の式の結果が自動的に返り値となります。
Rustの関数は複数の値を返すこともできます。
fn calculate(a: i32, b: i32) -> (i32, i32) {
(a + b, a - b)
}
let (sum, difference) = calculate(10, 5);
println!("Sum: {}, Difference: {}", sum, difference); // "Sum: 15, Difference: 5"が出力される
再帰: 自分自身を呼び出すことができます。
クロージャ: 無名の関数を作成し、変数にキャプチャさせることができます。
ジェネリクス: 型を指定せずに関数を定義することができ、後から具体的な型を指定できます。
Rustの関数は安全性、速度、パターンマッチング、ジェネリクス、所有権など、言語の多くの特徴を活用しています。これらの特性は、Rustを強力なプログラミング言語にしています。
Rustの関数とライフタイムは、関連性がありますが、関数のシグネチャ内でライフタイムを使用することは必ずしも必要ではありません。しかし、関数が参照を含む場合や、ジェネリクスを使う場合には、ライフタイムの指定が必要になることがあります。
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
この例では、longest関数は2つの文字列スライスを引数として受け取り、それらのうち長さが長い方の参照を返します。'aはライフタイムパラメータであり、2つの引数と返り値の参照のライフタイムが同じことを示しています。これにより、返される参照が有効なスコープを保証します。
Rustでは、ライフタイムの省略規則があります。特定のパターンにおいては、コンパイラが暗黙的にライフタイムを推論することができます。例えば、次のような関数シグネチャではライフタイムの省略が行われます。
fn longest(x: &str, y: &str) -> &str {
// ...
}
このような場合、コンパイラは適切なライフタイムを自動的に推論します。ただし、ライフタイムの省略は特定の条件に限定され、全ての場面で使えるわけではありません。
ライフタイムは主に、参照の有効期間を指定するために使用され、特に関数内で参照を扱う際に重要な役割を果たします。関数が複数の参照を扱い、それらの有効期間を整理する必要がある場合には、ライフタイムの指定が必要になることがあります。
Rustではクロージャも関数として扱われます。クロージャは自身のスコープ外の変数をキャプチャして利用できます。これは非常に便利で、関数よりも柔軟な振る舞いを提供します。
次のコード例では、クロージャと関数の組み合わせを使って、外部スコープの変数をキャプチャして利用する方法を示します。
fn main() {
let base_number = 10;
// クロージャの定義
let add_to_base = |x| x + base_number;
let new_number = 7;
// クロージャの使用
let result = add_to_base(new_number);
println!("Result: {}", result); // "Result: 17"が出力される
}
この例では、base_numberという変数がadd_to_baseクロージャにキャプチャされ、後でクロージャ内で使用されています。クロージャは外部の変数をキャプチャすることができ、そのコンテキストを保持して使用できる点が関数とは異なる特徴です。
Rustの関数は、パターンマッチングやジェネリクス、ライフタイム、クロージャなどの機能と組み合わせて、安全で効率的なコードを記述するための強力なツールです。
Rustは、関数型プログラミングの要素を備えた汎用プログラミング言語です。Rustでは、関数を変数やデータ構造に格納したり、関数を関数のパラメータとして渡したりすることができます。これらの機能は、高階関数として知られています。
Rustで高階関数を使用すると、コードの再利用性と保守性を向上させることができます。また、コードをより簡潔で読みやすくすることもできます。
Rustで高階関数を使用する方法はいくつかあります。
Rustでは、関数を変数に格納することができます。これにより、関数を繰り返し使用したり、関数を別の関数に渡したりすることができます。
fn square(x: i32) -> i32 {
x * x
}
let square_function = square;
println!("The square of 5 is {}", square_function(5));
このコードでは、square()関数をsquare_function変数に格納しています。その後、square_function()関数を呼び出すことで、square()関数と同じ結果を得ることができます。
Rustでは、関数を関数のパラメータとして渡すことができます。これにより、関数を別の関数に処理させることができます。
fn map_numbers(numbers: &[i32], f: fn(i32) -> i32) -> Vec {
let mut result = Vec::new();
for number in numbers {
result.push(f(number));
}
result
}
fn square(x: i32) -> i32 {
x * x
}
let numbers = [1, 2, 3, 4, 5];
let squared_numbers = map_numbers(numbers, square);
println!("The squared numbers are: {:?}", squared_numbers);
このコードでは、map_numbers()関数は、numbers配列の各要素をf関数に渡し、その結果を新しい配列に格納します。
Rustでは、クロージャを使用して高階関数を作成することができます。クロージャは、関数本体の一部として定義された関数です。クロージャは、変数やデータ構造を捕捉して、関数本体内で使用することができます。
fn filter_numbers(numbers: &[i32], f: impl Fn(i32) -> bool) -> Vec {
let mut result = Vec::new();
for number in numbers {
if f(number) {
result.push(number);
}
}
result
}
fn is_even(x: i32) -> bool {
x % 2 == 0
}
let numbers = [1, 2, 3, 4, 5];
let even_numbers = filter_numbers(numbers, is_even);
println!("The even numbers are: {:?}", even_numbers);
このコードでは、filter_numbers()関数は、numbers配列の各要素をfクロージャに渡し、その結果がtrueである場合、その要素を新しい配列に格納します。
Rustで高階関数を使用すると、コードの再利用性と保守性を向上させることができます。また、コードをより簡潔で読みやすくすることもできます。
Rustの標準ライブラリー（Standard Library）は、Rustコンパイラにバンドルされており、基本的なデータ構造、OSとのやり取り、スレッド、ファイルI/O、ネットワーキングなどの多くの機能を提供しています。以下に、標準ライブラリーの主要なカテゴリを紹介します。
Vec, VecDeque: ベクターや双方向キューなどの動的な配列。
HashMap, BTreeMap: ハッシュマップやBツリーマップなどのキーと値のペアを保持するマップ。
HashSet, BTreeSet: ハッシュセットやBツリーセットなどのユニークな値を保持するセット。
std::thread: スレッドの生成と操作を提供。
std::sync: Mutex、Atomicなどの同期機能を提供するモジュール。
std::fs: ファイルシステムとの相互作用を可能にするモジュール。
std::net: ネットワーキングのためのモジュール。
std::primitive: Rustのプリミティブ型（整数、浮動小数点数など）の機能を提供。
std::env: 環境変数の取得などのOS環境に関する操作。
std::time: 時間に関する機能を提供。
std::io: 標準入出力やバッファリング、ファイルI/OなどのI/O操作を提供。
std::str: 文字列の操作、変換、検索などの機能を提供。
std::alloc: メモリの割り当てと解放のための機能。
std::marker: マーカートレイトを提供し、コンパイラへのヒントを与える。
これらは標準ライブラリーの一部であり、Rustの基本的な機能を提供しています。開発者はこれらのモジュールや機能を組み合わせて、安全で効率的なプログラムを構築できます。
このコードギャラリーは、さまざまなRustの機能やパターン、ベストプラクティスを示すためのサンプルコード集です。
fn eratosthenes(n: usize) {
let mut sieve = vec![true; n + 1];
sieve[0] = false;
sieve[1] = false;
for i in 2..=n {
if sieve[i] {
println!("{}", i);
let mut j = i * 2;
while j <= n {
sieve[j] = false;
j += i;
}
}
}
}
fn main() {
eratosthenes(100);
}
このRustのコードは、エラトステネスの篩を使用して与えられた範囲内の素数を見つけるものです。
eratosthenes 関数は、与えられた n までの素数を見つけるためのエラトステネスの篩アルゴリズムを実装しています。このアルゴリズムでは、最初に n + 1 サイズの sieve というブール型の配列を作成します。この配列は、各インデックスが素数かどうかを示します。
sieve[0] と sieve[1] は素数ではないので、それらを false に設定します。
2 から n までの各数について、その数が素数である場合は、その数の倍数を素数ではないとマークします。これにより、素数の倍数を持つ数は素数ではないことがわかります。
main 関数では、eratosthenes 関数を呼び出し、100までの素数を見つけます。見つかった素数は画面に出力されます。
このアルゴリズムは素数を見つけるための効率的な方法の一つであり、与えられた範囲内の素数を見つけることができます。
fn gcd2(m: i32, n: i32) -> i32 {
if n == 0 {
m
} else {
gcd2(n, m % n)
}
}
fn gcd(ints: &[i32]) -> i32 {
ints.iter().fold(ints[0], |acc, &value| gcd2(acc, value))
}
fn lcm2(m: i32, n: i32) -> i32 {
m * n / gcd2(m, n)
}
fn lcm(ints: &[i32]) -> i32 {
ints.iter().fold(ints[0], |acc, &value| lcm2(acc, value))
}
fn main() {
println!("gcd2(30, 45) => {}", gcd2(30, 45));
println!("gcd(&[30, 72, 12]) => {}", gcd(&[30, 72, 12]));
println!("lcm2(30, 72) => {}", lcm2(30, 72));
println!("lcm(&[30, 42, 72]) => {}", lcm(&[30, 42, 72]));
}
このコードは高階関数を利用しています。fold関数は特に重要で、与えられた配列内の要素に対して特定の操作を順番に適用することができます。
まず、gcd関数では、ints配列内の要素に対してfold関数を使って最大公約数（gcd2関数）を計算しています。foldは初期値としてints[0]を受け取り、各要素valueに対してgcd2(acc, value)を適用し、次の要素に対して再帰的にgcd2を適用します。これにより、配列内のすべての要素の最大公約数が計算されます。
同様に、lcm関数もfoldを利用しています。ここではlcm2関数が利用され、各要素に対して最小公倍数を求めるための計算が行われます。
高階関数の利用により、配列内の要素に対して繰り返し処理を行う必要がある場合でも、シンプルで効率的なコードを書くことができます。
二分法
fn bisection(low: f64, high: f64, f: impl Fn(f64) -> f64) -> f64 {
let x = (low + high) / 2.0;
let fx = f(x);
match () {
_ if (fx.abs() - 1.0e-10) < f64::EPSILON => x,
_ if fx < 0.0 => bisection(x, high, f),
_ => bisection(low, x, f),
}
}
fn main() {
let result1 = bisection(0.0, 3.0, |x| x - 1.0);
println!("{}", result1);
let result2 = bisection(0.0, 3.0, |x| x * x - 1.0);
println!("{}", result2);
}
旧課程(-2012年度)高等学校数学B/数値計算とコンピューター#2分法の例を Rust に移植しました。
このRustのコードは、二分法（bisection method）を使って与えられた関数の根を見つけるものです。
bisection関数は、lowからhighの範囲で与えられた関数 f の根を探します。f は Fn(f64) -> f64 のトレイトを実装しており、実際の関数の定義は呼び出し時に与えられます。
この関数は再帰的に呼び出されます。与えられた区間 [low, high] の中央値 x を求め、その点での関数の値 f(x) を計算します。この値が非常に小さいか（ここでは 1.0e-10未満）、または非常に近い数になるまで low または high を更新して、区間を狭めていきます。
main関数では、2つの異なる関数 x - 1 と x^2 - 1 に対して bisection 関数を呼び出して、それぞれの関数の根を探し、println! マクロを使って根を表示しています。
Rustにクラスはありませんが、構造体がメソッドを持つことが出来ます。
struct Hello {
s: String,
}
impl Hello {
fn new(s: &str) -> Hello {
let s = if s.is_empty() { "world" } else { s };
Hello { s: s.to_string() }
}
fn to_string(&self) -> String {
format!("Hello {}!", self.s)
}
fn print(&self) {
println!("{}", self.s);
}
}
fn main() {
let hello1 = Hello::new("");
println!("{}", hello1.to_string());
hello1.print();
let hello2 = Hello::new("my friend");
println!("{}", hello2.to_string());
hello2.print();
println!("
Hello.constructor.name => Hello
hello1 => {:?}
hello2.s => {}", hello1, hello2.s);
}
このRustのコードは、Helloという名前の構造体を定義し、その構造体に関連するメソッドや、main()関数を含んでいます。
まず、Hello構造体はString型のsフィールドを持っています。#[derive(Debug)]アトリビュートは、この構造体にDebugトレイトを自動的に実装するようコンパイラに指示しています。Debugトレイトを実装することで、デバッグ目的で構造体の内容を出力できるようになります。
impl Helloブロックでは、Hello構造体に対するメソッドが定義されています。
newメソッドは、引数として文字列を受け取り、それが空文字列の場合はデフォルトの文字列 "world" を持つHello構造体を生成します。それ以外の場合は、引数で渡された文字列を使用してHello構造体を作成します。
to_stringメソッドは、Hello構造体のインスタンスに対して、挨拶文を含む文字列を生成します。
printメソッドは、Hello構造体のインスタンスのsフィールド（挨拶文）を標準出力に表示します。
main()関数では、Hello構造体を使ってインスタンスを生成し、メソッドを呼び出しています。println!マクロを使用して、構造体やそのフィールドをデバッグ出力しています。最後のprintln!マクロでは、hello1のデバッグ表示（{:?}）とhello2のsフィールドを出力しています。
Go/メソッドとインターフェースからの移植です。
use std::f64::consts::PI;
struct GeoCoord {
longitude: f64,
latitude: f64,
}
impl GeoCoord {
fn distance(&self, other: &GeoCoord) -> f64 {
let i = PI / 180.0;
let r = 6371.008;
let lat_i = self.latitude * i;
let other_lat_i = other.latitude * i;
let long_diff_i = (self.longitude - other.longitude) * i;
let sin_lat = f64::sin(lat_i) * f64::sin(other_lat_i);
let cos_lat = f64::cos(lat_i) * f64::cos(other_lat_i);
let cos_long_diff = f64::cos(long_diff_i);
let distance = f64::acos(sin_lat + cos_lat * cos_long_diff) * r;
distance
}
}
impl std::fmt::Display for GeoCoord {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let (mut ew, mut ns) = ("東経", "北緯");
let mut long = self.longitude;
let mut lat = self.latitude;
if long < 0.0 {
ew = "西経";
long = -long;
}
if lat < 0.0 {
ns = "南緯";
lat = -lat;
}
write!(f, "({}: {}, {}: {})", ew, long, ns, lat)
}
}
fn main() {
let sites = vec![
("東京駅", GeoCoord { longitude: 139.7673068, latitude: 35.6809591 }),
("シドニー・オペラハウス", GeoCoord { longitude: 151.215278, latitude: -33.856778 }),
("グリニッジ天文台", GeoCoord { longitude: -0.0014, latitude: 51.4778 }),
];
for (name, gc) in &sites {
println!("{}: {}", name, gc);
}
let ks: Vec<&str> = sites.iter().map(|(k, _)| *k).collect();
for i in 0..sites.len() {
let ksi = ks[i];
let ksx = ks[(i + 1) % sites.len()];
println!(
"{} - {}: {:.2} [km]",
ksi,
ksx,
sites[i].1.distance(&sites[(i + 1) % sites.len()].1)
);
}
}
逆ポーランド記法は、数式の演算子を後置記法で表現する方法です。通常の中置記法では演算子がオペランドの間に置かれますが、逆ポーランド記法では演算子がオペランドの後ろに置かれます。これにより、括弧や演算子の優先順位を考える必要がなくなり、計算機で容易に評価できる形式になります。
例えば、中置記法での式 3 + 4 * 5 は、逆ポーランド記法では 3 4 5 * + と表現されます。この記法では、演算子が対象のオペランドに対して順番に適用されます。
enum Token {
Add,
Sub,
Mul,
Div,
Operand(i32),
}
impl Token {
fn evaluate(&self, stack: &mut Vec) -> Result<(), &'static str> {
match self {
Token::Add | Token::Sub | Token::Mul | Token::Div => {
if stack.len() < 2 {
return Err("Invalid expression: not enough operands for operator");
}
let operand2 = stack.pop().unwrap();
let operand1 = stack.pop().unwrap();
match self {
Token::Add => stack.push(operand1 + operand2),
Token::Sub => stack.push(operand1 - operand2),
Token::Mul => stack.push(operand1 * operand2),
Token::Div => {
if operand2 == 0 {
return Err("Division by zero");
}
stack.push(operand1 / operand2);
}
_ => unreachable!(),
}
}
Token::Operand(num) => {
stack.push(*num);
}
}
Ok(())
}
}
fn evaluate_expression(expression: &str) -> Result {
let mut stack: Vec = Vec::new();
let tokens: Vec = expression
.split_whitespace()
.map(|token| {
if let Ok(parsed_num) = token.parse::() {
Token::Operand(parsed_num)
} else {
match token {
"+" => Token::Add,
"-" => Token::Sub,
"*" => Token::Mul,
"/" => Token::Div,
_ => unreachable!(),
}
}
})
.collect();
for token in tokens {
if let Err(err) = token.evaluate(&mut stack) {
return Err(err);
}
}
if stack.len() != 1 {
return Err("Invalid expression: too many operands or operators");
}
Ok(stack[0])
}
fn main() {
let expression = "5 3 2 * + 8 2 / -";
match evaluate_expression(expression) {
Ok(result) => println!("Result: {}", result),
Err(err) => println!("Error: {}", err),
}
}
このコードは、Tokenという列挙型を使って逆ポーランド記法の式を評価する関数を実装しています。
まず、TokenはAdd、Sub、Mul、Div、Operandの5つのバリアントを持ちます。Operandは整数値を保持します。
Tokenにはevaluateというメソッドが実装されています。このメソッドでは、Tokenの各バリアントに対する処理が行われます。Add、Sub、Mul、Divの場合は、スタックから2つの値を取り出して、それらを演算し結果をスタックに積みます。Operandの場合は、その値をスタックに積みます。
evaluate_expression関数では、与えられた式をトークン化してTokenのベクターに変換し、それぞれのトークンに対してevaluateメソッドを実行します。各トークンの評価においてエラーが発生した場合、そのエラーメッセージが直ちに返されます。最終的に、スタックに残った値が1つでない場合もエラーが返されます。
main関数では、evaluate_expressionの結果に応じて結果を出力するか、エラーを表示します。これにより、逆ポーランド記法の式を評価し、正常な結果またはエラーメッセージを表示できます。
enum Token {
Number(i32),
Plus,
Minus,
Multiply,
Divide,
}
fn main() {
let input = "12+34*56/78";
let tokens = parse_input(input);
let rpn = infix_to_rpn(tokens);
println!("{:?}", rpn);
}
fn parse_input(input: &str) -> Vec {
let mut tokens = Vec::new();
let mut num = String::new();
for c in input.chars() {
match c {
'0'..='9' => num.push(c),
'+' | '-' | '*' | '/' => {
if !num.is_empty() {
let n = num.parse().unwrap();
tokens.push(Token::Number(n));
num.clear();
}
match c {
'+' => tokens.push(Token::Plus),
'-' => tokens.push(Token::Minus),
'*' => tokens.push(Token::Multiply),
'/' => tokens.push(Token::Divide),
_ => unreachable!(),
}
}
_ => panic!("Invalid character in input!"),
}
}
if !num.is_empty() {
let n = num.parse().unwrap();
tokens.push(Token::Number(n));
}
tokens
}
fn infix_to_rpn(tokens: Vec) -> Vec {
let mut rpn = Vec::new();
let mut stack = Vec::new();
for token in tokens {
match token {
Token::Number(_) => rpn.push(token),
Token::Plus | Token::Minus | Token::Multiply | Token::Divide => {
while let Some(top) = stack.last().copied() {
if precedence(&token) <= precedence(⊤) {
rpn.push(stack.pop().unwrap());
} else {
break;
}
}
stack.push(token);
}
}
}
while let Some(op) = stack.pop() {
rpn.push(op);
}
rpn
}
fn precedence(token: &Token) -> i32 {
match token {
Token::Multiply | Token::Divide => 2,
Token::Plus | Token::Minus => 1,
_ => 0,
}
}
実行結果:
[Number(12), Number(34), Number(56), Multiply, Number(78), Divide, Plus]
このコードは、与えられた文字列を逆ポーランド記法（RPN）に変換するプログラムです。以下にその構造を解説します：
Token 列挙型: 数字と演算子を表す列挙型です。Number は数字を、Plus, Minus, Multiply, Divide はそれぞれ演算子を表します。derive(Debug, Clone, Copy) が付与されており、デバッグ表示やクローン、コピーが可能です。
parse_input 関数: 与えられた文字列をトークンに分割します。数字の場合は文字列を数値に変換して Token::Number に、演算子の場合は対応する Token に変換し、それらを Vec に収集します。
infix_to_rpn 関数: 中置記法のトークンのベクターを逆ポーランド記法に変換します。スタックとRPNベクターを使用して、トークンを処理します。演算子の場合、スタックのトップとの優先順位を比較して、適切な順序でRPNに追加します。
precedence 関数: 演算子の優先順位を返します。乗算と除算が優先され、それ以外の演算子は同じ優先順位です。
このコードは、入力された文字列を数値と演算子に分割し、それらを逆ポーランド記法に変換する機能を持っています。特定の演算子の優先順位を考慮しながら適切な順序で演算子を配置し、RPNを生成します。
enum Token {
Number(f64),
Plus,
Minus,
Multiply,
Divide,
LParen,
RParen,
EOF,
}
struct Lexer<'a> {
input: &'a str,
position: usize,
}
impl<'a> Lexer<'a> {
fn new(input: &'a str) -> Lexer<'a> {
Lexer { input, position: 0 }
}
fn skip_whitespace(&mut self) {
while self.position < self.input.len() && self.input.chars().nth(self.position).unwrap().is_whitespace() {
self.position += 1;
}
}
fn next_token(&mut self) -> Token {
self.skip_whitespace();
if self.position >= self.input.len() {
return Token::EOF;
}
let current_char = self.input.chars().nth(self.position).unwrap();
match current_char {
'+' => {
self.position += 1;
Token::Plus
}
'-' => {
self.position += 1;
Token::Minus
}
'*' => {
self.position += 1;
Token::Multiply
}
'/' => {
self.position += 1;
Token::Divide
}
'(' => {
self.position += 1;
Token::LParen
}
')' => {
self.position += 1;
Token::RParen
}
_ => {
if current_char.is_digit(10) || current_char == '.' {
let start = self.position;
while self.position < self.input.len() && (self.input.chars().nth(self.position).unwrap().is_digit(10) || self.input.chars().nth(self.position).unwrap() == '.') {
self.position += 1;
}
let number_str = &self.input[start..self.position];
let number = number_str.parse::().unwrap();
Token::Number(number)
} else {
panic!("Invalid character found: {}", current_char);
}
}
}
}
}
struct Parser<'a> {
lexer: Lexer<'a>,
current_token: Token,
}
impl<'a> Parser<'a> {
fn new(mut lexer: Lexer<'a>) -> Parser<'a> {
let current_token = lexer.next_token();
Parser { lexer, current_token }
}
fn eat(&mut self, token: Token) {
if self.current_token == token {
self.current_token = self.lexer.next_token();
} else {
panic!("Invalid syntax");
}
}
fn factor(&mut self) -> Vec {
match self.current_token {
Token::Number(num) => {
self.eat(Token::Number(num));
vec![Token::Number(num)]
}
Token::LParen => {
self.eat(Token::LParen);
let result = self.expr();
self.eat(Token::RParen);
result
}
_ => panic!("Invalid syntax"),
}
}
fn term(&mut self) -> Vec {
let mut result = self.factor();
while vec![Token::Multiply, Token::Divide].contains(&self.current_token) {
match self.current_token {
Token::Multiply => {
self.eat(Token::Multiply);
let mut next_factor = self.factor();
result.append(&mut next_factor);
result.push(Token::Multiply);
}
Token::Divide => {
self.eat(Token::Divide);
let mut next_factor = self.factor();
result.append(&mut next_factor);
result.push(Token::Divide);
}
_ => panic!("Invalid syntax"),
}
}
result
}
fn expr(&mut self) -> Vec {
let mut result = self.term();
while vec![Token::Plus, Token::Minus].contains(&self.current_token) {
match self.current_token {
Token::Plus => {
self.eat(Token::Plus);
let mut next_term = self.term();
result.append(&mut next_term);
result.push(Token::Plus);
}
Token::Minus => {
self.eat(Token::Minus);
let mut next_term = self.term();
result.append(&mut next_term);
result.push(Token::Minus);
}
_ => panic!("Invalid syntax"),
}
}
result
}
}
fn generate_reverse_polish_notation(input: &str) -> Vec {
let lexer = Lexer::new(input);
let mut parser = Parser::new(lexer);
parser.expr()
}
fn main() {
let result = generate_reverse_polish_notation("12+34*56/78");
println!("{:?}", result);
}
コードは、与えられた数式を逆ポーランド記法に変換するためのプログラムです。ここでは、Lexer（字句解析器）とParser（構文解析器）という2つの主要な構成要素があります。
Token
Token 列挙型は、数式をトークンに分割するために使用されます。数字、演算子、および括弧のトークンを定義します。
Lexer
Lexer は、与えられた数式文字列をトークンに分割する役割を担います。next_token メソッドは、数式の文字列を走査して、各文字がどの種類のトークンに対応するかを判断します。
Parser
Parser は、Lexer によって生成されたトークンのストリームを受け取り、逆ポーランド表記に変換します。再帰的に式を解析し、優先順位を考慮しながら、逆ポーランド表記のトークン列を生成します。
factor() メソッドは、数または括弧で始まる要素（ファクター）を解析します。
term() メソッドは、乗算と除算の演算子を解析します。
expr() メソッドは、加算と減算の演算子を解析します。
generate_reverse_polish_notation 関数
この関数は、与えられた数式文字列を逆ポーランド表記に変換します。Lexer を使ってトークンに分割し、Parser を使って逆ポーランド表記のトークン列を生成します。
main 関数
generate_reverse_polish_notation を使って、指定された式を逆ポーランド表記で出力します。
逆ポーランド記法は、演算子がオペランドの後ろに置かれるので、式を解析してトークン列に変換することで、演算の優先順位を反映した形で数式を表現することができます。
----
これらのコードは、与えられた数学式を逆ポーランド記法（Reverse Polish Notation, RPN）に変換する方法を示していますが、アプローチが異なります。
1番目のコードは、文字列を直接解析してトークンに分割し、その後逆ポーランド記法に変換しています。一方、2番目のコードは、字句解析器（lexer）とパーサー（parser）を使用して、トークンに分割し、その後パースして逆ポーランド記法に変換しています。
1番目のコードは、基本的な数値と演算子の処理に集中しています。一方で、2番目のコードは字句解析や構文解析の段階を厳密に分離しています。また、2番目のコードは小数点もサポートしており、より柔軟な数値表現を可能にしています。
どちらのコードも同じ目的を果たしていますが、アプローチの違いが見られます。1番目のコードはシンプルで直感的ですが、拡張性に欠けるかもしれません。
一方で、2番目のコードはより複雑ですが、より柔軟で拡張性があります。それぞれのコードには長所と短所がありますが、どちらも与えられた数式を逆ポーランド記法に変換する点では同等の結果を提供します。実際には２番めのコードは不動小数点数やカッコに対応しています。
use nom::character::complete::{char, digit1};
use nom::combinator::map;
use nom::multi::many0;
use nom::sequence::delimited;
use nom::IResult;
enum Token {
Number(i32),
Plus,
Minus,
Multiply,
Divide,
}
fn main() {
let input = "12+34*56/78";
let (_, tokens) = parse_input(input).unwrap();
let rpn = infix_to_rpn(tokens);
println!("{:?}", rpn);
}
fn parse_input(input: &str) -> IResult<&str, Vec> {
many0(parse_token)(input)
}
fn parse_token(input: &str) -> IResult<&str, Token> {
let (input, token) = delimited(
nom::character::complete::space0,
nom::branch::alt((
map(digit1, |s: &str| Token::Number(s.parse().unwrap())),
map(char('+'), |_| Token::Plus),
map(char('-'), |_| Token::Minus),
map(char('*'), |_| Token::Multiply),
map(char('/'), |_| Token::Divide),
)),
nom::character::complete::space0,
)(input)?;
Ok((input, token))
}
fn infix_to_rpn(tokens: Vec) -> Vec {
let mut rpn = Vec::new();
let mut stack = Vec::new();
for token in tokens {
match token {
Token::Number(_) => rpn.push(token),
Token::Plus | Token::Minus | Token::Multiply | Token::Divide => {
while let Some(top) = stack.last().copied() {
if precedence(&token) <= precedence(⊤) {
rpn.push(stack.pop().unwrap());
} else {
break;
}
}
stack.push(token);
}
}
}
while let Some(op) = stack.pop() {
rpn.push(op);
}
rpn
}
fn precedence(token: &Token) -> i32 {
match token {
Token::Multiply | Token::Divide => 2,
Token::Plus | Token::Minus => 1,
_ => 0,
}
}
このコードは、nomというパーサーコンビネータライブラリを使用して、与えられた文字列を解析し、トークンに分割する機能を持っています。前のコードと比較してみましょう。
parse_input 関数: many0コンビネータを使って、parse_tokenを繰り返し適用し、入力文字列をトークンのベクターに変換します。IResult型を返します。
parse_token 関数: delimitedコンビネータを使用してトークンの前後のスペースを処理し、与えられた文字列を様々なルールにマッチングさせます。数字、演算子それぞれのパースを行い、Token列挙型のトークンを返します。
infix_to_rpn 関数: 前のコードと同じですが、与えられたトークンのベクターを逆ポーランド記法に変換する機能を持っています。
このコードは、nomを使ってトークン分割を行い、より柔軟なパースを可能にしています。nomを使用することで、トークンのパースやスペースの処理など、より複雑なルールを柔軟に記述できるようになります。
extern crate num_complex;
use num_complex::Complex;
enum Token {
Number(Complex),
Plus,
Minus,
Multiply,
Divide,
LParen,
RParen,
EOF,
}
struct Lexer<'a> {
input: &'a str,
position: usize,
}
impl<'a> Lexer<'a> {
fn new(input: &'a str) -> Lexer<'a> {
Lexer { input, position: 0 }
}
fn skip_whitespace(&mut self) {
while self.position < self.input.len() && self.input.chars().nth(self.position).unwrap().is_whitespace() {
self.position += 1;
}
}
fn next_token(&mut self) -> Token {
self.skip_whitespace();
if self.position >= self.input.len() {
return Token::EOF;
}
let current_char = self.input.chars().nth(self.position).unwrap();
match current_char {
'+' => {
self.position += 1;
Token::Plus
}
'-' => {
self.position += 1;
Token::Minus
}
'*' => {
self.position += 1;
Token::Multiply
}
'/' => {
self.position += 1;
Token::Divide
}
'(' => {
self.position += 1;
Token::LParen
}
')' => {
self.position += 1;
Token::RParen
}
'i' => {
self.position += 1;
Token::Number(Complex::new(0.0, 1.0))
}
_ if current_char.is_digit(10) || current_char == '.' => {
let start = self.position;
while self.position < self.input.len()
&& (self.input.chars().nth(self.position).unwrap().is_digit(10)
|| self.input.chars().nth(self.position).unwrap() == '.')
{
self.position += 1;
}
let number_str = &self.input[start..self.position];
let number = number_str.parse::().unwrap();
if let Some('i') = self.input.chars().nth(self.position) {
self.position += 1;
Token::Number(Complex::new(0.0, number))
} else {
Token::Number(Complex::new(number, 0.0))
}
}
_ => panic!("Invalid character found: {}", current_char),
}
}
}
struct Parser<'a> {
lexer: Lexer<'a>,
current_token: Token,
}
impl<'a> Parser<'a> {
fn new(mut lexer: Lexer<'a>) -> Parser<'a> {
let current_token = lexer.next_token();
Parser { lexer, current_token }
}
fn eat(&mut self, token: Token) {
if self.current_token == token {
self.current_token = self.lexer.next_token();
} else {
panic!("Invalid syntax");
}
}
fn factor(&mut self) -> Complex {
let token = self.current_token.clone();
match token {
Token::Number(num) => {
self.eat(Token::Number(num));
num
}
Token::LParen => {
self.eat(Token::LParen);
let result = self.expr();
self.eat(Token::RParen);
result
}
_ => panic!("Invalid syntax"),
}
}
fn term(&mut self) -> Complex {
let mut result = self.factor();
while vec![Token::Multiply, Token::Divide].contains(&self.current_token) {
let token = self.current_token.clone();
match token {
Token::Multiply => {
self.eat(Token::Multiply);
let next_factor = self.factor();
result = result * next_factor;
}
Token::Divide => {
self.eat(Token::Divide);
let next_factor = self.factor();
result = result / next_factor;
}
_ => panic!("Invalid syntax"),
}
}
result
}
fn expr(&mut self) -> Complex {
let mut result = self.term();
while vec![Token::Plus, Token::Minus].contains(&self.current_token) {
let token = self.current_token.clone();
match token {
Token::Plus => {
self.eat(Token::Plus);
let next_term = self.term();
result = result + next_term;
}
Token::Minus => {
self.eat(Token::Minus);
let next_term = self.term();
result = result - next_term;
}
_ => panic!("Invalid syntax"),
}
}
result
}
}
fn main() {
let lexer = Lexer::new("(2+ 3i)*4i");
let mut parser = Parser::new(lexer);
let result = parser.expr();
println!("{:?}", result);
}
このコードは、数式をパースして複素数を計算する簡単な計算機の基本的な実装です。Rustの機能を活用して、トークン列を生成するLexerと、そのトークン列を解析して計算を行うParserを定義しています。
Tokenは、パーサーが認識するトークンの種類を表すenumです。Lexerは文字列を受け取り、その文字列をトークンに分割する役割を果たします。各トークンは、演算子や数値、括弧などを表現しています。Parserは、Lexerが生成したトークン列を受け取り、それを解析して数式を計算します。
Lexerは空白をスキップし、文字列を一文字ずつ見ていき、トークン列を生成します。Parserはトークン列を再帰的に解析し、四則演算を行って複素数を計算します。演算子の優先順位や括弧の処理も考慮されています。
このコードは、入力文字列 (2+ 3i)*4i を受け取り、それを計算して結果を表示します。各段階でトークンが正しく識別され、演算子や数値が正しく解釈されることを期待しています。
コード内のパニックは、予期しないトークンや構文エラーがあった場合に発生します。これらのエラーは、コードが期待する形式に文字列が合致しなかった場合に発生します。
このコードを用いると、複雑な数式も計算できますが、入力の検証やエラー処理についてはまだ改善の余地があります。
extern crate num_complex;
use num_complex::Complex;
fn main() {
// 複素数の作成
let a = Complex::new(3.0, 4.0);
let b = Complex::new(-2.0, 5.0);
println!("a: {a}");
println!("b: {b}");
println!("a + b: {}", a + b);
println!("a - b: {}", a - b);
println!("a * b: {}", a * b);
println!("a / b: {}", a / b);
}
実行結果:
a: 3+4i
b: -2+5i
a + b: 1+9i
a - b: 5-1i
a * b: -26+7i
a / b: 0.4827586206896552-0.7931034482758621i
このコードは、num-complexクレートを使用して複素数を扱うRustの例です。
extern crate num_complex; および use num_complex::Complex; は、num-complexクレートからComplex型を使えるようにするためのインポートです。
Complex::new(3.0, 4.0); および Complex::new(-2.0, 5.0); は、実部と虚部を指定して複素数を作成しています。
println!("a: {a}"); および println!("b: {b}"); は、複素数 a と b を出力しています。
b: {}", a * b);、println!("a / b: {}", a / b); は、それぞれ複素数 a と b の加算、減算、乗算、除算を行っています。結果を文字列として出力しています。
修正されたコードは次のようになります：
Goから順列・組合わせを移植
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=73612aa97bd4a1541a0313f38effde87 順列]:
fn permutation(s: &[T], n: usize) -> Vec> {
if s.is_empty() {
panic!("slice is nil");
}
if n == 1 {
let mut result = Vec::new();
for v in s.iter() {
result.push(vec![v.clone()]);
}
return result;
}
let mut result = Vec::new();
for (i, v) in s.iter().enumerate() {
let mut sf = Vec::new();
for (j, w) in s.iter().enumerate() {
if j != i {
sf.push(w.clone());
}
}
for w in permutation(&sf, n - 1) {
let mut v_w = vec![v.clone()];
v_w.extend_from_slice(&w);
result.push(v_w);
}
}
result
}
fn main() {
println!("{:?}", permutation(&[1, 2, 3], 1));
println!("{:?}", permutation(&[0, 1, 2], 2));
println!(
"{:?}",
permutation(&["abc".to_string(), "def".to_string(), "xyz".to_string()], 3)
);
println!("{:?}", permutation::(&[], 2));
}
実行結果:
1], [2], [3
0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1
"abc", "def", "xyz"], ["abc", "xyz", "def"], ["def", "abc", "xyz"], ["def", "xyz", "abc"], ["xyz", "abc", "def"], ["xyz", "def", "abc"
解説
上記の移植において、主に以下の点に注意が必要でした。
ジェネリック型の宣言方法がGoとは異なるため、func Permutation[T any](s []T, n int) のような書き方はできません。Rustでは、fn permutation(s: &[T], n: usize) のように、の前に:を付けてジェネリック境界を宣言します。
Goのmakeは、新しい配列やスライスを作成するための組み込み関数ですが、RustではVec::with_capacity()やVec::new()を使用します。
panic!("slice is nil")は、Rustのパニック処理において、エラーメッセージを伴うパニックを発生させるために使用されます。
Vecに要素を追加するには、Goのappendに相当するRustのメソッドであるVec::push()や、Vec::extend_from_slice()を使用します。また、Vecの要素数は、len()ではなくlen()とVec::capacity()の両方を使って取得する必要があります。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=06e15597fcf3bdc585abeccd3edb9454 組合わせ]:
fn combination(s: &[T], n: usize) -> Vec> {
if s.is_empty() {
panic!("slice is empty");
}
if n == 1 {
let mut result = Vec::new();
for v in s {
result.push(vec![v.clone()]);
}
return result;
}
let mut result = Vec::new();
for i in 0..=(s.len() - n) {
let v = s[i].clone();
for w in combination(&s[i + 1..], n - 1) {
let mut res = vec![v.clone()];
res.extend(w);
result.push(res);
}
}
return result;
}
fn main() {
println!("{:?}", combination(&[1, 2, 3], 1));
println!("{:?}", combination(&[0, 1, 2], 2));
println!(
"{:?}",
combination(&["abc", "def", "xyz"], 3)
);
// println!("{:?}", combination(&[], 2)); 要素型が確定できない
}
実行結果:
1], [2], [3
0, 1], [0, 2], [1, 2
"abc", "def", "xyz"
解説
上記の移植において、主に以下の点に注意が必要でした。
Rustのジェネリック関数の型パラメータには制約が必要なため、Tがクローン可能であることを示すCloneトレイトを指定する必要があります。
Goのスライスと異なり、Rustのスライスは要素数が0の場合にも安全であるため、ErrNilSliceに相当する処理はslice.is_empty()で判定することができます。
Goのスライスと異なり、Rustのスライスは範囲外アクセスがパニックを引き起こすため、再帰呼び出し時にはスライスの範囲を明示的に指定する必要があります。 |
2,871 | ----
OpenOffice.org（以下、「OOo」）は、オープンソースでフリーウェアとして配布されているアプリケーションスウィート（アプリケーションの集合体）です。Microsoft Office（以下、MS Office）と同様に、数本のソフトウェアをまとめてOOoと呼んでいます。もともとはサン・マイクロシステムズ社のStar Suiteというソフトウェアをオープンソースとして公開したものが起源となっているため、初めから商用レベルのクオリティがありました。
特徴としては、オープンソースで無償で利用できること、またそれゆえに柔軟でスピーディな開発がなされていること、そしてMS Officeと高い互換性を有していることなどが挙げられましょう。極めて簡単に表現すると、「無償で使えるMS Office」ということです。実際には、互換性も完全ではなく、機能の食い違いやインターフェースなどの違いもまだまだ多いですが、MS Officeのいいとこどりと独自のアイデアを次々と搭載し、着実に進化を続けています。
独自機能の代表例として、OOoは、早い段階でpdfファイル生成機能を持っていました。pdfは、コンピュータに Adobe Reader という無料のソフトが入っていれば、どんな端末でも同じような表示が可能なファイルの形式です。そのため、どうしてもMS Officeとの互換性ゆえに問題があって相手にファイルを送っても表示できない、という場合でも、pdf形式で送れば容易に閲覧することができます。また、OOoになにも追加してインストールする必要なくpdfファイルを作成することが出来ます。
また、2005年10月にリリースされたOOo2.0では、新たにXMLに基いた形式 (OpenDocument) でも文書を保存できるようになりました。これにより、さらに様々な環境に対して互換性が高まりました。
各ソフトを大まかに紹介します。
Writer:MS OfficeのWordに相当する、ワープロソフト。細かいレイアウトや機能、素材などの違いを除けば、ほとんどWordと変わりないと言ってよいでしょう。
Calc
表計算ソフトです。
Microsoft の 'Excel' や、旧ロータス・デベロップメント社の 'Lotus 1-2-3' のワークシートも読み込むことができ、Excel における Basicマクロにも互換性があります。
ワークシート内で使用する標準関数群も、Excel と同じものが用意されていますが、引数の区切り文字、シート参照の際の記号など表記法が異なっています。
Impress:MS OfficeのPowerPointに相当する、プレゼンテーションソフト。機能的にはほぼ同等です。
Base:データベースソフト。データベース機能は以前からありましたが、2.0になって単体のソフトで実装されました。
Math:数式エディタ
Draw:図形描画
HTML Editor
OOoにおけるワープロソフトです。基本的な使いかたは、類似するMicrosoft OfficeのWordと大きくは変わりません。
OOoには、「スタイル」と呼ばれる独自の仕組みがあります。これは、文書中に使われる書式をひとまとめにしたもので、スタイルを適用したものを一括して変更することが出来ます。これにより、本文、見出しなどの見栄えを一定の形に整えることが出来ます。
F11を押すと、「スタイルと書式」とタイトルのあるボックスが出現します。デフォルトでは「本文」「見出し」などのいくつかのスタイルが存在しています。このスタイルをダブルクリックすると、その時点でカーソルの置かれている文書にたいして、そのスタイルを適用することが出来ます。また、水やりモードを使うと、マウスで簡単にいくつものをスタイルを適用出来ます。
スタイルを編集するには、コンテキストメニューを呼び出して、「変更」を選択します。すると、そのスタイルにおいて変更可能な項目が出ます。また、編集できるスタイルは、利用しているアプリケーションや適用する対象によって異なります。
管理
そのスタイルの名前、継承元などを定義出来ます。
インデントと間隔
その文書の段落に対するインデント、改行の間隔などを定義出来ます。
配置
その段落内での文書のレイアウトを定義出来ます。
体裁
その文書に置けるハイフネーションなどを定義出来ます。
日本語の体裁
日本語を利用した際の改行、ぶらざげなどを定義出来ます。
フォント
その文書において利用するフォントを指定出来ます。
フォント効果
その文書において、フォントの見栄えを定義出来ます。
位置
その文書における文字の配置、文字間隔などを定義出来ます。
日本語レイアウト
日本語におけるレイアウトの定義が出来ます。
番号付け
改行した際の番号や箇条書きの定義が出来ます。
タブ
タブを挿入した際の定義が出来ます。
ドロップギャップ
文書の最初の一文字を強調する設定が出来ます。
背景
そのスタイル内の背景を定義出来ます。
外枠
そのスタイル内の枠を定義出来ます。
条件
スタイルを適用する際の条件を定義出来ます。
数
Calcにおいて、セルで利用する書式を定義出来ます。
ページ
ページ全体のスタイルを編集する際に利用でき、印刷の大きさなどを定義出来ます。
ヘッダ
印刷する際のヘッダのスタイルを定義出来ます。
フッタ
印刷する際のフッタのスタイルを定義出来ます。
表
Calcにおいて、印刷する方向などを定義出来ます。
箇条書き
Impressにおいて、改行する際の箇条書きの種類を定義出来ます。
番号付け
Impressにおいて、改行する際の番号付けの種類を定義出来ます。
図
Impressにおいて、改行する際の箇条書きの図を定義出来ます。
オプション
Impressにおいて、レベルが変更されたときのレイアウトを定義出来ます。
コネクタ
Drawにおいて、オブジェクトを結ぶコネクタの種類を定義出来ます。
透過性
Drawにおいて、オブジェクトの透過を定義出来ます。
テキスト
Drawにおいて、オブジェクトにテキストを挿入した際の定義が出来ます。
テキストアニメーション
Drawにおいて、オブジェクトにテキストを挿入した際のアニメーションを定義出来ます。
寸法の記入
Drawにおいて、オブジェクトに記入する寸法を定義出来ます。
OOoは、他のオフィススイートと同じように、マクロを利用して、作業の簡略化や機能の拡張を行うことが出来ます。
OpenOffice.org
OpenOffice.org
OpenOffice.org
OpenOffice.org
Vapautta tietoyhteiskuntaan!/OpenOffice.org
OpenOffice.org
אופן אופיס
OpenOffice.org a gyakorlatban
OpenOffice.org
ღია ოფისი (Open Office)
Portaal:OpenOffice.org
OpenOffice.org
OpenOffice.org
คู่มือติดตั้ง OpenOffice.org 2.0
OpenOffice.org |
2,872 | 法学＞民事法＞コンメンタール民法＞第3編 債権 (コンメンタール民法)
（賃貸借）
第601条
賃貸借は、当事者の一方がある物の使用及び収益を相手方にさせることを約し、相手方がこれに対してその賃料を支払うこと及び引渡しを受けた物を契約が終了したときに返還することを約することによって、その効力を生ずる。
2017年改正にて、上記下線部を追加。
第7節賃貸借
第三者に対抗できる借地権を有する者は、その土地に建物を建ててこれを使用する者に対し直接その建物の収去、土地の明渡を請求する妨害排除請求権を行使することができる。
第三者に対抗できる賃借権を有する者は、その土地に建物を有する第三者に対し、建物の収去、土地の明渡を請求することができる。
賃貸人の地位は賃貸物の譲渡に伴い当然に移動するか。
賃貸物の所有権が当初の賃貸人から順次移転し現在の現所有権者に帰した場合、当初の賃貸人と賃借人間の賃貸借は借家法上、現所有者に承継されたものと解すべきであるから現所有者は賃借人に本件家屋の使用収益をさせる義務を負う。
本判例の趣旨は不動産に関しては2017年改正で新設された第605条の2に制定された。
家屋賃借人の事実上の養子として待遇されていた者が賃借人の死後において家屋に居住できるとされた事例。
家屋賃借人の事実上の養子として待遇されていた者が賃借人の死後も引き続き家屋に居住する場合、賃借人の相続人らにおいて養子を遺産の事実上の承継者と認め、祖先の祭祀も同人に行わせる等（当審判決理由参照）の事情があるときは、その者は、家屋の居住につき、相続人らの賃借権を援用して賃貸人に対抗することができる。
土地賃貸借の合意解除は地上建物の賃借人に対抗できるか。
土地賃借人と賃借人との間において土地賃貸借契約を合意解除しても、土地賃貸人は、特別の事情がないかぎり、その効果を地上建物の賃借人に対抗できない。
土地の継続的な用益という外形的事実が存在し、かつ、それが賃借の意思に基づくことが客観的に表現されているときは、土地賃借権を時効により取得することができる。
賃貸借の目的となつている土地の所有者が、その所有権とともに賃貸人たる地位を他に譲渡する場合には、賃貸人の義務の移転を伴うからといつて、特段の事情のないかぎり、賃借人の承諾を必要としない。
本判例の趣旨は不動産に関しては2017年改正で新設された第605条の2に制定された。
家屋賃貸借における敷金は、賃貸借終了後家屋明渡義務履行までに生ずる賃料相当額の損害金債権その他賃貸借契約により賃貸人が賃借人に対して取得する一切の債権を担保するものであり、敷金返還請求権は、賃貸借終了後家屋明渡完了の時においてそれまでに生じた右被担保債権を控除しなお残額がある場合に、その残額につき具体的に発生するものと解すべきである。
家屋の賃貸借終了後明渡前にその所有権が他に移転された場合には、敷金に関する権利義務の関係は、旧所有者と新所有者との合意のみによつては、新所有者に承継されない。
家屋の賃貸借終了後であつても、その明渡前においては、敷金返還請求権を転付命令の対象とすることはできない。
土地又は建物の賃借人は、賃借物に対する権利に基づき自己に対して明渡を請求することができる第三者からその明渡を求められた場合には、それ以後、賃料の支払を拒絶することができる。
抵当不動産につき、抵当権者自身を権利者とする、賃借権又は抵当債務の不履行を停止条件とする条件付賃借権が設定され、その登記又は仮登記が抵当権設定登記と順位を前後して経由された場合において、競売申立までに対抗要件を具備した短期賃借権者が現われないまま、競落によつて第三者が当該不動産の所有権を取得したときには、特段の事情のない限り、抵当権者の賃借権は、それが短期賃借権であつても消滅する。
賃貸借が賃借人の債務不履行を理由とする解除により終了した場合、賃貸人の承諾のある転貸借は、原則として、賃貸人が転借人に対して目的物の返還を請求した時に、転貸人の転借人に対する債務の履行不能により終了する。
時効による農地の賃借権の取得については，農地法3条の規定の適用はない。
相続開始から遺産分割までの間に共同相続に係る不動産から生ずる金銭債権たる賃料債権は，各共同相続人がその相続分に応じて分割単独債権として確定的に取得し，その帰属は，後にされた遺産分割の影響を受けない。
----
{{前後
|民法
|第3編 債権
第2章 契約
第7節賃貸借
|民法第600条（損害賠償及び費用の償還の請求権についての期間の制限）
|民法第602条（短期賃貸借）
601
601 |
2,873 | 3年生まででは、千万の位についてまで学びましたが、それより大きい数について学びましょう。
次の数字を読んでみましょう。
どんな数でも、10倍すると、位が1つ上がり、右はしに0を1こつけた数になりますね。千万を10倍した数を、 一億 （いちおく）といいます。
次の数を読みましょう。
128734906
'''です。
100000000が 1億 です。 1 のうしろに 0 が 8個 あります。
一億の次は、十億、百億、千億です。
千億の十倍は、何かを考えてみましょう。千億を10倍すると、位がひとつ上がり、 一兆（いっちょう）という数になります。億の位の次は、兆の位になるのです。
1000000000000 が 1兆 です。 1 のうしろに 0 が 12個 あります。
一兆の次は、十兆、百兆、千兆です。
0、1、2、3、4、5、6、7、8、9の10この数を使って、一番大きい整数を作りましょう。一番大きい整数を作るには、大きい数からじゅんにならべましょう。答えは、9876543210です。
0、1、2、3、4、5、6、7、8の9つの数を使って、一番小さい整数を作りましょう。しかし、「012345678」ではありません。0は、一番左はしにつけることはできません。そのため、0は、左から2番目につけて、答えは、102345678となります。
1兆に1000をかけた数は 1000兆（せんちょう） です。
1兆に10000をかけた数は 1京（いっけい） と いいます。
10000000000000000 が 1京 です。1京は 1 のうしろに 0 が 16個 あります。
小学校の算数では、ふつうは 1000兆の位までの数字しか、つかいません。
さらにそのさきは、つぎのようになっています。
1の後ろに0が20個で 1垓（1がい） です。
1の後ろに0が24個で 1𥝱（1じょ） です。
1の後ろに0が28個で 1穣（1じょう） です。
1の後ろに0が32個で 1溝（1こう） です。
1の後ろに0が36個で 1澗（1かん） です。
1の後ろに0が40個で 1正（1せい） です。
1の後ろに0が44個で 1載（1さい） です。
1の後ろに0が48個で 1極（1ごく） です。
1の後ろに0が56個で 1阿僧祇（1あそうぎ） です。
1の後ろに0が60個で 1那由他（1なゆた） です。
1の後ろに0が64個で 1不可思議（1ふかしぎ） です。
1の後ろに0が68個で 無量大数（むりょうたいすう） です。
小学校の算数の計算では、ふつうは、「垓」や「𥝱」や「無量大数」などの大きな位（くらい）は、使いません。
小学校の算数では、億（おく）や兆（ちょう）の使い方を、おぼえてください。
今までに、たし算・ひき算・かけ算・わり算の4つを勉強しました。ここでは、それらがまざった式の計算について学習しましょう。
このような計算は、下のようなじゅんばんで計算するのがきまりです。
また、同じじゅんいにあるものは式の左にあるものから計算することになっています。
では、次の計算をしてみましょう。
この式にはかっこがあるのでかっこの中身を先に計算します。またかっこの中にある式の計算のじゅんばんも上にある通りです。まずはかっこの中にあるわり算から計算します。8\div2=4 なので、このような式になります。
\begin{matrix}2+5\times(4-3)\times4-1\end{matrix}
まだ かっこの中には 式があるので 次はその部分を 計算します。 \begin{matrix}4-3=1\end{matrix} です。 このように かっこの 中身を 全て 計算すること を かっこを外す と言います。
\begin{matrix}2+5\times1\times4-1\end{matrix}
これで かっこを 外すことが できました。 たし算 と かけ算 が のこっていますが 上のじゅんばんを 見ると つぎ に やるのは かけ算 です。
左から 計算 するので、 まずは 5\times1=5 を計算します。
\begin{matrix}2+5\times4-1\end{matrix}
つぎはさっき計算しなかった かけ算 の 5\times4=20 を 計算します。
\begin{matrix}2+20-1\end{matrix}
これで かけ算が すべて終わりました。 のこり は たし算 ですが、 これも 同じように 左から 計算します。\begin{matrix}2+20=22\end{matrix}です。
\begin{matrix}22-1=21\end{matrix}
最後に のこった式を 計算します。 すると 答えの 21が 出てきました。
たし算・ひき算・かけ算・わり算が まじった式を計算する場合は このように行います。
{{コラム|4つの4|
「4つの4」とは、4つの4と計算記号を使って いろいろな数を作るパズルです。
たとえば、答えが0になる式には、
4 + 4 - 4 - 4
4 \times 4 - 4 \times 4
(4 -4 )\times (4-4)
などがあります。
このようにして、答えが1から9になる式を作ってみましょう。
考えてみた後、答えを見てください。4つの4の答え
みなさんは、「1.5」や「0.3」のような数を見たことをありますか？このように、「.」がつく数について学習しましょう。
0.1 や 0.5 や 4.8 のような数を 小数 （しょうすう）といいます。真ん中の「.」を、 小数点（しょうすうてん） といいます。小数点の右の数字を「小数第1位」（しょうすう だい いちい）や「\frac{1}{10}の位」（じゅうぶんのいちのくらい）と、いいます。
0 や 1 や 10 などのような数を、つまり 小数では ない 数を、 整数 （せいすう）と いいます。
たとえば 3563 は整数です。たとえば 100.01 は整数では、ありません。
分数の種類には、大きく分けて3通りあります。
真分数(しんぶんすう)
分母よりも分子の数が小さい分数です。
たとえば\frac 1 2とか\frac 3 4とか\frac 5 7 のようなものです。
仮分数(かぶんすう)
分母と分子の数字が同じであるか、分子の数が分母より大きい分数のことです。
たとえば\frac 2 2 とか\frac 7 4とか\frac 9 5 のようなものがあります。
帯分数(たいぶんすう)
整数と真分数の和を表します。真分数の左に整数がついたものです。
たとえば1 \frac 2 3（1 +\frac 2 3)とか3 \frac 1 4とか4 \frac 3 5 のようなものがあります。
を計算しましょう。
分数の足し算は、つぎのように、考えて、計算します。
つぎの図を、見てください。
分母が同じ場合の、分数の、足し算 :
よって、
です。
を計算すると、どうでしょうか。
よって、
です。
次のたし算の問題を解いてみましょう。
ジュースがパックに、\frac{3}{5}L、ペットボトルに\frac{4}{5}L入っています。合わせて何リットルありますか。
式は\frac{3}{5} + \frac{4}{5}となります。
計算のしかたを考えてみましょう。
\frac{3}{5}は\frac{1}{5}の3こ分、\frac{4}{5}は\frac{1}{5}の4こ分です。
したがって、\frac{1}{5}が(3+4=7) より7こ分あります。
\frac{1}{5}が7こ集まると、\frac{7}{5}となります。
なので、\frac{3}{5} + \frac{4}{5} = \frac{7}{5}となります。答えは\frac{7}{5}Lです。
分数に直してもかまいません。
次のひき算の問題を解いてみましょう。
ジュースが\frac{7}{6}Lあります。\frac{2}{6}L飲むと、残りは何Lですか。
式は\frac{7}{6} - \frac{2}{6}となります。
計算のしかたを考えてみましょう。
\frac{7}{6}は\frac{1}{6}が7個、\frac{2}{6}は\frac{1}{6}が2こ分です。
したがって、\frac{1}{6}が(7-2=5)より5こ分あります。
\frac{1}{6}が5こ集まると、\frac{5}{6}となります。
なので、\frac{7}{6} - \frac{2}{6} = \frac{5}{6}となります。答えは\frac{5}{6}Lです。
数のはんいの表し方には「以上」「以下」「未満」があります。
といいます。'''
たとえば、「5以上」といえば、5, 6, 7, 8, 9...のように、5と5より大きい数をさします。
といいます。'''
たとえば、「5以下」といえば、5, 4, 3, 2, 1...のように、5と5より小さい数をさします。
ある数よりも小さい場合、その数の 未満（みまん） である、というふうに言います。
たとえば、「5未満」といえば、5は数えずに4, 3, 2, 1...のように、5より小さい数をさします。
による）
です。
そこで、数を分かりやすくするために およその数 について考えてみましょう。
およその数のことを がい数 といいます。
ある位を見た時に、 その数字の1つ上の位に1を足して、それ以下の数字を全て0にする ことを 切り上げ （きりあげ）といいます。
また、逆に その数字の位以下の数字を全て0にする ことを 切り捨て （きりすて）といいます。
では東京23区の人口を一万の位で切り上げたり切り捨ててみましょう。一万の位で切り上げる場合は1つ上の位である十万の位に1を足して、一万の位以下の全ての位を0にします。例えばこの場合は 9300000人 となります。
同じように一万の位で切り捨ててみると、一万の位以下の全ての位を0にすればいいので、 9200000人 となります。
ある位を見た時に、 その数字が0～4の場合は切り捨てて、5～9の場合は切り上げる ことを 四捨五入 （ししゃ ごにゅう）といいます。また、概数（がいすう）と言われるものは ほとんどの場合は 四捨五入のことを指します。
では、東京23区の人口を、千の位と一万の位で四捨五入してみましょう。
千の位の数字は「2」です。つまり、この場合は切り捨てればよいのです。すると、 9270000人 となります。
また、一万の位の数字は「7」です。つまり、この場合は切り上げればよいのです。すると、 9300000人 となります。
問題では「一万の位で四捨五入」や「千の位まで四捨五入」、「上から1けたまでのがい数」という書かれ方をよくします。この時、四捨五入をする位が少し違ってきます。
例えば、「一万の位で四捨五入」の「で」の場合、その位（ここでは一万の位）で四捨五入をします。
一方で、「千の位まで四捨五入」の「まで」の場合、その1つ下の位（ここでは百の位）で四捨五入をします。
さらに、「上から1けたまでのがい数」という場合は指定された1つ下の位（ここでは上から2けた目の位）で四捨五入をします。
「で」とついている場合は指定された位で四捨五入します。また「まで」となっている場合は指定された位の1つ下の位で四捨五入します。
四捨五入やがい数をつかって、おおよその計算をすることを がい算 といいます。
たとえば
を、十万未満の位は、四捨五入で計算した場合、
に、なります。だいたい同じ数字になりましたね。
これはがい算を、したことになります。
がい算は、べつに足し算だけでは、ありません。引き算でもかけ算でもわり算でも、四捨五入や切り上げ・切り捨てなどをしてがい数を使って計算していればがい算です。
250px|right|分度器
を使ってはかることができます。
」とよみます。一回転したときの角の大きさは360^\circです。
90^\circの角の大きさを直角といいます。
right|250px
'''は、物の広さを表すものです。しかし、いままでの単位では、どうやって表せばいいかわかりません。
そこで、1辺が1cmの正方形の面積を1cm2(1平方センチメートル)とします。
面積は、1辺1cmの正方形がいくつ分かで表します。
たて4cm、よこ5cmの長方形の面積を考えてみましょう。
1辺が1cmの正方形がたてに4つ、よこに5つしきつめられているので、
4\times 5 = 20 より、20cm2です。
められます(「横×たて」でもかまいません)。
×1辺'''で、求められます。
----
である'''といいます。
thumb|left|120px|垂直
である'''といいます。
左の図で2本の黒の直線は平行になっています。また、平行な2本の直線は交わりません。
thumb|left|120px|平行
thumb|left|120px|台形
'''といいます。
左の図で、上の辺と下の辺は平行になっています。
'''といいます。
平行四辺形の、向かい合った辺の長さは等しくなっています。
また、向かい合った角の大きさも等しくなっています。となり合った角の角度をたすと、180°になります。
thumb|left|120px|ひし形
thumb|right|120px|ひし形
4つの辺の長さがみな等しい四角形を、ひし形（ひしがた）といいます。
ひし形の、向かい合った辺は平行で、向かい合った角の大きさは等しくなっています（右の図を見てください）。
thumb|left|120px|対角線
向かい合った頂点をつないだ直線を、対角線（たいかくせん）といいます。左の図では、ABが対角線になっています。
四角形の対角線の数は2本です。
thumb|left|180px|直方体
ふでばこのような同じ大きさの長方形でかこまれた立体を 直方体 （ちょくほうたい）といいます。
立方体や直方体は、正方形や長方形で、かこまれています。
''' といいます。
たとえば立方体の面は6個あって、6個とも、面は、すべて、正方形です。
が 8個 あります。（数えてみてください。）
直方体には、辺が 12本 あります。（数えてみてください。）
直方体の展開図は11種類あります。
thumb|right|80px|立方体
さいころのような、すべての面が同じ大きさの正方形である立体を 立方体 （りっぽうたい）と言います。
''' といいます。
立体を辺にそって、つながったまま、切り開いたものを 展開図（てんかいず） といいます。
立方体の展開図は、次の11種類です。
Planificacao cubo.gif
といいます。
といいます。
といいます。
といいます。
たとえば、13÷3=4あまり1 となりますが、このときの商は4です。あまりの1は商ではありません。
thumb|600px|１年間の気温の、折れ線グラフの例。月平均で最低気温と最高気温が示されている。Jは1月のこと、Fは2月のこと、Mは3月、・・・、Dは12月。Month とは、1月や２月などの「月」のこと。Temparature とは「温度」のこと。
れ線グラフという。
上の表で、0℃よりも、ひくい、氷点下の温度は、マイナス「ー」で、あらわした。
折れ線グラフにすると、かわっていくようすが、わかりやすい。
っていく（へっていく）場合である。
折れ線が平らな場合は、増えも減りもせず、かわらない場合である。
今までに習った知しきを使って、問題をもっとたくさんときたい人は、「4年生のための算数ドリル」のページを見に行ってください。
下の「4年生のための算数ドリル」の文字をおすと、見ているページがドリルのぺージにかわります。 |
2,874 | 法学＞民事法＞商業登記法＞コンメンタール商業登記法
（商号の登記の抹消）
第33条
次の各号に掲げる場合において、当該商号の登記をした者が当該各号に定める登記をしないときは、当該商号の登記に係る営業所（会社にあつては、本店。以下この条において同じ。）の所在場所において同一の商号を使用しようとする者は、登記所に対し、当該商号の登記の抹消を申請することができる。
登記官は、前項において準用する第136条の規定により異議が理由があるとする決定をしたときは、第1項の申請を却下しなければならない。
3項
----
{{前後
|商業登記法
|第3章 登記手続
第2節 商号の登記
|商業登記法第32条（相続人による登記）
|商業登記法第34条（会社の商号の登記）
033 |
2,875 | 法学＞コンメンタール＞コンメンタール刑事訴訟法=コンメンタール刑事訴訟法/改訂
（不出頭と診断書の提出）
第278条
公判期日に召喚を受けた者が病気その他の事由によって出頭することができないときは、裁判所の規則の定めるところにより、医師の診断書その他の資料を提出しなければならない。
----
{{前後
|刑事訴訟法
|第2編 第一審
第3章 公判
第1節 公判準備及び公判手続き
|第277条（不当な期日変更に対する救済）
|第278条の2（検察官・弁護人に対する出頭命令）
278 |
2,876 | 公布日:1973年11月6日総理府告示30号
[http://www.env.go.jp/hourei/syousai.php?id=18000125]
自然は、人間生活にとつて、広い意味での自然環境を形成し、生命をはぐくむ母胎であり限りない恩恵を与えるものである。すなわち、それは、
②それ自体が豊かな人間生活の不可欠な構成要素をなす。
殊に我が国は、人間と自然と人間の造型作品とが有機的な統一体をなすというユニークな文化的伝統をもつてきた。
我々の社会生活におけるこの自然の役割を思うとき、なによりも、我々がその価値を高く評価し、保護保全の精神を我々の身についた習性とすることこそが、あらゆる対策の第一歩であるというべきであろう。この立場に立つならば、これを原点として、我々は、自然を構成する諸要素間のバランスに注目する生態学をふまえた幅広い思考方法を尊重し、人間活動も、日光、大気、水、土、生物などによつて構成される微妙な系を乱さないことを基本条件としてこれを営むという考え方のもとに、自然環境保全の問題に対処することが要請される。
ところが、現実をふりかえると、現に自然環境の破壊は容赦なく進んでおり、その規模において、多様性において、国土のいたるところで深刻な問題を提起していることは否めない。殊に問題なのは、これらの事態がしばしば社会的公正を損なう不均衡な利害を伴いがちで、そのために破壊への適確な対応が一段と複雑化しているという点である。
以上の観点に立つとき、我々は必要に応じて人間活動を厳しく規制する方向で、社会経済制度全般にわたる総合的な政策を強力に展開する必要にせまられている。すなわち、資源のもつ有限性に留意し、大量生産、大量消費、大量廃棄という型の経済活動に厳しい反省を加え、公害の未然防止に努めるとともに、経済的効率優先の陰で見落とされがちであつた非貨幣的価値を適正に評価し、尊重していかなければならない。更に、自然環境の適正な保全に留意した土地利用計画のもとに適切な規制と誘導を図り、豊かな環境の創造に努めなければならない。
もとより、自然保護を中心とする自然環境保全政策は、以上のごとき基本的な考え方のもとで展開すべき総合的な政策の重要部分を占めるものであり、それは自然環境保全の見地から地域の特性に応じて人間活動を規制するという面を主として分担するものであるといつてよい。したがつて、その施策は国土や各地方において確保すべき自然の適正な質と量とを科学的に検討し、それを明確にしたものでなければならない。しかし、この施策の確立には人間活動の限界の設定や、限られた資源の利用配分等の極めて困難な課題を伴うこととなり、更に、自然の全貌は、現代の科学的知見によつても、いまだうかがい知ることのできない多くの部分を持つものであることを認識せざるを得ない。
このような状況のもとでは、自然環境の保全については、将来に禍根を残すことのないよう先取り的なより積極的な姿勢が求められる。いいかえれば、現在破壊から免れている自然を保護するというだけでなく、進んで自然環境を共有的資源として復元し、整備していく方策が必要である。そのため、当面の政策としては、国土に存在する貴重な植生、野生動物、地形地質等のかけがえのない自然やすぐれた自然は、近い将来に起こり得べき事態を考慮に入れ、また、十分な面積にわたつての保全を図るとともに、太陽エネルギーの合理的な利用が可能である農林水産業に関しては、それが有する環境保全の役割を高く評価し、健全な育成を図る必要がある。都市地域においては、健康な人間生活を保障するに足る自然環境が巧妙に確保されなければならない。更に自然環境保全政策は、国内政策にとどまることなく、国際的な視野に立つて貴重な野生動植物の保護や海洋汚染の防止を図るなど、積極的な協力活動を展開する必要がある。
以上の前提に立ち、当面の自然環境保全施策の基本的な方向を展望すれば次のとおりである。
国土に存在する多様な自然を体系的に保全するため、自然環境保全法をはじめとする各種の関係制度を総合的に運用する。
(1)人為のほとんど加わつていない原生の自然地域、国を代表する傑出した自然景観、更に学術上、文化上特に価値の高い自然物等は、多様な生物種を保存し、あるいは自然の精妙なメカニズムを人類に教えるなど、国の遺産として後代に伝えなければならないものである。いずれもかけがえのないものであり、厳正に保全を図る。
(2)国土の自然のバランスを維持する上で重要な役割を果たす自然地域、すぐれた自然風景、野生動物の生息地、更に野外レクリエーシヨンに適した自然地域等は、いずれも人間と自然との関係において欠くことのできない良好な自然であり、適正に保護を図るとともに必要に応じて復元、整備に努力する。
(3)自然の物質循環に生産力の基礎をおく農林水産業が営まれる地域は食糧・林産物をはじめとする資源の供給面だけでなく、国土の保全、水源のかん養、大気の浄化等、自然のバランスの維持という面においても必要欠くべからざるものであり、その環境保全能力を評価し、健全な育成を図る。
(4)都市地域における樹林地、草地、水辺地などの自然地域は、大気浄化、気象緩和、無秩序な市街地化の防止、公害・災害の防止等に大きな役割を果たし、また地域住民の人間形成にも大きな影響を与えるものであるところから、健全な都市構成上、都市環境上不可欠なものについて積極的に保護し、育成し、あるいは復元を図る。
保全すべき自然地域は、その特性に応じて適切に管理されなければならない。このため、管理体制の整備に努めるとともに、必要な民有地の買上げを促進する。
自然環境を破壊するおそれのある大規模な各種の開発が行われる場合は、事業主体により必要に応じ、当該事業が自然環境に及ぼす影響の予測、代替案の比較等を含めた事前調査が行われ、それらが計画に反映され、住民の理解を得たうえで行われるよう努める。開発後においても自然環境の保全のための措置が必要に応じ講ぜられるよう十分な注意を払うものとする。
自然のメカニズムについては、解明されていない部分が極めて多い。人間活動と自然との関係、物質の循環、生態系の保全技術などについての研究を積極的に進めるため、研究体制の確立、情報システムの整備、研究者及び研究の成果を具体的施策に反映させる技術者の養成等に努める。
また、我が国の自然環境の現状を適確に把握するため、植生、野生動物、地形地質をはじめ、しばしば軽視されがちな目に見えない自然のメカニズムの側面などの各分野にわたる科学的な調査を実施する。
自然環境の保全を十分図るためには、国民一人一人が保護、保全の精神を身につけこれを習性とすることがなによりも肝要である。このため学校や地域社会において環境教育を積極的に推進し、自然のメカニズムや人間と自然との正しい関係について国民の理解を深め、自然に対する愛情とモラルの育成に努める。
国民の自然に対する渇望に応えることは、自然環境保全の主要な目的の一つである。自然との交流を図る健全な野外レクリエーシヨンは、今後国民生活においてますます重要性を占め、その需要も増大の傾向にある。しかし、一面それが一定の地域に過度に集中すれば、かけがえのない自然を破壊するおそれもある。したがつて自然環境の適正な保全を図る立場から野外レクリエーシヨン政策の調整を図る。
以上の自然環境保全施策は、国民の理解と協力のもとに、地方公共団体と連携を図りつつ、強力に展開しなければならない。そのためには開発行為に対する規制、土地のもつ公共的性格の重視等につき、勇断をもつて臨まなければならないが、同時に、国土保全その他の公益との調整に留意するとともに、保全のための負担の公平化、地域住民の生業の安定及び福祉の向上、所有権等の財産権の尊重等のため必要な施策を総合的見地から講じていく必要がある。自然の恵沢の享受と保全に関し、受益と負担の両面にわたつて社会的公正が確保されてこそ、自然環境の適正な保全が図られるのである。
自然環境保全法に規定する3種の保全地域、すなわち、原生自然環境保全地域、自然環境保全地域及び都道府県自然環境保全地域は「自然環境の保全に関する基本構想」に基づき国土全域を対象として体系的に選定され、適切に保全されなければならないが、それらについての基本的事項はおおむね次のとおりである。
我が国においては、国土の開発が非常に進んでいるため、人の活動によつて影響を受けていない地域は、自然環境保全上極めて高い評価がなされるに至つており、そのもつ学術的意義は大きく、重要な科学的情報源である。
我が国の亜熱帯多雨林帯、暖帯照葉樹林帯、温帯落葉広葉樹林帯、及び亜寒帯針葉樹林帯の各森林帯に残る原生の自然状態を維持している地域につき、次の要件に合致する典型的なものを原生自然環境保全地域として指定するものとする。
(1)極相あるいは、それに近い森林、湿原、草原等の植生及び野生動物等の生物共同体が人の活動によつて影響を受けることなく原生状態を維持していること。
(2)生態系として動的な平衡状態を維持するため、一定の面積と形態が確保されていること。
(3)(2)に関連し、当該地域の周辺が自然性の高い地域であること。
原生自然環境保全地域の指定方針にかんがみ、自然の推移にゆだねることを保全の基本方針とする。
(1)極相の状態や原生の状態を維持するため、原則として地域内において人為による改変を禁止するとともに、地域外からの各種の影響を極力排除するよう努める。
(2)特定の植物若しくは動物で稀有なもの又は当該地域に固有な植物若しくは動物で、人為の影響を著しく受け易いもの等を保存する必要のある場合には、立入制限地区を設け一層の保護を図るものとする。
(3)自然災害により損傷が生じた場合には、原則として人為を加えず、可能な限り、自然条件での遷移によつて復元を図るものとする。
(4)当該地域の自然を観察し、調査し、研究するとともに、必要最小限の保全事業を執行し、厳正な管理を図るものとする。
すぐれた天然林が相当部分を占める森林、その区域内に生存する動植物を含む自然環境がすぐれた状態を維持している海岸、湖沼、湿原又は河川、植物の自生地、野生動物の生息地等でその自然環境がすぐれた状態を維持しているもの等で一定の広がりをもつた地域について、農林漁業等地域住民の生業の安定、福祉の向上、資源の長期的確保等自然的社会的諸条件を配慮しながら、指定を図るものであるが、特に次に掲げるものについては、速やかに指定を図るものとする。
自然環境保全地域の保全対象である特定の自然環境を維持するため、自然環境の状況に対応した適正な保全を図るものとする。
(1)当該地域の生態系構造上重要な地区及び生態系の育成を特に図ることを必要とする地区、あるいは特定の自然環境を維持するため特に必要がある地区等で、保全対象を保全するために必要不可欠な核となるものについては、その必要な限度において、特別地区又は海中特別地区に指定し、保護を図るものとする。
(2)当該特別地区における特定の野生動植物で稀有なもの、又は固有なものを保存する必要がある地区については、野生動植物保護地区を指定するものとする。
(3)普通地区については、それが有する緩衝地帯としての役割が十分維持されるよう保全を図るものとする。
(4)当該地域内において自然災害等により損傷が生じた場合は防災上の観点とともに生態学的調査結果をふまえ復元等を図るものとする。
(5)当該地域においては、適正な管理を図り、必要な保全事業を実施するものとする。
(6)国土の保全その他公益との調整、住民の農林漁業等の生業の安定及び福祉の向上に配慮するものとする。
都道府県自然環境保全地域は、自然環境が自然環境保全地域に準ずる土地の区域を対象とするものであり、次により指定を行うものとする。
(1)自然環境保全地域の指定方針に準ずるものとするが、区域の設定は保護対象を保全するのに必要な限度において行うものとする。
(2)都市地域において、すぐれた自然環境が残されている地域については、都市計画との調整を図りつつ、指定するものとする。
(3)地域の指定は、私権の制約等を伴うものであるから、当該地域に係る住民及び利害関係人の意見を聴くなど、自然環境保全地域の指定手続に準じて行うものとする。
都道府県自然環境保全地域の保全対象である特定の自然環境を維持するため、自然の状況に対応した適正な保全を図り、必要に応じて積極的な復元を図るものとする。
(1)特別地区、野生動植物保護地区及び普通地区の指定等については、自然環境保全地域に準じて行うものとする。
(2)当該地域内において自然環境に損傷が生じた場合には、当該自然環境の特性と損傷の状況に応じ、速やかに復元又は緑化を図るものとする。
(3)当該地域が小面積である場合には、地域外と接する部分の取扱いに特に注意を払い、必要に応じて樹林帯等を造成し、保護を図るものとする。
(4)当該地域については、適正な管理を図り、必要な保全事業を実施する。
(5)国土の保全その他の公益との調整、住民の農林漁業等の生業の安定及び福祉の向上に配慮するものとする。
自然環境の適正な保全を総合的に推進するためには、自然環境保全法に基づく3種の地域のみならず、自然公園その他の自然環境保全を目的とする法律に基づく各種の地域の指定が促進され、それらの保全が積極的に図られなければならないが、その際の自然環境保全地域等と他の地域との調整は、おおむね次のとおり行うものとする。
(1)原生自然環境保全地域は、それが保有する自然環境の重要性にかんがみ、現に自然公園、その他自然環境保全を目的とする法律に基づく地域に含まれているものであつても、自然公園としての利用等からも十分検討し、厳正に保全を図るべきものにつき指定するものとする。
(2)自然環境保全地域及び都道府県自然環境保全地域は、自然公園の区域外において指定するものとする。ただし、現に都道府県立自然公園の区域に含まれているすぐれた自然の地域にあつては、当該地域の自然の特質、周辺の自然的社会的条件を検討し、場合により、関係都道府県と十分協議のうえ自然環境保全地域へ移行させるものとする。
(3)都市計画区域においては、自然環境保全地域と都道府県自然環境保全地域の指定は、原則として市街化区域については行わないものとし、その他の区域については良好な都市環境の形成を目的とする緑地保全地区と重複しないようにする等の調整を図りつつ行うものとする。
根拠条文は、自然環境保全法第12条である。
自然環境保全法 |
2,877 | 法学＞コンメンタール行政機関の保有する情報の公開に関する法律
（部分開示）
第6条
行政機関の長は、開示請求に係る行政文書の一部に不開示情報が記録されている場合において、不開示情報が記録されている部分を容易に区分して除くことができるときは、開示請求者に対し、当該部分を除いた部分につき開示しなければならない。ただし、当該部分を除いた部分に有意の情報が記録されていないと認められるときは、この限りでない。
開示請求に係る行政文書に前条第1号の情報（特定の個人を識別することができるものに限る。）が記録されている場合において、当該情報のうち、氏名、生年月日その他の特定の個人を識別することができることとなる記述等の部分を除くことにより、公にしても、個人の権利利益が害されるおそれがないと認められるときは、当該部分を除いた部分は、同号の情報に含まれないものとみなして、前項の規定を適用する。
----
{{前後
|行政機関の保有する情報の公開に関する法律
|第2章 行政文書の開示
|第5条（行政文書の開示義務）
|第7条（公益上の理由による裁量的開示）
06 |
2,878 | 絶対温度というマクロな物理量が、ミクロな分子の熱運動の激しさに対応していることを学ぶ。
化学熱力学における基本概念を学ぶ。化学エネルギー・力学的エネルギー・電気エネルギー・熱エネルギーの相互変換について学ぶ。
エントロピーが「断熱系における取り返しのつかなさ」の尺度であることを学ぶ。化学反応の進む向きが、標準反応ギブズエネルギーの正負から判断できることを学ぶ。
化学ポテンシャルが「分子が感じる居心地の悪さ」の尺度であることを学ぶ。 |
2,879 | /* ドメイン特化型言語 */ ドメイン特化型言語とは、ある特定の問題領域に対して、特化した文法や機能を持つプログラミング言語のことを指します。これには、SQL，LexやYaccなどが含まれます。 例えば、SQLはデータベースやデータ処理に特化した言語であり、専用の文法やデータ操作を実行するための関数が用意されています。 Lexは構文解析に特化されたプログラムであり、専用の文法定義書を作成することで、入力されたテキストを解析して、トークン、すなわち文法的な単位に分割します。 Yaccは、決定的文脈自由言語（CFG）で記述された文法に基づいて、入力されたテキストを解析して、構文木を生成するプログラムです。 ドメイン特化型言語は、専門的な分野での開発や問題解決において、高い生産性と効率性を発揮することができます。 |
2,880 | 答えは次のとおりです。答え合わせをしましょう。
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)
(17)
(18)
(19)
(20)
答えは次のとおりです。答え合わせをしましょう。
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)
(17)
(18)
(19)
(20)
答えは次のとおりです。答え合わせをしましょう。
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)
(17)
(18)
(19)
(20)
答えは次のとおりです。答え合わせをしてみましょう。
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)
(17)
(18)
(19)
(20)
答えは次のとおりです。答え合わせをしてみましょう。
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)
(17)
(18)
(19)
(20)
答えは次のとおりです。答え合わせをしてみましょう。
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)
(17)
(18)
(19)
(20)
答えは次のとおりです。答え合わせをしましょう。
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
答えは次のとおりです。答え合わせをしましょう。
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)
(17)
(18)
(19)
(20) |
2,881 | 法学＞民事法＞商法＞コンメンタール会社法＞第7編 雑則 (コンメンタール会社法)
（合資会社の設立の登記）
第913条
合資会社の設立の登記は、その本店の所在地において、次に掲げる事項を登記してしなければならない。
----
{{前後
|会社法
|第7編 雑則
第4章 登記
第2節 会社の登記
|会社法第912条（合名会社の設立の登記）
|会社法第914条（合同会社の設立の登記）
913 |
2,882 | 上訴をするには原則、訴える側に、上訴後に勝訴した場合の実質的な利益がなければならない。
このような亊を、「上訴の利益」（「不服の利益」ともいう）が上訴を起こす側に存在している、などのように言い、具体的には下記のような内容である。
たとえば、上訴前の判決で全部勝訴した側の当事者が上訴しても、棄却されるのが通常である。つまり、全部勝訴の場合には、上訴の利益は無いのが原則である。一部認容判決の場合は、原告・被告両方に上訴の権利がある安西、P246。
また、単に判決理由が納得できないという程度の理由では、上訴は基本的に認められない安西、P246 ※ 本文のページ中央あたり。
上訴の効果
適法に上訴がなされると、原裁判は確定しなくなり、このことを確定遮断効という（116条2項）。また上訴により、上級の裁判所が審理が移動するが、これを移審効という（規174条）。また、この2つの効果の適用範囲については、上訴した側の不服申立ての限度にかかわらず、元裁判の全体に確定遮断効と移審効が適用される（上訴不可分の原則）。
抗告とは、判決以外の決定または命令に対して不服を申し立てる独立の簡易な上訴である。
事件の本体についての訴訟とまとめてしまうと訴訟経済的に不経済なので、独立して抗告という制度が存在している安西、P253。
「通常抗告」には、抗告期間の定めがなく、いつでも抗告できるが、執行停止能が無い。
一方、「即時抗告」は、抗告期間が1週間以内であるが、執行停止能がある(332条)。
最高裁判所に対する抗告
最高裁判所に対する抗告として「特別抗告」が存在しており、これは憲法違反を理由とした抗告であり、高等裁判所の命令・決定に対して最高裁へ抗告できる。
「許可抗告」とは、最高裁判所などの判例に反する決定・命令が高等裁判所から出された場合に、最高裁判所に抗告することで、最高裁判所による法令解釈の統一性を図る制度である（337条）。
平成8年に許可広告は制定され、比較的に新しい制度である。8年以前には最高裁への抗告は、特別抗告しかなかった。 |
2,883 | コンメンタール＞コンメンタール民事＞コンメンタール遺失物法
遺失物法（平成18年法律第73号 最終改正：令和4年法律第68号）の逐条解説書。 |
2,884 | 生物学（せいぶつがく）は生き物（いきもの）の学問（がくもん）で、わたしたちの体の動く仕組みや構造（こうぞう）、体温調節（たいおんちょうせつ）などを理解（りかい）するのにとても大切です。生物学のいくつかの分野に 遺伝学（いでんがく）や生態学（せいたいがく）、動物学（どうぶつがく）や植物学（しょくぶつがく）などがあります。
生き物は活動的（かつどうてき）です。
生き物は以下のような特徴を持っています。
変化（へんか）し成長（せいちょう）ができる。
栄養（えいよう）が必要（ひつよう）で、飲み食い（のみくい）します。
うごくことができます。
太陽光（たいようこう）や水（みず）が十分（じゅうぶん）にあれば植物（しょくぶつ）が そだち、うごいていることを見ることができます。たとえば ヒマワリは 昼（ひる）には いつも太陽のほうを むいています。
繁殖（はんしょく）できます。
刺激（しげき）に、反応（はんのう）します。
排出（はいしゅつ）できます。
呼吸（こきゅう）できます。
動物（どうぶつ）や植物（しょくぶつ）は生き物です。
クルマやテーブルなどは上記の生物の条件（じょうけん）を 満たしていない（みたしていない）ので、生き物ではありません。
生き物は大小の違いが大きいです。1つの生物は有機体（ゆうきたい）と呼ばれ、以下に（いかに）、その構成要素（こうせいようそ）を示します。
これらの一覧（いちらん）は、上のほうが基（もと）になり、下のほうを形成しています。例えば、群衆（ぐんしゅう）は多くの集団（しゅうだん）により構成（こうせい）され、多くの群集（ぐんしゅう）が構成されることにより生態系（せいたいけい）ができます。 |
2,885 | 法学＞コンメンタール行政事件訴訟法
（出訴期間の定めがある当事者訴訟）
第40条
法令に出訴期間の定めがある当事者訴訟は、その法令に別段の定めがある場合を除き、正当な理由があるときは、その期間を経過した後であっても、これを提起することができる。
第15条（被告を誤った訴えの救済）の規定の準用
法令に出訴期間の定めがある当事者訴訟において、原告が故意又は重大な過失によらないで被告とすべき者を誤ったときは、裁判所は、原告の申立てにより、決定をもって、被告を変更することを許すことができる。
前項の決定は、書面でするものとし、その正本を新たな被告に送達しなければならない。
第1項の決定があったときは、出訴期間の遵守については、新たな被告に対する訴えは、最初に訴えを提起した時に提起されたものとみなす。
第1項の決定があったときは、従前の被告に対しては、訴えの取下げがあったものとみなす。
第1項の決定に対しては、不服を申し立てることができない。
第1項の申立てを却下する決定に対しては、即時抗告をすることができる。
----
{{前後
|行政事件訴訟法
|第3章 当事者訴訟
|第39条（出訴の通知）
|第41条（抗告訴訟に関する規定の準用）
40 |
2,886 | ]]では、小学校及び中学校、高等学校における社会科の演習問題を利用できます。 |
2,887 | 法学＞環境法＞自然公園法＞コンメンタール自然公園法
（目的）
第1条
原生自然公園地域及び自然環境保全地域は、自然環境を適正に保全し、将来の国民に継承していくという性格の地域であり、すぐれた自然の風景地を保護するとともにその利用を増進を図るという性格の地域である自然公園とは、その性格を異にする」としている。
などで特段の定義付けはされていない。
「生物の多様性の確保」については、平成二一年六月三日法律第四七号による改正で、自然環境保全法どもども追加された。
----
{{前後
|自然公園法
|第一章総則
|
|自然公園法第2条(定義)
01 |
2,888 | 法学＞コンメンタール＞コンメンタール刑事訴訟法=コンメンタール刑事訴訟法/改訂
（司法警察官との関係）
第350条の６
検察官は、司法警察員が送致し若しくは送付した事件又は司法警察員が現に捜査していると認める事件について、その被疑者との間で第350条の4の協議を行おうとするときは、あらかじめ、司法警察員と協議しなければならない。
検察官は、第350条の4の協議に係る他人の刑事事件について司法警察員が現に捜査していることその他の事情を考慮して、当該他人の刑事事件の捜査のため必要と認めるときは、前条第1項の規定により供述を求めることその他の当該協議における必要な行為を司法警察員にさせることができる。この場合において、司法警察員は、検察官の個別の授権の範囲内で、検察官が第350条の2第1項の合意の内容とすることを提案する同項第2号に掲げる行為の内容の提示をすることができる。
2016年改正により新設。
に定められていた「即決裁判手続き」に関する規定は刑事訴訟法第350条の20に条数が変更された。
----
{{前後
|刑事訴訟法
|第2編 第一審
第4章 証拠収集等への協力及び訴追に関する合意
第1節 合意及び協議の手続
|第350条の5（協議における供述の聴取）
|第350条の7（被告人の事件における合意内容書面等の証拠調べの請求）
350の06
350の06 |
2,889 | 法学＞コンメンタール民事訴訟法＞コンメンタール民事執行法
（配当等を受けるべき債権者の範囲）
第87条
差押えに係る強制競売の手続が停止され、第47条第6項の規定による手続を続行する旨の裁判がある場合において、執行を停止された差押債権者がその停止に係る訴訟等において敗訴したときは、差押えの登記後続行の裁判に係る差押えの登記前に登記された第1項第四号に規定する権利を有する債権者は、配当等を受けることができる。
----
{{前後
|民事執行法
|第2章 強制執行
第2節 金銭の支払を目的とする債権についての強制執行
第1款 不動産に対する強制執行
第2目 強制競売
|民事執行法第86条（売却代金）
|民事執行法第88条（期限付債権の配当等）
87 |
2,890 | 疑問文を作るとき英語では語順を変えて先頭に Do などの言葉を付加しますね。これが当然だと思い込んでいる人は、少し日本語や中国語やトルコ語のことを考えてみてください。実は英語（ドイツ語も）の疑問文はややこしい規則だということに気づくはずです。
ロジバンではどんな命題文も「xu」を（どこでもよいのですが大抵先頭に）加えるだけで「はい/いいえ」で答える質問文になります。幾つか例を挙げます。
xu do nelci la bil.
君はビルのことが好きなの？
xu mi klama
僕は来ているんだろうか。
xu crino
緑？
多くの言語のように、こういう質問に対してロジバンには幾つかの答え方があります。「はい/いいえ」に相当する言葉を知らなければ、「はい」と言いたいときには selbri をそのまま繰り返しましょう。
「君はビルのことが好きなの？」
「好き。」
また、「go'i」を使うこともできます。これは最後の bridi を繰り返す（疑問なしに）という役割を果たします。
注：もしあなたが「あなたはビルのことが好きか」と私に聞いて、私が「あなたはビルのことが好きだ」と答えたら違う意味になってしまいます。この点 go'i は便利です。「xu do nelci la bil.」「go'i」という会話で返答が意味する文は「do nelci la bil.」ではなく、ちゃんと「mi nelci la bil.」なのです。
じゃあ「いいえ」と言いたいときは？どんな bridi も「na」を使うことで否定文になります。「bridi 全体」を否定する役割があり、もうちょっと文法を学べば自由に置くことができます。ただ文法的に最も簡単なのが「selbri の直前に置くこと」です。なので「mi cu na nelci la bil.」は「私がビルを好きだということは正しくない。」つまり「私はビルのことが好きでない。」となります。
小ネタ：デフォルトでは na は selbri と共にあるものです。そして cu の役割は「selbri が来るぞ」と知らせることですから、na により cu は無用になります。なので上の文は単純に「mi na nelci la bil.」と変えれます。そして答え方としては先ほどと同様に、ただ「na nelci」だとか「na go'i」と言えば済みます。
論理の話：実は否定文というのは意外に複雑です。厳密には「mi na nelci la bil.」は私がビルのことなんて金輪際聞いたこともないという場合でも使えるのです（知らない相手を好きになることはできませんね）。この後も幾つか否定文が登場しますが、当分は na で不都合は起こりません。日本語で「君は田中ジョセフィーヌ太郎のことが好きか」と聞かれたら、当然そんな人など知らないので「いや」と答えますね。あまり収穫のある会話ではありませんが、嘘は言っていないわけです。
「何・誰・どこ・どれ」などの疑問はロジバンでは一つの言葉「ma」とそれを置く場所で表します。いわば「ここの不明な sumtiを埋めてね」と言っているようなものです。例を挙げましょう。後で学びますが、時制が決定されていないことに注意してください。
そしてもう一つ、「mo」という言葉があります。これは ma に似ているのですが、sumti でなくて selbri を尋ねる役割を果たします。つまり「sumti 同士の関係を述べてね」と言っているようなものです。例えば
do mo klaudias.
君？クラウディア⇒君はクラウディア に/の 何 する/である の？
答え方は文脈によります。あり得る答えとしては
ここで時制は問題ではないことに注意してください。「cinba」だけならば「キスする」「キスした」「キスするつもり」などなど様々な可能性があります。ロジバンには時制を表す言葉があるのですが、（中国語のように）使わなくてもよいというだけなのです。
mo は「～は何？」という類の質問にも使えると言いましたね。最も単純な例が「ti mo」で、「これは何？」を意味します。また、「la meilis. mo」と問えば「メイリって誰？」「メイリって何？」「メイリは何しているの？」などなど様々な意味になります。対する答えもまた、文脈によります。例えば、
もっと特定のことを訊くときは、ma を使って「la meilis. gasnu ma（メイリは何する？）」のように訊きます。
ロジバンには疑問のための言葉がまだありますが、とりあえずは「xu」「ma」「mo」で訊きたいことの多くは表現できるでしょう。そして「xo（幾つ）」「ca ma（いつ）」「pei（どう感じる？）」のような別の言葉は「数、時制、感情表現」の章で学びましょう。 |
2,891 | 法学＞環境法＞自然公園法＞コンメンタール自然公園法
（協議等）
第79条
第1項において、都道府県は、都道府県立自然公園の特別地区又は利用調整地区の指定又はその区域の拡張をしようとするときは、国の関係地方行政機関の長に協議しなければならないとされている。
都道府県立自然公園の区域内における行為について許可制、届出制等の規制を定めた場合における国の機関又は地方公共団体が行なう行為について、第68条の例により、協議等で行えることとする規定である。
----
{{前後
|自然公園法
|[[コンメンタール自然公園法#79|第三章都道府県立自然公園
]]
|自然公園法第78条(公害等調整委員会の裁定)
|自然公園法第80条(報告、助言又は勧告)
79 |
2,892 | 法学＞民事法＞コンメンタール商業登記法
（相続人による登記）
第32条
相続人が前三条の登記を申請するには、申請書にその資格を証する書面を添附しなければならない。
前三条
商号、営業の種類、営業所の変更、商号使用者の氏名及び住所
商号に財産的価値を認められることから、商号に伴う営業を含めて譲渡、相続をすることが出来る。
----
{{前後
|商業登記法
|第3章 登記手続
第2節 商号の登記
|商業登記法第31条（営業又は事業の譲渡の際の免責の登記）
|商業登記法第33条（商号の登記の抹消）
032 |
2,893 | 本書は、プログラミング言語Zigのチュートリアルです。
Zigは、堅牢で最適かつ再利用可能なソフトウェアを維持するための汎用システムプログラミング言語およびツールチェインです{{Cite web
|url=https://ziglang.org/
|title=Home ⚡ Zig Programming Language
|website=ziglang.org
|accessdate=2022-07-17
|cite=Zig is a general-purpose programming language and toolchain for maintaining robust, optimal and reusable software.
。
Zigは、アンドリュー・ケリー( ''[https://andrewkelley.me/ Andrew Kelley]'' )によって設計され、静的で強い型付けで型推論とジェネリックプログラミングをサポートします。
__TOC__
Zigは、2016年2月に発表された比較的若いプログラミング言語で{{Cite web
|last1=Kelley
|first1=Andrew
|title=Introduction to the Zig Programming Language
|url=https://andrewkelley.me/post/intro-to-zig.html
|website=andrewkelley.me
|accessdate=2022-07-17
、2024年2月10日現在の最新バージョンは 0.11.0 で、''pre-release'' と位置づけられています{{Cite web
|url=https://github.com/ziglang/zig/releases
|title=Releases · ziglang/zig · GitHub
|website=github.com
|date=2023-08-04
|accessdate=2024-02-10
。このため Hello world ですら、バージョン間で互換性がなくなることもあり、今後もリリースバージョンまでは言語仕様やライブラリーおよびツールチェインの仕様が変更される可能性があります。
Zigはメモリ安全性、高速なビルド、そして明快な言語設計を特長とする新しいプログラミング言語です。
以下のZigのクイックツアーでは、基本的な概念とコード例を紹介します。
基本構文:
Zigプログラムはmain関数から始まります。ここでは、stdout.writeAll()関数を使って標準出力に文字列を出力しています。
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
try stdout.writeAll("Hello, World!\n");
}
Hello, world!
データ型:
Zigには整数型、浮動小数点型、真偽値などの基本的なデータ型があります。
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
const age: i32 = 25;
const salary: f64 = 50000.50;
const isZigFun: bool = true;
const message: []const u8 = "Hello, Zig!";
const intOrNull: ?i16 = 42;
const nullOrInt: ?i16 = null;
const intOrError: anyerror!i16 = 178;
const errorOrInt: anyerror!i16 = error.BadValue;
try stdout.print("age = {}({})\n", .{age, @TypeOf(age)});
try stdout.print("salary = {}({})\n", .{salary, @TypeOf(salary)});
try stdout.print("isZigFun = {}({})\n", .{isZigFun, @TypeOf(isZigFun)});
try stdout.print("message = {s}({})\n", .{message, @TypeOf(message)});
try stdout.print("intOrNull = {?}({})\n", .{intOrNull, @TypeOf(intOrNull)});
try stdout.print("nullOrInt = {?}({})\n", .{nullOrInt, @TypeOf(nullOrInt)});
try stdout.print("intOrError = {!}({})\n", .{intOrError, @TypeOf(intOrError)});
try stdout.print("errorOrInt = {!}({})\n", .{errorOrInt, @TypeOf(errorOrInt)});
}
age = 25(i32)
salary = 5.00005e+04(f64)
isZigFun = true(bool)
message = Hello, Zig!([]const u8)
intOrNull = 42(?i16)
nullOrInt = null(?i16)
intOrError = 178(anyerror!i16)
errorOrInt = error.BadValue(anyerror!i16)
制御構造:
if、else if、else文を使って条件分岐ができます。whileループやforループを使って繰返し処理ができます。
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
const zero: f16 = 0.0;
const num = zero/zero;
if (num > 0.0) {
try stdout.writeAll("Positive\n");
} else if (num < 0.0) {
try stdout.writeAll("Negative\n");
} else if (num == 0.0) {
try stdout.writeAll("Zero\n");
} else {
try stdout.print("num = {}\n", .{num});
}
var a: ?u16 = 42;
if (a) |*value| {
try stdout.print("value.* = {}({})\n", .{value.*, @TypeOf(value.*)});
value.* = 123;
} else {
unreachable;
}
if (a) |n| {
try stdout.print("n = {}({})\n", .{n, @TypeOf(n)});
} else {
unreachable;
}
a = null;
if (a) |_| {
unreachable;
} else {
try stdout.print("a = {?}({})\n", .{a, @TypeOf(a)});
}
var b: anyerror!u32 = error.BadValue;
try stdout.print("b = {any}({})\n", .{b, @TypeOf(b)});
if (b) |_| {
unreachable;
} else |err| {
try stdout.print("err = {?}({})\n", .{err, @TypeOf(err)});
}
b = 4423;
try stdout.print("b = {any}({})\n", .{b, @TypeOf(b)});
if (b) |n| {
try stdout.print("n = {}({})\n", .{n, @TypeOf(n)});
} else |_| {
unreachable;
}
var x: i32 = 0;
while (x < 4) : (x += 1) {
try stdout.print("While: Iteration {}\n", .{x});
}
for (0..4) |i| {
try stdout.print("For: Iteration {}\n", .{i});
}
}
num = -nan
value.* = 42(u16)
n = 123(u16)
a = null(?u16)
b = error.BadValue(anyerror!u32)
err = error.BadValue(anyerror)
b = 4423(anyerror!u32)
n = 4423(u32)
While: Iteration 0
While: Iteration 1
While: Iteration 2
While: Iteration 3
For: Iteration 0
For: Iteration 1
For: Iteration 2
For: Iteration 3
関数:
関数はfnキーワードを使って宣言します。
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn add(a: i32, b: i32) i32 {
return a + b;
}
pub fn main() !void {
const result = add(5, 3);
try stdout.print("Sum: {}\n", .{result});
}
Sum: 8
構造体とメソッド:
構造体はstructキーワードを使って定義します。メソッドは構造体の関数を定義することで実現します。
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
const myCar = Car.init("Toyota", 2022);
try stdout.print("myCar = {}\n", .{myCar});
}
const Car = struct {
model: []const u8,
year: u32,
const Self = @This();
pub fn init(model: []const u8, year: u32) Self {
return Self{
.model = model,
.year = year,
};
}
pub fn format(
car: Self,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
out_stream: anytype,
) !void {
_ = options;
_ = fmt;
try out_stream.print("Car(Model: {s}, Year: {})", .{ car.model, car.year });
}
};
myCar = Car(Model: Toyota, Year: 2022)
ここでは、Zigの基本的な構文とコンセプトを簡単に紹介しました。
[https://ziglang.org/documentation/master/ Zig Language Reference]の、Hello worldの変遷（新しい順）。
master@2024-02-10{{Cite web
|url=https://ziglang.org/documentation/master/#Hello-World
|title=Zig Documentation(master@2024-02-10)
|website=ziglang.org
|accessdate=2024-02-10
0.11.0{{Cite web
|url=https://ziglang.org/documentation/0.11.0/#Hello-World
|title=Zig Documentation(0.11.0)
|website=ziglang.org
|accessdate=2024-02-10
0.10.0{{Cite web
|url=https://ziglang.org/documentation/0.10.0/#Hello-World
|title=Zig Documentation(0.10.0)
|website=ziglang.org
|accessdate=2022-11-15
0.9.1{{Cite web
|url=https://ziglang.org/documentation/0.9.1/#Hello-World
|title=Zig Documentation(0.9.1)
|website=ziglang.org
|accessdate=2022-07-17
[https://wandbox.org/permlink/dghWOQlzCD7jSCHj 0.8.1]{{Cite web
|url=https://ziglang.org/documentation/0.8.1/#Hello-World
|title=Zig Documentation(0.8.1)
|website=ziglang.org
|accessdate=2022-07-17
const std = @import("std");
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
try stdout.print("Hello, {s}!\n", .{"world"});
}
|url=https://ziglang.org/download/0.8.0/release-notes.html#Formatted-Printing
|title=0.8.0 Release Notes
|website=ziglang.org
|accessdate=2022-07-17
|quote=Disable the special casing of {} for u8 slices/arrays. Unless {s} is specified the contents won't be treated as a string.
0.7.1{{Cite web
|url=https://ziglang.org/documentation/0.7.1/#Hello-World
|title=Zig Documentation(0.7.1)
|website=ziglang.org
|accessdate=2022-07-17
const std = @import("std");
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
try stdout.print("Hello, {}!\n", .{"world"});
}
0.6.0{{Cite web
|url=https://ziglang.org/documentation/0.6.0/#Hello-World
|title=Zig Documentation(0.6.0)
|website=ziglang.org
|accessdate=2022-07-17
const std = @import("std");
pub fn main() !void {
const stdout = std.io.getStdOut().outStream();
try stdout.print("Hello, {}!\n", .{"world"});
}
初期化の初期値から try がなくなった。
0.4.0{{Cite web
|url=https://ziglang.org/documentation/0.4.0/#Hello-World
|title=Zig Documentation(0.4.0)
|website=ziglang.org
|accessdate=2022-07-17
0.5.0{{Cite web
|url=https://ziglang.org/documentation/0.5.0/#Hello-World
|title=Zig Documentation(0.5.0)
|website=ziglang.org
|accessdate=2022-07-17
const std = @import("std");
pub fn main() !void {
// If this program is run without stdout attached, exit with an error.
const stdout_file = try std.io.getStdOut();
// If this program encounters pipe failure when printing to stdout, exit
// with an error.
try stdout_file.write("Hello, world!\n");
}
stdout_file が var から const に変更された。
0.3.0{{Cite web
|url=https://ziglang.org/documentation/0.3.0/#Hello-World
|title=Zig Documentation(0.3.0)
|website=ziglang.org
|accessdate=2022-07-17
0.2.0{{Cite web
|url=https://ziglang.org/documentation/0.2.0/#Hello-World
|title=Zig Documentation(0.2.0)
|website=ziglang.org
|accessdate=2022-07-17
const std = @import("std");
pub fn main() !void {
// If this program is run without stdout attached, exit with an error.
var stdout_file = try std.io.getStdOut();
// If this program encounters pipe failure when printing to stdout, exit
// with an error.
try stdout_file.write("Hello, world!\n");
}
0.1.1{{Cite web
|url=https://ziglang.org/documentation/0.1.1/#hello-world
|title=Zig Documentation
|website=ziglang.org
|accessdate=2022-07-17
const io = @import("std").io;
pub fn main() -> %void {
%%io.stdout.printf("Hello, world!\n");
}
Zigは、コンパイル時に安全で高速なシステムプログラミング言語です。以下に、Zigの主な特徴を詳しく説明します。
Zigは静的型付けを採用しています。型はコンパイル時に解決され、実行時に型エラーを引き起こすことがありません。また、型推論もサポートされています。
Zigは、値型を採用しています。これは、オブジェクトのコピーが作成されるため、値型はポインタ型よりも安全で、予測可能な動作をします。
Zigには、コンパイル時メタプログラミングをサポートするためのcomptimeブロックがあります。これにより、コンパイル時に計算を実行し、コンパイル時に情報を収集することができます。
Zigは、メモリ管理について堅牢で安全なアプローチを採用しています。メモリリークやダングリングポインタなどの問題を回避するために、コンパイル時にメモリ安全性を検査することができます。
Zigには、モジュールシステムがあります。モジュールは、依存関係を管理するための仕組みを提供します。
Zigは、ネイティブコードを生成するコンパイラを提供します。これにより、高速かつ効率的なコードを実行することができます。
Zigには、エラーハンドリング機能があります。エラーハンドリングは、C言語のエラーコードや例外処理のようなアプローチに比べて、より安全で予測可能な動作をすることができます。
以上が、Zigの主な特徴のいくつかです。これらの特徴により、Zigは高速かつ安全なシステムプログラミングを可能にします。
以下、個別の要素に言及します。
コンパイル型言語 : １つまたは複数のソースコードをコンパイルして実行ファイルを得、それを実行します。
静的型付け : 値・変数・関数のパラメーター・関数の戻値などの型はコンパイル時に検証され、型安全性が担保されます。
例外はありません : エラー処理などのための例外はありません。この用途には、関数の戻値にエラーユニオン型やオプショナル型を使います。
演算子オーバーロードはありません : 演算子は演算子一覧表にある通りにしか機能しませんし、必ずそのように機能します。シフト演算子がストリーム入出力を行ったりはしません。
関数オーバーロードはありません : 関数に与えられたパラメーターによって違う関数が呼び出されることはありません。ただし、可変引数の関数は定義できます。その場合も、同じ関数が呼び出されます。
型推論が行われます : 変数宣言時に与えられた初期値（必須）から変数の型を推論することで型アノテーションを省略できます。
ガベージコレクション : ガベージコレクションはありません。
クラスはありませんがメソッドはあります : クラスはありませんが、コンテナー( struct, union, enum )がメソッドを持つことができます。
コンストラクターはありません : 慣習的に init() と名付けられたメソッドがコンテナーのインスタンス化に使われます。
デストラクターはありません : 慣習的に deinit() と名付けられたメソッドがコンテナーのインスタンスの解体処理に使われます。deinit() はスコープでを抜ける時に自動的に実行されません。defer myObj.deinit(); のようにインスタンスの生成時に解体処理を登録します。
継承はありません : タグ付きunionやusingnamespaceを使うと継承でしたいこと（＝差分プログラミング）が可能ですが、構文や仕組みは異なります。
interface や protocol はありません : Java や Go の interface や Swift の protocol はありませんが、コンパイル時にメソッドが定義されているかテストし、なければエラーにするプログラミングはできます。
名前空間の役割はコンテナーが担います : namespace の様なキーワードはありませんが、ドットシンタックス（コンテナー.識別子 や コンテナー変数.識別子）でコンテナーが名前空間の役目を果たします。また、usingnamespace を使うとドットシンタックスなしに公開識別子にアクセスできるようになります（ミックスインとも言えます）。
ジェネリックプログラミングに対応しています : 関数呼出しの引数に（コンパイル時に既知の）型を渡すことができるので、ジェネリックプログラミングを行うことが出来ます。
ソースファイルは匿名struct : コンパイル単位であるソースファイルは暗黙のうちに匿名structで、組込み関数@import() が返す値を識別子に束縛することで名前空間を構成します。ex: const std = @import("std")
インスタンスがスコープを抜けるときに実行する処理を登録できます : スコープを抜ける理由によって、 defer と errdefer の2種類の処理を登録できます。
多くの制御構造は式と文の構文を持ちます : if, while, for の3つの制御構文は、値を返す式構文とブロックを持つ文構文の両方を持ちます。switchは、値を返す式構文しかありません。
文末の;（セミコロン）の省略はできません : 最近の新興言語にして珍しく ; は省略できません。
ループ構文は else 節を持つことができます : whileとfor の2つの反復構文は、ループを「完走」した時に実行する else 節を持つことができます。
キーワードを識別子にできます : PL/Iのように無制限にではなく @"else" のような形式でキーワードや数字で始まる識別子を使うことができます。
シャドウイング禁止 : 外部スコープで使われている識別子と同じ識別子を内側のスコープで使うことは出来ません。コンパイルエラーになります。
関数のパラメーターはイミュータブル : 関数のパラメーターは、 const 宣言された変数（＝定数）と同じく書換えることは出来ません。
実際にZigで書かれたのコードを見てみましょう。
Ruby#ユーザー定義クラスの都市間の大圏距離を求めるメソッドを追加した例を、Zigに移植しました。
都市間の大圏距離:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const GeoCoord = struct {
longitude: f64,
latitude: f64,
const Self = @This();
pub fn init(longitude: f64, latitude: f64) Self {
return Self{
.longitude = longitude,
.latitude = latitude,
};
}
pub fn format(
self: Self,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
out_stream: anytype,
) !void {
_ = options;
_ = fmt;
var ew = "東経";
var ns = "北緯";
var long = self.longitude;
var lat = self.latitude;
if (long < 0.0) {
ew = "西経";
long = -long;
}
if (lat < 0.0) {
ns = "南緯";
lat = -lat;
}
try out_stream.print("({s}: {}, {s}: {})", .{ ew, long, ns, lat });
}
pub fn distance(self: Self, other: Self) f64 {
const math = std.math;
const i = math.pi / 180.0;
const r = 6371.008;
return math.acos(math.sin(self.latitude * i) * math.sin(other.latitude * i) +
math.cos(self.latitude * i) * math.cos(other.latitude * i) * math.cos(self.longitude * i - other.longitude * i)) * r;
}
};
pub fn main() !void {
const sites = comptime .{
.{
.name = "東京",
.gc = GeoCoord.init(139.7673068, 35.6809591),
},
.{
.name = "シドニー・オペラハウス",
.gc = GeoCoord.init(151.215278, -33.856778),
},
.{
.name = "グリニッジ天文台",
.gc = GeoCoord.init(-0.0014, 51.4778),
},
};
inline for (sites) |site| {
try stdout.print("{s}: {}\n", .{ site.name, site.gc });
}
try stdout.writeAll("---\n");
inline for (sites, 0..) |a, index| {
const b = sites[(index + 1) % sites.len];
try stdout.print("{s} - {s}: {} [km]\n", .{ a.name, b.name, a.gc.distance(b.gc) });
}
}
実行結果:
東京: (東経: 1.397673068e+02, 北緯: 3.56809591e+01)
シドニー・オペラハウス: (東経: 1.51215278e+02, 南緯: 3.3856778e+01)
グリニッジ天文台: (西経: 1.4e-03, 北緯: 5.14778e+01)
---
東京 - シドニー・オペラハウス: 7.823269299386704e+03 [km]
シドニー・オペラハウス - グリニッジ天文台: 1.69872708377249e+04 [km]
グリニッジ天文台 - 東京: 9.560546566490015e+03 [km]
Zig言語では、特定の名前で定義された format メソッドは、標準ライブラリである std.fmt を拡張し、コレクションの固有の文字列化メソッドを提供します。Zigでは、配列内に文字列を含む配列は第一級オブジェクトではないため、ストリーム入出力を拡張する方法が安全性を考慮する上で確実です。
新しい機能として、0.11.0で導入された「multi-object for loops」があります。この新しい構文を使用すると、同じ長さの複数のシーケンスを反復処理することができます。これにより、コードがより読みやすくなり、メンテナンスが容易になります。
また、for の前にある inline キーワードは、コンパイル時にループを展開することを意味し、タプルの配列であることをコンパイラに伝えます。これにより、コンパイラがより効率的なコードを生成できます。
ファイルを開いて内容をアロケートしたバッファに読出し標準出力に出力する例。
ファイルの読出し:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
const file = try std.fs.openFileAbsolute(
"/etc/hosts",
.{},
);
defer file.close();
var reader = std.io.bufferedReader(file.reader());
const in_stream = reader.reader();
const allocator = std.heap.page_allocator;
const file_size = try file.getEndPos();
const contents = try in_stream.readAllAlloc(allocator, file_size);
defer allocator.free(contents);
try stdout.writeAll(contents);
}
このコードは、指定された絶対パスにあるファイル（この場合は"/etc/hosts"）を開いて、その内容を標準出力に書き込むプログラムです。以下に、コードの各部分の機能を解説します。
const std = @import("std");: 標準ライブラリをインポートします。
const stdout = std.io.getStdOut().writer();: 標準出力のライターを取得します。
pub fn main() !void { ... }: プログラムのエントリーポイントとなるmain関数です。エラーが発生する可能性があるため、!void型が使用されています。
const file = try std.fs.openFileAbsolute("/etc/hosts", .{});: /etc/hostsファイルを絶対パスとして開きます。tryキーワードは、関数がエラーを返す可能性があることを示します。
defer file.close();: ファイルの処理が終了した後に、必ずファイルを閉じるようにします。deferキーワードは、そのスコープが終了する際に処理を実行することを示します。
var reader = std.io.bufferedReader(file.reader());: ファイルから読み取りを行うためのBufferedReaderを作成します。
const in_stream = reader.reader();: BufferedReaderから読み取りストリームを取得します。
const allocator = std.heap.page_allocator;: ページアロケータを使用してメモリを割り当てるためのアロケータを定義します。
const file_size = try file.getEndPos();: ファイルのサイズを取得します。
const contents = try in_stream.readAllAlloc(allocator, file_size);: ファイルの内容を読み取り、アロケータを使用してメモリを割り当てます。
defer allocator.free(contents);: メモリを解放するため、contentsがスコープを抜けた時に必ず実行されるようにします。
try stdout.writeAll(contents);: ファイルの内容を標準出力に書き込みます。エラーが発生した場合には、そのエラーが処理されます。
このプログラムは、指定されたファイルの内容を読み取り、その内容を標準出力に書き込みます。
ジェネリックプログラミングを使った複素数型を実装してみました。
[https://wandbox.org/permlink/RLtBPnQwfCsUkwt7 ジェネリックな複素数型]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const signbit = std.math.signbit;
fn Complex(comptime T: type) type {
return struct {
real: T,
imag: T,
const Self = @This();
pub fn init(real: T, imag: T) Self {
return Self{ .real = real, .imag = imag };
}
pub fn add(self: Self, other: Self) Self {
return Self{ .real = self.real + other.real, .imag = self.imag + other.imag };
}
pub fn format(
self: Self,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
out_stream: anytype,
) !void {
try std.fmt.formatType(self.real, fmt, options, out_stream, 1);
if (signbit(self.imag)) {
try out_stream.writeAll("-");
try std.fmt.formatType(-self.imag, fmt, options, out_stream, 1);
} else {
try out_stream.writeAll("+");
try std.fmt.formatType(self.imag, fmt, options, out_stream, 1);
}
return out_stream.writeAll("i");
}
};
}
pub fn main() !void {
const F64Complex = Complex(f64);
var f64cplx1 = F64Complex.init(3.0, 4.0);
const f64cplx2 = F64Complex.init(1.0, -4.0);
try stdout.print("{}\n", .{f64cplx1});
try stdout.print("{d:.1}\n", .{f64cplx2});
try stdout.print("{x}\n", .{f64cplx1.add(f64cplx2)});
}
実行結果:
3.0e+00+4.0e+00i 1.0-4.0i
0x1p2+0x0.0p0i
pub fn Complex(comptime T: type) typeは、要素型をパラメーターに複素数型を返します（複素数ではなく複素数型です）。
Zig には演算子オーバーライドがないのでメソッドとして定義します。
標準ライブラリーのソート機能の使用例。
ソートの例:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var ary = [_]i8{ 1, 4, 1, 4, 2, 1, 3, 5, 6 };
try stdout.print("befor: {any}\n", .{ary});
std.sort.insertion(i8, &ary, {}, struct {
pub fn cmp(context: void, a: i8, b: i8) bool {
return std.sort.asc(i8)(context, a, b);
}
}.cmp);
try stdout.print("after: {any}\n", .{ary});
}
実行結果:
befor: { 1, 4, 1, 4, 2, 1, 3, 5, 6 }
after: { 1, 1, 1, 2, 3, 4, 4, 5, 6 }
std.sort.insertion()は、型・配列・context・比較関数をパラメーターに配列をソートします。
Zigには、ラムダ式がないので匿名structのメソッドを比較関数に使いました。
structの配列のあるフィールドをキーにソートしたい場合は、匿名structのメソッドを比較関数に使う手口が有効ですし、ソート対象のstructのコードに手を入れられるときは、structのメソッドにしても良いでしょう（ラムダ式ほしい）。
エラトステネスの篩を、若干 Zig らしく書いてみました。
エラトステネスの篩:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
fn Eratosthenes(comptime n: u16) !void {
var sieve: [n + 1]bool = undefined;
for (&sieve, 0..) |*e, i| {
e.* = i >= 2;
}
for (sieve, 0..) |_, i| {
if (!sieve[i]) {
continue;
}
try stdout.print("{} ", .{i});
var j = 2 * i;
while (j <= n) : (j += i) {
sieve[j] = false;
}
}
}
pub fn main() !void {
try Eratosthenes(1000);
}
実行結果:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997
このコードは、0.11.0以降でしか動きません。
Crystalに移植しました例を題材に、Zigにはない抽象クラスの代替のコード例を書いてみました。
[https://wandbox.org/permlink/fA9yzsrUly8oRYbR 抽象クラス（の代替）]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const Point = struct {
x: i32 = 0,
y: i32 = 0,
const Self = @This();
pub fn init(x: i32, y: i32) Self {
return Self{ .x = x, .y = y };
}
pub fn format(
self: Self,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
out_stream: anytype,
) !void {
_ = options;
_ = fmt;
return out_stream.print("x:{}, y:{}", .{ self.x, self.y });
}
pub fn move(self: Self, dx: i32, dy: i32) Self {
self.x += dx;
self.y += dy;
return self;
}
};
const Shape = struct {
location: Point = Point.init(0, 0),
const Self = @This();
pub fn init(x: i32, y: i32) Self {
return Self{ .location = Point.init(x, y) };
}
pub fn format(
self: Self,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
out_stream: anytype,
) !void {
_ = options;
_ = fmt;
return out_stream.print("{}", .{self.location});
}
pub fn move(self: Self, dx: i32, dy: i32) Self {
self.location.move(dx, dy);
return self;
}
};
const Square = struct {
shape: Shape = Shape.init(0, 0),
wh: i32 = 0,
const Self = @This();
pub fn init(x: i32, y: i32, wh: i32) Self {
return Self{ .shape = Shape.init(x, y), .wh = wh };
}
pub fn format(
self: Self,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
out_stream: anytype,
) !void {
_ = options;
_ = fmt;
return out_stream.print("{}, wh:{}", .{ self.shape, self.wh });
}
pub fn move(self: Self, dx: i32, dy: i32) Self {
self.shape.move(dx, dy);
return self;
}
pub fn area(self: Self) i32 {
return self.wh * self.wh;
}
};
const Rectangle = struct {
shape: Shape = Shape.init(0, 0),
width: i32 = 0,
height: i32 = 0,
const Self = @This();
pub fn init(x: i32, y: i32, width: i32, height: i32) Self {
return Self{ .shape = Shape.init(x, y), .width = width, .height = height };
}
pub fn format(
self: Self,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
out_stream: anytype,
) !void {
_ = options;
_ = fmt;
return out_stream.print("{}, width:{}, height:{}", .{ self.shape, self.width, self.height });
}
pub fn move(self: Self, dx: i32, dy: i32) Self {
self.shape.move(dx, dy);
return self;
}
pub fn area(self: Self) i32 {
return self.width * self.height;
}
};
const Circle = struct {
shape: Shape = Shape.init(0, 0),
r: i32 = 0,
const Self = @This();
pub fn init(x: i32, y: i32, r: i32) Self {
return Self{ .shape = Shape.init(x, y), .r = r };
}
pub fn format(
self: Self,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
out_stream: anytype,
) !void {
_ = options;
_ = fmt;
return out_stream.print("{}, r:{}", .{ self.shape, self.r });
}
pub fn move(self: Self, dx: i32, dy: i32) Self {
self.shape.move(dx, dy);
return self;
}
pub fn area(self: Self) f32 {
return @as(f32, @floatFromInt(self.r * self.r)) * std.math.pi;
}
};
pub fn main() !void {
const ary = comptime .{ Point.init(3, 4), Shape.init(20, 24), Rectangle.init(10, 20, 32, 24) };
inline for (ary) |x| {
try stdout.print("{}({})\n", .{ @TypeOf(x), x });
}
try stdout.writeAll("\n");
const shapes = comptime .{ Square.init(10, 12, 40), Rectangle.init(10, 20, 32, 24), Circle.init(10, 12, 20) };
inline for (shapes) |shape| {
try stdout.print("{}({}).area() = {}\n", .{ @TypeOf(shape), shape, shape.area() });
}
}
実行結果:
Point(x:3, y:4)
Shape(x:20, y:24)
Rectangle(x:10, y:20, width:32, height:24)
Square(x:10, y:12, wh:40).area() = 1600
Rectangle(x:10, y:20, width:32, height:24).area() = 768
Circle(x:10, y:12, r:20).area() = 1.25663708e+03
インスタンスの文字列化は、format() メソッドを定義することで std.fmt を拡張しています。
area() メソッドを持つインスタンスを要素とするタプルを comptime 修飾した上で、inline な for で回しました。
この方法は、コンパイル時に全てのインスタンスが area() メソッドを持つことを担保します。
ここでは各インスタンスの型が Shape を継承してるわけではなく専ら area() メソッドを持つことを拠り所にしています。
その意味で、interface や protocol と似ていますが、「共通する特徴の定義」はしていません。
Zigには範囲型がないので代替のコード例を書いてみました。
[https://wandbox.org/permlink/jKGPlIi7JAKyYzPF 範囲型（の代替）]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const Range = struct {
s: i32,
e: i32,
const Self = @This();
pub fn init(s: i32, e: i32) Self {
return Self{ .s = s, .e = e };
}
pub fn next(self: *Self) ?i32 {
return if (self.s > self.e) null else blk: {
const n = self.s;
self.s += 1;
break :blk n;
};
}
};
pub fn main() !void {
var r = Range.init(23, 42);
while (r.next()) |i| {
try stdout.print("{} ", .{i});
}
}
実行結果:
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
エントリーポイント
コメント:
// から行末までがコメントです。
// /* ... */ スタイルのコメントはありません。
変数宣言
リテラル
\\ 複数行に渡る場合は
\\ この様に
\\ \\ を前置することで
\\ 記述できます。
制御構造
if ( 条件式 ) {
// ブロック
}
if ( 条件式 ) {
// ブロック１
} else {
// ブロック２
}
if ( オプショナル式 ) | 変数 | {
// ブロック１
} else {
// ブロック２
}
if ( エラーユニオン式 ) | 変数 | {
// ブロック１
} else | err | {
// ブロック２
}
switch ( 式 ) {
値１ => 式１,
値２ａ, 値２ｂ => | 変数２ | 式２, // 変数２にキャプチャー
値３ａ => | *変数３ | 式３, // 変数３にポインターをキャプチャー
elase => 式ｘ
}
var i = 1;
const q = while (i < 10) : (i += 1) {
if (i > 5) {
break true;
}
} else false;
var i: usize = 0;
outer: while (i < 10) : (i += 1) {
while (true) {
continue :outer;
}
}
while (オプショナル式) | 変数 | { // null でなければ変数にキャプチャー
// ブロック１
} else { // null だったとき
// ブロック２
}
while (エラーユニオン式) | 変数 | { // エラーコードでなければ変数にキャプチャー
// ブロック１
} else |err| { // エラーコードを err にキャプチャー
// ブロック２
}
const items = [_]i32 { 4, 5, 3, 4, 0 };
const q = for (items) | item | {
if (item == 5) {
break true;
}
} else false;
outer: for ([_]i32 { 4, 5, 3, 4, 0 }) | x | {
for ([_]i32 { 1, 3, 5, 7 }) | y | {
if ( x == y ) {
continue :outer;
}
}
}
コンテナー
struct型{
.メンバー１ = 式１,
.メンバー２ = 式２,
.メンバーｎ = 式ｎ
}
.{
式１,
式２,
式ｎ
}
関数
[TODO:書くべき項目を並べてみましたが、例えば「値と型」だけでも網羅的に書いていくとコンテンツの分量が爆発するのが目に見えているので、過剰になったらリファレンス篇に移動するなどの方法で、各節はコンパクトさを心がけたい]
Zigでは、関数 mainがエントリーポイントです。
nop.zig:
pub fn main() void {}
なにもしないプログラムはこの様になりますが、エラー集合型を返す可能性があるときは
pub fn main() !void {
// エラー集合型を返す可能性がある処理
}
と戻値の型を void から !void に代えます。
Zigのコメントに関する基本的なポイントを要約します。
3つのコメントのタイプ: Zigでは、通常のコメント、ドキュメントコメント、トップレベルのドキュメントコメントの3つのタイプがサポートされています。通常のコメントは無視されますが、ドキュメントコメントとトップレベルのドキュメントコメントは、パッケージのドキュメントを生成するためにコンパイラによって使用されます。
通常のコメント: 通常のコメントは // で始まり、次の改行文字（LFバイト）までがコメントとして扱われます。
ドキュメントコメント: ドキュメントコメントは、/// で始まります。複数のドキュメントコメントが連続する場合、1つの複数行のドキュメントコメントとして統合されます。ドキュメントコメントは、それに続く要素を文書化します。
トップレベルのドキュメントコメント: トップレベルのドキュメントコメントは、//! で始まります。これは、現在のモジュールを文書化します。
ドキュメントコメントの位置: ドキュメントコメントは特定の場所にのみ許可されています。例えば、式の途中や非ドキュメントコメントの直前にドキュメントコメントがある場合、コンパイルエラーになります。
通常のコメントとの統合: 現在、パッケージのドキュメントを生成する際に、通常のコメントはドキュメントコメントと統合されます。
Zigのコメントシステムは、コードの文書化と理解を容易にするための強力なツールです。
Zigでは、// から行末までがコメントです。
C言語の /* … */ のスタイルの複数行に渡るコメントはありません。
これは、コードの各行を文脈に関係なくトークン化できるようにするためです。
[https://wandbox.org/permlink/kAZ4vQFlg89ROhe9 hello.zig]:
// hello.zig:
const std = @import("std"); // 先頭に @ が付く関数は組込み関数です
pub fn main() !void { // 次の行の try 演算子がエラー集合を返す可能性があるので !void が戻値型
try std.io.getStdOut().writeAll("Hello, World!\n");
}
Zigでは、/// から始まるコメントは特別なコメントで、Docコメント( ''[https://ziglang.org/documentation/master/#Doc-comments Doc comments]'' )と呼ばれます。
Docコメントは特定の場所にしか許されません。式の途中や非Docコメントの直前など、予想外の場所にdocコメントがあると、コンパイルエラーになります。
[TODO:サンプルコードと整形結果]
Zigでは、//! から始まるコメントは特別なコメントで、トップレベルDocコメント( ''[https://ziglang.org/documentation/master/#Top-Level-Doc-Comments Top-Level Doc Comments]'' )と呼ばれます。
コンテナレベルのドキュメントのように、直後のドキュメントに属さないユーザードキュメントに、トップレベルDocコメントを使います。
[TODO:サンプルコードと整形結果]
DocコメントおよびトップレベルDocコメントは、コンパイル時に zig build-exe -femit-docs ソースファイル.zig の様に、-femit-docs をあたえると、 docs/ 以下にドキュメントが生成されます。
Zigの値と型に関する基本的なポイントを要約します。
値
整数: 整数は、i32、i64などのサイズに応じた型で表されます。算術演算やビット演算などがサポートされます。
浮動小数点数: 浮動小数点数は、f32、f64などのサイズに応じた型で表されます。浮動小数点数演算などがサポートされます。
真偽値: trueとfalseの2つの値を持つブール型があります。
オプション型: 値が存在するかどうかを示すオプション型があり、nullで初期化されます。
エラー統合: エラーコードまたは正常な値を保持するエラー統合型があります。
型
プリミティブ型: i32、f64、boolなどの基本的なデータ型があります。さらに、ポインターサイズの整数や特定のABIに対応する型もあります。
任意の型: void、anyerror、typeなど、特殊な目的の型があります。
文字列リテラルとUnicodeコードポイントリテラル: 文字列リテラルは定数のポインターであり、UTF-8でエンコードされた文字列を表します。Unicodeコードポイントリテラルは、UTF-8でエンコードされたUnicodeコードポイントを表します。
代入と変数
const: constキーワードを使用して、定数の値を変数に割り当てます。一度割り当てられた値は変更できません。
var: varキーワードを使用して、変数を宣言し、初期化して値を変更できるようにします。
undefined: undefinedは変数を初期化せずに残すために使用されます。これは、不正な値を意味し、バグの兆候です。undefinedは、任意の型に変換できますが、その後はその値が未定義であることを検出することはできません。
Zigの値と型のシステムは、明確で柔軟なプログラミングをサポートし、安全なコードの作成を促進します。
[TOD0:整数・浮動小数点数・bool・文字列・union・struct・enum・配列・ベクトル・スライス・ポインター・ゼロビットな型, 関連する組込み関数]
[https://wandbox.org/permlink/MVU7WLn9nYmcSFmq formatを伴うprintと値と型]:
pub fn main() !void {
const stdout = @import("std").io.getStdOut().writer();
try stdout.print(" (1) = {}\n", .{42});
try stdout.print(" (2) = {}\n", .{0x17});
try stdout.print(" (3) = {}\n", .{0o17});
try stdout.print(" (4) = {}\n", .{0b0100101});
try stdout.print(" (5) = {}\n", .{1e222});
try stdout.print(" (6) = {}\n", .{3.1415926536});
try stdout.print(" (7) = {}\n", .{'c'});
try stdout.print(" (8) = {c}\n", .{'c'});
try stdout.print(" (9) = {s}\n", .{"abcdef"});
try stdout.print("(10) = {}, {}\n", .{ 111, 999 });
try stdout.print("(11) = {1}, {0}\n", .{ 111, 999 });
try stdout.print("(12) = {1s}, {0}\n", .{ 111, "abc" });
try stdout.print("(13) = {0d}, {0b}, {0o}, {0x}, {0X}\n", .{ 123 });
}
実行結果:
(1) = 42
(2) = 23
(3) = 15
(4) = 37
(5) = 1.0e+222
(6) = 3.1415926536e+00
(7) = 99
(8) = c
(9) = abcdef
(10) = 111, 999
(11) = 999, 111
(12) = abc, 111
(13) = 123, 1111011, 173, 7b, 7B
print()の前の、[https://ziglang.org/documentation/master/#try try]は単項演算子です。
try は、右の式のエラーユニオン式を評価します。もしエラーであれば、同じエラーで現在の関数から戻ます。そうでない場合は、式はラップされていない値になります。
エラーユニオン型( [https://ziglang.org/documentation/master/#Error-Union-TypeError Union Type Error Union Type] )を返す関数は、try単項演算子か[https://ziglang.org/documentation/master/#catch catch]二項演算子で、値とエラーを弁別する必要があります（tryあるいはcatchがないと、コンパイル時にエラーになります）。
An error occurred:
/tmp/playground726918707/play.zig:3:10: error: error is ignored. consider using `try`, `catch`, or `if` stdout.print(" (1) = {}\n", .{42});
^
print()の様に、標準ライブラリーの format()を使う関数は、書式化文字列とタプル（匿名 struct ） .{ … } を引数にします。C言語のような、可変引数ではなくタプルを使うのでprintf() に代表される可変引数関数は利便性は高いですが、書式化文字列と引数の型不一致が生じると、スタックフレームを非可逆的に破壊します。これを未然に防ぐことは、コンパイル時の書式化文字列の解析と引数の型情報の照合で可能ですが、コンパイル時のメモリーと計算量（≒時間）の増大に直結します。、プレースホルダーがない場合でも、空のタプル.{} は必須です。
書式化文字列:通常の文字列ですが { と } で囲まれたプレスホルダーが、タプルの当該順位の値（を書式化した文字列）に置換わります。
と二文字重ねます。
書式化文字列のプレースホルダーによって、参照と文字列化される値のタプルです。
2つ以上の値を渡す場合は、第二引数を .{ 1, 2, 3 } の様にカンマ区切りのタプルにします（ {} の前の . （点）を忘れがちですが、型の省略を意味し必須です）。
基本的に、左から順にプレスホルダーにタプルの値が左から与えられますが、{0} {1} の書式で参照する引数の順位を明示できます。
書式指定と併用する時は、 stdout.print("? = {1s}, {0}\n", .{ 111, "abc" }) の様に順位が先、書式指定文字が後になります。
この機能は言語（自然言語）によって異なる語順を吸収することに使えそうですが、fmtの第一引数は comptime 修飾子がついていて変数にはできません。
数値（整数と浮動小数点数）や文字リテラルと文字列リテラルがあり、整数はいくつかの異なる基数表現が、浮動小数点数は指数表現と小数表現があります。
文字と文字列は明確に異なり、リテラルでは ’A’ が文字（@TypeOf('A') ⇒ comptime_int）、 ”ABC” が文字列（@TypeOf("ABC") ⇒ *const [3:0]u8）です。
嫌な予感がした人の直感は正解です。Zig では、文字列は第一級オブジェクトではなく文字（u8）の配列で、関数から返すときはアロケーターと defer の連携などで記憶域の寿命と値の妥当性を「プログラマー」が担保する必要があります。また、GoのGCはありません。CrystalのASTを操作できるマクロもありませんし、Rustの所有権も、C++のスマートポインターもありません。
このことは、C言語なみのプログラマー任せのメモリー管理を文字列以外でも強いられることを意味していますが、zig（コマンド）や標準ライブラリーのソースコードを読むと、複数の型でアロケーターを使い分け、スタック上のインスタンス（のハードウェア起因のスコープ）を使い分けられることを実践で証明しているので、pre-releaseから、initial-releasまでの間に、安定化・定式化が図られることを期待します。
[TODO:[https://github.com/ziglang/zig/blob/master/lib/std/fmt.zig master/lib/std/fmt.zig]を観て書いています。参照すべき標準ライブラリーのドキュメントを出来たら/仕様が安定したら見直し]
は符号付き7ビット整数を意味します。この表現の整数型に許される最大ビット幅は65535です。
構文(EBNF):
STRINGLITERALSINGLE = "\"" string_char* "\"" skip
STRINGLITERAL = STRINGLITERALSINGLE
| ( line_string skip )+
ox80_oxBF = [#x80-#xBF]
oxF4 = '\xF4'
ox80_ox8F = [#x80-#x8F]
oxF1_oxF3 = [#xF1-#xF3]
oxF0 = '\xF0'
ox90_0xBF = [#x90-#xBF]
oxEE_oxEF = [#xEE-#xEF]
oxED = '\xED'
ox80_ox9F = [#x80-#x9F]
oxE1_oxEC = [#xE1-#xEC]
oxE0 = '\xE0'
oxA0_oxBF = [#xA0-#xBF]
oxC2_oxDF = [#xC2-#xDF]
(* From https://lemire.me/blog/2018/05/09/how-quickly-can-you-check-that-a-string-is-valid-unicode-utf-8/ *)
mb_utf8_literal = oxF4 ox80_ox8F ox80_oxBF ox80_oxBF
| oxF1_oxF3 ox80_oxBF ox80_oxBF ox80_oxBF
| oxF0 ox90_0xBF ox80_oxBF ox80_oxBF
| oxEE_oxEF ox80_oxBF ox80_oxBF
| oxED ox80_ox9F ox80_oxBF
| oxE1_oxEC ox80_oxBF ox80_oxBF
| oxE0 oxA0_oxBF ox80_oxBF
| oxC2_oxDF ox80_oxBF
ascii_char_not_nl_slash_squote = [\000-\011\013-\046-\050-\133\135-\177]
char_escape = "\\x" hex hex
| "\\u{" hex+ "}"
| "\\" [nr\\t'"]
char_char = mb_utf8_literal
| char_escape
| ascii_char_not_nl_slash_squote
string_char = char_escape
| [^\\"\n]
line_string = ( "\\\\" [^\n]* [ \n]* )+
文字列リテラルは、ヌル終端バイト配列への定数型単一項目ポインターです。文字列リテラルの型は、長さとヌル終端であるという事実の両方をコード化しているため、スライスとヌル終端ポインターの両方に強制することが可能です。文字列リテラルを再参照すると配列に変換されます[https://ziglang.org/documentation/master/#String-Literals-and-Unicode-Code-Point-Literals String Literals and Unicode Code Point Literals]。
Zigにおける文字列のエンコーディングは、事実上UTF-8であると仮定されています。ZigのソースコードはUTF-8でエンコードされているので、ソースコードの文字列リテラル内に現れる非ASCIIバイトは、そのUTF-8の意味をZigのプログラム内の文字列の内容に引き継ぎ、コンパイラーがそのバイトを修正することはありません。ただし、UTF-8以外のバイトを文字列リテラルに埋め込むことは可能で、その場合は \xNN 記法を使用します。
Unicodeコードポイントリテラルの型は comptime_int で整数リテラルと同じです。すべてのエスケープシーケンスは、文字列リテラルと Unicodeコードポイントリテラルの両方において有効です。
他の多くのプログラミング言語では、Unicodeコードポイントリテラルは「文字リテラル」と呼ばれます。しかし、Unicode仕様の最近のバージョン（Unicode 13.0時点）では、「文字」の正確な技術的定義は存在しません。Zigでは、Unicodeコードポイントリテラルは、Unicodeのコードポイントの定義に対応します。
註：有効なUnicodeポイントの最大値は0x10ffffです。
マルチライン文字列リテラルは、エスケープが必要なく、複数の行にわたって記述することができます。マルチライン文字列リテラルを始めるには、\\ トークンを使用します。コメントと同様に、文字列リテラルは行の末尾まで続きます。行末は文字列リテラルに含まれません。ただし、次の行が \\ で始まる場合、改行が追加され、文字列リテラルが続きます。
[https://wandbox.org/permlink/TvQE1aV2QioiEnC3 マルチライン文字列リテラル]:
const stdout = @import("std").io.getStdOut().writer();
const message =
\\文字列リテラルを、エスケープ記号がなく複数行にまたがって書くことができます。
\\複数行の文字列リテラルを開始するには、\\ トークンを使用します。
\\コメントと同じように、文字列リテラルは行末まで続きます。
\\行の終わりは文字列リテラルに含まれません。
\\ただし、次の行が \\ で始まる場合は、改行が追加され文字列リテラルが続行されます。
pub fn main() !void {
try stdout.print("message = {s}", .{message});
}
実行結果:
message = 文字列リテラルを、エスケープ記号がなく複数行にまたがって書くことができます。
複数行の文字列リテラルを開始するには、\\ トークンを使用します。
コメントと同じように、文字列リテラルは行末まで続きます。
行の終わりは文字列リテラルに含まれません。
ただし、次の行が \\ で始まる場合は、改行が追加され文字列リテラルが続行されます
Zigにおける代入に関する説明の要旨は以下の通りです。
const キーワードを使用して、識別子に値を割り当てます。
const で定義された識別子は変更できません。その値は定数です。
変数として値を変更できるようにするには、var キーワードを使用します。
変数は初期化される必要があります。初期化されていない変数を使用すると、コンパイルエラーが発生します。
初期化されていない変数には undefined を使用して、未定義のままにすることができます。
定数式や単純型の型推論には comptime を使用します。
具体的なコード例は以下の通りです。
const print = @import("std").debug.print;
// constを使って定数を定義
const x = 1234;
pub fn main() void {
// 関数内でのconstは定数を定義
const y = 5678;
// 定数には値を再割り当てできない
// y = 1; // コンパイルエラー
// varを使って変数を定義
var z: i32 = 5678;
// 変数に値を再割り当て
z += 1;
// 変数は初期化する必要がある
// var w: i32;
comptime var w = 1; // 初期化を伴った宣言は型推論される
// 変数を undefined で初期化
var u: i32 = undefined;
u = 8;
print("{d}\n", .{x}); // 1234
print("{d}\n", .{y}); // 5678
print("{d}\n", .{z}); // 5679
print("{d}\n", .{w}); // 1
print("{d}\n", .{u}); // 8
}
上記のコードを実行すると、それぞれの変数や定数の挙動を確認できます。
comptimeは、Zig言語においてコンパイル時に式が評価されることを示します。この概念は、ジェネリック、定数式の評価、コンパイル時の最適化、およびコンパイル時の静的解析において重要な役割を果たします。
以下に、comptimeの詳細を説明します：
fn example(comptime T: type) T {
// Tの特定の型に基づいた処理を行う
}
const comptime MAX_VALUE: usize = 100;
const arraySize = comptime 10;
const comptime result = someFunction();
comptime if (someCondition) {
// このブロックはコンパイル時に評価される
} else {
// このブロックもコンパイル時に評価される
}
comptimeの使用により、Zig言語ではコンパイル時に高度な静的解析が実行され、パフォーマンスの向上やコードの安全性が確保されます。
このコードはコンパイルエラーになります。
[https://wandbox.org/permlink/0Wy4ptgSN9Rrxnq7 定数の初期値が関数の戻値だとエラー]:
fn mul(x: usize, y: usize) usize {
return x * y;
}
pub fn main() void {
const len : usize = mul(3, 4);
const ary: [len]i32 = undefined;
_ = ary;
}
コンパイル結果:
An error occurred:
playground/playground3656639701/play.zig:7:17: error: unable to resolve comptime value
playground/playground3656639701/play.zig:7:17: note: array length must be comptime-known
エラーメッセージの意味は以下の通りです：
error: unable to resolve comptime value: コンパイル時に解決できない値があります。
note: array length must be comptime-known: 配列の長さはコンパイル時に既知である必要があります。つまり、配列の長さは実行時に決定されることは許されません。
つまり、Zigでは配列の長さなどの定数値はコンパイル時に解決できる必要があります。そのため、関数の戻り値のように実行時に決定される値を定数の初期値として使用することはできません。
C++であれば、constexpr が適用なケースですが、Zigでは次のような解決方法を取ります。下記コードはエラーになりません。
[https://wandbox.org/permlink/bAZkdzqajcuNpEOG comptimeを追加しコンパイル時に実行]:
fn mul(x: usize, y: usize) usize {
return x * y;
}
pub fn main() void {
const len : usize = comptime mul(3, 4); // mul の前に comptime を追加
const ary: [len]i32 = undefined;
_ = ary;
}
変更点は mul() の呼出しを [https://ziglang.org/documentation/master/#comptime comptime] で修飾しただけです。comptime は、修飾子式をコンパイル時に実行する修飾子で、式の中でコンパイル時に未定な値が参照されると、エラーとなります。ここでは、数リテラル同士の商を求めているので、コンパイル時値が確定できます。
_ = ary は、「未使用変数」をサプレッスするときのイディオムです。
をサポートしています。
Zigのテストフレームワークは、テストを実行し、アサーションを評価し、カバレッジレポートを生成するための機能を提供します。
以下は、Zigのテストに関する概要です。
テスト宣言: テストは、testキーワードに続いて名前（オプション）とテストの本体を含むブロックで構成されます。これにより、コードの特定の部分や関数が期待どおりに動作するかを検証できます。
テスト実行: zig testコマンドを使用してテストを実行します。このコマンドは、テスト用のビルドを作成し、デフォルトのテストランナーを実行します。テストランナーは、テスト宣言を見つけて実行し、その結果を出力します。
テスト結果の報告: テストランナーは、テスト結果を標準エラーに出力します。成功したテスト、失敗したテスト、スキップされたテストなどの情報が報告されます。これにより、開発者はテストの状態を把握し、問題がある場合は修正できます。
テストのスキップ: error.SkipZigTestを返すことでテストをスキップすることができます。また、zig testコマンドに--test-filterオプションを指定して、特定のテストのみを実行することもできます。
テストの自動化: テストはコードの一部として記述されるため、変更があるたびに手動で実行する必要がありません。CI/CDパイプラインなどの自動化ツールと統合して、コードの品質を継続的に確認できます。
Zigのテストフレームワークは、コードの信頼性を向上させ、開発プロセスを効率化するのに役立ちます。テストは、バグを早期に発見し、コードの安定性を確保するのに不可欠な要素です。
テスト宣言の構文(EBNF):
test-decl = [ doc_comment ] "test" [ STRINGLITERALSINGLE ] block
if-test.zig:
const std = @import("std");
const expectEqual = std.testing.expectEqual;
test "if expr" {
const f = true;
var x: usize = 5;
x += if (f) 10 else 20;
try expectEqual(x, 15);
}
test "if stmt" {
const f = true;
var x: isize = 10;
if (!f) {
x += 10;
} else {
x -= 20;
}
try expectEqual(x, -10);
}
コマンドライン:
% zig test if-test.zig
All 2 tests passed.
このZigのテストコードは、 if 式と if 文の振る舞いをテストしています。
"if expr": if 式を使用して、条件に応じて異なる値を返し、その結果を変数に代入しています。その後、変数の値が期待通りであることを確認します。
"if stmt": if 文を使用して、条件に応じて異なるステートメントを実行し、その結果を変数に代入しています。その後、変数の値が期待通りであることを確認します。
テスト結果は、両方のテストが成功し、期待通りの結果が得られたことを示しています。つまり、条件式が正しく評価され、それに基づいて適切な操作が行われました。
このように、Zigのテストフレームワークを使用することで、さまざまな条件下でのプログラムの振る舞いを自動的にテストし、コードの信頼性を高めることができます。
fdiv-inf-nan.zig:
const std = @import("std");
const expect = std.testing.expect;
fn fdiv(n: f64, d: f64) f64 {
return n / d;
}
const inf = std.math.inf(f64);
const nan = std.math.nan(f64);
test "fdiv 1" {
try expect(fdiv(123.0, 111.1) == 123.0 / 111.1);
}
test "fdiv 2" {
try expect(fdiv(123.0, 0.0) == inf);
}
test "fdiv 3" {
try expect(fdiv(0.0, 0.0) == nan);
}
コマンドライン:
% zig version
0.11.0
% zig test fdiv-inf-nan.zig
Test [3/3] test.fdiv 3... FAIL (TestUnexpectedResult)
/usr/local/lib/zig/std/testing.zig:515:14: 0x2248df in expect (test)
if (!ok) return error.TestUnexpectedResult;
^
/usr/home/user1/tut/zig/fdiv-inf-nan.zig:20:5: 0x224b0b in test.fdiv 3 (test)
try expect(fdiv(0.0, 0.0) == nan);
^
2 passed; 0 skipped; 1 failed.
error: the following test command failed with exit code 1:
/home/user1/.cache/zig/o/00aa6779b54996b883ad0fc42233ea3d/test
この例では、Zig言語で fdiv-inf-nan.zig というファイルに記述されたテストコードが示されています。このコードは、fdiv 関数に対する3つのテストケースを含んでいます。
"fdiv 1": 正常な割り算が行われることを確認します。fdiv(123.0, 111.1) が 123.0 / 111.1 と等しいかどうかを期待します。
"fdiv 2": 0で割った場合、無限大を返すことを確認します。fdiv(123.0, 0.0) が inf と等しいかどうかを期待します。
"fdiv 3": 0を0で割った場合、非数を返すことを確認します。fdiv(0.0, 0.0) が nan と等しいかどうかを期待します。
テストを実行すると、2つのテストがパスし、1つのテストが失敗します。失敗したテストケースは "fdiv 3" です。このテストは、 fdiv(0.0, 0.0) が nan と等しいかどうかを検証しますが、実際にはそうではありませんでした。
この失敗は、期待される結果と実際の結果が一致しなかったことを示しています。この情報を元に、fdiv 関数の実装やテストコードを再検討することで、この問題を修正することができます。
fdiv-inf-nan-FIX.zig:
const std = @import("std");
const expect = std.testing.expect;
fn fdiv(n: f64, d: f64) f64 {
return n / d;
}
const inf = std.math.inf(f64);
const nan = std.math.nan(f64);
const isNan = std.math.isNan;
test "fdiv 1" {
try expect(fdiv(123.0, 111.1) == 123.0 / 111.1);
}
test "fdiv 2" {
try expect(fdiv(123.0, 0.0) == inf);
}
test "fdiv 3" {
try expect(isNan(fdiv(0.0, 0.0)));
}
コマンドライン:
% zig test fdiv-inf-nan-FIX.zig
All 3 tests passed.
修正された fdiv-inf-nan-FIX.zig ファイルでは、3番目のテストケースが修正されています。その変更箇所と結果について解説します。
この修正では、fdiv(0.0, 0.0) の結果が nan であるかどうかを確認するために、 std.math.isNan 関数を使用しています。この関数は、与えられた浮動小数点数が非数 (nan) であるかどうかを判定します。
修正後のコードを実行すると、全てのテストケースが成功し、期待通りの結果が得られました。
この修正により、fdiv 関数が非数 (nan) を返す場合に正常にテストが通るようになりました。
Zigでは、変数は名前を持った連続したメモリー領域で、型を持ちます。
変数は、宣言が必要です。
var キーワードまたは const キーワードを使用して変数を宣言します。const を使用することが一般的であり、これによりコードの読みやすさが向上し、最適化の機会が増えます。
extern キーワードや @extern 組み込み関数を使用して、他のオブジェクトからエクスポートされた変数とリンクすることができます。
コンテナレベルの変数は、静的なライフタイムを持ち、コンテナ内で宣言されるため、コンテナが評価されると初期化されます。これらは、構造体、共用体、列挙型、または不透明な型の内部で宣言することができます。
関数内でコンテナを使用することで、静的なローカル変数を作成することも可能です。
threadlocal キーワードを使用して、スレッドごとに異なる変数インスタンスを作成することができます。
関数内や comptime ブロック内で使用される変数は、ローカル変数と呼ばれます。これらは、関数やブロックのスコープ内でのみ有効です。
comptime キーワードを使用することで、コンパイル時に値がわかる変数を定義することができます。
Zig言語では、これらの変数のタイプやスコープを利用して、効率的で安全なプログラミングが可能です。
Zigでは型に名前を付けるためにも変数が使われます。
型を保持するconst変数の例:
const Complex = struct {
real: f64,
imag: f64,
};
const Colour = enum {
red,
green,
blue,
};
const Number = union {
int: i64,
float: f64,
};
構文(EBNF):
var-decl = ( "const" | "var" ) IDENTIFIER [ ":" type-expr ] [ byte-align ] [ link-section ] [ "=" expr ] ";"
var-decl = const-var-decl | var-var-decl
const-var-decl = "const" IDENTIFIER [ ":" type-expr ] [ byte-align ] [ link-section ] "=" expr ";"
var-var-decl = "var" IDENTIFIER ":" type-expr [ byte-align ] [ link-section ] "=" expr ";"
と意味論も加味するとなります。
var 変数の場合は、不定値としてプリミティブ値の undefined で初期化することができます[https://ziglang.org/documentation/master/#undefined undefined]。
undefinedは、任意の型に強制( ''be coerced'' )することができます。一旦これが起こると、値がundefinedであることを検出することができなくなります。 undefinedは、値が何にでもなり得ることを意味し、型によれば無意味なものでさえもあり得ることを意味します。英語で undefinedは "Not a meaningful value. Using this value would be a bug. The value will be unused, or overwritten before being used."（意味のない値。この値を使うとバグになる。この値は使われないか、使われる前に上書きされるでしょう）という意味です（ただしローカル変数が使われないと、error: unused local variable となります）。
キーワード const で宣言された変数は、必ず初期化が必要で、宣言以降は値を変更することはできません（イミュータブル）。
const 変数の宣言のとき型が省略されると、初期値から型をコンパイラーが決めてくれます（型推論）。
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
const i = 0;
try stdout.print("i = {}\n", .{i});
}
実行結果:
i = 0
このコードは、const キーワードを使って定数を宣言し、その値を出力しています。
以下に、このコードの各部分の解説を示します。
const std = @import("std");：std という名前で標準ライブラリをインポートします。これにより、標準ライブラリの機能を使うことができます。
const stdout = std.io.getStdOut().writer();：標準出力を表す stdout という名前のライターを取得します。これにより、プログラムは標準出力にテキストを書き込むことができます。
pub fn main() !void {：プログラムのエントリーポイントである main 関数を宣言します。この関数は、戻り値としてエラーを返す可能性があるため、!void 型を返します。pub キーワードは、この関数が外部からアクセス可能であることを示します。
const i = 0;：i という名前の定数を宣言し、初期値として整数 0 を与えます。この定数は後で使用されます。
try stdout.print("i = {}\n", .{i});：標準出力に文字列を書き込むために print メソッドを使用します。"i = {}\n" の部分はフォーマット文字列であり、{} の位置に i の値が挿入されます。.{i} は、変数 i の値を挿入するための特別な構文です。
キーワード var で変数を宣言するときも初期化は必須です。またいつでも値を変更することはできます。
var 変数の宣言では、型を省略することはできません。
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var i : isize = 0;
try stdout.print("i = {}\n", .{i});
i = 12;
try stdout.print("i = {}\n", .{i});
i *= i;
try stdout.print("i = {}\n", .{i});
}
実行結果:
i = 0
i = 12
i = 144
このコードは、var キーワードを使用して可変の変数を宣言し、その値を変更しています。
以下に、このコードの各部分の解説を示します。
const std = @import("std");：標準ライブラリを std としてインポートします。
const stdout = std.io.getStdOut().writer();：標準出力を表す stdout という名前のライターを取得します。
pub fn main() !void {：プログラムのエントリーポイントである main 関数を宣言します。この関数は、エラーを返す可能性があるため、!void 型を返します。
var i : isize = 0;：i という名前の変数を宣言し、型として isize を指定して初期値として整数 0 を与えます。
try stdout.print("i = {}\n", .{i});：標準出力に文字列を書き込むために print メソッドを使用します。"i = {}\n" の部分はフォーマット文字列であり、{} の位置に i の値が挿入されます。
i = 12;：変数 i の値を 12 に変更します。
try stdout.print("i = {}\n", .{i});：print メソッドを使用して、変更後の i の値を標準出力に出力します。
i *= i;：変数 i の値を自乗して再代入します。
try stdout.print("i = {}\n", .{i});：print メソッドを使用して、再代入後の i の値を標準出力に出力します。
変数は、外部スコープの変数をシャドーイングすることは許されません[https://ziglang.org/documentation/master/#Identifiers Identifiers]。
[https://wandbox.org/permlink/yRqEgKgW7ltWYjOc 外部スコープの識別子をシャドーイングすることは許されません]:
const x = 0;
pub fn main() !void {
var x : isize = 1;
}
コンパイル結果:
main.zig:3:9: error: local variable shadows declaration of 'x'
main.zig:1:1: note: declared here
(exit status 1)
エラーメッセージによれば、外部スコープで宣言された x がローカルスコープで再度宣言されたため、エラーが発生したことがわかります。Zigでは、外部スコープの変数をシャドーイングすることは許されていないため、このコードはコンパイルエラーとなります。
識別子は英数字かアンダースコアで始まり、英数字かアンダースコアがいくつでも続くことができます。また、キーワードと重なってはいけません。
外部ライブラリーとのリンクなど、これらの要件に適合しない名前が必要な場合は、@""構文を使用することができます。
const @"identifier with spaces in it" = 0xff;
const @"1SmallStep4Man" = 112358;
const c = @import("std").c;
pub extern "c" fn @"error"() void;
pub extern "c" fn @"fstat$INODE64"(fd: c.fd_t, buf: *c.Stat) c_int;
const Color = enum {
red,
@"really red",
};
const color: Color = .@"really red";
このコードは、Zigで識別子にスペースが含まれる場合や、数字で始まる識別子を使用する方法、および外部C関数に識別子を付ける方法を示しています。
以下に、各部分の解説を示します。
const @"identifier with spaces in it" = 0xff;：スペースが含まれる識別子を使用して、定数を宣言しています。Zigでは、ダブルクォートで囲まれた文字列を識別子として使用することができます。
const @"1SmallStep4Man" = 112358;：数字で始まる識別子を使用して、定数を宣言しています。同様に、ダブルクォートで囲まれた文字列を識別子として使用しています。
const c = @import("std").c;：外部ライブラリをインポートして、その一部を c という名前で定数として使用します。これにより、外部のCライブラリで定義された型や関数にアクセスすることができます。
pub extern "c" fn @"error"() void;：外部C関数に識別子を付けて宣言しています。extern "c" はC言語の呼び出し規約を指定し、void は戻り値の型を示しています。
pub extern "c" fn @"fstat$INODE64"(fd: c.fd_t, buf: *c.Stat) c_int;：同様に、外部C関数に識別子を付けて宣言しています。この関数は引数を取り、c_int 型を戻り値として返します。
const Color = enum { red, @"really red", };：列挙型 Color を定義しています。@"really red" のように、列挙子にも識別子を付けることができます。
const color: Color = .@"really red";：Color 列挙型の変数 color を宣言し、@"really red" の列挙子を初期値として指定しています。
このように、Zigでは識別子にスペースや数字を含めることができ、また識別子を外部C関数に付けることもできます。これにより、異なる名前付け規則を持つライブラリや関数をZigのコードから使用することができます。
Zigでは、さまざまな整数リテラルの表現がサポートされています。
構文(EBNF):
INTEGER = "0b" bin_int skip
| "0o" oct_int skip
| "0x" hex_int skip
| dec_int skip
skip = ([ \n] | line_comment)*
bin = "0" | "1"
bin_ = [ '_' ] bin
oct = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7"
oct_ = [ '_' ] oct
hex = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
| "a" | "b" | "c" | "d" | "e" | "f"
| "A" | "B" | "C" | "D" | "E" | "F"
hex_ = [ '_' ] hex
dec = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
dec_ = [ '_' ] dec
bin_int = bin bin_*
oct_int = oct oct_*
dec_int = dec dec_*
hex_int = hex hex_*
。
2進数・8進数・16進数はそれぞれ 0b・0o・0x を前置します。
他の多くの言語と異なり 0 の次の文字は小文字が必須で、大文字は受け付けません。
整数リテラルにはサイズ制限がなく、不明な動作が発生する場合にはコンパイラがそれをキャッチします。
ただし、整数値がコンパイル時には不明である場合、サイズが判明している必要があり、未定義の動作の影響を受けます。
fn divide(a: i32, b: i32) i32 {
return a / b;
}
このような関数では、値 a と b は実行時のみに判明するため、この除算操作は整数オーバーフローやゼロ除算の影響を受ける可能性があります。
整数演算では、+ や - などの演算子は整数オーバーフローに対して未定義の動作を引き起こします。代わりに、すべてのターゲットに対してラッピングおよびサチュレーティング演算を行うための代替演算子が提供されています。
Zigでは任意のビット幅の整数もサポートされており、i または u の後に数字が続く識別子を使用して参照されます。たとえば、i7 は7ビットの符号付き整数を示します。符号付き整数型の場合、Zigでは2の補数表現が使用されます。
[https://codapi.org/embed/?sandbox=zig&code=const+std+%3D+%40import%28%22std%22%29%3B%0Aconst+stdout+%3D+std.io.getStdOut%28%29.writer%28%29%3B%0A%0Apub+fn+main%28%29+%21void+%7B%0A++++var+i%3A+i5+%3D+0%3B%0A++++var+j%3A+i4+%3D+0%3B%0A++++var+k%3A+i4+%3D+0%3B%0A%0A++++while+%28i+%3C+20%29+%7B%0A++++++++try+stdout.print%28%22i%3A%7B%7D%2C+j%3A%7B%7D%2C+k%3A%7B%7D%5Cn%22%2C+.%7B+i%2C+j%2C+k+%7D%29%3B%0A++++++++i+%3D+i+%2B+1%3B%0A++++++++j+%3D+j+%2B%25+1%3B%0A++++++++k+%3D+k+%2B%7C+1%3B%0A++++%7D%0A%7D ラッピング演算およびサチュレーティング演算とオーバーフローの例]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var i: i5 = 0;
var j: i4 = 0;
var k: i4 = 0;
while (i < 20) {
try stdout.print("i:{}, j:{}, k:{}\n", .{ i, j, k });
i = i + 1;
j = j +% 1;
k = k +| 1;
}
}
実行結果:
i:0, j:0, k:0
i:1, j:1, k:1
i:2, j:2, k:2
i:3, j:3, k:3
i:4, j:4, k:4
i:5, j:5, k:5
i:6, j:6, k:6
i:7, j:7, k:7
i:8, j:-8, k:7
i:9, j:-7, k:7
i:10, j:-6, k:7
i:11, j:-5, k:7
i:12, j:-4, k:7
i:13, j:-3, k:7
i:14, j:-2, k:7
i:15, j:-1, k:7
thread 1 panic: integer overflow
/sandbox/src/main.zig:11:15: 0x21e650 in main (main)
i = i + 1;
^
/usr/lib/zig/std/start.zig:574:37: 0x21e4fe in posixCallMainAndExit (main)
const result = root.main() catch |err| {
^
/usr/lib/zig/std/start.zig:243:5: 0x21dfe1 in _start (main)
asm volatile (switch (native_arch) {
^
???:?:?: 0x0 in ??? (???)
(exit status 139)
このZigのプログラムは、異なるビット幅の整数型を使用し、それらの振る舞いを示しています。以下にコードの解説を示します。
var i: i5 = 0;：i という名前の変数を宣言し、初期値として 0 を与えます。この変数は i5 型であり、5ビットの符号付き整数を表します。
var j: i4 = 0;：j という名前の変数を宣言し、初期値として 0 を与えます。この変数は i4 型であり、4ビットの符号付き整数を表します。
var k: i4 = 0;：k という名前の変数を宣言し、初期値として 0 を与えます。この変数も i4 型であり、4ビットの符号付き整数を表します。
while (i < 20) { ... }：i の値が20未満の間、ループが続きます。
i = i + 1;：変数 i の値を1増加させます。この演算は、i5 型の整数の範囲を超える可能性があり、後に整数オーバーフローが発生します。
j = j +% 1;：変数 j の値を1増加させます。ここではラップアラウンド演算子 +% を使用しています。これにより、j の値が範囲外になる場合は0に戻ります。
k = k +| 1;：変数 k の値を1増加させます。ここでは飽和演算子 +| を使用しています。これにより、k の値が範囲外になる場合は最大値に飽和します。
プログラムの実行結果から、i の値がオーバーフローし、未定義の振る舞いが発生しました。これは i5 型の整数が範囲を超えたためです。このような場合、Zigは整数オーバーフローを検出してプログラムをパニックさせます。一方で、j の値はラッピング演算子により範囲外になることなく、k の値は飽和演算子により最大値で飽和しています。
Zigでは、以下の浮動小数点数型がサポートされています：
浮動小数点数リテラルは、comptime_float型を持ち、最大の他の浮動小数点数型（f128）と同じ精度と操作を保証します。
浮動小数点数リテラルは、任意の浮動小数点数型および整数型（小数点以下がない場合）に変換されます。
const floating_point = 123.0E+77;
const another_float = 123.0;
const yet_another = 123.0e+77;
const hex_floating_point = 0x103.70p-5;
const another_hex_float = 0x103.70;
const yet_another_hex_float = 0x103.70P-5;
構文(EBNF):
FLOAT = "0x" hex_int "." hex_int [ ( "p" | "P" ) [ "-" | "+" ] dec_int ] skip
| dec_int "." dec_int [ ( "e" | "E" ) [ "-" | "+" ] dec_int ] skip
| "0x" hex_int ( "p" | "P" ) [ "-" | "+" ] dec_int skip
| dec_int ( "e" | "E" ) [ "-" | "+" ] dec_int skip
。
10進数のほか、16進数の浮動小数点数リテラルに対応していますが、2進数・8進数の浮動小数点数リテラルには対応していません。
16進数の浮動小数点数リテラルも、指数部は10進数です。
NaN、無限大、負の無限大のための構文はありません。これらの特殊な値については、標準ライブラリを使用する必要があります。
const std = @import("std");
const inf = std.math.inf(f32);
const negative_inf = -std.math.inf(f64);
const nan = std.math.nan(f128);
デフォルトでは、浮動小数点数の演算はStrictモードを使用しますが、ブロックごとにOptimizedモードに切り替えることができます。
export fn foo_strict(x: f64) f64 {
return x + big - big;
}
export fn foo_optimized(x: f64) f64 {
@setFloatMode(.Optimized);
return x + big - big;
}
上記の例では、演算をStrictモードとOptimizedモードで比較しています。
Zigの演算子の概要は以下の通りです：
演算子の詳細は、Zigのドキュメントやリファレンスを参照してください。
Zigは、やや関数型プログラミング言語の影響を受けており、多くの構文が値を持ちます。
Zigの制御構造の多くは式構文と文構文を持ちます（例外は #switch で式構文しかありません）。
以下、Kotlin#分岐から、一部の例を移植しました。
Zigには、#if と #switch の２つの分岐構文があります。
Zigでは、if は値を分岐する if式 とブロックを分岐する if文 があります。
構文(EBNF)[https://ziglang.org/documentation/master/#Grammar Grammar]から抜粋。原文はPEG(Parsing Expression Grammar)なので終端子の記法などはアレンジしています。:
if-expr = if-prefix expr [ "else" [ payload ] expr ]
if-prefix = "if" "(" expr ")" [ ptr-payload ]
payload = "|" IDENTIFIER "|"
ptr-payload = "|" [ "*" ] IDENTIFIER "|"
if-statement = if-prefix block-expr [ "else" [ payload ] statement ]
| if-prefix assign-expr ( ”;” | "else" [ payload ] statement )
block-expr = [ block-label ] block
block-label = IDENTIFIER ":"
block = "{" statement* "}"
assign-expr = expr [ assign-op expr ]
assign-op = "+=" | "-=" | "*=" | "/=" ...（略）
[https://wandbox.org/permlink/QcMQ37j87DHcVBBA if式の例]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
const i = 0;
if (i == 0)
try stdout.writeAll("zero\n") // ここに ; があるとエラーになります。
else
try stdout.writeAll("non zero\n");
try stdout.print(if (i == 0)
"ゼロ\n"
else
"非ゼロ\n", .{});
}
実行結果:
zero
ゼロ
if文に変更:
if (i == 0) {
try stdout.writeAll("zero\n"); // ブロック中ならば ; があってもエラーになりません。
} else {
try stdout.writeAll("non zero\n");
}
と ; を使うことができますこの場合、文法的には if-expr（if式）ではなく if-statment（if文）になります。。
if式で、条件が成立せずelseを省略されたとき、式の値は void となります。
[https://wandbox.org/permlink/GAyh2Mk0KK0AFLwT 条件不成立でelseを省略すると]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
try stdout.print("if (false) 1 => {}\n", .{ if (false) 1 });
}
実行結果:
if (false) 1 => void
[https://wandbox.org/permlink/OCdAr0VGlXu42dOK 条件式に整数を使うと]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
const i = 0;
if (i) {
try stdout.writeAll("not zero");
}
}
./main.zig:7:9: error: expected type 'bool', found 'comptime_int'
if (i) {
^
Zigでは、if に限らず、条件式は、bool、オプショナル型あるいはエラーユニオン型でなければいけません。
if (i != 0) {
とします。
ifの条件式にはオプショナル型( ?T )を使うことが出来ます。この場合は、通常の値のほか null を想定でき、null に出会った場合は else 節が実行されます。
[https://codapi.org/embed/?sandbox=zig&code=const+std+%3D+%40import%28%22std%22%29%3B%0Aconst+stdout+%3D+std.io.getStdOut%28%29.writer%28%29%3B%0A%0Apub+fn+main%28%29+%21void+%7B%0A++++var+a%3A+%3Fu16+%3D+42%3B%0A++++if+%28a%29+%7C*value%7C+%7B%0A++++++++try+stdout.print%28%22value.*+%3D+%7B%7D%28%7B%7D%29%5Cn%22%2C+.%7Bvalue.*%2C+%40TypeOf%28value.*%29%7D%29%3B%0A++++++++value.*+%3D+123%3B%0A++++%7D+else+%7B%0A++++++++unreachable%3B%0A++++%7D%0A++++if+%28a%29+%7Cn%7C+%7B%0A++++++++try+stdout.print%28%22n+%3D+%7B%7D%28%7B%7D%29%5Cn%22%2C+.%7Bn%2C+%40TypeOf%28n%29%7D%29%3B%0A++++%7D+else+%7B%0A++++++++unreachable%3B%0A++++%7D%0A++++a+%3D+null%3B%0A++++if+%28a%29+%7C_%7C+%7B%0A++++++++unreachable%3B%0A++++%7D+else+%7B%0A++++++++try+stdout.print%28%22a+%3D+%7B%3F%7D%28%7B%7D%29%5Cn%22%2C+.%7Ba%2C+%40TypeOf%28a%29%7D%29%3B%0A++++%7D%0A%7D nullable-if.zig]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var a: ?u16 = 42;
if (a) |*value| {
try stdout.print("value.* = {}({})\n", .{value.*, @TypeOf(value.*)});
value.* = 123;
} else {
unreachable;
}
if (a) |n| {
try stdout.print("n = {}({})\n", .{n, @TypeOf(n)});
} else {
unreachable;
}
a = null;
if (a) |_| {
unreachable;
} else {
try stdout.print("a = {?}({})\n", .{a, @TypeOf(a)});
}
}
value.* = 42(u16)
n = 123(u16)
a = null(?u16)
このコードでは、aという名前のオプショナル型の変数を定義し、最初に値 42 で初期化しています。
次に、最初のif文では、aがnullでない場合にブロック内の処理が実行されます。この場合、|*value|構文を使ってオプショナル型の値を取り出し、そのポインターをvalueに割り当てています。その後、取り出した値を出力してから、その値を123に書き換えています。
2番目のif文も同様に、aがnullでない場合にブロック内の処理が実行されます。ただし、こちらでは|n|の構文を使ってオプショナル型の値そのものを取り出し、その値を出力しています。
最後のif文では、aにnullを割り当てています。その後、aがnullであるかどうかをチェックし、nullの場合にはelseブロック内の処理が実行されます。ここでは、|_|の構文を使って、取り出す値がないことを示しています。その後、aがnullであることを出力しています。
実行結果を見ると、それぞれのif文が条件に応じて正しく動作していることがわかります。
ifの条件式にはエラーユニオン型( !T )を使うことが出来ます。この場合は、通常の値のほかエラーコードを想定でき、エラーコードに出会った場合は else |err| 節が実行され、err がエラーコードです。
[https://codapi.org/embed/?sandbox=zig&code=const+std+%3D+%40import%28%22std%22%29%3B%0Aconst+stdout+%3D+std.io.getStdOut%28%29.writer%28%29%3B%0A%0Apub+fn+main%28%29+%21void+%7B++++%0A++++var+b%3A+anyerror%21u32+%3D+error.BadValue%3B%0A++++try+stdout.print%28%22b+%3D+%7Bany%7D%28%7B%7D%29%5Cn%22%2C+.%7Bb%2C+%40TypeOf%28b%29%7D%29%3B%0A++++if+%28b%29+%7C_%7C+%7B%0A++++++++unreachable%3B%0A++++%7D+else+%7Cerr%7C+%7B%0A++++++++try+stdout.print%28%22err+%3D+%7B%3F%7D%28%7B%7D%29%5Cn%22%2C+.%7Berr%2C+%40TypeOf%28err%29%7D%29%3B%0A++++%7D%0A++++b+%3D+4423%3B%0A++++try+stdout.print%28%22b+%3D+%7Bany%7D%28%7B%7D%29%5Cn%22%2C+.%7Bb%2C+%40TypeOf%28b%29%7D%29%3B%0A++++if+%28b%29+%7Cn%7C+%7B%0A++++++++try+stdout.print%28%22n+%3D+%7B%7D%28%7B%7D%29%5Cn%22%2C+.%7Bn%2C+%40TypeOf%28n%29%7D%29%3B%0A++++%7D+else+%7C_%7C+%7B%0A++++++++unreachable%3B%0A++++%7D%0A%7D errorunion-if.zig]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var b: anyerror!u32 = error.BadValue;
try stdout.print("b = {any}({})\n", .{b, @TypeOf(b)});
if (b) |_| {
unreachable;
} else |err| {
try stdout.print("err = {?}({})\n", .{err, @TypeOf(err)});
}
b = 4423;
try stdout.print("b = {any}({})\n", .{b, @TypeOf(b)});
if (b) |n| {
try stdout.print("n = {}({})\n", .{n, @TypeOf(n)});
} else |_| {
unreachable;
}
}
b = error.BadValue(anyerror!u32)
err = error.BadValue(anyerror)
b = 4423(anyerror!u32)
n = 4423(u32)
このコードでは、bという名前のエラーユニオン型の変数を定義し、最初にerror.BadValueというエラーコードを割り当てます。
次に、最初のif文では、bがエラーコードを持っている場合にはelse |err|ブロック内の処理が実行されます。この場合、|err|の構文を使ってエラーコードを取り出し、そのエラーコードをデバッグ出力しています。
2番目のif文も同様に、bがエラーコードを持っている場合にはelse |_|ブロック内の処理が実行されます。ただし、こちらでは|n|の構文を使ってエラーコードの値そのものを取り出し、その値をデバッグ出力しています。
実行結果を見ると、それぞれのif文が条件に応じて正しく動作していることがわかります。最初の場合ではエラーコードが出力され、2番目の場合では正常な値が出力されています。
Zigでは、switch は式で値を返します。switch文はありません。switch-prong（分岐先）の値の型は一致している必要があります。
構文(EBNF):
switch-expr = "switch" "(" expr ")" "{" switch-prong-list "}"
switch-prong-list = (switch-prong "," )* [ switch-prong ]
switch-prong = switch-case "=>" [ ptr-payload ] assign-expr
switch-case = switch-item ( "," switch-item )* [ "," ] | "else"
switch-item = expr [ "..." expr ]
[https://wandbox.org/permlink/xhVUSAwvUzfCqnTi switch.zig]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
const ary = .{1, 'Z', 3.14, .{1,2,3}, true, void, null, i64};
inline for (ary) |obj| {
switch (@typeInfo(@TypeOf(obj))) {
.ComptimeInt => try stdout.print("ComptimeInt: {}\n", .{obj}),
.ComptimeFloat => try stdout.print("ComptimeFloat: {}\n", .{obj}),
.Struct => try stdout.print("Struct: {}\n", .{obj}),
.Bool => try stdout.print("Bool: {}\n", .{obj}),
.Type => try stdout.print("Type: {}\n", .{obj}),
.Null => try stdout.print("Null: {}\n", .{obj}),
else => try stdout.print("{}\n", .{@typeInfo(@TypeOf(obj))})
}
}
}
実行結果:
ComptimeInt: 1
ComptimeInt: 90
ComptimeFloat: 3.14e+00
Struct: { 1, 2, 3 }
Bool: true
Type: void
Null: null
Type: i64
Zigには、#while と #for の２つの反復構文があります。
whileは条件が成立している間、繰り返しを行います。条件がブロック内で評価され、条件が偽になるまで続きます。whileにはelse節もあり、ループ完了後に実行されます。また、ラベルを付けてネストしたループからのbreakやcontinueも可能です。オプショナル型やエラーユニオン型の条件も受け付け、それらの値をキャプチャできます。インライン化も可能で、コンパイル時の最適化や型の利用が可能です。
構文(EBNF):
loop-expr = [ "inline" ] ( for-expr | while-expr )
while-expr = while-prefix expr [ "else" [ payload ] expr ]
while-prefix = "while" "(" expr ")" [ ptr-payload ] [ while-continue-expr ]
while-continue-expr = ":" "(" assign-expr ")"
while-statement = while-prefix block-expr [ "else" [ pay-load ] statement ]
| while-prefix assign-expr ( ”;” | "else" [ payload ] statement )
多くの構文要素は if と共通しているので #if の構文も参照してください。
Zigも、else を伴うことのできる while です。
while.zig:
pub fn main() !void {
var i: usize = 1;
while (i < 50) : (i += 1) {
try stdout.print("{}! == {}\n", .{ i, fib(i) });
}
}
fn fib(n: usize) usize {
return if (n < 2) n else fib(n - 1) + fib(n - 2);
}
const stdout = std.io.getStdOut().writer();
const std = @import("std");
実行結果:
An error occurred:
1! == 1
2! == 1
3! == 2
4! == 3
5! == 5
6! == 8
7! == 13
8! == 21
9! == 34
10! == 55
11! == 89
12! == 144
13! == 233
14! == 377
15! == 610
16! == 987
17! == 1597
18! == 2584
19! == 4181
20! == 6765
21! == 10946
22! == 17711
23! == 28657
24! == 46368
25! == 75025
26! == 121393
27! == 196418
28! == 317811
29! == 514229
30! == 832040
31! == 1346269
32! == 2178309
33! == 3524578
34! == 5702887
35! == 9227465
36! == 14930352
37! == 24157817
38! == 39088169
39! == 63245986
while (i < 50) : (i += 1) {
try stdout.print("{}! == {}\n", .{ i, fib(i) });
}
while (i < 50) {
try stdout.print("{}! == {}\n", .{ i, fib(i) });
i += 1;
}
と等価で、追加の式はC言語の for (;;) の三項目にあたります。
while-with-else.zig:
const stdout = std.io.getStdOut().writer();
const std = @import("std");
pub fn main() !void {
var i: usize = 0;
while (i < 5) : (i += 1) {
try stdout.print("{} ", .{i});
} else {
try stdout.writeAll("done!\n");
}
i = 0;
while (i < 50) : (i += 1) {
try stdout.print("{} ", .{i});
if (i == 10) {
try stdout.writeAll("break!\n");
break;
}
} else {
try stdout.writeAll("done!\n");
}
}
実行結果:
0 1 2 3 4 done!
0 1 2 3 4 5 6 7 8 9 10 break!
while のループを「完走」すると、else 以降が実行されます。
もし break などで中断されると、else 以降は実行されません。
{{コラム|elseを伴ったwhileの使いどころ|2=
Zigのwhileループは完走すると実行するelse節を置くことができます。
では、このelse節は何に使うのでしょう？
1000以下の素数を求める（フラッグ版）:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var i: usize = 2;
while (i <= 1000) : (i += 1) {
var j: usize = 2;
var is_prime = true;
while (j * j <= i) : (j += 1) {
if (i % j == 0) {
is_prime = false;
break;
}
}
if (is_prime)
try stdout.print("{} ", .{i});
}
}
1000以下の素数を求める（else版）:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var i: usize = 2;
while (i <= 1000) : (i += 1) {
var j: usize = 2;
while (j * j <= i) : (j += 1) {
if (i % j == 0) {
break;
}
} else try stdout.print("{} ", .{i});
}
}
フラッグがなくなり簡素になりました。
Zig以外の言語では、Pythonでも else を伴ったループ構文があります。
whileループにラベルを付けると、ネストしたループ内からのbreakやcontinueから参照できます[https://ziglang.org/documentation/master/#Labeled-while Labeled while]。
ラベル付きwhile:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var i: u16 = 0;
var j: u16 = 0;
outer: while (i < 15) : (i += 1) {
j = 0;
while (j < 15) : (j += 1) {
if (i == 7 and j == 11) {
break :outer;
}
}
}
try stdout.print("i = {}, j = {}\n", .{ i, j });
}
実行結果:
i = 7, j = 11
ifと同じように、whileループは条件としてオプショナル型の値を受け取り、ペイロードをキャプチャすることができます。null に遭遇した場合、ループは終了します[https://ziglang.org/documentation/master/#while-with-Optionals while with Optionals]。
while 式に |x| 構文がある場合、while 条件はオプショナル型（あるいは次で述べるエラーユニオン型）でなければなりません（この x かキャプチャされたペイロードです）。
[https://wandbox.org/permlink/fFmMl6h4567ILpTt オプショナル型を条件としたwhile]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var sum: u32 = 0;
while (sequence()) |n| {
sum += n;
}
try stdout.print("sum = {}\n", .{sum});
}
fn sequence() ?u32 {
const S = struct {
var x: u32 = 5;
};
return if (S.x == 0) null else blk: {
S.x -= 1;
break :blk S.x;
};
}
実行結果:
sum = 10
ifと同じように、whileループは条件としてエラーユニオン型の値を受け取り、ペイロードをキャプチャすることができます。エラーコードに遭遇した場合、ループは終了します[https://ziglang.org/documentation/master/#while-with-Error-Unions while with Error Unions]。
while 式に |x| 構文がある場合、while 条件はエラーユニオン型（あるいは前で述べたオプショナル型）でなければなりません（この x かキャプチャされたペイロードです）。
while 式に else |x| 構文がある場合、while 条件にエラーユニオン型が必要です。
[https://wandbox.org/permlink/r8xbAanhVSDHyIws エラーユニオン型を条件としたwhile]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var sum: u32 = 0;
while (sequence()) |n| {
sum += n;
} else |err| {
try stdout.print("err = {}\n", .{err});
}
try stdout.print("sum = {}\n", .{sum});
}
fn sequence() !u32 {
const S = struct {
var x: u32 = 5;
};
return if (S.x == 0) error.ReachedZero else blk: {
S.x -= 1;
break :blk S.x;
};
}
実行結果:
err = error.ReachedZero
sum = 10
whileループはインライン化することができる。これにより、ループが展開され、コンパイル時にしかできないこと、例えば、型をファーストクラスの値として使用することなどができるようになります[https://ziglang.org/documentation/master/#inline-while inline while]。
[TODO:コード例]
Zigのforループは、スライスや配列をイテレートする際に柔軟性を提供します。要素ごとに処理を行い、continueやbreakを使用して制御フローを操作できます。インデックスや複数のオブジェクトの同時イテレーション、参照によるイテレーションなど、多彩な機能を持ちます。また、forループを式として使用することも可能で、else節を使ってループが完了した際に特定の処理を行うことができます。ラベル付きループやインライン化もサポートされ、効率的なコーディングを実現します。
構文(EBNF):
for-statement = "for" for-prefix block-expr [ "else" statement ]
for-expr = "for" for-prefix expr [ "else" expr ]
for-prefix = "(" for-arguments-list ")" ptr-list-payload
for-arguments-list = for-item { "," for-item } [ "," ]
for-item = expr [ ".." expr]
ptr-list-payload = "|" [ "*" ] IDENTIFIER { "," [ "*" ] IDENTIFIER } [ "," ] "|"
。
for-ary.zig:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
const int = i16;
const ary = [_]int{ 1, 5, 4, 6, 4, 9 };
var sum: int = 0;
for (ary, 0..) |n, i| {
try stdout.print("n = {}, i = {}\n", .{ n, i });
sum += n;
}
try stdout.print("sum = {}\n", .{sum});
var ary2 = ary;
for (&ary2) |*r| {
r.* += 10;
}
for (ary2) |n| {
try stdout.print("{}, ", .{n});
}
}
実行結果:
n = 1, i = 0
n = 5, i = 1
n = 4, i = 2
n = 6, i = 3
n = 4, i = 4
n = 9, i = 5
sum = 29
11, 15, 14, 16, 14, 19,
[https://wandbox.org/permlink/BOuIKx4BYffBh5Bk for-str.zig]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
const str = "simple string";
for (str) |c| {
try stdout.print("{c} ", .{c});
}
}
実行結果:
s i m p l e s t r i n g
for-range.zig:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
for (23..43) |i| {
try stdout.print("{} ", .{i});
}
}
実行結果:
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
ラベル付きfor( ''Labeled for'' )とは、ラベルを伴った for ループでラベルも for 構文の一部です。for ループにラベルを付けると、ネストしたループ内からのbreakやcontinueから参照できます[https://ziglang.org/documentation/master/#Labeled-for Labeled for]。
ラベル付きfor:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var x: usize = undefined;
var y: usize = undefined;
loop_top: for ("Hello", 0..) |co, i| {
for ("World", 0..) |ci, j| {
if (co == ci) {
try stdout.print("c = '{c}'({}, {})\n", .{ ci, i, j });
x = i;
y = j;
break :loop_top;
}
}
}
try stdout.print("x = {}, y = {}\n", .{ x, y });
}
実行結果:
c = 'l'(2, 3)
x = 2, y = 3
Forループはインライン化することができます。これにより、ループが展開され、コンパイル時にしかできないこと、例えば、型をファーストクラスの値として使用することなどができるようになります。インライン化されたforループのキャプチャ値とイテレータ値は、コンパイル時既知です[https://ziglang.org/documentation/master/#inline-for inline for]。
inline for:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var x: usize = undefined;
var y: usize = undefined;
loop_top: inline for ("Hello", 0..) |co, i| {
inline for ("World", 0..) |ci, j| {
if (co == ci) {
try stdout.print("c = '{c}'({}, {})\n", .{ ci, i, j });
x = i;
y = j;
break :loop_top;
}
}
}
try stdout.print("x = {}, y = {}\n", .{ x, y });
}
実行結果:
c = 'l'(2, 3)
x = 2, y = 3
Zigの関数は、プログラム内で再利用可能なコードブロックを表します。
Zigの関数の引数は、const で宣言された変数と同じくイミュータブルです。
ミュータブルにする方法はありません。
構文(EBNF):
top-level-decl = [ "inline" | "noinline" ] FnProto ( ";" | block )
FnProto = "fn" [ IDENTIFIER ] "(" param-decl-list ")" [ byte-align ] [ link-section ] [ call-conv ] [ "!" ] type-expr
param-decl-list = ( param-decl "," )* [ param-decl ]
param-decl = [ doc_comment ] [ "noalias" | "comptime" ] [ IDENTIFIER ":" ] param-type | "..."
param-type = "anytype" | type-expr
type-expr = [ prefix-type-op ] ErrorUnionExpr
prefix-type-op = "?"
| "anyframe" "->"
| slice-type-start ( byte-align | "const" | "volatile" | "allowzero" )*
| ptr-type-start ( "align" "(" expr [ ":" INTEGER ":" INTEGER) ] ")" | "const" | "volatile" | "allowzero" )*
| array-type-start
slice-type-start = "[" [ ":" expr ] "]"
byte-align = "align" "(" expr ")"
link-section = "linksection" "(" expr ")"
call-conv = "callconv" "(" expr ")"
ptr-type-start = "*" | "**" | "[" "*" [ "c" | ":" expr ] "]"
array-type-start = "[" expr [ ":" expr ] "]"
top-level-declは関数宣言の他、変数宣言なども含みますが、関数宣言部分を抜粋しました。
[https://wandbox.org/permlink/S46Dr2HRn6xgzSSA 関数の例]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
try stdout.print("{}\n", .{div(1, 0)});
try stdout.print("{}\n", .{div(0, 0)});
}
fn div(f1: f64, f2: f64) f64 {
return f1 / f2;
}
実行結果:
inf
nan
他のプログラミング言語をご存じの方なら、関数 div() が前方参照になっているのは大丈夫なのか？と思われるかもしれません。
Zigではトップレベルの識別子は処理系が参照解決（とシグネチャーを含めた型の一致の確認）を引受けてくれます。
----
基本的な関数の定義: Zigでの関数の定義は、以下のように行います。
fn add(a: i8, b: i8) i8 {
return a + b;
}
この例では、addという関数が定義されており、2つのi8型の引数を受け取り、i8型の値を返します。
外部関数の定義: Zigでは、外部ライブラリやAPIから関数を利用するために、externキーワードを使用して外部関数を宣言します。
extern "kernel32" fn ExitProcess(exit_code: u32) callconv(WINAPI) noreturn;
この例では、Windowsのkernel32ライブラリからExitProcessという関数を使用しています。
パラメータの型推論: 関数のパラメータの型は、anytypeを使用して関数が呼び出されるときに推論されます。
fn addFortyTwo(x: anytype) @TypeOf(x) {
return x + 42;
}
この例では、addFortyTwo関数のパラメータxの型が呼び出し時に推論されます。
インライン関数: inlineキーワードを使用することで、関数をコールサイトにインライン展開することができます。
inline fn foo(a: i32, b: i32) i32 {
return a + b;
}
この例では、foo関数がインラインで展開され、コンパイル時に計算が行われます。
関数ポインタ: 関数を値として扱うために、関数ポインタを使用することができます。
const Call2Op = *const fn (a: i8, b: i8) i8;
fn doOp(fnCall: Call2Op, op1: i8, op2: i8) i8 {
return fnCall(op1, op2);
}
この例では、Call2Op型の関数ポインタを引数として受け取り、その関数を呼び出します。
Zigの関数は、柔軟性があり、さまざまな目的に使用できます。関数は、プログラムの構造化と再利用性を高めるために不可欠な要素です。
Zigでは、エラー( ''Errors'' )も１つの型です[https://ziglang.org/documentation/master/#Errors Errors]。
型( ''Error Set Type'' )は、enum のようなものです。同じエラー名を複数回宣言することは可能で、宣言した場合は同じ整数値が割り当てられます[https://ziglang.org/documentation/master/#Error-Set-Type Error Set Type]。
コンパイル全体のユニークなエラー値の数が、エラー集合型のサイズを決定するはずです。しかし、いま0.10.0は u16 になるようにハードコーディングされています。
サブセットからスーパーセットへエラーを強制することができます。
構文(EBNF):
error-set-decl = "error" "{" identifier-list "}"
エラー集合型の例:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const FileOpenError = error {
AccessDenied,
OutOfMemory,
FileNotFound,
};
const AllocationError = error {
OutOfMemory,
};
pub fn main() !void {
try stdout.print("AllocationError.OutOfMemory == FileOpenError.OutOfMemory ⇒ {}\n", .{AllocationError.OutOfMemory == FileOpenError.OutOfMemory});
}
実行結果:
AllocationError.OutOfMemory == FileOpenError.OutOfMemory ⇒ true
エラー集合型をマージするには、|| 演算子を使用します。
結果として得られるエラー集合型には、両方のエラー集合型のエラーが含まれます。
''' は、グローバルエラー集合を参照します。これは、コンパイルユニット全体のすべてのエラーを含むエラー集合です。これは他のすべてのエラー集合のスーパーセットで、どのエラー集合のサブセットでもありません。
任意のエラー集合をグローバルエラー集合に強制することができ、グローバルエラー集合のエラーを非グローバルエラー集合に明示的にキャストすることができます。この場合、言語レベルのアサートが挿入され、エラー値が宛先のエラー集合に実際に含まれていることが確認されます。
グローバルエラー集合は、コンパイラーがコンパイル時にどのようなエラーが起こりうるかを知ることができないため、一般に避けるべきです。コンパイル時にエラー集合を知っていた方が、生成されるドキュメントや有用なエラーメッセージ（例えば switch で起こりうるエラー値を忘れてしまうなど）に有利です。
エラー集合型と正常型を二項演算子 ! で結合して、エラーユニオン型( ''Error Union Type'' )にすることができます。
var error_or_value: AllocationError ! u16 = 10;
エラーユニオン型は、エラー集合型単体よりも頻繁に使用される可能性があります[https://ziglang.org/documentation/master/#Error-Union-Type Error Union Type]。
構文(EBNF):
error-union-expr = suffix-expr ( "!" TypeExpr )?
suffix-expr = "async" PrimaryTypeExpr SuffixOp* FnCallArguments
| PrimaryTypeExpr ( SuffixOp | FnCallArguments )*
Zigには、演算子のオーバーロードはありません。
Zigのプログラムに演算子を見たとき、それが次の一覧表に示すもので、それ以外のものでないことが保証されます[https://ziglang.org/documentation/master/#Operators Operators]。
Zigでは、四則演算などの演算子はディフォルトでオーバーフローを検出します。それとは別に、（C言語などのように）ラッピングを行う演算子が別に用意されています。
オーバーフローの例:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var r :i3 = 0;
while (r < 10) : (r += 1){
try stdout.print("{} ", .{r});
}
}
実行結果:
An error occurred:
0 1 2 3 thread 7015 panic: integer overflow
/tmp/playground2097195080/play.zig:6:25: 0x22cff6 in main (play)
while (r < 10) : (r += 1){
^
/usr/local/bin/lib/std/start.zig:561:37: 0x22657a in std.start.callMain (play)
const result = root.main() catch |err| {
^
/usr/local/bin/lib/std/start.zig:495:12: 0x20716e in std.start.callMainWithArgs (play)
return @call(.{ .modifier = .always_inline }, callMain, .{});
^
/usr/local/bin/lib/std/start.zig:409:17: 0x206206 in std.start.posixCallMainAndExit (play)
std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
^
/usr/local/bin/lib/std/start.zig:322:5: 0x206012 in std.start._start (play)
@call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
^
符号付き３ビット整数の r を r < 10 の間インクリメントしています。
符号付き３ビット整数は、 -4 ... 3 の値しか表せず 4 になるとオーバーフローします。
C言語などでは、無限ループになりますが Zig ではランタイムに検出されます。
Zigには、四則演算などの演算子に飽和演算( ''Saturation calculation'' )バージョンが用意されています。
飽和演算の例:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var i: i5 = 0;
var sum: i5 = 0;
while (i < 10) : (i += 1) {
sum +|= i;
try stdout.print("i = {}, sum = {}\n", .{ i, sum });
}
}
実行結果:
i = 0, sum = 0
i = 1, sum = 1
i = 2, sum = 3
i = 3, sum = 6
i = 4, sum = 10
i = 5, sum = 15
i = 6, sum = 15
i = 7, sum = 15
i = 8, sum = 15
i = 9, sum = 15
高
x() x[] x.y x.* x.?
a!b
x{}
!x -x -%x ~x &x ?x
* / % ** *% *| ||
+ - ++ +% -% +| -|
<< >> <<|
& ^ | orelse catch
and
or
低
Zigには「オプショナル型」( ''optional type'' )と「非オプショナル型」があります。
オプショナル型: 値としてnullを受け入れられる。
非オプショナル型: 値としてnullを受け入れられない。
ここまでに紹介した変数および定数の型は非オプショナル型です。
オプショナル型の変数および定数は宣言のときに ?型名 と書きます。
var a: i32 = null; // 非オプショナル型を null で初期化するとエラーになる！
var b: ?i32 = null; // オプショナル型は null で初期化してもエラーにならない
オプショナル型の式から基底型の値を参照することをアンラップを呼びます。
[https://wandbox.org/permlink/5JjpPVjhPwt8dqhb ifを使ったアンラップ]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var s: ?[]const u8 = null;
if (s) |ss| {
try stdout.print("{s}\n", .{ss});
} else {
try stdout.writeAll("it's null\n");
}
s = "abc";
if (s) |ss| {
try stdout.print("{s}\n", .{ss});
} else {
try stdout.writeAll("it's null\n");
}
}
実行結果:
it's null
abc
Zigの配列は、次のような特徴を持ちます：
配列の定義
配列の操作
コンパイル時初期化
多次元配列
センチネル終端配列
Zigの配列は柔軟で効率的なデータ構造であり、様々なアプリケーションで使用されます。
構文(EBNF):
array-type-start = "[" expr [ ":" expr ] "]"
配列には、特有な演算子が２つあります。
配列のコード例:
const stdout = @import("std").io.getStdOut().writer();
pub fn main() !void {
const ary = [_]i8{ 2, 3, 5, 7 };
try stdout.print("ary == {}{{ ", .{@TypeOf(ary)});
for (ary) |elm| {
try stdout.print("{}, ", .{elm});
}
try stdout.writeAll("}\n");
try stdout.print("ary ++ ary == {}{{ ", .{@TypeOf(ary ++ ary)});
for (ary ++ ary) |elm| {
try stdout.print("{}, ", .{elm});
}
try stdout.writeAll("}\n");
try stdout.print("ary ** 3 == {}{{ ", .{@TypeOf(ary ** 3)});
for (ary ** 3) |elm| {
try stdout.print("{}, ", .{elm});
}
try stdout.writeAll("}\n");
}
実行結果:
ary == [4]i8{ 2, 3, 5, 7, }
ary ++ ary == [8]i8{ 2, 3, 5, 7, 2, 3, 5, 7, }
ary ** 3 == [12]i8{ 2, 3, 5, 7, 2, 3, 5, 7, 2, 3, 5, 7, }
const ary = [_]i8{ 2, 3, 5, 7 };
const ary: [4]i8= [4]i8{ 2, 3, 5, 7 };
ですが、型は型推定で、要素数もリテラルなので _ と書けます。
ary ++ ary
++ は配列と配列を連結した新しい配列を返す演算子です。
ary ** 3
** は配列を回数だけ繰返した新しい配列を返す演算子です。
ary ** ary は ary ++ ary ++ ary と等価です。
多次元配列( ''Multidimensional Arrays'' )は、ネストした配列で生成します[https://ziglang.org/documentation/master/#Multidimensional-Arrays Multidimensional Arrays]。
多次元配列:
const stdout = @import("std").io.getStdOut().writer();
pub fn main() !void {
var matrix: [16][16]i32 = undefined;
// 全成分を 0 に
for (&matrix) |*col| {
for (&col.*) |*value| {
value.* = 0;
}
}
try stdout.print("martix == {}{{\n", .{@TypeOf(matrix)});
for (matrix) |col| {
try stdout.writeAll(" { ");
for (col) |value| {
try stdout.print("{}, ", .{value});
}
try stdout.writeAll("},\n");
}
try stdout.writeAll("}\n\n");
// 対角成分を 1 に
for (&matrix, 0..) |*col, ci| {
for (&col.*, 0..) |*value, ri| {
if (ci == ri) {
value.* = 1;
}
}
}
try stdout.print("martix == {}{{\n", .{@TypeOf(matrix)});
for (matrix) |col| {
try stdout.writeAll(" { ");
for (col) |value| {
try stdout.print("{}, ", .{value});
}
try stdout.writeAll("},\n");
}
try stdout.writeAll("}\n");
}
実行結果:
martix == [16][16]i32{
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
}
martix == [16][16]i32{
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, },
}
var matrix : [16][16]i32 = undefined;
undefined で初期化しています。というより初期化していません。
var matrix : [16][16]i32 = 0; // これはエラーになる
と書きたいところですができないので、二重のforループで初期化しています。
センチネル終端配列( ''Sentinel Terminated Arrays'' )は、文字列のように特殊な値（センチネル（ ''sentinel''；番兵 ））で終端した配列です。
文字列の場合のセンチネルは ’\0’ ですが、構文 [配列長:x]要素型 の x で任意の値をセンチネルにできます[https://ziglang.org/documentation/master/#Sentinel-Terminated-Arrays Sentinel Terminated Arrays]。
センチネル終端配列:
const stdout = @import("std").io.getStdOut().writer();
pub fn main() !void {
const ary = [_:-1]i32{ 1, 4, 9, 16, 25 };
try stdout.print("@TypeOf(ary) ⇒ {}\n", .{@TypeOf(ary)});
var i: u16 = 0;
while (i <= ary.len) : (i += 1) {
try stdout.print("{} ", .{ary[i]});
}
}
実行結果:
@TypeOf(ary) ⇒ [5:-1]i32
1 4 9 16 25 -1
ベクトルは、bool、整数、浮動小数点数、ポインターのグループで、可能であればSIMD命令を使って並列に操作されます。ベクトル型は、組込み関数 @Vector で作成します[https://ziglang.org/documentation/master/#Vectors Vectors]。
ベクトルは、基本型と同じ組み込み演算子をサポートしています。これらの演算は要素ごとに行われ、入力ベクトルと同じ長さのベクトルを返します。これには以下が含まれます。
算術演算:+, -, /, *, @divFloor, @sqrt, @ceil, @log, など
ビット演算子:>>, <<, &, |, ~, など
比較演算子:<, >, ==, など
スカラー（個々の数値）とベクトルが混在している場合に数学演算子を使用することは禁止されています。Zigでは、スカラーからベクトルへの変換を容易にするために組込み関数@splatが用意されており、ベクトルからスカラーへの変換には組込み関数@reduceと配列インデックスの構文がサポートされています。ベクトルは、長さが既知の固定長の配列との間の代入もサポートしています。
Zigは，組込み関数@shuffleと組込み関数@selectを提供し，ベクトル内やベクトル間の要素の並べ替えを行います．
ターゲットマシンのネイティブ SIMD サイズより短いベクトルに対する操作は、通常は単一の SIMD 命令にコンパイルされます。ある演算がターゲット・アーキテクチャで SIMD をサポートしていない場合、コンパイラーはデフォルトで各ベクトル要素に対して一度に 1 つずつ演算します。Zig は、232-1 までの既知のベクトル長をサポートしていますが、2 の累乗（2-64）が最も一般的です。ただし、現在の Zig では、長すぎるベクトル長 (例えば 220) はコンパイラーがクラッシュする可能性があります。
ベクトル演算:
const stdout = @import("std").io.getStdOut().writer();
pub fn main() !void {
const a = @Vector(4, i32){ 1, 2, 3, 4 };
const b = @Vector(4, i32){ 5, 6, 7, 8 };
try stdout.print(" {}\n+ {}\n= {}\n\n", .{ a, b, a + b });
try stdout.print(" {}\n- {}\n= {}\n\n", .{ a, b, a - b });
try stdout.print(" {}\n* {}\n= {}\n\n", .{ a, b, a * b });
try stdout.print(" {}\n/ {}\n= {}\n\n", .{ a, b, a / b });
try stdout.print(" {}\n% {}\n= {}\n\n", .{ a, b, a % b });
}
実行結果:
{ 1, 2, 3, 4 }
+ { 5, 6, 7, 8 }
= { 6, 8, 10, 12 }
{ 1, 2, 3, 4 }
- { 5, 6, 7, 8 }
= { -4, -4, -4, -4 }
{ 1, 2, 3, 4 }
= { 5, 12, 21, 32 }
{ 1, 2, 3, 4 }
/ { 5, 6, 7, 8 }
= { 0, 0, 0, 0 }
{ 1, 2, 3, 4 }
% { 5, 6, 7, 8 }
= { 1, 2, 3, 4 }
[TODO:配列との相互変換]
Zigには、単一項目と多項目の2種類のポインターがあります[https://ziglang.org/documentation/master/#Pointers Pointers]。
*T - 正確に1つの項目への単一項目ポインター。
[*]T - 未知数のアイテムへの多項目ポインター。
T は既知のサイズでなければならず、anyopaqueや他の opaque型 にはできません。
これらの型は、配列やスライスと密接に関係しています。
*[N]T - N 個のアイテムへのポインター、配列への単項目ポインターと同じです。
[]T - スライス (ファットポインター。[*]T型のポインターと長さを含みます）。
単項目ポインターを得るには、&xを使用します。
[TODO]
ロードとストアは、副作用がないことが前提です。MMIO (Memory Mapped Input/Output) のように、ロードやストアが副作用を持つべき場合は volatile を使用します[https://ziglang.org/documentation/master/#volatile volatile]。
それぞれの型にはアライメント( ''Alignment'' )があり、その型の値がメモリーからロードされたり、メモリーにストアされたりするとき、メモリーアドレスがこの数で均等に割り切れるようなバイト数になっています。この値は組込み関数 @alignOf を使って知ることができます[https://ziglang.org/documentation/master/#Alignment Alignment]。
アラインメントはCPUアーキテクチャに依存しますが、常に2のべき乗であり、1 << 29 より小さい値です。
Zigでは、ポインター型はアライメント値を持っています。この値が基礎となる型のアライメントと等しい場合、その型は省略することができます。
align は、ポインターのアライメントを指定するために使用します。また、変数や関数の宣言の後に使用して、その変数や関数へのポインターのアライメントを指定することができます。
allowzeroポインター属性は、ポインターのアドレスがゼロであることを許可します。これは、アドレスゼロがマッピング可能な独立型OSターゲットでのみ必要とされます。nullポインターを表現したい場合は、代わりにオプショナルポインターを使用します。allowzeroを持つオプショナルポインターは、ポインターと同じサイズではありません[https://ziglang.org/documentation/master/#allowzero allowzero]。
constポインター属性は、（ポインターではなく）ポインターが参照する値が変更できないことを示します。
センチネル終端ポインター( ''Sentinel Terminated Pointers'' )。
構文 [*:x]T は、センチネル値によって長さが決定されるポインターを記述します。これにより、バッファオーバーフローやオーバーリードから保護されます[https://ziglang.org/documentation/master/#Sentinel-Terminated-Pointers Sentinel Terminated Pointers]。
スライス( ''Slices'' )はポインターと長さです。配列とスライスの違いは、配列の長さが型の一部でコンパイル時にわかるのに対して、スライスの長さは実行時にわかることです。どちらも len プロパティでアクセスすることができます[https://ziglang.org/documentation/master/#Slices Slices]。
スライスを使ったコード例:
const stdout = @import("std").io.getStdOut().writer();
pub fn main() !void {
var array = [_]i32{ 2, 3, 5, 7, 11, 13, 17 };
var q: usize = 1;
const slice = array[q .. array.len -1];
try stdout.print("@TypeOf(slice) ⇒ {}\n", .{@TypeOf(slice)});
for (slice) |x| {
try stdout.print("{} ", .{x});
}
}
実行結果:
@TypeOf(slice) ⇒ []i32
3 5 7 11 13
センチネル終端スライス( ''Sentinel-Terminated Slices'' )。
構文[:x]Tは、実行時に既知の長さを持ち、また長さでインデックスされた要素で センチネル値を保証するスライスです。この型は、それ以前にセンチネル要素がないことを保証するものではありません。センチネル終端スライスはlenインデックスへのエレメントアクセスを可能にします[https://ziglang.org/documentation/master/#Sentinel-Terminated-Slices Sentine -Terminated Slices]。
スライスを使ったコード例:
const stdout = @import("std").io.getStdOut().writer();
pub fn main() !void {
const slice: [:0]const u8 = "hello";
try stdout.print("@TypeOf(slice) ⇒ {}\n", .{@TypeOf(slice)});
for (slice) |ch| {
try stdout.print("{c} ", .{ch});
}
}
実行結果:
@TypeOf(slice) ⇒ [:0]const u8
h e l l o
コンテナー（Containers）とは、変数や関数の宣言を保持する名前空間として機能する構文上の構造です。コンテナーは、インスタンス化可能な型定義でもあります。struct、enum、unionとopaque そしてZigのソースファイル自体も、コンテナーの例です。
コンテナーは、定義を囲むために波括弧を使用しますが、ブロックや関数とは異なります。コンテナーには文が含まれていません。
[TODO:std.containerについて]
構文(EBNF):
container-members = container-declarations ( container-field "," )* (container-field | container-declarations)
container-declarations = TestDecl container-declarations
| TopLevelComptime container-declarations
| [ doc_comment ] [ "pub" ] TopLevelDecl container-declarations
|
container-field = [ doc_comment ] [ "comptime" ] IDENTIFIER [ ":" ( "anytype" | TypeExpr) [ ByteAlign ] ] [ "=" expr ]
container-decl-auto = container-decl-type "{" [ container_doc_comment ] container-members "}"
container-decl-type = "struct"
| "opaque"
| "enum" [ "(" expr ")" ]
| "union" [ "(" ( "enum" [ "(" expr ")" ] ) | expr ")"
struct（構造あるいは構造型C言語の struct は、テンプレートの定義を行う構文で型にするためには、追加の typedef が必要で「構造体」がふさわしかったのですが、Zig では正確に型を定義するので「構造」あるいは「構造型」が妥当です。ここでは混乱を避けるためキーワードでもある struct としました。）はデータの集合を定義するための構文であり、フィールドにはデフォルト値やメソッドを持たせることができます。packed structやextern structといった特殊な形式も提供され、メモリレイアウトを制御します。関数内でのstructの生成やジェネリックな構造体の定義もサポートされています。さらに、関数からstructを返すことも可能です。
struct の定義:
const stdout = @import("std").io.getStdOut().writer();
const Complex = struct {
real: f64,
imag: f64,
};
pub fn main() !void {
try stdout.print("@TypeOf(Complex) ⇒ {}\n", .{@TypeOf(Complex)});
}
実行結果:
@TypeOf(Complex) ⇒ type
3-6 行目が struct の宣言で、変数に保存しています。
struct で宣言した値の型は type です。
ところで Zigはフィールドの順番とサイズを保証しません。しかし、フィールドはABIアラインされていることが保証されています[https://ziglang.org/documentation/master/#struct struct]。
もし、順番とサイズを保証したい場合キーワード packed を前置します。
順番とサイズを保証したい場合:
const Complex = packed struct {
real: f64,
imag: f64,
};
インスタンスの生成:
const stdout = @import("std").io.getStdOut().writer();
const Complex = struct {
real: f64,
imag: f64,
};
pub fn main() !void {
const cplx = Complex{
.real = 1.2,
.imag = 4.1,
};
try stdout.print("{}\n", .{ cplx });
}
実行結果:
Complex{ .real = 1.2e+00, .imag = 4.1e+00 }
メンバー名の前に . が付くのが独特です。
メンバーは常に pub です。
private や protected や friend はありません。
struct はメソッド( ''Methods'' )を持つことができます。
メソッドは特別なものではなく、名前空間を持つだけです。
ドットシンタックス（インスタンス名.メソッド名）で呼び出すことができる関数です。
メソッドの例:
const stdout = @import("std").io.getStdOut().writer();
const sqrt = @import("std").math.sqrt;
const Complex = struct {
real: f64,
imag: f64,
pub fn init(real: f64, imag: f64) Complex {
return Complex{
.real = real,
.imag = imag,
};
}
pub fn abs(self: Complex) f64 {
return sqrt(self.real * self.real + self.imag * self.imag);
}
};
pub fn main() !void {
const cplx = Complex.init(3.3, 4.4);
try stdout.print("cplx = {}\n", .{cplx});
try stdout.print("cplx.abs() = {}\n", .{cplx.abs()});
try stdout.print("Complex.abs(cplx) = {}\n", .{Complex.abs(cplx)});
}
実行結果:
cplx = Complex{ .real = 3.3e+00, .imag = 4.4e+00 }
cplx.abs() = 5.5e+00
Complex.abs(cplx) = 5.5e+00
インスタンスを生成するメソッド init() と絶対値を返すメソッド abs() を定義しました。
インスタンスを生成するメソッドに init と名付けるのも、フィールドにアクセスするメソッドの第一引数を self と名付けるのも言語仕様ではなく慣習ですが、逸脱する積極的な理由はありません。
[TODO:組込み関数＠This]
Zigでは、structリテラルの型は識別子と結びついている必要はありません。結果が強制される場合、structリテラルはコピーなしで結果の場所を直接インスタンス化します。
( ''Tuple'' )と呼びます[https://ziglang.org/documentation/master/#Anonymous-Struct-Literals Anonymous Struct Literals]。
Zigのenumは列挙型を定義するための構文であり、異なる値をグループ化します[https://ziglang.org/documentation/master/#enum enum]。
値の順序を指定せずに列挙型を宣言することができ、任意の整数型を指定してタグ型を制御できます。
タグ型を指定しない場合、自動的に整数型が割り当てられ、0から始まる連続した値が与えられます。
列挙型にはメソッドを追加することができ、switch文を使用して値を切り替えることができます。
また、列挙型リテラルを使用して、特定の列挙値を指定することも可能です。
Zigのenumは柔軟性が高く、CのABIとの互換性を保つための機能も提供されています。
enum の定義:
const stdout = @import("std").io.getStdOut().writer();
const Colour = enum {
red,
green,
blue,
};
const JISC5062 = enum(u4) {
black = 0,
brown,
red,
orange,
yellow,
green,
blue,
violet,
gray,
white,
const Self = @This();
const len = @typeInfo(Self).Enum.fields.len;
pub fn allCases() [Self.len]Self {
var result: [Self.len]Self = undefined;
var i: u4 = 0;
while (i < Self.len) : (i += 1) {
result[i] = @as(Self, @enumFromInt(i));
}
return result;
}
};
pub fn main() !void {
try stdout.print("@TypeOf(Colour) ⇒ {}\n", .{@TypeOf(Colour)});
const c: Colour = .green;
try stdout.print("c ⇒ {}\n", .{c});
try stdout.print("JISC5062.allCases() ⇒ {any}\n", .{JISC5062.allCases()});
for (JISC5062.allCases()) |e| {
try stdout.print("{s} ⇒ {}\n", .{ @tagName(e), @intFromEnum(e) });
}
}
実行結果:
@TypeOf(Colour) ⇒ type
c ⇒ main.Colour.green
JISC5062.allCases() ⇒ { main.JISC5062.black, main.JISC5062.brown, main.JISC5062.red, main.JISC5062.orange, main.JISC5062.yellow, main.JISC5062.green, main.JISC5062.blue, main.JISC5062.violet, main.JISC5062.gray, main.JISC5062.white }
black ⇒ 0
brown ⇒ 1
red ⇒ 2
orange ⇒ 3
yellow ⇒ 4
green ⇒ 5
blue ⇒ 6
violet ⇒ 7
gray ⇒ 8
white ⇒ 9
3-7,9-31行目が enum の宣言で、それぞれ変数に保存しています。
enum で宣言した値の型は type です。
enum は、struct と同じくメンバーとは別に、型に属する変数やメソッドを持つことが出来ます。
JISC5062.allCases() は、JISC5062のメンバー全てを含む配列を返しています。
const Self = @This();は、コンテナー定義でコンテナーの識別子を書く手間をなくし、コピーアンドペーストを容易にします。
red, green と blue が Colour と JISC5062 で重複していますが、コンテナーは名前空間として機能するので問題になりません。
const std = @import("std");
const mem = std.mem;
const testing = std.testing;
const expect = testing.expect;
test "Enum w/ method" {
// Enumを定義します。
const Color = enum {
red,
green,
blue,
};
// Enumフィールドを宣言します。
const primaryColor: Color = .red;
_ = primaryColor;
// Enumメソッドを持たせます。
const Suit = enum {
clubs,
spades,
diamonds,
hearts,
const Self = @This();
pub fn isClubs(self: Self) bool {
return self == Self.clubs;
}
};
// Enumメソッドをテストします。
const p = Suit.spades;
try expect(!p.isClubs());
}
test "Enum w/ switch" {
// Enumをスイッチで使用します。
const Foo = enum {
string,
number,
none,
};
const p2 = Foo.number;
const what_is_it = switch (p2) {
Foo.string => "This is a string",
Foo.number => "This is a number",
Foo.none => "This is none",
};
try expect(mem.orderZ(u8, what_is_it, "This is a number") == .eq);
}
test "Enum Literal " {
// Enumリテラルを使用します。
const Status = enum {
ok,
err,
};
const status1: Status = .ok;
const status2 = Status.err;
try expect(status1 != status2);
}
test "Non-exhaustive enum" {
// 非全網羅Enumを作成します。
const Shape = enum(u8) {
circle,
square,
rectangle,
_,
};
const shape = Shape.circle;
const shapeMessage = switch (shape) {
Shape.circle => "This is a circle",
Shape.square => "This is a square",
Shape.rectangle => "This is a rectangle",
_ => "Unknown shape", // 非全網羅のため、_ で処理
};
try expect(mem.orderZ(u8, shapeMessage, "This is a circle") == .eq);
}
Zigのunionは、値が取りうる可能な型のセットをフィールドのリストとして定義しますす[https://ziglang.org/documentation/master/#union union]。
一度に1つのフィールドしかアクティブにできません。
裸のUnionのメモリ表現は保証されておらず、メモリを再解釈するためには@ptrCastを使用するか、保証されたメモリレイアウトを持つextern unionまたはpacked unionを使用する必要があります。
非アクティブなフィールドへのアクセスは安全性が確認されておらず、未定義の動作になります。
Union全体を割り当てることで他のフィールドをアクティブにできます。
また、Switch文を使用するためには、Unionにenumタグ型を付ける必要があります。
これにより、Switch式でUnionのペイロードを変更することが可能になります。
Unionにはenumタグ型を推論させることもでき、またstructやenumと同様にメソッドを持つことができます。
[https://wandbox.org/permlink/ySVa32mXWe7uzLPF 非アクティブフィールドを参照するとコンパイルエラーになります]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const SimpleUnion = union {
char: u8,
int: i64,
float: f64,
};
pub fn main() !void {
var su = SimpleUnion{ .char = 'C' };
try stdout.print("su.int = {}\n", .{su.int});
}
コンパイル結果:
panic: access of inactive union field
[https://wandbox.org/permlink/5Z9kPxAAFDKJsGFG アクティブフィールドであれば参照できます]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const SimpleUnion = union {
char: u8,
int: i64,
float: f64,
};
pub fn main() !void {
var su = SimpleUnion{ .char = 'C' };
try stdout.print("su.char = {c}\n", .{su.char});
su = SimpleUnion{ .int = 42 };
try stdout.print("su.int = {}\n", .{su.int});
su = SimpleUnion{ .float = 2.71828_18284_59045_23536_02874_71352 };
try stdout.print("su.float = {}\n", .{su.float});
}
実行結果:
su.char = C
su.int = 42
su.float = 2.718281828459045e+00
'' )になり、switch式で使用することができるようになります。タグ付きunionは、そのタグ型に強制されます[https://ziglang.org/documentation/master/#Tagged-union Tagged union]。
[https://wandbox.org/permlink/WnsPOu50oZMhJNxh タグ付きunion]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const Tag = enum {
char,
int,
float,
};
const TaggedUnion = union(Tag) {
char: u8,
int: i64,
float: f64,
};
pub fn main() !void {
var tu = TaggedUnion{ .char = 'C' };
try stdout.print("@as(Tag, tu) ⇒ {}\n", .{@as(Tag, tu)});
switch (tu) {
Tag.char => |ch| try stdout.print("ch = {c}\n", .{ch}),
Tag.int => |i| try stdout.print("i = {}\n", .{i}),
Tag.float => |f| try stdout.print("f = {}\n", .{f}),
}
}
実行結果:
@as(Tag, tu) ⇒ Tag.char
ch = C
タグの enum と、それを使うタグ付きunionのメンバー集合は一致していないとエラーになります。
タグ付きunionを式とするswitch式では、バターンでタグのメンバーを網羅している必要があります（網羅性の検証が行えます。ただし _ や else をパターン使うと台無し）。
[https://wandbox.org/permlink/dvve8enu4S5GZQH3 匿名enum版タグ付きunion]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const TaggedUnion = union(enum) {
char: u8,
int: i64,
float: f64,
};
pub fn main() !void {
var tu = TaggedUnion{ .char = 'C' };
try stdout.print("@tagName(tu) ⇒ {s}\n", .{@tagName(tu)});
switch (tu) {
.char => |ch| try stdout.print("ch = {c}\n", .{ch}),
.int => |i| try stdout.print("i = {}\n", .{i}),
.float => |f| try stdout.print("f = {}\n", .{f}),
}
}
匿名enum版タグ付きunionは、enum のメンバーと union のメンバーの名前を一致させる手間が不要です。
他方、（unionのメンバーでなく）enum のメンバーに値を与えたいときは、実体化したタグをつか合う必要があります。
構文木を考えてみましょう。Cで実装するとノードの種別と種別ごとのペイロードの共用体になります。Zigではこれを一般化してタグ付きunion１つで実装することが出来ます。
タグ付きunionを使うと網羅性の保証もでき、多くの特性をメソッドとして記述できます。たとえばキーワードや演算子を追加した場合、対応するswitchのパターンがないとエラーになりコンパイル時に事前に変更必要箇所を確認できます。
switch式でタグ付きunionのペイロードを変更するには、変数名の前に*を置き、ポインターにします
[https://wandbox.org/permlink/5MMXzHDF0O9FkHro switch式でタグ付きunionの値の変更]:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const Tag = enum {
char,
int,
float,
};
const TaggedUnion = union(Tag) {
char: u8,
int: i64,
float: f64,
};
pub fn main() !void {
var tu = TaggedUnion{ .int = 42 };
try stdout.print("@as(Tag, tu) ⇒ {}\n", .{@as(Tag, tu)});
switch (tu) {
Tag.char => |*ch| ch.* -= 1,
Tag.int => |*i| i.* += 10,
Tag.float => |*f| f.* /= 1.2,
}
try stdout.print("tu.int ⇒ {}\n", .{tu.int});
}
実行結果:
@as(Tag, tu) ⇒ Tag.int
tu.int ⇒ 52
union も他のコンテナーと同様にメソッドを持つことが出来ます。
unionのメソッド:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const signbit = std.math.signbit;
const Number = union(enum) {
Int: i32,
Float: f32,
const Self = @This();
// 共用体にメソッドを追加
pub fn isPositive(self: Self) bool {
return switch (self) {
.Int => |value| value > 0,
.Float => |value| !signbit(value),
};
}
};
pub fn main() !void {
const i = Number{ .Int = 42 };
const f = Number{ .Float = -4.82 };
try stdout.print("i.isPositive() = {}\n", .{i.isPositive()});
try stdout.print("f.isPositive() = {}\n", .{f.isPositive()});
}
実行結果:
i.isPositive() = true
f.isPositive() = false
このコードは、ZigのUnionにメソッドを追加し、そのメソッドを使用して共用体の値を操作する方法を示しています。また、浮動小数点数の場合には、std.math.signbit を使用して符号を判定しています。
まず、Number というUnionが定義されています。このUnionは、Int フィールドと Float フィールドを持ち、それぞれ整数型と浮動小数点数型の値を保持します。また、const Self = @This() を使用して、メソッド内で共用体の型を参照できるようにしています。
次に、共用体に isPositive メソッドが追加されています。このメソッドは、共用体が保持する値が正の値かどうかを判定します。整数型の場合は、単純に値が0より大きいかどうかを確認しています。浮動小数点数型の場合は、std.math.signbit を使用して、値の符号を判定しています。符号が正の場合は、値が正の数であると判断します。
最後に、main 関数では、整数と浮動小数点数の共用体を作成し、それぞれの isPositive メソッドを呼び出して、共用体が保持する値が正の値かどうかを確認しています。結果は標準出力に出力されます。
実行結果では、整数が正の値であり、浮動小数点数が負の値であるため、"i.isPositive() = true" と "f.isPositive() = false" というメッセージが表示されます。
const std = @import("std");
const testing = std.testing;
const expect = testing.expect;
// Bare Unionの定義
const Payload = union {
int: i64,
float: f64,
boolean: bool,
};
// Bare Unionの使用例
test "Bare Union" {
var payload = Payload{ .int = 1234 };
try expect(payload.int == 1234);
}
// Tagged Unionの定義
const ComplexTypeTag = enum {
ok,
not_ok,
};
const ComplexType = union(ComplexTypeTag) {
ok: u8,
not_ok: void,
};
// Tagged Unionの使用例
test "Tagged Union" {
const c = ComplexType{ .ok = 42 };
try expect(@as(ComplexTypeTag, c) == ComplexTypeTag.ok);
try switch (c) {
ComplexTypeTag.ok => |value| expect(value == 42),
ComplexTypeTag.not_ok => unreachable,
};
}
// Unionにメソッドを追加する
const Variant = union(enum) {
int: i32,
boolean: bool,
none,
fn truthy(self: Variant) bool {
return switch (self) {
Variant.int => |x_int| x_int != 0,
Variant.boolean => |x_bool| x_bool,
Variant.none => false,
};
}
};
// Unionのメソッドの使用例
test "Union Method" {
var v1 = Variant{ .int = 1 };
var v2 = Variant{ .boolean = false };
try expect(v1.truthy());
try expect(!v2.truthy());
}
// @tagNameを使用したEnumの値の表示
const Small2 = union(enum) {
a: i32,
b: bool,
c: u8,
};
// @tagNameの使用例
test "@tagName" {
try expect(std.mem.eql(u8, @tagName(Small2.a), "a"));
}
// 匿名Unionリテラルの初期化
const Number = union {
int: i32,
float: f64,
};
// 匿名Unionリテラルの使用例
test "Anonymous Union Literal Syntax" {
const i: Number = .{ .int = 42 };
const f = makeNumber();
try expect(i.int == 42);
try expect(f.float == 12.34);
}
fn makeNumber() Number {
return .{ .float = 12.34 };
}
実行結果:
1/5 test.Bare Union... OK
2/5 test.Tagged Union... OK
3/5 test.Union Method... OK
4/5 test.@tagName... OK
5/5 test.Anonymous Union Literal Syntax... OK
All 5 tests passed.
Zigのopaqueは、サイズとアライメントが不明（ただしゼロではない）な新しい型を宣言します。struct、union、enumと同様に、宣言を含めることができます。
これは、構造の詳細を公開しないCコードとやり取りする際の型安全性のために一般的に使用されます。例えば：
const Derp = opaque {};
const Wat = opaque {};
extern fn bar(d: *Derp) void;
fn foo(w: *Wat) callconv(.C) void {
bar(w);
}
test "call foo" {
foo(undefined);
}
opaqueを使うと、foo関数内でbar関数を呼び出す際に型の安全性が保証されます。
ブロック（Blocks）は、プログラム内で複数の文をグループ化する構造で、主に変数のスコープを制限し、可読性を向上させます。ブロック内で宣言された変数は、そのブロックの外部からはアクセスできず、名前の衝突を防ぎます。また、条件分岐やループの本体として使用され、制御フローを明確にします。さらに、ラベル付きブロックではbreak文を使って値を返したり、ブロックから脱出したりすることができます。空のブロックはプログラムの構造を整理するために使用され、有効な構造化要素として機能します。ブロックはコードの構造化に不可欠であり、プログラムの理解と保守性を向上させます。
構文(EBNF):
block = "{" statement* "}"
statement = "comptime"? var-decl
| "comptime" block-expr-statement
| "nosuspend" block-expr-statement
| "suspend" block-expr-statement
| "defer" block-expr-statement
| "errdefer" pay-load? block-expr-statement
| if-statement
| labeled-statement
| switch-expr
| AssignExpr ";"
ブロックは式です。ラベルを付けると、break はブロックから値を返すために使うことができます。
const stdout = @import("std").io.getStdOut().writer();
pub fn main() !void {
var y: i32 = 123;
const x = blk: {
y += 1;
break :blk y + 2;
};
try stdout.print("x = {}, y = {}\n", .{x, y});
}
実行結果:
x = 126, y = 124
ラベル blk は、任意の識別子に置換えられますが、慣習として blk がよく用いられます。
識別子は、同じ名前を使用して他の識別子を "隠す"ことは決して許されません。
コンパイラーは、外部スコープで既に使われている識別子を、ブロック内で使うとエラーにします。
このため、Zigのコードを読むときには、その識別子が定義されたスコープ内では常に同じ意味であることを確認することができます。ただし、スコープが分かれている場合（入れ子関係にない場合）には同じ名前を使用することができます。
defer は、スコープを抜けるときに実行される式またはブロックを登録します[https://ziglang.org/documentation/master/#defer defer]。
複数の defer 文で登録された場合、登録された逆の順序に実行されます。
const std = @import("std");
const stdout = std.io.getStdOut().writer();
fn basic_example() !usize {
var x: usize = 0;
{
defer x = 123;
x = 0;
try stdout.print("@small block: x = {}\n", .{x});
}
try stdout.print("@function block: x = {}\n", .{x});
x = 5;
return x;
}
fn multiple_example() !void {
try stdout.writeAll("multiple_example(): ");
defer {
try stdout.writeAll("1 ");
}
defer {
try stdout.writeAll("2 ");
}
if (false) {
// defer 自身が一度も実行されない場合は、実行されません。
defer {
try stdout.writeAll("3 ");
}
}
}
pub fn main() !void {
try stdout.print("basic_example() = {}\n", .{basic_example()});
multiple_example();
}
実行結果:
@small block: x = 0
@function block: x = 123
basic_example() = 5
multiple_example(): 2 1
errdefer は、エラーが原因でスコープを抜けるときに実行される式またはブロックを登録します[https://ziglang.org/documentation/master/#errdefer errdefer]。
複数の errdefer 文で登録された場合、登録された逆の順序に実行されます。
errdefer は、スコープを抜ける原因となったエラーコードをキャプチャーできます。
errdefer |err| {
std.debug.print("the error is {s}\n", .{@errorName(err)});
}
Zigでは、キャスティングは一つの型から別の型への明示的な変換を指します。この機能は、異なる型間でのデータの変換や操作を可能にし、プログラムの柔軟性を高めます。Zigにはさまざまな種類のキャストがあり、それぞれが特定の目的に使用されます[https://ziglang.org/documentation/master/#Casting Casting]。
以下では、Zigのキャスティングについて詳細に説明します。
Zigでは、@bitCast、@alignCast、@enumFromIntなどのビルトイン関数を使用して、明示的なキャストを実行します。
これらのキャストは、安全なものとそうでないものがあります。一部のキャストはランタイムでの動作を変更せず、他のキャストは言語レベルのアサーションを実行します。
たとえば、@intCastは整数型間での変換を行いますが、ビットの丸めは行いません。これに対して、@floatCastは浮動小数点数をより小さいサイズの浮動小数点数に変換しますが、精度が失われる可能性があります。
switch、if、while、forなどの文脈で複数の型が存在する場合、Zigはそれらの型を解決します。これにより、すべての型が変換可能な型が選択されます。
たとえば、switch文内でi8とi16の変数を追加すると、その結果の型はi16になります。これにより、型が一貫性を持ち、予測可能な動作が実現されます。
これらのキャスト機能は、Zigの柔軟性と安全性を向上させ、異なる型間でのデータの変換や操作を容易にします。
Type Coercionは、一つの型が期待される場面で、異なる型が提供された場合に発生します。
test_type_coercion.zigでは、変数宣言や関数呼び出し時に型変換が示されています。
同じランタイム表現を持つ値を、修飾子の厳密さを増やすためにキャストすることができます。
整数および浮動小数点の型が、それを表現できるより大きな型に自動的に変換されます。
浮動小数点数を整数にキャストすることは曖昧であり、コンパイラエラーが発生します。
スライス、配列、ポインタの間での相互変換が示されています。
オプショナル型のペイロードやnull値が、オプショナル型自体にキャストされることが示されています。
エラーコードやエラーセットがエラーユニオン型にキャストされることが示されています。
数値が宛先型で表現可能である場合にのみ、キャストが行われることが示されています。
タグ付きユニオンが列挙型に、そして列挙型がタグ付きユニオンにキャストされることが示されています。
同じ型のフィールドを持つタプルは、配列にキャストすることができます。
@bitCast、@alignCast、@enumFromIntなどのビルトイン関数を使用して明示的なキャストが行われます。
Peer Type Resolutionは、スイッチ式やif式などの複数のオペランド型が与えられた場合に使用されます。
これらの機能は、Zig言語において型の柔軟な操作と安全な変換を可能にし、コードの表現力を高めます。
Zigにおける型強制（Type Coercion）は、コンパイラが型の不一致を解消するために行う自動的な型変換のプロセスを指します。Zigでは、いくつかの場面で型強制が行われます。
変数の代入: 変数がある型で宣言されている場合、その変数に代入される値が宣言された型と異なる場合、Zigは型強制を行います。ただし、この変換は安全な場合に限ります。たとえば、整数型から浮動小数点数型への変換は安全ですが、逆の変換は損失が発生する可能性があるため、コンパイラは警告やエラーを生成することがあります。
関数呼び出し時の引数の型の一致: 関数が特定の型の引数を受け取る場合、関数呼び出し時に与えられた引数の型が完全に一致しない場合、Zigは適切な型に変換します。これにより、型の不一致によるエラーが回避されます。
演算子の使用: 演算子を使用する際に、オペランドの型が一致しない場合、Zigは適切な型に変換して演算を行います。たとえば、整数型と浮動小数点数型の演算を行う場合、整数型は浮動小数点数型に変換されます。
明示的な型変換: プログラマが明示的に型を変換したい場合、@asや@intCastなどの組み込み関数を使用して、型変換を行うことができます。これにより、プログラマが意図的に型変換を行うことができます。
Zigの型強制は、安全な変換のみを行うことを目指しており、潜在的なデータの損失や不正確な結果を防ぐために注意深く設計されています。
明示的キャスト（Explicit Casts）は、コンパイラに対して特定の型への明示的な変換を指示する手段です。これは、コンパイラによって自動的に処理される型強制とは異なり、プログラマが意図的に型の変換を指定する場合に使用されます。Zigでは、さまざまな種類の明示的キャストが提供されています。
以下は、Zigで使用できる主な明示的キャストの例です：
@bitCast: ビットレベルでの変換を行い、型のビット表現を維持します。このキャストは非常に低レベルであり、注意が必要です。
@alignCast: ポインタのアライメントを増やします。より厳格なアライメントが必要な場合に使用されます。
@enumFromInt: 整数値から列挙型の値を取得します。列挙型の値を整数値に変換する逆の操作は、自動的な型強制で行われます。
@errorFromInt: 整数値からエラーコードを取得します。
@errorCast: より小さなエラーセットに変換します。
@floatCast: より大きな浮動小数点数型から小さな浮動小数点数型に変換します。
@floatFromInt: 整数値から浮動小数点数値に変換します。
@intCast: 整数型間での変換を行います。
@intFromBool: 真偽値を整数値に変換します。
@intFromEnum: 列挙型のタグ値を整数値として取得します。
@intFromError: エラーコードを整数値として取得します。
@intFromFloat: 浮動小数点数値の整数部分を取得します。
@intFromPtr: ポインタのアドレスを整数値として取得します。
@ptrFromInt: 整数値をポインタのアドレスに変換します。
@ptrCast: ポインタ型間の変換を行います。
@truncate: 整数型間での変換を行い、ビットを切り捨てます。
これらの明示的なキャストは、プログラマがコンパイラに対して特定の型変換を指定する必要がある場合に使用されます。ただし、使用する際には注意が必要であり、不適切なキャストがプログラムの安全性や正確性に影響を与える可能性があるため、慎重に検討する必要があります。
Zigのピア型解決（Peer Type Resolution）は、複数のオペランドの型から、それらが共通して受け入れ可能な型を決定するプロセスです。このプロセスは、通常、switchやifなどの条件式、またはforやwhileなどのループの条件式で使用されます。ピア型解決は、これらの式で使用される型を決定するために、与えられた複数の型の間で最も適切な共通型を見つけることを目的としています[https://ziglang.org/documentation/master/#Peer-Type-Resolution Peer Type Resolution]。
具体的には、ピア型解決は以下の場面で発生します：
ピア型解決では、複数の型の間で共通の型を見つけるために、次のようなルールが適用されます：
整数の場合、最大のビット幅を持つ整数型が選択されます。
浮動小数点数の場合、最も精度の高い浮動小数点数型が選択されます。
スライスや配列などのコンテナ型の場合、要素の型が共通の場合に選択されます。
オプショナル型の場合、共通の基底型が選択されます。
ポインタ型の場合、共通のポインタ型が選択されます。
これにより、Zigのコンパイラは、異なる型を持つ複数のオペランドに対して最も適切な共通の型を決定し、型の整合性を確保します。
ゼロビット型( ''Zero Bit Types'' )、実際にはデータを保持しない型のことを指します。これらの型は、メモリ内の領域を占有しないため、サイズがゼロビットです[https://ziglang.org/documentation/master/#Zero-Bit-Types Zero Bit Types]。
整数のu0とi0。
len == 0 または 0 ビット型の要素型を持つ配列とベクトル。
タグが1つしかないenum。
すべてのフィールドがゼロビット型であるstruct。
ゼロビット型のフィールドを1つだけ持つunion。
Zigでは、ゼロビット型は主に型システムの柔軟性と型安全性を高めるために使用されます。これらの型は、実行時のメモリ使用量やパフォーマンスには影響しませんが、コードの明確さと保守性を向上させるのに役立ちます。
[TODO:所謂インラインアセンラ]
Zigでは、キーワード async を伴って関数またはメソッドを呼び出すと、その関数またはメソッドの処理を休止し再開することができます。
[https://wandbox.org/permlink/NqJoL0PdY3mm3EAh async.zig]:
const std = @import("std");
var frame: anyframe = undefined;
pub fn main() !void {
try println("begin main");
_ = async func();
try println("resume func");
resume frame;
try println("end main");
}
fn func() !void {
try println("begin func");
frame = @frame();
suspend {}
try println("end func");
}
fn println(s: []const u8) !void {
try std.io.getStdOut().writer().print("{s}\n",.{s});
}
実行結果:
begin main
begin func
resume func
end func
end main
Zigのunreachableは、制御フローが特定の位置に到達しないことを明示するために使用されます。具体的には、その部分に到達することがプログラムの不正な動作であることを表明します。
if (false) {
unreachable;
}
Debug と ReleaseSafe モード、および zig test を使用する場合、unreachable は到達不能なコードに到達したメッセージとともに panic への呼び出しを出します[https://ziglang.org/documentation/master/#unreachable unreachable]。
ReleaseFast モードでは、オプティマイザーは到達不能なコードは決してヒットしないという仮定を使用して最適化を実行します。しかし、ReleaseFastモードでもzigテストはunreachableをpanicへの呼出しとして出力します。
unreachableの型はnoreturnです[https://ziglang.org/documentation/master/#At-Compile-Time At Compile Time]。
＠TypeOf(unreachable)はコンパイルに失敗します。
unreachable式はコンパイルエラーになるからです。
noreturnは、つぎ文の型です[https://ziglang.org/documentation/master/#noreturn noreturn]。
if節やswitchの分岐先( ''prongs'' )など、型を一緒に解決する場合、noreturn型は他のすべての型と互換性があります。
Zigのビルドモードは、プログラムをビルドする際の特定の設定とオプションの組み合わせを指定するものです。Zigには次の4つのビルドモードがあります。
それぞれのビルドモードは、異なる目的に対応しています。例えば、デバッグ中には実行時のパフォーマンスよりもデバッグしやすさや安全性が重要ですが、リリース時には実行時のパフォーマンスやバイナリサイズの最適化が優先されることがあります。
ビルドモードを指定するには、zig build-exeコマンドを使用します。例えば、ReleaseFastモードでプログラムをビルドするには、次のようにします。
$ zig build-exe example.zig -O ReleaseFast
各ビルドモードの特性は以下の通りです。
これらのビルドモードは、プロジェクトのニーズや要件に応じて適切なものを選択することが重要です。
Zigのメモリー管理の基礎について、重要なポイントを要約します。
メモリー管理の責任: Zig言語では、プログラマーがメモリー管理を行います。つまり、Zigにはランタイムがないため、リアルタイムソフトウェア、オペレーティングシステムカーネル、組み込みデバイス、低遅延サーバーなど、さまざまな環境でZigコードがシームレスに動作します。
アロケーターの使用: Zigでは、C言語とは異なり、デフォルトのアロケーターは提供されません。代わりに、アロケートが必要な関数は Allocator パラメーターを受け入れます。データ構造も同様に、初期化関数で Allocator パラメーターを受け入れます。
アロケーターの選択: どのアロケーターを使用するかは、さまざまな要因に依存します。ライブラリを作成する場合やlibcをリンクする場合、またはメモリー要件が既知の場合など、適切なアロケーターを選択するためのフローチャートが提供されています。
メモリーの場所: Zigでは、異なる種類のデータが異なる場所に配置されます。例えば、関数内のvar宣言はその関数のスタックフレームに配置されます。一方、グローバルレベルや構造体内のvar宣言はグローバルデータセクションに配置されます。
アロケーターの実装: Zigプログラマーは、Allocator インターフェースを満たすことで独自のアロケーターを実装できます。これには、allocFnとresizeFnを提供する必要があります。
再帰: 再帰は、Zigでモデリングソフトウェアにおいて基本的なツールですが、無制限のメモリー割り当て問題があります。現在、再帰は通常どおり動作しますが、将来のZigバージョンではスタックオーバーフローからの保護が提供される予定です。
ライフタイムと所有権: ポインターが指すメモリが使用できなくなった場合に、そのポインターにアクセスしないようにすることが、Zigプログラマーの責任です。所有権とライフタイムのセマンティクスは、ポインターの所有者とメモリーの使用可能な期間を明確にするために、関数やデータ構造のAPIドキュメントで説明されるべきです。
Zigは、メモリー管理に関する柔軟性と制御を提供し、プログラマーがそのアプリケーションのニーズに合わせて最適なアロケーターを選択できるようにしています。
Zig言語はプログラマーに代わってメモリー管理を行うことはありません。このため、Zigにはランタイムがなく、Zigのコードはリアルタイム・ソフトウェア、OSカーネル、組込み機器、低遅延サーバーなど、多くの環境でシームレスに動作します。その結果、Zigのプログラマーは常に次のような問いに答えられなければなりません[https://ziglang.org/documentation/master/#Memory Memory]。
Zigと同様、C言語もメモリー管理を手動で行っています。しかし、Zigとは異なり、C言語にはmalloc、realloc、freeというデフォルトのアロケーターがあります。libc とリンクするとき、Zig はこのアロケーターを std.heap.c_allocator で公開します。しかし、慣習として、Zig にはデフォルトのアロケーターはありません。代わりに、割当てが必要な関数は Allocator パラメーターを受け取ります。同様に、std.ArrayList のようなデータ構造もその初期化関数で Allocator パラメーターを受け付けます。
allocator.zig:
const std = @import("std");
const Allocator = std.mem.Allocator;
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
var buffer: [100]u8 = undefined;
var fba = std.heap.FixedBufferAllocator.init(&buffer);
const allocator = fba.allocator();
const result = try concat(allocator, "foo", "bar");
try stdout.print("concat(allocator, \"foo\", \"bar\") ⇒ \"{s}\"\n", .{result});
}
fn concat(allocator: Allocator, a: []const u8, b: []const u8) ![]u8 {
const result = try allocator.alloc(u8, a.len + b.len);
std.mem.copy(u8, result, a);
std.mem.copy(u8, result[a.len..], b);
return result;
}
実行結果:
concat(allocator, "foo", "bar") ⇒ "foobar"
上記の例では、スタック上の 100 バイトのメモリーが FixedBufferAllocator の初期化に使われ、それが関数に渡されます。
利便性のために std.testing.allocator でグローバルな FixedBufferAllocator が用意されており、基本的なリーク検出も行うことができます。
Zig には std.heap.GeneralPurposeAllocator でインポート可能な汎用アロケーターがあります。しかし、やはり、アロケーターの選び方の指針に従うことが推奨されます。
どのアロケーターを使うかは、様々な要因によって決まります。以下は、判断のためのフローチャートです[https://ziglang.org/documentation/master/#Choosing-an-Allocator Choosing an Allocator]。
ライブラリーを作っているのですか？この場合、パラメーターとしてアロケーターを受け取り、ライブラリーのユーザーにどのアロケーターを使うかを委ねるのがベストです。
libc をリンクしていますか? この場合、少なくともメインのアロケーターは std.heap.c_allocator が正しい選択だと思われます。
必要なバイト数の最大値は、コンパイル時に分かっている数で制限されていますか? この場合、スレッドセーフが必要かどうかによって std.heap.FixedBufferAllocator か std.heap.ThreadSafeFixedBufferAllocator を使ってください。
あなたのプログラムはコマンドラインアプリケーションで、基本的な循環パターンを持たずに最初から最後まで実行され（ビデオゲームのメインループやウェブサーバーのリクエストハンドラーなど）、最後にすべてを一度に解放することに意味があるようなものでしょうか？このような場合、このパターンに従うことをお勧めします。
const std = @import("std");
pub fn main() !void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
const ptr = try allocator.create(i32);
std.debug.print("ptr={*}\n", .{ptr});
}
ptr=i32@7fcdf92dd018
この種のアロケーターを使用する場合、手動で何かを解放する必要はありません。arena.deinit()を呼び出すと、すべてが一度に解放されます。
ビデオゲームのメインループやウェブサーバのリクエストハンドラのような周期的なパターンの一部でしょうか？例えば、ビデオゲームのフレームが完全にレンダリングされた後や、ウェブサーバーのリクエストが処理された後など、サイクルの終わりにすべてのアロケーションを一度に解放できる場合、std.heap.ArenaAllocator は素晴らしい候補となります。前の箇条書きで示したように、これによってアリーナ全体を一度に解放することができます。また、メモリの上限を設定できる場合は、std.heap.FixedBufferAllocator を使用すると、さらに最適化できることに注意しましょう。
テストを書いていて、error.OutOfMemoryが正しく処理されることを確認したいですか？この場合は std.testing.FailingAllocator を使ってください。
テストを書いていますか？この場合は std.testing.allocator を使ってください。
最後に、上記のどれにも当てはまらない場合は、汎用のアロケーターが必要です。Zigの汎用アロケーターは、設定オプションのcomptime構造体を受け取り、型を返す関数として提供されている。一般的には、メイン関数に std.heap.GeneralPurposeAllocator をひとつセットアップし、アプリケーションの様々な部分にそのアロケーターやサブアロケーターを渡していくことになる。
アロケーターの実装を検討することもできます。
Where are the bytes?
”foo” のような文字列リテラルは、グローバル定数データセクション( ''global constant data section'' )にあります。このため、文字列リテラルをミュータブルスライスに渡すとエラーになります[https://ziglang.org/documentation/master/#Where-are-the-bytes Where are the bytes]。
文字列リテラルと同様に、コンパイル時に値が分かっているconst宣言は、グローバル定数データセクションに格納されます。また、コンパイル時変数もグローバル定数データセクションに格納されます。
関数内のvar宣言は、その関数のスタックフレームに格納されます。関数から戻ると、関数のスタックフレームにある変数へのポインターは無効な参照となり、その参照解除は未確認の未定義動作となります。
Zig プログラマーは Allocator インターフェースを満たすことで、自分自身のアロケーターを実装することができます。そのためには、std/mem.zig のドキュメントコメントをよく読んで、allocFn と resizeFn を指定する必要があります[https://ziglang.org/documentation/master/#Implementing-an-Allocator Implementing an Allocator]。
インスピレーションを得るために、多くのアロケータの例を見ることができます。std/heap.zig と std.heap.GeneralPurposeAllocator を見てください。
多くのプログラミング言語では、ヒープ割り当てに失敗した場合、無条件にクラッシュすることで対処することにしています[https://ziglang.org/documentation/master/#Heap-Allocation-Failure Heap Allocation Failure]。
Zig のプログラマは、慣習として、これが満足のいく解決策であるとは考えていません。
その代わり、error.OutOfMemoryはヒープ割り当ての失敗を表し、Zigライブラリーはヒープ割り当ての失敗で処理が正常に完了しなかったときはいつでもこのエラーコードを返します。
Linuxなどの一部のOSでは、デフォルトでメモリーのオーバーコミットが有効になっているため、ヒープ割り当ての失敗を処理することは無意味であると主張する人もいます。この理由には多くの問題があります。
オーバーコミット機能を持つのは一部のOSだけである。
Linuxはデフォルトで有効になっていますが、設定可能です。
Windowsはオーバーコミットしません。
組込みシステムはオーバーコミットしません。
ホビー用OSはオーバーコミットがあってもなくてもよい。
リアルタイムシステムでは、オーバーコミットがないだけでなく、通常、アプリケーションごとの最大メモリ容量があらかじめ決められています。
ライブラリーを作成する場合、コードの再利用が主な目的の1つです。ライブラリーの作成において、コードの再利用は重要な目的の一つである。
オーバーコミットが有効であることに依存しているソフトウェアもありますが、その存在は数え切れないほどのユーザー体験の破壊の原因となっています。オーバーコミットを有効にしたシステム、例えばLinuxのデフォルト設定では、メモリーが枯渇しそうになると、システムがロックして使えなくなる。このとき、OOM Killer はヒューリスティックに基づき kill するアプリケーションを選択します。この非決定的な判断により、重要なプロセスが強制終了されることが多く、システムを正常に戻すことができないことがよくあります。
再帰( ''Recursion'' )はソフトウェアをモデリングする際の基本的なツールである。しかし、再帰にはしばしば見落とされがちな問題があります[https://ziglang.org/documentation/master/#Recursion Recursion]。
再帰はZigで活発に実験されている分野であり、ここにある文書は最終的なものではありません。[https://ziglang.org/download/0.3.0/release-notes.html#recursion 0.3.0のリリースノートで、再帰の状況を要約]して読むことができます。
簡単にまとめると、現在のところ再帰は期待通りに動作しています。Zigのコードはまだスタックオーバーフローから保護されていませんが、Zigの将来のバージョンでは、Zigのコードからのある程度の協力が必要ですが、そのような保護を提供することが予定されています。
ポインターを指しているメモリーが利用できなくなったときに、ポインターにアクセスしないようにするのは、Zigのプログラマーの責任です。スライスは、他のメモリーを参照するという点で、ポインターの一種であることに注意してください
[https://ziglang.org/documentation/master/#Lifetime-and-Ownership Lifetime and Ownership]。
バグを防ぐために、ポインターを扱うときに従うと便利な規則があります。一般に、関数がポインターを返す場合、その関数のドキュメントでは、誰がそのポインターを「所有」しているかを説明する必要があります。この概念は、プログラマーがポインターを解放することが適切である場合、そのタイミングを判断するのに役立ちます。
例えば、関数のドキュメントに「返されたメモリーは呼び出し元が所有する」と書かれていた場合、その関数を呼び出すコードは、いつそのメモリーを解放するかという計画を持っていなければなりません。このような場合、おそらく関数は Allocator パラメーターを受け取ります。
時には、ポインターの寿命はもっと複雑な場合があります。例えば、std.ArrayList(T).items スライスは、新しい要素を追加するなどしてリストのサイズが次に変更されるまで有効です。
関数やデータ構造のAPIドキュメントでは、ポインターの所有権と有効期限について細心の注意を払って説明する必要があります。所有権とは、ポインターが参照するメモリーを解放する責任が誰にあるかということであり、寿命とは、メモリーがアクセス不能になる時点（未定義動作が発生しないように）を決めることです。
ZigはC言語から独立しており、他の多くの言語とは異なりlibcに依存しませんが、Zigは既存のC言語で書かれたとの相互作用の重要性を認めています[https://ziglang.org/documentation/master/#C C]。
ZigはC言語との相互運用を容易にするために、いくつかの方法を用意しています。
以下に示すZigの型はC言語とのABI互換性が保証されており、他の型と同様に使用することができます[https://ziglang.org/documentation/master/#C-Type-Primitives C Type Primitives]。
C の void 型と相互運用する場合は anyopaque を使用します。
組込み関数 @cImport を使用すると、.h ファイルからシンボルを直接インポートすることができます[https://ziglang.org/documentation/master/#Import-from-C-Header-File Import from C Header File]。
@cImport 関数は、パラメーターとして式を受取ります。この式はコンパイル時に評価され、プリプロセッサー指令の制御や複数の.hファイルをインクルードするために使用されます。
align
ポインターのアライメントを指定するために使用します。
また、変数や関数の宣言の後に使用して、その変数や関数へのポインターのアライメントを指定することができます。
allowzero:ポインターの属性 allowzero は、ポインターのアドレスが 0 であることを許可します。
and:論理積
anyframe:関数フレームへのポインターを保持する変数の型として使用することができます。
anytype:関数のパラメーターは、型の代わりにanytypeで宣言することができます。型は関数が呼出された場所で推測されます
asm:インラインアセンブリ式を開始します。これにより、コンパイル時に生成される機械語を直接制御することができます。
async:関数呼出しの前に使用することで、関数がサスペンドされたときにそのフレームへのポインターを取得することができます。
await:await の後に提供されるフレームが完了するまで、現在の関数を中断するために使用することができます。await は、ターゲット関数のフレームから返される値を呼出し側にコピーします。
break:ブロックラベルと一緒に使うことで、ブロックから値を返すことができます。また、ループが自然に終了する前に終了させることもできます。
callconv:関数の呼出し規則を変更します。
catch:前の式がエラーと評価された場合に、その式を評価するために使用することができます。catchの後の式は、オプションでエラーコードをキャプチャーすることができます。[TODO:クリーンアップ]
comptime:コンパイル時に変数や関数パラメーターが既知であることを示すために、宣言の前に comptime を使用することができます。また、コンパイル時に式の実行を保証するために使用することもできます。
const:変更できない変数を宣言します。また、ポインターの属性として使用すると、ポインターが参照する値を変更できないことを示す。
continue:ループの中で使うと、ループの最初にジャンプして戻ることができます。
defer:制御フローが現在のブロックから離れるときに実行する式やブロックを登録します。
else
if、switch、while、forの代替ブランチ( ''alternate branch'' )を提供するために使用できます。
if の後で使用した場合、elseブランチ はテスト値が false、null、またはerrorを返した場合に実行されます。
switch式の中で使用した場合、elseブランチはテスト値が他のケースと一致しない場合に実行されます。
ループの後で使用した場合、else分岐はループがブレークせずに終了した場合に実行されます。
if, switch, while, forも参照してください。
enum:enum型を定義します。
errdefer:関数がエラーを返した場合、制御フローが現在のブロックを離れるとき実行する式やブロックを登録します。
error:error型を定義します。
export:生成されたオブジェクトファイルにおいて、関数や変数を外部から見えるようにします。エクスポートされた関数は、デフォルトでC言語の呼出し規則( ''calling convention'' )に従います。
extern:静的にリンクする場合はリンク時に、動的にリンクする場合は実行時に解決される関数や変数を宣言するために使用することができます。
fn:関数を宣言します。
for:スライス、配列、タプルの要素に対して反復処理を行うために使用します。
if:論理式、オプショナル値、エラーユニオンをテストすることができます。オプショナル値やエラーユニオンの場合、if はラップされていない値をキャプチャーすることができます。
inline:コンパイル時にループ式が展開されるようにラベル付けするために使用されます。また、関数のすべての呼出し箇所で強制的にインライン化することもできます。
noalias:TODO add documentation for noalias
nosuspend
ブロック、文、式の前で使用することができ、サスペンドポイントに到達しないスコープをマークすることができます。
suspend キーワードを使用すると、コンパイルエラーになります。
まだ完了していない関数フレームで await を使用すると、安全が確認された未定義の動作になる。
非同期関数を呼出すと、await を含む await async some_async_fn() と等価であるため、安全が確認された未定義の動作になることがある。
nosuspendスコープ内のコードは、それを囲む関数を非同期関数にすることはありません。
opaque:サイズとアライメントが未知の（ただしゼロではない）新しい型を宣言します。
or:論理和
orelse:前の式が null と評価される場合に、その式を評価するために使用することができます。
packed:struct 定義の前にキーワード packed を指定すると、そのstructのメモリー内レイアウトが保証された packed レイアウトに変更されます。
pub:トップレベル宣言の前にある pub は、その宣言が宣言されているファイルとは異なるファイルから参照できるようにます。
resume:関数が中断された時点から、その関数のフレームを継続して実行します。
return:値を伴って関数を終了させます。
linksection:TODO add documentation for linksection
struct:struct を宣言します。
suspend:制御フローを関数の呼出し側または再呼出し側に戻します。suspendは、関数内のブロックの前にも使用でき、制御フローが呼出し側に戻る前に関数がそのフレームにアクセスできるようにします。
switch:共通の型の値をテストするために使用することができます。switchケースは、タグ付けされたユニオンのフィールド値をキャプチャーすることができます。
test:動作が期待に沿うことを確認するために使用されるコードのトップレベルブロックを示すために使用します。
threadlocal:変数をスレッドローカルとして指定するために使用します。
try:エラーユニオン式を評価する。もしそれがエラーであれば、同じエラーで現在の関数から戻る。そうでない場合は、式はラップされていない値になります。
union:unionを定義します。
unreachable:制御フローが特定の場所に到達することがないことを保証するために使用することができます。ビルドモードによっては、unreachable はパニックを発生させるかもしれません。
usingnamespace:struct、union、または enum でなければならないオペランドのすべての公開宣言を現在のスコープにインポートするトップレベルの宣言を行います。
var:変更可能な変数を宣言します。
volatile:ポインターのロードやストアに副作用があることを示すために使用されます。また、インラインアセンブリ式を修正して、副作用があることを示すこともできます。
while:boolean、optional、errorの各ユニオン式を繰返しテストし、それぞれfalse、null、errorと評価された時点でループを停止するために使用されます。
Zigは、2024年2月10日時点で pre-release の段階にあり、インストール手順も何度か変わっているので、まずは https://ziglang.org/learn/getting-started/ を参照し、最新のインストール手順を確認してください。
ローカルにコンパイル実行環境を作るのが困難、あるいは手間を掛けずにコンパイルと実行を試してみたい。そんな場合には、オンラインコンパイル実行環境を使うことも検討に値します。
[https://zig-play.dev/ Zig Playground]
公式のオンラインコンパイル実行環境です。
フォーマッターも利用できます。
[https://wandbox.org/ Wandbox]
複数のプログラミン言語に対応しており、Zigにも対応しています。
[https://codapi.org/zig/ codapi]
複数のプログラミン言語に対応しており、Zigにも対応しています。
test 機能にも対応しています。
nightly の Zigを使いたい場合でない限り、お使いのOSやディストリビューションでサポートされているパッケージ マネージャーを使ってインストールする事をお勧めします。
また、ローカルのパッケージデータベースをパッケージシステムのリポジトリーと同期を取り、鮮度の高い状態を維持するよう心がけてください。これは、インストール後も同じですし、zigに限ったことでもありません。
Windows
Zig は、Chocolateyパッケージシステムが対応しています。
> choco install zig
macOS
macOS では、HomebrewとMacPortsが対応しています。
FreeBSD
GNU/Linuxのディストリビューション
いわゆるLinuxは、Linux（ここではOSカーネル）と、FSFがHurdカーネルのために設計・開発したGNUユーザーランド（OSの基本機能を提供するソフトウェアの集合）を組合わせたものです。
このように、LinuxカーネルとGNUユーザーランドを組合わせたソフトウェアプラットフォームをGNU/Linuxと呼びますGNU/Linuxの中核として、商用・非商用を問わず、再配布可能なユーティリティを収集・配布するディストリビューターが登場しました。これらのディストリビューターは、それぞれの配布物（互換性を失いがち）を、ディストリビューションとして区別する必要が生じました（特に、共有ライブラリーの非互換性は目立ち、Linux支持者自身が嫌悪するWindowsのDLL-Hellに酷似しています)。 このようにして、ディストリビューション間の区別がなされたのです(また、ほかにもマーケティング上の理由などもあります)。Unixでディストリビューションという言葉は、ソースコードで配布されるBSDのD (''distribution'') と関連付けられ、一方、非ソースコード指向のGNU/Linuxディストリビューションが、Unix訴訟の間隙を利する形で386 BSDのニッチをに受入れているのは皮肉なことです。
$ sudo snap install zig --beta --classic
Zig は、ソースコードが Github の https://github.com/ziglang/zig.git で公開されているので、必要に応じてソースコードからビルドすることができます。
Zigは、セルフホスティングZigコンパイラーを始めとする、Zigの言語処理系とツールチェインやユーティリティーなどは、Zig自身で書かれています。なので、最初にバイナリーを入手してブートストラップするか、クロスビルドしたバイナリーを持込むか、パッケージシステムからインストールし、ターゲットでセルフコンパイル出来る状態を作る方法があります（FreeBSDのPortsが行っているのは、まさにこれです）。
ビルド方法こそ頻繁に内容が変わるので、個別具体的な手順は述べませんが、zig はコンパイラーであるとともにツールチェインでもあり、ビルドシステムも内包しているので、
zig buildとすると build.zig ファイルに書かれているレシピにしたがって自動的にビルドが進行します（ストレージとメモリーと時間に余裕を見る必要があります）。
Zig の処理系 zig という１つのコマンドで、コンパイラーだけでなく、アーカイバー・C/C++コンパイラーやテストフレームワーク・フォーマッター・ビルドツールなどのツールチェインが統合されています。
zig コマンドを tcsh から実行:
% uname -a
FreeBSD localhost 14.0-STABLE FreeBSD 14.0-STABLE #0 60d9bb14e: Tue Dec 26 01:07:17 JST 2023 user1@localhost:/usr/obj/usr/src/amd64.amd64/sys/OLYMPIC amd64
% zig version
0.11.0
% cat hello.zig
const std = @import("std");
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
try stdout.print("Hello, {s}!\n", .{"world"});
}
% zig run hello.zig
Hello, world!
Zig言語のzig runコマンドは、Zigコンパイラを使用してZigソースコードをコンパイルし、実行可能なバイナリを生成して実行するためのコマンドです。このコマンドを使うと、Zigソースコードを直接実行することができます。
公式ドキュメント
Zigの最も包括的なチュートリアルは、公式ドキュメントにあります。ドキュメントには、Zigの基本的な概念、プログラミングスタイル、および標準ライブラリの使用方法が説明されています。ここでは、基本から上級まで、詳細に解説されています。
公式ドキュメントは以下からアクセス可能です。
ZigLearn
「ZigLearn」とは、Zigというプログラミング言語を学ぶためのオンラインリソースの集まりです。Zigは、C言語に似た構文を持ち、メモリセーフでありながら高速なプログラムを書くことができる言語です。このサイトでは、Zigを初めて学ぶ人から、より高度なトピックに取り組みたい人まで、様々なレベルの学習者に向けたリソースが提供されています。
ZigLearnは以下からアクセス可能です。
Zig Learn X in Y Minutes
「Zig Learn X in Y Minutes」というウェブサイトは、簡潔で理解しやすい形式でZigの紹介をしています。このチュートリアルでは、Zigでプログラムを作成する基本的なステップを紹介します。
Zig Learn X in Y Minutesは以下からアクセス可能です。 |
2,894 | サン＝ジェルマン条約は、1919年9月に結ばれた、第一次世界大戦の対オーストリア用の講和条約である。
条約の詳しい内容は「サン＝ジェルマン条約]を参照してほしい。
条約の内容。 |
2,895 | input "ガイド";A%
これで「ガイド？」と表示されます。
input "ガイド",B%
これで「ガイド」と表示されます。
input "ガイド";C%,D%
これで複数の変数を入力してもらえます。
カンマ(,)で区切って入力します。
input "ガイド";A%
? A%
例1と「? A%」を組み合わせて、入力した値を表示させます。 |
2,896 | いくつかの方法がある。
あるいは、 .NET Framework を実行するために .NET Framework のインストーラーをダウンロードしてくる方法。
これらをインストールすれば、基本的にC#の実行環境はついてくるはずである。
2020年11月、マイクロソフトは.NET 5.0をリリースした。Windows専用製品の .NET Frameworkとの混同を避けるため、「Core」ブランドは削除され、バージョン4.0はスキップされた。
本ページでは区別のため「.NET Core」と呼ぶことにする。
なお、.NET Core のほうが新しく、将来的にマイクロソフトは .NET Core に一本化する予定なので、最新版のC#を使いたければ .NET Core を選ぶと良い。
C#8 以降は、.NET Core になる。
.NET Framework はバージョンが .NET Framework 4.8で打ち止めであり、これはC#7.3台までしか対応していない。いちおう、2029年くらいまでは.NET Framework の新しめのバージョンのどれかがサポート予定である。
Visual Studioにインストールする場合、Visual Studio 2002にインストールするのと Visual Studio 2019にインストールするのとでは別々のインストールとして扱われるので注意。つまり、もし2つのバージョンのVisual Studio を使っているなら、2つのVisual Studio のバージョンで使えるようにするには、インストールに必要な容量は約2倍になる。
ダウンロードの仕方およびインストール先も、公式サイトから個別にダウンロードするのか、それともマイクロソフトの統合開発環境 Visual Studio から上記のものをインストールするのか、方法が分かれる。
なお、Visual Studio の利用にはアカウント登録が必要。
Visual Studio の起動には時間が掛かるし、もしインストールしていなければインストールに長い時間が掛かるので、単にC#をコマンドラインで勉強するだけなら、.NET Core を公式サイトからダウンロードするほうが早い。
Visual Studio のアカウント登録をしなくても、テキストエディタから. net core を起動してビルドする方法もある。
インストールの確認まで
.NET Core の最新安定版のインストーラーをダウンロードしてインストールする。2022年6月なら .NET Core 6 が最新バージョンであるので、それをダウンロードする。7は当分は開発中で不安定なので、初心者はダウンロードしない。
インストール作業は普通にインストーラーをマウスで起動してダイアログにOKなり何なりで終わる。
インストールが終わったら、以降の作業はコマンドプロンプトで行うので、コマンドプロンプトを起動する。
まず、本当にインストールできたかどうか確認するため、コマンド dotnet --versionを入れる。成功していれば、たとえば 6.0.301とか表示される。
.NET Coreとコマンドラインによる方法でも、いわゆる「プロジェクト」的な関連ファイルが多く自動的に作られる。
なので、コマンドラインから実行する場合は、まずプロジェクト用のフォルダを作成しないとマズい。でないと、デスクトップなりホームフォルダなどに、関連ファイルが大量に作成され、管理が面倒になる。（というか、作り直し）プロジェクト用のフォルダの作成自体は、マウスで普通に作成して大丈夫である。sampleとかtestとか気軽に命名したフォルダ名で構わない。
コマンド
mkdir test
で作成してもいい。
とりあえず、「test」という名前のフォルダを作成したとしよう。
cd 移動先フォルダ でコマンドライン上にて現在いる位置を移動。つまり「test」という名のフォルダに移動するなら cd test である。
dotnet new console でコンソール用の関連ファイルの一式を作成。なお、ついでにHello World のソースコードも作成され、Program.cs というファイル名がついている。このProgram.cs を目的のコードに書き換えていく。フォルダ名の「test」やら「sample」やらのcsファイルが作成されるわけではない。
C#9以降だと、Program.cs は下記のような短いコードになっている。これでもビルドすれば実行できる。
// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");
ビルドのコマンドは dotnet build なので、このコマンドを入れてビルドする。
実行コマンドは dotnet run なので、このコマンドを入れて実行する。
以上の準備がすべて成功すれば、
Hello, World!
と表示される。
従来はWindows用のGUIアプリを作るのは非常に困難ないし不可能と考えられていましたが、2019年にリリースされた .NET Core 3がWindows Forms、WPF、UWPをサポートされ道がひらけました。
また、mono というオープンソース版の.NetFramewark 利用環境があり、C#プログラムも実行できます。
.net core のSDKについても、 dotnet-sdk-バージョン番号 が公開されている。
mono 開発環境のインストール方法は Fedora Linux の場合、コマンド
sudo dnf install mono-devel
でインストールされます。
作成したプログラムのソースコードには、拡張子はウィンドウズ同様、「.cs」をつけます。
コンパイルは、コマンド
mcs ファイル名.cs
でコンパイルできます。
すると
ファイル名.exe
の形式のファイルが作成されるので (Linuxでも、拡張子.exeのファイルが作成されます)、
mono ファイル名.exe
で実行できます。
終了するにはリターンキー（エンターキー）を押す。
monoは仕様が少し古め
なお、monoがサポートして実行できるC#の言語仕様のバージョンは、C#7台までの対応であり、やや古めのバージョンです。monoが準拠している.net Framework 自体、対応するC#がC# 7.3 くらいまでのバージョンだと一般に言われています（マイクロソフトが詳細なバージョンを公表してないので正確な対応バージョンは不明）。
C#8 以降の新しいC#を使うには、 .net core をインストールしましょう。
マイクロソフトの公式サイトに、Fedora の場合のインストール方法がずばり書いてあるので参照せよ[https://docs.microsoft.com/ja-jp/dotnet/core/install/linux-fedora 『Fedora に .NET SDK または .NET ランタイムをインストールする』 2022/04/06 ]（なお、リンク先は機械翻訳）。
念のためコマンドを控えておくと、
sudo dnf install dotnet-sdk-6.0
である。
末尾の数字は必要。数字がないと、dnf検索でヒットしない。 |
2,897 | 前）（次）
（公共職業訓練等を受ける場合）
第41条
特例受給資格者が、当該特例受給資格に基づく特例一時金の支給を受ける前に公共職業安定所長の指示した公共職業訓練等（その期間が政令で定める期間に達しないものを除く。）を受ける場合には、第10条第3項及び前3条の規定にかかわらず、特例一時金を支給しないものとし、その者を第15条第1項に規定する受給資格者とみなして、当該公共職業訓練等を受け終わる日までの間に限り、第二節（第33条第1項ただし書の規定を除く。）に定めるところにより、求職者給付を支給する。
41 |
2,898 | 法学＞民事法＞民事訴訟法＞コンメンタール民事訴訟規則
（管轄権の標準時）
第3条の12
日本の裁判所の管轄権は、訴えの提起の時を標準として定める。
2011年改正において新設。
----
{{前後
|民事訴訟法
|第1編総則
第2章 裁判所
第1節 日本の裁判所の管轄権
|第3条の11（職権証拠調べ）
|第4条（普通裁判籍による管轄）
003の12
003の12 |
2,899 | コンメンタール＞労働基準法
（休業手当）
第26条
使用者の責に帰すべき事由によつて解雇された労働者が解雇期間内に他の職について利益を得た場合、使用者が、労働者に解雇期間中の賃金を支払うにあたり、右利得金額を賃金額から控除することの可否およびその限度。
使用者の責に帰すべき事由によつて解雇された労働者が解雇期間内に他の職について利益を得た場合、使用者が、労働者に解雇期間中の賃金を支払うにあたり、右利得金額を賃金額から控除することはできるが、その限度は、平均賃金の4割の範囲内にとどめるべきである。
労働基準法第26条は、使用者の責に帰すべき事由による休業に関して、平均賃金の6割以上の支払いを課しており、使用者に支払いを免除される限度は4割とした。
申請人らは本件解雇の後である昭和40年11月以降同41年10月までの間に、別会社で稼働し、賃金を得ていた事実が認められる。ところで、右賃金はその額および稼働日数に照らせば、副業的な稼働による利得ではなく、或いは解雇がなくとも当然取得し得るなど特段の事情に基いて利得したものともみられないから、右各申請人らは、民法第536条第2項但書により、その利得額を会社に償還すべきである。しかし、会社は労働基準法第26条に定めるとおり、平均賃金の6割以上を右各申請人に支払う義務があるから、右各申請人の前掲解雇後に利得した賃金は、会社で支払うべき平均賃金の四割を超えない限度で、平均賃金からそれぞれ控除するのが相当である。
労働基準法26条は、使用者の責に帰すべき事由による休業の場合においては、使用者は、休業期間中当該労働者に、その平均賃金の100分の60六以上の手当を支払わなければならないと規定しているが、ここにいう休業とは個々の労働者の労務の履行不能の場合もこれに含まれるものと考えられるので、同条の規定は、労働者が民法第536条第2項にいう債権者である使用者の責に帰すべき事由によつて就労できなかつた場合、即ち不当解雇の場合にもその適用があるものと解すべきである。そして、労働基準法26条は民法の原則を排除したものではなく、労働者が債務を免れたことによつて使用者に対し償還すべき利益がある場合には、使用者が賃金全額を一応支払つたうえ右利益の償還を受けるという手続の繁を省き、その決済手段を簡易化するため、右償還すべき利益の額をあらかじめ賃金額から控除し得ることを前提としたうえ、労働者の生活保障の見地から、労働者の有する賃金債権のうち、平均賃金額の6割を超える部分についてのみ右利益控除の対象とすることを許容し、右平均賃金額の六割に達するまでの部分については利益控除の対象とすることを禁止したもの、と解するのが相当である。
したがつて、控訴人が被控訴人に支払うべき解雇期間中の賃金額から右期間内に被控訴人が他に就職して得た収入額を控除することは、全く許されないわけではなく、右賃金額のうち平均賃金額の六割に達するまでの部分については控除対象とすることが禁止されているが、これを超える部分から右収入額を控除することは許されるものと解すべきである。もつとも、労働基準法26条の果たすべき前述のような利益調整機能と労働者の生活保障機能の権衡上、賃金から控除し得る償還利益は、その利益の発生した期間が賃金の計算の基礎となる期間と時期的に対応するものであることを要し、ある期間の賃金から、それとは時期を異にする期間内に得た利益を控除することは、同条が控除を許容する範囲から逸脱し、許されないものというべきである。
使用者が、その責めに帰すべき事由による解雇期間中の賃金を労働者に支払う場合、労働基準法第12条4項所定の賃金については、その全額を対象として、右賃金の支給対象期間と時期的に対応する期間内に労働者が他の職に就いて得た利益の額を控除することができる。
労働基準法26条の「使用者の責に帰すべき事由」は、民法536条2項の「債権者ノ責ニ帰スヘキ事由」よりも広く、使用者側に起因する経営、管理上の障害を含む。
定期航空運輸事業を営む会社に職業安定法44条違反の疑いがあつたことから、労働組合がその改善を要求して部分ストライキを行つた場合であつても、同社がストライキに先立ち、労働組合の要求を一部受け入れ、一応首肯しうる改善案を発表したのに対し、労働組合がもつぱら自らの判断によつて当初からの要求の貫徹を目指してストライキを決行したなど判示の事情があるときは、右ストライキにより労働組合所属のストライキ不参加労働者の労働が社会観念上無価値となつたため同社が右不参加労働者に対して命じた休業は、労働基準法26条の「使用者の責に帰すべき事由」によるものということができない。
----
{{前後
|労働基準法
|第3章 賃金
|労働基準法第25条（非常時払）
|労働基準法第27条（出来高払制の保障給）
026 |