Riferimento per la scrittura in ExpandaEVE

ExpandaEVE è la forma leggibile del linguaggio EVE. È ciò che scrivi in un file di filtro .eve. Ogni costrutto qui viene tradotto in CompactaEVE e poi compilato. Questa pagina documenta ciascun costrutto con esempi reali tratti dai file di filtro distribuiti.

Per le direttive a livello di documento (DEFINE, LET, REALM, le istruzioni di regola) vedi Il linguaggio EVE. Questa pagina riguarda il corpo di una regola fuzzy: il pattern stesso.

La forma di un corpo di regola

Un corpo di regola fuzzy ha sempre una radice e può aggiungere un numero qualsiasi di costrutti attorno a essa. La radice è la parola stem su cui la regola è costruita. Tutto il resto la raffina: suffissi, gestione dei plurali, esclusioni, contesto e così via.

HEAR rule
AS
  fuck(WHOLE)
  suffix(NONE OR er OR ers OR ing OR ed OR s)
  FLAG(pf YES)

Qui fuck(WHOLE) è la radice, suffix(...) aggiunge terminazioni consentite, e FLAG(pf YES) etichetta la categoria. I costrutti possono apparire in qualsiasi ordine che si legga in modo naturale; il traduttore riconosce ciascuno tramite la parola chiave.

La radice e i suoi marcatori di confine

La radice è l'ancoraggio di una regola. Esattamente un marcatore di radice imposta quanto strettamente la corrispondenza è delimitata alla radice:

Usa (WHOLE) quando la parola nuda è essa stessa l'offesa:

  spic(WHOLE)
  PLURAL

Usa (ROOT) quando attaccherai terminazioni o gruppi finali:

  ni(ROOT)
  suffix(g OR ga OR gga OR gger OR gl LETTER t)
  PLURAL

Il matching fuzzy è automatico

Una radice fuzzy non è un test di stringa letterale. Il matcher tollera già l'evasione comune: le vocali sono intercambiabili tramite l'insieme di vocali, le lettere possono essere allungate, e i gap (vedi GAP) lasciano passare i caratteri inseriti dove lo consenti. Non lo abiliti; è così che le regole fuzzy corrispondono. Per catturare una gamma più ampia di errori di ortografia deliberati, aggiungi alias e skeleton.

suffix: terminazioni consentite

suffix(...) elenca le terminazioni che la parola può assumere dopo la radice. Le opzioni sono separate da OR. È necessario solo un gruppo di suffissi, ma puoi impilarne diversi; ciascuno aggiunge un segmento opzionale in ordine.

  bitch(WHOLE)
  suffix(NONE OR es OR ed OR ing OR y OR ier OR iest OR fest OR fests)

NONE significa che la terminazione è opzionale: la parola può terminare proprio alla radice. Senza un'opzione NONE il suffisso è richiesto.

I gruppi di suffissi si compongono da sinistra a destra, quindi diversi di fila costruiscono una catena di segmenti opzionali:

  fa(ROOT)
  suffix(g OR gg OR NONE)
  suffix(ggot OR NONE)
  suffix(ggie OR NONE)

Un'opzione di suffisso può contenere essa stessa GAP o LETTER (vedi GAP e LETTER):

  suffix(g OR ga OR gga OR gger OR gl LETTER t)

  suffix(my GAP OR NONE)

PLURAL

PLURAL aggiunge un ricco insieme di terminazioni plurali e di flessione in una sola parola. Si espande nella classe integrata s di terminazioni, quindi una regola etichettata PLURAL cattura anche -s, -z, -es, -ing, -ed, -er, -y e gli altri membri dichiarati nella funzione s.

  dyke(WHOLE)
  PLURAL

PLURAL legge la classe chiamata s. Il filtro inglese distribuito la dichiara come:

LET function(s) BE s OR z OR es OR ez OR ies OR iez OR y>ies OR y>iez OR ing OR ings OR ed OR er OR ers OR y OR ys

