.task {
    do {
        let instructions =
        """
        You are a screen writer pitching ideas for a screenplay.
        Your response should be a synopsis of the plot followed by a bulleted list
        of major characters with a brief biography.
        """
        let options = GenerationOptions(sampling: .greedy)
        let session = LanguageModelSession(instructions: instructions)
        session.prewarm()
        let prompt = "Write a murder mystery set on a train"
        let response = try await session.respond(to: prompt,
                           generating: ScreenPlaySynopsis.self, options: options)
        print(response)
    } catch {
        print(error)
    }
}

@globalActor
actor MyActor {
    static let shared = MyActor()
    private init() { }
}

import FoundationModels
let instructions =
"""
    All recipes should be vegan. Start every answer with a bulleted list of ingredients followed by a description of the dish followed by a numbered list of instructions.
"""
let options = GenerationOptions(temperature: 5.0)
let session = LanguageModelSession(instructions: instructions)

let prompt = "create a recipe for Mapo Tofu"
let response = try await session.respond(to: prompt, options: options)
print(response.content)

    Text("Hello, World!")
        .font(.title)
        .padding()
        .glassEffect(.regular.tint(.orange).interactive())

// swift-tools-version: 6.2

.target(name: "uuid-exploration"),
        swiftSettings: [.strictMemorySafety(), .treatAllWarnings(as: .error)])

unsafe withUnsafeMutableBytes(of: &random) { raw in
    let result = unsafe SecRandomCopyBytes(kSecRandomDefault, 10, raw.baseAddress!)
    precondition(result == errSecSuccess)
}

struct ContentView: View {
    var body: some View {
        List {
            ForEach(0..<10) { i in
                LabeledContent {
                    Text("Title")
                        .font(.body)
                        .foregroundStyle(.red)
                    Text("Subtitle")
                    Text("Subsubtitle")
                    Text("Subsubsubtitle")
                } label: {
                    Label("hello", systemImage: "star.fill")
                }
                .labeledContentStyle(.verticalHierarchicalText)
            }
        }
    }
}

struct HierarchicalLabeledContentStyle: LabeledContentStyle {
    var orientation: Axis = .horizontal
    var spacing: Double = .zero
    enum Constant {
        static let fontFromIndex: [Int: Font] = [ 1 : .body, 2: .caption2, 3 : .caption]
        static let shapeStyleFromIndex: [Int: AnyShapeStyle] = [ 1 : AnyShapeStyle(.primary), 2: nyShapeStyle(.secondary), 3 : AnyShapeStyle(.tertiary)]
    }

    func makeBody(configuration: Configuration) -> some View {
        let layout = switch orientation {
          case .horizontal: AnyLayout(HStackLayout(spacing: spacing))
          case .vertical: AnyLayout(VStackLayout(alignment: .leading, spacing: spacing))
        }
        HStack(spacing: 10) {
          configuration.label
                .alignmentGuide(.listRowSeparatorLeading) { $0[.trailing] + 10 }
  
            layout {
                var index = 0
                ForEach(subviews: configuration.content) { subview in
                    subview.font(Constant.fontFromIndex[index] ?? .footnote)
                        .foregroundStyle(Constant.shapeStyleFromIndex[index] ?? AnyShapeStyle(.quaternary))
                    let _ = index += 1
                }
            }
        }
    }
}

extension LabeledContentStyle where Self == HierarchicalLabeledContentStyle {
    static var horizontal: Self {
        Self(orientation: .horizontal)
    }
    static var verticalHierarchicalText: Self {
        Self(orientation: .vertical)
    }
    static func verticalHierarchicalText(spacing: Double) -> Self {
        Self(orientation: .vertical, spacing: spacing)
    }
}

extension UUID {
  @inlinable init(_ value: UInt128) {
    let v: uuid_t =
      (UInt8(value >> 120 & 0xff),
       UInt8(value >> 112 & 0xff),
       UInt8(value >> 104 & 0xff),
       UInt8(value >> 96 & 0xff),
       UInt8(value >> 88 & 0xff),
       UInt8(value >> 80 & 0xff),
       UInt8(value >> 72 & 0xff),
       UInt8(value >> 64 & 0xff),
       UInt8(value >> 56 & 0xff),
       UInt8(value >> 48 & 0xff),
       UInt8(value >> 40 & 0xff),
       UInt8(value >> 32 & 0xff),
       UInt8(value >> 24 & 0xff),
       UInt8(value >> 16 & 0xff),
       UInt8(value >> 8 & 0xff),
       UInt8(value & 0xff))
    self = UUID(uuid: v)
  }
}

