anchor.diff:  	   (transpiler-dot-symbol-string tr sl)
   	   (transpiler-symbol-string-0 tr s))))
   
  +(defun transpiler-to-string-cons (tr x)
  +  (?
  +    (%transpiler-string? x)      (funcall (transpiler-gen-string tr) (cadr x))
  +    (eq '%transpiler-native x.)  (transpiler-to-string tr .x)
  +    x))
  +
   (defun transpiler-to-string (tr x)
  -  (maptree #'((e)
  -				(?
  -				  (cons? e)
  -					(?
  -					  (%transpiler-string? e)
  -						(funcall (transpiler-gen-string tr) (cadr e))
  -					  (eq '%transpiler-native e.)
  -						(transpiler-to-string tr .e)
  -					  e)
  -				  (string? e)
  -					e
  -				  (or (assoc-value e (transpiler-symbol-translations tr) :test #'eq)
  -					  (transpiler-symbol-string tr e))))
  +  (maptree (fn ?
  +			    (cons? _)    (transpiler-to-string-cons tr _)
  +			    (string? _)  _
  +				(or (assoc-value _ (transpiler-symbol-translations tr) :test #'eq)
  +					(transpiler-symbol-string tr _)))
   		   x))
  
positive.code: 
  (defun transpiler-special-char? (tr x)
    (not (funcall (transpiler-identifier-char? tr) x)))
  
  (defun transpiler-symbol-string-r (tr s)
    (with (encapsulate-char
  
negative.code: 				   (? (digit-char-p c)
  					  (append (encapsulate-char c)
  							  (convert-special2 ._))
  					  (convert-special2 _)))))
          convert-global
  	       #'((x)
                 (let l (length x)
                   (remove-if (fn = _ #\-) (string-list (string-upcase (subseq x 1 (1- l))))))))
  	(? (or (string? s)
  		   (number? s))
  	   (string s)
         (list-string
             (let str (string s)
  	         (convert-special (? (global-variable-notation? str)
                                   (convert-global str)
      	                         (convert-camel (string-list str) 0))))))))
  
  (defun transpiler-symbol-string-0 (tr s)
    (aif (symbol-package s)
  