Thanks. Ok... so, this line here:

```ruby
f = filter.split.collect { |word| word.downcase }
```

Is being called once for each word in the original string. That's not very efficient, right? Ideally, I imagine, we would process the exclusion list once and save it some where, the use the saved version for each word in the original string.... does that make sense?


```ruby
    def filter_proc(filter)
      if filter.respond_to?(:to_a)
        filter_procs = Array(filter).map(&method(:filter_proc))
        ->(word) {
          filter_procs.any? { |p| p.call(word) }
        }
      elsif filter.respond_to?(:to_str)
        f = filter.split.collect { |word| word.downcase } # <---- THIS LINE HERE
        ->(w) { f.include?(w.downcase) }
      elsif Regexp.try_convert(filter)
        filter = Regexp.try_convert(filter)
        Proc.new { |w| w =~ filter }
      elsif filter.respond_to?(:to_proc)
        filter.to_proc
      else
        raise ArgumentError, "Incorrect filter type"
      end
    end
```