davbeck

import Combine
import Foundation
import SwiftUI

class ObservablePublisher<Output>: ObservableObject {
	@Published var output: Output?
	@Published var error: Swift.Error?
	private var observer: AnyCancellable?
	
	init() {}

davbeck

@propertyWrapper
struct IgnoreHashable<T>: Hashable {
	var wrappedValue: T
	
	init(wrappedValue: T) {
		self.wrappedValue = wrappedValue
	}
	
	func hash(into hasher: inout Hasher) {}
	

davbeck

class Loader<Output>: ObservableObject {
	@Published var isLoding: Bool = false
	@Published var error: Swift.Error?
	@Published var value: Output?
	
	private var observer: AnyCancellable?
	
	func load<P: Publisher>(_ publisher: P) where P.Output == Output {
		self.observer?.cancel()
		

davbeck

# remap windows menu/application key to option to avoid hidden characters
# in particular when using the Microsoft ergonomic keyboard 
# I found that I would accidentally insert hidden characters when pasting
hidutil property --set '{"UserKeyMapping":
    [{"HIDKeyboardModifierMappingSrc":0x700000065,
      "HIDKeyboardModifierMappingDst":0x7000000e6}]
}'

davbeck

struct Lock {
	private var unfairLock = os_unfair_lock_s()
	
	mutating func lock(_ work: () -> Void) {
		self.lock()
		work()
		self.unlock()
	}
	
	mutating func trylock(_ work: () -> Void) -> Bool {

davbeck

import ObjectiveC


extension objc_AssociationPolicy {
	public static let retain = objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN
	public static let retainNonatomic = objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC
	public static let copy = objc_AssociationPolicy.OBJC_ASSOCIATION_COPY
	public static let copyNonatomic = objc_AssociationPolicy.OBJC_ASSOCIATION_COPY_NONATOMIC
	public static let assign = objc_AssociationPolicy.OBJC_ASSOCIATION_ASSIGN
}

davbeck

import Foundation

/// Allows a property to fail decoding, defaulting to nil instead of surfacing the error.
@propertyWrapper
struct AllowDecodeFailure<Wrapped>: Codable where Wrapped: Codable {
	var wrappedValue: Wrapped?
	
	init() {
		self.wrappedValue = nil
	}

davbeck

func _if<T>(_ test: Bool, action: () -> T) -> T? {
	if test {
		return action()
	} else {
		return nil
	}
}

extension Optional {
	func _else(action: () -> Wrapped) -> Wrapped {

davbeck

extension Collection where Element: FloatingPoint {
	func average() -> Element {
		return self.reduce(Element.zero, +) / Element(self.count)
	}
}

extension Collection where Element: BinaryInteger {
	func average() -> Double {
		return Double(self.reduce(0, +)) / Double(self.count)
	}

davbeck

import PlaygroundSupport

let limiter = RateLimiter(timeframe: 5)

PlaygroundPage.current.needsIndefiniteExecution = true

for i in 0..<100 {
	limiter.perform {
		print("perform", i)
	}