dabrahams

/*

  On 64-bit platforms, the discriminator is the most significant 4 bits of the
  bridge object.

  ┌─────────────────────╥─────┬─────┬─────┬─────┐
  │ Form                ║ b63 │ b62 │ b61 │ b60 │
  ╞═════════════════════╬═════╪═════╪═════╪═════╡
  │ Immortal, Small     ║  1  │ASCII│  1  │  0  │
  ├─────────────────────╫─────┼─────┼─────┼─────┤

dabrahams

#!/usr/bin/env python
import os
import sys
import subprocess

if len(sys.argv) > 1:
    files = []
    for arg in sys.argv[1:]:
        if os.path.exists(arg):
            p = os.path.abspath(arg).replace('\\', '\\\\').replace('"', '\\"')

dabrahams

//===--- Algorithms.swift.gyb ---------------------------------*- swift -*-===//
//
// 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
//

dabrahams

struct BitArray<Base : RandomAccessCollection & MutableCollection>
  : RandomAccessCollection & MutableCollection
  where Base.Element : FixedWidthInteger 
{
  fileprivate var base: Base
  private var bitWidth: Int { return Base.Element.bitWidth }
  
  var startIndex: Int { return 0 }
  var endIndex: Int { return Base.Element.bitWidth * base.count }

dabrahams

/// A default index type for a type that only supplies
/// `IteratorProtocol` conformance and value semantics
enum SequenceIndex<Base: Sequence> : Comparable {
  
  init() { self = .end }
  
  init(_ s: Base) {
    self = .normal(0, s.makeIterator())
  }

dabrahams

/// A default index type for a type that only supplies
/// `IteratorProtocol` conformance and value semantics
enum SequenceIndex<Base: Sequence> : Comparable {
  
  init() { self = .end }
  
  init(_ s: Base) {
    self = .normal(0, s.makeIterator())
  }

dabrahams

public struct MyPrefixWhile<Base: Sequence> : Sequence {
  var predicate: (Base.Element)->Bool
  var base: Base
  
  public struct Iterator : IteratorProtocol {
    var predicate: (Base.Element)->Bool
    var base: Base.Iterator?
    public mutating func next() -> Base.Element? {
      guard let r = base?.next() else { return nil }
      if predicate(r) { return r }

dabrahams

protocol Computation {
  associatedtype Input
  associatedtype Output
}

struct Map<C: Computation, F: Computation> : Computation
where C.Output : Collection,
C.Output.Element : Numeric, F.Input == C.Output.Element {
  typealias Output =  MetalArray<F.Output>
  typealias Input = C

dabrahams

struct MutableBidirectionalRangeReplaceableZip2<
First : BidirectionalCollection
  & RangeReplaceableCollection
  & MutableCollection,
Second : BidirectionalCollection 
  & RangeReplaceableCollection 
  & MutableCollection
> {
  var first: First, second: Second
  init(first: First, second: Second) {

dabrahams

extension BidirectionalCollection where Self : MutableCollection {
  @discardableResult
  mutating func partition(
    by belongsInSecondPartition: (Element)->Bool
  ) -> Index {
    guard var pivot = index(where: belongsInSecondPartition)
    else { return endIndex }
    
    for i in indices[index(after: pivot)...] {
      if !belongsInSecondPartition(self[i]) {