In a Swift package you must first use the latest tools:

// swift-tools-version: 6.2

and in the target specify the .stringMemorySafety(condition)

.target(name: "uuid-exploration"),
        swiftSettings: [.strictMemorySafety(), .treatAllWarnings(as: .error)])

You then get warnings (errors if you wish to treat them that way) for all the places that use unsafe constructs:

 withUnsafeMutableBytes(of: &random) { raw in
    let result = SecRandomCopyBytes(kSecRandomDefault, 10, raw.baseAddress!)
    precondition(result == errSecSuccess)
}

Needs to be changed to:

unsafe withUnsafeMutableBytes(of: &random) { raw in
    let result = unsafe SecRandomCopyBytes(kSecRandomDefault, 10, raw.baseAddress!)
    precondition(result == errSecSuccess)
}

All of the details are in the proposal, of course, which you can read here:

• https://github.com/swiftlang/swift-evolution/blob/main/proposals/0458-strict-memory-safety.md

Consider the following contrived example:

struct Item {
  var name: String
  var date: Date

  enum Sorting {
    case none
    case name

    func sort(_ input: [Item]) -> [Item] {
      switch self {
      case .none:
        return input
      case .name:
        return input.sorted { $0.name < $1.name }
      }
    }
  }
}

This code creates a simple model and the ability to sort it a few different ways. The definition is closed because as a user of this model, you would need to add to the enumeration and add to switch statement to get a different sorting. (Or make a whole new abstraction altogether.)

That’s where SE-0299: Extending Static Member Lookup in Generic Contexts come into play.

As an alternate design to an enumeration you can define a protocol:

protocol ItemSorting {
  func sorted(_ items: [Item]) -> [Item]
}

Then you can provide a generic function for sorting.

extension Array where Element == Item {
  func sorted<Method: ItemSorting>(using method: Method) -> [Item] {
    method.sorted(self)
  }
}

Here, the sort method is defined as part of arrays of Items. You could also make it a free function but adding it as part of arrays makes it nice and discoverable.

To specify the .none and name item sorting as before, your library could provide the following:

// .none item sorting

struct NoneItemSorting: ItemSorting {
  func sorted(_ items: [Item]) -> [Item] {
    items
  }
}

extension ItemSorting where Self == NoneItemSorting {
  static var none: NoneItemSorting { NoneItemSorting() }
}

// .name Item sorting

struct NameItemSorting: ItemSorting {
  func sorted(_ items: [Item]) -> [Item] {
    items.sorted { $0.name < $1.name }
  }
}

extension ItemSorting where Self == NameItemSorting {
  static var name: NameItemSorting { NameItemSorting() }
}

This way of building it is a little more verbose but great because it lets you add to the ways that you can sort, even from outside the library.

struct DateItemSorting: ItemSorting {
  func sort(_ items: [Item]) -> [Item] {
    return items.sorted { $0.date < $1.date }
  }
}

extension ItemSorting where Self == DateItemSorting {
  static var date: DateItemSorting { DateItemSorting() }
}

Now, in Swift 5.5 in beyond, you can say:

items.sorted(using: .date)

Talk about clarity at the call-site. And with a nice autocomplete list of sorting options. That’s pretty neat.

We want to be able to say something like this:

[1, 2, 3, 2, 1, 2, 8] < 3

And this should return a sequence of boolean values:

[true, true, false, true, true, true, false]

Generating Sequences of Boolean Values

In order create a sequence of boolean values we can add:

extension Sequence where Element: Comparable {
    static func <(_ lhs: Self, _ rhs: Element) -> [Bool] {
        lhs.map { $0 < rhs }
    }
}

This does the job, but materializes a boolean array of the same size as the source. To avoid that allocation, we can make it lazy and return a lazy sequence like this:

extension Sequence where Element: Comparable {
    static func <(_ lhs: Self, _ rhs: Element) -> LazyMapSequence<Self, Bool> {
        lhs.lazy.map { $0 < rhs }
    }
}

Although it requires some boilerplate, we can extend this to all of the other comparison operators as well.

Broadcasting a collection