Un'opzione scritta from>to è una terminazione di riscrittura: corrisponde a una parola che termina con to testando la radice con la terminazione from al suo posto. y>ies cattura una parola che termina con ies come se terminasse con y, che è il modo in cui baby e babies sono entrambi raggiunti da una radice. Vedi Suffissi di riscrittura per i meccanismi.

NEVER: esclusioni

NEVER(...) elenca le frasi che non devono apparire nella riga circostante. Se una qualsiasi frase elencata è presente, la regola non si attiva, anche se il pattern corrisponde altrimenti. Questo è il modo in cui una radice aggressiva viene tenuta lontana dal catturare parole innocenti.

  wop(WHOLE)
  PLURAL
  NEVER(doowop OR doo wop OR doowap OR doo wap OR dowap OR do wap OR do wop)

  gook(WHOLE)
  PLURAL
  NEVER(600k OR 900k OR 60ok OR 90ok OR 6ook OR 9ook OR 600ks OR 900ks)

Un controllo NEVER è un semplice test di sottostringa contro l'intera riga, in minuscolo. Se la frase è ovunque nel messaggio, la regola viene posta in veto.

ALIAS: grafie alternative

ALIAS(...) aggiunge una grafia alternativa della radice. Ogni alias è una variante di radice separata che riutilizza il resto della regola (i suoi suffissi, gruppi, esclusioni). Elenca un alias per riga per coprire errori di ortografia deliberati e scambi di lettere.

  ALIAS(phuck)
  ALIAS(fuk)
  ALIAS(fukk)
  ALIAS(fucc)
  ALIAS(fck)
  ALIAS(fk)
  fuck(WHOLE)
  suffix(NONE OR er OR ers OR ing OR ed OR s)

Ogni alias qui corrisponde con lo stesso insieme di suffissi di fuck. Un alias può portare il proprio marcatore (WHOLE) o (ROOT); senza uno eredita il confine della radice.

Un alias può fare riferimento a una funzione, nel qual caso ogni membro di quella funzione diventa un alias:

  ALIAS(function(selfharmverb))
  kill(ROOT)

Un alias può anche essere una parola segmentata o un frammento a più parti; viene normalizzato allo stesso modo della radice.

ALSO: frammenti additivi

ALSO(...) aggiunge un frammento che può apparire ovunque dopo la radice anziché in ordine fisso. Viene usato quando una parola extra richiesta può fluttuare rispetto allo stem.

  kill(ROOT)
  GAP
  suffix(yo OR ur OR your OR yor)
  suffix(self)
  ALSO(wrists OR wrist OR throat)

ALSO si riduce a un gruppo fluttuante che si attacca in qualsiasi posizione raggiungibile dopo la radice e i gruppi normali. Vedi Gruppi plus per come viene corrisposto un gruppo fluttuante.

GAP e LETTER

Queste abbreviazioni controllano cosa può stare tra le parti di un pattern.

GAP tra una radice e un suffisso permette a una frase di distribuirsi su più parole:

  moon(ROOT)
  GAP
  suffix(cricket)
  PLURAL

Questo cattura moon cricket, mooncricket e grafie con riempitivo tra le due parti. LETTER corrisponde a un singolo carattere, utile all'interno di un'opzione di suffisso per consentire una posizione jolly:

  suffix(m LETTER GAP OR NONE)

LETTERS corrisponde a una serie di sole lettere, quindi si ferma a uno spazio:

  my(ROOT)
  GAP
  LETTERS
  GAP
  suffix(hit)

OR e NONE

OR separa le alternative all'interno di un costrutto come suffix(...), NEVER(...), ALSO(...), BEFORE(...) e AFTER(...), e separa i membri delle classi in una dichiarazione LET. Deve stare come parola intera.

