ひだまりソケットは壊れない

ソフトウェア開発に関する話を書きます。 最近は主に Android アプリ、Windows アプリ (UWP アプリ)、Java 関係です。

まじめなことを書くつもりでやっています。 適当なことは 「一角獣は夜に啼く」 に書いています。

Android の Instrumented Test で指定のサイズのテストだけ実行する (@SmallTest とか @LargeTest とか)

Android アプリ ライブラリ

Android Testing Support Library (ATSL) の話。 バージョン 0.5 時点での情報です。

ライブラリの準備方法などはドキュメントを読んでください。

テストサイズを表すアノテーション

android.support.test.filters というパッケージがあって、この中にはテストをフィルタするのに使用できるアノテーションが入っています。 その中に、テストのサイズを表すためのアノテーションが 3 つ入っています。

これらはテストクラス自体に付けることもできますし、メソッド単体に付けることもできます。 実装を見たところ、メソッドとクラスの両方にアノテーションが付けられている場合はメソッドのアノテーションが優先されるようです。

ちなみに、Android Testing Support Library じゃなくて android.test.suitebuilder.annotation パッケージの方にも同名のアノテーションがありますが、そっちは deprecated ぽいし AndroidJUnitRunner と組み合わせて使うことはできないぽいので注意しましょう。

AndroidJUnitRunner とテストサイズによるフィルタリング

AndroidJUnitRunner でテストを実行する場合、テストサイズによるフィルタリングが可能です。 下記 Javadoc にいろいろ書かれています。

adb でテスト実行する場合

上のドキュメントでは、adb コマンドでテストを実行する際にどういうオプションを渡せばいいかが主に書かれています。 例えば、small サイズのテストのみを実行する場合は、以下のようになります。

adb shell am instrument -w -e size small your.test.target/android.support.test.runner.AndroidJUnitRunner

Gradle の connectedAndroidTest タスクで実行する場合

AndroidManifest.xml で指定する (ただし現在はバグで動かない)

上のドキュメントには All arguments can also be specified in the in the AndroidManifest via a meta-data tag ということが書かれています。 すなわち、テスト用のアプリパッケージの AndroidManifest.xml ファイル (app/src/androidTest/AndroidManifest.xml ファイル) に以下のような記述をすると、small サイズのテストのみが実行されるはず、ということです。

    <instrumentation
        android:name="android.support.test.runner.AndroidJUnitRunner"
        android:targetPackage="...">
        <meta-data android:name="size"
                   android:value="small"/>
    </instrumentation>

ただし現在はバグで動きません。 (指定が無視されます。) バグ報告を上げたので、対応状況は下記ページをご覧ください。

バグがなければ、上のような記述をしておけば ./gradlew :app:connectedAndroidTest という感じで Gradle タスクでテストを実行したときにテストサイズのフィルタリングが効きます。

Gradle のビルドスクリプトで指定する

AndroidManifest.xml に書かずに Gradle のビルドスクリプトにオプションを指定することができます。 上の方法の代わりにこの方法を使うことで、上のバグを回避できます。 sumio さんに教えて頂きました。


android {
    defaultConfig {
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        testInstrumentationRunnerArguments size: 'small'
    }
}

上のような感じで書きます。

Android Studio 上でテストを実行する場合

Android Studio 上でテストを実行する場合は、build.gradle での記述が有効にならないので、configurations を弄る必要があります。 下図のような感じで、Extra options に 「-e size small」 と入力すれば良いです。

f:id:nobuoka:20160527031054p:plain

おわり

@SmallTest アノテーションとか @LargeTest アノテーションとかがあって、テスト実行時にそれらのフィルタリングができるという情報を過去に見たのですが、いざやってみるとあまり情報がなくてうまくいかなかったのでまとめてみました。

コミットごとのテストは @SmallTest だけにして、ある程度開発が終わってレビューに出す前の段階になったら @MediumTest と @LargeTest のテストも行うようにする、とかにしたらテストにかかる時間が短くなっていいかもしれませんね。

関連ページ

Rust 入門してる #3 : オブジェクト指向っぽい部分？

Rust

#2 に続いて Rust のドキュメントをぼちぼち読んでます。 このブログ記事はメモと感想程度のものですので、詳細は各見出しの下のリンク先を見てください。

