[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_2112":2113},"routes/examples.$slug",{"_9":10},"example",{"_11":12,"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":24,"_25":26,"_27":28,"_29":-5,"_30":-5,"_31":32},"slug","rust-async-await","title","RFC: Async/Await Notation","subtitle","Native async/await syntax for ergonomic asynchronous programming in Rust.","sourceLabel","rust-lang/rfcs #2394","sourceUrl","https://github.com/rust-lang/rfcs/blob/master/text/2394-async_await.md","order",3,"readingTime","22 min read","questionCount",5,"content",{"_33":34,"_27":35},"stageName","stageDescription","updatedAt",["D",0],"type","doc",[36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180],{"_33":285,"_182":2108,"_27":2109},{"_33":194,"_27":2102},{"_33":194,"_27":2089},{"_33":285,"_182":2085,"_27":2086},{"_33":194,"_27":2067},{"_33":194,"_27":2037},{"_33":194,"_27":2019},{"_33":194,"_27":1995},{"_33":194,"_27":1977},{"_33":181,"_182":1973},{"_33":285,"_182":1969,"_27":1970},{"_33":285,"_182":1965,"_27":1966},{"_33":194,"_27":1954},{"_33":228,"_182":1950,"_27":1951},{"_33":194,"_27":1925},{"_33":194,"_27":1916},{"_33":228,"_182":1912,"_27":1913},{"_33":194,"_27":1898},{"_33":194,"_27":1879},{"_33":285,"_182":1872,"_27":1873},{"_33":194,"_27":1850},{"_33":228,"_182":1846,"_27":1847},{"_33":194,"_27":1840},{"_33":194,"_27":1826},{"_33":285,"_182":1819,"_27":1820},{"_33":194,"_27":1811},{"_33":228,"_182":1807,"_27":1808},{"_33":194,"_27":1796},{"_33":228,"_182":1792,"_27":1793},{"_33":194,"_27":1753},{"_33":194,"_27":1732},{"_33":285,"_182":1724,"_27":1725},{"_33":194,"_27":1693},{"_33":228,"_182":1689,"_27":1690},{"_33":194,"_27":1664},{"_33":194,"_27":1655},{"_33":194,"_27":1644},{"_33":285,"_182":1640,"_27":1641},{"_33":285,"_182":1636,"_27":1637},{"_33":194,"_27":1624},{"_33":181,"_182":1620},{"_33":285,"_182":1611,"_27":1612},{"_33":194,"_27":1593},{"_33":194,"_27":1587},{"_33":285,"_182":1583,"_27":1584},{"_33":194,"_27":1538},{"_33":194,"_27":1520},{"_33":285,"_182":1516,"_27":1517},{"_33":194,"_27":1504},{"_33":228,"_182":1500,"_27":1501},{"_33":194,"_27":1497},{"_33":228,"_182":1493,"_27":1494},{"_33":194,"_27":1474},{"_33":285,"_182":1470,"_27":1471},{"_33":194,"_27":1451},{"_33":194,"_27":1440},{"_33":228,"_182":1436,"_27":1437},{"_33":285,"_182":1432,"_27":1433},{"_33":194,"_27":1424},{"_33":228,"_182":1420,"_27":1421},{"_33":194,"_27":1396},{"_33":285,"_182":1385,"_27":1386},{"_33":194,"_27":1363},{"_33":228,"_182":1359,"_27":1360},{"_33":285,"_182":1355,"_27":1356},{"_33":194,"_27":1340},{"_33":194,"_27":1328},{"_33":194,"_27":1310},{"_33":194,"_27":1292},{"_33":285,"_182":1288,"_27":1289},{"_33":194,"_27":1282},{"_33":285,"_182":1266,"_27":1267},{"_33":194,"_27":1246},{"_33":194,"_27":1234},{"_33":285,"_182":1230,"_27":1231},{"_33":194,"_27":1216},{"_33":228,"_182":1212,"_27":1213},{"_33":194,"_27":1203},{"_33":194,"_27":1183},{"_33":285,"_182":1179,"_27":1180},{"_33":194,"_27":1160},{"_33":424,"_27":1079},{"_33":194,"_27":1073},{"_33":285,"_182":1068,"_27":1069},{"_33":194,"_27":1043},{"_33":194,"_27":1017},{"_33":285,"_182":1013,"_27":1014},{"_33":194,"_27":1000},{"_33":194,"_27":979},{"_33":194,"_27":958},{"_33":285,"_182":951,"_27":952},{"_33":194,"_27":939},{"_33":228,"_182":935,"_27":936},{"_33":194,"_27":900},{"_33":194,"_27":860},{"_33":285,"_182":856,"_27":857},{"_33":194,"_27":844},{"_33":194,"_27":816},{"_33":194,"_27":776},{"_33":194,"_27":755},{"_33":285,"_182":751,"_27":752},{"_33":194,"_27":739},{"_33":194,"_27":721},{"_33":285,"_182":717,"_27":718},{"_33":194,"_27":701},{"_33":228,"_182":697,"_27":698},{"_33":194,"_27":694},{"_33":598,"_27":652},{"_33":194,"_27":643},{"_33":285,"_182":639,"_27":640},{"_33":194,"_27":630},{"_33":194,"_27":624},{"_33":598,"_27":599},{"_33":194,"_27":586},{"_33":194,"_27":571},{"_33":285,"_182":566,"_27":567},{"_33":194,"_27":560},{"_33":285,"_182":551,"_27":552},{"_33":194,"_27":534},{"_33":194,"_27":489},{"_33":228,"_182":485,"_27":486},{"_33":194,"_27":482},{"_33":424,"_27":425},{"_33":194,"_27":418},{"_33":181,"_182":415},{"_33":285,"_182":408,"_27":409},{"_33":194,"_27":381},{"_33":228,"_182":377,"_27":378},{"_33":194,"_27":362},{"_33":285,"_182":358,"_27":359},{"_33":194,"_27":346},{"_33":194,"_27":343},{"_33":228,"_182":339,"_27":340},{"_33":285,"_182":332,"_27":333},{"_33":194,"_27":312},{"_33":194,"_27":299},{"_33":181,"_182":294},{"_33":285,"_182":286,"_27":287},{"_33":194,"_27":260},{"_33":194,"_27":250},{"_33":228,"_182":246,"_27":247},{"_33":194,"_27":235},{"_33":228,"_182":229,"_27":230},{"_33":194,"_27":195},{"_33":181,"_182":183},"inlineQuestion","attrs",{"_184":185,"_186":187,"_188":189,"_190":191,"_192":193},"question-id","d68ff536-931f-4869-a98d-c16840d6e042","question-text","We plan to disallow `?`, `return`, `break`, and `continue` across async block boundaries. Describe a real pattern in your code where you'd want these to work inside an async block.","question-type","long_text","question-config","{\"options\":[]}","question-description","","paragraph",[196,197,198,199,200,201,202,203,204,205,206,207,208],{"_33":209,"_209":227},{"_33":209,"_209":224,"_212":225},{"_33":209,"_209":223},{"_33":209,"_209":211,"_212":221},{"_33":209,"_209":220},{"_33":209,"_209":217},{"_33":209,"_209":219},{"_33":209,"_209":217},{"_33":209,"_209":218},{"_33":209,"_209":217},{"_33":209,"_209":216},{"_33":209,"_209":211,"_212":213},{"_33":209,"_209":210},"text"," keyword.","return","marks",[214],{"_33":215},"code","which make use the "," ","the other hand this would introduce a difference to closures and async closures","indicate that it applies to the async block and not its surrounding function. On"," could be beneficial to",[222],{"_33":215}," keyword instead of ","break",[226],{"_33":215},"The use of the ","codeBlock",{"_233":234},[231],{"_33":209,"_209":232},"async {\n if true { break \"foo\" }\n}","language","rust",[236,237,238,239,240],{"_33":209,"_209":245},{"_33":209,"_209":224,"_212":243},{"_33":209,"_209":242},{"_33":209,"_209":217},{"_33":209,"_209":241},"an async block:"," to return early from",[244],{"_33":215},"Also, it was discussed to allow the use of ",{"_233":234},[248],{"_33":209,"_209":249},"let reader: AsyncRead = ...;\nasync {\n let foo = await!(reader.read_to_end())?;\n Ok(foo.parse().unwrap_or(0))\n}: impl Future>",[251,252,253,254],{"_33":209,"_209":259},{"_33":209,"_209":217},{"_33":209,"_209":256,"_212":257},{"_33":209,"_209":255},"-operator. This would make them suitable for fallible IO:","?",[258],{"_33":215},"It was discussed that async blocks should act as a boundary for the",[261,262,263,264,265,266,267,268,269,270],{"_33":209,"_209":284},{"_33":209,"_209":256,"_212":282},{"_33":209,"_209":281},{"_33":209,"_209":217},{"_33":209,"_209":211,"_212":279},{"_33":209,"_209":278},{"_33":209,"_209":224,"_212":276},{"_33":209,"_209":275},{"_33":209,"_209":272,"_212":273},{"_33":209,"_209":271}," should work inside async blocks.","continue",[274],{"_33":215}," and ",[277],{"_33":215},", ",[280],{"_33":215},"-operator and control-flow constructs like",[283],{"_33":215},"This RFC does not propose how the ","heading",{"_293":22},[288,289],{"_33":209,"_209":256,"_212":291},{"_33":209,"_209":290},"-operator and control-flow constructs in async blocks",[292],{"_33":215},"level",{"_184":295,"_186":296,"_188":297,"_190":298,"_192":193},"2845dca2-bea3-496b-af3e-038382b1aa8d","The anonymous future type gets `impl !Unpin`. Does any executor or combinator in your stack require `Unpin` on futures it accepts?","multiple_choice","{\"options\":[{\"id\":\"0\",\"label\":\"Yes, at least one executor/combinator requires Unpin\"},{\"id\":\"1\",\"label\":\"No, but we'd have to audit to be sure\"},{\"id\":\"2\",\"label\":\"No, our stack handles non-Unpin futures fine\"},{\"id\":\"3\",\"label\":\"We don't know yet\"}]}",[300,301,302,303,304,305],{"_33":209,"_209":311},{"_33":209,"_209":217},{"_33":209,"_209":310},{"_33":209,"_209":217},{"_33":209,"_209":307,"_212":308},{"_33":209,"_209":306},". The annotation to enable this is left unspecified for the time being.","Unpin",[309],{"_33":215},"does not contain any references across yield points, allowing it to implement","We could also, with an annotation, typecheck an async function to confirm that it",[313,314,315,316,317,318,319,320,321],{"_33":209,"_209":331},{"_33":209,"_209":307,"_212":329},{"_33":209,"_209":328},{"_33":209,"_209":217},{"_33":209,"_209":327},{"_33":209,"_209":324,"_212":325},{"_33":209,"_209":323},{"_33":209,"_209":217},{"_33":209,"_209":322},"across yield points.",". This allows them to contain references","Pin",[326],{"_33":215},"it unsafe to move them out of a ",", making",[330],{"_33":215},"As proposed in this RFC, all async functions do not implement ",{"_293":22},[334,335],{"_33":209,"_209":338},{"_33":209,"_209":307,"_212":336},[337],{"_33":215},"Async functions which implement ",{"_233":234},[341],{"_33":209,"_209":342},"// Returns an iterator of i32\nfn foo(mut x: i32) yield i32 {\n while x > 0 {\n yield x;\n x -= 2;\n }\n}\n\n// Returns a stream of i32\nasync fn foo(io: &AsyncRead) yield i32 {\n async for line in io.lines() {\n yield line.unwrap().parse().unwrap();\n }\n}",[344],{"_33":209,"_209":345},"For example (using syntax which could change);",[347,348,349,350,351,352,353],{"_33":209,"_209":357},{"_33":209,"_209":217},{"_33":209,"_209":356},{"_33":209,"_209":217},{"_33":209,"_209":355},{"_33":209,"_209":217},{"_33":209,"_209":354},"iterator, while async generators can evaluate to a kind of stream.","this use case by way of generators. Generators can evaluate to a kind of","evaluate to streams, rather than evaluating to futures. We propose to handle","In the future, we may also want to be able to define async functions that",{"_293":22},[360],{"_33":209,"_209":361},"Generators and Streams",[363,364,365,366,367,368,369],{"_33":209,"_209":376},{"_33":209,"_209":217},{"_33":209,"_209":375},{"_33":209,"_209":372,"_212":373},{"_33":209,"_209":371},{"_33":209,"_209":217},{"_33":209,"_209":370},"small as possible)."," in the standard library (to keep the companion RFC to this one as","Stream",[374],{"_33":215},"of ","This is left out of the initial RFC to avoid having to stabilize a definition",{"_233":234},[379],{"_33":209,"_209":380},"for await value in stream {\n println!(\"{}\", value);\n}",[382,383,384,385,386,387,388,389,390,391,392],{"_33":209,"_209":407},{"_33":209,"_209":217},{"_33":209,"_209":406},{"_33":209,"_209":403,"_212":404},{"_33":209,"_209":402},{"_33":209,"_209":217},{"_33":209,"_209":401},{"_33":209,"_209":398,"_212":399},{"_33":209,"_209":397},{"_33":209,"_209":394,"_212":395},{"_33":209,"_209":393},":","IntoIterator",[396],{"_33":215}," instead of an ","IntoStream",[400],{"_33":215},"an ",", which takes","for await",[405],{"_33":215},"using a for loop. One could imagine a construct like ","Another extension left out of the RFC for now is the ability to process streams",{"_293":22},[410,411],{"_33":209,"_209":403,"_212":413},{"_33":209,"_209":412}," and processing streams",[414],{"_33":215},{"_184":416,"_186":417,"_188":189,"_190":191,"_192":193},"b8edbecb-263c-44c5-8617-4910a5d52c3d","We're using `await!(expr)` macro syntax as a placeholder. What existing code patterns in your codebase would conflict with postfix or keyword await syntax?",[419,420,421],{"_33":209,"_209":423},{"_33":209,"_209":217},{"_33":209,"_209":422},"of these is least bad.","This is left as an unresolved question to find another solution or decide which","orderedList",[426,427,428,429],{"_33":430,"_27":465},{"_33":430,"_27":451},{"_33":430,"_27":443},{"_33":430,"_27":431},"listItem",[432],{"_33":194,"_27":433},[434,435,436,437],{"_33":209,"_209":442},{"_33":209,"_209":217},{"_33":209,"_209":439,"_212":440},{"_33":209,"_209":438}," - this seems very unusual in its own way.","await? future",[441],{"_33":215},"Introduce a special syntax to handle the multiple applications, such as",[444],{"_33":194,"_27":445},[446,447,448],{"_33":209,"_209":450},{"_33":209,"_209":217},{"_33":209,"_209":449},"surprising as the other precedence.","Define the precedence as the inconvenient precedence - this seems equally",[452],{"_33":194,"_27":453},[454,455,456,457,458],{"_33":209,"_209":464},{"_33":209,"_209":217},{"_33":209,"_209":463},{"_33":209,"_209":460,"_212":461},{"_33":209,"_209":459}," - this seems very surprising for users.","(await future)?",[462],{"_33":215},"users to write ","Define the precedence as the obvious, if inconvenient precedence, requiring",[466],{"_33":194,"_27":467},[468,469,470,471,472,473,474],{"_33":209,"_209":481},{"_33":209,"_209":217},{"_33":209,"_209":480},{"_33":209,"_209":477,"_212":478},{"_33":209,"_209":476},{"_33":209,"_209":217},{"_33":209,"_209":475},"noisy."," - this is rather","await { future }?",[479],{"_33":215},"it will look more like how you expect - ","Require delimiters of some kind, maybe braces or parens or either, so that",[483],{"_33":209,"_209":484},"There are a couple of possible solutions:",{},[487],{"_33":209,"_209":488},"await future?",[490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510],{"_33":209,"_209":533},{"_33":209,"_209":530,"_212":531},{"_33":209,"_209":529},{"_33":209,"_209":256,"_212":527},{"_33":209,"_209":526},{"_33":209,"_209":217},{"_33":209,"_209":525},{"_33":209,"_209":522,"_212":523},{"_33":209,"_209":521},{"_33":209,"_209":217},{"_33":209,"_209":520},{"_33":209,"_209":256,"_212":518},{"_33":209,"_209":517},{"_33":209,"_209":217},{"_33":209,"_209":516},{"_33":209,"_209":256,"_212":514},{"_33":209,"_209":513},{"_33":209,"_209":217},{"_33":209,"_209":512},{"_33":209,"_209":217},{"_33":209,"_209":511},"precedence you would get:","However, because it introduces a space, it doesn't look like this is the",", so that the pattern will work how users wish it to.",[515],{"_33":215},"precedence than "," to. This implies that await should have a tighter",[519],{"_33":215},"then want to apply ",", which the user will","Result",[524],{"_33":215},"common to have a future which will evaluate to a ",". It is very",[528],{"_33":215}," has an interesting interaction with ","await",[532],{"_33":215},"In particular, ",[535,536,537,538,539,540,541,542,543],{"_33":209,"_209":550},{"_33":209,"_209":530,"_212":548},{"_33":209,"_209":547},{"_33":209,"_209":217},{"_33":209,"_209":546},{"_33":209,"_209":217},{"_33":209,"_209":545},{"_33":209,"_209":217},{"_33":209,"_209":544},"some kind.","this is how to handle its precedence & whether or not to require delimiters of","some day it be a normal control flow construct. The unresolved question about"," be a built-in macro, we'd prefer that",[549],{"_33":215},"Though this RFC proposes that ",{"_293":22},[553,554,555],{"_33":209,"_209":559},{"_33":209,"_209":530,"_212":557},{"_33":209,"_209":556}," expression",[558],{"_33":215},"Final syntax for the ",[561,562,563],{"_33":209,"_209":565},{"_33":209,"_209":217},{"_33":209,"_209":564},"included in this initial RFC.","This section contains design extensions which have been postponed & not",{"_293":570},[568],{"_33":209,"_209":569},"Unresolved questions",2,[572,573,574,575,576,577,578,579,580],{"_33":209,"_209":585},{"_33":209,"_209":217},{"_33":209,"_209":584},{"_33":209,"_209":217},{"_33":209,"_209":583},{"_33":209,"_209":217},{"_33":209,"_209":582},{"_33":209,"_209":217},{"_33":209,"_209":581},"return type polymorphism here) make this deviation well-motivated.","section, Rust's specific context (lifetime elision, the lack of a need for","type, rather than the outer return type. As discussed in the alternatives","typed languages (such as C#) is that we have chosen to show the \"inner\" return","One way in which our handling of async/await differs from most other statically",[587,588,589,590,591,592,593],{"_33":209,"_209":597},{"_33":209,"_209":217},{"_33":209,"_209":596},{"_33":209,"_209":217},{"_33":209,"_209":595},{"_33":209,"_209":217},{"_33":209,"_209":594},"green-threading).","enables us to have an entirely library-based asynchronicity model (unlike","favorably with ownership and borrowing (unlike systems based on monads) and it","Async/await is the most compelling model for Rust because it interacts","bulletList",[600,601,602],{"_33":430,"_27":619},{"_33":430,"_27":611},{"_33":430,"_27":603},[604],{"_33":194,"_27":605},[606,607,608],{"_33":209,"_209":610},{"_33":209,"_209":217},{"_33":209,"_209":609},"Haskell).","Monadic transformations on lazily evaluated code, such as do notation (e.g.",[612],{"_33":194,"_27":613},[614,615,616],{"_33":209,"_209":618},{"_33":209,"_209":217},{"_33":209,"_209":617},"communicating sequential processes (e.g. Go) or an actor model (e.g. Erlang).","An implicit concurrent runtime, often called \"green-threading,\" such as",[620],{"_33":194,"_27":621},[622],{"_33":209,"_209":623},"Async and await notation.",[625,626,627],{"_33":209,"_209":629},{"_33":209,"_209":217},{"_33":209,"_209":628},"today:","There are three paradigms for asynchronous programming which are dominant",[631,632,633,634,635],{"_33":209,"_209":638},{"_33":209,"_209":217},{"_33":209,"_209":637},{"_33":209,"_209":217},{"_33":209,"_209":636},"JavaScript, and Python.","way of handling asynchronous operation - notable examples include C#,","There is a lot of precedence from other languages for async/await syntax as a",{"_293":570},[641],{"_33":209,"_209":642},"Prior art",[644,645,646,647,648],{"_33":209,"_209":651},{"_33":209,"_209":217},{"_33":209,"_209":650},{"_33":209,"_209":217},{"_33":209,"_209":649},"before stabilization.","that we will want both of them, but we can always reconsider this question","The RFC proposes to include both constructs up front, since it seems inevitable",[653,654],{"_33":430,"_27":672},{"_33":430,"_27":655},[656],{"_33":194,"_27":657},[658,659,660,661,662,663,664],{"_33":209,"_209":671},{"_33":209,"_209":668,"_212":669},{"_33":209,"_209":667},{"_33":209,"_209":217},{"_33":209,"_209":666},{"_33":209,"_209":217},{"_33":209,"_209":665},"direct/primitive way of constructing futures.","mentioned in the RFC text, and the fact that it provides a more"," blocks: The initialization pattern","async",[670],{"_33":215},"There's a strong reason to have ",[673],{"_33":194,"_27":674},[675,676,677,678,679,680,681,682,683],{"_33":209,"_209":671},{"_33":209,"_209":691,"_212":692},{"_33":209,"_209":690},{"_33":209,"_209":687,"_212":688},{"_33":209,"_209":686},{"_33":209,"_209":217},{"_33":209,"_209":685},{"_33":209,"_209":217},{"_33":209,"_209":684},"service.","such closures are often useful for higher-order constructs like constructing a",";","async fn",[689],{"_33":215}," for consistency with ","async ||",[693],{"_33":215},[695],{"_33":209,"_209":696},"We could consider having only one of the two constructs. However:",{"_233":234},[699],{"_33":209,"_209":700},"// almost equivalent\nasync { ... }\n(async || { ... })()\n\n// almost equivalent\nasync |..| { ... }\n|..| async { ... }",[702,703,704,705,706,707,708],{"_33":209,"_209":716},{"_33":209,"_209":668,"_212":714},{"_33":209,"_209":713},{"_33":209,"_209":668,"_212":711},{"_33":209,"_209":710},{"_33":209,"_209":217},{"_33":209,"_209":709},"related, and are roughly inter-expressible:"," closures are closely",[712],{"_33":215}," blocks and ",[715],{"_33":215},"As noted in the main text, ",{"_293":22},[719],{"_33":209,"_209":720},"Async blocks vs async closures",[722,723,724,725,726,727,728,729,730,731,732],{"_33":209,"_209":738},{"_33":209,"_209":217},{"_33":209,"_209":737},{"_33":209,"_209":217},{"_33":209,"_209":736},{"_33":209,"_209":217},{"_33":209,"_209":735},{"_33":209,"_209":217},{"_33":209,"_209":734},{"_33":209,"_209":217},{"_33":209,"_209":733},"thing to implement at this stage in Rust's evolution.","which interacts well with our existing async IO libraries) is the most logical","shipping - async/await syntax (a concept available widely in many languages","area to support it in the near-term. Given our goals for 2018 - which emphasize","async/await could be supported by Rust, there has not enough research in this","While it is hypothetically plausible that some generalization beyond",[740,741,742,743,744,745,746],{"_33":209,"_209":750},{"_33":209,"_209":217},{"_33":209,"_209":749},{"_33":209,"_209":217},{"_33":209,"_209":748},{"_33":209,"_209":217},{"_33":209,"_209":747},"green-threading, and stack-full coroutines.","Among those suggested are a generalized effects system, monads & do notation,","as the mechanism for async/await in Rust and to adopt a different paradigm.","A final - and extreme - alternative would be to abandon futures and async/await",{"_293":22},[753],{"_33":209,"_209":754},"Using async/await instead of alternative asynchronicity systems",[756,757,758,759,760,761,762,763,764,765,766,767],{"_33":209,"_209":775},{"_33":209,"_209":217},{"_33":209,"_209":774},{"_33":209,"_209":530,"_212":772},{"_33":209,"_209":217},{"_33":209,"_209":771},{"_33":209,"_209":217},{"_33":209,"_209":770},{"_33":209,"_209":217},{"_33":209,"_209":769},{"_33":209,"_209":217},{"_33":209,"_209":768},"initialization step.","immediately evaluated and asynchronously evaluated portions of a future with an","async block provide a clearer mechanism for distinguishing between the","statements (which could possibly be macro generated). The use of a terminal",[773],{"_33":215},"is evaluated depends on whether or not it appears before all ","This is also complicated from a user perspective - when a portion of the body",[777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797],{"_33":209,"_209":815},{"_33":209,"_209":217},{"_33":209,"_209":814},{"_33":209,"_209":217},{"_33":209,"_209":813},{"_33":209,"_209":217},{"_33":209,"_209":812},{"_33":209,"_209":217},{"_33":209,"_209":811},{"_33":209,"_209":217},{"_33":209,"_209":810},{"_33":209,"_209":687,"_212":808},{"_33":209,"_209":275},{"_33":209,"_209":668,"_212":806},{"_33":209,"_209":805},{"_33":209,"_209":217},{"_33":209,"_209":804},{"_33":209,"_209":800,"_212":801},{"_33":209,"_209":799},{"_33":209,"_209":217},{"_33":209,"_209":798},"eager execution is likely to lead to significant confusion and bugs."," to make progress. Allowing for partial,","actively polled",[802],{"_33":803},"italic","resulting future be "," blocks as well, where it's vital that the",[807],{"_33":215},[809],{"_33":215},"over to ","spins up a future that starts executing immediately. This difference carries","precisely this reason. In contrast, in other languages, calling an async fn","built around this: for example, cancellation is dropping the future for","is that Rust's futures do not do anything unless polled. The whole system is","A fundamental difference between Rust's futures and those from other languages",[817,818,819,820,821,822,823,824,825,826,827,828,829,830,831],{"_33":209,"_209":843},{"_33":209,"_209":217},{"_33":209,"_209":842},{"_33":209,"_209":530,"_212":840},{"_33":209,"_209":839},{"_33":209,"_209":217},{"_33":209,"_209":838},{"_33":209,"_209":217},{"_33":209,"_209":837},{"_33":209,"_209":530,"_212":835},{"_33":209,"_209":834},{"_33":209,"_209":217},{"_33":209,"_209":833},{"_33":209,"_209":217},{"_33":209,"_209":832},"future.","conditional on whether or not the await is the first await in the body of the",", prior to polling the future being awaited,",[836],{"_33":215},"point within the ","this would be quite complicated - they would need to have an additional yield",", preserving their state until then. The implementation of",[841],{"_33":215},"their first ","An alternative would be to have async functions immediately evaluate up until",[845,846,847,848,849,850,851],{"_33":209,"_209":855},{"_33":209,"_209":217},{"_33":209,"_209":854},{"_33":209,"_209":217},{"_33":209,"_209":853},{"_33":209,"_209":217},{"_33":209,"_209":852},"cases need to use a terminal async block, for example.","use cases in which you have an immediate \"initialization\" step - those use","evaluating their bodies at all. As discussed above, this is not convenient for","As proposed by this RFC, all async functions return immediately, without",{"_293":22},[858],{"_33":209,"_209":859},"\"Hot async functions\"",[861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879],{"_33":209,"_209":899},{"_33":209,"_209":372,"_212":897},{"_33":209,"_209":896},{"_33":209,"_209":217},{"_33":209,"_209":895},{"_33":209,"_209":892,"_212":893},{"_33":209,"_209":891},{"_33":209,"_209":530,"_212":889},{"_33":209,"_209":888},{"_33":209,"_209":217},{"_33":209,"_209":887},{"_33":209,"_209":884,"_212":885},{"_33":209,"_209":883},{"_33":209,"_209":217},{"_33":209,"_209":882},{"_33":209,"_209":217},{"_33":209,"_209":881},{"_33":209,"_209":217},{"_33":209,"_209":880},"seems like a more promising approach.","syntax for generator functions, async functions, and async generator functions,","work. For this reason, the \"matrix\" approach in which we have independent"," (which would include streams) would","()",[886],{"_33":215},"async fn yielding something other than "," inside of an",[890],{"_33":215},". It's unclear how ","Poll>",[894],{"_33":215},"which need to yield ","s,",[898],{"_33":215},"The problem with this approach is that does not ergonomically handle ",[901,902,903,904,905,906,907,908,909,910,911,912,913,914,915],{"_33":209,"_209":934},{"_33":209,"_209":884,"_212":932},{"_33":209,"_209":931},{"_33":209,"_209":217},{"_33":209,"_209":930},{"_33":209,"_209":884,"_212":928},{"_33":209,"_209":920},{"_33":209,"_209":925,"_212":926},{"_33":209,"_209":924},{"_33":209,"_209":217},{"_33":209,"_209":923},{"_33":209,"_209":884,"_212":921},{"_33":209,"_209":920},{"_33":209,"_209":917,"_212":918},{"_33":209,"_209":916},".","Iterator",[919],{"_33":215}," would implement ",[922],{"_33":215},"returns ",", using a blanket impl. An async fn that","Future",[927],{"_33":215},[929],{"_33":215},"yields ",". An async fn that",[933],{"_33":215},"Both return and yield would be optional, default to ",{"_233":234},[937],{"_33":209,"_209":938},"async fn foo(arg: Arg) -> Return yield Yield",[940,941,942,943,944],{"_33":209,"_209":950},{"_33":209,"_209":947,"_212":948},{"_33":209,"_209":946},{"_33":209,"_209":217},{"_33":209,"_209":945},"creating generators. In this design, we would write a generator like this:"," the syntax for","be",[949],{"_33":803},"Another alternative design would be to have async functions ",{"_293":22},[953,954],{"_33":209,"_209":668,"_212":956},{"_33":209,"_209":955}," based on generators alone",[957],{"_33":215},[959,960,961,962,963,964,965,966,967,968,969,970,971],{"_33":209,"_209":978},{"_33":209,"_209":217},{"_33":209,"_209":977},{"_33":209,"_209":217},{"_33":209,"_209":976},{"_33":209,"_209":217},{"_33":209,"_209":975},{"_33":209,"_209":217},{"_33":209,"_209":974},{"_33":209,"_209":217},{"_33":209,"_209":973},{"_33":209,"_209":217},{"_33":209,"_209":972},"proc macros.","built-in async/await functionality than to attempt to stabilize generators and","For this reason, we believe it is more expedient to stabilize the minimal","does not even address the open questions of stabilizing more procedural macros.","and have a wider range of open questions - both syntactic and semantic. This","faster stabilization. Generators can express a wider range of possibilities,","It seems unlikely that using macros which expand to generators will result in a",[980,981,982,983,984,985,986,987,988,989,990,991,992],{"_33":209,"_209":999},{"_33":209,"_209":217},{"_33":209,"_209":998},{"_33":209,"_209":217},{"_33":209,"_209":997},{"_33":209,"_209":217},{"_33":209,"_209":996},{"_33":209,"_209":217},{"_33":209,"_209":995},{"_33":209,"_209":217},{"_33":209,"_209":994},{"_33":209,"_209":217},{"_33":209,"_209":993},"introducing async functions now.","more expedited stability by using generators for the time being than by","statements). Given that, the only question is whether or not we could have a","if statements rather than having macros which compile to loops and match","enough to justify it (similar to - for example - having built in for loops and","because it is more ergonomic & the use case is compelling and significant","In the long run, we believe we will want dedicated syntax for async functions,",[1001,1002,1003,1004,1005,1006,1007],{"_33":209,"_209":1012},{"_33":209,"_209":217},{"_33":209,"_209":1011},{"_33":209,"_209":217},{"_33":209,"_209":1010},{"_33":209,"_209":884,"_212":1008},{"_33":209,"_209":916},[1009],{"_33":215},"async function can be modeled as a generator which yields ","generators, rather than introducing built-in syntax for async functions. An","Another alternative is to focus on stabilizing procedural macros and",{"_293":22},[1015],{"_33":209,"_209":1016},"Built-in syntax instead of using macros in generators",[1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032],{"_33":209,"_209":1042},{"_33":209,"_209":217},{"_33":209,"_209":1041},{"_33":209,"_209":217},{"_33":209,"_209":1040},{"_33":209,"_209":668,"_212":1038},{"_33":209,"_209":1037},{"_33":209,"_209":217},{"_33":209,"_209":1036},{"_33":209,"_209":217},{"_33":209,"_209":1035},{"_33":209,"_209":217},{"_33":209,"_209":1034},{"_33":209,"_209":217},{"_33":209,"_209":1033},"functions is left as an unresolved question.","signature of the function. Exactly how to handle API documentation for async","also perform other transformations, possibly optionally, to display the outer","understand async notation know that the function will return a future. We can"," annotation in the documentation, so that users who",[1039],{"_33":215},"include the ","ways to make them easier to understand. At minimum we should make sure to","Rustdoc can handle async functions using the inner return type in a couple of",[1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058],{"_33":209,"_209":1067},{"_33":209,"_209":217},{"_33":209,"_209":1066},{"_33":209,"_209":217},{"_33":209,"_209":1065},{"_33":209,"_209":217},{"_33":209,"_209":1064},{"_33":209,"_209":217},{"_33":209,"_209":1063},{"_33":209,"_209":217},{"_33":209,"_209":1062},{"_33":209,"_209":217},{"_33":209,"_209":1061},{"_33":209,"_209":211,"_212":1059},{"_33":209,"_209":916},[1060],{"_33":215},"you ","of the correspondence between the return type and the type of the expressions","understand how to write an async function using the inner return type, because","definitely see what you get as the caller. In contrast, it can be easier to","type is documentation: when you read automatically generated API docs, you will","return type. One of the most compelling arguments in favor of the outer return","There are arguments from learnability in favor of both the outer and inner",{"_293":1072},[1070],{"_33":209,"_209":1071},"Learnability / documentation trade off",4,[1074,1075,1076],{"_33":209,"_209":1078},{"_33":209,"_209":217},{"_33":209,"_209":1077},"to return the outer type.","For these reasons, we don't think there's a strong argument from polymorphism",[1080,1081,1082],{"_33":430,"_27":1140},{"_33":430,"_27":1105},{"_33":430,"_27":1083},[1084],{"_33":194,"_27":1085},[1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096],{"_33":209,"_209":1104},{"_33":209,"_209":687,"_212":1102},{"_33":209,"_209":1101},{"_33":209,"_209":217},{"_33":209,"_209":1100},{"_33":209,"_209":217},{"_33":209,"_209":1099},{"_33":209,"_209":217},{"_33":209,"_209":1098},{"_33":209,"_209":217},{"_33":209,"_209":1097},"async generators seems more promising.","in the unresolved questions section, a solution based on generators and","significantly between those which return futures and streams. As discussed","However, this mean that the semantics of the internal function would differ"," which return streams.",[1103],{"_33":215},"It has been proposed that we support ",[1106],{"_33":194,"_27":1107},[1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122],{"_33":209,"_209":1139},{"_33":209,"_209":1136,"_212":1137},{"_33":209,"_209":1135},{"_33":209,"_209":1132,"_212":1133},{"_33":209,"_209":1131},{"_33":209,"_209":217},{"_33":209,"_209":1130},{"_33":209,"_209":217},{"_33":209,"_209":1129},{"_33":209,"_209":217},{"_33":209,"_209":1128},{"_33":209,"_209":1125,"_212":1126},{"_33":209,"_209":1124},{"_33":209,"_209":217},{"_33":209,"_209":1123},"object case), a feature we want separately from async fn."," in object-safe traits (probably by boxing the return type in the","impl Trait",[1127],{"_33":215},"methods in object-safe traits. This is a special case of supporting ","call site. The motivation for the attribute variant was to support async","have async functions always be unboxed and only box them explicitly at the"," variant. We would prefer to","(boxed)",[1134],{"_33":215}," macro has a ","#[async]",[1138],{"_33":215},"The current ",[1141],{"_33":194,"_27":1142},[1143,1144,1145,1146,1147,1148,1149,1150],{"_33":209,"_209":1159},{"_33":209,"_209":925,"_212":1157},{"_33":209,"_209":1156},{"_33":209,"_209":217},{"_33":209,"_209":1153,"_212":1154},{"_33":209,"_209":1152},{"_33":209,"_209":217},{"_33":209,"_209":1151},"object-safe custom self-types are not available on stable yet.",". However, this distinction is artificial and only because","StableFuture",[1155],{"_33":215}," and",[1158],{"_33":215},"In the 0.2 branch of futures, there is a distinction between ",[1161,1162,1163,1164,1165,1166,1167,1168],{"_33":209,"_209":1178},{"_33":209,"_209":1175,"_212":1176},{"_33":209,"_209":217},{"_33":209,"_209":1174},{"_33":209,"_209":217},{"_33":209,"_209":1173},{"_33":209,"_209":1170,"_212":1171},{"_33":209,"_209":1169},". We do not have a compelling use case for this:","Task",[1172],{"_33":215},"return types other than ","(their \"outer type\") was that they wanted to have async functions which could","Task",[1177],{"_33":215},"According to the C# developers, one of the major factors in returning ",{"_293":1072},[1181],{"_33":209,"_209":1182},"Polymorphic return (a non-factor for us)",[1184,1185,1186,1187,1188,1189,1190,1191,1192],{"_33":209,"_209":1202},{"_33":209,"_209":1199,"_212":1200},{"_33":209,"_209":1198},{"_33":209,"_209":217},{"_33":209,"_209":1197},{"_33":209,"_209":687,"_212":1195},{"_33":209,"_209":1194},{"_33":209,"_209":217},{"_33":209,"_209":1193},"worse than showing the interior type."," than other functions; this seems",[1196],{"_33":215},"differently for the return type of "," but have lifetime capture work","impl Future",[1201],{"_33":215},"We could have it return ",[1204,1205,1206,1207,1208],{"_33":209,"_209":1211},{"_33":209,"_209":217},{"_33":209,"_209":1210},{"_33":209,"_209":217},{"_33":209,"_209":1209},"prefer returning the interior type.","and much less easy to learn. This issue weighs heavily in the decision to","This would be very unergonomic and make async both much less pleasant to use",{"_233":234},[1214],{"_33":209,"_209":1215},"async fn foo<'ret, 'a: 'ret, 'b: 'ret>(x: &'a i32, y: &'b i32) -> impl Future + 'ret {\n *x + *y\n}",[1217,1218,1219,1220,1221,1222,1223],{"_33":209,"_209":1229},{"_33":209,"_209":217},{"_33":209,"_209":1228},{"_33":209,"_209":1125,"_212":1226},{"_33":209,"_209":1225},{"_33":209,"_209":217},{"_33":209,"_209":1224},"outer return type, it would become necessary to eliminate lifetime elision:"," does not capture any lifetimes. To accurately reflect the",[1227],{"_33":215},"default, ","As alluded to previously, the returned future captures all input lifetimes. By",{"_293":1072},[1232],{"_33":209,"_209":1233},"The lifetime elision problem",[1235,1236,1237,1238,1239,1240,1241],{"_33":209,"_209":1245},{"_33":209,"_209":217},{"_33":209,"_209":1244},{"_33":209,"_209":217},{"_33":209,"_209":1243},{"_33":209,"_209":217},{"_33":209,"_209":1242},"disadvantages.","return type in the function signature. This has both advantages and","in the function signature. This RFC proposes instead to display the \"inner\"","Most statically typed languages with async fns display the \"outer\" return type",[1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257],{"_33":209,"_209":1265},{"_33":209,"_209":217},{"_33":209,"_209":1264},{"_33":209,"_209":217},{"_33":209,"_209":1263},{"_33":209,"_209":211,"_212":1261},{"_33":209,"_209":1260},{"_33":209,"_209":217},{"_33":209,"_209":1259},{"_33":209,"_209":217},{"_33":209,"_209":1258},"call it.","and the \"exterior\" return type - the type that the function returns when you"," keyword,",[1262],{"_33":215},"\"interior\" return type - the type that you return with the ","There are two different perspectives on the return type of an async fn: the","The return type of an asynchronous function is a sort of complicated question.",{"_293":22},[1268,1269,1270,1271,1272],{"_33":209,"_209":1281},{"_33":209,"_209":1278,"_212":1279},{"_33":209,"_209":1277},{"_33":209,"_209":1274,"_212":1275},{"_33":209,"_209":1273},")","impl Future",[1276],{"_33":215}," instead of ","T",[1280],{"_33":215},"The return type (",[1283,1284,1285],{"_33":209,"_209":1287},{"_33":209,"_209":217},{"_33":209,"_209":1286},"opposed to those it merely postpones).","This section contains alternative design decisions which this RFC rejects (as",{"_293":570},[1290],{"_33":209,"_209":1291},"Rationale and alternatives",[1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303],{"_33":209,"_209":1309},{"_33":209,"_209":217},{"_33":209,"_209":1308},{"_33":209,"_209":217},{"_33":209,"_209":1307},{"_33":209,"_209":217},{"_33":209,"_209":1306},{"_33":209,"_209":217},{"_33":209,"_209":1305},{"_33":209,"_209":217},{"_33":209,"_209":1304},"appropriate section of the RFC.","The decisions we made on each of these questions are justified in the","functions in which they are evaluated immediately up to the first await point.","return type, for example. We could have a different evaluation model for async","There is a trade off between using the \"inner\" return type and the \"outer\"","There are drawbacks to several of the smaller decisions we have made as well.",[1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321],{"_33":209,"_209":1327},{"_33":209,"_209":217},{"_33":209,"_209":1326},{"_33":209,"_209":217},{"_33":209,"_209":1325},{"_33":209,"_209":217},{"_33":209,"_209":1324},{"_33":209,"_209":217},{"_33":209,"_209":1323},{"_33":209,"_209":217},{"_33":209,"_209":1322},"confident that this is the correct path forward.","costly because this exists. However, given our experience with futures, we are","Adding an alternative mechanism for asynchronous programming would be more","reverse course after stabilizing these features, it will be quite costly.","futures & async/await than we have previously as a project. If we decide to","This RFC, along with its companion lib RFC, makes a much firmer commitment to",[1329,1330,1331,1332,1333,1334,1335],{"_33":209,"_209":1339},{"_33":209,"_209":217},{"_33":209,"_209":1338},{"_33":209,"_209":217},{"_33":209,"_209":1337},{"_33":209,"_209":217},{"_33":209,"_209":1336},"expedient & low risk path to achieving that goal in the near future.","goals for 2018. Async & await syntax based on the Future trait is the most","success as a language for writing high performance network services, one of our","We believe that an ergonomic asynchronous IO solution is essential to Rust's",[1341,1342,1343,1344,1345,1346,1347,1348,1349],{"_33":209,"_209":1354},{"_33":209,"_209":217},{"_33":209,"_209":1353},{"_33":209,"_209":217},{"_33":209,"_209":1352},{"_33":209,"_209":217},{"_33":209,"_209":1351},{"_33":209,"_209":217},{"_33":209,"_209":1350},"significant addition mustn't be taken lightly, and only with strong motivation.","implies will grow as well (see the unresolved questions section). Such a","the smallest beachhead of features, in the long term the set of features it","one of the most significant additions since 1.0. Though we have started with","Adding async & await syntax to Rust is a major change to the language - easily",{"_293":570},[1357],{"_33":209,"_209":1358},"Drawbacks",{"_233":234},[1361],{"_33":209,"_209":1362},"async move {\n // body\n}",[1364,1365,1366,1367,1368,1369,1370,1371,1372,1373],{"_33":209,"_209":1384},{"_33":209,"_209":1381,"_212":1382},{"_33":209,"_209":1380},{"_33":209,"_209":217},{"_33":209,"_209":1379},{"_33":209,"_209":217},{"_33":209,"_209":1376,"_212":1377},{"_33":209,"_209":1375},{"_33":209,"_209":217},{"_33":209,"_209":1374},"significant for the meaning.",". Permitting only one ordering avoids confusion about whether it is","async move",[1378],{"_33":215},"the variables they close over. The order of the keywords is fixed to"," to capture ownership of","move",[1383],{"_33":215},"Async closures and blocks can be annotated with ",{"_293":22},[1387,1388,1389,1390],{"_33":209,"_209":1395},{"_33":209,"_209":668,"_212":1393},{"_33":209,"_209":275},{"_33":209,"_209":1381,"_212":1391},[1392],{"_33":215},[1394],{"_33":215},"The order of ",[1397,1398,1399,1400,1401,1402,1403,1404,1405,1406],{"_33":209,"_209":1419},{"_33":209,"_209":1416,"_212":1417},{"_33":209,"_209":1415},{"_33":209,"_209":217},{"_33":209,"_209":1414},{"_33":209,"_209":668,"_212":1412},{"_33":209,"_209":1411},{"_33":209,"_209":1408,"_212":1409},{"_33":209,"_209":217},{"_33":209,"_209":1407},"is a compiler builtin instead of an actual macro.","await!",[1410],{"_33":215}," functions. This is why ",[1413],{"_33":215},"expressed in the surface syntax within "," concept cannot be","yield",[1418],{"_33":215},"This is not a literal expansion, because the ",{"_233":234},[1422],{"_33":209,"_209":1423},"let mut future = IntoFuture::into_future($expression);\nlet mut pin = unsafe { Pin::new_unchecked(&mut future) };\nloop {\n match Future::poll(Pin::borrow(&mut pin), &mut ctx) {\n Poll::Ready(item) => break item,\n Poll::Pending => yield,\n }\n}",[1425,1426,1427],{"_33":209,"_209":1431},{"_33":209,"_209":1408,"_212":1429},{"_33":209,"_209":1428}," builtin expands roughly to this:",[1430],{"_33":215},"The ",{"_293":22},[1434],{"_33":209,"_209":1435},"The expansion of await",{"_233":234},[1438],{"_33":209,"_209":1439},"// only arg1's lifetime is captured in the returned future\nfn foo<'a>(arg1: &'a str, arg2: &str) -> impl Future + 'a {\n // do some initialization using arg2\n\n // closure which is evaluated immediately\n async move {\n // asynchronous portion of the function\n }\n}",[1441,1442,1443,1444,1445],{"_33":209,"_209":1450},{"_33":209,"_209":1199,"_212":1448},{"_33":209,"_209":1447},{"_33":209,"_209":217},{"_33":209,"_209":1446},"which is evaluated immediately:"," using a closure",[1449],{"_33":215},"One option is to write a function that returns ",[1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462],{"_33":209,"_209":1469},{"_33":209,"_209":217},{"_33":209,"_209":1468},{"_33":209,"_209":217},{"_33":209,"_209":1467},{"_33":209,"_209":217},{"_33":209,"_209":1466},{"_33":209,"_209":217},{"_33":209,"_209":1465},{"_33":209,"_209":687,"_212":1463},{"_33":209,"_209":916},[1464],{"_33":215},"arguments, this pattern cannot be expressed directly with an ","begin evaluating until you poll it, and it captures the lifetimes of its","with data conversion and temporary borrows. Because the async function does not","which should be performed during its construction. This is useful when dealing","One pattern that sometimes occurs is that a future has an \"initialization\" step",{"_293":1072},[1472],{"_33":209,"_209":1473},"\"Initialization\" pattern",[1475,1476,1477,1478,1479,1480,1481,1482,1483],{"_33":209,"_209":1492},{"_33":209,"_209":1125,"_212":1490},{"_33":209,"_209":1489},{"_33":209,"_209":217},{"_33":209,"_209":1488},{"_33":209,"_209":1278,"_212":1486},{"_33":209,"_209":1277},{"_33":209,"_209":1274,"_212":1484},{"_33":209,"_209":916},[1485],{"_33":215},[1487],{"_33":215},"lifetime. This is a big part of why the return type is ",", which does not capture the",[1491],{"_33":215},"This is different from the default for ",{"_233":234},[1495],{"_33":209,"_209":1496},"fn foo<'a>(arg: &'a str) -> impl Future + 'a { ... }",[1498],{"_33":209,"_209":1499},"It has an equivalent type signature to this:",{"_233":234},[1502],{"_33":209,"_209":1503},"async fn foo(arg: &str) -> usize { ... }",[1505,1506,1507,1508,1509,1510,1511],{"_33":209,"_209":1515},{"_33":209,"_209":217},{"_33":209,"_209":1514},{"_33":209,"_209":217},{"_33":209,"_209":1513},{"_33":209,"_209":217},{"_33":209,"_209":1512},"like this:","in its initial state (and possibly later states). That is, given a function","by the async function, because it stores all of the arguments to the function","All of the input lifetimes to this function are captured in the future returned",{"_293":22},[1518],{"_33":209,"_209":1519},"Lifetime capture in the anonymous future",[1521,1522,1523,1524,1525,1526,1527,1528],{"_33":209,"_209":1537},{"_33":209,"_209":307,"_212":1535},{"_33":209,"_209":1534},{"_33":209,"_209":217},{"_33":209,"_209":1531,"_212":1532},{"_33":209,"_209":1530},{"_33":209,"_209":217},{"_33":209,"_209":1529},"means it needs to never be moved.",". This is because the future could have internal references which","impl !Unpin",[1533],{"_33":215}," trait - that is",[1536],{"_33":215},"The anonymous return type has a negative impl for the ",[1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557],{"_33":209,"_209":1582},{"_33":209,"_209":925,"_212":1580},{"_33":209,"_209":1579},{"_33":209,"_209":217},{"_33":209,"_209":1576,"_212":1577},{"_33":209,"_209":1575},{"_33":209,"_209":1572,"_212":1573},{"_33":209,"_209":217},{"_33":209,"_209":1571},{"_33":209,"_209":530,"_212":1569},{"_33":209,"_209":1568},{"_33":209,"_209":1559,"_212":1566},{"_33":209,"_209":1565},{"_33":209,"_209":217},{"_33":209,"_209":211,"_212":1563},{"_33":209,"_209":1562},{"_33":209,"_209":1559,"_212":1560},{"_33":209,"_209":217},{"_33":209,"_209":1558},"once will panic.","Ready",[1561],{"_33":215}," point. Any attempt to poll it after it has already returned ",[1564],{"_33":215}," with the item when it hits a",[1567],{"_33":215}," point, and ",[1570],{"_33":215},"when it hits an ","Pending",[1574],{"_33":215},". Polling it advances the state of the function, returning ","Item",[1578],{"_33":215},", with the return type as its",[1581],{"_33":215},"The anonymous return type implements ",{"_293":1072},[1585],{"_33":209,"_209":1586},"Trait bounds",[1588,1589,1590],{"_33":209,"_209":1592},{"_33":209,"_209":217},{"_33":209,"_209":1591},"state, which contains all of the arguments to this function.","When the function is called, this anonymous type is returned in its initial",[1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604],{"_33":209,"_209":1610},{"_33":209,"_209":217},{"_33":209,"_209":1609},{"_33":209,"_209":217},{"_33":209,"_209":1608},{"_33":209,"_209":217},{"_33":209,"_209":1607},{"_33":209,"_209":217},{"_33":209,"_209":1606},{"_33":209,"_209":217},{"_33":209,"_209":1605},"point.","stores the state that is needed to be stored to resume control from that yield","the beginning of it, the await expressions, and every return. Each variant","being like an enum, with one variant for every \"yield point\" of the function -","the compiler, similar to the type of a closure. You can think of this type as","The return type of an async function is a unique anonymous type generated by",{"_293":22},[1613,1614,1615],{"_33":209,"_209":1619},{"_33":209,"_209":668,"_212":1617},{"_33":209,"_209":1616}," functions, closures, and blocks",[1618],{"_33":215},"Return type of ",{"_184":1621,"_186":1622,"_188":1623,"_190":191,"_192":193},"7f427458-70a0-4a3d-9f6b-2047e37e6ee5","We plan to make `async`/`await` keywords only in the 2018 edition. Does your codebase use `async` or `await` as identifiers today?","short_text",[1625,1626,1627,1628,1629],{"_33":209,"_209":1635},{"_33":209,"_209":668,"_212":1633},{"_33":209,"_209":275},{"_33":209,"_209":530,"_212":1631},{"_33":209,"_209":1630}," become keywords, gated on the 2018 edition.",[1632],{"_33":215},[1634],{"_33":215},"Both ",{"_293":22},[1638],{"_33":209,"_209":1639},"Keywords",{"_293":570},[1642],{"_33":209,"_209":1643},"Reference-level explanation",[1645,1646,1647,1648,1649],{"_33":209,"_209":1654},{"_33":209,"_209":1408,"_212":1652},{"_33":209,"_209":1651},{"_33":209,"_209":217},{"_33":209,"_209":1650},"later. See more information in the unresolved questions section.)"," is a compiler built-in to leave space for deciding its exact syntax",[1653],{"_33":215},"(",[1656,1657,1658,1659],{"_33":209,"_209":1408,"_212":1662},{"_33":209,"_209":1661},{"_33":209,"_209":217},{"_33":209,"_209":1660},"Using it outside of that context is an error."," can only be used inside of an async function, closure, or block.",[1663],{"_33":215},[1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675],{"_33":209,"_209":1688},{"_33":209,"_209":1685,"_212":1686},{"_33":209,"_209":1684},{"_33":209,"_209":217},{"_33":209,"_209":1683},{"_33":209,"_209":1680,"_212":1681},{"_33":209,"_209":1156},{"_33":209,"_209":217},{"_33":209,"_209":1679},{"_33":209,"_209":1676,"_212":1677},{"_33":209,"_209":916},"Poll::Ready",[1678],{"_33":215},"eventually evaluating to the item value when it returns ","Poll::Pending",[1682],{"_33":215},"yielding control of the function when it returns "," on the future it receives,","poll",[1687],{"_33":215},"The expansion of await repeatedly calls ",{"_233":234},[1691],{"_33":209,"_209":1692},"// future: impl Future\nlet n = await!(future);",[1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707],{"_33":209,"_209":1723},{"_33":209,"_209":1408,"_212":1721},{"_33":209,"_209":1720},{"_33":209,"_209":1408,"_212":1718},{"_33":209,"_209":1717},{"_33":209,"_209":217},{"_33":209,"_209":1716},{"_33":209,"_209":217},{"_33":209,"_209":1408,"_212":1714},{"_33":209,"_209":1713},{"_33":209,"_209":1710,"_212":1711},{"_33":209,"_209":1709},{"_33":209,"_209":217},{"_33":209,"_209":1708},"value of the item type that that future has.",", and evaluates to a","IntoFuture",[1712],{"_33":215}," takes any expression which implements ",[1715],{"_33":215},"\"pause\" the computation of the future, yielding control back to the caller."," can be used to",[1719],{"_33":215}," is added to the compiler. ",[1722],{"_33":215},"A builtin called ",{"_293":22},[1726,1727,1728],{"_33":209,"_209":1431},{"_33":209,"_209":1408,"_212":1730},{"_33":209,"_209":1729}," compiler built-in",[1731],{"_33":215},[1733,1734,1735,1736,1737,1738,1739,1740,1741],{"_33":209,"_209":1752},{"_33":209,"_209":668,"_212":1750},{"_33":209,"_209":1749},{"_33":209,"_209":668,"_212":1747},{"_33":209,"_209":1746},{"_33":209,"_209":1381,"_212":1744},{"_33":209,"_209":1743},{"_33":209,"_209":217},{"_33":209,"_209":1742},"ownership of the variables they close over."," to capture",[1745],{"_33":215}," blocks can be annotated with ",[1748],{"_33":215}," closures, ",[1751],{"_33":215},"As with ",[1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772],{"_33":209,"_209":1791},{"_33":209,"_209":211,"_212":1789},{"_33":209,"_209":278},{"_33":209,"_209":224,"_212":1787},{"_33":209,"_209":275},{"_33":209,"_209":272,"_212":1785},{"_33":209,"_209":1784},{"_33":209,"_209":217},{"_33":209,"_209":1783},{"_33":209,"_209":1780,"_212":1781},{"_33":209,"_209":1779},{"_33":209,"_209":217},{"_33":209,"_209":1778},{"_33":209,"_209":256,"_212":1776},{"_33":209,"_209":1775},{"_33":209,"_209":217},{"_33":209,"_209":1774},{"_33":209,"_209":217},{"_33":209,"_209":1773},"questions).","should work inside async blocks has not yet been established (see unresolved","-operator and early returns",[1777],{"_33":215},"context like a closure or a loop). How the "," (unless they appear within a fresh control-flow","body",[1782],{"_33":215},"not allowed within "," are",[1786],{"_33":215},[1788],{"_33":215},[1790],{"_33":215},"except that control-flow constructs like ",{"_233":234},[1794],{"_33":209,"_209":1795},"async { /* body */ }\n\n// is equivalent to\n\n(async || { /* body */ })()",[1797,1798,1799,1800,1801],{"_33":209,"_209":1806},{"_33":209,"_209":668,"_212":1804},{"_33":209,"_209":1803},{"_33":209,"_209":217},{"_33":209,"_209":1802},"That is:"," closure.",[1805],{"_33":215},"This form is almost equivalent to an immediately-invoked ",{"_233":234},[1809],{"_33":209,"_209":1810},"let my_future = async {\n println!(\"Hello from an async block\");\n};",[1812,1813,1814],{"_33":209,"_209":1818},{"_33":209,"_209":668,"_212":1816},{"_33":209,"_209":1815}," block:",[1817],{"_33":215},"You can create a future directly as an expression using an ",{"_293":22},[1821,1822],{"_33":209,"_209":668,"_212":1824},{"_33":209,"_209":1823}," blocks",[1825],{"_33":215},[1827,1828,1829,1830,1831,1832],{"_33":209,"_209":668,"_212":1838},{"_33":209,"_209":1837},{"_33":209,"_209":1381,"_212":1835},{"_33":209,"_209":1834},{"_33":209,"_209":217},{"_33":209,"_209":1833},"variables they close over."," to capture ownership of the",[1836],{"_33":215}," closures can be annotated with ",[1839],{"_33":215},[1841,1842,1843],{"_33":209,"_209":1845},{"_33":209,"_209":217},{"_33":209,"_209":1844},"async closure.\"","This will print both \"Hello from main\" statements before printing \"Hello from",{"_233":234},[1848],{"_33":209,"_209":1849},"fn main() {\n let closure = async || {\n println!(\"Hello from async closure.\");\n };\n println!(\"Hello from main\");\n let future = closure();\n println!(\"Hello from main again\");\n futures::block_on(future);\n}",[1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861],{"_33":209,"_209":1871},{"_33":209,"_209":217},{"_33":209,"_209":1870},{"_33":209,"_209":1274,"_212":1868},{"_33":209,"_209":1867},{"_33":209,"_209":217},{"_33":209,"_209":1866},{"_33":209,"_209":1278,"_212":1864},{"_33":209,"_209":1863},{"_33":209,"_209":217},{"_33":209,"_209":1862},"evaluating any of the body (just like an async function).",". When you call that closure, it returns a future immediately without",[1865],{"_33":215},"than ",", rather",[1869],{"_33":215},"function, an async closure has a return type of ","In addition to functions, async can also be applied to closures. Like an async",{"_293":1072},[1874,1875],{"_33":209,"_209":691,"_212":1877},{"_33":209,"_209":1876}," closures",[1878],{"_33":215},[1880,1881,1882,1883,1884,1885,1886,1887],{"_33":209,"_209":1897},{"_33":209,"_209":1894,"_212":1895},{"_33":209,"_209":1893},{"_33":209,"_209":217},{"_33":209,"_209":1890,"_212":1891},{"_33":209,"_209":1889},{"_33":209,"_209":217},{"_33":209,"_209":1888},"generated by the compiler.",". The return type is an anonymous type","fn(args..) -> impl Future",[1892],{"_33":215}," is a function of the type","async fn foo(args..) -> T",[1896],{"_33":215},"An ",[1899,1900,1901,1902,1903],{"_33":209,"_209":1911},{"_33":209,"_209":1908,"_212":1909},{"_33":209,"_209":1907},{"_33":209,"_209":1904,"_212":1905},{"_33":209,"_209":916},"\"Hello from print_async\"",[1906],{"_33":215}," before printing ","\"Hello from main\"",[1910],{"_33":215},"This will print ",{"_233":234},[1914],{"_33":209,"_209":1915},"async fn print_async() {\n println!(\"Hello from print_async\")\n}\n\nfn main() {\n let future = print_async();\n println!(\"Hello from main\");\n futures::executor::block_on(future);\n}",[1917,1918,1919,1920,1921],{"_33":209,"_209":1924},{"_33":209,"_209":217},{"_33":209,"_209":1923},{"_33":209,"_209":217},{"_33":209,"_209":1922},"function. For example:","function actually runs until you begin polling the future returned by the","An async function is a kind of delayed computation - nothing in the body of the",[1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938],{"_33":209,"_209":1949},{"_33":209,"_209":217},{"_33":209,"_209":1948},{"_33":209,"_209":217},{"_33":209,"_209":1947},{"_33":209,"_209":925,"_212":1945},{"_33":209,"_209":1944},{"_33":209,"_209":217},{"_33":209,"_209":1943},{"_33":209,"_209":530,"_212":1941},{"_33":209,"_209":1940},{"_33":209,"_209":217},{"_33":209,"_209":1939},"the await syntax section next)."," or return point inside of it (see",[1942],{"_33":215},"function is evaluated up to the next ",". As that future is polled, the",[1946],{"_33":215},"anonymous type which implements ","is called, it does not enter the body immediately. Instead, it evaluates to an","Async functions work differently from normal functions. When an async function",{"_233":234},[1952],{"_33":209,"_209":1953},"async fn function(argument: &str) -> usize {\n // ...\n}",[1955,1956,1957,1958,1959],{"_33":209,"_209":1964},{"_33":209,"_209":668,"_212":1962},{"_33":209,"_209":1961},{"_33":209,"_209":217},{"_33":209,"_209":1960},"functions\":"," keyword, making them \"async",[1963],{"_33":215},"Functions can be annotated with the ",{"_293":22},[1967],{"_33":209,"_209":1968},"Async functions",{"_293":570},[1971],{"_33":209,"_209":1972},"Guide-level explanation",{"_184":1974,"_186":1975,"_188":297,"_190":1976,"_192":193},"08be2569-af96-4138-b2c2-5a18c1db5ff7","Today, when you share state across await points, which workaround do you most often reach for?","{\"options\":[{\"id\":\"0\",\"label\":\"Arc/Mutex\"},{\"id\":\"1\",\"label\":\"join/combinator chaining\"},{\"id\":\"2\",\"label\":\"restructuring to avoid sharing\"},{\"id\":\"3\",\"label\":\"other\"}]}",[1978,1979,1980,1981,1982,1983,1984,1985,1986,1987,1988],{"_33":209,"_209":1994},{"_33":209,"_209":217},{"_33":209,"_209":1993},{"_33":209,"_209":217},{"_33":209,"_209":1992},{"_33":209,"_209":217},{"_33":209,"_209":1991},{"_33":209,"_209":217},{"_33":209,"_209":1990},{"_33":209,"_209":217},{"_33":209,"_209":1989},"asynchronous IO.","use cases for async & await will also flourish, that are not tied directly to","IO, but by introducing first class syntax and libstd support we believe more","IO space. The use cases we've experience with today are generally tied to async","concurrency in general, and likely has applications outside of the asynchronous","Async/await & futures can be a powerful abstraction for asynchronicity and",[1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010],{"_33":209,"_209":2018},{"_33":209,"_209":217},{"_33":209,"_209":2017},{"_33":209,"_209":217},{"_33":209,"_209":2016},{"_33":209,"_209":217},{"_33":209,"_209":2015},{"_33":209,"_209":217},{"_33":209,"_209":2014},{"_33":209,"_209":217},{"_33":209,"_209":2013},{"_33":209,"_209":217},{"_33":209,"_209":2012},{"_33":209,"_209":217},{"_33":209,"_209":2011},"functions and calls.","use async/await as if it were synchronous code, and only need to annotate their","control while the future is being polled. From a user's perspective, they can","futures can be awaited using an await expression, which causes them to yield","than evaluating immediately when it is called. Inside the function, other","await keywords. In brief, an asynchronous function returns a future, rather","sugar which has become common in many languages with async IO - the async and","Fortunately, the Future abstraction is well suited to use with a syntactic",[2020,2021,2022,2023,2024,2025,2026,2027,2028,2029,2030],{"_33":209,"_209":2036},{"_33":209,"_209":217},{"_33":209,"_209":2035},{"_33":209,"_209":217},{"_33":209,"_209":2034},{"_33":209,"_209":217},{"_33":209,"_209":2033},{"_33":209,"_209":217},{"_33":209,"_209":2032},{"_33":209,"_209":217},{"_33":209,"_209":2031},"callbacks.","writing a future, they still often led to messy sets of nested and chained","chaining - and while combinators were often more ergonomic than manually","across await points was extremely unergonomic - requiring either Arcs or join","discovered certain ergonomics challenges. Using state which needs to be shared","After gaining experience & user feedback with the futures-based ecosystem, we",[2038,2039,2040,2041,2042,2043,2044,2045,2046,2047,2048,2049,2050,2051,2052,2053,2054,2055,2056],{"_33":209,"_209":2066},{"_33":209,"_209":217},{"_33":209,"_209":2065},{"_33":209,"_209":217},{"_33":209,"_209":2064},{"_33":209,"_209":217},{"_33":209,"_209":2063},{"_33":209,"_209":217},{"_33":209,"_209":2062},{"_33":209,"_209":217},{"_33":209,"_209":2061},{"_33":209,"_209":217},{"_33":209,"_209":2060},{"_33":209,"_209":217},{"_33":209,"_209":2059},{"_33":209,"_209":217},{"_33":209,"_209":2058},{"_33":209,"_209":217},{"_33":209,"_209":2057},"implemented using the futures interfaces.","tokio library provided a mio-based event loop that could execute code","by providing a convenient, shared abstraction for asynchronous operations. The","Windows. In mid-2016, the introduction of the futures crate had a major impact","cross-platform abstraction over the async IO primitives of Linux, Mac OS, and","asynchronous IO initially focused around the mio library, which provided a","program written in Rust - and it was removed shortly before 1.0. After 1.0,","the language. However, this proved too opinionated - because it impacted every","Prior to 1.0, we experimented with having a green-threading runtime built into","The development of asynchronous IO in Rust has gone through multiple phases.",[2068,2069,2070,2071,2072,2073,2074,2075,2076,2077,2078],{"_33":209,"_209":2084},{"_33":209,"_209":217},{"_33":209,"_209":2083},{"_33":209,"_209":217},{"_33":209,"_209":2082},{"_33":209,"_209":217},{"_33":209,"_209":2081},{"_33":209,"_209":217},{"_33":209,"_209":2080},{"_33":209,"_209":217},{"_33":209,"_209":2079},"network services in Rust.","adoption by other users - by making it more ergonomic to write asynchronous","services space, and we wish to continue to enable those users - and to enable","many concurrent connections. Rust has seen some adoption in the network","blocking IO, because it can be easier to get optimal performance when handling","High performance network services frequently use asynchronous IO, rather than",{"_293":570},[2087],{"_33":209,"_209":2088},"Motivation",[2090,2091,2092],{"_33":209,"_209":2101},{"_33":209,"_209":2094,"_212":2095},{"_33":209,"_209":2093}," to add a small futures API to libstd and libcore.","a companion RFC",[2096],{"_33":2097,"_182":2098},"link",{"_2099":2100},"href","2592-futures.md","This has ",[2103,2104,2105],{"_33":209,"_209":2107},{"_33":209,"_209":217},{"_33":209,"_209":2106},"futures.","Add async & await syntaxes to make it more ergonomic to write code manipulating",{"_293":570},[2110],{"_33":209,"_209":2111},"Summary","clerkState",{"_2114":2115},"__internal_clerk_state",{"_2116":2117,"_2118":2119,"_2120":193,"_2121":193,"_2122":2123,"_2124":2125,"_2126":2127,"_2128":-7,"_2129":2130,"_2131":-7,"_2132":-7,"_2133":2134,"_2135":-7,"_2136":-7,"_2137":-7,"_2138":-7,"_2139":-7,"_2140":2123,"_2141":2123,"_2142":2123},"__clerk_ssr_state",{"_2152":2153,"_2154":-5,"_2155":-5,"_2156":-5,"_2157":-5,"_2158":-5,"_2159":-5,"_2160":-5,"_2161":-5,"_2162":-5,"_2163":-5,"_2164":2165,"_2166":2167,"_2168":2169,"_2144":2123},"__publishableKey","pk_live_Y2xlcmsudXNlaW5rbGluZy5jb20k","__proxyUrl","__domain","__isSatellite",false,"__signInUrl","/sign-in","__signUpUrl","/sign-up","__signInForceRedirectUrl","__signUpForceRedirectUrl","/onboarding","__signInFallbackRedirectUrl","__signUpFallbackRedirectUrl","__clerk_debug",{"_2143":2123,"_2144":2123,"_2145":193,"_2146":2147,"_2148":193,"_2149":2119,"_2150":2123,"_2151":193},"__clerkJSUrl","__clerkJSVersion","__clerkUIUrl","__clerkUIVersion","__prefetchUI","__telemetryDisabled","__telemetryDebug","__unsafeDisableDevelopmentModeConsoleWarning","isSignedIn","isAuthenticated","proxyUrl","reason","session-token-and-uat-missing","message","publishableKey","isSatellite","domain","tokenType","session_token","sessionClaims","sessionId","sessionStatus","userId","actor","orgId","orgRole","orgSlug","orgPermissions","factorVerificationAge","getToken",["SingleFetchFallback"],"has",["SingleFetchFallback"],"debug",["SingleFetchFallback"]]