import Foundation
    
extension UUID {
      
  var version: Int {
    Int((uuid.6 & 0xf0) >> 4)
  }
      
  enum Variant {
     case ncs, rfc9562, guid, future
   }
       
   var variant: Variant {
       switch (uuid.8 >> 4) & 0xf {
       case 0x0 ... 0x7: .ncs
       case 0x8 ... 0xb: .rfc9562
       case 0xc ... 0xd: .guid
       case 0xe ... 0xf: .future
       }
   }
      
  init(_ value: UInt128) {
    var bigEndian = value.bigEndian
    let t = withUnsafeBytes(of: &bigEndian) { raw -> uuid_t in
      raw.load(as: uuid_t.self)
    }
    self = UUID(uuid: t)
  }
      
  var value: UInt128 {
    var source = uuid
    var destination: UInt128 = 0        
    _ = withUnsafeBytes(of: &source) { src in
      withUnsafeMutableBytes(of: &destination) { dst in
        src.copyBytes(to: dst)
      }
    }        
    return Int(littleEndian: 42) == 42 ? destination.byteSwapped : destination
  }

  static func v7() -> UUID {
      let timestamp = UInt128(Date().timeIntervalSince1970 * 1000)
      var random = UInt128.zero
      withUnsafeMutableBytes(of: &random) { raw in
        let result = SecRandomCopyBytes(kSecRandomDefault, 10, raw.baseAddress!)
        assert(result == 0)
      }
        
      var value = UInt128(0x7000_0000_000000000000)
      value |= (timestamp & ((UInt128(1) << 48) - 1)) << 80
      value |= (random & ((UInt128(1) << 76) - 1))
        
      // Patch in the variant
      value &= ~(UInt128(0b11) << 62) // clear the two bits
      value |=  (UInt128(0b10) << 62) // set to 10
        
      return UUID(value)
    }
      
  var unixMilliseconds: UInt64? {
     guard version == 7 else { return nil }
     return UInt64((value >> 80) & ((UInt128(1) << 48) - 1))
   }
      
  var timestamp: Date? {
    guard let unixMilliseconds else { return nil }
    return Date(timeIntervalSince1970: TimeInterval(unixMilliseconds) / 1000.0)
  }
}

import Testing
import Foundation
@testable import uuid_exploration
    
@Suite struct UUIDTests {
  @Test func version() {
    let uuid = UUID()
    #expect(uuid.version == 4)
    #expect(uuid.timestamp == nil)
  }
      
  @Test func initialize() {
    let x = UUID(1)
    #expect(x.uuidString == "00000000-0000-0000-0000-000000000001")
    #expect(x.value == 1)
        
    let y = UUID(0x112233445566778899AABBCCDDEEFF00)
    #expect(y.uuidString == "11223344-5566-7788-99AA-BBCCDDEEFF00")
    #expect(y.value == 0x112233445566778899AABBCCDDEEFF00)
  }
      
  @Test func generateUUID7() {
    let uuid = UUID.v7()
    #expect(uuid.version == 7)
    print(uuid.uuidString)
    print(uuid.timestamp!)
  }
}

print(String(Int.random(in: 0..<Int.max), radix: 36).uppercased())

print(ObjectIdentifier(a).debugDescription)

@globalActor
actor MyActor {
    static let shared = MyActor()
    private init() { }
}

nonisolated final class Subscriptions {
    private var disposables: [() -> Void] = []
    deinit { disposables.forEach { $0() } }
    static func += <Value> (lhs: Subscriptions, rhs: Task<Value, some Error>) {
        lhs.disposables.append(rhs.cancel)
    }
}

func assign<each Value, Target: AnyObject>(
        on target: Target,
        to keyPaths: repeat ReferenceWritableKeyPath<Target, each Value>
    ) -> Task<Void, Never> where Element == (repeat each Value) {
        subscribe(referencing: target) { target, values in
            for (value, keyPath) in repeat (each values, each keyPaths) {
                target[keyPath: keyPath] = value
            }
        }
    }