Another great feature of the R language and other languages like Octave, is the ability to broadcast values. This gives you a way to deal with sequences of unequal lengths by “broadcasting” the values of a sequence again and again if necessary.

We can make a custom collection to do this:

struct Broadcasted<Base: Collection>: Collection where Base.Index: BinaryInteger {

  typealias Element = Base.Element
  typealias Index = Base.Index

  private var base: Base
  private var count_: Index

  var startIndex: Index { base.startIndex }
  var endIndex: Index { count_ + base.startIndex }

  func index(after i: Index) -> Index { i + 1 }

  subscript(index: Index) -> Element {
    base[(index - startIndex) % Index(base.count) + startIndex]
  }

  init(_ base: Base, count: Index) {
    self.base = base
    self.count_ = count
  }
}

It requires the collection to have an index that supports the modulo operation so it can get at the value again and again.

Selection subscript

We can bring these together to let us select elements from a collection.

extension Collection {
    subscript<C>(selection: C) -> [Element] where C: Collection, C.Index: BinaryInteger, C.Element == Bool {
        zip(Broadcasted(selection, count: C.Index(self.count)), self)
            .filter(\.0).map(\.1)
    }
}

This let’s us say something like this:

// values: [Double]

values[values < 3.2]

Future Improvements

The gist is here: https://gist.github.com/rayfix/b5f5641f0c34e88f9a178e9a57d39092

I think it’s a nice start but there are some other things to look at. Our subscript operators allocates a new array. It might be better to return a slice into the original array. It could, for example, return a DiscontinuousSlice of the original collection specified as part of SE-0270. See https://github.com/apple/swift-se0270-range-set/blob/main/Sources/SE0270_RangeSet/DiscontiguousSlice.swift .

It might also be nice to create boolean operators for lists of boolean values. Left for a future post. :)

UPDATES:

• The original post’s Broadcast collection didn’t handle slices (non-zero start indexes correctly). Fixed.
• Josh Homann suggested using an UnfoldSequence instead of a custom Broadcasted collection. This removes the requirements on the index type to know about modulo arithmetic, which is nice. Although it only uses Sequence API, it extends Collection since repeated access to a Sequence is not defined.

extension Collection {
  func repeatForever() -> UnfoldSequence<Element, Iterator> {
    sequence(state: self.makeIterator()) { iterator in
      iterator.next() ?? {
        iterator = self.makeIterator()
        return iterator.next()
       }()
    }
  }
}

[1,2,3].repeatForever().prefix(8).forEach { print($0) }

Concurrency Roadmap

• Glossary of terms

SE-0296: Async/Await

• This proposal is about asynchrony but doesn’t talk about concurrency.
• Built on the idea of continuations, a generalized subroutine that can be suspended and resume. See Coroutine Representations and ABIs in LLVM by John McCall.
• Avoids the control complexity of using callbacks and lets you use control structures found in normal synchronous code.
• Potential suspension points are marked explicitly. This allows you to reason about potential interleaving.
• Init can be async. Deinit cannot be async.
• An async throwing function type can accept a non-throwing sync function. Async throwing functions are all-mighty.
• Potential suspension points must be marked with await and must occur in an async context.
• A single await can handle multiple expressions that are potential suspension points.
• Normally it is “try await …” but you can reverse it with parenthesis “await (try …)”
• Closures can type infer async closures if you use an await in the closure. (Though the inference does not propagate to outer closures.)
• Overloads must differ more than just async. Overload resolution uses the context to decide what function to call.
• A function that takes an async autoclosure must be async itself. (Future possible direction reasync.)
• An a async function cannot fulfill a sync protocol requirement.

Main example:

func processImageData() async throws -> Image {
  let dataResource  = try await loadWebResource("dataprofile.txt")
  let imageResource = try await loadWebResource("imagedata.dat")
  let imageTmp      = try await decodeImage(dataResource, imageResource)
  let imageResult   = try await dewarpAndCleanupImage(imageTmp)
  return imageResult
}

SE-302: Sendable and @Sendable closures

