sidepelican

import Foundation

@propertyWrapper
public struct ThreadLocal<Value> {
    private let defaultValue: () -> Value
    private let name: String

    public init(wrappedValue: @autoclosure @escaping () -> Value) {
        self.defaultValue = wrappedValue
        self.name = UUID().uuidString

sidepelican

var greeting = "Hello, playground"
print(greeting, ProcessInfo.processInfo.processorCount)
defer {
    print(greeting)
}

for i in 0..<30 {
    Task.detached {
        print("detached", i)
        sleep(1)

sidepelican

import Foundation

enum MyValue {
    @TaskLocal static var foo: Int = 0
}

func myFunc(@_inheritActorContext _ op: @Sendable @escaping () async -> ()) async {
    await withCheckedContinuation { c in
        DispatchQueue.global().async {
            Task {

sidepelican

import Foundation

func mySleep(seconds: Int) async {
    await withCheckedContinuation { c in
        DispatchQueue.global().asyncAfter(deadline: .now() + TimeInterval(seconds)) {
            c.resume()
        }
    }
}

sidepelican

import Foundation

func brokenTask() async {
  await withCheckedContinuation { (c) in
    // キャンセルシグナルが握りつぶされていて正しく中断しない処理
    Task {
      try await Task.sleep(for: .seconds(5))
      c.resume()
    }
  }

sidepelican

public struct RandomUInt8Sequence: Sequence {
    @usableFromInline var count: Int
    public init(count: Int) {
        self.count = count
    }
    public func makeIterator() -> Iterator {
        Iterator(self)
    }
    
    public struct Iterator: IteratorProtocol {

sidepelican

import Foundation

@dynamicMemberLookup
struct Concat<L: Decodable, R: Decodable>: Decodable {
    init(left: L, right: R) {
        self.left = left
        self.right = right
    }
    private var left: L
    private var right: R