struct Renderer: TextRenderer {
    var time: TimeInterval
    func draw(layout: Text.Layout, in context: inout GraphicsContext) {
        let glyphs = layout.lazy.flatMap(\.self).flatMap(\.self)
        let currentTime = sin(time)
        for (offset, glyph) in glyphs.enumerated() {
            var context = context
            let blur = abs(Double(offset) * currentTime)
            context.addFilter(.blur(radius: blur))
            context.translateBy(x: 0, y: Double(offset) * 5 * currentTime)
            context.draw(glyph)
        }
    }
}

struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            TimelineView(.animation) { context in
                Text("Hello, world!")
                    .font(.largeTitle)
                    .textRenderer(Renderer(time: context.date.timeIntervalSince1970))
            }
        }
        .padding()
    }
}

extension Observation.Observable where Self: AnyObject {
    func values<Value: Sendable>(of keyPath: KeyPath<Self, Value>) -> some AsyncSequence<Value, Never> {
        Observations.untilFinished { [weak self] in
            self.map { .next($0[keyPath: keyPath]) } ?? .finish
        }
    }
    func newValues<Value: Sendable>(of keyPath: KeyPath<Self, Value>) -> some AsyncSequence<Value, Never> {
        values(of: keyPath).dropFirst()
    }
}

@Observable
@MainActor
final class Person: Sendable {
    var name = "Joshua"
    var age = 25
    init() {
        let a = newValues(of: \.name)
        Task {
            try await Task.sleep(for: .seconds(1))
            name = "Mark"
        }
        Task {
            for await name in a {
                print(name)
            }
        }
    }
}

import JavaScriptCore

let context = JSContext()
let squareScript = """
var a = 1;
function square(number) {
    return number * number;
}
"""
context?.evaluateScript(squareScript)
let square = context?.objectForKeyedSubscript("square")
print(square?.call(withArguments: [2]).toDouble())

TabView {
    // ... views ...
}
.tabViewStyle(.page(indexDisplayMode: .always))

import Swift
import Observation

@Observable
final class Person: Sendable {
    var name = "John"
    var age = 30
    init(name: String = "John", age: Int = 30) {
        self.name = name
        self.age = age
    }
}

extension Observation.Observable where Self: Sendable & AnyObject {
    func changes<Value: Sendable>(in transform: @escaping @Sendable (Self) -> Value) -> some AsyncSequence<Value, Never> {
        Observations.untilFinished { [weak self] in
            if let self {
                return .next(transform(self))
            } else {
                return .finish
            }
        }
    }
}

let p = Person()
let names = p.changes { $0.name }

Task {
    for await name in names {
        print(name)
    }
}

Task {
    try await Task.sleep(for: .seconds(1))
    p.name = "Jane"
    try await Task.sleep(nanoseconds: 0)
    p.name = "Jim"
}

KeyframeTrack(\.x) {
    MoveKeyframe(0)
    LinearKeyframe(0, duration: appearDuration)
    let keyframes = spiralKeyframes(cos, targetAngle: a, targetRadius: r, duration: flyDuration)
    KeyframeTrackContentBuilder.buildArray(keyframes)
}

struct MeshGradientView: View {
    @State var isAnimating = false
    
    var body: some View {
        MeshGradient(width: 3, height: 3, points: [
            [0.0, 0.0], [0.5, 0.0], [1.0, 0.0],
            [0.0, 0.5], [isAnimating ? 0.1 : 0.8, 0.5], [1.0, isAnimating ? 0.5 : 1],
            [0.0, 1.0], [0.5, 1.0], [1.0, 1.0]
        ], colors: [
            .purple, .indigo, .purple,
            isAnimating ? .mint : .purple, .blue, .blue,
            .purple, .indigo, .purple
        ])
        .edgesIgnoringSafeArea(.all)
        .onAppear() {
            withAnimation(.easeInOut(duration: 3.0).repeatForever(autoreverses: true)) {
                isAnimating.toggle()
            }
        }
    }
}