NONE è un'alternativa vuota. In un suffisso rende la terminazione opzionale; in un elenco di membri di funzione lascia che la classe contribuisca con una corrispondenza vuota:

LET function(quantifier) BE NONE OR some OR any OR a OR an OR the

BEFORE e AFTER: gating di contesto

Questi condizionano una regola su testo altrove nella riga. Vengono usati per far attivare un termine altrimenti ampio o ambiguo solo in un contesto rivelatore.

  BEFORE(function(seeking))
  cp
  AFTER(mega OR pack OR packs OR nz OR db OR dropbox OR folder OR vids OR pics)
  (WHOLE)

Una frase BEFORE è un semplice controllo di sottostringa contro l'intera riga, in minuscolo. Quando una regola ha un gate BEFORE rimane inattiva a meno che una delle frasi sia presente, o a meno che la parola soddisfi la post condizione AFTER da sola. AFTER accetta un plurale finale s sulle sue terminazioni. Vedi Gating per la regola esatta.

SWAP: insieme di sostituzione inline

SWAP(...) corrisponde a un qualsiasi frammento di diversi piccoli frammenti in una posizione, con controllo sui confini di parola. Viene usato dove un breve pezzo intercambiabile sta all'interno di una frase.

  kill(ROOT)
  GAP
  SWAP(my* OR me*)
  suffix(self)

Ogni opzione può portare asterischi che liberano un confine:

• Un * iniziale libera l'inizio (l'opzione non deve iniziare a un confine di parola).
• Un * finale libera la fine.
• Nessun asterisco, o un doppio ** iniziale, ancora entrambi i lati a un confine di parola.

Quindi my* corrisponde a my con un confine richiesto prima ma non necessariamente dopo, permettendogli di scorrere in self. Vedi Swap per le regole di confine per intero.

SKELETON: grafie esatte

SKELETON(...) elenca le forme di parola esatte che la regola corrisponde anche direttamente, aggirando il matcher fuzzy. Viene usato per fissare grafie offuscate specifiche usando liste di scelta inline.

  ni(ROOT)
  suffix(g OR ga OR gga OR gger OR gl LETTER t)
  PLURAL
  NEVER(snigger OR sniggers OR sniggered)
  SKELETON(n[a,e,i,o,u]gg[a,e,i,o,u]r OR n[a,e,i,o,u]gg[a,e,i,o,u]h)

Uno skeleton viene espanso nell'insieme completo di parole concrete che può comporre, e qualsiasi candidato uguale a una di quelle parole corrisponde immediatamente. L'espansione prende il prodotto incrociato di ogni scelta, quindi n[a,e,i,o,u]gg[a,e,i,o,u]r produce naggar, neggar, niggar e così via per ogni coppia di vocali.

Liste di scelta inline

All'interno di uno skeleton, [a,e,i,o,u] è una lista di scelta inline: una posizione di carattere che può essere uno qualsiasi dei membri separati da virgola. I membri possono essere più lunghi di un carattere. Gli spazi bianchi attorno a un membro vengono rimossi. Uno skeleton può anche fare riferimento a una funzione con &name, che si espande nei membri di quella funzione.

  SKELETON(r[e,i]t[a,e,i]rd)

  SKELETON(m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t OR m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t[a,e,i,o,u])

Il risultato è in minuscolo. Gli skeleton corrispondono alla grafia esatta, quindi sono complementari alla radice fuzzy, che gestisce le varianti più libere.

FUNCTION: classi con nome

Una funzione è una classe con nome dichiarata con LET (vedi Il linguaggio EVE). Viene referenziata con function(name), e il riferimento si espande nei membri della classe. Le funzioni hanno diversi ruoli a seconda di dove appaiono.

Come un intero gruppo di alternative in un corpo di regola:

  groom(ROOT)
  suffix(NONE OR ing OR ed)
  GAP
  MAYBE function(declarative)
  GAP
  function(vulnerable)

