anchor.diff:    {"~{__}~" | string transform from "~" to "!" | unquote | each data (1 2 3)}
       !1!!2!!3!
     
  -- I take a Daimio string, get its ptree, do some mangling (macros), then get the processed output.
  -------> THINK: do we want this in here? I'm taking it out for now because it's kind of silly.
  -//  {daimio parse string "x{foo}y"}
  -//    {"m":"string","f":"join","p":{"value":["x",{"m":"variable","f":"get","p":{"path":"foo"}},"y"]}}
  -//  {variable set path :xy value {daimio parse string "x{foo}y"}}
  -//    {"m":"string","f":"join","p":{"value":["x",{"m":"variable","f":"get","p":{"path":"foo"}},"y"]}}
  -//  {variable set path :xy.p.value.#3 value "z"}
  -//    z
  -//  {xy}
  -//    x123z
  -
  -- I take a Daimio string, pass it to the server, capture the (possibly object) return value and use it.
  -
  -  
  -
   - ensure all strings get fully processed
     {"{"{"{1} 2"} 3"} 4"}
       1 2 3 4
  
positive.code:         42
        {20 | ( {__} 2 {__} ) | add}
          42
  
  
      
      Double pipes are also used to squelch output from a pipeline:
        {42 ||}
  
negative.code:   {"{"{"{1} 2"} 3"} 4" | quote}
      {"{"{1} 2"} 3"} 4
    
  
  
  
  
  BLOCK APPLICATION AND ORDER OF OPERATIONS
  
    Inside the list we're evaluating {2 | $>a} before the next call to $a
      {1 | $>a | ( $a {2 | $>a} $a )}
        [1,2,2]
  
    Same here -- the braces around $a have no effect
      {2 | $>a | ( {$a} {4 | $>a} {$a} )}
        [2,4,4]
  
    Block processing comes later, or sometimes not at all
      {4 | $>a | ( "{$a}" {8 | $>a} {$a} ) | unquote}
        ["8",8,8]
      {4 | $>a | ( "{$a}" {8 | $>a} {$a} )}
        ["{$a}",8,8]
  
    Set up a block that changes the value in $value
      {:x | $>x || :y | $>y || :xylo | $>value}
        xylo
      {begin x_to_y | $>x_to_y}{string transform value $value from $x to $y}{end x_to_y}
        yylo
      {:xyzzy | $>value || $x_to_y}
        yyzzy
      
    Anything we apply it to is stringified (and blocks in lists aren't executed by default)
      {"{(:tex :mex)}" | $>value | ($value $x_to_y {$value | run} {$x_to_y | run})}
        ["{(:tex :mex)}","{string transform value $value from $x to $y}",["tex","mex"],"{(:tey :mey)}"]
    
    Even itself
      {$x_to_y | $>value | $x_to_y | run}
        {string transform value $value from $y to $y}
        
    But we can explicitly unquote it
  // THINK: what are we really doing here? this is completely demented.
  //    {$x_to_y | $>value | $x_to_y | run | >y_to_y | "/[y{__}]/" | $>y | _y_to_y | unquote | run}
  //      asdlkfjasldkfj
        
  
    alternately:
      {$x_to_y | string transform from :x to :z | string transform from :y to :x | string transform from :z to :y | $>y_to_x}
        {string transform value $value from $y to $x}
    
      {"axy fix hex hoax" | $>value || :x | $>x || :y | $>y || $y_to_x}
        {string transform value $value from $y to $x}
  
  
    run the process instantly
      {"axy fix hex hoax" | $>value || :x | $>x || :y | $>y || $y_to_x | unquote | run}
        axx fix hex hoax
  
      {$y_to_x | unquote | run | quote}
        axx fix hex hoax
  
  
    unquote the string to create a block
      {$y_to_x | unquote | $>y_to_x_block}
        axx fix hex hoax
  
      {$y_to_x | unquote | quote}
        {string transform value $value from $y to $x}
  
      {"axy faxy foxy" | $>value || $y_to_x_block}
        axx faxx foxx
  
    Let's examine strings in strings in braces etc
      {:z | $>z | :a | $>y}
        a
  
    test for fully processing each nested block
      {"1 {$z} {"2 {$z} {"3 {$z}"}"}"}
        1 z 2 z 3 z
  
    this test shows that we process elements in the outer block before processing the inner block -- i.e., the last $y is processed before the earlier ones. 
      {"1 {"{$y} 2 {$z | $>y} 3"} {$y}"}
        1 a 2 z 3 a
      
    this time we're explicitly running the inner block
      {"1 {"{$y} 2 {:x | $>y} 3" | run} {$y}"}
        1 z 2 x 3 x
  
    testing order of operations. 
      {1 | $>x | ({"{$x}" | $>asdf} "zxcv" {"{$x}"} $asdf) | string join on " "}
        {$x} zxcv {$x} {$x}
      {1 | $>x | ({"{$x}" | $>asdf} "zxcv" {"{$x}"} $asdf) | string join on " " | unquote}
        1 zxcv 1 1
      
    notice that the block inside the list isn't processed until after the pipelines in the list.
      {1 | $>x | "{$x}dog" | $>asdf | ($asdf {8 | $>x} $asdf) | string join on " "}
        {$x}dog 8 {$x}dog
      {1 | $>x | "{$x}dog" | $>asdf | ($asdf {8 | $>x} $asdf) | string join on " " | unquote}
        8dog 8 8dog
      {1 | $>x | "{$x}dog" | $>asdf | ($asdf "{8 | $>x}" $asdf) | string join on " " | unquote}
        1dog 8 8dog
  
    When the list is processed by {string join} it quotes any blocks. 
      {:bebop | $>genre | ($genre {:modal | $>genre} $genre {"{"渋谷系" | $>genre}"} $genre) | string join on " {$genre} "}
        bebop {$genre} modal {$genre} modal {$genre} {"渋谷系" | $>genre} {$genre} modal
      
    Unquoting after finishes the processing.
      {:bebop | $>genre | ($genre {:modal | $>genre} $genre {"{"渋谷系" | $>genre}"} $genre) | string join on " {$genre} " | unquote}
        bebop modal modal modal modal modal 渋谷系 渋谷系 modal
    
    Blocks inside vars suffer the same fate.
      {({"{$x}dog" | $>asdf} $asdf {8 | $>x} $asdf) | string join on " {$x} "}
        {$x}dog {$x} {$x}dog {$x} 8 {$x} {$x}dog
      {1 | $>x | ({"{$x}dog" | $>asdf} $asdf {8 | $>x} $asdf) | string join on " {$x} " | unquote}
        8dog 8 8dog 8 8 8 8dog
      
    
    
    
  