Präzise Semantik

PEP 634 enthält explizit einen Abschnitt über undefiniertes Verhalten. Große Mengen undefinierten Verhaltens mögen in einer Sprache wie C akzeptabel sein, aber in Python sollte es auf ein Minimum beschränkt werden. Pattern Matching in Python kann präziser definiert werden, ohne an Ausdrucksstärke oder Leistung zu verlieren.

Verbesserte Kontrolle über Klassenabgleich

PEP 634 delegiert die Entscheidung, ob eine Klasse eine Sequenz oder ein Mapping ist, an collections.abc. Nicht alle Klassen, die als Sequenzen betrachtet werden könnten, sind als Unterklassen von collections.abc.Sequence registriert. Dieser PEP erlaubt ihnen, Sequenzmuster abzugleichen, ohne die vollständige collections.abc.Sequence Maschinerie.

PEP 634 bevorzugt einige eingebaute Klassen mit einer speziellen Form des Abgleichs, dem "Self"-Abgleich. Zum Beispiel gleicht das Muster list(x) eine Liste ab und weist die Liste x zu. Indem Klassen erlaubt wird zu wählen, welche Arten von Mustern sie abgleichen, können andere Klassen diese Form ebenfalls verwenden.

Zum Beispiel könnten wir mit sympy schreiben

# a*a == a**2
case Mul(args=[Symbol(a), Symbol(b)]) if a == b:
    return Pow(a, 2)

Was erfordert, dass die sympy-Klasse Symbol einen "Self"-Abgleich durchführt. Für sympy ist es möglich, dieses Muster mit PEP 634 zu unterstützen, aber ein wenig knifflig. Mit diesem PEP kann es sehr einfach implementiert werden [1].

Robustheit

Mit diesem PEP wird der Zugriff auf Attribute während des Pattern Matching gut definiert und deterministisch. Dies macht Pattern Matching fehlerresistenter beim Abgleichen von Objekten mit versteckten Nebeneffekten, wie z. B. Objekt-Relationalen Mappern. Objekte erhalten mehr Kontrolle über ihre eigene Dekonstruktion, was unbeabsichtigte Folgen verhindern kann, falls der Attributzugriff Nebeneffekte hat.

PEP 634 stützt sich auf das collections.abc Modul, wenn es bestimmt, welche Muster ein Wert abgleichen kann, und importiert es bei Bedarf implizit. Dieser PEP eliminiert überraschende Importfehler und irreführende Audit-Ereignisse durch diese Imports.

Effiziente Implementierung

Die in diesem PEP vorgeschlagene Semantik ermöglicht eine effiziente Implementierung, teilweise aufgrund einer präzisen Semantik und teilweise durch die Nutzung des Objektmodells.

Mit präziser Semantik ist es möglich, darüber nachzudenken, welche Code-Transformationen korrekt sind, und somit Optimierungen effektiv anzuwenden.

Da das Objektmodell ein Kernbestandteil von Python ist, verarbeiten Implementierungen spezielle Attribut-Lookups bereits effizient. Das Nachschlagen eines speziellen Attributs ist viel schneller als das Durchführen eines Unterklassen-Tests bei einer abstrakten Basisklasse.

Ergänzungen zum Objektmodell

Die Attribute __match_container__ und __match_class__ werden zu object hinzugefügt. __match_container__ sollte von Klassen überschrieben werden, die Mapping- oder Sequenzmuster abgleichen möchten. __match_class__ sollte von Klassen überschrieben werden, die das Standardverhalten beim Abgleichen von Klassenmustern ändern möchten.

__match_container__ muss ein Integer sein und sollte genau einer der folgenden sein

0
MATCH_SEQUENCE = 1
MATCH_MAPPING = 2

MATCH_SEQUENCE wird verwendet, um anzuzeigen, dass Instanzen der Klasse Sequenzmuster abgleichen können.

MATCH_MAPPING wird verwendet, um anzuzeigen, dass Instanzen der Klasse Mapping-Muster abgleichen können.

__match_class__ muss ein Integer sein und sollte genau einer der folgenden sein

0
MATCH_SELF = 8

MATCH_SELF wird verwendet, um anzuzeigen, dass bei einem Klassenmuster mit einem einzigen Positionsargument das Subjekt und nicht seine Dekonstruktion verwendet wird.

