anchor.diff:  	   unless (chain s (has elem))
   	   do (chain lst (push elem)))
   	lst))
  +
  +    (defun lines (string) (chain string (split #\newline)))
   
       (defun join (strings &optional (separator "")) (chain strings (join separator)))
   
  
positive.code: 		  (chain -code-mirror commands 
  			 (autocomplete mirror (@ -code-mirror hint ajax) (create :async t))))))
  
         (setf (@ -code-mirror commands show-arg-hint)
  	     (debounce
  	      (lambda (mirror)
  		($aif (by-selector-all ".notebook-arg-hint")
  		      (map (lambda (elem) (chain elem (remove))) it))
  		(labels ((find-first (ctx) 
  			   (cond ((null ctx) nil)
  				 ((or (= "arglist" (@ ctx node_type))
  				      (and (@ ctx prev)
  					   (@ ctx prev node_type)
  					   (= "arglist" (@ ctx prev node_type)))) nil)
  				 ((= "(" (@ ctx opening)) (@ ctx first))
  				 (t (find-first (@ ctx prev))))))
  		  (let* ((coords (chain mirror (cursor-coords)))
  			 (cur (chain mirror (get-cursor)))
  			 (tok (chain mirror (get-token-at cur))))
  		    ($aif (and tok (find-first (@ tok state ctx)))
  			  (progn (console.log tok)
  				 (arg-hint it (+ 1 (@ coords right)) (@ coords bottom)))))))
  	      100))
         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
         (notebook-events)
         (hide! (by-selector ".footer"))
  
negative.code: 
  (define-handler (js/pareditesque.js :content-type "application/javascript") ()
    (ps
      (defun get-cur (mirror)
        (with-slots (line ch) (chain mirror (get-cursor))
  	(create :line line :ch (+ ch 1)))) ;; compensating for codemirrors' alignment issues
      (defun token-type-at-cursor (mirror)
        (chain mirror (get-token-type-at (get-cur mirror))))
      (defun token-at-cursor (mirror)
        (chain mirror (get-token-at (get-cur mirror))))
      (defun go-group-right (mirror) (chain mirror (exec-command "goGroupRight")))
      (defun go-word-right (mirror) (chain mirror (exec-command "goWordRight")))
      (defun go-char-right (mirror) (chain mirror (exec-command "goCharRight")))
      (defun mirror-contents (mirror)
        (chain mirror (get-value)))
  
      (defun char-at-cursor (mirror &optional (ls (lines (mirror-contents mirror))))
        (with-slots (line ch) (chain mirror (get-cursor))
  	(aref ls line ch)))
      (defun char-at-cursor? (char mirror &optional (ls (lines (mirror-contents mirror))))
        (= char (char-at-cursor mirror ls)))
  
      (defun skip-to (chars mirror &optional (ls (lines (mirror-contents mirror))))
        (let ((s (new (-set chars))))
  	(loop do (go-char-right mirror)
  	   until (chain s (has (char-at-cursor mirror ls))))))
      (defun skip-over (chars mirror &optional (ls (lines (mirror-contents mirror))))
        (let ((s (new (-set chars))))
  	(loop do (go-char-right mirror)
  	   ;; TODO careful with this. Each of the skips should check that they're not at the end of the content
  	   while (or (= undefined (char-at-cursor mirror ls)) (chain s (has (char-at-cursor mirror ls)))))))
      (defun skip-whitespace (mirror &optional (ls (lines (mirror-contents mirror))))
        (skip-over (list #\space #\newline #\tab) mirror ls))
  
      (defun forward-sexp (mirror)
        (let ((ls (lines (mirror-contents mirror))))
  	(skip-whitespace mirror ls)
  	(when (= undefined (token-type-at-cursor mirror)) 
  	    (go-group-right mirror))
  	(loop while (and (= nil (token-type-at-cursor mirror))
  			 (not (= "(" (char-at-cursor mirror ls)))
  			 (not (= "\"" (char-at-cursor mirror ls))))
  	   do (go-char-right mirror))
  	(loop while (and (= :bracket (token-type-at-cursor mirror))
  			 (not (char-at-cursor? "(" mirror ls))
  			 (not (char-at-cursor? ")" mirror ls)))
  	   do (go-char-right mirror))
  	(console.log ls (char-at-cursor mirror ls) (= (char-at-cursor mirror ls) " ") (token-type-at-cursor mirror))
  	(cond ((and (= :string (token-type-at-cursor mirror)) (not (char-at-cursor? "\"" mirror ls)))
  	       (skip-over " " mirror ls)
  	       (skip-to " " mirror ls))
  	      ;; ((= :string (token-type-at-cursor mirror))
  	      ;;  ;; skip to end of string
  	      ;;  )
  	      ((and (= :bracket (token-type-at-cursor mirror)) (char-at-cursor? "(" mirror ls))
  	       (loop with tally = 1
  		  do (go-char-right mirror)
  		  when (char-at-cursor? "(" mirror ls) do (incf tally)
  		  when (char-at-cursor? ")" mirror ls) do (decf tally)
  		  until (and (= ")" (char-at-cursor mirror ls)) (= 0 tally)))
  	       (go-char-right mirror))
  	      (t (skip-to " " mirror ls))))
        (console.log (char-at-cursor mirror ls)))
  
      (defun backward-sexp (mirror))
      (defun kill-forward-sexp (mirror))
      (defun kill-backward-sexp (mirror))
  