What’s new in Swift 3

The Swift Evolution Process

To understand Swift 3, we’re going to first touch on the Swift evolution process before examining the list of changes planned in Swift 3. It’s important to understand how these changes made it into the Swift language, because this is the first time Apple has developed a language in consultation with a larger community of developers, rather than it being limited to Apple’s own engineers. As a result, a broader range of changes have been made in the language than would ordinarily appear.

One of the most impressive aspects of the Swift open source project is how the Swift evolution processes established by Apple allowed users to contribute to version 3. While this report isn’t about the Swift evolution process, it’s necessary to understand it in order to comprehend the way Swift 3 is changing.

The Swift evolution process is designed to give everyone a chance to discuss changes to the Swift language and the Swift standard library, including additions, removals, and modifications to language features and APIs, no matter how small they might be. The evolution process is not for bug fixes, optimizations, and other small improvements; those happen through a more conventional open source contribution process.

Changes proposed through the Swift evolution process must not duplicate existing ones, must be presented to and discussed by the community, and must be presented using a template, before being submitted for review via a GitHub pull request on the Swift evolution project repository. Proposals are typically in support of the goals of upcoming Swift releases, which are defined in advance; otherwise they may be deferred for a future release or rejected. Through this process, complete and reasonable Swift evolution (SE) proposals are numbered (e.g., SE-0004); scheduled for review; and eventually accepted, rejected, deferred, or revised. Once a Swift evolution proposal is accepted, it’s allocated to an upcoming Swift release and scheduled for development by the Swift team.

So, Swift 3, then?

The Swift open source project reports that the primary goal of the Swift 3 release is “to solidify and mature the Swift language and development experience.” Thus they plan to make future versions of Swift, following Swift 3, as source compatible as is reasonably possible. The core goals, in support of the primary goal, are:

To provide API design guidelines

Lots of libraries and APIs for Swift have already been created by the community, and with Swift 3, the team saw fit to create a set of guidelines for the naming and design of APIs to assist in this.

To establish naming guidelines and Swiftification for key APIs and Objective-C APIs

Objective-C APIs that get imported are designed for an improved Swift programming experience and are automatically mapped to names complying with the Swift naming guidelines; and the Swift standard library itself now complies with the new API design guidelines.

To refine the language

In line with the objective of making Swift 3 the last release to have major changes that break source code compatibility, there are refinements to the syntax and semantics as a whole (e.g., parameter labels and the type system).

To improve the tooling

Swift was created by compiler and language design academics, and performance of the compiled output is a focus of the Swift 3 release.

To improve portability to non-Apple platforms

The Swift language is designed to be adopted and used across a myriad platforms, and a useful, functional version for Linux is already available. Swift on the server will enable a lot of interesting projects, and we’ll touch on some of them later on in this report.

Swift 3’s focus is on stability and ease of use of the language. Judging from the changes that were made from Swift 2, we can see a clear indication of the direction that Apple’s taking: one in which the community is working to improve the language, which itself is becoming cleaner and more expressive and enjoyable to write in.

Using the New Stuff

In this report, we’ve selected some of the most important, impactful, or otherwise interesting changes that are being made to the language in version 3. Here’s the list:

• The API guidelines are applied to the Swift standard library.

• The ++ and -- operators have been removed.

• C-style for-loops have been removed.

• libdispatch now has a nicer, Swiftier API.

• First parameters in functions now have labels.

• Foundation types are now imported as Swift types.

• Objective-C lightweight generic types are imported as Swift generic types.

• Function parameters may no longer be variables, and are now always constants.

• Selectors and key paths are now type-checked.

• UpperCamelCase has become lowerCamelCase for enums and properties.

• M_PI is now Float.pi.

• Some symbols have been deprecated.

• Functions can be marked as having a result that can be ignored.

• Debugging identifiers have been made nicer.

Let’s take a look at each of these, one by one, to get a better idea of how they impact the Swift language, and how things differ from Swift 2.

var numbers = [5, 17, 1]

numbers.sort()

print(numbers)

var moreNumbers = [10, 42, 3]

print(moreNumbers.sorted()) // prints [3, 10, 42]

print(moreNumbers) // prints [10, 42, 3], unchanged

myArray.insert("Fido", atIndex: 10)