今回は構造体とか列挙型とかメソッドとかトレイトとかそこら辺のオブジェクト指向っぽい部分 (の途中まで) を読みました。 パターンマッチとか文字列とかも出てきました。

構造体 (Structs)

// こういう感じで定義して、
struct Point {
    x: i32,
    y: i32,
}

// こういう感じでインスタンスを生成。
let origin = Point { x: 0, y: 0 };
// `..` に続けて別のインスタンスを指定すると、残りのフィールドにそのインスタンスの値を渡せるぽい。
let x1 = Point { x: 1, .. origin };

Tuple に名前を付けたような Tuple Structs というものもある。 型としては Tuple 型らしい。

struct Color(i32, i32, i32);
let black = Color(0, 0, 0);

Unit-like Structs というものもある。 これはフィールドを持たない構造体で、Unit-like Structs を定義すると、同時にその構造体と同名の定数も定義される。

// Unit-like Structs
struct Cookie;

上の定義は、下のコードと同等。

struct Cookie {}
const Cookie: Cookie = Cookie {};

単に構造体を定義してフィールドの値を読み書きする、というぐらいであれば簡単っぽいけど、実践的に使うためにはトレイトと組み合わせたりしないとだめそうな気がする。 (まだよくわかってない。)

列挙型 (Enums)

列挙型は、複数の変種 (variant) の中の 1 つのデータを表す型。 列挙型の中のそれぞれの変種は、それに関連するデータを保持することもできる。 列挙型の値としては、その列挙型の任意の変種を取りうる。 代数的データ型でいうところの直和型 (sum type) に相当するっぽい。

enum Message {
    Quit,
    ChangeColor(i32, i32, i32),
    Move { x: i32, y: i32 },
    Write(String),
}

上の例を見るとわかるように、各変種を定義するための構文は、構造体を定義するための構文に似ている。

それぞれの変種は列挙型の名前でスコープ化されているので、:: を使って各変種の名前を使用する。

let message: Message = Message::Move { x: 10, y: 5 };

列挙型のコンストラクタは、関数としても扱えるらしい。 例えば、上の例の Message::Write のコンストラクタは fn (String) -> Message という型の値として扱える。 クロージャとかと同様に他の関数に渡したりして使う場合に便利っぽい。

Match

match 式はパターンによって分岐するものである。 単純な例だと、以下のように if/else の連なりを書きかえることができる。

let x = 3;

let val = match x {
    1 => "one",
    2 => "two",
    3 => "three",
    _ => "else",
};

match には、「網羅的なチェック」 を強制するという利点がある。 例えば上の例で 「_」 を除くとコンパイルエラーになる。

パターン (Patterns)

変数束縛や match 式、他の場所にもパターンは現れる。 下記のものを組み合わせてパターンが表現される。

  • 複式パターン : 1 | 2
  • 範囲 : 1 ... 5
  • 変数への束縛 : x
    • 値の型に応じてコピーか移動になる。
  • 参照を束縛 : ref x (ref mut x)
  • サブパターンで束縛 : e @ 1 ... 5
  • デストラクチャリング : Point { x, y }
    • フィールドの値に別名を付けて束縛 : Point { x: x1, y: ref y1 }
  • ワイルドカード (..) : Point { x: x1, .. }
  • プレイスホルダ (_) : Err(_)

パターンガードもある。

let message = match val {
    Some(x) if x < 5 => "Less than five",
    Some(x) => "Else",
    None => "None",
};

メソッド

impl キーワードである型に対するメソッドを定義できる。 第 1 引数は self か &self か &mut self。 impl は同じ型に対していくつも定義できるらしい。

struct Point { x: i32, y: i32 }
impl Point {
    fn p(&self) {
        println!("({}, {})", self.x, self.y);
    }
}

let point = Point { x: 1, y: 2 };
point.p();

関連する関数 (static メソッドぽいもの) も定義できる。 第 1 引数が self (または &self、&mut self) でない場合は自動的にそうなる。

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x: x, y: y }
    }
}

let point = Point::new(10, 2);

ここら辺は Perl とかやってると馴染みのある感じ。 既存の構造体に対して新しいメソッドを定義することもできそうだし、そこら辺は便利そうな気がする。 (動的型付けだとどこでメソッドが定義されたのかわからなくて困りそうだけど、Rust だとまあ大丈夫そう？)

