anchor.diff:      printfn "Listener up @ 0.0.0.0:%d" port
       
       let mut state: Node = {
  +        name = name;
           executed = false;
           included = true;
           pending = false;
           relations = [];
  -        dependencies = Map.empty;
  +        conditions = Map.empty;
       }
      
       let rec loop (store : Map<string, string>) = 
  
positive.code: ﻿// --debois, Mar '15
  module Server
  
  // REST key-value store. 
  
  let (|Prefix|_|) (p:string) (s:string) =
      if s.StartsWith(p) then
          Some(s.Substring(p.Length))
      else
          None
  
  type Relation =             // The internal string is a http address
      | Condition of string   // What is enabled once a node is executed
      | Exclusion of string   // What becomes excluded once this node is executed
      | Response of string    // What becomes pending once a node is executed
  
  type Node = {
      executed: bool;
      included: bool;
      pending: bool;
      relations: Relation list;
      dependencies: Map<string, bool>; // Whether each condition is fulfilled
      // Ex: {"register": false}
  }
  
  // Add a relation to the node
  let addRelation node relation =
  
negative.code: 
  // Handles when the node is executed
  let tryExecute node =
      let rec notify = function
      | [] -> ()
      | relation::remainder ->
          let result = 
              match relation with
              | Condition dest -> sendMessage dest (Executed node.name)
              | Exclusion dest -> sendMessage dest SetExcluded
              | Response dest  -> sendMessage dest SetPending
          // TODO do something with the result
          notify remainder
      
      if Map.forall (fun k v -> v) node.conditions // All deps are OK
      then 
          notify node.relations // In order?
          Some { node with executed = true; }
      else
          printfn "The node was attempted executed, but all conditions were not met!"
          None
      
  
  // Returns the status of the node (Should this be here?)
  // Note: This should not return the node
  let getStatus node =
      failwith  "Not Implemented"
  
  // Excludes the node
  let exclude node =
      let rec notify = function 
      | [] -> ()
      | relation::remainder ->
          match relation with
          | Condition target -> 
              let result = sendMessage target RemoveCondition
              // TODO handle the result / error
              ()
          | _ -> ()
          notify remainder
      notify node.relations
      { node with included = false; } // TODO What about executed?
  
  // REST key-value store. 
  let (|Prefix|_|) (p:string) (s:string) =
      if s.StartsWith(p) then
          Some(s.Substring(p.Length))
      else
          None
  
  [<EntryPoint>]
  let main args = 
  