Vytvoření kombinátoru analyzátoru:třída analyzátoru.

Tato série představuje implementaci kombinátoru analyzátoru, krok za krokem od začátku vysvětluje, jak to funguje.

za prvé, co je to kombinátor analyzátoru?

třída analyzátoru

Objekt této třídy představuje nejjednodušší stavební blok kombinátoru analyzátoru.

class Parser {
  constructor(fn) {
    this.process = fn;
  }
}

constructor funkce přebírá funkci fn = fn(state) -> state , kde state je aktuální stav analyzátoru a vrací nový stav.

řetězení analyzátorů

Základní funkcí je „řetězení“ analyzátorů, aby mohly pracovat v sekvenci a předat state navzájem.

class Parser {
  // ...
  chain(parser) {
    return new Parser(state => {
      return parser.process(this.process(state));
    });
  }
}

chain metoda vezme analyzátor jako argument a vrátí nový analyzátor.

#next funkce

Aby bylo možné provádět další operace s výsledkem analyzátoru, #next byla přidána metoda, která převezme výsledný stav a operuje s ním.

class Parser {
  // ...
  #next(fn, onErr) {
    return this.chain(
      new Parser(state => {
        return state.err ^ onErr ? state : fn(state);
      })
    );
  }
}

Jednoduše "zřetězí" nový analyzátor k aktuálnímu, který - v závislosti na onErr hodnota - vrátí state který mu byl předán tak, jak je, nebo stav vrácený z fn .

Pro zjednodušení práce s #next , byly přidány dvě metody.

pracující na state

next metoda funguje, pokud nebyly žádné chyby.

class Parser {
  // ...
  next(fn) {
    return this.#next(fn, false);
  }
}

zachycení chyb

error metoda funguje, pokud došlo k chybě.

class Parser {
  // ...
  error(fn) {
    return this.#next(fn, true);
  }
}

spuštění analyzátoru

class Parser {
  // ...
  run(input) {
    return this.process({ input, err: false });
  }
}

Kde input je vstupní řetězec, který se má analyzovat.

No, to teď nevypadá moc užitečně, ale v příštím příspěvku budou základní analyzátory implementovány pomocí třídy analyzátorů a nakonec je lze "zkombinovat" dohromady a vytvořit tak větší analyzátory.

Kód najdete na githubu na dev větev

pari

Jednoduchý analyzátorový kombinátor.

použití

import { char, zeroOrMore } from 'pari';

// char takes a Regex that matches one character.
const charResult = char('[a-z]').run('s');

// parsers may take other parsers as arguments
const zomResult = zeroOrMore(char('[a-z]')).run('string');

dostupné analyzátory

import {
  char,
  zeroOrMore,
  sequence,
  oneOrMore,
  spaceArround,
  separatedBy,
  between,
  zeroOrOne,
  spaceBefore,
  spaceAfter,
  lazy
} from 'pari';

definujte svůj analyzátor

import { Parser } from 'pari';
const myParser = new Parser(state => {
  // do something with state
  return newState;
});

// parser has three methods

someParser.chain(anotherParser); // chain another parser.

someParser.map(state => {
  // do extra operations on the result.
… Zobrazit na GitHubu



Děkuji za přečtení 😄.