anchor.diff:              let updatedProgram = 
                   parsedProgram
                   |> ParsedProgram.addMnemonic name (Const (serializeConst objVal, dataType))
  -            updatedProgram, None
  +            updatedProgram, predcessors
   
           | _ ->
               printfn "%A" expr
  
positive.code:     let rec visitDeclarations program predcessors declarations = 
          match declarations with
          | [] ->
              program
          | _ ->
              let decl, tail = List.head declarations, List.tail declarations
              match decl with
              | Entity _ ->
                  failwith "Nested types or modules are not allowed"
  
              | InitAction expr ->
                  let updatedProgram, depOpt = visitExpression None predcessors program expr
                  let predcessors' = 
                      match depOpt with
                      | Some op -> predcessors |> Set.add op
                      | None -> predcessors
                  visitDeclarations updatedProgram predcessors' tail
  
              | MemberOrFunctionOrValue (funcOrVal, _, expression) ->
                  if (|Function|) funcOrVal then
                      "Functions declaration" |> notSupported
                  else
                      let updatedProgram, _ = 
                          visitExpression (Some funcOrVal.FullName) predcessors program expression
                      visitDeclarations updatedProgram predcessors tail
              
      let (|Module|) (x: FSharpEntity) = if x.IsFSharpModule then Some x else None
      
      let parseProgramTree (implFile: FSharpImplementationFileContents) =
          match implFile.Declarations with
          | [Entity(Module _, subdecls)] ->
              do printfn "%A" subdecls
              visitDeclarations ParsedProgram.empty Set.empty subdecls
          | [_] -> 
              failwith "Top-level declaration can be module only"
          | [] ->
              failwith "Empty file"
          | _ ->
              failwith "Too many declarations"
          
      let parse optSources source = 
          let targetName = tempFileName ()
  
negative.code:         | Ok (trees, checkWarnings) ->
              let errors = ParsingError.ofFSharpErrorInfos checkWarnings
              let graph = 
                  trees
                  |> parseProgramTree
                  |> ParsedProgram.toComputationGraph
              graph, errors
  
  