Vectors

以下のようなイテレーションの例があるけど、vector の指定方法に応じて i の型も変わるのが慣れるまで大変そう。

for i in &v {
    println!("A reference to {}", i);
}

for i in &mut v {
    println!("A mutable reference to {}", i);
}

for i in v {
    println!("Take ownership of the vector and its element {}", i);
}

文字列

Rust の文字列は UTF-8 エンコードされた Unicode スカラ値の連なり。 全ての文字列は UTF-8 列として正しい。

型としては主に 2 種類。

  • &str : 文字列スライス (string slices)
    • サイズ固定で変更不可。
  • String : ヒープ割り当てされた文字列。
    • 変更可能。

文字列リテラルは static にメモリ割り当てされるので、それへの参照として &str を使用できる。

  • &str の値の to_string() メソッドを呼ぶことで String の値を得られる。 (メモリ割り当てするのでコストがかかる。)
  • String の値の参照を取ることで &str として扱える。 (&String から &str への自動的な型強制がかかるため。 コストはかからない。)

バイトごとや文字ごとのイテレーションをしたい場合は as_bytes() メソッドや chars() メソッドを使うぽい。

String の後ろに &str を結合できる。

let s1: String = "こんにちは".to_string();
let s2: &str = "世界";
println!("{}", s1 + s2);

こういう結合をしたときの所有権の動きがいまいちよくわかってない。

ジェネリクス

ここで紹介されてる分に関しては、Java のジェネリクスを知ってれば大丈夫そう。

トレイト

Rust のトレイトは、メソッドを宣言するだけで実装は含まないから *1 トレイトというよりインターフェイスなのでは？ と思ったけど、impl キーワードでトレイトに対する実装を提供する、という感じだからインターフェイスじゃなくてトレイトなのか。 impl HasArea for Circle { ... } という感じ。

Java なんかの Circle が HasArea を実装する、というのとは逆で、Circle に対する HasArea の実装を提供する、という感じなのが面白い。 こういう風になっているおかげで、既存の構造体に対して追加でトレイトの実装を提供できて便利ぽい。 (と思ったけど、トレイトと実装対象の型のどちらかは自分で実装したものではないとだめっぽいから、自由になんでもできるわけではなさそう。)

ジェネリック関数の境界にトレイトを使用できる。

fn print_area<T: HasArea>(shape: T) { ... }

複数の境界を指定することもできる。 Java 8 の intersection types っぽい。

fn foo<T: Clone + Debug>(x: T) { ... }

ジェネリック型の実装のジェネリックパラメータの境界にトレイトを使用した場合は、その実装はその条件を満たすジェネリックパラメータの場合のみにその実装が提供される。

impl<T: PartialEq> Rectangle<T> {
    fn is_square(&self) -> bool {
        self.width == self.height
    }
}

上の例だと、ジェネリックパラメータ T に対して PartialEq の実装が提供されている場合にのみ Rectangle<T> に is_square メソッドが生える。

ジェネリックパラメータの宣言場所での境界の定義だけでなく、where 句での定義も可能。

fn foo<T: Clone, K: Clone + Debug>(x: T, y: K) { ... }
// 上と同じ。
fn foo<T, K>(x: T, y: K) where T: Clone, K: Clone + Debug { ... }

トレイトはメソッドのデフォルト実装を持てる。 また、継承も可能。

一部のトレイトは、属性を使って自動的に実装できる。

#[derive(Debug)]
struct Foo;

Drop トレイト

標準ライブラリによって提供される Drop トレイトを使うことで、値がスコープから外れた際に終了処理を実行させることができる。

*1:後ろの方に書いたけどデフォルト実装を持てます。 suzak さん指摘ありがとうございます！

React Native の Universal Windows Platform サポートを試してみた

UWP アプリ

React Native が Universal Windows Platform をサポートするという発表が、2016 年 4 月の F8 にて Microsoft と Facebook により行われました。 すなわち、React Native を使って Universal Windows Platform (UWP) アプリを開発できるようになります。

blogs.windows.com

上のブログ記事の公開時点では、React Native の本家とは独立した Git リポジトリに UWP サポートが入っているものが公開されているのみで、本家の方には UWP サポートは入っていません。 今後、React Native プロジェクトの本家に UWP サポートが追加されていくようです。

