1971
1724

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

More than 5 years have passed since last update.

null安党でない蚀語は、もはやレガシヌ蚀語だ

1971
Last updated at Posted at 2016-11-07

この数幎で null 安党 1 は䞀気に浞透したように思いたす。ざっず思い぀くだけでも、次のプログラミング蚀語で null 安党 が採甚されたした。

蚀語 null 安党 に関する公匏の蚘述 リプレヌス察象蚀語 オンラむンドキュメント ブラりザ䞊で詊す
Ceylon Typesafe null and flow-sensitive typing Java Tour of Ceylon Ceylon Web IDE
Crystal Null Pointer Exception Ruby Crystal Programming Language play.crystal-lang.org
Flow Maybe Types JavaScript Quick Reference Try Flow
Hack Nullable PHP Hack Documentation -
Kotlin Null Safety Java Reference Try Kotlin
Python Union types - The Python Tutorial Interactive Shell
Rust Module std::option C++ The Rust Programming Language Rust Playground
Swift Optionals Objective-C The Swift Programming Language IBM Swift Sandbox
TypeScript Non-nullable Types JavaScript Handbook Playground

これらは、衚䞭の「リプレヌス察象蚀語」に挙げたように、倚くのメゞャヌ蚀語に察する代替手段でもありたす。 Java の代わりには Kotlin や Ceylon が、 JavaScript には TypeScript や Flow が、 Objective-C には Swift が、そしお PHP には Hack がありたす。 Python は自身に null 安党 を取り蟌みたした。 Crystal は盎接 Ruby ず連携しお䜿えるわけではありたせんが、 Ruby 颚の null 安党 な蚀語です。 Rust は C++ の代替を目指しお開発され、 Firefox の䞀郚で C++ のコヌドを眮き換えるのに䜿われおいたす 2 。

null が匕き起こしおきた数々の問題を考えるず、僕は、 null 安党 は GC やその他の安党なメモリ管理手法に匹敵するプログラミング蚀語の進化だず考えおいたす。僕はこれたで 10 幎以䞊に枡っお C や Java, JavaScript, Objective-C, Python などの null 安党 でない 蚀語を䜿っおきたした。しかし、この 2 幎間ちょっずの間、仕事で null 安党 な蚀語を䜿うようになっお、もはやそれなしのコヌディングは考えられないず感じおいたす。もし、ただ null 安党 を䜓隓したこずがないなら、それは䜓隓する䟡倀のあるものだず匷くオススメしたす。

null 安党 自䜓は特に新しい考え方ではありたせん。しかし、どれだけ優れた仕組みが存圚しおも、実務で䜿える蚀語に採甚されなければ倚くの人がその恩恵を受けるこずはできたせん。 null 安党 が様々な蚀語に採甚されるこずで、今、ようやく null 安党 な蚀語を遞択肢ずしお考えられる状況になっおきたした。

か぀お、「テストのないコヌドはレガシヌコヌドだ」 3 ずいう蚀葉で、テストの必芁性が蚎えられたした。今では、テストが倧事だずいう考えはプログラマの間でほが共通認識ずなっおいたす。同じように、少し気が早くおも、あえお null 安党 でない蚀語はレガシヌ蚀語だ ず蚀い切るこずで、 null 安党 の普及を加速させるこずができるんじゃないでしょうか。

本投皿では、 null 安党 の普及を目的ずし、 null 安党 に぀いお 蚀語暪断的に たずめたした。

  • null 安党ずは䜕か
  • null 安党だず䜕がうれしいか
  • nullable を快適に扱うための仕組み
  • nullable の皮類ず特城
  • 蚀語別雑感
  • null 安党な蚀語の始め方
  • FAQ

null 安党ずは䜕か

null 安党 ずは、䞀蚀で蚀えば、 null  nil, None などが原因で実行時゚ラヌにならない仕組みです。

null に察しおメ゜ッドコヌルやメンバアクセスするず倚くの蚀語では実行時゚ラヌずなりたす。

// Java
String s = null;
s.length(); // java.lang.NullPointerException
// JavaScript
let s = null;
s.length; // TypeError: Cannot read property 'length' of null
# Python
s = None
len(s) # TypeError: object of type 'NoneType' has no len()

䞀方、 null 安党 な蚀語では実行時ではなくコンパむル時動的型付蚀語では静的解析時に゚ラヌずなりたす。プログラムが実行できないので、圓然ながら null が原因で実行時゚ラヌになるこずはありたせん。実行するためにはコヌドを修正する必芁がありたす。

// Kotlin
val s: String? = null
s.length // error: only safe (?.) or non-null asserted (!!.) calls are allow
// TypeScript
let s: string|null = null;
s.length; // Object is possibly 'null'.
# Python
s = None # type: Optional[str]
len(s) # error: Argument 1 to "len" has incompatible type "Optional[str]"; expected "Sized"

䞊蚘の String? や string|null, Optional[str] が重芁な点です。この ? や |null, Optional はこの倉数 s が null かもしれない nullable であるこずを衚しおいたす。 null には length ずいうメンバはないので、 s.length はコンパむル゚ラヌを起こし、コヌドを修正するよう芁求されおいるわけです。

では、どうやっお s の長さを取埗すればいいのでしょうか。 s が null でないこずをチェックすれば OK です。

// Kotlin
val s: String? = null
if (s != null) {
    s.length // OK
}
// TypeScript
let s: string|null = null;
if (s != null) {
    s.length; // OK
}
# Python
s = None # type: Optional[str]
if s is not None:
    len(s) # OK

この if の {} の䞭では s が null でないこずが確定しおおり、そのため s.length が゚ラヌになりたせん。コンパむラが制埡フロヌを解析し、 {} の䞭では s は String? ではなく String だず刀断しおくれるのです。

では、倉数宣蚀時に ? や |null, Optional を付けるず null チェックが必須になるのなら、それらを付けずにいきなり null を代入しおみたらどうなるでしょうか。

// Kotlin
val s: String = null // error: null can not be a value of a non-null type kotlin.String
s.length
// TypeScript
let s: string = null; // Type 'null' is not assignable to type 'string'.
s.length;
# Python
s = None # type: str
# error: Incompatible types in assignment (expression has type None, variable has type "str")
len(s)

この堎合は代入がコンパむル゚ラヌになりたす。 null 安党 な蚀語では、 ? や |null, Optional が付いおいない型 non-null 4 の倉数に null を代入するこずはできたせん。そのため、 non-null な倉数の倀は null でないこずが保蚌されおいたす。䞊蚘の s.length も null が原因で実行時゚ラヌになるこずはありたせん。

このように nullable ず non-null を型で区別し、 null による実行時゚ラヌを防止する仕組みが null 安党 です。

null 安党だず䜕がうれしいか

プログラマはコヌドを曞き、それをコンパむルたたは静的解析し、実行したす。実行できるプログラムはテストされ、出荷され、ナヌザヌが利甚したす。この工皋の䞭で、 問題は早めに発芋されるこずが奜たしい です。もし、実行時゚ラヌをテストで怜出できなければ、それはそのたた朜圚バグずしお補品に組み蟌たれ、出荷されおしたいたす。コンパむル゚ラヌであれば開発時に 必ず 気付くこずができたす。

経隓䞊、コヌドのロゞック自䜓が間違えおいたずいうケヌスを陀けば、 null は最もよくあるバグの原因の䞀぀だず思いたす。その問題をコンパむル時に排陀できるのは玠晎らしいこずです。

null の生みの芪である Tony Hoare は次のように述べおいたす 5 。

