anchor.diff:  
   function TNodakRepo.e(sub, rel, obj : string) : IEdge;
     begin
  -    result := nil
  +    result := TEdge.New(self, -MaxInt, 'sub', 'rel', 'obj');
     end;
   
   function TNodakRepo.f(eid : integer) : IEdge;
     begin
  -    result := nil
  +    result := TEdge.New(self, -MaxInt, 'sub', 'rel', 'obj');
     end;
   
   function TNodakRepo.q(sub,rel,obj : string) : IEdges;
  
positive.code: 
  function TNodakRepo.v(key : string) : ICell;
    begin
      result := nil
    end;
  
  
  {-- unit interface --}
  
negative.code:   function open(path : string) : dndk.IBase;
  
  implementation uses classes, udb;
  
  type
    TNodakRepo = class (TComponent, IBase)
      protected
        _dbc : udb.TDatabase;
      public
        function e(sub, rel, obj : string) : IEdge;   // store edge
        function f(eid : integer) : IEdge;            // fetch edge
        function q(sub,rel,obj : string) : IEdges;    // query edges
        function n(key : string) : INode;             // node name -> nid
        function a(key, val : string) : IBase;        // assign = e(key,':=',val)
        function v(key : string) : ICell;             // v(key) = n(key).val
      end;
    TBase	= class (TComponent, IBase)
      protected
        _base : IBase;
      public
        constructor New(aBase : IBase);
        property base:IBase read _base implements IBase;
      end;
  
  type
    TCell	= class (TBase, ICell)
      protected
        _value : variant;
      public
        constructor New(aValue : variant);
        function s : string;
        function i : integer;
        function b : boolean;
        function n : INode;
      end;
    TEdge = class (TBase, IEdge)
      protected
        _eid : integer;
        _sub, _rel, _obj : string;
      public
        constructor New(aBase: IBase; aEid : integer; aSub, aRel, aObj : string);
        function eid : integer;
        function sub : ICell;
        function rel : ICell;
        function obj : ICell;
      end;
  {-- TCell --}
  
  constructor TCell.New(aValue : variant);
    begin
      _value := aValue
    end;
  
  function TCell.s : string;
    begin
      result := string(_value)
    end;
  
  function TCell.i : integer;
    begin
      result := integer(_value)
    end;
  
  function TCell.b : boolean;
    begin
      result := boolean(_value)
    end;
  
  function TCell.n : INode;
    begin
      result := _base[_value]
    end;
  
  
  {-- TBase --}
  
  constructor TBase.New(aBase: IBase);
    begin
      inherited Create(Nil);
      _base := aBase;
    end;
  
  {-- TEdge --}
  
  constructor TEdge.New(aBase: IBase; aEid : integer; aSub, aRel, aObj : string);
    begin
      _eid := aEid; _sub := aSub; _rel := aRel; _obj := aObj;
      inherited New(aBase)
    end;
  
  function TEdge.eid : integer;
    begin
      result := _eid
    end;
  
  function TEdge.sub : ICell;
    begin
      result := _base.v(_sub)
    end;
  
  function TEdge.rel : ICell;
    begin
      result := _base.v(_rel)
    end;
  
  function TEdge.obj : ICell;
    begin
      result := _base.v(_obj)
    end;
  
  