Taylor Blau <m...@ttaylorr.com> writes:
> * `git grep --and -e foo -e bar`. This binary operation should recur
> on its sub-expressions and take the minimum of the starting offset
> and the maximum of the ending offset.
We use infix notation, so the above is "git grep -e foo --and -e
bar" actually ;-).
But you raise an interesting point. A line with "hello foo bar baz"
on it would match, so does a line with "goodbye bar baz foo", as
both of them hits pattern "foo" *and* pattern "bar". It is not
quite clear what it means to "show the first hit on the line". One
interpretation would be to take the minimum span that makes both
sides of "--and" happy (your "minimum of start, maximum of end").
Another might be to pick "foo" in the first and "bar" in the second
line, as that is the "first hit" on the line, which is consistent
with how "git grep -e foo" would say about "a foo b foo c foo" (I
expect that the leftmost "foo" would be the first hit). So there
may be multiple, equally plausible answer to the question.
> For inputs of the form "foobar" and "foo bar", it will do the right
> thing (give the starting and ending offset for "foobar" and give no
> match, respectively).
I think I agree with "foobar", but I do not understand why there is
no match for "foo bar".
> * `git grep --or -e foo -e bar`. This is the most complicated case, in
> my opinion. In going with the min/max idea in the and case above, I
> think that `--or` should also min/max its sub-expressions, but in
> fact we short-circuit evaluating the second sub-expression when we
> find a match for the first.
I am not sure I follow. "git grep -e foo --or -e bar" is just a
longhand for "git grep -e foo -e bar". Shouldn't it highlight
whichever between foo and bar that appears leftmost on the line?
> So, in cases like matching `--or -e foo -e bar` with "foo baz bar",
> we'll do the right thing, since `foo` is the first sub-expression
> and happens to be the left-most match. In other words, we __adhere
> to our answer with the left-most match first__ semantics, but only
> because __the first sub-expression is the left-most match__.
> In the other case where we try and match the same expression against
> "bar baz foo", we'll return the starting offset of "foo", even
> though it isn't the left-most match, violating our semantics.
I am not sure why you think your min-starting/max-ending would lead
to such a conclusion. 'foo baz bar' would be covered in its
entirety, 'bar baz foo' would also, as starting of hits with pattern
'foo' and pattern 'bar' would be 'b' in 'bar' on that three-word
line, and ending of hits with these two patterns would be the last
'o' in 'foo' on the line.
I'd expect that a line 'foo baz bar' matched against "-e foo --or -e
bar" would say "among three words on me, 'f' in foo is the first
location of the match", though.