natecook1000

extension String.StringInterpolation {
    mutating func appendInterpolation<T>(_ value: T?, default: @autoclosure () -> String) {
        self.appendLiteral(value.map(String.init(describing:)) ?? `default`())
    }
}

let num = Int("21")
print("The number is: \(num, default: "<invalid>")")
// The number is: 21

natecook1000

struct Transposition<Base: Collection>: RandomAccessCollection
  where Base.Element: RandomAccessCollection
{
  typealias Index = Int
  typealias Indices = Range<Int>
  
  var base: Base
  
  struct Transposed: Collection {
    typealias Index = Base.Index

natecook1000

The following table lists the Unicode properties as described here, along with the corresponding Unicode.Scalar.Properties property and type, if implemented.

Unicode Property	Unicode.Scalar.Properties	Type
General
Name	name	String?
Name_Alias	nameAlias	String?
Block
Age	age	`Unicode.Versi

natecook1000

// Based on https://gist.github.com/dabrahams/852dfdb0b628e68567b4d97499f196f9
struct Dispatch<Model> {
  func apply<A, R>(_ a: A, _ f: (Model) -> R) -> R {
    f(a as! Model)
  }
}

protocol RandomAccessCollectionDispatch {
  func fastCount<C: Collection>(_ x: C) -> Int?
}

natecook1000

/// Calls the given closure with a buffer over the given tuple's elements.
///
/// - Parameters:
///   - tuple: The tuple.
///   - elementType: The type of all of the elements in the tuple.
///   - body: The closure to execute.
///
/// - Returns: The result of `body`, if any.
func withUnsafeElementBufferPointer<Tuple, Element, Result>(
    of tuple: Tuple,

natecook1000

public struct DefaultedDictionary<Key: Hashable, Value> {
  var _data: [Key: Value]
  var _default: Value
  
  public init(default defaultValue: Value) {
    _data = [:]
    _default = defaultValue
  }
  
  public init(_ data: [Key: Value], default defaultValue: Value) {

natecook1000

struct EachPairCollection<Base: Collection>: Collection {
    var base: Base
    
    struct Index: Comparable {
        var first: Base.Index
        var second: Base.Index
        
        // This is a little weird. Equality and comparisons
        // are only based on `second`, to allow an endIndex
        // to be created where both `first` and `second`

natecook1000

extension Collection where Element: Hashable {
  /// Returns the first matching element in `needles`, along with its index.
  func firstLiteralMatch<C: Collection>(from needles: C) -> (C.Element, Index)?
    where C.Element: Collection, C.Element.Element == Element
  {
    let prefixes = Dictionary(grouping: needles, by: { $0.first! })
    for i in indices {
      if let possibleMatches = prefixes[self[i]] {
        if let match = possibleMatches.first(where: { self[i...].starts(with: $0) }) {
          return (match, i)

natecook1000

// These functions turn nested tuples into flat ones

func munge<T, U, V>(_ x: ((T, U), V)) -> (T, U, V) {
  return (x.0.0, x.0.1, x.1)
}

func munge<T, U, V>(_ x: (T, (U, V))) -> (T, U, V) {
  return (x.0, x.1.0, x.1.1)
}

natecook1000

/// A dictionary wrapper that uses a `CaseIterable` type as its key.
/// This differs from a dictionary in two ways:
///
/// - Key-value pairs are accessed in a fixed order, which is the same
///   as the `Key`'s `allCases` property.
/// - Every possible key must have a value given, so using the key-based
///   subscript returns a non-optional value.
struct CaseMap<Key: CaseIterable & Hashable, Value> : Collection {
  typealias Index = Key.AllCases.Index