anchor.diff:  ----
   
   Each of those clauses can be specified in any order and can be omitted but for
  -the +FROM+ clause.
  +the +FROM+ clause; Also, when +TOP+ is specified then no +COMMIT+ or +FLUSH+
  +must be present.
   
   The semantic is:
   
  
positive.code: 
  == Overview
  
  Ramen is a _stream processor_. Unlike other stream processors that are designed
  to scale to many servers, Ramen is designed to be efficient on a single (or
  very few) servers. In other words, it is not designed to be distributed. As a
  trade off, what we gain from relaxing this constraint is a much simpler design
  and faster program.
  
  Ramen is composed by a central server that serves an API allowing clients to
  edit the configuration. This configuration consists of a graph of operations,
  each of which is given using a specialized high level language that's inspired
  by SQL and alleviate users to program the operations in actual programing
  languages. These operations are then compiled by the central server down to
  machine code into individual programs for faster execution. Also, events sent
  from one operation to the next are sent directly from the emitter to the
  recipient using memory-mapped ring-buffers, thus avoiding another source of
  complexity and latency.
  
  The last design principle is that events must be _tuples_ of primitive types,
  with no special field, and are statically typed; not unlike tuples from a SQL
  database.  Therefore, each node has an input and an output type: the types of
  event they accept and produce.
  
  == Glossary
  
  
negative.code: == The Configuration Language Reference
  
  We describe first values, then expressions, then operations.  All these
  concepts reference each others so there is no reading order that would save
  you from jumping around. First reading may not be clear but everything should
  eventually fall into place.
  
  === Blanks
  
  Any blank or newline is a separator.
  
  === Comments
  
  As in SQL, two dashes introduce a line comment. Everything from those dashes
  and the end of that line is considered a space.
  
  There is no block comments.
  
  === Quotation
  
  Some rare reserved keywords cannot be used as identifiers unless surrounded by
  simple quotes.
  
  === Values
  
  ==== NULLs
  
  Like in SQL, some field may have the NULL value. Ramen typing system knows what
  value can be NULL and spare the NULL checks unless necessary.
  
  Users can check if a nullable value is indeed NULL using the +IS NULL+ or +IS
  NOT NULL+ operators, which turn a nullable value into a boolean. This is useful
  in where clauses.
  
  +NULL+ is both a type and a value. The +NULL+ value is the only possible value
  of the +NULL+ type, or a possible value for any nullable field.
  
  To write a literal +NULL+ value (of the +NULL+ type, for what it's worth),
  enter `NULL`.
  
  ==== Booleans
  
  The type for booleans is called `boolean` (`bool` is also accepted).
  Boolean true and false are spelled `true` and `false`.
  
  ==== Strings
  
  The type for character strings is called `string`.  A literal string is double
  quoted (with +"+). To include a double-quote, backslash it.  Other characters
  can be backslashed: single quote (`"\'"`), newlines (`"\n"` and `"\r"`),
  horizontal tab (`"\t"`), backspace (`"\b"`) and the backslash itself (`"\\"`).
  
  Some functions consider strings as UTF-8 encoded, some consider strings as mere
  sequence of bytes.
  