Future与promise (Chinese Wikipedia)

Henry Baker; Carl Hewitt. The Incremental Garbage Collection of Processes. Proceedings of the Symposium on Artificial Intelligence Programming Languages,. ACM Sigplan Notices 12, 8: 55–59. August 1977 [2024-01-26]. （原始内容存档于2024-04-12）. In this paper we consider an "eager beaver" evaluator for an applicative programming language which starts evaluating every subexpression as soon as possible, and in parallel. This is done through the mechanism of futures, which are roughly Algol-60 "thunks" which have their own evaluator process ("thinks"?). (Friedman and Wise [10] call futures "promises", while Hibbard [13] calls them "eventuals".) When an expression is given to the evaluator by the user, a future for that expression is returned which is a promise to deliver the value of that expression at some later time, if the expression has a value. A process is created for each new future which immediately starts to work evaluating the given expression. ……
The intuitive semantics associated with a future is that it runs asynchronously with its parent's evaluation. This effect can be achieved by either assigning a different processor to each future, or by multiplexing all of the futures on a few processors. Given one such implementation, the language can easily be extended with a construct having the following form: "(EITHER <e₁> <e₂> … <e_n>)" means evaluate the expressions <e_i> in parallel and return the value of "the first one that finishes".
Barbara Liskov; Liuba Shrira. Promises: Linguistic Support for Efficient Asynchronous Procedure Calls in Distributed Systems. Proceedings of the SIGPLAN '88 Conference on Programming Language Design and Implementation; Atlanta, Georgia, United States. ACM: 260–267. 1988 [2024-01-26]. ISBN 0-89791-269-1. doi:10.1145/53990.54016. （原始内容存档于2024-01-26）. Promises were designed to support an efficient asynchronous remote procedure call mechanism for use by components of a distributed program. A promise is a place holder for a value that will exist in the future. It is created at the time a call is made. The call computes the value of the promise, running in parallel with the program that made the call. When it completes, its results are stored in the promise and can then be “claimed” by the caller. ……
Call-streams allow a sender to make a sequence of calls to a receiver without waiting for replies. The stream guarantees that the calls will be delivered to the receiver in the order they were made and that the replies from the receiver will be delivered to the sender in call order. ……
The design of promises was influenced by the future mechanism of MultiLisp[5]. Like futures, promises allow the result of a call to be picked up later. However, promises extend futures in several ways: Promises are strongly typed and thus avoid the need for runtime checking to distinguish them from ordinary values. They allow exceptions from the called procedure to be propagated in a convenient manner. Finally, they are integrated with the call-stream mechanism and address problems such as node failures and network partitions that do not arise in a single-machine environment. ……
There are two reasons for using stream calls instead of RPCs: they allow the caller to run in parallel with the sending and processing of the call, and they reduce the cost of transmitting the call and reply messages. RPCs and their replies are sent over the network immediately, to minimize the delay for a call. Stream calls and their replies, however, are buffered and sent when convenient; in the case of sends, normal replies can be omitted. Buffering allows us to amortize the overhead of kernel calls and the transmission delays for messages over several calls, especially for small calls and replies. Also published in ACM SIGPLAN Notices 23(7).
Domenico Talia. Survey and comparison of PARLOG and Concurrent Prolog. 1990 [2024-03-13]. （原始内容存档于2024-03-13）. Concurrent logic languages are born from a new interpretation of Horn clauses, the process interpretation. According to this interpretation, an atomic goal ← C can be viewed as a process, a conjunctive goal ← C₁, …, C_n, as a process network, and a logic variable shared between two clauses can be viewed as a communication channel between two processes.

angularjs.org

AngularJS — Superheroic JavaScript MVW Framework. angularjs.org. [2019-01-04]. （原始内容存档于2015-06-23）.

aosabook.org

500 lines or less, "A Web Crawler With asyncio Coroutines" by A. Jesse Jiryu Davis and Guido van Rossum （页面存档备份，存于互联网档案馆） says "implementation uses an asyncio.Event in place of the Future shown here. The difference is an Event can be reset, whereas a Future cannot transition from resolved back to pending."

apple.com

developer.apple.com

Dispatch - Apple Developer Documentation. developer.apple.com. [2019-01-04]. （原始内容存档于2018-12-31）.

appliedgo.net

Futures in Go, no package required. [2024-03-08]. （原始内容存档于2024-03-08）.

archive-it.org

wayback.archive-it.org

Lazy. caml.inria.fr. [2018-12-31]. （原始内容存档于2015-07-06）.

bitbucket.org

al45tair / Async. bitbucket.org. [2018-12-31]. （原始内容存档于2018-12-31）.

boost.org

Chapter 30. Thread 4.0.0. [2013-06-26]. （原始内容存档于2019-10-16）.
Dlib C++ Library #thread_pool. [2013-06-26]. （原始内容存档于2019-10-16）.

c2.com

Promise Pipelining on the C2 wiki. [2018-12-31]. （原始内容存档于2005-09-25）.

celluloid.io

Celluloid: Actor-based Concurrent Objects for Ruby. celluloid.io. [2019-01-04]. （原始内容存档于2018-12-31）.

codehaus.org

gpars.codehaus.org

Groovy GPars. [2018-12-31]. （原始内容存档于2013-01-12）.

common-lisp.net

Eager Future2. common-lisp.net. [2019-01-04]. （原始内容存档于2018-12-31）.

commonjs.org

wiki.commonjs.org

CommonJS Promises/A（页面存档备份，存于互联网档案馆）
Kris Zyp. Promise API Proposal. 2009-05-25 [2024-03-20]. （原始内容存档于2024-03-20）.
CommonJS — Promises. [2024-03-20]. （原始内容存档于2024-03-20）.

cujojs.com

cujoJS: Javascript architectural toolkit. cujojs.com. [2019-01-04]. （原始内容存档于2012-03-17）.

dartlang.org

Gilad Bracha. Dart Language Asynchrony Support: Phase 1. October 2014 [2018-12-31]. （原始内容存档于2016-07-02）.