myArray.insert("Fido", at: 10)

"Take command, Mr Riker"
    .stringByReplacingOccurrencesOfString("command",
    withString: "the conn")

"Take command, Mr Riker"
    .replacingOccurrences(of: "command", with: "the conn")

// post-increment, returning a copy of x
// before it's incremented
let q = x++

// pre-increment, returning a copy of x after it's incremented
let p = ++x

var x = 1

x = x + 1 // x is now 2

x = x - 1 // x is now 1

var x = 1

x += 1 // x is now 2

x -= 1 // x is now 1

for (i = 1; i <= 5; i++) {
    print(i)
}

for i in 1...5 {
    print(i)
}

(1...5).forEach{
    print($0)
}

let queue = dispatch_queue_create("com.test.myqueue", nil)

dispatch_async(queue) {
   print("Hello World")
}

let queue = DispatchQueue(label: "com.test.myqueue")

queue.async {
   print("Hello World")
}

Dog.feedFoodType(specialMix, quantity: 5)

Dog.feed(foodType: specialMix, quantity: 5)

let formatter = NSMassFormatter()

let formatter = MassFormatter()

NSArray* <NSString*> arrayOfStrings;

var arrayOfStrings : [String]

func foo(var i: Int) {
    i += 1
}

func foo(i: Int) {
    var localI = i
    localI += 1
}

control.sendAction("doSomething", to: target, forEvent: event)

control.sendAction(#selector(MyApplication.doSomething),
to: target, forEvent: event)

UIControlEvents.EditingDidBegin

UIControlEvents.editingDidBegin

Float.pi

Double.pi

let r = 3.0 / .pi

@discardableResult
func add(a: Int, b:Int) -> Int {
    return a + b
}

add(a: 1,b: 2)
// won't emit a warning, even though we didn't use the result

func a() {
    print ("I'm in \(#function) in \(#file) at" +
        "line \(#line) column \(#column)")
}

a()

Putting It All Together

One of the best ways to get a holistic understanding of what makes Swift 3 a little different from Swift 2 is to assemble a more complete program. Here’s a simple program, designed to be run in Swift Playgrounds (on iOS or Mac OS), that showcases some of the changes.

The playground shows a big circle and a button that you can tap or click to increment a counter that changes the color of the circle each time. Let’s take a look!

First, we import a few things, like UIKit, as well as PlaygroundSupport:

  import UIKit
  import PlaygroundSupport

Next we’ll create a class for our demo, with some variables for our label, which will show how many times we tap the screen; our image view, which will display the colored circle; and an integer to count the taps:

  class DemoViewController : UIViewController {

      var label : UILabel!
      var imageView = UIImageView()
      var tapCount = 0

Now we need a function to actually draw our colored circle. It’s going to take a size and a color as parameters:

  // Draws and returns an image
  func drawImage(size : CGSize, color: UIColor) -> UIImage? {

Create a canvas to do the drawing in, as well as a deferred call to end the context when everything is over:

  // Create a canvas for drawing
  UIGraphicsBeginImageContext(size)

  // When this function exits, tear down the canvas
  defer {
      UIGraphicsEndImageContext()
  }

Then, get a context to draw in. We’re using the newly simplified and Swiftier Core Graphics API. In Swift 3, we can use the Core Graphics context like a regular object, and we don’t have to repeatedly call verbose Core Graphics functions. We’ll also fill the context with the color that was passed into the function and create an ellipse:

  // Get a context for drawing with
  let context = UIGraphicsGetCurrentContext()

  // 'context' can now be used like an object, whereas
  // it couldn't in Swift 2
  context?.setFillColor(color.cgColor)
  context?.fillEllipse(in: CGRect(x: 0, y: 0, width:
      size.width, height: size.height))

Then, finishing off our image drawing function, we’ll return the image from the context:

      // Return the image now in the canvas
      return UIGraphicsGetImageFromCurrentImageContext()
  }

Next we need to override the function called when a view loads and actually put things on the screen, starting with the label to count clicks:

  override func viewDidLoad() {

      label = UILabel()
      label.frame = CGRect(x: 50, y: 50, width: 200, height: 50)
      label.textColor = UIColor.white
      label.text = ""

      self.view.addSubview(label)

and then the image, which we created the function to draw earlier:

  imageView.frame =
      CGRect(x: 50, y: 150, width: 250, height: 250)
  imageView.image =
      drawImage(size: imageView.frame.size, color: UIColor.red)

  self.view.addSubview(imageView)

then a button to tap, for which we’ll use the new selector syntax:

      let button = UIButton()

      button.setTitle("Tap This Button!", for: [])
      button.frame =
          CGRect(x: 0, y: 0, width: 200, height: 40)

      // Note the #selector syntax, camel-case enumeration,
      // simplified parameter names
      button.addTarget(self, action: #selector(buttonTapped),
          for: .touchUpInside)

      self.view.addSubview(button)

  }

Finally, we need a function to call when the button is tapped. It’s going to increment the tap counter, change the label text to reflect that, and randomly pick a new hue for the circle’s color:

      func buttonTapped() {
          tapCount += 1
          label.text = "Tapped \(tapCount) times"
          let hue = CGFloat(arc4random()) / CGFloat(RAND_MAX)
          let newColor = UIColor(hue: hue,
              saturation: 0.7, brightness: 1.0, alpha: 1.0)
          imageView.image = drawImage(size: imageView.frame.size,
              color: newColor)
      }
  }

