当我们有代码契约/静态分析时，为什么我们需要Option类型？

Question

When designing a null safe piece of code, what's the better approach?

F# and Scala has Options type that encapsulates null check, but we also have static code analysis tools like code contracts, findbugs.

To me static analysis seems a little cleaner, so what is the reason for Option/Maybe? In particular, what makes it better in preventing NullPointerExceptions/NullReferenceExceptions?

Answer 1

Option is used to model the fact that computation maybe return a value. It doesn't exist merely to encapsulate null check; many functional programming languages such as SML, Haskell don't have null but Option/Maybe are present as useful tools for modeling problems.

To me static analysis seems a little cleaner, so what is the reason for Option/Maybe?

In the context of functional programming, using static analysis to check the absence of values is overkill . Static type checking can do it just fine (with Option ). And the type systems can guarantee absolute correctness while static analysis tools may have false positives.

Another problem with static analysis tools is high cost . It costs a lot to build them (I don't know any good static analysis tools for F# and Scala) and to use them (software purchase, developer training). Admittedly, they are powerful and should be used to catch more subtle errors (which can't be caught by static type checkers) such as index out of bounds, integer overflows, etc.

Answer 2

Option is monadic. A primary benefit is transparent integration into monadic chains of computation, typically using the for comprehension syntax.

Furthermore, I doubt static analysis could even in principle obviate tests for the presence or absence of a value (the Some / None distinction). Offhand my intuition is that it would be the equivalent of the halting problem.

Answer 3

For one thing, static analysis can only work if the API is annotated or full source/bytecode is available.

If you have an API but the actual library implementing it will be decided at runtime, static analysis is helpless.

For another thing, static analysis is intrinsically limited. The limitations of turing completeness apply, which means it can't decide whether something maybe be null or not in all cases.

So, these are all limitations of static analysis, not shared by option types, but option types have an additional advantage: they are monads. That means you can compose computation with them, while you'd have to resort to repeating yourself if limited to if-checks for nullability.

The last statement is probably unclear, but it's the nature of the thing: if you understand how monads are used, you don't need further explanation; if you do not, then explanations won't help you much. The best way to learn the usage of monads is to use it -- same as everything else in programming, really.