Python không đồng bộ mà không cần chờ đợi

Và cá nhân bạn lo lắng về hàm ý hiệu suất của lớp bọc .map[|ret: String| ret] giả đó;

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
-   .map[|ret: String| ret]
}

để "tối ưu hóa" công cụ

Vấn đề là,

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

0 chỉ đang ánh xạ hàm nhận dạng, tôi. e. , nó đang tạo kênh một giá trị thông qua thông qua không cần thao tác, không cần thêm bất kỳ mã nào để có cùng ngữ nghĩa. Nói cách khác, trình biên dịch đủ thông minh để tự tìm ra và do đó thực hiện tối ưu hóa mà bạn đã đề cập, ít nhất là khi sử dụng

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

1, đây là thời điểm duy nhất mà loại tối ưu hóa vi mô siêu nhỏ này nên quan trọng. Đó là toàn bộ quan điểm của một ngôn ngữ có tính trừu tượng với chi phí bằng không

Nó không cải thiện hiệu suất

Điều này có nghĩa là việc tước bỏ

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

2 / tước bỏ

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

3 xung quanh sẽ không ảnh hưởng đến hiệu suất dưới bất kỳ hình thức nào

Nó cản trở khả năng đọc

Thật,

async fn b[] -> String

đọc tốt hơn

fn b[] -> impl 'static + Future

phải không? . Thật vậy, so sánh

async
fn foo [a: &str, b: &str]
{
    bar[a, b].await
}

đến

________số 8_______

Một số người đã đề xuất ý tưởng có "auto-

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

4" / ngầm định

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

4. Mặc dù họ chưa bao giờ thực sự đặt ra các quy tắc cơ bản [vì phải có cách để không

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

6 trong một tương lai, để có thể gửi tương lai cho các chức năng khác, chẳng hạn như bộ điều hợp

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

7 hoặc bất kỳ chức năng nào trong số vô số các chức năng

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

8 / . điều duy nhất được ngầm hiểu là

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

4ed sẽ là một lệnh gọi hàm mang lại [n

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
-   .map[|ret: String| ret]
}

1]

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
-   .map[|ret: String| ret]
}

2, khi được thực hiện trong phần thân

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
-   .map[|ret: String| ret]
}

3

// Given:
async
fn foo []
  -> String
{
    "…".into[]
}
// and
fn bar []
  -> impl Future
{
    println!["bar"];
    async {
        println!["polled"];
    }
}

// We could imagine writing:
async
fn example []
{
    let _: String = foo[];
    let [] = bar[];
    // same as `bar[].boxed[]` currently: prints "bar" right now
    let boxed = [|| bar[].boxed[]][];
    // less noisy version with almost the same semantics, but
    // for the call to `bar[]` being lazy: "bar" not yet printed.
    let boxed_lazy = async { bar[] }.boxed[];
    let spawn_handle = some_runtime::spawn[async move { foo[] }];
    let [] = boxed.await; // prints "polled"
    let [] = boxed_lazy.await; // prints "bar" and "polled"
    let _: String = spawn_handle.await;
}

• Bản trình diễn chỉ ra rằng

  use ::futures::future::FutureExt;
  
  fn b []
    -> impl 'static + Future
  {
      a[]
      .map[|ret: String| ret]
  }
  

  4 chỉ xảy ra khi giá trị

  use ::futures::future::FutureExt;
  
  fn b []
    -> impl 'static + Future
  {
      a[]
  -   .map[|ret: String| ret]
  }
  

  1phần tử

  use ::futures::future::FutureExt;
  
  fn b []
    -> impl 'static + Future
  {
      a[]
  -   .map[|ret: String| ret]
  }
  

  2 thực sự khả thi

Theo đề xuất này, đoạn trích của bạn thực sự sẽ hoạt động

async fn a[] -> String {
    "test".to_owned[]
}

async fn b[] -> String {
    a[] /* implicitly `.await`ed */
}

Nhưng cho đến khi một mô hình đầy đủ chính thức của

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

4 ngầm định được đặt ra, mô hình này đã chứng minh được tính hữu ích của nó, tôi nghi ngờ [và thậm chí có thể hy vọng] chúng ta sẽ không đưa điều đó vào ngôn ngữ, ít nhất là không theo mặc định. ít nhất thì toàn bộ hành vi phải là chọn tham gia ở cấp mô-đun, sau đó vẫn có tùy chọn từ chối đối với một số mô-đun phụ hoặc chức năng, vì việc ẩn các

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
    .map[|ret: String| ret]
}

4 dưới tấm thảm chắc chắn sẽ cản trở việc gỡ lỗi. cho dù thế giới

use ::futures::future::FutureExt;

fn b []
  -> impl 'static + Future
{
    a[]
-   .map[|ret: String| ret]
}

3 muốn làm cho các khối

async fn b[] -> String

0 và

async fn b[] -> String

1 trông giống như luồng điều khiển tuyến tính đến mức nào, thì các điểm năng suất và tất cả ngữ nghĩa mà chúng ngụ ý làm cho toàn bộ sự việc trở nên rất phi tuyến tính, vì vậy lập trình viên phải nhận thức được những điều đó

Bạn có thể sử dụng async mà không cần chờ Python không?

Tôi có thể chạy chức năng async mà không cần chờ đợi không?

Điều gì xảy ra nếu bạn không chờ một phương thức không đồng bộ Python?

Điều gì xảy ra khi bạn gọi phương thức async mà không chờ đợi?