| #!/usr/bin/env python | |
| import argparse | |
| import sys | |
| import gzip | |
| import urllib | |
| import urlparse | |
| import posixpath | |
| import cStringIO | |
| import os |
The standard library lacks equivalents to the floor() and ceil() functions found in the standard libraries of most other languages. Currently, we need to import Darwin or Glibc in order to access the C standard library versions.
The compiler would statically optimise a function with particular values, and generate an entry point which checks for the values and runs the optimised implementations.
@_specialize(value: 42)
// Some function on our hot path
func someFunction(value: Int) -> Result? {
if value == 42 {
// magic value. Do some special processing.
During the review process, add the following fields as needed:
| import Dispatch | |
| // Import C11 for atomic_flag | |
| // FIXME: SWIFT(canImport) | |
| //#if canImport(Glibc) | |
| // import Glibc.stdatomic | |
| //#elseif canImport(Darwin) | |
| import Darwin.C.stdatomic | |
| //#endif |
| extension Collection { | |
| /// Repeats the collection _itself_ N times. | |
| /// | |
| /// ``` | |
| /// > [1, 2, 3].repeated(3).forEach { print($0) } | |
| /// [1, 2, 3] | |
| /// [1, 2, 3] | |
| /// [1, 2, 3] |
| struct VirtualKeyPath<Root, Value> { | |
| private let block: (Root) -> Value | |
| init(block: @escaping (Root) -> Value) { self.block = block } | |
| } | |
| // Evaluation | |
| extension VirtualKeyPath { | |
| func evaluate(on: Root) -> Value { return block(on) } |
| import Foundation | |
| /// This isn't safe to use before Swift gets ABI stability, because generic classes | |
| /// could change their names. Also, be sure to register bridges with the Obj-C runtime | |
| /// if using to decode during iOS state restoration. | |
| /// | |
| class CodableBridge<Wrapped: Codable>: NSObject, NSSecureCoding { | |
| let value: Wrapped | |
| init(_ value: Wrapped) { self.value = value } |
| enum IndexType<C: Collection> { | |
| case keypath(KeyPath<C, C.Index>) | |
| case index(C.Index) | |
| } | |
| struct IndexExpression<C: Collection> { | |
| let base: IndexType<C> | |
| let distance: C.IndexDistance | |
| func resolve(in collection: C) -> C.Index { |
| // Another idea for more convient slicing in Collections. | |
| /// Lazily-resolved indexes, by their nature, are not really safe to use with a potentially-mutating collection because | |
| /// their cached 'base' index might have been invalidated. If you want to use them in that situation, you have to ensure | |
| /// they point to locations which will survive the mutation, then manually resolve them *before* mutating. | |
| /// | |
| /// Or... you use the `Collection.easySlice()` method to do your slicing on a (hopefully) immutable copy | |
| /// of the collection. | |
| /// |