code: def filter(key, *options)
        if options.present? && options.first.instance_of?(Hash)
          options = options.first.with_indifferent_access
  
          if options.key?(:only)
            return filter_only_values(key, options[:only])
          elsif options.key?(:except)
            return filter_excluded_values(key, options[:except])
          end
        else
          return fetch(key, *options)
        end
      end
docs: Filters and returns the raw data values for the specifid key and options
  
   @param key [String,Symbol] the key of the values in {#data} to filter
   @param [optional, Hash] options the options available for this filter
   @option options [optional] :only when specified, only return the matching values
     If you specify a single value, a single value will be returned
     If you specify an Array of values, an Array will be returned, even if only one value matches
   @option options [optional] :except return all values except the ones given here
     If the raw data value is a single value, a single value will be returned
     If the raw data value is an Array, and array will be returned, even if all values are excluded
     If nothing was excluded, the raw value is returned as-is
  
   If you pass a scalar value instead of a Hash into options, it will be treated as the default, just like
   Hash#fetch does.
  
   If you pass nothing into the options argument, it will return all values if the key exists or raise
   a KeyError like Hash#fetch.
  
   @return [void]
  
   @example
  
     data = { :select => [:id, :name, :created_at] }
     results = Muster::Results.new(data)
     results.filter(:select)                            #=> [:id, :name, :created_at]
     results.filter(:select, :only => :name)            #=> :name
     results.filter(:select, :only => [:other, :name])  #=> [:name]
     results.filter(:other, :default)                   #=> :default
     results.filter(:other)                             #=> KeyError