RFC: revset relation operator

[Matt Mackall]

On Tue, 2015-10-13 at 13:16 -0700, Durham Goode wrote:
> 
> On 10/12/15 7:07 AM, Augie Fackler wrote:
> > On Sun, Oct 11, 2015 at 05:45:24PM -0500, Matt Mackall wrote:
> >> It would be nice if we had a convenience syntax for finding things
> >> related to a given changeset. Currently, we have a couple of these for
> >> parents, ancestors, and descendants.
> >>
> >>   foo^  # first parent
> >>   foo^2 # second parent
> >>   foo^^ # first parent of first parent
> >>   foo~2 # same
> >>   ::foo # ancestors, inclusive
> >>   foo:: # descendants, inclusize
> >>
> >> But we have nothing directly equivalent to parents(), nor any shorthand
> >> for children(), successors(), origin(), destination(), or any other type
> >> of relation we may add. We'd also like a way to specify next, previous,
> >> all, all exclusive, last, etc.
> >>
> >> So my proposal[1] is to add a bracketed postfix (one of {}, [], or <>,
> >> but perhaps {} is the least bad) that looks like this:
> >>
> >>   foo{1}     # children(foo)
> >>   foo{2}     # children(children(foo))
> >>   foo{}      # defaults to 1, so children(foo)
> >>   foo{0}     # synonym for foo
> >>   foo{-1}    # parents(foo) (both of 'em)
> >>   foo{-}     # same
> >>   foo{*}     # foo:: - foo (exclusive)
> >>   foo{**}    # foo:: (inclusive)
> >>   foo{-*}    # ::foo - foo
> >>   foo{$}     # heads(foo::) aka "the last children"
> >>   foo{-4}::foo # last five changesets in a branch
> >>
> >> This makes a lot of our most common expressions shorter. To talk about
> >> other types of relations, we use a suffix character:
> >>
> >>   foo{1g}    # immediate grafts of foo
> >>   foo{-g}    # origin for grafts
> >>   foo{o}     # successor(foo)
> >>   foo{$o}    # final successor of foo
> > Neat. The one-character suffix thing gives me a little pause as
> > possibly-not-entirely-self-documenting. Maybe it could be whole [a-z]
> > words, and we could allow unambiguous prefixes?
> I thought about using a multidimensional array style syntax for allowing 
> full words instead of single letters:
> 
> foo{1g} == foo{1, graft}

This form with the comma will definitely trigger shell expansion and
thus require quoting. I'm ok with allowing a space here though:

foo{1g} == foo{1 g} == foo{1 graft}

> which allow for more self-documenting uses.
> 
> I also thought about using [] to have the nice side effect of implying a 
> array style access:
> 
> foo[-1]
> foo[1, graft]
> foo[$][-1o]

This isn't a show-stopper, but the analogy doesn't work well for me. []
is usually an operation on lists or arrays that returns an element
inside that array:

 container[integer] -> subelement

The relation operator is an operation on one or more nodes of a graph
(and not the graph as a whole) that return other elements by following
graph edges outward from that set:

 set[distance dimension] -> set

If we're going to use [] for something, it should probably be as a way
to replace first/last/limit:

 heads()[0] -> first(heads())
 heads()[-1] -> last(heads())
 heads()[:10] -> limit(heads(), 10)

-- 
Mathematics is the supreme nostalgia of our time.