Sendable is used as the primary currency that gets passed between concurrency domains. Actors can be thought of message sending domains that use mailbox messages. Sendable data and @Sendable functions are the payloads being sent.

• Sendable is a “marker protocol” (implemented specially in the compiler for now)
• Many ways to handle concurrency. Swift wants to be a principled system that is sound and easy to use.
• Want a simple model that lasts many decades into the future.
• Built with value semantic types.
• Actors are islands of concurrency and Sendable lets you transfer across concurrency domains.
• Standard type such as Int and String are Sendable.
• Many structs and enums get Sendable conformance for free if all of their sub-types conform. (Public non-frozen structs and enums don’t get it)
• Actors are Sendable implicitly
• Use @unchecked Sendable as an escape hatch.
• You will get weird behavior if your type is marked Sendable but is actually not. (Much like implementing Hash requirements incorrectly.)
• The type @Sendable is an attribute on functions
• Error types must conform to Sendable

Standard library types:

extension Optional: Sendable where Wrapped: Sendable {}
extension Array: Sendable where Element: Sendable {}
extension Dictionary: Sendable
    where Key: Sendable, Value: Sendable {}

• ManagedBuffer must not conform to Sendable (even unsafely)
• The Unsafe**Pointer pointer family are Sendable but you have to be careful not to mutate from the parent

SE-0304: Structured concurrency

Let’s make this simple list app:

Start by creating a vanilla SwiftUI project and importing the fluent-sqlite-driver Swift package. File > Swift Packages and add https://github.com/vapor/fluent-sqlite-driver to the project.

Once that is done you can create a model type:

import FluentSQLiteDriver

final class Planet: Model {
  static let schema = "planets"

  @ID(key: .id) var id: UUID?
  @Field(key: "name") var name: String

  init() {}

  init(id: UUID? = nil, name: String) {
    self.id = id
    self.name = name
  }
}

You will want to create a migration to prepare the tables in the database:

struct CreatePlanetMigration: Migration {
  func prepare(on database: Database) -> EventLoopFuture<Void> {
    database.schema(Planet.schema)
      .id()
      .field("name", .string, .required)
      .create()
  }

  func revert(on database: Database) -> EventLoopFuture<Void> {
    database.schema(Planet.schema)
      .delete()
  }
}

For SwiftUI, you will want to creat a view-model:

import SwiftUI

final class AppModel: ObservableObject {
  let databases: Databases

  var logger: Logger = {
    var logger = Logger(label: "database.logger")
    logger.logLevel = .trace
    return logger
  }()

  var database: Database {
    return self.databases.database(
      logger: logger,
      on: self.databases.eventLoopGroup.next()
    )!
  }
  // More to follow...
}

The databases keeps the databases available. (Just like core data there might multiple stores.)

Next add this to the AppModel:

init() {
  let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
  let threadPool = NIOThreadPool(numberOfThreads: 1)
  threadPool.start()

  databases = Databases(threadPool: threadPool, on: eventLoopGroup)
  databases.use(.sqlite(.memory), as: .sqlite)
  databases.default(to: .sqlite)

  do {
    try CreatePlanetMigration().prepare(on: database).wait()
    try ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Ntune"].forEach {
      let item = Planet(name: $0)
      try item.save(on: database).wait()
    }
  }
  catch {
    print("error \(error)")
  }
}

This creates an in-memory database and adds some records to it. It performs the work syncronously on the main thread, but this should happen fast so is probably okay. (Fluent is designed to scale to hundreds or even thousands of concurrent operations.)

If you want the database to use durable storage, you can use .sqlite(.file(path)) instead of .sqlite(.memory)

Now let’s get the UI working. Finally add this to the AppModel:

var planets: [Planet] {
  try! database.query(Planet.self).all().wait()
}

This just syncronously grabs the data. Now create the SwiftUI to show it off.

@main
struct PlanetsApp: App {

  @StateObject var model = AppModel()

  var body: some Scene {
    WindowGroup {
      ContentView(model: model)
    }
  }
}

struct ContentView: View {
  @ObservedObject var model: AppModel
  var body: some View {
    NavigationView {
      List {
        ForEach(model.planets, id: \.id) {
          Text($0.name)
        }
      }.navigationTitle("Planets")
    }
  }
}

