Swift 2.0

Error handling model

An advanced error handling model provides clear, expressive syntax for catching and throwing errors. It’s also easy to create your own custom error types so you can describe error cases with clear, meaningful names. The new error model was designed to work
seamlessly with NSError and the Cocoa frameworks. Error handling code now looks like:

func loadData() throws { }

func test() {
do {
try loadData()
} catch {
print(error)
}
}

Availability

You should always use the latest SDK to get access to the latest features, documentation, and API changes, but sometimes your app needs to run on an older OS. Swift 2.0 has built-in availability checking to make it easy to build the best possible app for
each target OS version. The compiler will give you an error when using an API too new for your minimum target OS, and a new keyword lets you wrap blocks of code in a conditional version check to run only on specific OS releases.

Syntax improvements

New syntax features let you write more expressive code while improving consistency across the language. The SDKs have employed new Objective-C features such as generics and nullability annotation to make Swift code even cleaner and safer. Here is just a
sampling of Swift 2.0 enhancements.

Powerful control flow with do,
guard, defer, and repeat
Keyword naming rules unified for functions and methods
Protocol extensions and default implementations
Extended pattern matching to work in if clauses and for loops

Xcode 7 includes a powerful migrator that will help convert your application and playground code to work with the latest syntax improvements in Swift 2.0.

Open Source

Later this year Swift will be released as open source. Swift’s unique combination of elegance, power, and safety has the opportunity to move the entire software industry forward. It is exciting to imagine what we will build together.

Modern

Swift is the result of the latest research on programming languages, combined with decades of experience building Apple platforms. Named parameters brought forward from Objective-C are expressed in a clean syntax that makes APIs in Swift even easier to read
and maintain. Inferred types make code cleaner and less prone to mistakes, while modules eliminate headers and provide namespaces. Memory is managed automatically, and you don’t even need to type semi-colons. All this modern thinking results in a language
that is easy and fun to use.

extension String {
var banana : String {
let shortName = String(dropFirst(characters))
return "\(self) \(self) Bo B\(shortName) Banana Fana Fo F\(shortName)"
}
}

let bananaName = "Jimmy".banana

Swift has many other features to make your code more expressive:

Closures unified with function pointers
Tuples and multiple return values
Generics
Fast and concise iteration over a range or collection

Structs that support methods, extensions, and protocols
Functional programming patterns, e.g., map and filter
Native error handling using try / catch / throw