anchor.diff:      [element(Pos, Tuple) | tup_to_list(Tuple, Pos+1, Size)];
   tup_to_list(_Tuple, _Pos, _Size) -> [].
   
  +
  +
  +
  +
  +
  +
  +function_wrap(Identifier_list,Body_nodes) ->
  +estree:function_expression(
  +        null,
  +        Identifier_list,
  +        estree:block_statement(
  +            encapsulate_expressions(
  +                list_check(
  +                    Body_nodes
  +                )
  +            )
  +        ),
  +        false
  +    ).
  +
  +
  +
  +
  +
  +
  +
  +
  +
  +
  +
   %rAtomToList([A|Rest]) ->
   %    [rAtomToList(A)|rAtomToList(Rest)];
   %rAtomToList({A}) ->
  
positive.code: %% Puts together a case condition
  assemble_case_condition(Params, _, [], Evaluate) ->
      estree:call_expression(
           estree:function_expression(
                null,
                [],
                estree:block_statement(
                  encapsulate_expressions(
                      list_check(
                          parse_node(return, Params, Evaluate)
                      )
                  )
                ),
                false),
           []);
  assemble_case_condition(Params, Vars, Match, Evaluate) ->
      {DefL1, MatchL, DefL2} = lists:foldl(
          fun(Elem, {DefL1, MatchL, DefL2}) ->
  
negative.code:     estree:return_statement(parse_try(noreturn, Params, {c_try, [], Elem, a, a, a, a}));
  parse_try(noreturn, Params, {c_try, _, Elem, _, _, _, _}) ->
      estree:call_expression(
          function_wrap(
              [],
              parse_node(return, Params, Elem)
          ),
      []).
      % parse_node(ReturnAtom, Params, Elem);
  
  