Example: subsequent transmission style in JavaScript (1)

Currently, CPS has been discovered again as a programming style of a non-blocking (usually distributed) system.

I like CPS very much, because it is a secret weapon for me to obtain a doctorate. In, it helped me lose a year or two and some incalculable pains.

This article introduces the two roles played by CPS-as a non-blocking programming style in JavaScript and as an intermediate form of a functional language (Brief Introduction ).

The content includes:

◆ CPS in JavaScript

◆ CPS for Ajax Programming

◆ CPS used in non-blocking programming (node. js)

◆ CPS for distributed programming

◆ How to use CPS to implement exceptions

◆ Simple Lisp CPS Converter

◆ How to implement call/cc using Lisp

◆ How to implement call/cc using JavaScript

Read down to learn more.

What is a continuous transmission style?

If a language supports subsequent continuation, programmers can add control structures such as exceptions, backtracking, threads, and constructors.

Unfortunately, many of the subsequent explanations (including me) are vague and unsatisfactory.

Subsequent transmission style is the basis.

Subsequent transmission styles give subsequent code meanings.

Even better, programmers can discover their own subsequent transmission styles, if they are constrained by the following constraints:

No process is allowed to be returned to its caller -- always so.

A revelation makes programming in this style possible:

A callback method can be called when they return values.

When a process (procedure) prepares to "return" to its caller, it calls "current subsequent (current continuation)" When returning the value) "This callback method (provided by its caller)

One is followed by an initial type (first-class) Return Point.

Example: Identification Function

Consider the identifier function in the normal format:

 
 

  
  
function id(x) {    
  
  
         return x ;  
  
  
} 
 
 

Then the subsequent transmission style is as follows:

 
 

  
  
function id(x,cc) {  
  
  
   cc(x) ;  
  
  
} 
 
 

Sometimes, naming the current subsequent parameter ret makes the purpose more obvious:

 
 

  
  
function id(x,ret) {  
  
  
   ret(x) ;  
  
  
} 
 
 

Example: simple factorial

Below is the standard Simple factorial:

 
 

  
  
function fact(n) {  
  
  
   if (n == 0)  
  
  
     return 1 ;  
  
  
   else 
  
  
    return n * fact(n-1) ;  
  
  
} 
 
 

The following is the implementation of the CPS style:

 
 

  
  
function fact(n,ret) {  
  
  
   if (n == 0)  
  
  
     ret(1) ;  
  
  
   else 
  
  
    fact(n-1, function (t0) {  
  
  
      ret(n * t0) }) ;  
  
  
} 
 
 

Next, we will pass a callback method to "use" the function:

 
 

  
  
Fact (5, function (n ){
  
  
Console. log (n); // output 120 in Firebug
  
  
})
 
 

Example: tail recursion factorial

Below is the tail recursive factorial:

 
 

  
  
function fact(n) {  
  
  
   return tail_fact(n,1) ;  
  
  
}    
  
  
function tail_fact(n,a) {  
  
  
   if (n == 0)  
  
  
     return a ;  
  
  
   else 
  
  
     return tail_fact(n-1,n*a) ;  
  
  
} 
 
 

The CPS implementation method is as follows:

 
 

  
  
function fact(n,ret) {  
  
  
   tail_fact(n,1,ret) ;  
  
  
}     
  
  
function tail_fact(n,a,ret) {  
  
  
   if (n == 0)  
  
  
     ret(a) ;  
  
  
   else 
  
  
     tail_fact(n-1,n*a,ret) ;  
  
  
}    
 
 

CPS and Ajax

Ajax is a web programming technology that uses an XMLHttpRequest object in JavaScript to extract data from the server (asynchronously. (The extracted data does not need to be in XML format .) CPS provides an elegant way to implement Ajax programming. With XMLHttpRequest, we can write a blocking process fetch (url), capture the content on a url, and then return the content as a string. The problem with this method is that JavaScript is a single-threaded language. When JavaScript is blocked, the browser is temporarily frozen and cannot be moved. This will lead to unpleasant user experience. A better way is to execute the fetch (url, callback) process, which allows (or the browser to render work, the provided callback method is called once the request is complete. In this way, part of the CPS conversion has become a natural encoding method.

Implement fetch

It is not difficult to implement the fetch process. The non-blocking mode or blocking mode operation depends on whether the programmer provides the callback method:

 
 

  
  
/*
  
  
For client-> server-side requests,
  
  
Fetch is an optional blocking process.
  
  

  
  
The process is blocked and the content on the url is returned only when a url is provided.
  
  

  
  
If the onSuccess callback method is provided,
  
  
The process is non-blocking and the file
  
  
To call the callback method.
  
  

  
  
If the onFail callback method is also provided,
  
  
OnFail is called when a failure event occurs.
  
  

  
  
*/
  
  

  
  
Function fetch (url, onSuccess, onFail ){
  
  
// The callback method is asynchronous only when the callback method is defined.
  
  
Var async = onSuccess? True: false; // do not complain about the inefficiency of the Code,
  
  

  
  
// Otherwise, you will not understand the key .)
  
  
Var req; // XMLHttpRequest object.
  
  

  
  
// XMLHttpRequest callback method:
  
  
Function processReqChange (){
  
  
If (req. readyState = 4 ){
  
  
If (req. status = 200 ){
  
  
If (onSuccess)
  
  
OnSuccess (req. responseText, url, req );
  
  
} Else {
  
  
If (onFail)
  
  
OnFail (url, req );
  
  
}
  
  
}
  
  
}
  
  

  
  
// Create an XMLHttpRequest object:
  
  
If (window. XMLHttpRequest)
  
  
Req = new XMLHttpRequest ();
  
  
Else if (window. ActiveXObject)
  
  
Req = new ActiveXObject ("Microsoft. XMLHTTP ");
  
  

  
  
// If asynchronous, set the callback method:
  
  
If (async)
  
  
Req. onreadystatechange = processReqChange;
  
  

  
  
// Initiate a request:
  
  
Req. open ("GET", url, async );
  
  
Req. send (null );
  
  

  
  
// If asynchronous,
  
  
// Return the request object. Otherwise
  
  
// Return the response.
  
  
If (async)
  
  
Return req;
  
  
Else
  
  
Return req. responseText;
  
  
}
 
 

Example: extract data

Consider a program. The program needs to capture a name from the UID.

Fetch is used in the following two methods:

 
 

  
  
// Blocking until the request is complete:
  
  
Var someName = fetch ("./1031/name ");
  
  

  
  
Document. write ("someName:" + someName +"
  
  
");
 
 

 
 

  
  
// Do not block:
  
  
Fetch ("./1030/name", function (name ){
  
  
Document. getElementById ("name"). innerHTML = name;
  
  
});
  
  

 
 

CPS and non-blocking Programming

Node. js is a high-performance JavaScript server platform on which blocking processes are not allowed.

Cleverly, the usual blocking process (such as network or file I/O) uses the callback method called through the result.

Part of the program's CPS conversion has contributed to the natural node. js programming.