>>>>> On Mon, 4 Aug 2014, Michał Górny wrote:

> Reasonable. However, as I see it, we'll end up having up to four
> different operators:

> - || that is deprecated yet everyone will still use it (like they don't
>   use :* right now),

> - ||* that will be used scarcely,

> - <<= that would be the preferred variant for compile-time switches yet
>   many people will not use it because it has different characters than
>   '||' [we could try maybe '||<' so that people will still see it as
>   replacement for '||'],

> - ||= that most people would use forgetting about '<<=' [or '||<'].

No, we will have only two distinct operators, namely ||* and ||=.
Alternatively, or in addition, || could be kept but would be identical
to ||*.

> So, banning '|| ( A:= B:= )' in a future EAPI sounds reasonable.

What prevents us from banning it now, by adding a repoman check?
The || ( A:= B:= ) construct would mean that you can switch from
provider A to provider B and back to A. Nothing would prevent you from
choosing a different slot in the second step, which renders the :=
operator meaningless.

> However, there's still the matter of setting current Portage behavior
> because I don't we should keep the non-predictable magic.

> What should be the current behavior then? Should we assume that all
> '||' are not well-defined and need to be compile-switchable? Or try to
> invent heuristic like I suggested?

The devmanual [1] is very clear about it. || ( ) is only allowed if
the implementation can be switched at runtime:

# * fnord is merged on a system which has foo and not bar installed.
#   foo is then unmerged, and bar is installed. fnord must continue to
#   work correctly.
# * A binary package of fnord made on a system with foo and not bar
#   can be taken and installed on a system with bar and not foo.

Ulrich

[1] http://devmanual.gentoo.org/general-concepts/dependencies/index.html