object wird die folgenden Werte für die speziellen Attribute haben

__match_container__ = 0
__match_class__= 0
__match_args__ = ()

Diese speziellen Attribute werden wie gewohnt vererbt.

Wenn __match_args__ überschrieben wird, muss es ein Tupel von eindeutigen Strings enthalten. Es kann leer sein.

Die Pattern-Matching-Implementierung ist *nicht* verpflichtet zu prüfen, ob diese Attribute sich wie spezifiziert verhalten. Wenn der Wert von __match_container__, __match_class__ oder __match_args__ nicht wie spezifiziert ist, kann die Implementierung jede Ausnahme auslösen oder das falsche Muster abgleichen. Natürlich steht es Implementierungen frei, diese Eigenschaften zu prüfen und aussagekräftige Fehlermeldungen bereitzustellen, wenn sie dies effizient tun können.

Semantik des Matching-Prozesses

Im Folgenden sind alle unten aufgeführten zusätzlichen Codes, die nicht im Originalquelltext vorhanden sind, werden keine Zeilenereignisse auslösen, gemäß PEP 626.

Variablen der Form $var sind temporäre Variablen und für das Python-Programm nicht sichtbar. Sie können durch Introspektion sichtbar sein, aber das ist ein Implementierungsdetail und sollte nicht davon abhängig gemacht werden. Die Pseudo-Anweisung FAIL wird verwendet, um anzuzeigen, dass der Abgleich für dieses Muster fehlgeschlagen ist und dass der Abgleich zum nächsten Muster übergehen sollte. Wenn die Kontrolle das Ende der Übersetzung ohne Erreichen eines FAIL erreicht, hat es abgeglichen, und folgende Muster werden ignoriert.

Variablen der Form $ALL_CAPS sind Metavariablen, die ein syntaktisches Element enthalten, sie sind keine normalen Variablen. So ist $VARS = $items keine Zuweisung von $items an $VARS, sondern ein Entpacken von $items in die Variablen, die $VARS enthält. Zum Beispiel bei der abstrakten Syntax case [$VARS]: und der konkreten Syntax case[a, b]: würde $VARS die Variablen (a, b) enthalten, nicht die Werte dieser Variablen.

Die Pseudo-Funktion QUOTE nimmt eine Variable und gibt den Namen dieser Variablen zurück. Wenn zum Beispiel die Meta-Variable $VAR die Variable foo enthielte, dann wäre QUOTE($VAR) == "foo".

match expr:

$value = expr

case capture_var:

capture_var = $value

case _:

# No code -- Automatically matches

case LITERAL:

if $value != LITERAL:
    FAIL

if $value is not LITERAL:
    FAIL

case value.pattern:

if $value != value.pattern:
    FAIL

case [$VARS]:

$kind = type($value).__match_container__
if $kind != MATCH_SEQUENCE:
    FAIL
if len($value) != len($VARS):
    FAIL
$VARS = $value

case [$VARS]

$kind = type($value).__match_container__
if $kind != MATCH_SEQUENCE:
    FAIL
if len($value) < len($VARS):
    FAIL
$VARS = $value # Note that $VARS includes a star expression.

case {$KEYWORD_PATTERNS}:

$sentinel = object()
$kind = type($value).__match_container__
if $kind != MATCH_MAPPING:
    FAIL
# $KEYWORD_PATTERNS is a meta-variable mapping names to variables.
for $KEYWORD in $KEYWORD_PATTERNS:
    $tmp = $value.get(QUOTE($KEYWORD), $sentinel)
    if $tmp is $sentinel:
        FAIL
    $KEYWORD_PATTERNS[$KEYWORD] = $tmp

case {$KEYWORD_PATTERNS, **$DOUBLE_STARRED_PATTERN}:

$kind = type($value).__match_container__
if $kind != MATCH_MAPPING:
    FAIL
# $KEYWORD_PATTERNS is a meta-variable mapping names to variables.
$tmp = dict($value)
if not $tmp.keys() >= $KEYWORD_PATTERNS.keys():
    FAIL:
for $KEYWORD in $KEYWORD_PATTERNS:
    $KEYWORD_PATTERNS[$KEYWORD] = $tmp.pop(QUOTE($KEYWORD))
$DOUBLE_STARRED_PATTERN = $tmp

case ClsName():