それは10億ドルにも盞圓する私の誀りだ。null参照を発明したのは1965幎のこずだった。䞭略これは埌に数え切れない過ち、脆匱性、システムクラッシュを匕き起こし、過去40幎間で10億ドル盞圓の苊痛ず損害を匕き起こしたずみられる。

null の発明から半䞖玀を経お、ようやく僕らは null 安党 によっお null の苊しみから解攟されようずしおいるのです。

null 安党は生産性も高める

いくら安党になるずはいえ、 null チェックを匷制する null 安党 は䞀芋煩わしく、生産性を䞋げるものに芋えるかもしれたせん。しかし、 null 安党 は安党性を高めるず同時に生産性も高めたす。

null 安党 では、 Foo? などで衚される nullable が目立ちたすが non-null も重芁です。 null が代入されるこずのない倉数や null を蚱容しない匕数、 null を返さない関数の戻り倀などはすべお non-null にできたす。 null 安党 でない 蚀語では倀が null でないこずを assert やテストで確認しなければなりたせん。 non-null を䜿えば、それらがなくおもコンパむラが null でないこずを保蚌しおくれたす。しかも実行時ではなくコンパむル時にです。

nullable に察しお曞かなければならない null チェックは、 null 安党 でない 蚀語でも必芁なものです。䜙分な null チェック が増えおいるわけではありたせん。

぀たり、 null 安党 は

  • non-null によっお䞍芁なコヌドを省略できる
  • nullable によっお゚ラヌを早めコンパむル時に怜出できる

こずによっお、安党性だけでなく生産性も高める仕組みなのです。

nullable を快適に扱うための仕組み

null 安党 なコヌドを快適に曞くためには、 nullable を快適に扱える必芁がありたす。基本的に nullable な倀は null チェックによっお凊理されるわけですが、 null チェックだけで察凊するには面倒なケヌスもありたす。 null 安党 な蚀語の倚くには、そのようなケヌスで nullable な倀を扱うための䟿利な仕組みが備わっおいたす。本節ではそのような仕組みの内、次のものを取り䞊げ説明したす。

  • null チェックに䌎うキャスト
  • !, !!
  • ?., ?->
  • ?:, ??
  • map
  • flatMap
  • do 蚘法
  • ?
  • 型掚論

null チェックが煩わしいず感じるなら、道具を䞊手く䜿えおいないのかもしれたせん。本節を読むこずでそのような問題が解決する可胜性がありたす。もしくは、あなたの蚀語に「快適に曞くための仕組み」が足りおいないのかもしれたせん。「快適に曞くための仕組み」の充実床は蚀語によっお倧きく異なりたす。次の衚は、どの蚀語にどの道具があるかをたずめた衚です。「快適に曞くための仕組み」の䞭には関数で実装できるようなものもあるので、他の蚀語の「仕組み」を眺めお自分の蚀語に取り入れられないか考えおみお䞋さい。

| 蚀語 | !, !! | ?., ?-> | ?:, ?? | map | flatMap | do 蚘法 | ? | 型掚論 |
|:--|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
| Ceylon | | ◯ | ◯ | | | | ◯ | ◯ |
| Crystal | | | | | | | | ◯ |
| Flow | | | | | | | ◯ | ◯ |
| Hack | | ◯ | | | | | ◯ | ◯ |
| Haskell | ◯ | | ◯ | ◯ | ◯ | ◯ | | ◯ |
| Java | ◯ | | ◯ | ◯ | ◯ | | | △ |
| Kotlin | ◯ | ◯ | ◯ | ◯ | ◯ | | ◯ | ◯ |
| Python | | | | | | | △ | ◯ |
| Rust | ◯ | | ◯ | ◯ | ◯ | | | ◯ |
| Scala | ◯ | | ◯ | ◯ | ◯ | ◯ | | ◯ |
| Swift | ◯ | ◯ | ◯ | ◯ | ◯ | | ◯ | ◯ |
| TypeScript | ◯ | | | | | | | ◯ |

  • Java ず Scala は null 安党 な蚀語ではありたせんが、 null を䜿わずに Optional, Option を䜿っお null 安党 なコヌドを曞くこずができたす。そのため、 Optional, Option でどの道具を䜿えるかを瀺すために衚に加えおいたす。
  • Python の ? が △ なのは、 Union[Foo, None] を Optional[Foo] ず衚すシンタックスシュガヌはあるけれども、 Foo? ほど簡朔でないからです。
  • Java の型掚論が △ なのは、ラムダ匏の型は掚論できるけれども倉数の型は掚論できないからです。

null チェックに䌎うキャスト

これたでに芋おきたように、 if 文で null チェックをするず、その if 文の {} の䞭では String? が String ずしお扱われるキャストされるずいう仕組みがありたした。この仕組みは スマヌトキャスト (Smart cast) (Kotlin), 制埡フロヌ解析 (Control flow analysis) (TypeScript), Flow-sensitive typing (Ceylon) などず呌ばれおいたす。以䞋、本投皿では スマヌトキャスト ず呌びたす。

スマヌトキャスト がないず、 null チェックをしおも s は String? のたたです。 s が String? のたただず、 null チェックをしおも結局 s.length でコンパむル゚ラヌになっおしたいたす。 length にアクセスするには s を匷制的に String にキャストしなければなりたせん。

// Kotlin
val s: String? = null
if (s != null) {
  (s as String).length // String にキャストしおから s を䜿う
}

しかし、これだずもし null チェックを忘れおもコンパむルが通っおしたいたす。

// Kotlin
val s: String? = null
(s as String).length // 実行時゚ラヌ

s は null なので、䞊蚘のコヌドは String にキャストしようずしたずきに実行時゚ラヌになりたす。 nullable ず non-null によっお、せっかくコンパむル時に null による゚ラヌを怜出できるようになったのに、これでは意味がありたせん。

このように、 null チェックず non-null ぞのキャストが独立しおいるず、キャストの倱敗による゚ラヌが実行時に発生したす。 null チェックず non-null ぞのキャストをセットで行う仕組みは null 安党 を実珟する䞊で欠かせたぜん。

䌌たような仕組みずしお、 Swift や Rust には if let (Optional binding) が、 Java の Optional には ifPresent メ゜ッドがありたす。 Haskell や Scala では パタヌンマッチング を䜿いたす。どれも スマヌトキャスト ずは異なる仕組みですが、やりたいこずは null チェックの条件分岐ず non-null ぞのキャストずいう意味では同じです。

!, !!

どうしおも null である可胜性を無芖しお nullable を non-null に倉換したいこずもありたす。

䟋ずしお、テキストフィヌルドに入力された文字列を敎数に倉換する凊理を考えたしょう。䞀般的に、文字列から敎数ぞの倉換は倱敗する可胜性がありたす。 "123" は 123 に倉換できたすが "ABC" は敎数に倉換できたせん。倉換に倱敗した堎合には null を返すずするず、文字列を敎数に倉換する凊理は String から Int? ぞの倉換だず考えられたす。

// Swift
let number: Int? = Int(text)

しかし、テキストフィヌルドに制玄が加えられおいお数字しか入力できないこずもありたす。そのようなケヌスでは文字列から敎数ぞの倉換に倱敗するこずはありたせん。それでも、テキストフィヌルドから埗られるのは文字列なので、型の䞊では敎数ぞの倉換が必芁ずなりたす。

// Swift
if let number: Int = number { // null チェック
  // ここでは number を Int ずしお䜿える
}

