anchor.diff:  eval_is([#b_set{op=Op,dst=Dst}=I|Is], From, Bs, St)
     when Op =:= is_tagged_tuple; Op =:= is_nonempty_list ->
       #b_set{args=Args} = sub(I, Bs),
  -    case eval_rel_op(Op, Args, St) of
  +    case eval_test(Op, Args, St) of
           #b_literal{}=Val ->
               eval_is(Is, From, bind_var(Dst, Val, Bs), St);
           none ->
  
positive.code: 
  shortcut_terminator(#b_br{bool=#b_literal{val=true},succ=Succ0},
                      _Is, From, St0) ->
      St = St0#st{rel_op=none},
      shortcut(Succ0, From, #{}, St);
  shortcut_terminator(#b_br{bool=#b_var{}=Bool,succ=Succ0,fail=Fail0}=Br,
                      Is, From, St0) ->
      St = St0#st{target=one_way},
      RelOp = get_rel_op(Bool, Is),
  
      %% The boolean in a `br` is seldom used by the successors. By
      %% not binding its value unless it is actually used we might be able
      %% to skip some work in shortcut/4 and sub/2.
      SuccBs = bind_var_if_used(Succ0, Bool, #b_literal{val=true}, St),
      BrSucc = shortcut(Succ0, From, SuccBs, St#st{rel_op=RelOp}),
      FailBs = bind_var_if_used(Fail0, Bool, #b_literal{val=false}, St),
      BrFail = shortcut(Fail0, From, FailBs, St#st{rel_op=invert_op(RelOp)}),
  
      case {BrSucc,BrFail} of
          {#b_br{bool=#b_literal{val=true},succ=Succ},
  
negative.code: -type basic_type_test() :: atom() | {'is_tagged_tuple',pos_integer(),atom()}.
  -type type_test() :: basic_type_test() | {'not',basic_type_test()}.
  -type op_name() :: atom().
  -type basic_test() :: {op_name(),beam_ssa:b_var(),beam_ssa:value()} |
                        {basic_type_test(),beam_ssa:value()}.
  -type test() :: {op_name(),beam_ssa:b_var(),beam_ssa:value()} |
                  {type_test(),beam_ssa:value()}.
  
  -record(st,
          {bs :: beam_ssa:block_map(),
           us :: used_vars(),
           skippable :: #{beam_ssa:label():='true'},
           test=none :: 'none' | test(),
           target=any :: 'any' | 'one_way' | beam_ssa:label()
          }).
  
  