if not isinstance($value, ClsName):
    FAIL

case ClsName($VAR):

$kind = type($value).__match_class__
if $kind == MATCH_SELF:
    if not isinstance($value, ClsName):
        FAIL
    $VAR = $value
else:
    As other positional-only class pattern

case ClsName($VARS):

if not isinstance($value, ClsName):
    FAIL
$attrs = ClsName.__match_args__
if len($attr) < len($VARS):
    raise TypeError(...)
try:
    for i, $VAR in enumerate($VARS):
        $VAR = getattr($value, $attrs[i])
except AttributeError:
    FAIL

case ClsName($KEYWORD_PATTERNS):

if not isinstance($value, ClsName):
    FAIL
try:
    for $KEYWORD in $KEYWORD_PATTERNS:
        $tmp = getattr($value, QUOTE($KEYWORD))
        $KEYWORD_PATTERNS[$KEYWORD] = $tmp
except AttributeError:
    FAIL

case ClsName($VARS, $KEYWORD_PATTERNS):

if not isinstance($value, ClsName):
    FAIL
$attrs = ClsName.__match_args__
if len($attr) < len($VARS):
    raise TypeError(...)
$pos_attrs = $attrs[:len($VARS)]
try:
    for i, $VAR in enumerate($VARS):
        $VAR = getattr($value, $attrs[i])
    for $KEYWORD in $KEYWORD_PATTERNS:
        $name = QUOTE($KEYWORD)
        if $name in pos_attrs:
            raise TypeError(...)
        $KEYWORD_PATTERNS[$KEYWORD] = getattr($value, $name)
except AttributeError:
    FAIL

case [int(), str()]:

$kind = type($value).__match_class__
if $kind != MATCH_SEQUENCE:
    FAIL
if len($value) != 2:
    FAIL
$value_0, $value_1 = $value
#Now match on temporary values
if not isinstance($value_0, int):
    FAIL
if not isinstance($value_1, str):
    FAIL

case pattern if guard:

[translation for pattern]
if not guard:
    FAIL

__match_container__ == 0 or __match_container__ == MATCH_SEQUENCE or __match_container__ == MATCH_MAPPING
__match_class__ == 0 or __match_class__ == MATCH_SELF

Werte der speziellen Attribute für Klassen in der Standardbibliothek

Für die Kern-Container-Klassen __match_container__ wird sein

• list: MATCH_SEQUENCE
• tuple: MATCH_SEQUENCE
• dict: MATCH_MAPPING
• bytearray: 0
• bytes: 0
• str: 0

Named Tuples erhalten __match_container__ auf MATCH_SEQUENCE gesetzt.

• Alle anderen Klassen der Standardbibliothek, für die issubclass(cls, collections.abc.Mapping) wahr ist, erhalten __match_container__ auf MATCH_MAPPING gesetzt.
• Alle anderen Klassen der Standardbibliothek, für die issubclass(cls, collections.abc.Sequence) wahr ist, erhalten __match_container__ auf MATCH_SEQUENCE gesetzt.

Für die folgenden eingebauten Klassen wird __match_class__ auf MATCH_SELF gesetzt

• bool
• bytearray
• bytes
• float
• frozenset
• int
• set
• str
• list
• tuple
• dict

Rechtliche Optimierungen

Die oben genannte Semantik impliziert viel redundante Arbeit und Kopien in der Implementierung. Es ist jedoch möglich, die obige Semantik effizient zu implementieren, indem man semantik wahrende Transformationen auf die naive Implementierung anwendet.

Bei der Durchführung von Abgleichen dürfen Implementierungen die folgenden Funktionen und Methoden als rein behandeln

Für jede Klasse, die MATCH_SEQUENCE unterstützt

* ``cls.__len__()``
* ``cls.__getitem__()``

Für jede Klasse, die MATCH_MAPPING unterstützt

* ``cls.get()`` (Two argument form only)

Implementierungen dürfen die folgenden Annahmen treffen

