Starting tasks synchronously from caller context

extension Task {
  @discardableResult
  public static func immediate(
    name: String? = nil,
    priority: TaskPriority? = nil,
    executorPreference taskExecutor: consuming (any TaskExecutor)? = nil,
    @_inheritActorContext(always) operation: sending @escaping () async throws(Failure) -> Success
  ) -> Task<Success, Failure>

  @discardableResult
  public static func immediateDetached(
    name: String? = nil,
    priority: TaskPriority? = nil,
    executorPreference taskExecutor: consuming (any TaskExecutor)? = nil,
    @_inheritActorContext(always) operation: sending @escaping () async throws(Failure) -> Success
  ) -> Task<Success, Failure>
}

func synchronous() { // 呼び出し元スレッド: T1
  let task: Task<Void, Never> = Task.immediate {
    // T1 上で即座に実行開始
    guard keepRunning() else { return }

    await noSuspension() // 実際には suspend しなかった → T1 で継続
    await suspend()      // ここで本当に suspend → T1 を手放す
    // ここから先は別のエグゼキュータ／スレッドで再開
  }

  // task が suspend した時点で、呼び出し元はここに戻ってくる
}

@MainActor
func onMain() {
  Task { /* @MainActor isolated だが enqueue される */ }
  Task.immediate { /* @MainActor isolated で即座に実行 */ }
}

actor Caplin {
  var anything: Int = 0

  func act() {
    Task { /* nonisolated。グローバルエグゼキュータに enqueue */ }
    Task {
      // self をキャプチャしていれば self isolated で enqueue
      self.anything
    }
    Task.immediate {
      // キャプチャに関係なく self isolated、即座に実行
    }
  }
}

@MainActor var counterUsual = 0
@MainActor var counterImmediate = 0

@MainActor
func sayHelloOnMain() {
  sayHello() // メインアクターから呼ぶ
}

// 同期関数（@MainActor は付いていない）
func sayHello() {
  MainActor.assertIsolated()

  Task { @MainActor in
    counterUsual += 1
  }
  // この時点では counterUsual はまだ 0
  // メインアクターのエグゼキュータをまだ手放していないので走れない

  Task.immediate { @MainActor in
    counterImmediate += 1
  }
  // この時点で counterImmediate は 1 であることが保証される
  // 呼び出し元のエグゼキュータが要求 isolation と一致するので即座に実行された
}

// このAPIは @MainActor で呼ばれる前提だが、古い設計のためシグネチャには現れていない
func alwaysCalledFromMainActor() {
  MainActor.assumeIsolated { // ここで @MainActor に入る
    assert(num == 0)
    Task.immediate { // @MainActor のまま即座に実行
      num += 1
      assert(num == 1) // 間に他の仕事は挟まれない
      await asyncMainActorMethod() // ここで初めて suspend しうる
    }
  }
}

extension (Throwing)TaskGroup {
  func addImmediateTask(
    name: String? = nil,
    priority: TaskPriority? = nil,
    executorPreference taskExecutor: (any TaskExecutor)? = nil,
    operation: sending @escaping () async throws -> ChildTaskResult
  )

  func addImmediateTaskUnlessCancelled(
    name: String? = nil,
    priority: TaskPriority? = nil,
    executorPreference taskExecutor: (any TaskExecutor)? = nil,
    operation: sending @escaping () async throws -> ChildTaskResult
  )
}

actor Worker {
  func workIt(work: Work) async {
    await withDiscardingTaskGroup { group in
      group.addImmediateTask { // nonisolated だが、Worker 上で即座に走り始める
        let partial = await work.work() // 実際に suspend するとここで Worker を手放す
        work.moreWork(partial) // 以降はグローバル並行エグゼキュータ等で実行
      }
    }
  }
}