必ず null でないずわかっおいる堎合にも、 null チェックを曞かなければならないのは手間です。 型は䞇胜ではありたせん。ロゞックの䞊では null にならないけれど、型の䞊では nullable になっおしたうこずがしばしばありたす。このたたでは、 null 安党 でない 蚀語では曞かなくお良かった無駄な null チェックを曞かなくおはならないこずになり、生産性が䞋がりかねたせん。 null である可胜性を明瀺的に無芖しお nullable を non-null に倉換する簡単な方法が必芁です。

Swift では nullable な倀の埌ろに ! ずいう埌眮挔算子を付けるこずで、匷制的に non-null に倉換するこずができたす。これを Forced unwrapping ず呌びたす。

// Swift
let number: Int = Int(text)!

number の型が Int? ではなく Int であるこずに泚意しお䞋さい。これは、 ! によっお Int? 型である Int(text) の戻り倀が Int 型に匷制倉換されたからです。

もし、倀が null のずきに ! で non-null に倉換しようずするず実行時゚ラヌずなりたす。 ! を乱甚しおはいけたせん。䞊蚘の䟋のように 絶察に null にならないけれども型の䞊では nullable になっおしたうケヌスや、䜿い捚おのスクリプトで null ならクラッシュしおも良いケヌスなど、 ! が問題を匕き起こさないよう垞に意識的でなければなりたせん。

安党でない操䜜には長い名前を付けるべきだずいう意芋もありたすが、僕はその意芋には反察です。補完があれば長くおも簡単に入力できたす。そしお、 ! はたった 1 文字ですが、プログラマが明瀺的に曞く必芁がありたす。 ! を曞くずきに立ち止たっお、本圓に問題ないケヌスか確認するずいう䜜業を怠らなければ null 安党 を砎壊するこずはありたせん。

TypeScript の ! や Kotlin の !! も同じように nullable を non-null 化する埌眮挔算子です。 Java の Optional クラスや Scala の Option クラスには同じ目的の get メ゜ッドが、 Rust の Option には unwrap メ゜ッドがありたす。それらを適切に䜿うこずで、快適に null 安党 なコヌドを曞くこずができたす。

䜙談ですが、 Swift では Forced unwrapping 以倖にも ! ずいう蚘号は危険な凊理に甚いられるこずが䞀貫されおおり、 ! を曞くずきに垞に意識的でいやすいです。察しお、䟋えば Java では get ずいうメ゜ッドが安党な凊理 Map の get メ゜ッド等でも䜿われおおり、 Swift ず比范するず危険な凊理であるこずを意識しづらいのではないかず思いたす。ロゞカルには二぀のやっおいるこずは同じですが、芖芚的・感芚的に蚎えるこずのできる Swift のような蚀語デザむンは玠晎らしいず思いたす。

?., ?->

nullable な倀のメンバやメ゜ッドにアクセスしたい、ただし、倀が null の堎合は結果も null でいいずいうのもよくあるケヌスです。愚盎に曞くず次のようになりたす 6 。

// Kotlin
val s: String? = null
val length: Int?
if (s != null) {
  length = s.length
} else {
  length = null
}

length を取埗するためだけにこの分岐を曞くのは倧倉です。 Swift や Kotlin, Ceylon, Hack などの ?.  Swift では Optional chaining ず呌びたすを䜿えばこれを簡単に実珟できたす Hack では . の代わりに -> を䜿うので ?-> です。

// Kotlin
val s: String? = null
val length: Int? = s?.length // s が null なら結果も null

特に、 ?. は null になるかもしれない操䜜をチェヌンするずきに重宝したす。

// Kotlin
val baz: Baz? = foo?.bar?.baz

これを null チェックず条件分岐で曞こうずするず次のようになりたす。

// Kotlin
val baz: Baz?
if (foo != null) {
  val bar: Bar? = foo.bar
  if (bar != null) {
    baz = bar.baz
  } else {
    baz = null
  }
} else {
  baz = null
}

?. によっお、 null チェックによる耇雑な条件分岐を曞かかずに簡朔なコヌドで枈たせられたす。

?:, ??

null の堎合にデフォルト倀を䞎えたいずいうのもよくあるケヌスです。

// Kotlin
val s: String? = null
val length: Int
if (s != null) {
  length = s.length
} else {
  length = 0 // デフォルト倀 0 を䞎える
}

Kotlin の ?: 挔算子や Swift の ?? 挔算子を䜿えばこれを簡単に曞けたす。

// Kotlin
val s: String? = null
val length: Int = s?.length ?: 0 // デフォルト倀 0 を䞎える

Java の Optional の orElse メ゜ッドも同様の働きをしたす。

map

?. は匷力な構文ですが、 nullable な倀を挔算子のオペランドにしたり、関数やメ゜ッドの匕数に枡したいずきには圹に立ちたせん。

たずえば、 Int? を二乗するこずを考えおみたしょう。 ?. ず同じように元の倀が null のずきは結果ずしお null を埗たいずしたす。

もし、 square 二乗するずいうメ゜ッドがあれば次のように曞けたす。

// Swift
let number: Int? = nil
let squared: Int? = number?.square()

しかし * 挔算子で number * number のように曞こうずするず ?. ではうたく曞けたせん。

// Swift
let number: Int? = nil
let squared: Int? = number?. * number?. // コンパむル゚ラヌ

これを null チェックず条件分岐で曞くず次のようになりたす。

// Swift
let number: Int? = nil
let squared: Int?
if let number: Int = number { // null (nil) チェック
  squared = number * number
} else {
  squared = null
}

ずおも面倒です。こういう堎合には、 map ずいう高階メ゜ッドが圹立ちたす。

// Swift
let number: Int? = nil
let squared: Int? = number.map { $0 * $0 }

Swift を知らないず number.map { $0 * $0 } ずいう衚蚘が䜕を衚しおいるのかわかりづらいず思いたすが、これは JavaScript の number.map(function(x) { return x * x; }) たたは number.map(x => x * x) 、 Java の number.map(x -> x * x) に盞圓したす。

map メ゜ッドに枡されたラムダ匏は、 Optional の倀が nil でない堎合だけ実行され、 map の結果ずしお返されたす。ラムダ匏の匕数に枡されるのは non-null 化された倀です。もし Optional の倀が nil であれば結果も nil になりたす。

Java の Optional や Scala, Rust の Option の map メ゜ッド、 Haskell の Maybe の fmap も同様の挙動をしたす。 Kotlin では nullable に map メ゜ッドはないですが、 ?. ず let メ゜ッドを組み合わせるこずで number?.let { it * it } ず曞くこずができたす。

flatMap

前述の文字列から敎数ぞの倉換

// Swift
let number: Int? = Int(text)


の `text` が `String` ではなく `String?`だったらどうでしょうか。敎数ぞの倉換が `Int?` を返すので、 `map` で曞くず `Optional` がネストしお戻り倀の型が `Int??` になっおしたいたす。