Found what I needed to get my UIKit (storyboard and UIViewControllerRepresentables) to work with the transparent tab bar in iOS 18 and iOS 26 
    
    .ignoresSafeArea(.all, edges: .bottom)
    .toolbarBackgroundVisibility(.hidden, for: .tabBar)

@resultBuilder
struct ArrayBuilder<Element> {
    typealias Expression = Element
    typealias Component = Array<Element>
    
    static func buildBlock(_ components: Component...) -> Component {
        buildArray(components)
    }
    static func buildExpression(_ expression: Expression) -> Component {
        [expression]
    }
    static func buildExpression(_ expression: Expression?) -> Component {
        expression.map { [$0] } ?? []
    }
    static func buildOptional(_ component: Component?) -> Component {
        component ?? []
    }
    static func buildEither(first component: Component) -> Component {
        component
    }
    static func buildEither(second component: Component) -> Component {
        component
    }
    static func buildArray(_ components: [Component]) -> Component {
        components.flatMap { $0 }
    }
    static func buildLimitedAvailability(_ component: Component) -> Component {
        component
    }
}

extension Array {
    static func build(@ArrayBuilder<Element> _ make: () -> Self) -> Self {
        make()
    }
}

var b = true
var c: Int? = nil
let a = Array<Int>.build {
    1
    2
    c
    if b {
        3
    }
    if #available(iOS 26.0, *) {
        4
    }
}

let chars: [Character] = ["a", "ä"]
extension Character {
    func isSemanticallyEquivalent(to other: Character) -> Bool {
//        String(self).compare(String(other), options: [.diacriticInsensitive, .caseInsensitive, .widthInsensitive], locale: .current) == .orderedSame
        String(self).folding(options: [.diacriticInsensitive, .caseInsensitive, .widthInsensitive], locale: .current) == String(other).folding(options: [.diacriticInsensitive, .caseInsensitive, .widthInsensitive], locale: .current)
    }
}
print(chars[0].lowercased() == chars[1].lowercased())
print(chars[0].isSemanticallyEquivalent(to: chars[1]))
```swift
Then how to solve the problem: First the indexing solution which shows how RandomAccessCollection works.  YUou should no use this solution in any language since index math is unsafe:
```swift
extension RandomAccessCollection where Element == Character  {
    var isPalindrome: Bool {
        let backwards = reversed()
        var front = indices.first
        var back = backwards.indices.first
        while let unwrappedFront = front, let unwrappedBack = back {
            front = self[unwrappedFront...].firstIndex(where: \.isLetter)
            back = backwards[unwrappedBack...].firstIndex(where:\.isLetter)
            guard let unwrappedFront = front, let unwrappedBack = back  else { return true }
            guard self[unwrappedFront].isSemanticallyEquivalent(to: backwards[unwrappedBack]) else {
                return false
            }
            front = front.map { self.index(after: $0) }
            back = back.map { backwards.index(after: $0)}
        }
        return true
    }
}

extension BidirectionalCollection where Element == Character {
    var isPalindrome2: Bool {
        var frontIterator = makeIterator()
        var backIterator = reversed().makeIterator()
        var matchCount = 0
        let length = count / 2
        while let front = frontIterator.next(where: \.isLetter), let back = backIterator.next(where: \.isLetter), matchCount < length  {
            guard front.isSemanticallyEquivalent(to: back) else {
                return false
            }
            matchCount += 1
        }
        return true
    }
}

private extension IteratorProtocol where Element == Character {
    mutating func next(where predicate: (Character) -> Bool) -> Character? {
        while let next = next(){
            if predicate(next){
                return next
            }
        }
        return nil
    }
}

extension String {
    var isPalindrome3: Bool {
        zip(
            lazy.compactMap { $0.isLetter ? $0 : nil },
            reversed().lazy.compactMap { $0.isLetter ? $0 : nil }
        ).prefix(count/2).allSatisfy { $0.isSemanticallyEquivalent(to: $1) }
    }
}

    struct ContentView: View {
        var body: some View {
      ScrollView(.horizontal) {
       LazyHStack(spacing: 100) {
        ForEach(0..<20) { item in
         Rectangle()
          .fill([Color.red, .green, .blue][item % 3])
    //      .aspectRatio(3.0 / 2.0, contentMode: .fit)
          .frame(height: 100)
    //      .overlay(Color.yellow.opacity(0.5))
          
          .containerRelativeFrame(
           .horizontal, count: 3, span: 1, spacing: 100)
    //      .overlay(Color.blue.opacity(0.5))
        }
       }
      }
    //  .safeAreaPadding(.horizontal, 20.0)
        }
    }
    
    #Preview {
        ContentView()
    }

