JadenGeller

struct OffsetIndexCollection<Base: RandomAccessCollection>: RandomAccessCollection {
    var base: Base
    var distance: Int
    
    @inlinable @inline(__always)
    var startIndex: Base.Index {
        index(base.startIndex, offsetBy: distance)
    }
    
    @inlinable @inline(__always)

JadenGeller

extension Float32 {
    public static func gaussianRandomPair(using generator: inout some RandomNumberGenerator) -> (Float32, Float32) {
        let u1 = Float.random(in: 0..<1, using: &generator)
        let u2 = Float.random(in: 0..<1, using: &generator)
        
        let r = sqrt(-2 * log(u1))
        let theta = 2 * Float.pi * u2
        
        let z0 = r * cos(theta)
        let z1 = r * sin(theta)

JadenGeller

import Accelerate

public struct Vector512Float32: VectorProtocol, Hashable {
    public typealias Scalar = Float32
    public var components: [Scalar]
    
    public init(components: [Scalar]) {
        self.components = components
    }
    

JadenGeller

struct PinnedCollection<Base: RandomAccessCollection, Index: Strideable>: RandomAccessCollection where Index.Stride == Int {
    var reindexedBase: ReindexedCollection<Base, Index>
    
    @inlinable @inline(__always)
    var startIndex: Index {
        reindexedBase.startIndex
    }

    @inlinable @inline(__always)
    var endIndex: Index {

JadenGeller

// import https://gist.github.com/JadenGeller/66585051f8de54d9f2a3df1acfd87c32#file-pinnedcollection-swift
import DequeModule

struct AdaptiveRangeBuffer<Index: Strideable, Element>: RandomAccessCollection, MutableCollection where Index.Stride == Int {
    var storage: PinnedCollection<Deque<Element>, Index>
    var defaultValue: (Index) -> Element
    var willRemoveRange: (Slice<Self>) -> Void

    init(indices: Range<Index>, defaultValue: @escaping (Index) -> Element, willRemoveRange: @escaping (Slice<Self>) -> Void = { _ in }) {
        self.defaultValue = defaultValue

JadenGeller

extension PHPhotoLibrary {
    // RADAR: https://feedbackassistant.apple.com/feedback/13660931
    func withTemporarilyUnhiddenAssets<Success>(_ assets: [PHAsset], _ block: () async throws -> Success) async throws -> Success {
        var collectionPlaceholder: PHObjectPlaceholder?
        try await performChanges {
            let collectionChange = PHAssetCollectionChangeRequest.creationRequestForAssetCollection(withTitle: "Temporarily Unhidden Assets")
            collectionPlaceholder = collectionChange.placeholderForCreatedAssetCollection
            collectionChange.insertAssets(assets as NSArray, at: IndexSet((0...).prefix(assets.count)))
            for asset in assets {
                precondition(asset.isHidden)

JadenGeller

actor RequestBatcher<Request, Response> {
    var maxBatch: Int
    var maxDelay: Duration
    var priority: TaskPriority?
    var dispatchBatch: ([Request]) async -> [Result<Response, Error>]
    init(maxBatch: Int, maxDelay: Duration, dispatchBatch: @escaping ([Request]) async -> [Result<Response, Error>]) {
        self.maxBatch = maxBatch
        self.maxDelay = maxDelay
        self.dispatchBatch = dispatchBatch

JadenGeller

protocol PipelineStep {
    associatedtype Context
    associatedtype Downstream: PipelineStep
    func step(with context: Context) async throws -> Downstream
}

protocol IdleCheckablePipelinewStep: PipelineStep {
    var isIdle: Bool { get }
}

JadenGeller

extension RandomAccessCollection {
    /// A sequence that partitions a sorted collection into non-overlapping segments based on a sorted sequence of boundaries.
    ///
    /// If N bounds are provided, the resulting sequence contains N + 1 segments, since the segment before the first boundary
    /// and the segment after the last boundary are both included.
    ///
    /// - Parameter bounds: A sequence of bounds used to partition the collection.
    /// - Parameter areInIncreasingOrder: A predicate that determines whether an element should be included
    ///   in the segment before the boundary.
    /// - Returns: A sequence of collection subseqences partitioned by the given bounds.

JadenGeller

import SwiftUI
import UniformTypeIdentifiers

struct FileDragProvider: NSViewRepresentable {
    var filePromise: FilePromise
    var preview: PlatformImage
    
    class NSViewType: NSView, NSFilePromiseProviderDelegate, NSDraggingSource {
        var filePromise: FilePromise
        var preview: PlatformImage