To get it all working in the playground, we set the view controller to be an instance of the new class we defined:

  let viewController = DemoViewController()

Then we tell the playground support system that it should run until we stop it, and that the live view component of the playground (where buttons and such are displayed) should be our view controller:

  PlaygroundPage.current.needsIndefiniteExecution = true
  PlaygroundPage.current.liveView = viewController

On a Mac, this playground should now be running, and on an iPad it will run if you press the “Run my code” button! You can see the final result in Figure 3-1.

Summary

A lot has changed in Swift 3. Almost all of these changes take the form of subtle refinements that smooth the rough corners off the language. Human interactions with the Swift language are being made smoother: the removal of prefixes, unnecessary words, and more straightforward bridging of types between Objective-C and Swift are some of the stand-out examples.

Swift on Linux

Swift on Linux offers a huge range of exciting possibilities, from running Swift-based web frameworks (as we’ll discuss shortly), to eventually building apps for Linux desktop, Raspberry Pi, or even Android.

In this section, we’ll take a quick look at the process of installing Swift on Linux, how to work with Swift on Linux, and what works and what doesn’t, yet, in the Linux version.

$ swift --version

Swift version 3.0-dev (LLVM 834235, Clang 3434, Swift 354636)
Target: x86_64-unknown-linux-gnu

print("Hello from Swift!")

$ swiftc hello.swift

$ ./hello

A Working Example

There’s no better way to get a feel for using Swift on Linux to write actual programs than to write an actual program! In this section, we’ll write a simple little Swift program, using the Swift Foundation libraries provided as part of the Swift 3 release.

The program we’ll write will read a text file of comma-separated data containing a date, a price, and a note. The data file will look like this:

2016-07-13,2.52,Bus ticket
2016-07-12,1.21,Coffee
2016-07-15,5.00,Orange Juice

And, using this data, it will print out an easier-to-read report, like this:

Wednesday, 13 July 2016: $2.52 for Bus ticket
---
Wednesday, 13 July 2016: $1.21 for Coffee
---
Wednesday, 13 July 2016: $5.00 for Orange Juice

This program makes use of Swift 3 and showcases a number of different elements changed through Swift evolution proposals, many of which we discussed earlier, including:

• Removed prefixes

• Changed function parameter labels

• Simplified parameters

• Enums have become camelCased

Let’s get started!

First, we need to import the Foundation framework that we’re going to use:

  // Import the necessary classes from the Foundation framework
  import Foundation

Now, we’ll read the data file containing the comma-separated data:

  // Get the data from a file called "Data.txt"
  let data = try! String(contentsOfFile: "Data.txt")

Next, we’ll split the data into different lines, filtering to remove any blank lines:

  // Split into lines and remove blank lines
  let rows = data.components(separatedBy: "\n")
      .filter({ $0.characters.count > 0 })

We need to be able to understand dates in order to print them nicely in the output, so we need two data formatters: one for the input and one for the output. Create the input date formatter:

  // Create the first date formatter, for reading the date
  let dateInputFormatter = DateFormatter()
  dateInputFormatter.dateFormat = "dd-MM-YY"