api.dartlang.org

Dart SDK dart async Completer. [2018-12-31]. （原始内容存档于2016-03-04）.

dist-prog-book.com

Kisalaya Prasad, Avanti Patil, Heather Miller. Futures and Promises. [2024-03-11]. （原始内容存档于2024-03-03）.

doi.org

Halstead, Robert H. Jr. MultiLisp: A Language for Concurrent Symbolic Computation. ACM Transactions on Programming Languages and Systems. October 1985, 7 (4): 501–538. S2CID 1285424. doi:10.1145/4472.4478 . Multilisp's principal construct for both creating tasks and synchronizing among them is the future. The construct (future X) immediately returns a future for the value of the expression X and concurrently begins evaluating X. When the evaluation of X yields a value, that value replaces the future. The future is said to be initially undetermined; it becomes determined when its value has been computed. An operation (such as addition) that needs to know the value of an undetermined future will be suspended until the future becomes determined, but many operations, such as assignment and parameter passing, do not need to know anything about the values of their operands and may be performed quite comfortably on undetermined futures. ……
The future construct in Multilisp, for example, offers a way to introduce parallelism that fits very nicely with the principal program operation of Multilisp — expression evaluation. Also, no special care is required to use a value generated by future. Synchronization between the producer and the users of a future’s value is implicit, freeing the programmer’s mind from a possible source of concern.
Barbara Liskov; Liuba Shrira. Promises: Linguistic Support for Efficient Asynchronous Procedure Calls in Distributed Systems. Proceedings of the SIGPLAN '88 Conference on Programming Language Design and Implementation; Atlanta, Georgia, United States. ACM: 260–267. 1988 [2024-01-26]. ISBN 0-89791-269-1. doi:10.1145/53990.54016. （原始内容存档于2024-01-26）. Promises were designed to support an efficient asynchronous remote procedure call mechanism for use by components of a distributed program. A promise is a place holder for a value that will exist in the future. It is created at the time a call is made. The call computes the value of the promise, running in parallel with the program that made the call. When it completes, its results are stored in the promise and can then be “claimed” by the caller. ……
Call-streams allow a sender to make a sequence of calls to a receiver without waiting for replies. The stream guarantees that the calls will be delivered to the receiver in the order they were made and that the replies from the receiver will be delivered to the sender in call order. ……
The design of promises was influenced by the future mechanism of MultiLisp[5]. Like futures, promises allow the result of a call to be picked up later. However, promises extend futures in several ways: Promises are strongly typed and thus avoid the need for runtime checking to distinguish them from ordinary values. They allow exceptions from the called procedure to be propagated in a convenient manner. Finally, they are integrated with the call-stream mechanism and address problems such as node failures and network partitions that do not arise in a single-machine environment. ……
There are two reasons for using stream calls instead of RPCs: they allow the caller to run in parallel with the sending and processing of the call, and they reduce the cost of transmitting the call and reply messages. RPCs and their replies are sent over the network immediately, to minimize the delay for a call. Stream calls and their replies, however, are buffered and sent when convenient; in the case of sends, normal replies can be omitted. Buffering allows us to amortize the overhead of kernel calls and the transmission delays for messages over several calls, especially for small calls and replies. Also published in ACM SIGPLAN Notices 23(7).

dojotoolkit.org

Dojo Deferreds and Promises - Archived Tutorial - Dojo Toolkit. dojotoolkit.org. [2019-01-04]. （原始内容存档于2018-12-31）.

elm-lang.org

package.elm-lang.org

Task. [2018-12-31]. （原始内容存档于2018-12-31）.

erights.org

Pipeline, E rights, [2018-12-31], （原始内容存档于2018-10-22）
Promise Pipelining. www.erights.org. [2018-12-31]. （原始内容存档于2018-10-22）.

wiki.erights.org

Promise, E rights, [2018-12-31], （原始内容存档于2018-12-31）

geeksforgeeks.org

Future and FutureTask in java. [2024-03-11]. （原始内容存档于2024-03-11）.

github.com

Rich Hickey. changes.txt at 1.1.x from richhickey's clojure. 2009 [2018-12-31]. （原始内容存档于2016-02-18）.
GitHub – facebook/folly: An open-source C++ library developed and used at Facebook.. [2018-12-31]. （原始内容存档于2019-03-22）.
A solid, fast Promises/A+ and when() implementation, plus other async goodies.: cujojs/when. 2018-12-25 [2018-12-31]. （原始内容存档于2019-01-16） –通过GitHub.
kriskowal/q. [2024-01-24]. （原始内容存档于2024-05-09）.
A lightweight library that provides tools for organizing asynchronous code: tildeio/rsvp.js. 2019-01-03 [2018-12-31]. （原始内容存档于2019-01-17） –通过GitHub.
:bird: :zap: Bluebird is a full featured promise library with unmatched performance.: petkaantonov/bluebird. 2019-01-04 [2018-12-31]. （原始内容存档于2018-12-28） –通过GitHub.
promise（页面存档备份，存于互联网档案馆）
Asynchronous Java made easier. Contribute to linkedin/parseq development by creating an account on GitHub. 2018-12-29 [2018-12-31]. （原始内容存档于2018-06-10） –通过GitHub.
Proxying futures library for Objective-C. Contribute to mikeash/MAFuture development by creating an account on GitHub. 2019-01-01 [2018-12-31]. （原始内容存档于2019-02-13） –通过GitHub.
An Objective-C Class which implements the Promises/A+ specification.: couchdeveloper/RXPromise. 2018-12-26 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.
Futures, for Objective-C, that automatically collapse so it's nearly impossible to mix up the level of future nesting despite the lack of generics.: Strilanc/ObjC-CollapsingFutures. 2018-12-07 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.
Promises for Swift & ObjC. Contribute to mxcl/PromiseKit development by creating an account on GitHub. 2019-01-03 [2019-01-04]. （原始内容存档于2019-01-08） –通过GitHub.
Objective-C Promises in the CommonJS style. Contribute to mproberts/objc-promise development by creating an account on GitHub. 2018-09-11 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.
OAPromise is an API separating async operations and their callbacks, adding consistency and useful features like fall-through errors and progress reports.: oleganza/OAPromise. 2017-03-29 [2018-12-31]. （原始内容存档于2013-10-27） –通过GitHub.
Promises/A implementation for PHP. Contribute to reactphp/promise development by creating an account on GitHub. 2019-01-04 [2018-12-31]. （原始内容存档于2019-04-07） –通过GitHub.
promise — Ultra-performant Promise implementation in Python. [2024-01-23]. （原始内容存档于2024-01-23）.
Ruby bindings for libuv. Contribute to cotag/libuv development by creating an account on GitHub. 2018-10-16 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.
Wait on resources being set in the future. Contribute to adhearsion/future-resource development by creating an account on GitHub. 2013-12-27 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.
Zero-cost asynchronous programming in Rust. Contribute to rust-lang-nursery/futures-rs development by creating an account on GitHub. 2019-01-04 [2019-01-04]. （原始内容存档于2019-02-26） –通过GitHub.
A Swift based Future/Promises Library for IOS and OS X.: FutureKit/FutureKit. 2018-12-31 [2018-12-31]. （原始内容存档于2018-08-10） –通过GitHub.
FutureLib is a pure Swift 2 library implementing Futures & Promises inspired by Scala.: couchdeveloper/FutureLib. 2018-10-15 [2018-12-31]. （原始内容存档于2018-06-12） –通过GitHub.
Work with values that haven't been determined yet.: bignerdranch/Deferred. 2019-01-02 [2019-01-04]. （原始内容存档于2018-06-10） –通过GitHub.
Write great asynchronous code in Swift using futures and promises: Thomvis/BrightFutures. 2019-01-03 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.

