anchor.diff:      lists:last(List);
       
   get_value(Index, [_H | _T] = List)
  -		when is_integer(Index) ->
  +        when is_integer(Index) ->
       lists:nth(Index, List);
       
   get_value(Index, Obj)
  -		when is_integer(Index)  ->
  +        when is_integer(Index)  ->
       erlang:error({index_for_non_list, {Index, Obj}});
  -    
  -get_value(_Key, [_H | _T]) ->
  -    undefined;    
  -    
  -    
  -get_value({startswith, KeyPrefix}, List)
  -		when is_binary(KeyPrefix) ->
  -    Res = lists:filter(fun({K, _}) -> matching_prefix(KeyPrefix, K) end, List),
  -    case Res of
  -        [] -> undefined;
  -        _ -> Res
  -    end;
  -    
  -    
  -get_value(Key, {from_select, []}) ->
  +
  +
  +% array_select()
  +get_value(_Key, {from_select, []}) ->
       undefined;
       
  -get_value(Key, {from_select, List}) ->
  +get_value(Key, {from_select, List})
  +        when is_list(List)  ->
       lists:flatten([get_value(Key, L) || L <- List]);    
       
   get_value({select, KeyValue}, [_H | _T] = List)
  -		when is_tuple(KeyValue) orelse KeyValue =:= all  ->
  -    {from_select, matching_array_elements(KeyValue, List)}.
  +        when is_tuple(KeyValue) orelse KeyValue =:= all  ->
  +    {from_select, matching_array_elements(KeyValue, List)};
  +    
  +get_value({select, KeyValue}, #{} = Map)
  +        when is_tuple(KeyValue) orelse KeyValue =:= all  ->
  +    {from_select, matching_array_elements(KeyValue, maps:to_list(Map))};    
  +    
  +
  +get_value(_Key, [_H | _T]) ->
  +    undefined.
  +    
  +    
  +% catchall  error?    
  +%get_value(_Key, _Obj) ->
  +%    undefined.
   
       
   %%%%% ------------------------------------------------------- %%%%%
  
positive.code:     
  matching_array_elements(CompKey, List) ->
      lists:filter(fun(E) -> matching_element(CompKey, E) end, List).
  
      
  matching_prefix(Prefix, V) ->
      PrefixSize = byte_size(Prefix),
      case V of
          <<Prefix:PrefixSize/binary, _/binary>> -> true;
          _ -> false
      end.
  
      
  matching_element({K, V}, {struct, E}) ->
      Value = as_binary(V),
      case lists:keyfind(as_binary(K), 1, E) of
        false      -> false;
  
negative.code:       _          -> false
      end;
      
  matching_element(CompKey, {E})
          when is_list(E)  ->
      matching_element(CompKey, E);
      
  matching_element(Key, E) ->
      erlang:error({error_matching_element, {Key, E}}).
  