[Concurrency] Add async properties Task.value and Task.result

Author: DougGregor

stdlib/public/Concurrency/SourceCompatibilityShims.swift

@@ -164,6 +164,30 @@ extension Task where Success == Never, Failure == Never {
   }
 }
 
+@available(SwiftStdlib 5.5, *)
+extension Task {
+  @available(*, deprecated, message: "get() has been replaced by .value")
+  @_alwaysEmitIntoClient
+  public func get() async throws -> Success {
+    return try await value
+  }
+
+  @available(*, deprecated, message: "getResult() has been replaced by .result")
+  @_alwaysEmitIntoClient
+  public func getResult() async -> Result<Success, Failure>  {
+    return await result
+  }
+}
+
+@available(SwiftStdlib 5.5, *)
+extension Task where Failure == Never {
+  @available(*, deprecated, message: "get() has been replaced by .value")
+  @_alwaysEmitIntoClient
+  public func get() async -> Success {
+    return await value
+  }
+}
+
 @available(SwiftStdlib 5.5, *)
 extension TaskGroup {
   @available(*, deprecated, renamed: "async(priority:operation:)")

stdlib/public/Concurrency/Task.swift

@@ -60,10 +60,27 @@ extension Task {
   /// If the task gets cancelled internally, e.g. by checking for cancellation
   /// and throwing a specific error or using `checkCancellation` the error
   /// thrown out of the task will be re-thrown here.
-  public func get() async throws -> Success {
-    return try await _taskFutureGetThrowing(_task)
+  public var value: Success {
+    get async throws {
+      return try await _taskFutureGetThrowing(_task)
+    }
   }
 
+  /// Wait for the task to complete, returning (or throwing) its result.
+  ///
+  /// ### Priority
+  /// If the task has not completed yet, its priority will be elevated to the
+  /// priority of the current task. Note that this may not be as effective as
+  /// creating the task with the "right" priority to in the first place.
+  ///
+  /// ### Cancellation
+  /// If the awaited on task gets cancelled externally the `get()` will throw
+  /// a cancellation error.
+  ///
+  /// If the task gets cancelled internally, e.g. by checking for cancellation
+  /// and throwing a specific error or using `checkCancellation` the error
+  /// thrown out of the task will be re-thrown here.
+
   /// Wait for the task to complete, returning its `Result`.
   ///
   /// ### Priority
@@ -78,11 +95,13 @@ extension Task {
   /// If the task gets cancelled internally, e.g. by checking for cancellation
   /// and throwing a specific error or using `checkCancellation` the error
   /// thrown out of the task will be re-thrown here.
-  public func getResult() async -> Result<Success, Failure> {
-    do {
-      return .success(try await get())
-    } catch {
-      return .failure(error as! Failure) // as!-safe, guaranteed to be Failure
+  public var result: Result<Success, Failure> {
+    get async {
+      do {
+        return .success(try await get())
+      } catch {
+        return .failure(error as! Failure) // as!-safe, guaranteed to be Failure
+      }
     }
   }
 
@@ -114,8 +133,10 @@ extension Task where Failure == Never {
   /// way than throwing a `CancellationError`, e.g. it could provide a neutral
   /// value of the `Success` type, or encode that cancellation has occurred in
   /// that type itself.
-  public func get() async -> Success {
-    return await _taskFutureGet(_task)
+  public var value: Success {
+    get async {
+      return await _taskFutureGet(_task)
+    }
   }
 }
 

test/Concurrency/async_tasks.swift

@@ -95,7 +95,7 @@ func test_detached() async throws {
     await someAsyncFunc() // able to call async functions
   }
 
-  let result: String = await handle.get()
+  let result: String = await handle.value
   _ = result
 }
 
@@ -106,7 +106,7 @@ func test_detached_throwing() async -> String {
   }
 
   do {
-    return try await handle.get()
+    return try await handle.value
   } catch {
     print("caught: \(error)")
   }