仕組み

React Native の仕組みが、冒頭で紹介したブログ記事で簡単に紹介されています。

Under the hood, React Native enables app builders to declare their UI using JavaScript and React, and the framework translates the React DOM from JavaScript into method calls to view managers on the native platform, allowing developers to proxy direct calls to native modules through JavaScript function invocations. In the case of React Native on UWP, the view managers and native modules are implemented in C#, and the view managers instantiate and operate on XAML elements. We use Chakra for the JavaScript runtime, which can be consumed by any UWP app without any additional binaries being added to the app package.

React Native on the Universal Windows Platform | Building Apps for Windows

React Native でアプリ開発をする場合、開発者は JavaScript と React で UI を定義し、React Native のフレームワークが React DOM をもとにネイティブプラットフォームの View マネージャのメソッドコールを行ってネイティブの UI 要素を生成します。 また、ネイティブモジュールのメソッド呼び出しを JS から行うこともできます。

UWP での React Native の場合は、ネイティブの UI マネージャやモジュールは C# で実装されており、それらを JS から使うことができます。 JS 実行環境には Chakra が使われるため、アプリに JS 実行用の追加のバイナリを含める必要はないとのことです。

試してみた

まだ React Native 本家に UWP サポートは入っていませんが、UWP サポートが入っている Git リポジトリが公開されているので試すことができます。 というわけでリポジトリに入っているデモプロジェクトを動かすところまでやってみました。

リポジトリ

下記のリポジトリです。

UWP サポートに関するドキュメントは、今のところ次のものしかなさそうです。

試し方

上のドキュメントに書かれている通りに進めれば試せます。 簡単に流れを書くと次のような感じです。

  1. まずは Node.js や Python などの必要なツールをインストールする。
  2. リポジトリを Git で clone してくる。
  3. プロジェクトのディレクトリで npm install。
  4. プロジェクトのディレクトリで node local-cli\cli.js start。
  5. Visual Studio 2015 で ReactWindows\ReactNative.sln を開き、Playground プロジェクトを実行するとアプリが起動する。

Visual Studio 側で開かれるプロジェクトは、React Native と UWP の橋渡しのための機能群やアプリのガワの部分だけです。 アプリ内部の JS で書かれている部分はプロジェクトの Examples\UIExplorer\UIExplorerApp.windows というファイル (Playground プロジェクトの AppReactPage.cs ファイルで指定されている) で、JS 部分は node local-cli\cli.js start で起動されたプロセスがアプリのガワの方に渡すっぽいです。 (詳しいことはわかってない。)

アプリが起動すると、最初に次のような画面が開きます。

f:id:nobuoka:20160504020228p:plain

しばらくすると次のような表示になるはずです。

f:id:nobuoka:20160504020423p:plain

JS ファイルを変更したら、Ctrl + R で更新できます *1。

とりあえずデバッグビルドで動かすことは簡単にできましたが、リリースビルドの作り方とかはよくわかってないです。

雑感

UWP アプリ開発においては、もともと JS + HTML + CSS での開発がサポートされています。 Windows Runtime API も基本的には JS からそのまま使用できます。 よって、単に 「JS + React でアプリ開発ができる」 という点では、React Native を使った場合ももともとの JS サポートも大差はありません。

もともとの JS サポートと React Native を使った場合とを比べて一番違ってくるのは、UI 周りかなと思います。 前者は HTML + CSS で UI を記述しますが、後者は本来であれば XAML で記述される UI を JS 側から操作する、ということになります。 Windows 8 や 8.1 の Windows ストアアプリの頃は、C# + XAML での UI コンポーネント相当のものが WinJS で提供されていましたが、Windows 10 の UWP アプリでは、C# + XAML では使えるカレンダーなどのコンポーネントが WinJS では提供されていないなどの差が出てきました。 同じ UI コンポーネントを異なる環境用に提供してメンテナンスするのはコストが大きいのかもしれません。

WinJS が C# + XAML の UI コンポーネントを全てカバーしきれていないという状況の中で、React Native は 「慣れている JS + React でアプリ開発したいけどネイティブの UI コンポーネントを使いたい」 という人の有力な選択肢になるかなと思います。 もちろん、もともとの JS + HTML + CSS でのアプリ開発が React Native に劣っているというわけではなく、HTML や CSS に慣れている人にとっては JS + HTML + CSS の方が view 周りをごりごり書いていくことができたり、web 側の UI ライブラリをそのまま使えたりできるといった利点もありますので、どちらを選ぶかは状況次第という感じになりそうです。