groups.google.com

Kris Zyp. Promise API Proposal. 2009-05-25 [2024-03-20]. （原始内容存档于2024-03-20）.
CommonJS — Promises. [2024-03-20]. （原始内容存档于2024-03-20）.

haskell.org

downloads.haskell.org

GHC User’s Guide — 6. Language extensions — 6.15. Parallel and Concurrent. [2024-03-13]. （原始内容存档于2024-03-13）.

haskell.org

Control Concurrent MVar, Haskell, [2018-12-31], （原始内容存档于2009-04-18）

ieeeghn.org

Liskov, Barbara, Distributed computing and Argus, Oral history, IEEE GHN, [2018-12-31], （原始内容存档于2014-11-22）

inria.fr

caml.inria.fr

Lazy. caml.inria.fr. [2018-12-31]. （原始内容存档于2015-07-06）.

iolanguage.org

Steve Dekorte. Io, The Programming Language. 2005 [2018-12-31]. （原始内容存档于2019-01-04）.

jdeferred.org

JDeferred. JDeferred. [2019-01-04]. （原始内容存档于2019-01-08）.

jquery.com

jQuery. [2018-12-31]. （原始内容存档于2012-02-29）.

api.jquery.com

Deferred Object. [2024-01-26]. （原始内容存档于2012-10-30）.

kotlinlang.org

Future – Kotlin Programming Language. [2024-03-12]. （原始内容存档于2024-03-12）.

lparallel.org并行Lisp

- Common Lisp的并行编程库^{[永久失效連結]}

marijnhaverbeke.nl

PCall. marijnhaverbeke.nl. [2018-12-31]. （原始内容存档于2020-08-06）.

metacpan.org

Future - represent an operation awaiting completion - metacpan.org. metacpan.org. [2019-01-04]. （原始内容存档于2019-01-01）.
Promises - An implementation of Promises in Perl - metacpan.org. metacpan.org. [2018-12-31]. （原始内容存档于2018-12-31）.
Reflex - Class library for flexible, reactive programs. - metacpan.org. metacpan.org. [2019-01-04]. （原始内容存档于2019-01-04）.

microsoft.com

devblogs.microsoft.com

Async in 4.5: Worth the Await – .NET Blog. April 3rd, 2012 [2024-03-20]. （原始内容存档于2024-03-20）. 请检查|date=中的日期值 (帮助)

msdn.microsoft.com