You can, of course, do more fancy queries using the Fluent ORM. For example:

var planets: [Planet] {
   try! database.query(Planet.self).filter(\.$name ~~ "a").all().wait()
}

This filters down to all of the planets that contain an “a”. If you look at the console, you can see the SQL this boils down to:

database.logger : database-id=sqlite 
 SELECT "planets"."id" AS "planets_id", 
        "planets"."name" AS "planets_name" FROM "planets" 
 WHERE "planets"."name" LIKE ? ["%a%"]

That’s pretty cool. In a future post, we’ll look at how to interface with Combine better with non-blocking calls.

Property wrappers which which first appeared in Swift 5.1, abstract away access patterns on a type continue to improve in Swift 5.4 by allowing them to be be applied to local variables. The easiest way to see what they do is to look at the API.

@propertyWrapper
struct <#Name#> {
    private var value: <#Wrapped#>
    var wrappedValue: <#Wrapped#> {
        get { value }
        set { value = newValue }
    }
    var projectedValue: <#Projected#> {
        get { value }
        set { value = newValue }
    }
    init(wrappedValue: <#Wrapped#>) {
        value = wrappedValue
    }
}

You use this type with the @ mark to give types the special behavior. @Behavior var velocity: Double. The wrappedValue is used where you use velocity and you can get at the projectedValue with $velocity.

The only real requirement is that you implement wrappedValue. It is not required to have a projected value. For example:

@propertyWrapper
struct Clamping<T: Comparable> {
  init(wrappedValue: T, range: ClosedRange<T>) {
    self.value = range.clamp(wrappedValue)
    self.range = range
  }

  private var value: T
  let range: ClosedRange<T>
  var wrappedValue: T {
    get { value }
    set { value = range.clamp(newValue) }
  }
}

extension ClosedRange {
  func clamp(_ value: Bound) -> Bound {
    Swift.min(Swift.max(value, self.lowerBound), self.upperBound)
  }
}

class Spaceship {
  @Clamping(range: 1...100) var velocity: Double = 10
}

let t = Spaceship()
t.velocity           // 10
t.velocity = 25
t.velocity           // 25
t.velocity = 200
t.velocity           // 100

This doesn’t have a projected value. You might add one that keeps the original value passed in. With that design way you could project to the unclamped original, which might be useful.

The entire code for this app is here:

import SwiftUI

final class GreetingViewModel: ObservableObject {
  @Published var name: String = "World 🌏"
}

struct GreetingView: View {
  @ObservedObject var model: GreetingViewModel
  var body: some View {
    Text("Hello, \(model.name)!").padding()
  }
}

@main
struct GreetingApp: App {
  @StateObject var model = GreetingViewModel()
  var body: some Scene {
    WindowGroup {
      GreetingView(model: model)
    }
  }
}

The GreetingViewModel holds the app’s business logic. A real app would have a more involved view model, obviously. Keep it simple for this example.

Adding in ArgumentParser

Next, add the Swift Argument Parser Swift package with File > Swift Packages > Add Package Dependency… Enter in https://github.com/apple/swift-argument-parser and click through until added and finished.

Back in the source file, add this to the top of the file:

import ArgumentParser

struct GreetingArguments: ParsableArguments {
  @Option(help: "Override the greeting name")
  var name: String?
}

Notice that since this isn’t a command. You create a type conforming to ParsableArguments, so you don’t need to implement a run method.

Create a helper for updating parameters

Now add this:

extension GreetingArguments {
  func update(_ viewModel: GreetingViewModel) {
    if let name = name {
      viewModel.name = name
    }
  }
}

This update isn’t part of the protocol; it is just a convenient method that clarifies the type for updating GreetingViewModel.

Using GreetingArguments

Next change how the source of truth is created with the below code:

@StateObject var model: GreetingViewModel = {
  let model = GreetingViewModel()
  do {
    let args = try GreetingArguments.parse()
    args.update(model)
  }
  catch {
    print("Error: Could not parse arguments")
    print(CommandLine.arguments.dropFirst().joined(separator: " "))
    print(GreetingArguments.helpMessage())
  }
  return model
}()

