ollieatkinson

public struct Tuple<each T> {
    public private(set) var value: (repeat each T)
    public init(_ value: repeat each T) { self.value = (repeat each value) }
}

extension Tuple {

    public func map<each U>(
        _ transform: (repeat each T) throws -> (repeat each U)
    ) rethrows -> (repeat each U) {

moyerr

struct AnyAsyncSequence<Element>: AsyncSequence {
    struct AnyAsyncIterator: AsyncIteratorProtocol {
        private let _next: () async throws -> Element?

        init<Base: AsyncSequence>(_ base: Base) where Base.Element == Element {
            var baseIterator = base.makeAsyncIterator()
            self._next = { try await baseIterator.next() }
        }

        func next() async throws -> Element? {

jegnux

extension Result {
    public func `catch`(_ handler: () throws -> Success) -> Result<Success, Error> {
        flatMapError { _ in
            .init { try handler() }
        }
    }

    public func `catch`(_ handler: (Failure) throws -> Success) -> Result<Success, Error> {
        flatMapError { error in
            .init { try handler(error) }

MaximKotliar

import UIKit
import PlaygroundSupport
import CoreGraphics

extension Numeric {
    /// Linear interpolation
    /// - Parameters:
    ///   - a: a value to interpolate from
    ///   - b: a value to interpolate to
    ///   - delta: interpolation delta value (0 - 1)

AliSoftware

/*:
 This is a concept re-implementation of the @Binding and @State property wrappers from SwiftUI

 The only purpose of this code is to implement those wrappers myself
   just to understand how they work internally and why they are needed,

 ⚠️ This is not supposed to be a reference implementation nor cover all
      subtleties of the real Binding and State types.
    The only purpose of this playground is to show how re-implementing
      them myself has helped me understand the whole thing better

adamgraham

/// An extension to provide conversion to and from CIELCh° colors.
extension UIColor {

    /// The CIELCh° components of a color - lightness (L), chroma (C), and hue (h).
    struct CIELCh: Hashable {

        /// The lightness component of the color, in the range [0, 100] (darkest to brightest).
        var L: CGFloat
        /// The chroma component of the color.
        var C: CGFloat

douglashill

// Douglas Hill, December 2018
// Made for https://douglashill.co/reading-app/
// Find the latest version of this file at https://github.com/douglashill/KeyboardKit

import UIKit

/// A table view that allows navigation and selection using a hardware keyboard.
/// Only supports a single section.
class KeyboardTableView: UITableView {
    // These properties may be set or overridden to provide discoverability titles for key commands.

lattner

Swift Concurrency Manifesto

Author: Chris Lattner

Chinese Translation by Jason Yu

Contents

• Introduction
• Overall Vision

endavid

public class FontAtlas: NSObject, NSSecureCoding {
    public static var supportsSecureCoding: Bool { get { return true } }

    static let atlasSize: Int = 2048 // 4096 runs out of mem...
    var glyphs : [GlyphDescriptor] = []
    let parentFont: UIFont
    var fontPointSize: CGFloat
    let textureSize: Int
    var textureData: [UInt8] = []
  

Koze

    NSMutableArray *mArray = [NSMutableArray array];
    
    // fetch all image assets
    PHFetchOptions *fetchOptions = [[PHFetchOptions alloc] init];
    fetchOptions.predicate = [NSPredicate predicateWithFormat:@"mediaType == %d", PHAssetMediaTypeImage];
    PHFetchResult *result = [PHAsset fetchAssetsWithOptions:fetchOptions];
    [result enumerateObjectsUsingBlock:^(PHAsset * __nonnull asset, NSUInteger idx, BOOL * __nonnull stop) {
        // filter with subtype for screenshot
        if (asset.mediaSubtypes & PHAssetMediaSubtypePhotoScreenshot) {
            [mArray addObject:asset];