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

natecook1000

let xs = [0,1,2,3,4,5]

let double: (Int) -> Int = { $0 * 2 }

let isEven: (Int) -> Bool = { $0 % 2 == 0 }

// Goal: [0,2,4,6,4,10]. Double all but the last even element.
extension Collection {
    func mapExceptLast(matching predicate: (Element) -> Bool, transform: (Element) -> Element) -> [Element] {
        var result: [Element] = []

natecook1000

/// Returns a binary predicate using the given key path to create an ascending order
/// for elements of type `Root`.
func ascending<Root, Value: Comparable>(_ path: KeyPath<Root, Value>) -> (Root, Root) -> Bool {
  return { $0[keyPath: path] < $1[keyPath: path] }
}

/// Returns a binary predicate using the given key path to create a descending order
/// for elements of type `Root`.
func descending<Root, Value: Comparable>(_ path: KeyPath<Root, Value>) -> (Root, Root) -> Bool {
  return { $0[keyPath: path] > $1[keyPath: path] }

natecook1000

extension Sequence {
  func interspersed(with element: Element) -> [Element] {
    var result: [Element] = []
    var iterator = makeIterator()
    if let first = iterator.next() {
      result.append(first)
    }
    while let elementFromSelf = iterator.next() {
      result.append(element)
      result.append(elementFromSelf)

natecook1000

extension BidirectionalCollection {
  func drop(first: Int, last: Int) -> SubSequence {
    return self.dropFirst(first).dropLast(last)
  }
}

let numbers = 0..<10
numbers.drop(first: 1, last: 1)  // 1..<9
numbers.drop(first: 2, last: 4)  // 2..<6