This code makes a closure and calls it to produce a GreetingViewModel type. You call parse and update the model.

If you run the app now, you won’t see any difference.

There’s no difference because you haven’t passed an option. To do that, open the scheme with Command < and enter it like so:

When you run the app now you will get this:

Error handling

If you enter invalid arguments, the app will still run but will print messages to the console.

Error: Could not parse arguments
Kitty
USAGE: greeting_arguments [--name <name>]

OPTIONS:
  --name <name>           Override the greeting name 
  -h, --help              Show help information.

Here, you didn’t put in --name, so it failed to parse. It is a soft error and the app launches, but you could easily make it trap as well.

Final thoughts

Adding a command line to your app is a great way to improve development speed by generating fake data to test things out. The example here is trivial, but easy to imagine how you could scale it up to a larger project.

Building m25

To guide your journey, you’ll build a command-line tool to help practice multiplication called m25. (Mental math books suggest that one memorize the 25x25 table if you want to go fast.)

Open Xcode and create a macOS command-line tool called m25. The convention for command-line tools is to use lower-case names.

Start with an abstraction for questions and answers. Open the file main.swift and replace it with this:

import Foundation

struct Multiplication {
  var a, b: Int
  var question: String { "\(a)·\(b)" }
  var answer: String { "\(a*b)" }
}

Using this abstraction, you can generate a list of shuffled multiplications:

let numberToStudy = 12
let multiplications = (2...25).map {
  Multiplication(a: numberToStudy, b: $0)
}.shuffled()

This code maps the numbers two through twenty-five to multiplication questions. Now you have a random list of multiplications. Next, add this:

var correctResponseCount = 0

for (offset, mult) in multiplications.enumerated() {

    print("Question \(offset+1) of \(multiplications.count)")
    print(mult.question)

    let response = readLine(strippingNewline: true)?
        .trimmingCharacters(in: .whitespaces)

    if response == mult.answer {
      print("⭐️ Correct")
      correctResponseCount += 1
    } else {
        print("❌ Incorrect \(mult.question) = \(mult.answer)")
    }
}

let performance = Int(Double(correctResponseCount) / 
                      Double(multiplications.count) * 100)
print("🏁🏁🏁 Finished \(performance)% 🏁🏁🏁")

This code enumerates through the problems, prints a question, takes in a response, removing whitespace and grades the results. After you finish, it shows the percentage you got correct.

Run the app and look in the debug console window type in some answers. You may need to hit Command-Shift-Y to toggle the console area.

This CLI is already useful… at least for studying 12. What if you want to study a different number?

The hard way

To parse arguments yourself, you can use the CommandLine to get arguments from the command line. Use this to get the number to study by replacing let numberToStudy = 12 with this:

guard let numberToStudy = CommandLine.arguments.dropFirst()
        .first.flatMap(Int.init) else {
  print("Need a number to study")
  exit(-1)
}

The above code gets the second argument and tries to parse it as an Int. If it fails, it prints a message and exits. When you run the program, you’ll see this:

Need a number to study
Program ended with exit code: 255

Fortunately, Xcode allows you to specify arguments to a starting app or application easily. Open the scheme with Command < switch to Arguments tab and add 15 to Arguments Passed On Launch.

Now when you run the program, you will again be able to answer questions, but this time for 15.

Adding ArgumentParser

You probably want to add more features to the application, and while it is possible using the CommandLine object directly, you are better off leveraging Argument Parser.

To add the Swift Package, go to Xcode File : Swift Packages : Add Package Dependency. Then add https://github.com/apple/swift-argument-parser to the search field and press Next. You will see something like this:

Press Next again. Make sure your target m25 has ArgumentParser checked and click Finish.

Using ArgumentParser

You can now convert your main.swift over to using ArgumentParser. First, at the top of the file, add this:

import ArgumentParser

Next, you will create a type called RunQuiz that conforms to the ParsableCommand protocol. It has a run method that will do the work you did previously. Remove numberToStudy and add it as a property to RunQuiz. It will look like so:

