anchor.diff:  			   actions :initial-value nil))))
   
   (defun action (expression)
  -  (unless (eql (first expression) 'last)
  +  (unless (string= (first expression) 'last)
       (if (= (length expression) 5)
   	(list t   (nth 1 expression) (nth 3 expression) (nth 2 expression) (nth 4 expression))
   	(list nil (nth 1 expression) (nth 2 expression) (stringp nth-3) (nth 3 expression)))))
   
   
  -(defun get-field (field token)
  -  (let ((v (slot-value token (intern (symbol-name field) "CL-CONLLU"))))
  -    (if (integerp v)
  -	(write-to-string v))))
  +(defun get-field-value (field token)
  +  (let ((value (slot-value token (intern (symbol-name field) "CL-CONLLU"))))
  +    (if (integerp value)
  +	(write-to-string value)
  +	value)))
   
   
   (defun normalize-shorthand (expression operator)
  -  (if (eql (first expression) '>)
  +  (if (string= (first expression) '>)
         (nth 1 (reduce #'(lambda (result node-2)
   			 (list node-2
   			       (cons `(,operator ,node-2 ,(first result) head id)
  
positive.code: 
  (defun token-matchers (definition tokens)
    (reduce #'(lambda (result-matchers token)
  	      (let ((token-matched (token-match definition token)))
  		(if token-matched
  		    (cons token-matched result-matchers)
  		    result-matchers)))
  	  tokens :initial-value nil))  
  
  (defun token-match (definition token)
    (when (all-defs-test token (getf definition :defs))
      token))
  
  (defun all-defs-test (token defs) 
    (if defs
  
negative.code: (in-package :conllu.editor)
  
  (defun conlluedit (sentences transformations)
    (reduce #'(lambda (acumulated-results sentence)
  	      (let* ((sent-id (sentence-id sentence)) 
  		     (results (apply-transformations sentence sent-id transformations)))
  		(if results
  		    (cons (cons sent-id results) acumulated-results)
  		    acumulated-results)))
  	  sentences :initial-value nil))
  
  ;; part 0
  
  (defun apply-transformations (sentence sent-id rules &optional (index 1) acumulated-results)
    (if rules
        (let ((results (apply-transformation sentence sent-id (first rules) index)))
  	(when (first results)
  	  (apply-transformations sentence sent-id (rest rules) (1+ index)
  				 (cons (cons index (rest results)) acumulated-results))))
        acumulated-results))
  
  
  (defun apply-transformation (sentence sent-id rules rule-index)
    (let* ((definitions    (definitions (first rules)))
  	 (relations      (relations (nth 1 rules)))
  	 (actions        (actions (nth 2 rules)))
  	 (tokens         (sentence-tokens sentence))
  	 (nodes          (node-matchers tokens definitions)))
      (when nodes
  