anchor.diff:        {"{("Much" "nesting") | string join on " "} is divinest sense" | run | split on " " | join on " "}
           Much nesting is divinest sense
   
  -:::In Depth:::
  -
  -We've seen the 5 elements of Daimio (three primitive types, commands, and the pipe operator). We've also seen 3 types of sugar that can be applied (variables, blocks, and aliases). Here we'll examine some of those areas in more depth.
  -
  -Depth 1: Blocks and scope
  +
  +<h2>In Depth: Scope</h2>
   
     so.... blocks don't have a private scope. there's currently pipeline vars and space vars. pipeline vars are single-assignment and can bleed through blocks (but not into called subblocks). 
     
  
positive.code:         2
    
    We'll see some more ways to reach into variables in a bit.
    
  
  Snack 2: Blocks
  
    A block encloses text. [Could be a template, or some Daimio code (or a mix). they're roughly equivalent to a string join + context + var. discuss var scope]
    
    Note that blocks no longer set variables automatically. We may include a {begin $foo}...{end $foo} form in the future to allow automatic var setting, but scope vars should be used carefully so forcing explicit setting is probably good. (We could also consider automatically setting a pipeline var, but for now explicit and simple is better.)
    
      Here's a simple block:
        {begin foo}Some text{end foo}
          Some text
  
negative.code:       four sixsix...
      {"foursixsixfour" | string truncate to 10 add "..."}
        foursixsix...
  
      
  
  <h3>PROCESS COMMANDS</h3>
  
    
    RUN
      { "{12 | add 1}" | run}
        13
      {("{1 | add 2}" "{2 | add 7}") | map block "{__ | run}"}
        [3,9]
      { "{__ | add 1}" | run with 7}
        8
      { "{_foo | add 1}" | run with {* (:foo 91)}}
        92
  
  
  <h2>EDGE CASES</h2>
  
    A section for pushing the parser and interpreter into corners.
    
    
    
  notes: the block execution scope isn't being given each item, and also isn't given even the first item correctly. probably need to do this global looping manually over all matches to properly support this effect... maybe two different commands or params? or just don't worry about opt yet.
    {"12 x 34" | string transform from "/\d+/g" to "{__ | add 7}"}
      19 x 41
  
  Extra braces don't matter. extra quotes do, but are generally ok.
    {{{"{__ | add {"4"}}"}} | map data {(1 2)} }
      [5,6]
      
  
  Tests for switch
    ham?
      {logic switch on 2 value (1 :one 2 :two 3 :three)}
        two
      
      {logic switch on {:asdf | string slice start 2} value (:as 1 :sd 2 :df 3)}
        3
  
  Tests for blocks
    the second set should override the first one (BUG)
      {"{:foo}x" | $>xxx || 123 | $>xxx.y | $xxx}
        {y:123}
    works this way
      {"{:foo}x" | $>xxx || 123 | $>xxx.#3 | $xxx}
        ["{:foo}x",[],123]
    
    make sure we're not defuncing pre-merge
    NOTE: needing the x:1 before poking is a bug (BUG)
      {* (:x 1) | $>qq}
        {"x":1}
      {"{:foo}x" | $>qq.ww.ee || merge data $qq block "{_ee | quote}"}
        {:foo}x
      {$qq | merge block "{__}"}
        1{"ee":"{:foo}x"}
      {$qq | merge block "{(__)}"}
        [1][{"ee":"{:foo}x"}]
          
  
  Tests for stringification
    {1 | $>power || each data (1 2 3 4) block "{math pow value 2 exp $power | $>power} "}
      2 4 16 65536
  
      
  Tests for pipes
    ensure we're not front-piping: the initial command segment shouldn't get pipe vars
  