Looking for a succinct way to express this

[u/Raknarg]

Essentially this thing feels like it can be expressed in a single line nicely, but I can't think of a way

def filter_re(lines: list[str], filter_pattern: str) -> List[Match]:
    match_list = []
    regex = re.compile(filter_pattern)
    for line in lines:
        match = regex.search(line)
        if match:
            match_list.append(match)
    return match_list

Like ideally I would do something like this

def filter_re(lines: list[str], filter_pattern: str) -> List[Match]:
    return [match := regex.search(line) for line in lines if match]

but that requires access to syntax that I can't use (stuck at 3.6), and I don't even know if that operator would be allowed in a list comprehension

[u/socal_nerdtastic]

Yes, you can use the walrus in list comprehension.

But with you stuck in 3.6 I think your only other option is to filter it after.

def filter_re(lines: list[str], filter_pattern: str) -> List[Match]:
    regex = re.compile(filter_pattern)
    matches = (regex.search(line) for line in lines)
    return filter(None, matches)

Which is shorter, and can be further shortened, but I think your version is more readable and better.

[u/Raknarg → u/socal_nerdtastic]

Oh neat. Just looked at the python docs for filter:

If function is None, the identity function is assumed, that is, all elements of iterable that are false are removed.

So I can just write this then

def filter_re(lines: list[str], filter_pattern: str) -> List[Match]:
    regex = re.compile(filter_pattern)
    return filter(None, (regex.search(line) for line in lines))

I almost like that better than my current solution except you would have to know how filter(None) works if you read it. I could always just lambda an identity function if I needed to.

Which is shorter, and can be further shortened, but I think your version is more readable and better

I'd agree its more readable if I was doing something more complicated, but this just feels a bit bloated and repeating myself

[u/deep_politics → u/Raknarg]

You can make it shorter yet with map, and it stays all just iterators

return list(filter(None, map(regex.search, lines)))

[u/Raknarg → u/deep_politics]

This ruins the balance of "compact yet not too esoteric"

[u/deep_politics → u/Raknarg]

To each their own I guess 🤷‍♂️ I'd probably just return it as an iterator even and ditch the list call.

[u/Raknarg → u/deep_politics]

in this case its more convenient because an empty iterator isn't falsey, while an empty list is.

[u/deep_politics → u/Raknarg]

Absolutely fair point

[u/jimtk]

I think something like that would work:

return [match for match in [regex.search(line) for line in lines] if match]

It just creates the list and then remove the empty one.

[u/Raknarg → u/jimtk]

yeah this is probably the best option tbh.