// Single identity
// .clear option becomes a no-op 
ViewWithState()
    .background(flag ? .red : .clear)
    .animation(.easeInOut(duration: 2), value: flag)

struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("Hello, world!").opacity(0.0)
            Text("a")
        }
        .padding()
    }
}

import SwiftUI

@Observable
@MainActor
final class VM {
    var names: [String] = []
    func sort() async {
        async let sortedNames = { [names] in
            names.sorted()
        }()
        names = await sortedNames
    }
}

@Observable
@MainActor
final class VM {
    var names: [String] = []
    var sortTask: Task<[String], Error>?
    func sort() async {
        sortTask?.cancel()
        let sortTask = Task.detached { [names] in
            try await Task.sleep(for: .seconds(1))
            return names.sorted()
        }
        self.sortTask = sortTask
        do {
            names = try await sortTask.value
        } catch {
            switch error {
            case is CancellationError: print("task was canceled")
            default: print(error.localizedDescription)
            }
        }
    }
}

    Publishers.Merge(
        NotificationCenter.default.publisher(for: NSApplication.willResignActiveNotification).map { _ in false },
        NotificationCenter.default.publisher(for: NSApplication.willBecomeActiveNotification).map { _ in true }
    )
    .prepend(true)

extension Sequence {
  static func +<Right: Sequence>(lhs: Self, rhs: Right) -> ConcatenatedSequence<Self, Right, Element> {
    ConcatenatedSequence(leftSequence: lhs, rightSequence: rhs)
  }
}
    
struct ConcatenatedSequence<Left: Sequence<Value>, Right: Sequence<Value>, Value>: Sequence {
  typealias Element = Value
  var leftSequence: Left
  var rightSequence: Right
  func makeIterator() -> Iterator {
      .init(leftIterator: leftSequence.makeIterator(), rightIterator: rightSequence.makeIterator())
  }
  struct Iterator: IteratorProtocol {
      typealias Element = Value
      var leftIterator: Left.Iterator
      var rightIterator: Right.Iterator
      mutating func next() -> Value? {
          leftIterator.next() ?? rightIterator.next()
      }
  }
}
    
let a = [1,2,3] + Set([4,5,6])
for value in a {
    print(value)
}

extension Sequence {
  static func +(lhs: Self, rhs: some Sequence<Element>) -> some Sequence<Element> {
    sequence(
        state: (
                leftIterator: lhs.makeIterator(),
                rightIterator: rhs.makeIterator()
        )
    ) { state in
          state.leftIterator.next() ?? state.rightIterator.next()
    }
}

extension FixedWidthInteger {
  var data: Data {
    let data = withUnsafeBytes(of: self) { Data($0) }
    return data
  }
}

enum JSON {
    indirect case array([JSON])
    indirect case dictionary([String: JSON])
    case boolean(Bool)
    case number(Double)
    case string(String)
    case null
}
    
extension JSON: Decodable {
    init(from decoder: Decoder) throws {
        self = try Result { try decoder.singleValueContainer() }
            .flatMap { container in
                container.decodeNil()
                    ? .success(JSON.null)
                    : Result { JSON.boolean(try container.decode(Bool.self)) }
                        .flatMapError { _ in Result { JSON.number(try container.decode(Double.self)) } }
                        .flatMapError { _ in Result { JSON.string(try container.decode(String.self)) } }
                        .flatMapError { _ in Result { JSON.array(try container.decode([JSON].self)) } }
                        .flatMapError { _ in Result { JSON.dictionary(try container.decode([String: JSON].self)) } }
             }.get()
    }
}

static func embiggened(_ value: [Int]) -> [Int] {
    var mutableValue = value
    for index in mutableValue.indices {
        mutableValue[index] += 1
    }
    return mutableValue
}

static func embiggened(byBorrowing value: borrowing [Int]) -> [Int] {
    var mutableValue = copy value
    for index in mutableValue.indices {
        mutableValue[index] += 1
    }
    return mutableValue
}
static func embiggen(byExclusiveBorrow value: inout [Int]) {
    for index in value.indices {
        value[index] += 1
    }
}
static func embiggen(byConsuming value: consuming [Int]) -> [Int] {
    for index in value.indices {
        value[index] += 1
    }
    return consume value
}
    
let a = [1, 2, 3]
let b = embiggen(byConsuming: a)
print(a,b)

import Foundation
import Synchronization
    
public final class Pipe<Value: Sendable>: Sendable, AsyncSequence {
    public typealias Stream = AsyncStream<Element>
    public typealias AsyncIterator = Stream.AsyncIterator
    public typealias Element = Value
    private let lockedContinuations: Mutex<[UUID: Stream.Continuation]>
    private let replayCount: Int
    public init(replay: Int = 0) {
        replayCount = replay
        lockedContinuations = .init([:])
    }
    deinit {
        lockedContinuations.withLock { continuations in
            continuations.values.forEach { $0.finish() }
        }
    }
    public func send(_ value: Value) {
        lockedContinuations.withLock { continuations in
            continuations.values.forEach { $0.yield(value) }
        }
    }
    