import ArgumentParser
import Foundation

struct Multiplication {
  var a, b: Int
  var question: String { "\(a)·\(b)" }
  var answer: String { "\(a*b)" }
}

struct RunQuiz: ParsableCommand {
  @Argument
  var numberToStudy: Int

  mutating func run() throws {
    let multiplications = (2...25).map {
      Multiplication(a: numberToStudy, b: $0)
    }.shuffled()

    var correctResponseCount = 0
    for (offset, mult) in multiplications.enumerated() {
      print("Question \(offset+1) of \(multiplications.count)")
      print(mult.question)
      let response = readLine(strippingNewline: true)?
        .trimmingCharacters(in: .whitespaces)

      if response == mult.answer {
        print("⭐️ Correct")
        correctResponseCount += 1
      }
      else {
        print("❌ Incorrect \(mult.question) = \(mult.answer)")
      }
    }

    let performance = Int(Double(correctResponseCount) / 
                          Double(multiplications.count) * 100)
    print("🏁🏁🏁 Finished \(performance)% 🏁🏁🏁")
  }
}

RunQuiz.main()

Your variable, numberToStudy, is now modified with the property wrapper @Argument, which tells the parser that this is a required argument. You call RunQuiz.main(). This statement starts the argument parser going, which will find numberToStudy and call the run method for you.

The behavior works the same as before but with a few improvements. Go back to the scheme (with Command <) and stop the argument 15 from being passed in by unchecking the box. You will get this output when you run the program:

Error: Missing expected argument '<number-to-study>'

USAGE: run-quiz <number-to-study>

ARGUMENTS:
  <number-to-study>

OPTIONS:
  -h, --help              Show help information.

Program ended with exit code: 64

That’s pretty great. Automatic error checking and reporting and some help too.

Add help

You can improve the help text of number-to-study by specifying help in your @Argument. Change the property to this:

@Argument(help: "Specify the number to study.")
var numberToStudy: Int

Rerun it to see the improved help.

Change the type

One of the advantages of using the argument parser is that it uses the type of the property to direct its processing. To see how you can use this to great effect, change numberToStudy: Int to numbersToStudy: [Int] like so:

@Argument(help: "Specify the numbers to study.")
var numbersToStudy: [Int]

Now that it is an array, you need to change how the multiplications are generated. Change the code to this:

let multiplications = numbersToStudy.flatMap { a in
  (2...25).map { b in
    Multiplication(a: a, b: b)
  }
}.shuffled()

Open the scheme and change the argument to 10 11. Just like that, you can practice a batch of numbers.

Add an option

@Argument says that a property is required for the command to run. An option is, well, optional. Suppose you want to limit the number of questions that appear. To do that, first create a limit property like this:

  @Option(name: .shortAndLong, help: "Limit the number of questions.")
  var limit: Int?

If limit is nil there is no limit. If it is non-nil, it limits the questions to that number. Change your code to respect this property:

let all = numbersToStudy.flatMap { a in
  (2...25).map { b in
    Multiplication(a: a, b: b)
  }
}.shuffled()
let multiplications = limit.map { Array(all.prefix($0)) } ?? all

The help now looks like this:

USAGE: run-quiz [<numbers-to-study> ...] [--limit <limit>]

ARGUMENTS:
  <numbers-to-study>      Specify the numbers to study. 

OPTIONS:
  -l, --limit <limit>     Limit the number of questions. 
  -h, --help              Show help information.

Program ended with exit code: 0

By specifying the name of the option to be .shortAndLong, it used the name of the property limit (long) and just the first letter l (short).

Note: If you have two options with the same argument name will have an assertion failure at runtime.

Enumerated options

Now create an option that controls the order of multiplication questions. Add this nested enumeration to the RunQuiz type:

enum Ordering: String, ExpressibleByArgument {
  case random, sorted, reversed

  func arrange(_ items: [Multiplication]) -> [Multiplication] {
    switch self {
    case .random:
      return items.shuffled()
    case .sorted:
      return items.sorted { ($0.a, $0.b) < ($1.a, $1.b) }
    case .reversed:
      return items.sorted { ($0.a, $0.b) > ($1.a, $1.b) }
    }
  }
}

