Experimental control-flow operator (#368)

* AST and syntax for delimited control

* stashing for later

* a little more progress

* progress on delimited continuations

* delimit, suspend, and resume implemented (draft)

* example that generates the natural numbers

* fixes

* tinkering

* changed demo to experimental

* comments and name changes

* describe delimited continuations in the README

* renamed Snapshot to Continuation, edits to comments

* Update executable_semantics/ast/statement.h

improve comment for MakeDelimitStmt

Co-authored-by: Dave Abrahams <dabrahams@google.com>

* Update executable_semantics/interpreter/interpreter.cpp

remove snake_case

Co-authored-by: Dave Abrahams <dabrahams@google.com>

* edits to comments, change name of variable

* updates to handle review edits

* trailing whitespace

* fixes to delimited continuations, added more tests, also fixed assignment to do a copy

* improvements from Geoffrey

* new test from Geoffrey, fix for empty blocks

* more suggestions from Geoffrey

* more tests for delimited continuations, renaming some of them

* renamed test files

* improve a comment

* sketch of creating continuation

* initial implementation of shift/reset style continuations

* more documentation

* fix some camel case

* implemented deep copy of continuations, added a test case for it

* fixed a bug and got the recursive test case working

* removed __delimit, polished up __continuation

* back to shallow copy for continuations

* suggestions from Geoffrey

* removed structured binding (for now)

* Update executable_semantics/ast/expression.cpp

Co-authored-by: Geoff Romer <gromer@google.com>

* responses to Geoffrey

Co-authored-by: Dave Abrahams <dabrahams@google.com>
Co-authored-by: Geoff Romer <gromer@google.com>

executable_semantics/ast/expression.cpp

@@ -36,6 +36,14 @@ auto MakeAutoType(int line_num) -> Expression* {
   return t;
 }
 
+// Returns a Continuation type AST node at the given source location.
+auto MakeContinuationType(int line_num) -> Expression* {
+  auto* type = new Expression();
+  type->tag = ExpressionKind::ContinuationT;
+  type->line_num = line_num;
+  return type;
+}
+
 auto MakeFunType(int line_num, Expression* param, Expression* ret)
     -> Expression* {
   auto* t = new Expression();
@@ -150,6 +158,18 @@ auto MakeTuple(int line_num,
   return e;
 }
 
+// Create an AST node for an empty tuple.
+// TODO(geoffromer): remove this and rewrite its callers to use
+// `MakeTuple(line_num, {})`, once that works.
+auto MakeUnit(int line_num) -> Expression* {
+  auto* unit = new Expression();
+  unit->line_num = line_num;
+  unit->tag = ExpressionKind::Tuple;
+  auto* args = new std::vector<std::pair<std::string, Expression*>>();
+  unit->u.tuple.fields = args;
+  return unit;
+}
+
 auto MakeIndex(int line_num, Expression* exp, Expression* i) -> Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
@@ -171,13 +191,13 @@ static void PrintOp(Operator op) {
       std::cout << "-";
       break;
     case Operator::Not:
-      std::cout << "!";
+      std::cout << "not";
       break;
     case Operator::And:
-      std::cout << "&&";
+      std::cout << "and";
       break;
     case Operator::Or:
-      std::cout << "||";
+      std::cout << "or";
       break;
     case Operator::Eq:
       std::cout << "==";
@@ -272,6 +292,9 @@ void PrintExp(const Expression* e) {
     case ExpressionKind::AutoT:
       std::cout << "auto";
       break;
+    case ExpressionKind::ContinuationT:
+      std::cout << "Continuation";
+      break;
     case ExpressionKind::FunctionT:
       std::cout << "fn ";
       PrintExp(e->u.function_type.parameter);

executable_semantics/ast/expression.h

@@ -19,6 +19,7 @@ enum class ExpressionKind {
   GetField,
   Index,
   IntT,
+  ContinuationT,  // The type of a continuation value.
   Integer,
   PatternVariable,
   PrimitiveOp,
@@ -100,6 +101,8 @@ auto MakeGetField(int line_num, Expression* exp, std::string field)
 auto MakeTuple(int line_num,
                std::vector<std::pair<std::string, Expression*>>* args)
     -> Expression*;
+// Create an AST node for an empty tuple.
+auto MakeUnit(int line_num) -> Expression*;
 auto MakeIndex(int line_num, Expression* exp, Expression* i) -> Expression*;
 
 auto MakeTypeType(int line_num) -> Expression*;
@@ -108,6 +111,9 @@ auto MakeBoolType(int line_num) -> Expression*;
 auto MakeFunType(int line_num, Expression* param, Expression* ret)
     -> Expression*;
 auto MakeAutoType(int line_num) -> Expression*;
+// Returns a Continuation type AST node at the given source location,
+// which is the type of a continuation value.
+auto MakeContinuationType(int line_num) -> Expression*;
 
 void PrintExp(const Expression* exp);
 

executable_semantics/ast/statement.cpp

@@ -104,6 +104,36 @@ auto MakeMatch(int line_num, Expression* exp,
   return s;
 }
 
+// Returns an AST node for a continuation statement give its line number and
+// parts.
+auto MakeContinuationStatement(int line_num, std::string continuation_variable,
+                               Statement* body) -> Statement* {
+  auto* continuation = new Statement();
+  continuation->line_num = line_num;
+  continuation->tag = StatementKind::Continuation;
+  continuation->u.continuation.continuation_variable =
+      new std::string(continuation_variable);
+  continuation->u.continuation.body = body;
+  return continuation;
+}
+
+// Returns an AST node for a run statement give its line number and argument.
+auto MakeRun(int line_num, Expression* argument) -> Statement* {
+  auto* run = new Statement();
+  run->line_num = line_num;
+  run->tag = StatementKind::Run;
+  run->u.run.argument = argument;
+  return run;
+}
+
+// Returns an AST node for an await statement give its line number.
+auto MakeAwait(int line_num) -> Statement* {
+  auto* await = new Statement();
+  await->line_num = line_num;
+  await->tag = StatementKind::Await;
+  return await;
+}
+
 void PrintStatement(Statement* s, int depth) {
   if (!s) {
     return;
@@ -177,13 +207,44 @@ void PrintStatement(Statement* s, int depth) {
       PrintStatement(s->u.sequence.stmt, depth);
       if (depth < 0 || depth > 1) {
         std::cout << std::endl;
+      } else {
+        std::cout << " ";
       }
       PrintStatement(s->u.sequence.next, depth - 1);
       break;
     case StatementKind::Block:
-      std::cout << "{" << std::endl;
-      PrintStatement(s->u.block.stmt, depth - 1);
-      std::cout << std::endl << "}" << std::endl;
+      std::cout << "{";
+      if (depth < 0 || depth > 1) {
+        std::cout << std::endl;
+      }
+      PrintStatement(s->u.block.stmt, depth);
+      if (depth < 0 || depth > 1) {
+        std::cout << std::endl;
+      }
+      std::cout << "}";
+      if (depth < 0 || depth > 1) {
+        std::cout << std::endl;
+      }
+      break;
+    case StatementKind::Continuation:
+      std::cout << "continuation " << *s->u.continuation.continuation_variable
+                << " ";
+      if (depth < 0 || depth > 1) {
+        std::cout << std::endl;
+      }
+      PrintStatement(s->u.continuation.body, depth - 1);
+      if (depth < 0 || depth > 1) {
+        std::cout << std::endl;
+      }
+      break;
+    case StatementKind::Run:
+      std::cout << "run ";
+      PrintExp(s->u.run.argument);
+      std::cout << ";";
+      break;
+    case StatementKind::Await:
+      std::cout << "await;";
+      break;
   }
 }
 }  // namespace Carbon

executable_semantics/ast/statement.h

@@ -22,7 +22,10 @@ enum class StatementKind {
   While,
   Break,
   Continue,
-  Match
+  Match,
+  Continuation,  // Create a first-class continuation.
+  Run,           // Run a continuation to the next await or until it finishes..
+  Await,         // Pause execution of the continuation.
 };
 
 struct Statement {
@@ -69,6 +72,15 @@ struct Statement {
       std::list<std::pair<Expression*, Statement*>>* clauses;
     } match_stmt;
 
+    struct {
+      std::string* continuation_variable;
+      Statement* body;
+    } continuation;
+
+    struct {
+      Expression* argument;
+    } run;
+
   } u;
 };
 
@@ -86,6 +98,22 @@ auto MakeContinue(int line_num) -> Statement*;
 auto MakeMatch(int line_num, Expression* exp,
                std::list<std::pair<Expression*, Statement*>>* clauses)
     -> Statement*;
+// Returns an AST node for a continuation statement give its line number and
+// contituent parts.
+//
+//     __continuation <continuation_variable> {
+//       <body>
+//     }
+auto MakeContinuationStatement(int line_num, std::string continuation_variable,
+                               Statement* body) -> Statement*;
+// Returns an AST node for a run statement give its line number and argument.
+//
+//     __run <argument>;
+auto MakeRun(int line_num, Expression* argument) -> Statement*;
+// Returns an AST node for an await statement give its line number.
+//
+//     __await;
+auto MakeAwait(int line_num) -> Statement*;
 
 void PrintStatement(Statement*, int);