    public func makeAsyncIterator() -> AsyncIterator {
        let (stream, continuation) = Stream.makeStream(of: Element.self,
                bufferingPolicy: .bufferingNewest(replayCount))
        let id = UUID()
        continuation.onTermination = { [weak self] _ in
            self?.lockedContinuations.withLock { $0[id] = nil }
        }
        lockedContinuations.withLock { $0[id] = continuation }
        return stream.makeAsyncIterator()
    }
}

import SwiftUI
import PlaygroundSupport
    
PlaygroundPage.current.setLiveView(ContentView())
    
struct ContentView: View {
    var body: some View {
        TimelineView(.periodic(from: .now, by: 3)) { _ in
            let _ = print("-----------\(Date.now)-----------")
            V()
        }
    }
}
    
struct V: View {
    var vm = VM("naked var")
    @State var vm0 = VM("@State")
    @ViewModel var vm1 = VM("@ViewModel")
    var body: some View {
        Text(vm.text)
        Text(vm0.text)
        Text(vm1.text)
    }
}
    
@Observable
final class VM {
    var text: String
    init(_ text: String) {
        self.text = text
        print("Init \(text)")
    }
    deinit {
        print("Deinit \(text)")
    }
}

@propertyWrapper
struct ViewModel<Wrapped: AnyObject & Observable>: DynamicProperty {
    @State private var reference: Reference
    var wrappedValue: Wrapped {
        reference.value
    }
    var projectedValue: Bindable<Wrapped> {
        reference.bindable
    }
    init(wrappedValue make: @autoclosure @escaping () -> Wrapped) {
        _reference = State(wrappedValue: Reference(make))
    }
}
    
extension ViewModel {
    final class Reference {
        private var viewModel: Wrapped?
        private let makeViewModel: () -> Wrapped
        lazy var value: Wrapped = makeViewModel()
        lazy var bindable = { Bindable(value) }()
        init(_ make: @escaping () -> Wrapped) {
            makeViewModel = make
        }
    }
}

import Foundation
    
final class Q {
    func sync() {
        MyActor.assertIsolated()
        print("synchronous Q")
    }
    nonisolated func nonSync() async {
        MyActor.assertIsolated()
        print("asynchronous Q")
    }
}
    
@MyActor
final class P {
    var q = Q()
    func doStuff() async {
        q.sync()
        async let v = q.nonSync()
        let _ = await v
    }
}
    
@globalActor
actor MyActor: GlobalActor {
    static let shared = MyActor()
    private init() { }
}
    
Task {
    let p = await P()
    await p.doStuff()
}

@discardableResult
func shellOneShot(_ command: some StringProtocol) throws -> String {
   let task = Process()
   let pipe = Pipe()
       
   task.standardOutput = pipe
   task.standardError = pipe
   task.arguments = ["-c", command]
       
   //task.currentDirectoryURL
   //task.qualityOfService
   //task.environment = ProcessInfo.processInfo.environment
       
   task.standardInput = nil
   task.executableURL = URL(fileURLWithPath: "/bin/zsh")
   try task.run()
       
   let data = pipe.fileHandleForReading.readDataToEndOfFile()
   let output = String(data: data, encoding: .utf8)!
       
   task.waitUntilExit()
    
   if task.terminationStatus == 0 || task.terminationStatus == 2 {
     return output
   } else {
     print(output)
     throw CustomProcessError.unknownError(exitCode: task.terminationStatus)
   }
}

@discardableResult
func runProcess(_ tool:URL, arguments:[some StringProtocol] = [], workingDirectory:URL? = nil) throws -> String {
    let task = Process()
    let pipe = Pipe()
        
    task.standardOutput = pipe
    task.standardError = pipe
    task.arguments = arguments
        
    if let workingDirectory {
        task.currentDirectoryURL = workingDirectory
    }
    //task.qualityOfService
    //task.environment
    
    task.standardInput = nil
    task.executableURL = tool
    try task.run()
        
    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: .utf8)!
        