Asynchronous Programming with Async and Await (C# and Visual Basic). Msdn.microsoft.com. [2014-05-13]. （原始内容存档于2014-05-27）.

learn.microsoft.com

Task Parallel Library (TPL). [2024-03-11]. （原始内容存档于2024-05-21）.

mikeash.com

mikeash.com: Friday Q&A 2010-02-26: Futures. www.mikeash.com. [2019-01-04]. （原始内容存档于2018-12-31）.

mit.edu

pmg.csail.mit.edu

Argus, MIT, [2018-12-31], （原始内容存档于2018-04-27）

mochi.github.io

manage asynchronous tasks. MochiKit.Async. [2019-01-04]. （原始内容存档于2018-12-31）.

mozart-oz.org

Seif Haridi; Nils Franzen. Tutorial of Oz. Mozart Global User Library. [2011-04-12]. （原始内容存档于2011-05-14）.
WaitNeeded, Mozart Oz, [2018-12-31], （原始内容存档于2013-05-17）

mozilla.org

developer.mozilla.org

Using promises. Mozilla Developer Network. [23 February 2021]. （原始内容存档于2024-05-24）.
Making asynchronous programming easier with async and await. Mozilla Developer Network. [23 February 2021]. （原始内容存档于2022-03-05）.
Web Workers API. [2024-03-11]. （原始内容存档于2024-05-21）.
Worker threads API. [2024-03-25]. （原始内容存档于2024-05-11）.
threads.js — Make web workers & worker threads as simple as a function call. [2024-03-25]. （原始内容存档于2024-05-09）.

nodejs.org

Web Workers API. [2024-03-11]. （原始内容存档于2024-05-21）.
Worker threads API. [2024-03-25]. （原始内容存档于2024-05-11）.
threads.js — Make web workers & worker threads as simple as a function call. [2024-03-25]. （原始内容存档于2024-05-09）.

oracle.com

docs.oracle.com

java.util.concurrent.Future. [2024-03-11]. （原始内容存档于2024-05-21）.
java.util.concurrent.CompletableFuture. [2024-03-11]. （原始内容存档于2024-04-29）.

orthecreedence.github.io

Blackbird promise library - Blackbird. orthecreedence.github.io. [2018-12-31]. （原始内容存档于2017-11-10）.

pocoproject.org

Threads Slides of POCO (PDF). [2018-12-31]. （原始内容存档 (PDF)于2020-05-08）.

promisesaplus.com

Promises/A+. promisesaplus.com. [2019-01-04]. （原始内容存档于2018-12-29）.
Promises/A+ Conformant Implementations. [2018-12-31]. （原始内容存档于2018-12-31）.

psu.edu

citeseerx.ist.psu.edu

Kenjiro Taura; Satoshi Matsuoka; Akinori Yonezawa. ABCL/f: A Future-Based Polymorphic Typed Concurrent Object-Oriented Language – Its Design and Implementation.. In Proceedings of the DIMACS workshop on Specification of Parallel Algorithms, number 18 in Dimacs Series in Discrete Mathematics and Theoretical Computer Science. American Mathematical Society: 275–292. 1994. CiteSeerX 10.1.1.23.1161 .

python.org

PEP 0492 – Coroutines with async and await syntax. [2018-12-31]. （原始内容存档于2019-01-05）.
Python 3.2 发布. Python.org. [2018-12-31]. （原始内容存档于2018-12-31）.
PEP 3148 – futures - execute computations asynchronously. [2018-12-31]. （原始内容存档于2018-12-31）. The proposed design of this module was heavily influenced by the Java java.util.concurrent package [1]. The conceptual basis of the module, as in Java, is the Future class, which represents the progress and result of an asynchronous computation. The Future class makes little commitment to the evaluation mode being used e.g. it can be used to represent lazy or eager evaluation, for evaluation using threads, processes or remote procedure call.
Futures are created by concrete implementations of the Executor class (called ExecutorService in Java). The reference implementation provides classes that use either a process or a thread pool to eagerly evaluate computations.
Python 3.5.0 发布. Python.org. [2018-12-31]. （原始内容存档于2019-01-05）.

docs.python.org

The Python Standard Library — Concurrent Execution — concurrent.futures — Launching parallel tasks. [2018-12-31]. （原始内容存档于2018-12-31）.
The Python Standard Library — Networking and Interprocess Communication — asyncio — Asynchronous I/O. [2024-03-11]. （原始内容存档于2019-05-05）.

qt-project.org

QtCore 5.0: QFuture Class. Qt Project. [2013-06-26]. （原始内容存档于2013-06-01）.

r-project.org

cran.r-project.org

Bengtsson, Henrik. future: Unified Parallel and Distributed Processing in R for Everyone. 2018-10-17 [2018-12-31]. （原始内容存档于2019-10-16） –通过R-Packages.

racket-lang.org

docs.racket-lang.org

Parallelism with Futures. [2024-01-22]. （原始内容存档于2024-03-06）.

raku.org

docs.raku.org

class Promise. raku.org. [2022-08-19]. （原始内容存档于2024-03-12）.

researchgate.net

Don Syme; Tomas Petricek; Dmitry Lomov. The F# Asynchronous Programming Model, PADL 2011. 2010-10-21. This paper describes the asynchronous support in F# 2.0. While the core idea was released and published in book form 2007, the model has not been described in the conference literature.

rubygems.org

promise - RubyGems.org - your community gem host. rubygems.org. [2019-01-04]. （原始内容存档于2018-12-31）.

rust-lang.org

doc.rust-lang.org

Future in std::future - Rust. doc.rust-lang.org. [2023-12-16]. （原始内容存档于2024-05-22）.

scala-lang.org

docs.scala-lang.org

scala.concurrent包（页面存档备份，存于互联网档案馆）

seastar-project.org

Seastar. Seastar project. [2016-08-22]. （原始内容存档于2016-08-20）.

semanticscholar.org

api.semanticscholar.org

Halstead, Robert H. Jr. MultiLisp: A Language for Concurrent Symbolic Computation. ACM Transactions on Programming Languages and Systems. October 1985, 7 (4): 501–538. S2CID 1285424. doi:10.1145/4472.4478 . Multilisp's principal construct for both creating tasks and synchronizing among them is the future. The construct (future X) immediately returns a future for the value of the expression X and concurrently begins evaluating X. When the evaluation of X yields a value, that value replaces the future. The future is said to be initially undetermined; it becomes determined when its value has been computed. An operation (such as addition) that needs to know the value of an undetermined future will be suspended until the future becomes determined, but many operations, such as assignment and parameter passing, do not need to know anything about the values of their operands and may be performed quite comfortably on undetermined futures. ……
The future construct in Multilisp, for example, offers a way to introduce parallelism that fits very nicely with the principal program operation of Multilisp — expression evaluation. Also, no special care is required to use a value generated by future. Synchronization between the producer and the users of a future’s value is implicit, freeing the programmer’s mind from a possible source of concern.

sitepen.com

Robust promises with Dojo deferred, Site Pen, 2010-05-03 [2018-12-31], （原始内容存档于2018-12-31）

sourceforge.net

tcl-promise. SourceForge. [2018-12-31]. （原始内容存档于2018-12-31）.

sunless-sea.net

Promise, Sunless Sea, [2018-12-31], （原始内容存档于2007-10-23）

sylvain-huet.com

Rishiyur S. Nikhil. ID Reference Manual (PDF). 1991 [2024-03-13]. （原始内容存档 (PDF)于2024-05-19）. A component of a data structure may have I-structure semantics (as opposed to functional or M-structure semantics). For such a component, no value is specified when the data structure is created; instead, a separate assignment statement is used. An I-structure component may be in one of two states: be full (with a value), or empty. all components begin in the empty state (when the data structure is allocated).
An I-structure component has a single assignment restriction, i.e. it can only be assigned once, at which point its state goes from empty to full. Any attempt to assign it more than once is caught as a runtime error. The component can be read an arbitrary number of times.
……
An M-structure component can be assigned with a put operation and read with a take operation. A value can be put only into an empty component — it is a runtime error if it is already full. Many take's may be attempted concurrently on a component.

threads.js.org

Web Workers API. [2024-03-11]. （原始内容存档于2024-05-21）.
Worker threads API. [2024-03-25]. （原始内容存档于2024-05-11）.
threads.js — Make web workers & worker threads as simple as a function call. [2024-03-25]. （原始内容存档于2024-05-09）.

tomasp.net

Tomas Petricek. Asynchronous C# and F# (I.): Simultaneous introduction. 2010-10-29 [2018-12-31]. （原始内容存档于2018-12-31）. Currently, you can run the operation on a background thread or using a Task, but coordinating multiple such operations is difficult. …… This problem has been the main motivation for including asynchronous workflows in F# about 3 years ago. In F#, this also enabled various interesting programming styles - for example creating GUI using asynchronous workflows ……. The C# asynchronous programming support and the await keyword is largely inspired by F# asynchronous workflows …….

twisted.org

docs.twisted.org

Deferred Reference. twistedmatrix.com. [2024-01-23]. （原始内容存档于2024-04-25）.

twitter.github.io

Util. twitter.github.io. [2018-12-31]. （原始内容存档于2018-12-23）.

uchicago.edu

cml.cs.uchicago.edu

The Concurrent ML Reference Manual — The SyncVar structure. [2024-03-13]. （原始内容存档于2024-05-10）. The SyncVar structure provides Id-style synchronous variables (or memory cells). These variables have two states: empty and full. An attempt to read a value from an empty variable blocks the calling thread until there is a value available. An attempt to put a value into a variable that is full results in the Put exception being raised. There are two kinds of synchronous variables: I-variables are write-once, while M-variables are mutable.

udanax.com

Gold, Udanax, [2018-12-31], （原始内容存档于2008-10-11）

uni-saarland.de

ps.uni-saarland.de

Gert Smolka. Concurrent Constraint Programming Based on Functional Programming. 1998 [2024-03-13]. （原始内容存档于2024-03-13）. As base language we choose a dynamically type language DML that is obtained from SML by eliminating type declarations and static type checking. ……
A state is a finite function σ mapping addresses a to so-called units u. Units are either primitive values other than names or representations of records, variants, reference cells, functions, and primitive operations …… A match Match is a sequence of clauses (p₁ ⇒ e₁ | … | p_k ⇒ e_k). ……
We now extend DML with logic variables, one of the essentials of logic programming. Logic variables are a means to represent in a state partial information about the values of addresses. Logic variables are modelled with a new unit lvar. The definition of states is extended so that a state may map an address also to lvar or an address. ……
A match …… blocks until the store contains enough information to commit to one of the clauses or to know that none applies.
Jan Schwinghammer. A Concurrent Lambda Calculus with Promises and Futures. 2002 [2024-03-14]. （原始内容存档于2024-03-14）. General logic variables stem from the class of logic programming languages such as Prolog [Pro85, SS94, JL87]. Initially, when freshly introduced, they carry no value. Therefore they allow for the stepwise construction of values, using further logic variables for the construction of subvalues if necessary. They are transient, in that they are identified with their value as soon as this becomes available. This provides a mechanism for implicit synchronization of concurrent threads that share a logic variable: A thread reading the variable automatically suspends while sufficient information is not available.
We will be concerned with futures and promises, which differ from general logic variables in that a distinction is made between reading and writing them. Bidirectional unification can be replaced by (single-) assignment.
Alice manual — Future. [2024-03-13]. （原始内容存档于2024-04-17）.
Alice Manual — Promise. [2024-03-13]. （原始内容存档于2024-04-17）.

web.archive.org

Henry Baker; Carl Hewitt. The Incremental Garbage Collection of Processes. Proceedings of the Symposium on Artificial Intelligence Programming Languages,. ACM Sigplan Notices 12, 8: 55–59. August 1977 [2024-01-26]. （原始内容存档于2024-04-12）. In this paper we consider an "eager beaver" evaluator for an applicative programming language which starts evaluating every subexpression as soon as possible, and in parallel. This is done through the mechanism of futures, which are roughly Algol-60 "thunks" which have their own evaluator process ("thinks"?). (Friedman and Wise [10] call futures "promises", while Hibbard [13] calls them "eventuals".) When an expression is given to the evaluator by the user, a future for that expression is returned which is a promise to deliver the value of that expression at some later time, if the expression has a value. A process is created for each new future which immediately starts to work evaluating the given expression. ……
The intuitive semantics associated with a future is that it runs asynchronously with its parent's evaluation. This effect can be achieved by either assigning a different processor to each future, or by multiplexing all of the futures on a few processors. Given one such implementation, the language can easily be extended with a construct having the following form: "(EITHER <e₁> <e₂> … <e_n>)" means evaluate the expressions <e_i> in parallel and return the value of "the first one that finishes".
Barbara Liskov; Liuba Shrira. Promises: Linguistic Support for Efficient Asynchronous Procedure Calls in Distributed Systems. Proceedings of the SIGPLAN '88 Conference on Programming Language Design and Implementation; Atlanta, Georgia, United States. ACM: 260–267. 1988 [2024-01-26]. ISBN 0-89791-269-1. doi:10.1145/53990.54016. （原始内容存档于2024-01-26）. Promises were designed to support an efficient asynchronous remote procedure call mechanism for use by components of a distributed program. A promise is a place holder for a value that will exist in the future. It is created at the time a call is made. The call computes the value of the promise, running in parallel with the program that made the call. When it completes, its results are stored in the promise and can then be “claimed” by the caller. ……
Call-streams allow a sender to make a sequence of calls to a receiver without waiting for replies. The stream guarantees that the calls will be delivered to the receiver in the order they were made and that the replies from the receiver will be delivered to the sender in call order. ……
The design of promises was influenced by the future mechanism of MultiLisp[5]. Like futures, promises allow the result of a call to be picked up later. However, promises extend futures in several ways: Promises are strongly typed and thus avoid the need for runtime checking to distinguish them from ordinary values. They allow exceptions from the called procedure to be propagated in a convenient manner. Finally, they are integrated with the call-stream mechanism and address problems such as node failures and network partitions that do not arise in a single-machine environment. ……
There are two reasons for using stream calls instead of RPCs: they allow the caller to run in parallel with the sending and processing of the call, and they reduce the cost of transmitting the call and reply messages. RPCs and their replies are sent over the network immediately, to minimize the delay for a call. Stream calls and their replies, however, are buffered and sent when convenient; in the case of sends, normal replies can be omitted. Buffering allows us to amortize the overhead of kernel calls and the transmission delays for messages over several calls, especially for small calls and replies. Also published in ACM SIGPLAN Notices 23(7).
Kisalaya Prasad, Avanti Patil, Heather Miller. Futures and Promises. [2024-03-11]. （原始内容存档于2024-03-03）.
Domenico Talia. Survey and comparison of PARLOG and Concurrent Prolog. 1990 [2024-03-13]. （原始内容存档于2024-03-13）. Concurrent logic languages are born from a new interpretation of Horn clauses, the process interpretation. According to this interpretation, an atomic goal ← C can be viewed as a process, a conjunctive goal ← C₁, …, C_n, as a process network, and a logic variable shared between two clauses can be viewed as a communication channel between two processes.
Gert Smolka. Concurrent Constraint Programming Based on Functional Programming. 1998 [2024-03-13]. （原始内容存档于2024-03-13）. As base language we choose a dynamically type language DML that is obtained from SML by eliminating type declarations and static type checking. ……
A state is a finite function σ mapping addresses a to so-called units u. Units are either primitive values other than names or representations of records, variants, reference cells, functions, and primitive operations …… A match Match is a sequence of clauses (p₁ ⇒ e₁ | … | p_k ⇒ e_k). ……
We now extend DML with logic variables, one of the essentials of logic programming. Logic variables are a means to represent in a state partial information about the values of addresses. Logic variables are modelled with a new unit lvar. The definition of states is extended so that a state may map an address also to lvar or an address. ……
A match …… blocks until the store contains enough information to commit to one of the clauses or to know that none applies.
Jan Schwinghammer. A Concurrent Lambda Calculus with Promises and Futures. 2002 [2024-03-14]. （原始内容存档于2024-03-14）. General logic variables stem from the class of logic programming languages such as Prolog [Pro85, SS94, JL87]. Initially, when freshly introduced, they carry no value. Therefore they allow for the stepwise construction of values, using further logic variables for the construction of subvalues if necessary. They are transient, in that they are identified with their value as soon as this becomes available. This provides a mechanism for implicit synchronization of concurrent threads that share a logic variable: A thread reading the variable automatically suspends while sufficient information is not available.
We will be concerned with futures and promises, which differ from general logic variables in that a distinction is made between reading and writing them. Bidirectional unification can be replaced by (single-) assignment.
Rishiyur S. Nikhil. ID Reference Manual (PDF). 1991 [2024-03-13]. （原始内容存档 (PDF)于2024-05-19）. A component of a data structure may have I-structure semantics (as opposed to functional or M-structure semantics). For such a component, no value is specified when the data structure is created; instead, a separate assignment statement is used. An I-structure component may be in one of two states: be full (with a value), or empty. all components begin in the empty state (when the data structure is allocated).
An I-structure component has a single assignment restriction, i.e. it can only be assigned once, at which point its state goes from empty to full. Any attempt to assign it more than once is caught as a runtime error. The component can be read an arbitrary number of times.
……
An M-structure component can be assigned with a put operation and read with a take operation. A value can be put only into an empty component — it is a runtime error if it is already full. Many take's may be attempted concurrently on a component.
The Concurrent ML Reference Manual — The SyncVar structure. [2024-03-13]. （原始内容存档于2024-05-10）. The SyncVar structure provides Id-style synchronous variables (or memory cells). These variables have two states: empty and full. An attempt to read a value from an empty variable blocks the calling thread until there is a value available. An attempt to put a value into a variable that is full results in the Put exception being raised. There are two kinds of synchronous variables: I-variables are write-once, while M-variables are mutable.
Promise, Sunless Sea, [2018-12-31], （原始内容存档于2007-10-23）
Argus, MIT, [2018-12-31], （原始内容存档于2018-04-27）
Liskov, Barbara, Distributed computing and Argus, Oral history, IEEE GHN, [2018-12-31], （原始内容存档于2014-11-22）
Gold, Udanax, [2018-12-31], （原始内容存档于2008-10-11）
Pipeline, E rights, [2018-12-31], （原始内容存档于2018-10-22）
Future and FutureTask in java. [2024-03-11]. （原始内容存档于2024-03-11）.
Async in 4.5: Worth the Await – .NET Blog. April 3rd, 2012 [2024-03-20]. （原始内容存档于2024-03-20）. 请检查|date=中的日期值 (帮助)
Asynchronous Programming with Async and Await (C# and Visual Basic). Msdn.microsoft.com. [2014-05-13]. （原始内容存档于2014-05-27）.
Tomas Petricek. Asynchronous C# and F# (I.): Simultaneous introduction. 2010-10-29 [2018-12-31]. （原始内容存档于2018-12-31）. Currently, you can run the operation on a background thread or using a Task, but coordinating multiple such operations is difficult. …… This problem has been the main motivation for including asynchronous workflows in F# about 3 years ago. In F#, this also enabled various interesting programming styles - for example creating GUI using asynchronous workflows ……. The C# asynchronous programming support and the await keyword is largely inspired by F# asynchronous workflows …….
Gilad Bracha. Dart Language Asynchrony Support: Phase 1. October 2014 [2018-12-31]. （原始内容存档于2016-07-02）.
PEP 0492 – Coroutines with async and await syntax. [2018-12-31]. （原始内容存档于2019-01-05）.
Alice manual — Future. [2024-03-13]. （原始内容存档于2024-04-17）.
Dart SDK dart async Completer. [2018-12-31]. （原始内容存档于2016-03-04）.
Task. [2018-12-31]. （原始内容存档于2018-12-31）.
GHC User’s Guide — 6. Language extensions — 6.15. Parallel and Concurrent. [2024-03-13]. （原始内容存档于2024-03-13）.
Steve Dekorte. Io, The Programming Language. 2005 [2018-12-31]. （原始内容存档于2019-01-04）.
java.util.concurrent.Future. [2024-03-11]. （原始内容存档于2024-05-21）.
java.util.concurrent.CompletableFuture. [2024-03-11]. （原始内容存档于2024-04-29）.
Using promises. Mozilla Developer Network. [23 February 2021]. （原始内容存档于2024-05-24）.
Making asynchronous programming easier with async and await. Mozilla Developer Network. [23 February 2021]. （原始内容存档于2022-03-05）.
Rich Hickey. changes.txt at 1.1.x from richhickey's clojure. 2009 [2018-12-31]. （原始内容存档于2016-02-18）.
Parallelism with Futures. [2024-01-22]. （原始内容存档于2024-03-06）.
Task Parallel Library (TPL). [2024-03-11]. （原始内容存档于2024-05-21）.
Future – Kotlin Programming Language. [2024-03-12]. （原始内容存档于2024-03-12）.
Seif Haridi; Nils Franzen. Tutorial of Oz. Mozart Global User Library. [2011-04-12]. （原始内容存档于2011-05-14）.
The Python Standard Library — Concurrent Execution — concurrent.futures — Launching parallel tasks. [2018-12-31]. （原始内容存档于2018-12-31）.
Python 3.2 发布. Python.org. [2018-12-31]. （原始内容存档于2018-12-31）.
PEP 3148 – futures - execute computations asynchronously. [2018-12-31]. （原始内容存档于2018-12-31）. The proposed design of this module was heavily influenced by the Java java.util.concurrent package [1]. The conceptual basis of the module, as in Java, is the Future class, which represents the progress and result of an asynchronous computation. The Future class makes little commitment to the evaluation mode being used e.g. it can be used to represent lazy or eager evaluation, for evaluation using threads, processes or remote procedure call.
Futures are created by concrete implementations of the Executor class (called ExecutorService in Java). The reference implementation provides classes that use either a process or a thread pool to eagerly evaluate computations.
Python 3.5.0 发布. Python.org. [2018-12-31]. （原始内容存档于2019-01-05）.
class Promise. raku.org. [2022-08-19]. （原始内容存档于2024-03-12）.
Future in std::future - Rust. doc.rust-lang.org. [2023-12-16]. （原始内容存档于2024-05-22）.
scala.concurrent包（页面存档备份，存于互联网档案馆）
Blackbird promise library - Blackbird. orthecreedence.github.io. [2018-12-31]. （原始内容存档于2017-11-10）.
Eager Future2. common-lisp.net. [2019-01-04]. （原始内容存档于2018-12-31）.
PCall. marijnhaverbeke.nl. [2018-12-31]. （原始内容存档于2020-08-06）.
Chapter 30. Thread 4.0.0. [2013-06-26]. （原始内容存档于2019-10-16）.
Dlib C++ Library #thread_pool. [2013-06-26]. （原始内容存档于2019-10-16）.
QtCore 5.0: QFuture Class. Qt Project. [2013-06-26]. （原始内容存档于2013-06-01）.
Seastar. Seastar project. [2016-08-22]. （原始内容存档于2016-08-20）.
GitHub – facebook/folly: An open-source C++ library developed and used at Facebook.. [2018-12-31]. （原始内容存档于2019-03-22）.
Threads Slides of POCO (PDF). [2018-12-31]. （原始内容存档 (PDF)于2020-05-08）.
Groovy GPars. [2018-12-31]. （原始内容存档于2013-01-12）.
Promises/A+. promisesaplus.com. [2019-01-04]. （原始内容存档于2018-12-29）.
Promises/A+ Conformant Implementations. [2018-12-31]. （原始内容存档于2018-12-31）.
cujoJS: Javascript architectural toolkit. cujojs.com. [2019-01-04]. （原始内容存档于2012-03-17）.
A solid, fast Promises/A+ and when() implementation, plus other async goodies.: cujojs/when. 2018-12-25 [2018-12-31]. （原始内容存档于2019-01-16） –通过GitHub.
Dojo Deferreds and Promises - Archived Tutorial - Dojo Toolkit. dojotoolkit.org. [2019-01-04]. （原始内容存档于2018-12-31）.
manage asynchronous tasks. MochiKit.Async. [2019-01-04]. （原始内容存档于2018-12-31）.
Deferred Object. [2024-01-26]. （原始内容存档于2012-10-30）.
CommonJS Promises/A（页面存档备份，存于互联网档案馆）
AngularJS — Superheroic JavaScript MVW Framework. angularjs.org. [2019-01-04]. （原始内容存档于2015-06-23）.
kriskowal/q. [2024-01-24]. （原始内容存档于2024-05-09）.
A lightweight library that provides tools for organizing asynchronous code: tildeio/rsvp.js. 2019-01-03 [2018-12-31]. （原始内容存档于2019-01-17） –通过GitHub.
:bird: :zap: Bluebird is a full featured promise library with unmatched performance.: petkaantonov/bluebird. 2019-01-04 [2018-12-31]. （原始内容存档于2018-12-28） –通过GitHub.
promise（页面存档备份，存于互联网档案馆）
JDeferred. JDeferred. [2019-01-04]. （原始内容存档于2019-01-08）.
Asynchronous Java made easier. Contribute to linkedin/parseq development by creating an account on GitHub. 2018-12-29 [2018-12-31]. （原始内容存档于2018-06-10） –通过GitHub.
Proxying futures library for Objective-C. Contribute to mikeash/MAFuture development by creating an account on GitHub. 2019-01-01 [2018-12-31]. （原始内容存档于2019-02-13） –通过GitHub.
mikeash.com: Friday Q&A 2010-02-26: Futures. www.mikeash.com. [2019-01-04]. （原始内容存档于2018-12-31）.
An Objective-C Class which implements the Promises/A+ specification.: couchdeveloper/RXPromise. 2018-12-26 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.
Futures, for Objective-C, that automatically collapse so it's nearly impossible to mix up the level of future nesting despite the lack of generics.: Strilanc/ObjC-CollapsingFutures. 2018-12-07 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.
Promises for Swift & ObjC. Contribute to mxcl/PromiseKit development by creating an account on GitHub. 2019-01-03 [2019-01-04]. （原始内容存档于2019-01-08） –通过GitHub.
Objective-C Promises in the CommonJS style. Contribute to mproberts/objc-promise development by creating an account on GitHub. 2018-09-11 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.
OAPromise is an API separating async operations and their callbacks, adding consistency and useful features like fall-through errors and progress reports.: oleganza/OAPromise. 2017-03-29 [2018-12-31]. （原始内容存档于2013-10-27） –通过GitHub.
Future - represent an operation awaiting completion - metacpan.org. metacpan.org. [2019-01-04]. （原始内容存档于2019-01-01）.
Promises - An implementation of Promises in Perl - metacpan.org. metacpan.org. [2018-12-31]. （原始内容存档于2018-12-31）.
Reflex - Class library for flexible, reactive programs. - metacpan.org. metacpan.org. [2019-01-04]. （原始内容存档于2019-01-04）.
Promises/A implementation for PHP. Contribute to reactphp/promise development by creating an account on GitHub. 2019-01-04 [2018-12-31]. （原始内容存档于2019-04-07） –通过GitHub.
promise — Ultra-performant Promise implementation in Python. [2024-01-23]. （原始内容存档于2024-01-23）.
Deferred Reference. twistedmatrix.com. [2024-01-23]. （原始内容存档于2024-04-25）.
Bengtsson, Henrik. future: Unified Parallel and Distributed Processing in R for Everyone. 2018-10-17 [2018-12-31]. （原始内容存档于2019-10-16） –通过R-Packages.
promise - RubyGems.org - your community gem host. rubygems.org. [2019-01-04]. （原始内容存档于2018-12-31）.
Ruby bindings for libuv. Contribute to cotag/libuv development by creating an account on GitHub. 2018-10-16 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.
Celluloid: Actor-based Concurrent Objects for Ruby. celluloid.io. [2019-01-04]. （原始内容存档于2018-12-31）.
Wait on resources being set in the future. Contribute to adhearsion/future-resource development by creating an account on GitHub. 2013-12-27 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.
Zero-cost asynchronous programming in Rust. Contribute to rust-lang-nursery/futures-rs development by creating an account on GitHub. 2019-01-04 [2019-01-04]. （原始内容存档于2019-02-26） –通过GitHub.
Util. twitter.github.io. [2018-12-31]. （原始内容存档于2018-12-23）.
al45tair / Async. bitbucket.org. [2018-12-31]. （原始内容存档于2018-12-31）.
A Swift based Future/Promises Library for IOS and OS X.: FutureKit/FutureKit. 2018-12-31 [2018-12-31]. （原始内容存档于2018-08-10） –通过GitHub.
Dispatch - Apple Developer Documentation. developer.apple.com. [2019-01-04]. （原始内容存档于2018-12-31）.
FutureLib is a pure Swift 2 library implementing Futures & Promises inspired by Scala.: couchdeveloper/FutureLib. 2018-10-15 [2018-12-31]. （原始内容存档于2018-06-12） –通过GitHub.
Work with values that haven't been determined yet.: bignerdranch/Deferred. 2019-01-02 [2019-01-04]. （原始内容存档于2018-06-10） –通过GitHub.
Write great asynchronous code in Swift using futures and promises: Thomvis/BrightFutures. 2019-01-03 [2018-12-31]. （原始内容存档于2018-06-11） –通过GitHub.
tcl-promise. SourceForge. [2018-12-31]. （原始内容存档于2018-12-31）.
Futures in Go, no package required. [2024-03-08]. （原始内容存档于2024-03-08）.
The Python Standard Library — Networking and Interprocess Communication — asyncio — Asynchronous I/O. [2024-03-11]. （原始内容存档于2019-05-05）.
Kris Zyp. Promise API Proposal. 2009-05-25 [2024-03-20]. （原始内容存档于2024-03-20）.
CommonJS — Promises. [2024-03-20]. （原始内容存档于2024-03-20）.
Web Workers API. [2024-03-11]. （原始内容存档于2024-05-21）.
Worker threads API. [2024-03-25]. （原始内容存档于2024-05-11）.
threads.js — Make web workers & worker threads as simple as a function call. [2024-03-25]. （原始内容存档于2024-05-09）.
Robust promises with Dojo deferred, Site Pen, 2010-05-03 [2018-12-31], （原始内容存档于2018-12-31）
Alice Manual — Promise. [2024-03-13]. （原始内容存档于2024-04-17）.
500 lines or less, "A Web Crawler With asyncio Coroutines" by A. Jesse Jiryu Davis and Guido van Rossum （页面存档备份，存于互联网档案馆） says "implementation uses an asyncio.Event in place of the Future shown here. The difference is an Event can be reset, whereas a Future cannot transition from resolved back to pending."
Control Concurrent MVar, Haskell, [2018-12-31], （原始内容存档于2009-04-18）
Promise, E rights, [2018-12-31], （原始内容存档于2018-12-31）
Promise Pipelining. www.erights.org. [2018-12-31]. （原始内容存档于2018-10-22）.
Promise Pipelining on the C2 wiki. [2018-12-31]. （原始内容存档于2005-09-25）.
WaitNeeded, Mozart Oz, [2018-12-31], （原始内容存档于2013-05-17）

webcitation.org

jQuery. [2018-12-31]. （原始内容存档于2012-02-29）.