Mönster, klausuler och matchningar i kroppar

Huvuden i funktionsklausuler, matchningar i kroppar, case-klausuler och if-guards är körbara för varje tillåten termsort (termer). Giltighet och tillgänglighet kontrolleras separat: ogiltig Erlang är ett semantiskt fel även i onåbar kod; giltig kod som kräver en saknad funktion får en diagnostik om förmåga (capability); en avvikelse (mismatch) vid körning är aldrig ett kompilatorfel.

Comprehensions

[T1, ..., Tn || Q1, ..., Qm], << T || Q1, ... >> och #{K => V, ... || Q1, ... } följer OTP 29:

• Kvalificerare körs från vänster till höger; varje generator loopar över resten. Mallar utvärderas i den ordningen för varje kvarvarande kombination; flera mallar lägger till flera element per kombination. Mallen i en binary-comprehension måste vara en bitstring (annars error:badarg vid det elementet); delarna sammanfogas i ordning, inklusive ofullständiga byte. En map-comprehension utvärderar sitt (första) värde före sin nyckel, och en senare dubblerad nyckel vinner.
• Generatorer: P <- List, <<Segs>> <= Bits och K := V <- Map, med de strikta formerna <:- (listor, maps) och <:=. En bitstring-generator matchar sitt mönster mot ett prefix och fortsätter med resten. När en avslappnad generator avvisar ett element hoppar den över så många bitar som mönstrets storlekar beskriver (värden ignoreras, flyttal läses som heltal, som OTP gör); när även det misslyckas, eller färre bitar återstår, avslutas generatorn. En map-generator går igenom mapen i nyckelordning (OTP itererar också upp till 32 nycklar i nyckelordning, utom atomnycklar, som ordnas efter atomindex; större maps följer OTP:s hashordning, som Clause inte återskapar).
• Ett generatormönster binder nya namn: det skuggar yttre namn, och inget som en comprehension binder syns efter den. En avslappnad generator hoppar över element som dess mönster avvisar; en strikt ger error:{badmatch, E} med listelementet, den återstående bitstringen eller {Key, Value}.
• En zip-grupp (P1 <- L1 && P2 <- L2) tar ett element från varje indata per steg; dess mönster binder tillsammans, så ett upprepat namn måste matcha. Ett avvisat steg hoppas över om inte ett strikt mönster avvisar det. Indata som tar slut ojämnt, eller en strikt avvisning, ger error:{bad_generators, {L1', L2'}} med de indata som återstår vid det steget (en map-generator visar OTP:s iterator {K, V, Next}, som slutar i none). Filter inuti en zip-grupp är semantiska fel. När avslappnade och strikta generatorer i en grupp delar en variabel kan överhoppningsregeln skilja sig från OTP (skillnader).
• Indata som inte är en map ger error:{bad_generator, Input} innan en map-generator startar, även inuti en zip-grupp.
• Listindata som inte är en lista, eller en oäkta svans, och bitstring-indata som inte är en bitstring ger error:{bad_generator, Tail} när elementen före den är klara.
• Ett filter som är ett guard-test (OTP erl_lint:is_guard_test/3: guardsyntax som endast anropar oskuggade guard-BIF:ar, äldre typtester på toppnivå) avvisar elementet vid varje fel, som en guard. Alla andra filter måste returnera true eller false; andra värden ger error:{bad_filter, Value} och dess undantag sprids vidare.
• En matchningskvalificerare på toppnivå (P = E) är ett semantiskt fel om inte den experimentella funktionen compr_assign är aktiverad; att köra den är då inte implementerat (förmåga).

Varje generator är en loop i funktionskroppen vars indatamarkör (en rest av en lista eller bitstring, eller en map och en position) lever i termplatser i ramen; de producerade elementen ackumuleras omvänt i en annan termplats och blir listan, den sammanfogade bitstringen eller mapen en gång i slutet, så långa indata kräver konstant inbyggd stack och processtack.

Mönsterformer

Räckvidder

Map-nycklar och binary-storlekar läser den inkommande miljön, aldrig syskon: #{K := V} = #{key := K} och <<X:N>> = <<N:8>> kan inte binda sin egen nyckel eller storlek. Inuti en binary kan en storlek läsa tidigare segment: <<N:8, X:N>> är giltigt; {N, <<X:N>>} kräver att N är bundet i förväg. Konstant felaktig aritmetik i en nyckel eller storlek är giltig och misslyckas vid matchning.

Binary-validering avvisar segment med nästlade behållare/alias, motstridiga modifierare, felaktiga enhetsintervall, enhet utan storlek för standardvärden för heltal/flyttal, ogiltig UTF-storlek/enhet, typade/storleksangivna literala strängar och binary-segment utan storlek som inte står sist.

Körning

• En platt matchningsplan per huvud/vänsterled över de ursprungliga argumentplatserna; alias delar indata, första definitioner binder SSA-värden, upprepningar genererar tester för exakt likhet. Formkontroller dominerar extrahering; extrahering använder kontrollerade runtime-tjänster.
• Klausuler körs i källkodsordning, var och en med en ny miljö som laddar om de ursprungliga argumenten. Avvikelse i huvudet eller avvisning av guard går till nästa klausul; fel i kroppen och infrastrukturfel provar aldrig senare klausuler.
• En case utvärderar sitt granskade uttryck en gång och provar sedan varje klausul i ordning med det granskade uttrycket som planens enda indata: mönsteravvikelse eller avvisning av guard (inklusive guard-fel) går till nästa klausul, och när alla är uttömda ges {case_clause, Value}. Varje klausul börjar från bindningarna före case; case-värdet och varje exporterad bindning sammanförs i en PHI per värde.
• En if är en case utan granskat uttryck eller mönster: varje klausuls guard provas i ordning (ett guard-fel avvisar klausulen), när alla är uttömda ges if_clause, och värden och exporter sammanförs på samma sätt.
• begin/end kör sin sekvens i den omslutande räckvidden och ger sitt sista värde.
• Sekvenser i kroppar körs i ordning och returnerar det sista värdet. En matchning utvärderar sitt högerled en gång, binder nya namn, kontrollerar befintliga och returnerar högerledet (även för _ = RHS). Kedjor utvärderar det innersta högerledet först.
• Atomliteraler laddar modulbindningar; matchning internerar aldrig atomer.
• Ovillkorliga variabelhuvuden kompileras till kompakt projektions-IR.

Gränser

Mönsternormalisering delar modulens semantiska budget på 1 000 000 enheter (ett heltal kostar ungefär sitt antal decimala siffror); en konstant bortom heltalsgränsen på 4 194 240 bitar är ett illegal pattern, som i OTP (termer). Varje matchningsplan har ett tak på 100 000 arbetsenheter. Parsern begränsar separat nästling till 256 (hårt tak 512).