This enumeration is a raw representable string and importantly conforms to ExpressibleByArgument. It defines three cases .random, .sorted and reversed. It also has a helper method that arranges a list of multiplication items based on the ordering.

Add this property:

@Option(name: .customLong("order"), help: "The order of the question.")
var ordering = Ordering.random

Now replace the logic for generating questions, using the ordering property:

let all = numbersToStudy.flatMap { a in
  (2...25).map { b in
    Multiplication(a: a, b: b)
  }
}

let ordered = ordering.arrange(all)

let multiplications = limit.map { Array(ordered.prefix($0)) } ?? ordered

Now you can practice multiplication shuffled, in order, or even reversed.

Flags

Now create a boolean flag using @Flag right after the limit property:

@Flag(name: .customLong("show"), help: "Show answers and exit.")
var showAnswersAndExit = false

Notice how you can use a name that is different from the property name. Use the variable right after you compute multiplications.

guard !showAnswersAndExit else {
  multiplications.forEach { mult in
    print(mult.question, "=", mult.answer)
  }
  return
}

Try it out by running with the arguments ‘17 –order sorted –show –limit 5`. You should this:

17·2 = 34
17·3 = 51
17·4 = 68
17·5 = 85
17·6 = 102

Set range of multiplications

Give the user the ability to set the range of multiplications. Start by adding these option properties:

@Option(name: .shortAndLong, help: "The start of the multiplication table.")
var from: Int = 2

@Option(name: .shortAndLong, help: "The end of the multiplication table.")
var to: Int = 25

Next, change how you compute all by using the properties:

let all = numbersToStudy.flatMap { a in
  (from...to).map { b in
     Multiplication(a: a, b: b)
   }
}

What will happen if the user specifies the to property smaller than from? Yes, it will trap and crash the program. On my machine, the crash looks like this:

Fatal error: Can't form Range with upperBound < lowerBound: file Swift/x86_64-apple-macos.swiftinterface, line 5584

Not very nice. Fortunately, the ParsableCommand lets you implement a validate method. Add this method to RunQuiz:

mutating func validate() throws {
  guard from <= to else {
    throw ValidationError("`from` must be smaller or equal to `to`.")
  }
}

This method lets you check out all of your arguments and parameters before run gets called. Now, if you launch the command with illegal --from and --to options, you will get the helpful message:

Error: `from` must be smaller or equal to `to`.

Adding some final touches

The ParsableCommand protocol lets you return a custom configuration object that allows you to change many more options. Many of them are self-explanatory.

Add this to RunQuiz:

static var configuration: CommandConfiguration {
  CommandConfiguration(commandName: "m25",
                       abstract: "Practice multiplication at the console.",
                       discussion: """
      Practice your multiplication table.

      Examples:
         # Practice 12x2 up to 12x25 in random order.
         m25 12

        # Practice 12x2 up to 12x25, present questions in order.
        m25 --order sorted 12

        # Practice 12, 13, and 14
        m25 12 13 14

        # Practice 15, 16 but limit to 10 questions.
        m25 15 16 --limit 10

        # Show 12x2 to 12x25 in order and exit.
        m25 12 --show --order reversed

        # Show 12x12 to 12x24 in order and exit
        m25 12 --show --order sorted --from 12 --to 24
   """)
}

This configuration explicitly names the command to be m25 instead of run-quiz. It also provides more detailed examples of usage.

Additionally, you might want to add some output formatting.

Final thoughts

Command-line tools are super powerful, and the Swift Argument Parser makes it quick and easy to put together a robust interface.

While you have used many of the features of argument parser in this little example, there are many more things to explore, including parsing custom types, changing parsing strategies, subcommands, and generating completion scripts automatically. The argument parser package comes with some excellent documentation itself, and it is easy to access from Xcode’s file navigator. Check out the Documentation and Examples folders.

You can find the code for this post here: https://github.com/rayfix/m25.

If you find this post helpful or have questions, please reach out to me on Twitter @rayfix.