```swift
// Swift
let text: String? = nil
let number: Int?? = text.map { Int($0) }

Int?? がネストしおいる郚分です。今ほしいのは Int? なのでこのたたではダメです。

flatMap は map ず䌌おいたすが、ネストした Optional を䞀重に朰しおフラットにしお返しおくれたす。

// Swift
let text: String? = null
let number: Int? = text.flatMap { Int($0) }

Java の Optional や Scala の Option の flatMap メ゜ッド、 Rust の Option の and_then 、 Haskell の Maybe の >>= 挔算子も同様の挙動をしたす。

実は map ず flatMap があれば ?. でできるこずはすべおできたす。 ?. は map ず flatMap をより簡単に曞くための衚蚘だず蚀えるでしょう。 map ず flatMap は ?. ではカバヌできないケヌスに察応可胜なより柔軟な仕組みずしお重芁です。

なお、 Kotlin や Ceylon, TypeScript, Python では nullable をネストするこずができたせん。詳しくは埌述したすが、たずえば Kotlin の Int?? は Int? ず等䟡になりたす。そのため、これらの蚀語では map ず flatMap が等䟡になりたす。 Kotlin では flatMap 盞圓のこずをするのにも、 map ず同じく ?.let で代替できたす。

do 蚘法

a: Int? ず b: Int? があったずきに、 a ず b を足すにはどうすればいいでしょうか。䟋によっお、 a か b のどちらかが null だった堎合は結果ずしお null を埗たいずしたす。

null チェックをしお条件分岐は面倒なので、 flatMap ず map を䜿っお曞いおみたす。

// Swift
let a: Int? = 2
let b: Int? = 3
let sum: Int? = a.flatMap { x in b.map { y in x + y } }

a.flatMap { x in b.map { y in x + y } } は、 JavaScript なら a.flatMap(x => b.map(y => x + y)) 、 Java なら a.flatMap(x -> b.map(y -> x + y)) ずいう意味です。

曞けないこずはないですが、ラムダ匏をネストするのは少々読みづらいです。 Haskell では do 蚘法を䜿い、より簡朔に蚘述できたす。

do 蚘法は flatMap のネストを簡朔に曞くための蚘法です。 map が混ざっおいおはいけないので、たずは map を flatMap で曞き倉えおみたしょう。

// Swift
let sum: Int? = a.flatMap { x in b.flatMap { y in .some(x + y) } }

.some(x + y) は、 Int 型である x + y の結果を Optional で包んで Int? 型にするための凊理です。これを Haskell で曞くず次のようになりたす。

-- Haskell
sum = a >>= (\x -> b >>= (\y -> Just (x + y)))

>>= は Swift の flatMap に、 Just は .some に圓たりたす。 do 蚘法を䜿うず、このコヌドを次のように曞き倉えられたす。 do 蚘法は >>= のシンタックスシュガヌなので、この二぀のコヌドは等䟡です。

-- Haskell
sum = do
  x <- a
  y <- b
  return (x + y)

<- は do 蚘法で甚いられ、䞊蚘のコヌドでは nullable な a, b を non-null な x, y に倉換しおいたす。 non-null に倉換さえできれば最埌に x + y を蚈算するだけです。 >>=  flatMap をネストするよりずっずわかりやすいず思いたす。

Scala にも同様の仕組みがありたす。

// Scala
val a = Option(2)
val b = Option(3)

val sum = for {
  x <- a
  y <- b
} yield x + y

これたでの関係をたずめるず、

  • 倚くのケヌスで簡朔な ?. を䜿う
  • 䞀郚のケヌスでは ?. では曞けないので、䞊䜍互換の map や flatMap を䜿う
  • flatMap がネストするずわかりづらいので do 蚘法を䜿う

ずなりたす。ただし、これは蚀語暪断的な話で、 Haskell や Scala に ?. はないですし、 Swift や Kotlin には do 蚘法がありたせん。実甚䞊はその蚀語で欠けおいる郚分を諊めお別の方法で劥協する必芁がありたす。

?

Swift や Kotlin, Ceylon, Hack, Flow などの蚀語では、型名に ? を付けお nullable な型を衚したす。 nullable な型を曞く機䌚は倚いので、簡朔な蚘法が甚意されおいるのはうれしいずころです。

Foo? は、 Swift では Optional<Foo> の、 Ceylon では Foo|Null のシンタックスシュガヌです。 Kotlin のように ? が盎接的に nullable であるこずを衚す蚀語仕様なら ? の存圚は必須ですが、そうでなくおも ? がシンタックスシュガヌずしお甚意されおいれば䟿利です。

TypeScript には、残念ながら 2.0 時点でこのようなシンタックスシュガヌはありたせん。 Crystal にもありたせんが、 Crystal のように極力コヌド䞭に型を曞かず掚論させる蚀語であれば䞍芁だず思いたす。

型掚論

盎接的に null 安党 に関わっおいるわけではないですが、僕は 型掚論 も null 安党 を快適にするために重芁だず考えおいたす。

null 安党 は、 null に関する゚ラヌを型を䜿っおコンパむル時たたは静的解析時に怜出する仕組みです。そのため、蚀語に静的型付けであるこずを匷制したす。しかし、 null 安党 のために動的型付けの曞き心地が損なわれおしたっおは、 null 安党 を取るのか、動的型付けの曞き心地を取るのかずいう話になっおしたいたす。

静的型付けでも、 型掚論 で倉数や匕数、戻り倀の型を曞かなくおよいのであれば、動的型付けに近い曞き心地を実珟できたす。

// Swift 型掚論なし
let numbers: [Int] = [2, 3, 5]
let squares: [Int] = numbers.map { (x: Int) -> Int in x * x }
// Swift 型掚論あり
let numbers = [2, 3, 5]
let squares = numbers.map { $0 * $0 }
// JavaScript
let numbers = [2, 3, 5];
let squares = numbers.map(x => x * x);

静的型付けの Swift でも型掚論があれば、動的型付けの JavaScript ず同じような簡朔さでコヌドが曞けおいるのがわかるず思いたす。

nullable の皮類ず特城

䞀口に nullable ず蚀っおもその実珟方法は様々です。しかし、倧きく分けるず二぀に分けられたす。それは nullable な型をネストできるかできないかです。

ネストできる

  • Haskell
  • Java
  • Rust
  • Scala
  • Swift

ネストできない

  • Ceylon
  • Crystal
  • Hack
  • Kotlin
  • Python
  • TypeScript

nullable な型をネストした Foo?? ずいう型は䜕を衚すのでしょうか。もし Foo? を単に Foo か null を入れられる型だず考えるず、 Foo?? であっおも null を入れられるずいう性質を二重に蚘述しおいるだけになり Foo? ず倉わらないように思えたす。

Foo?? が䜕の圹に立぀のかは䟋を芋おみるのが䞀番です。最も身近な䟋の䞀぀は、 Map や Dictionary 、ハッシュを䜿うずきです。

Kotlin や Java の Map<K, V> は K 型のキヌで V 型の倀を匕くためのクラスです。キヌで倀を匕くず、キヌに察応した倀が存圚する堎合ずしない堎合がありたす。キヌが存圚しない堎合は null を返したいので、戻り倀の型は V? になりたす。䟋えば、 Map<String, Int> なら String 型のキヌで倀を匕き、戻り倀ずしお Int? を埗たす。

// Kotlin
val map: Map<String, Int> = mapOf("a" to 2, "b" to 3, "d" to 5)
map["a"] // 2
map["e"] // null キヌ "e" に察応した倀が存圚しない

では、倀ずしお null も栌玍したい堎合はどうなるでしょうか。぀たり、 Int? を V ずし、 Map<String, Int?> ずしたいずいうこずです。このずき、キヌで倀を匕いた戻り倀の型は、 V? の V が Int? なので Int?? になりたす。しかし、 Kotlin では ? は null を代入できるかどうかを衚すだけなので、 Int?? は Int か null か null か、ずいう意味になり Int? ず同䞀です。その結果、

// Kotlin
val map: Map<String, Int?> = mapOf("a" to 2, "b" to 3, "c" to null, "d" to 5)
map["a"] // 2
map["c"] // null キヌ "c" に察応した倀 null 
map["e"] // null キヌ "e" に察応した倀が存圚しない

ずなり、 null ずいう倀が返されたのか、倀が存圚しなかったのかを区別するこずができたせん。

もし nullable な型をネストできれば話は違いたす。 Swift では Int?? ず Int? が区別され、次のようになりたす。

// Swift
let map: [String: Int?] = ["a": 2, "b": 3, "c": nil, "d": 5]
map["a"] // Optional(Optional(2))
map["c"] // Optional(nil)
map["e"] // nil

これなら、 nil ずいう倀が存圚したのか、それずも倀が存圚しなかったのかで分岐するこずができたす。

// Swift
if let c: Int? = map["c"] {
  if let c: Int = c {
    // nil でない倀が存圚した堎合
  } else {
    // 倀 nil が存圚した堎合
  }
} else {
  // キヌに察応した倀が存圚しなかった堎合
}

nullable な型がネストできるずいうこずはそれだけ衚珟力が高いずいうこずです。ですので、僕は䞀般論ずしおはネストできる方が望たしいず考えおいたす。ただ、パフォヌマンスや蚀語仕様、実行環境ずの盞性などを考慮するず、䜕がベストかは䞀抂には蚀えたせん。たずえ nullable な型をネストするこずができなくおも null 安党 の魅力を倧きく損ねるわけではありたせん。たたに䞍䟿なケヌスがある皋床です。

本節ではさらに詳しく、それぞれの蚀語で nullable な型がどのように実珟されおいるのか芋おいきたす。仕組みを知れば、なぜ nullable な型をネストできる蚀語ずできない蚀語があるのかも理解できるず思いたす。

nullable か non-null かだけを区別

䞀番単玔な方法で、型に ? を぀けるず nullable に、そうでなければ non-null になるずいう方法です。 Kotlin や Hack が採甚しおいたす。ある型 Foo に ? を぀けお Foo? ずするず Hack では ?Foo 、 Foo? 型の倉数には Foo むンスタンスの他に null も代入できたす。

// Kotlin
val s1: String = null // コンパむル゚ラヌ
val s2: String? = null // OK

この堎合、 Foo?? のように nullable な型をネストしおも、 Foo か null か null ずいうこずを衚すだけであり、 Foo か null 、぀たり Foo? ず蚀っおいるのず同じです。そのため、 Foo?? ず Foo? は同じ型を衚したす。

nullable な型をネストできないのは䞍䟿なずきもありたすが、 Kotlin においおは劥圓な遞択だったんじゃないかず思いたす。 Kotlin は "100% interoperable with Java" を謳う Java 仮想マシン䞊で動䜜する蚀語です。 Java には null が存圚し、その Java ずの連携を考えるず、この実装は自然で理にかなっおいるず思いたす。

Union type

Ceylon や TypeScript, Python, Crystal が採甚しおいるのがこの方匏です。これらの蚀語の型システムには Union type が存圚しおおり、それを䜿っお nullable を実珟しおいたす。 Union Type ずは耇数の型のいずれかを衚す型です。たずえば、 Foo|Bar のようにしお Foo たたは Bar を代入可胜な型を䜜りたす Python では Union[Foo, Bar]。

Ceylon では Foo|Null, TypeScript では Foo|null, Python では Union[Foo, None] のようにしお nullable な型を衚したす。 Ceylon の null は Null 型の倀、 TypeScript の null は null 型の倀、 Python の None は None 型の倀ずしお扱われたす。

// Ceylon
Foo|Null foo = null;
// TypeScript
let foo: Foo|null = null;
# Python
foo = None # type: Union[Foo, None]

Foo|Null が Foo 型の倀か null かを代入できるずいうのは自然な衚珟です。蚀語仕様ずしお Union type を持぀なら、 Union type で nullable を衚珟するのは自然だず思いたす。

なお、 Ceylon や Python には、 Foo|Null や Union[Foo, None] をより簡朔に蚘述するためのシンタックスシュガヌが甚意されおいたす。 Ceylon では Foo? は Foo|Null ず、 Python では Optional[Foo] は Union[Foo, None] ず等䟡です。䞊蚘のコヌドは次のようにも曞けたす。

// Ceylon
Foo? foo = null;
# Python
foo = None # type: Optional[Foo]

TypeScript にはこのようなシンタックスシュガヌはないので単玔に string|null のようにしお nullable であるこずを衚したす。 Crystal にもシンタックスシュガヌがないですが、前述のように、 Crystal では型を明蚘するこずがほずんどないので問題にならないず思いたす。

Union type で nullable を衚す堎合もネストするこずはできたせん。 Kotlin のずきず同じで、 Foo|Null|Null (Foo??) は Foo か Null か Null かなので、 Foo|Null (Foo?) 、぀たり Foo か Null かず同䞀です。匏倉換で曞くず Foo?? == (Foo?)? == (Foo|Null)|Null == Foo|Null|Null == Foo|Null == Foo? ず曞けたす。

Tagged union

Swift や Rust, Haskell が採甚しおいるのがこの方法です。 Swift でも Foo? のようにしお nullable な型を衚したすが、倀を持぀ずきは some 、持たないずきは none ずいうタグが付けられおいたす。 Union type 颚に曞くず、 Foo? が some(Foo)|none ず衚されるようなむメヌゞです。タグ付きの Union なので Tagged union ず呌ばれたす。

nullable を衚す Swift の Optional ず Haskell の Maybe は次のように宣蚀されおいたす。

// Swift
enum Optional<T> {
  case none
  case some(T)
}
-- haskell
data Maybe a = Nothing | Just a

Swift では none ず some が、 Haskell では Nothing ず Just がタグです。

タグがあるこずで nullable な型をネストできるようになりたす。 Foo?? == (Foo?)? == some(some(Foo)|none)|none なので、明確に倖偎の ? が none なのか、内偎の ? が none なのかを区別するこずができたす。

Union type 同様、 Tagged union で nullable な型を衚すのも、盎接的に倀があるかないかを衚しおいるので自然です。蚀語仕様ずしお Tagged union を持぀なら、ネストでき、自然な衚珟である Tagged union で nullable な型を衚すのが望たしいず思いたす。

クラスや構造䜓

Java の Optional や Scala の Option はクラスで実珟されおいたす。

Java の Optional は単玔にフィヌルドに倀を保持し、それが null かどうかでメ゜ッドの挙動が倉化するようになっおいたす。 Scala はおもしろくお、抜象クラス Option を継承した具象クラス Some ず None ずしお実装され、ポリモヌフィズムで挙動が切り替わるようになっおいたす。オブゞェクト指向的には Scala の方がキレむな実装なように感じたす。

Java の Optional の isPresent メ゜ッドは次のように実装されおいたす。

// Java
public boolean isPresent() {
  return value != null;
}

しかし、 Scala の Option の isEmpty は Some ず None でそれぞれ実装されおいたす。

// Scala
final case class Some[+A](x: A) extends Option[A] {
  def isEmpty = false
}
case object None extends Option[Nothing] {
  def isEmpty = true
}

false, true を返しおいるだけで条件分岐はありたせん。ただし、 Scala がポリモヌフィズムで切り分けおいるのは isEmpty だけです。 map や flatMap など、その他のメ゜ッドは条件分岐で蚘述されおいたす 7 。やろうず思えばすべおのメ゜ッドの挙動をポリモヌフィズムで切り替えられたす 8 が、おそらくパフォヌマンス䞊の条件分岐があっおも静的ディスパッチした方が速いずいう理由で条件分岐で曞かれおいるのだず思いたす。

なお、 Java の Optional を Scala の Option のように継承でサブクラスを䜜れなかったのは、 Java に sealed class がないからだず思われたす。もし、 Java で Optional を継承しお Some ず None を䜜ろうずするず、 Optional を final クラスにするこずができないので Some ず None の他にも Optional のサブクラスを䜜れおしたいたす。 Scala の sealed class は継承を限定できるので Some ず None 以倖に Option のサブクラスを䜜るこずはできたせん。

この方法であれば、 Optional はただのゞェネリックなクラスなので Optional<Optional<Foo>> ずしお問題なくネストできたす。

远蚘: コメントで @kmizu さんにご指摘いただいた通り、 Scala や Kotlin の sealed class は Tagged union を䜜る手段なので、 Scala の Option は Tagged union ずも蚀えたす。詳しくはコメント欄を埡芧䞋さい。

蚀語別雑感

今床は蚀語別に null 安党 に関連した雑感を述べたす。

  • C#
  • C++
  • Crystal
  • Go
  • Java
  • JavaScript
  • Kotlin
  • Objective-C
  • Python
  • Ruby
  • Scala
  • Swift
  • TypeScript

C#

C# の T? (Nullable<T>) は本投皿で芋おきた nullable ずよく䌌おいるように芋えたすが、 T ずしお倀型しかずれないずいう問題がありたす。たた、 nullable な倀のメンバにアクセスしおもコンパむル゚ラヌずなりたせん。これが参照型に拡匵され、静的に型チェックされ、参照型の T が non-null 化されれば null 安党 な蚀語ずなりたす。

珟状では䞭途半端で残念な仕様ですが、 C# はこれたでも先進的な仕様を取り入れおきた蚀語であり、たた null 安党 になった TypeScript ず同じ開発者が関わっおいるので、今埌 null 安党 になるこずを期埅しおいたす。

远蚘: @gorn708 さんから補足コメントをいただきたした。

次のC#のバヌゞョンだずこの蟺が本件の関連ですかね。
https://github.com/dotnet/roslyn/blob/features/NullableReferenceTypes/docs/features/NullableReferenceTypes/Nullable%20reference%20types.md

この Proposal が採甚されお、 C# が null 安党 に䞀歩近づくずいいですね。

C++

C++17 で std::optional が導入されたす。しかし、それだけで null 安党 になるわけではありたせん。既存のコヌドベヌスが巚倧なので、すべおが std::optional に察応しお、 C++ が null 安党 になるずいうのは珟実的ではないでしょう。そもそも、そういうこずを目指しおいる蚀語でもないず思うので、それでいいのかもしれたせんが。

Crystal

基本的に型を曞かずに掚論させるずいう方針は Ruby 的な蚀語仕様ず盞性が良さそうです。しかし、 Ruby ず連携せずにどこたで Ruby プログラマを取り蟌めるかが普及するかの分かれ目になっおきそうです。ただ 1.0 がリリヌスされおいないので、今埌の展開に泚目です。

Go

Go は過去 10 幎で登堎した人気蚀語の䞭ではめずらしく null 安党 でない 蚀語です。

僕は Go に詳しくないですが、 Go はこれたでのプログラミング蚀語の進化に逆らっお、倧胆に仕様を削ぎ萜ずしおシンプルであるこずを目指した蚀語だず理解しおたす。ゞェネリクスがなくおも型付けされた配列やマップがあれば倧䜓問題ないでしょ的な。

しかし、 Kotlin のように単に nullable ず non-null を区別するだけであれば、蚀語仕様も倧しお耇雑化しないず思うので、是非取り入れお欲しいずころです。身近に Go に粟通した人がいないので、 Go プログラマがどう感じおいるのか聞いおみたいです。

Java

Java 8 で Optional が远加されたしたが、 Java で nullable をすべお Optional にしようずいうのは無理がありたす。暙準ラむブラリレベルで null を返すものがたくさんあるので、結局混ざっおしたいたす。䟋えば、 Map の get メ゜ッドはキヌに察応する倀がなければ null を返したす。 null 安党 な蚀語では nullable になっおいるずころです。たた、 Java の Optional はフィヌルドに䜿わない方がいい 9 ずいう話もあり、そもそもが null を代替できるものではありたせん。

別のアプロヌチずしお、 JSR 305 10 が進めばアノテヌションで non-null チェックできるようになるかもしれたせん。暙準ラむブラリに片っ端から @NonNull を぀けおくれれば倧分楜になりそうです。ただ、しばらくは JSR 305 の暙準化も期埅できないので、サヌドパヌティの @NonNull 的なものでがんばるしかないのでしょうか。たずえ @NonNull が暙準になっおも、本投皿で挙げた「快適に曞くための仕組み」があるわけではないですし、蟛い状況は続きそうです。

JavaScript

型アノテヌションに関する話もある 11 12 13 ようですが、近いうちに採甚される芋蟌みはほがなさそうです。 null 安党 は曎にその先の話になるので、 JavaScript を null 安党 に曞きたいなら、しばらくは TypeScript か Flow を䜿うのが珟実的だず思いたす。

Kotlin

蚀語自䜓の問題ではないですが、 Swift が Objective-C の蚀語仕様に手を入れるこずで Objective-C ずの連携を改善しお、 Objective-C ずの境界でも null 安党 なコヌドを曞けるようになっおきおいるのに察しお、 Kotlin ず Java の境界では null 安党 が砎壊されおしたう状況が蟛いです。このあたりは、同じ組織が䞡蚀語を開発しおいるかどうかの差が倧きそうです。前述のように Java が @NonNull を採甚しおくれれば解決するかもしれたせん。

Objective-C

Objective-C はめずらしく、 nil に察しおメ゜ッドコヌルしたり、 nil のプロパティにアクセスしたりしおも゚ラヌにはならない蚀語です。

Foo *foo = nil;
NSString *bar = foo.bar; // OK: bar == nil

しかし、これは null 安党 ずいうこずではありたせん。い぀でも nil が実行時゚ラヌを起こさないわけではなく、この bar を次のように䜿うず実行時゚ラヌずなりたす。

NSURL *url = [[NSURL alloc] initWithString: bar]; // 'NSInvalidArgumentException', reason: '*** -[NSURL initWithString:relativeToURL:]: nil string parameter'

Objective-C の nil の扱いは䞀芋安党なように芋えお、問題の発芚を遅らせ、解決をより難しくしおいるだけです。朜圚バグを生みやすいずいう点で、僕は Objective-C 方匏は最悪だず考えおいたす。か぀お、 Objective-C で曞いたプログラムを Java に移怍したずきに、 Java で NullPointerException が発生しお初めお Objective-C 偎の nil ハンドリングが䞍適切だったこずに気付くずいうこずが䜕床もありたした。

Swift が安定しおきた今、もはや Swift を䜿わずに Objective-C を䜿う理由はほがないように思いたす。 C++ 連携したいのでもない限り Swift を䜿いたしょう。

Python

Python の蚀語仕様に型ヒント 14 が取り入れられるのは 3.5 からですが、コメント構文を䜿うこずで Python 2 でも型ヒントを蚘述し null 安党 なコヌドを曞くこずができたす。

# Python 3
def to_int(s: str) -> Optional[int]:
# Python 2
def to_int(s): # type: (str) -> Optional[int]

型ヒント やコメント構文で蚘述された型は mypy 15 16 を䜿っおチェックしたす。 mypy は Python の静的型チェッカヌです。 Python 2 でも䜿える 17 ずいうこずは、すべおの Python プログラマが今すぐでも null 安党 なコヌドを曞けるずいうこずです。

なお、 mypy は珟状ではデフォルトで null 安党 なモヌドになっおいないので、 null 安党 にするには

mypy --strict-optional foo.py

のように --strict-optional オプションを指定する必芁がありたす 18 。

Python の Optional にはただ「快適に曞くための仕組み」のほずんどありたせん。関連する Proposal ずしお PEP 505 19 がありたすが、圓面は「快適な仕組み」をあきらめるか、自力で関数を䜜っお再珟する必芁があるでしょう。

Ruby

静的型付 + 型掚論が流行り、倚くの動的型付蚀語も型アノテヌションを取り入れる䞭、䞀向にその動きが芋えなかった Ruby ですが、 RubyKaigi 2016 の Matz の講挔 20 で静的に型掚論する話が取り䞊げられたした。これがどういうものになるかはただわかりたせんが、 null 安党 のためには静的型が欠かせないので歓迎です。もし、 Ruby 3 に null 安党 も取り入れられればうれしいですね。

Scala

僕は Scala をほずんど觊ったこずがないので、 Scala で null がどのように扱われおいるのか長い間疑問だったんですが、次のツむヌトで疑問が解けたした。

Scala は蚀語仕様的には null 安党 でないけれども、 null を䜿わずにすべお Option に統䞀するずいう文化によっお null 安党 を実珟しおいるようです。

Swift

ここに挙げた蚀語の䞭では nullable な型を䞀番快適に䜿える蚀語だず思いたす。「快適に曞くための仕組み」が充実しおいるこずに加え、連携先の蚀語 Swift の堎合は Objective-C 偎を修正するこずで、 null 安党 でない Objective-C ずの境界でも null 安党 なコヌドを曞けるようになっおいるこずが倧きいです。䞡方の蚀語を Apple が䞻導しおいるからこそできる芞圓です。

TypeScript

TypeScript 2.0 で null 安党 な蚀語に進化を遂げたした。ただし、今のずころデフォルトでは null 安党 なモヌドになっお いない ので、 --strictNullChecks フラグをオンにする必芁がありたす。 6

null 安党 になったずは蚀うものの、今のずころ Python 同様「快適に曞くための仕組み」がほがありたせん。䟋えば、 ?. は JavaScript 埅ちのようです 21 。将来的な発展に期埅です。

null 安党な蚀語の始め方

null 安党 な蚀語が良さそうに芋えおも、既存のコヌドベヌスやラむブラリもあり、今䜿っおいる蚀語を倉曎するずいうのは倧倉な䜜業です。しかし、 null 安党 な蚀語の䞭には既存の蚀語ずシヌムレスに連携しお、䞀぀のプロゞェクトの䞭でミックスしおコヌドを曞けるものもありたす。それなら、新しく曞く郚分だけを null 安党 な蚀語で曞き始めるこずもできたす。

本節では、次の null 安党 でない 蚀語を䜿っおいる人を察象に、できるだけ簡単に null 安党 な蚀語を䜿い始めるための方法を述べたす。

蚀語 null 安党 な蚀語の導入しやすさ
Java ◯
JavaScript ◎
Objective-C ◯
Python ◎
Ruby △

ただし、マヌクの意味は次の通りです。

マヌク 意味
◎ 既存コヌドに察しお付加的であり、問題が起こっおもすぐに元に戻すこずができる。導入のための障害はほが存圚しない。
◯ 既存コヌドずシヌムレスに連携するこずができる。ただし、新しい蚀語で曞いたコヌドは新しい蚀語ずしおメンテする必芁はある。新しい蚀語は蚀語仕様が倉化しがちなので、メンテコストは既存コヌドより盞察的に高くなるこずが倚い。
△ 既存のコヌドず連携するこずはできない。䜿い捚おのスクリプトや詊隓的なプロゞェクトなど利甚できるケヌスが限定的。

Java

Java の既存コヌドず連携できお null 安党 なコヌドを曞ける蚀語ずしおは Ceylon, Kotlin, Scala あたりが有名です。僕は特に Kotlin をオススメしたす。

Kotlin は構文が Java ず近く、 Java プログラマにずっお違和感がなく䜿えるず思いたす。 Ceylon はキヌワヌドが特殊なのず、これからあたり流行るず思えないので埮劙です。 Scala に぀いおは関数型蚀語的な考え方など孊ばなければならないこずが倚いず思いたす。

Kotlin ず Java では、それぞれの蚀語で曞かれたクラスやメ゜ッドを互いにシヌムレスに利甚するこずが出来たす。 Java で曞かれたクラスをそのたた Kotlin 偎で䜿ったり継承したりできるので、たずは新しく曞くクラスだけ Kotlin で曞いおみるのがいいず思いたす。

特に、 Android アプリ開発者であれば、 Kotlin は準公匏蚀語のようなものです。 Android Studio は IntelliJ IDEA をベヌスに䜜られおいたすが、 Kotlin は IntelliJ IDEA を開発しおいる JetBrains が䜜った蚀語です。 Android Studio 䞊でも Java ず比べおも遜色ないレベルのサポヌトを受けるこずができたす。 22 23

JavaScript

AltJS は色々ありたすが、無難に TypeScript か Flow を䜿うのがいいず思いたす。 TypeScript ず Flow の䜿い分けは、 @mizchi さんの↓が参考になりたす 24 。

流行っおいるラむブラリのみを組み合わせお䜿う堎合や、バック゚ンドずの連携においお型が十分に提䟛される環境なら、正盎、flowtypeよりtypescriptでいいず思っおいたす。flowtypeが力を発揮する環境は、既存のJSが倧量に存圚する環境や、railsなどの動的な型のフレヌムワヌク環境で、静的な定矩が抜出できない環境だず思いたす。

TypeScript も Flow も JavaScript にトランスパむルされるので、導入埌䜕か問題が起こっおも TypeScript や Flow のコヌドを捚おお、トランスパむル埌の JavaScript コヌドだけ䜿うこずができたす。そのため、既存のプロゞェクトに察しおも導入のハヌドルは䜎いです。

なお、 TypeScript 2.0 の段階ではデフォルトで null 安党 なモヌドになっおいないので泚意しお䞋さい。 null 安党 なモヌドにするには、 --strictNullChecks を指定する必芁がありたす。デフォルトではないですが、垞に --strictNullChecks をオンにするこずが掚奚されおいたす。 6

Objective-C

Objective-C ず連携できる null 安党 な蚀語は Swift 䞀択だず思いたす。これたでの Swift は砎壊的倉曎が倚く、メンテコストがおそろしくお Swift に移行できなかった人も倚いかもしれたせん。しかし、珟行の Swift 3 からはできるだけ埌方互換が保たれる予定です。僕の勀務先では Swift バヌゞョンアップ時のマむグレヌションコストを差し匕いおも Swift で開発する生産性が勝぀ずいう刀断でこれたでも Swift で開発しおきたしたが、今埌はマむグレヌションコストも小さくなり、たすたす Objective-C を䜿う理由がなくなりそうです。

Swift のコヌドは Objective-C のコヌドず互いに連携するこずができたす。 Objective-C で曞かれたクラスを Swift 偎で継承し、それを Objective-C 偎で䜿うようなこずもできたす。すでに Objective-C のコヌドが存圚するなら、新しく曞く郚分だけを Swift で曞いおみるのがいいず思いたす。 Xcode を䜿っおいるなら、特に新しくむンストヌルしなければならないものはありたせん。

Python

mypy 15 を導入するこずで今すぐにでも Python で null 安党 なコヌドを曞くこずができたす。 Python 2 でも䜿える 17 ので、今すぐ Python 3 に移行できなくおも今すぐ始めるこずができたす。 Python 2 でも䜿えるコメント構文は実行時にはただのコメントずしお解釈され、動䜜に䞀切圱響を䞎えないので、既存のプロゞェクトにも気軜に導入できたす。

mypy ず Python の Gradual Typing に぀いお孊ぶには次の各蚘事が参考になりたす。

  • [翻蚳] Python の静的型、すごい mypy! 16
  • What is Gradual Typing: 挞進的型付けずは䜕か 25
  • Mypy syntax cheat sheet 26
  • PEP 484 -- Type Hints 14

前述のように、 mypy では珟状デフォルトで null 安党 なモヌドになっおいないので、 --strict-optional オプションを指定する必芁がありたす 18 。

Ruby

残念ながら、本節で挙げた他の蚀語ほど、 Ruby の堎合はうたくいきたせん。 Ruby の代替である Crystal は、 Ruby ず構文が䌌おいるだけで Ruby のコヌドず連携するこずができたせん。既存のプロゞェクトの䞀郚だけを Crystal にするずいうのは難しいでしょう。

しかし、独立したスクリプトなら Crystal で曞いおも問題ないはずです。曞けるずころから Crystal を詊しおみるのが良いでしょう。 Amethyst 27 ずいう Rails ラむクな Web フレヌムワヌクもあるので、小芏暡な新芏プロゞェクト等で詊しおみるのも良いかもしれたせん。

FAQ

はおブコメントや Twitter を眺めおいるずきちんず䌝わっおいないず思われるこずがあったので簡単に回答したす。なお、僕ず完党に意芋が同じわけではないですが、 @omochimetaru が同じ趣旚でより倚様な質問に䞁寧に回答しおいるので、䞋蚘で足りなければそちらも埡芧䞋さい。

Q. null 安党がそんなに良いものならずっくに普及しおいるはずでは

A. 良いものでもすぐに普及するずは限りたせん。今では圓たり前になっおいる GC やオブゞェクト指向やラムダ匏、高階関数が倚くの蚀語に取り入れられるたでにどれだけの時間がかかったか思い出しお䞋さい。

Q. null 安党を導入したらよくわかっおない初心者がひどいコヌドを曞いおより悲惚なこずになるのでは

A. この可胜性は吊定できないですが、この論法では新しいものは䜕も導入できないこずになっおしたいたす。䜿いこなすのが著しく難しいものならその指摘も的倖れではないですが、 null 安党 なコヌドを曞く䞊で気を付けなければならないこずはそれほど倚くなく nullable のたた倀を取り回しすぎない、コンパむラを黙らせるだめに ?: 等でテキトヌに倀を䞎えない等、たずえばオブゞェクト指向ず比范しおも難しくないず思いたす。

Q. null オブゞェクトじゃダメなの

A. null オブゞェクトには臎呜的な問題がありたす。それは null 、぀たり倀が存圚しないずきに期埅される挙動は文脈によっお異なるずいうこずです。䟋えば、こちらのコヌドの 58 行目に枡すべき適切な null オブゞェクトを実装するこずはできたせん。 Integer が存圚しないずきに、それが 0 ずしお振る舞っお欲しいのか、 1 ずしお振る舞っお欲しいのかは文脈によっお異なるからです。

Q. 安党性ず生産性のトレヌドオフでは䞀抂に良いものず蚀えないのでは

A. null 安党 は 安党性ず生産性を同時に高めるもの です。詳しくは本文に远蚘したのでそちらを埡芧䞋さい。

Q. null で゚ラヌを扱うず゚ラヌ情報を扱えず蟛くない

A. ゚ラヌ情報が必芁な堎合には null で゚ラヌを衚すべきではないず思いたす。たた、 null のたた取り回すずどこで゚ラヌが発生したのかわからなくなっおしたうので、゚ラヌになる可胜性のある関数が nullable を返す堎合には、できるだけ早い段階で゚ラヌ凊理をすべきです。

Q. Option に぀いお玹介するならモナドに觊れるべきでは

A. モナドに぀いお詳しい人には改めお説明する必芁はないず思いたすし、詳しくない人に察しおモナドの話たでするず混乱するだけかず思い、本投皿では省略したした。

Q. ?. があるから◯◯も null 安党では

A. ?. やそれに類䌌した仕組みを持぀蚀語は倚いですがそしお、 null 安党 な蚀語の ?. も Groovy や CoffeeScript, Dart などの動的型付蚀語由来だず思いたすが、 null 安党 の肝はコンパむル静的解析時に null による゚ラヌを怜出できるこずなので、 ?. だけあっおも null 安党 にはなりたせん。

  1. null 安党 たたは null 安党性 は null safety の蚳語です。 null safety ずいう甚語は䞻に Kotlin コミュニティで䜿われおいるもので、蚀語によっお Optional や Option, Maybe, nullable type などの型で実珟できる、 null が原因で実行時゚ラヌを起こさない性質のこずを衚したす。そのような性質を衚す蚀葉ずしお null 安党 はぎったりだず思うので、本投皿では null 安党 ずいう呌び方を採甚したす。 ↩

  2. Shipping Rust in Firefox ↩

  3. レガシヌコヌド改善ガむドによるレガシヌコヌドの定矩 ↩

  4. non-nullable ず蚀うこずもありたすが TypeScript など、本投皿では Kotlin 流に non-null で統䞀しおいたす。 ↩

  5. アントニヌ・ホヌア - Wikipedia ↩

  6. Kotlin の if 文は匏なのでそのたた戻り倀を代入するこずができたすが、他蚀語のプログラマには銎染みのない䜿い方なのでここでは文ずしお䜿甚しおいたす。 ↩ ↩2 ↩3

  7. Option.scala - scala/scala ↩

  8. Optional.kt - qoncept/kotopt: Kotlin で sealed class を䜿っおポリモヌフィズムで Some ず None の挙動を切り替えた䟋 ↩

  9. OptionalがSerializableではない話ず䜿い方たずめ - きしだのはおな ↩

  10. JSR 305: Annotations for Software Defect Detection ↩

  11. Proposal for types in Harmony ↩

  12. Types (Experimental) - google/traceur-compiler ↩

  13. ES8 Proposal: Optional Static Typing ↩

  14. PEP 484 -- Type Hints ↩ ↩2

  15. mypy ↩ ↩2

  16. [翻蚳] Python の静的型、すごい mypy! ↩ ↩2

  17. mypy: Type checking Python 2 code ↩ ↩2

  18. mypy: Experimental strict optional type and None checking ↩ ↩2

  19. PEP 505 -- None-aware operators ↩

  20. RubyKaigi 2016 基調講挔レポヌト Ruby3 Typing ↩

  21. Suggestion: "safe navigation operator", i.e. x?.y 16 - Microsoft/TypeScript ↩

  22. Getting started with Android and Kotlin ↩

  23. Android開発を受泚したからKotlinをガッツリ䜿っおみたら最高だった ↩

  24. 型なき䞖界のためのflowtype入門 ↩

  25. What is Gradual Typing: 挞進的型付けずは䜕か ↩

  26. Mypy syntax cheat sheet ↩

  27. Codcore/amethyst: Crystal 版の Rails ↩

1971
1724
31

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
1971
1724

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?