• isinstance(obj, cls) kann frei durch issubclass(type(obj), cls) und umgekehrt ersetzt werden.
• isinstance(obj, cls) wird immer dasselbe Ergebnis für jedes Paar (obj, cls) zurückgeben und wiederholte Aufrufe können somit weggelassen werden.
• Das Lesen von __match_container__, __match_class__ oder __match_args__ ist eine reine Operation und kann zwischengespeichert werden.
• Sequenzen, d. h. jede Klasse, für die __match_container__ == MATCH_SEQUENCE nicht Null ist, werden durch Iteration, Indizierung oder Aufrufe von len() nicht verändert. Folglich können diese Operationen frei substituiert werden, wo sie bei Anwendung auf eine unveränderliche Sequenz äquivalent wären.
• Mappings, d. h. jede Klasse, für die __match_container__ == MATCH_MAPPING nicht Null ist, werden das zweite Argument der get() Methode nicht erfassen. Daher kann der $sentinel Wert frei wiederverwendet werden.

Tatsächlich werden Implementierungen ermutigt, diese Annahmen zu treffen, da dies wahrscheinlich zu einer erheblich besseren Leistung führt.

Mögliche Optimierungen

Das Folgende ist nicht Teil der Spezifikation, sondern Leitlinien, um Entwicklern zu helfen, eine effiziente Implementierung zu erstellen.

case []:
    A
case [x]:
    B
case [x, y]:
    C
case other:
    D

  # Choose lane
  $i = iter($value)
  for $0 in $i:
      break
  else:
      A
      goto done
  for $1 in $i:
      break
  else:
      x = $0
      B
      goto done
  for $2 in $i:
      del $0, $1, $2
      break
  else:
      x = $0
      y = $1
      C
      goto done
  other = $value
  D
done:

match obj:
    case {a:x, b:y}:
        W
    case {a:x, c:y}:
        X
    case {a:x, b:_, c:y}:
        Y
    case other:
        Z

# Choose lane
if len($value) == 2:
    if "a" in $value:
        if "b" in $value:
            x = $value["a"]
            y = $value["b"]
            goto W
        if "c" in $value:
            x = $value["a"]
            y = $value["c"]
            goto X
elif len($value) == 3:
    if "a" in $value and "b" in $value:
        x = $value["a"]
        y = $value["c"]
        goto Y
other = $value
goto Z

Verwendung von Attributen aus dem Instanzwörterbuch

Eine frühere Version dieses PEP verwendete nur Attribute aus dem Instanzwörterbuch beim Abgleichen eines Klassenmusters, wenn __match_class__ der Standardwert war. Die Absicht war, gebundene Methoden und andere synthetische Attribute nicht zu erfassen. Dies bedeutete jedoch auch, dass Eigenschaften ignoriert wurden.

Für die Klasse

class C:
    def __init__(self):
        self.a = "a"
    @property
    def p(self):
        ...
    def m(self):
        ...

Idealerweise würden wir die Attribute "a" und "p" abgleichen, aber nicht "m". Es gibt jedoch keine allgemeine Möglichkeit, dies zu tun, daher folgt dieser PEP jetzt der Semantik von PEP 634.

Lookup von __match_args__ auf dem Subjekt, nicht auf dem Muster

Eine frühere Version dieses PEP suchte nach __match_args__ in der Klasse des Subjekts und nicht in der im Muster angegebenen Klasse. Dies wurde aus mehreren Gründen abgelehnt

* Using the class specified in the pattern is more amenable to optimization and can offer better performance.
* Using the class specified in the pattern has the potential to provide better error reporting is some cases.
* Neither approach is perfect, both have odd corner cases. Keeping the status quo minimizes disruption.

Kombination von __match_class__ und __match_container__ zu einem einzigen Wert

Eine frühere Version dieses PEP kombinierte __match_class__ und __match_container__ zu einem einzigen Wert, __match_kind__. Die Verwendung eines einzigen Wertes hat einen kleinen Vorteil hinsichtlich der Leistung, führt aber wahrscheinlich zu unbeabsichtigten Änderungen beim Abgleich von Containern, wenn das Verhalten von Klassenmustern überschrieben wird, und umgekehrt.

Einen separaten Wert haben, um alle Klassenübereinstimmungen abzulehnen

In einer früheren Version dieses PEP gab es einen separaten Wert für __match_class__, der es Klassen erlaubte, keine Klassenmuster abzugleichen, die eine Dekonstruktion erfordert hätten. Dies wäre jedoch redundant geworden, sobald MATCH_POSITIONAL eingeführt wurde, und verkompliziert die Spezifikation für einen extrem seltenen Fall.