Come un alias, dove ogni membro diventa una radice alternativa:

  ALIAS(function(genderword))
  internal
  GAP
  condom(WHOLE)

All'interno di un elenco suffix, NEVER, ALSO, BEFORE o AFTER, dove i membri si uniscono alle alternative:

  suffix(function(article) OR box of OR a box of OR internal OR function(genderword) OR NONE)

Modificatori di funzione

Un riferimento function(...) può portare modificatori, uniti con +:

  function(subject + ADDITIVE + GAP)
  function(desire + ADDITIVE + GAP)
  function(quantifier + ADDITIVE + GAP)
  rap(ROOT)
  suffix(e OR ist OR ed OR ing OR eable OR able)
  PLURAL

Ogni funzione additiva qui fluttua nella corrispondenza ovunque si adatti, quindi il soggetto, il desiderio e il quantificatore possono apparire in ordine variabile prima della radice.

MAYBE FUNCTION: funzione opzionale

MAYBE FUNCTION(name) rende opzionale un riferimento a una funzione: la corrispondenza ha successo che uno dei suoi membri sia presente o meno.

  rap(ROOT)
  suffix(NONE OR e OR es OR ed OR ing OR eing OR in OR ist OR ists)
  GAP
  MAYBE function(declarative)
  GAP
  function(vulnerable)

Qui function(declarative) (parole come a, the, my) può apparire o meno tra il verbo e la parola che indica la persona vulnerabile.

FLAG: regole condizionali ed etichettatura delle categorie

FLAG(name YES) etichetta la regola con un flag dichiarato. Quando la regola si attiva, quel flag viene impostato, che è il modo in cui il filtro riporta una categoria come autolesionismo o abuso anziché un blocco ordinario.

  kms(WHOLE)
  FLAG(sh YES)

Il valore può essere scritto YES, Y o TRUE per attivo, e qualsiasi altra cosa per disattivo. Il nome del flag deve essere dichiarato con DEFINE (vedi Il linguaggio EVE), altrimenti il documento non riesce a caricarsi. Sotto il cofano un flag avvolge il pattern in un gate condizionale; vedi Wrapper di flag.

NOTE: commenti

NOTE(...) allega un commento inline. Viene rimosso prima della compilazione e non influisce sul matching, quindi è un modo per annotare un pattern sul posto. I commenti su tutta la riga usano comunque un # iniziale.

ALIAS con marcatori WHOLE o ROOT

Un alias può terminare con (WHOLE) o (ROOT) per impostare il proprio confine, indipendentemente da quello della radice:

  ALIAS(dike)
  dyke(WHOLE)

Senza un marcatore finale l'alias eredita il marcatore di confine della radice.

Radici segmentate

Una radice può essere scritta come diversi pezzi tra parentesi e senza per marcare parte di essa come flessibile. Quando sono presenti almeno due pezzi e almeno uno è tra parentesi, si fondono in un'unica radice con punti di ingresso alternativi.

  re[tard] (WHOLE)
  suffix(NONE OR d OR ded OR ted OR t OR der OR ders OR ing OR ed OR s)

Il pezzo tra parentesi marca il segmento flessibile. Vedi Radici segmentate per sapere esattamente quali alternative vengono generate.

Mettere tutto insieme

Una regola realistica combina diversi costrutti:

HEAR rule
AS
  ALIAS(masterb)
  masturb(ROOT)
  suffix(ate OR ating OR ation OR ated OR ates OR at)
  SKELETON(m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t OR m[a,e,i,o,u]st[a,e,i,o,u]rb[a,e,i,o,u]t[a,e,i,o,u])

Questa regola ha un alias per un errore di ortografia comune, una radice con un insieme di suffissi fisso, e skeleton per le grafie in leetspeak che il matcher fuzzy potrebbe mancare. Leggi CompactaEVE per vedere come ciascuno di questi si riduce e corrisponde.