airspeedswift

indirect enum Tree<Element: Comparable> {
    enum Color { case R, B }
  
    case empty
    case node(Color, Tree<Element>, Element, Tree<Element>)
    
    init() { self = .empty }
    
    init(

airspeedswift

// To run this code on a Mac with Xcode installed:
// Download the latest toolchain from https://www.swift.org/download/#trunk-development-main and install it
// From a command line:
// export TOOLCHAINS=`plutil -extract CFBundleIdentifier raw -o - /Library/Developer/Toolchains/swift-latest.xctoolchain/Info.plist`
// xcrun swiftc -parse-as-library -enable-experimental-feature NoncopyableGenerics -enable-experimental-feature MoveOnlyPartialConsumption -Xfrontend -disable-round-trip-debug-types -enable-experimental-feature BorrowingSwitch linkedlist.swift


struct Box<Wrapped: ~Copyable>: ~Copyable {
  private let pointer: UnsafeMutablePointer<Wrapped>
  

airspeedswift

enum Color { case R, B }

indirect enum Tree<Element: Comparable> {
    case empty
    case node(Color, Tree<Element>, Element, Tree<Element>)
    
    init() { self = .empty }
    
    init(
        _ x: Element,

airspeedswift

////===--- EitherCollection.swift - A collection of two different types -----===//
////
//// This source file is part of the Swift.org open source project
////
//// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
//// Licensed under Apache License v2.0 with Runtime Library Exception
////
//// See https://swift.org/LICENSE.txt for license information
//// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
////

airspeedswift

////===--- EitherSequence.swift - A sequence type-erasing two sequences -----===//
////
//// This source file is part of the Swift.org open source project
////
//// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
//// Licensed under Apache License v2.0 with Runtime Library Exception
////
//// See https://swift.org/LICENSE.txt for license information
//// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
////

airspeedswift

/// Conform references types for use in the COW wrapper to this protocol
protocol Cowable: class {
  /// Make a new unique instance of `copied`
  static func makeUnique(_ copied: Self) -> Self
}

/// A wrapper that turns a Cowable reference type into a value-semantic
/// type with access to all of its properties
@dynamicMemberLookup

airspeedswift

extension Sequence {
  func count(where p: (Element)->Bool)->Int {
    return reduce(0) { p($1) ? $0 + 1 : $0 }
  }
}

let fn:  ((Int) -> Bool) -> Int = [1,2,3].count
let n = fn { $0<2 }
print(n) // 1

airspeedswift

struct BoundedSequence<Base: Sequence> {
  let _base: Base
}

extension BoundedSequence {
  struct Iterator {
    enum State { case starting, iterating, ended }
    var _state: State
    var _iterator: Base.Iterator
  }

airspeedswift

extension UnsafeMutableBufferPointer {
  public mutating func merge(
    using aux: UnsafeMutableBufferPointer<Element>,
    _ lo: Int, _ mid: Int, _ hi: Int,
    by isOrderedBefore: (Element, Element) -> Bool
  ) {
    assert(hi <= self.endIndex)
    assert(self.count == aux.count)
    let from = self.baseAddress!, to = aux.baseAddress!

airspeedswift

import QuartzCore

/// Reorder elements in-place into the next permutation, returning false when
/// the collection has been permuted into lexicographical order. To cycle
/// through all permutations, start with a lexicographically-sorted collection
/// and permute until it returns false.
///
/// - Complexity: O(*n*), where *n* is the length of the collection.
public extension MutableCollection where Self: BidirectionalCollection {