    task.waitUntilExit()
    
    if task.terminationStatus == 0 || task.terminationStatus == 2 {
      return output
    } else {
      print(output)
      throw CustomProcessError.unknownError(exitCode: task.terminationStatus)
    }
    }

enum CustomProcessError: Error {
  case unknownError(exitCode: Int32)
}

struct A {
    //@MainActor
    nonisolated func a() {
        Task {
            MainActor.assertIsolated()
        }
    }
}

Task {
     A().a()
}

extension AsyncSequence where Failure == Never {
    func subscribe<Unretained: AnyObject>(withUnretained object: Unretained, onNext: @escaping (Unretained, Element) -> Void) -> Task<Void, Never> {
        Task { [weak object] in
            for await value in self {
                guard let object else { return }
                onNext(object, value)
            }
        }
    }
}

actor A {
    var subscription: Task<Void, Never>?
     func a()  {
         let (output, input) = AsyncStream.makeStream(of: Int.self, bufferingPolicy: .bufferingNewest(1))
         subscription = output.subscribe(withUnretained: self) { unretained, value in
             print(unretained, value)    
         }
         input.yield(1)
         input.yield(2)
         input.yield(3)
    }
}

actor LandingSite {
    private let queue = DispatchSerialQueue(label: "something")

    nonisolated var unownedExecutor: UnownedSerialExecutor {
        queue.asUnownedSerialExecutor()
    }
    
    func acceptTransport(_ transport: PersonalTransportation) {
        // this function will be running on queue
    }
}

@globalActor actor SharedActor {
  static let shared = SharedActor()
}
    
@SharedActor final class A { }
@SharedActor final class B { }

// Dependency grouping
enum Dependencies {
    static var common: [Target.Dependency] {
        [
            .product(name: "Difference", package: "Difference"),
            .product(name: "LifetimeTracker", package: "LifetimeTracker"),
        ]
    }
}

    .target(
         name: "SharedModels",
         dependencies:
            Dependencies.common + [
                "AutomaticSettings",
            ]
    ),

@_exported import PackageName

struct W: View {
    let a: Int
    @ViewBuilder
    var body: some View {
        switch a {
        case ..<0: Text("Negative")
        case 0: Text("Zero")
        case 1... : Color.green
        default: EmptyView()
      }
    }
}

struct ContentView: View {
    var body: some View {
        NavigationStack {
            NavigationLink {
                Text("Do not tap back, you'll regret it")
                    .toolbarBackground(.visible, for: .navigationBar)
                    .toolbarBackground(Color.orange, for: .navigationBar)
                    .toolbarColorScheme(.dark, for: .navigationBar)
            } label: {
                VStack {
                    Text("First page is the sweetest")
                }               
                .padding()
            }
            .navigationTitle("First Page")
            .toolbarBackground(.visible, for: .navigationBar)
            .toolbarBackground(Color.orange, for: .navigationBar)
            .toolbarColorScheme(.dark, for: .navigationBar)
        }
    }
}

    withAnimation(animation, completionCriteria: .logicallyComplete) {
                operation()
            } completion: {
                continuation.resume()
            }