ともかく React Native で UWP アプリ開発ができるようになるのは喜ばしいことですね！

*1:文字入力用のフォームにフォーカスが当たっているときでないと反応しませんでした。

ISO 8601 DateFormat 1.0.0 (Java 向けライブラリ) をリリースしました

Java Android アプリ Release notes ライブラリ

2016 年 5 月 3 日に ISO 8601 DateFormat の 1.0.0 をリリースしました。 ISO 8601 形式 (もしくは RFC 3339 や W3C-DTF 形式) の日付時刻文字列のパースとフォーマットのための DateFormat のサブクラスを提供するライブラリです。

Bintray の JCenter リポジトリで公開しています。

現在は、時刻オフセット付きの拡張形式の日付時刻文字列のみをサポートしています。

  • 2016-01-01T00:30:21Z
  • 2016-01-01T09:30:21+09:00

動機

Java では、ISO 8601 形式の日付時刻文字列をパースする方法がいろいろあります。 例えば、SimpleDateFormat で “yyyy-MM-dd'T'HH:mm:ssX” というフォーマットを使う (Java SE 7 以降) とか、Date and Time API (JSR 310; Java SE 8 以降) を使うとか、Joda-Time ライブラリを使うとか、Apache Commons Lang ライブラリを使うなどです。

しかし、Java SE 6 環境や Android プラットフォームでは、大きなライブラリを導入することなく ISO 8601 形式の文字列をパースすることが簡単ではありませんでした。 そのため、このようなライブラリを公開しました。

使い方

Gradle を使っている場合、以下のようにリポジトリと依存を追加します。

repositories {
    jcenter()
}
dependencies {
    compile 'info.vividcode:date-format-iso8601:1.0.0'
}

あとは、以下のように使うだけです。

import info.vividcode.time.iso8601.Iso8601ExtendedOffsetDateTimeFormat;

DateFormat f = new Iso8601ExtendedOffsetDateTimeFormat();
Date d1 = f.parse("1970-01-01T00:00:00Z");
Date d2 = f.parse("1970-01-01T09:00:00+09:00");

最新の情報はリポジトリの README ファイルを見てください。

ISO 8601 関連の情報

小さなライブラリが欲しいのでなければ、Joda-Time や Apache Commons Lang、JSR 310 のバックポートライブラリなどを使うのが良いかもしれません。

Rust 入門 #2 : 所有権システムと可変性

Rust

「Rust 入門してる #1」 に続き、ぼちぼちと Rust を学んでます。 今日は所有権システムと可変性についてのメモです。 4 月 14 日に Rust 1.8 がリリースされたので、バージョン 1.8 のドキュメントを読んでます。 *1

所有権システムについては下記の 3 ページを読みました。

可変性については次のページ。

基本的にはそんなに難しいことは書かれてないですが、後で説明される内容が出てきたり説明があまりうまくなかったりで理解が難しい感じがしますね。 まあざっくりと理解して読み進めていけば良さそうです。

所有権システム (Ownership system)

  • Rust の最も独特で感動的な機能であり、Rust 開発者はこれに精通すべきとのこと。
  • メモリ安全がこの機能の大きな目的である。
  • コンセプトは次の 3 つ。
    • 所有権 (ownership)
    • 借用 (borrowing) とそれに関連する機能である 「参照 (reference)」
    • 生存期間 (lifetimes)

Meta

  • Rust は安全性と速度に焦点を当てている。
  • 所有権システムはゼロコストの抽象化の最たる例で、コンパイル時に解析することで実行時にコストがかからないようになっている。
  • 一方で、このシステムには学習曲線というコストがかかる。 実際の実装と開発者のメンタルモデルが違っていて、開発者が正しいと思っているコードがコンパイラに弾かれるということが最初のうちは多いかもしれない。 経験を積むことで徐々にそれは減っていく。

所有権 (Ownership)

  • 変数束縛 (variable binding) には、それらの結合先の 「所有権を持っている」 かどうかを表すプロパティがある。
  • 束縛がスコープを抜けると、Rust は束縛されているリソースを解放するであろう。
