misyltoad

template <class _Ty>
_NODISCARD /* constexpr */ _Ty _Common_lerp(const _Ty _ArgA, const _Ty _ArgB, const _Ty _ArgT) noexcept {
    // on a line intersecting {(0.0, _ArgA), (1.0, _ArgB)}, return the Y value for X == _ArgT

    const int _Finite_mask = (int{isfinite(_ArgA)} << 2) | (int{isfinite(_ArgB)} << 1) | int{isfinite(_ArgT)};
    if (_Finite_mask == 0b111) {
        // 99% case, put it first; this block comes from P0811R3
        if ((_ArgA <= 0 && _ArgB >= 0) || (_ArgA >= 0 && _ArgB <= 0)) {
            // exact, monotonic, bounded, determinate, and (for _ArgA == _ArgB == 0) consistent:
            return _ArgT * _ArgB + (1 - _ArgT) * _ArgA;

sharplet

// Copyright (c) 2019–20 Adam Sharp and thoughtbot, inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in

freak4pc

//
//  Combine+WithLatestFrom.swift
//
//  Created by Shai Mishali on 29/08/2019.
//  Copyright © 2019 Shai Mishali. All rights reserved.
//

import Combine

// MARK: - Operator methods

ZevEisenberg

// RxSwift signposts

import os.signpost
import RxSwift

func signpost<T>(log: OSLog, name: StaticString, value: String, _ thing: () throws -> T) rethrows -> T {
    let signpostID = OSSignpostID(log: log)

    os_signpost(
        .begin,

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

IanKeen

public typealias LosslessStringCodable = LosslessStringConvertible & Codable

public struct Value<T: LosslessStringCodable>: Codable {
    private let type: LosslessStringCodable.Type
    
    public var value: T
    
    public init(from decoder: Decoder) throws {
        do {
            self.value = try T.init(from: decoder)

IanKeen

class DictionaryEncoder {
    init() { }
    
    func encode(_ value: Encodable) throws -> [String: Any] {
        let encoder = _Encoder(codingPath: [])
        try value.encode(to: encoder)
        
        guard let result = encoder.value as? [String: Any] else {
            throw EncodingError.invalidValue(encoder.value as Any, .init(codingPath: [], debugDescription: "Invalid root container"))
        }

erica

extension Never {
  /// A developer facing statement explaining how program correctness has failed.
  public struct Reason: CustomStringConvertible {
    public let description: String
    public init(_ rationale: String) {
      self.description = rationale
    }
  }
}

danielt1263

//
//  TokenAcquisitionService.swift
//
//  Created by Daniel Tartaglia on 16 Jan 2019.
//  Copyright © 2024 Daniel Tartaglia. MIT License.
//

import Foundation
import RxSwift

IanKeen

func debounce<T>(delay: TimeInterval, function: @escaping (T) -> Void, complete: @escaping () -> Void = { }) -> (T) -> Void {
    let queue = DispatchQueue(label: "Debouncer")
    var current: DispatchWorkItem?
    
    return { input in
        current?.cancel()
        let new = DispatchWorkItem {
            function(input)
            complete()
        }