As you may have gathered, I have found an interest in Swift. I have always found it easier to pick up new languages by comparing it to the one I know best, Java.

Please note, this series is intended for experienced Java Developers. I will not go into details of Java or its API. Where sensible I will provide relevant links.

Tony Hoare, inventor of null (aka nil), famously proclaimed it to be his “…billion dollar mistake”. This should not be interpreted as null/nil being evil per se, denoting the absence/not-existence of a value is essential for data processing, but rather the absence of sensible language features to handle null/nil values.

To fully appreciate this you have to jump a couple of sentences further: “… More recent programming languages like Spec# have introduced declarations for non-null references. This is the solution, which I rejected in 1965.”

Unlike Java, Optional is an integral part of Swift language. In Swift variables may not be assigned nil (null), either they have to be initialized with a value or declared as an ? optional.

1 2 3 var nonNill : String = "Foo" //may not be nil var optNil : String ? //optional may contain nil var optNonNill : String ? = "Bar" //Bar wrapped in an optional

Any attempt to assign a non-optional variable with a nil value results in a compilation error.



Java on the other hand leaves null handling completely open, the introduction of Optional in Java 8 has provided API level functionality, sadly it has several design flaws which mitigate its usefulness (see Java 8 Optional: What’s the Point? and Why Isn’t Optional Serializable? ).

1 2 3 4 String nullString = null ; //can be null String nonNullString = "Foo" ; Optional optNull = Optional . ofNullable ( null ) ; //optional may contain null Optional optNonNull = Optional . ofNullable ( "Bar" ) ;

Just like in Java optionals have to be unwrapped, this can either be done by force unwrapping the optional with !.

1 2 if optNonNill != nil { print ( optNonNill ) //Optional("Bar")

The preferred way of handling optionals is optional binding, if the value exists it is unwrapped and assigned to a temporary variable/constant.

1 2 3 if let unwrapped = optNonNill { print ( unwrapped ) //Foo }

Force unwrapping a nil optional will still cause a runtime error, and as such should be avoided.

1 2 3 4 5 6 7 var unwarpped : String = optNull ! fatal error : unexpectedly found nil while unwrapping an Optional value Current stack trace : 0 libswiftCore . so 0x00007fe2b790cc90 swift_reportError + 117 1 libswiftCore . so 0x00007fe2b791e1d0 ...

In contrast Java’s null handling can seem rather archaic, with the one exception being Optional in combination with lambdas.

1 2 3 4 5 6 7 8 9 10 11 12 if ( nonNullString != null ) { . . . } if ( optNonNull . isPresent ( ) ) { String value = optNonNull . get ( ) ; . . . } //optional with lambda optNonNull . ifPresent ( x -> { . . . } ) ; optNull . orElseGet ( ( ) -> { . . . } ) ;

In plain vanilla Java code ternary operator are often employed, to assign default values in case of null, with Java 8 Optional you can also use .orElse(...).

1 2 3 4 //Ternary operator String default = nullString != null ? nullString : "" ; String default = optNull . orElse ( "" ) ;

Swift has an explicit nil coalescing operator ??, allowing for easy assignment of default values.

1 2 3 4 5 6 7 var myVal1 : String = optNil ? ? "default" print ( myVal1 ) //default //Optional binding requires an optional even with nil coalescing. if let myVal2 = optNil ? ? Optional ( "default" ) { print ( myVal2 ) //default }

Swift allows optional chaining, enabling the chaining of multiple optional calls. The output will be an optional which may be nil.

1 2 3 4 5 6 7 8 9 var address : Address ? = Address ( street : "Foo Lane" , city : "Bar Town" , postcode : "42" ) var customer : Customer ? = Customer ( surname : "Baz" , firstname : nil , address : address ) let streetLC = customer ? . address ? . street ? . lowercased ( ) print ( streetLC ) //Optional("foo lane") if let streetUC = customer ? . address ? . street ? . uppercased ( ) { print ( streetUC ) //FOO LANE }

Doing the same in Java requires a long chain of multiple null checks, or the use of null objects (see Null Object Pattern).

1 2 3 4 5 if ( customer != null && customer . getAddress ( ) != null && customer . getAddress ( ) . getStreet ( ) != null ) { . . . }

Sadly it is not advisable to use Optional in domain models since they are not Serializable, which makes serializing across system boundaries (e.g. RMI, JAX-RS, JAX-WS, etc…) difficult. It can also wreak havoc when employed in passivatable context in stateful applications (such as CDI).

IBM hosts a public Swift-Sandbox, that allows you to try out Swift. This posts Swift code is published in a sandbox here for you to try out.

The next post will cover Swifts handling of variables, constants and types.

Further Resources:

Swift – The Basics

Swift – Optional Chaining

Understanding Optionals in Swift

Optionals Brocken (Java)

Java 8 Optional: What’s the Point?

IBM Swift Sandbox