Daniel Tull danielctull

Why make `Tracker` Sendable?

TL;DR

Telemetry is cross-cutting. A Tracker gets passed into view models, services, background workers, network layers — anything that might want to record an event. In Swift 6, anything shared across concurrency boundaries (tasks, actors, @Sendable closures) must be Sendable. Today Tracker isn't, so every consumer either fights the compiler with workarounds (@unchecked Sendable wrappers, nonisolated(unsafe), captured-var hacks) or simply can't adopt strict concurrency.

Making Tracker Sendable removes that friction once, at the source, so every downstream library and feature gets safe concurrent telemetry for free.


	import Advent
	import Algorithms
	import Foundation

	public enum Day10: Day {

	public static let title = "Syntax Scoring"

	public static func part1(_ input: Input) throws -> Int {


	import SwiftUI

	// MARK: - SwiftUI environment definition (CoreTracking)

	private struct EmptyTracker: Tracker {
	func track(_ event: Event) {}
	}

	public struct TrackerEnvironmentKey: EnvironmentKey {

	public enum Either<Left, Right> {
	case left(Left)
	case right(Right)
	}

	extension Either {

	public func `as`(_ type: Left.Type) -> Left? {
	guard case let .left(left) = self else { return nil }
	return left


	// EXAMPLE

	let string: String? = "Hello World" // String?
	let unwrappedString = string.really.srsly.itsfine.honestly.aaarggh // String
	print(unwrappedString)

	// IMPLEMENTATION

	extension Optional {


	extension Intersperse: Collection where Base: Collection {
	public struct Index: Comparable {
	enum Representation {
	case end
	case element(Base.Index)
	case separator(Base.Index)
	}

	let representation: Representation

	import SwiftUI

	extension Binding {

	func invmap<NewValue>(
	to: @escaping (Value) -> NewValue,
	from: @escaping (NewValue) -> Value
	) -> Binding<NewValue> {

	Binding<NewValue>(


	struct Multimap<Key: Hashable, Value: Hashable> {

	fileprivate struct _Element: Hashable {
	let key: Key
	let value: Value
	}

	private var elements: Set<_Element> = []


	@propertyWrapper
	struct B {
	var wrappedValue: Int
	}

	@propertyWrapper
	struct Clamp {
	var wrappedValue: Int
	}


	import SwiftUI

	public struct UnwrapView<Some: View, None: View>: View {

	private let some: () -> Some?
	private let none: () -> None?

	public init<Value>(value: Value?,
	some: @escaping (Value) -> Some,

Daniel Tull danielctull

Why make Tracker Sendable?

TL;DR

The problem in practice

Why make `Tracker` Sendable?