Swift CommandLineKit

// Create a new flags object for the system-provided command-line arguments
var flags = Flags()

// Define the various flags
let filePaths  = flags.strings("f", "filepath",
                               description: "Adds file path in which programs are searched for.")
let libPaths   = flags.strings("l", "libpath",
                               description: "Adds file path in which libraries are searched for.")
let heapSize   = flags.int("x", "heapsize",
                           description: "Initial capacity of the heap", value: 1000)
let importLibs = flags.strings("i", "import",
                               description: "Imports library automatically after startup.")
let prelude    = flags.string("p", "prelude",
                              description: "Path to prelude file which gets executed after " +
                                           "loading all provided libraries.")
let prompt     = flags.string("r", "prompt",
                              description: "String used as prompt in REPL.", value: "> ")
let quiet      = flags.option("q", "quiet",
                              description: "In quiet mode, optional messages are not printed.")
let help       = flags.option("h", "help",
                              description: "Show description of usage and options of this tools.")

// Parse the command-line arguments and return error message if parsing fails
if let failure = flags.parsingFailure() {
  print(failure)
  exit(1)
}

// If help flag was provided, print usage description and exit tool
if help.wasSet {
  print(flags.usageDescription(usageName: TextStyle.bold.properties.apply(to: "usage:"),
                               synopsis: "[<option> ...] [---] [<program> <arg> ...]",
                               usageStyle: TextProperties.none,
                               optionsName: TextStyle.bold.properties.apply(to: "options:"),
                               flagStyle: TextStyle.italic.properties),
        terminator: "")
  exit(0)
}
...
// Define how optional messages and errors are printed
func printOpt(_ message: String) {
  if !quiet.wasSet {
    print(message)
  }
}
...
// Set heap size (assuming 1234 is the default if the flag is not set)
virtualMachine.setHeapSize(heapSize.value ?? 1234)
...
// Register all file paths
for path in filePaths.value {
  virtualMachine.fileHandler.register(path)
}
...
// Load prelude file if it was provided via flag `prelude`
if let file = prelude.value {
  virtualMachine.load(file)
}

@main struct LispKitRepl: Command {
  @CommandArguments(short: "f", description: "Adds file path in which programs are searched for.")
  var filePath: [String]
  @CommandArguments(short: "l", description: "Adds file path in which libraries are searched for.")
  var libPaths: [String]
  @CommandArgument(short: "x", description: "Initial capacity of the heap")
  var heapSize: Int = 1234
  ...
  @CommandOption(short: "h", description: "Show description of usage and options of this tools.")
  var help: Bool
  @CommandParameters // Inject the unparsed parameters
  var params: [String]
  @CommandFlags // Inject the flags object
  var flags: Flags
  
  mutating func fail(with reason: String) throws {
    print(reason)
    exit(1)
  }
  
  mutating func run() throws {
    // If help flag was provided, print usage description and exit tool
    if help {
      print(flags.usageDescription(usageName: TextStyle.bold.properties.apply(to: "usage:"),
                                   synopsis: "[<option> ...] [---] [<program> <arg> ...]",
                                   usageStyle: TextProperties.none,
                                   optionsName: TextStyle.bold.properties.apply(to: "options:"),
                                   flagStyle: TextStyle.italic.properties),
            terminator: "")
      exit(0)
    }
    ...
    // Define how optional messages and errors are printed
    func printOpt(_ message: String) {
      if !quiet {
        print(message)
      }
    }
    ...
    // Set heap size
    virtualMachine.setHeapSize(heapSize)
    ...
    // Register all file paths
    for path in filePaths {
      virtualMachine.fileHandler.register(path)
    }
    ...
    // Load prelude file if it was provided via flag `prelude`
    if let file = prelude {
      virtualMachine.load(file)
    }
  }
}

if let ln = LineReader() {
  ln.setCompletionCallback { currentBuffer in
    let completions = [
      "Hello!",
      "Hello Google",
      "Scheme is awesome!"
    ]
    return completions.filter { $0.hasPrefix(currentBuffer) }
  }
  ln.setHintsCallback { currentBuffer in
    let hints = [
      "Foo",
      "Lorem Ipsum",
      "Scheme is awesome!"
    ]
    let filtered = hints.filter { $0.hasPrefix(currentBuffer) }
    if let hint = filtered.first {
      let hintText = String(hint.dropFirst(currentBuffer.count))
      return (hintText, TextColor.grey.properties)
    } else {
      return nil
    }
  }
  print("Type 'exit' to quit")
  var done = false
  while !done {
    do {
      let output = try ln.readLine(prompt: "> ",
                                   maxCount: 200,
                                   strippingNewline: true,
                                   promptProperties: TextProperties(.green, nil, .bold),
                                   readProperties: TextProperties(.blue, nil),
                                   parenProperties: TextProperties(.red, nil, .bold))
      print("Entered: \(output)")
      ln.addHistory(output)
      if output == "exit" {
        break
      }
    } catch LineReaderError.CTRLC {
      print("\nCaptured CTRL+C. Quitting.")
      done = true
    } catch {
      print(error)
    }
  }
}