fn foo() {
    let v = vec![1, 2, 3];
}

上の例だと、新しい vector がスタック上に作られ、各要素のためのスペースはヒープ上に生成される。 v がスコープから外れると、Rust は vector に関するリソースを解放する (ヒープに割り当てられたメモリも)。

Move semantics
  • 任意のリソースに対して所有権を持つ束縛は、プログラム中に 1 つしか存在できない？
  • あるリソースに対して所有権を持つ束縛を別の束縛に割り当てた場合、所有権は新しい束縛に移り、古い束縛経由でリソースにアクセスしようとしてもコンパイルエラーが発生する。
fn foo() {
    let v = vec![1, 2, 3];
    let v2 = v; // 所有権が v から v2 に移る。
    // v 経由で vector の操作をしようとしてもコンパイルエラーになる。
}

上は別の変数束縛への割り当ての例だが、関数の引数として渡す場合もやはり所有権は移る。

Copy 型
  • 上で見たように、ある束縛の値を別の束縛に割り当てると普通は所有権が移る。 そのため、古い束縛を使おうとするとコンパイルエラーになる。
  • 所有権が移らないような型を定義する場合は、Copy トレイトを実装することになるらしい。
    • プリミティブ型は Copy トレイトを実装している。

参照と借用 (References and Borrowing)

単純に引数で所有権を受け取る関数を書いた場合、呼び出し元に所有権を返すために戻り値で所有権を返す必要がある。 それはめっちゃ面倒なので、参照を受け取るようにして回避する。

参照と借用

参照はリソースを所有するのではなく、所有権を借りる (借用)。 スコープを抜けたときにはリソースを解放するのではなく所有権を返す。

2 つの参照

2 種類の参照がある。

  • (通常の) 参照
    • &T
  • ミュータブルな参照
    • &mut T

通常の参照とミュータブルな参照は同時に存在はできない。 通常の参照は同時に複数個存在できるが、ミュータブルな参照は 1 つのみしか存在できない。

参照を使う際には、前置の単項演算子 * を使ってデリファレンスすればよい。 ただし、自動でのデリファレンス機能もあるっぽくて、* を使って明示的にデリファレンスしなくてもそのまま使える状況が多いっぽい。 (まだよくわかってない。)

生存期間 (Lifetimes)

  • 生存期間とは、参照が有効であるスコープを記述するもの。
  • 全ての参照は生存期間を持つが、一般的には明示しなくても良い。 (省略可能。)
  • 特別な生存期間として 「static」 がある。 これはプログラム全体を表す生存期間である。
  • 生存期間を指定する場合、参照を表す型の & の後ろに 'lifetime を付ける。
    • 例えば fn calc(val: &'static i32) { ... } という感じ。
  • ジェネリックパラメータとして生存期間を宣言することもできる。
    • 例えば fn calc<'a>(val: &'a i32) { ... } という感じ。
生存期間の省略 (lifetime elision)
  • Rust ではシグネチャでの型推論は基本的に禁止されているが、関数のシグネチャにおいては 「生存期間の省略」 が適用される。
  • 関数の引数に関連する生存期間を入力生存期間 (input lifetime)、関数の戻り値に関連する生存期間を出力生存期間 (output lifetime) という。
  • 「生存期間の省略」 のルールは次のとおり。
    • 関数の引数のうち、省略された生存期間は全て異なる生存期間のパラメータを持つ。
    • 入力生存期間が 1 つのみの場合 (省略されているかどうかに関わらない)、返り値に関連する生存期間のうち省略されているものは全て、入力生存期間と同じ生存期間となる。
    • 入力生存期間が複数ある場合でも、引数の 1 つが &self か &mut self の場合は、返り値に関連する生存期間のうち省略されているものは全て、self の生存期間と同じ生存期間となる。 (これはまだよくわかってない。)
    • 上記以外は全てエラーとなる。

可変性 (Mutability)

  • Rust で 「イミュータブル」 というのは、必ずしも 「変更できない」 ことを意味するわけではない。
  • 通常の参照と mut 参照が Rust における不可変性の基礎となっている。
  • すなわち、「イミュータブル」 であれば、複数の参照が存在しても安全であるということである。

*1:前回は 1.7 のドキュメントを読んでました。 基本的には変わりないはずです。