Now, create the the output date formatter:

  let dateOutputFormatter = DateFormatter()
  dateOutputFormatter.dateStyle = .fullStyle

Next we’ll create a formatter to format the currency:

  // Create a number formatter for formatting the currency
  let numberFormatter = NumberFormatter()
  numberFormatter.numberStyle = .currency

And a place to store the output lines of the pretty report we’re creating:

  // The lines in our report will go in here
  var reportLines : [String] = []

Finally, we’ll iterate through the rows of data from the input file:

  // Process each row
  for row in rows {

splitting each row into columns, based on the position of the comma:

  // Split the row into columns
  let columns = row.components(separatedBy: ",")

and then extracting each piece of data we want, from each column of the row we’re working with:

  // Extract the data from each column
  let dateColumn = columns[0]
  let amountColumn = columns[1]
  let noteColumn = columns[2]

We’ll grab the currency amount, pulling a double variable out of the string we are working with:  

  // Read the price as a number
  let scanner = Scanner(string: amountColumn)

  var price : Double = 0

  scanner.scanDouble(&price)

and format it as currency, using the currency formatter we created earlier:

  // Format the number
  let priceFormatted =
      numberFormatter.string(from:price) ?? "$0.00"

Also formatting the date, using the date output formatter we created earlier:

  // Format the date
  let dateFormatted = dateOutputFormatter.string(from: Date())

And then add a nice, pretty line to the report variable:  

      // Add the line to the report
      reportLines.append(
          "\(dateFormatted): \(priceFormatted) for \(noteColumn)")

  }

Last, to display our nice report, we’ll create one big string, with each line separated by a new line and a series of dashes:

  // Turn the report lines into a single string,
  // separated by lines of '---'
  let report = reportLines.joined(separator: "\n---\n")

and print the report:

  // Finally, print the report
  print(report)

To test this program, put this text in a file called Data.txt, and make sure it’s in the same folder as your Swift file:

2016-07-13,2.52,Bus ticket
2016-07-12,1.21,Coffee
2016-07-15,5.00,Orange Juice

Then compile your Swift, like so:

swiftc SimpleDemo.swift

Then run the newly compiled program:

./SimpleDemo

If everything worked as intended, then you’ll get this:

Wednesday, 13 July 2016: $2.52 for Bus ticket
---
Wednesday, 13 July 2016: $1.21 for Coffee
---
Wednesday, 13 July 2016: $5.00 for Orange Juice

Kitura: A Web Framework for Swift

IBM has been doing some amazing work with Swift, and one of the most interesting pieces that it’s produced is the Kitura Swift web framework and HTTP server. Kitura features the basics you’d expect to find in a modern web framework, and…not much more…yet. It’s got:

• URL routing, with GETs, POSTs, PUTs, and DELETEs

• URL parameters

• Static file serving

• JSON parsing

And really, that’s about it so far. But it’s a phenomenal start—it’s very Swifty in approach, and everything feels like it should feel in a Swift web framework. Kitura supports Swift 3 and can be run on Mac OS and Linux (as well as in Docker or Vagrant, if that’s your thing).

To install Kitura, follow the guides available on the project page for your preferred platform. The basics of Kitura should be familiar to you if you’ve used web frameworks on other platforms.

First, you import the Kitura framework and create a constant to store a router in:

import Kitura

let router = Router()

Then you sit up the router to response to requests, and display something when the root URL (/) is hit with a GET request:

router.get("/") {

    request, response, next in

    response.send("Hello from Kitura!")

    next()

}

Finally, you can start Kitura’s built-in HTTP server and fire up the Kitura framework:

Kitura.addHTTPServer(onPort: 80, with: router)

Kitura.run()

To run your simple web app, you’d then need to compile it. (You hadn’t forgotten that Swift is a compiled language, had you? It’s easy to forget!) To compile it, you’ll need to run some variant of the Swift build command on your terminal. On Mac OS, that’s likely to be:

$ swift build

You’ll then end up with a compiled binary that you can fire up, and then surf to the URL it’s serving to be greeted by “Hello from Kitura!” Pretty nifty!