-- 定義解析的目標(biāo)數(shù)據(jù)結(jié)構(gòu)
data Time = Time
  { year :: Int
  , month :: Int
  , day :: Int
  , hour :: Int
  , minute :: Int
  , second :: int
  }
-- 解析整數(shù)的解析器
anyInt :: Parser Int
anyInt = read <$> many1 (satisfy isDigit)
-- 目標(biāo)解析器，通過(guò)組合anyInt 和 char函數(shù)實(shí)現(xiàn)
timeParser :: Parser Time
timeParser = Time <$> anyInt << char '-'
                  <*> anyInt << char '-'
                  <*> anyInt << char ' '
                  <*> anyInt << char ':'
                  <*> anyInt << char ':'    
                  <*> anyInt

csvLineParser :: Parser [String]
csvLineParser = many (satisfy (/= ',')) `sepBy` (symbol ',')

// timeParser
Parser intParser = NumberParser.anyIntStr();
Parser timeParser = intParser.chain(() -> TextParsers.one('-').ignore()) //year 
                             .chain(() -> intParser).chain(() -> TextParsers.one('-').ignore()) //month
                             .chain(() -> intParser).chain(() -> TextParsers.one(' ').ignore()) //day
                             .chain(() -> intParser).chain(() -> TextParsers.one(':').ignore()) //hour
                             .chain(() -> intParser).chain(() -> TextParsers.one(':').ignore()) //minute
                             .chain(() -> intParser); //second
Result result = timeParser.runParser(new Buffer("2023-05-01 12:30:30".getBytes()));
assert result.<Integer>get(0) = 2023
assert result.<Integer>get(1) = 5
assert result.<Integer>get(2) = 1
assert result.<Integer>get(3) = 12
assert result.<Integer>get(4) = 30
assert result.<Integer>get(5) = 30
//csvLineParser
Parser csvLineParser = TextParser.satisfy(Character::isLetterOrDigit).some()
                    .map(Mapper.toStr())
                    .sepBy(TextParsers.one(',');

public abstract class Parser {
    //是否需要忽略解析結(jié)果
    protected boolean ignore = false;
    //判斷此解析器的結(jié)果是否需要忽略
    public boolean isIgnore() {
        return this.ignore;
    }
    //設(shè)置此解析器的結(jié)果需要忽略
    public Parser ignore() {
        this.ignore = true;
        return this;
    }
    //解析器的執(zhí)行函數(shù)，內(nèi)部執(zhí)行parser
    public Result runParser(IBuffer buffer) {
        Result result = parse(buffer);
        if (result.isError()) {
            return result;
        }
        if (isIgnore()) {
            result.clear();
            return result;
        }
        return result;
    }
    //抽象方法，具體的解析邏輯
    public abstract Result parse(IBuffer buffer);
    ...
}

public class Result {
    //結(jié)果列表
    private List result;
    //錯(cuò)誤信息
    String errorMsg;
    //解析消耗的輸入的長(zhǎng)度
    int length;
    //解析的位置，相對(duì)于整個(gè)輸入來(lái)說(shuō)
    int pos;
}

public interface IBuffer {
    //回溯
    void backward(int n);
    //前進(jìn)，消耗輸入
    void forward(int n);
    //讀取輸入，但不設(shè)置position
    byte[] headN(int n);
    ... //其他的輔助方法
}

public class ByteParsers {
    //解析一個(gè)滿足條件的字符
    public static Parser satisfy(Predicate<Byte> predicate) {
        return new Parser() {
            @Override
            public Result parse(IBuffer buffer) {
                Optional<Byte> b = buffer.head();
                if (b.isEmpty() || !predicate.test(b.get())) {
                    return Result.builder()
                            .pos(buffer.getPos())
                            .errorMsg(ErrorUtil.error(buffer))
                            .build();
                }
                buffer.forward(1);
                return Result.builder()
                        .result(List.of(b))
                        .length(1)
                        .build();
            }
        };
    }
    //解析指定的字節(jié)數(shù)組
    public static Parser bytes(byte[] data, String desc) {
        return new Parser() {
            @Override
            public Result parse(IBuffer buffer) {
                byte[] bs = buffer.headN(data.length);
                if (!Arrays.equals(data, bs)) {
                    return Result.builder()
                            .pos(buffer.getPos())
                            .errorMsg(ErrorUtil.error(buffer))
                            .build();
                }
                buffer.forward(bs.length);
                return Result.builder()
                        .length(data.length)
                        .result(List.of(data))
                        .build();
            }
        };
    }
    //解析一個(gè)指定字節(jié)
    public static Parser one(byte b) {
        return satisfy(a -> a == b);
    }
    //讀取n個(gè)字節(jié)
    public static Parser take(int n) {
        ...
    }
    //路過(guò)n個(gè)字節(jié)
    public static Parser skip(int n) {
        ...
    }
    ...
}

public class TextParsers {
    //解析一個(gè)滿足條件的，特別編碼的字符
    public static Parser satisfy(Predicate<Character> predicate, Charset charset) {
        return new Parser() {
            @Override
            public Result parse(IBuffer buffer) {
                byte[] bytes = buffer.headN(4);
                Optional<Character> ch = CharUtil.read(bytes, charset);
                if (ch.isPresent() && predicate.test(ch.get())) {
                    int len = String.valueOf(ch.get()).getBytes(charset).length;
                    buffer.forward(len);
                    return Result.builder()
                            .result(List.of(ch.get()))
                            .length(len)
                            .build();
                }
                return Result.builder()
                        .pos(buffer.getPos())
                        .errorMsg(ErrorUtil.error(buffer))
                        .build();
            }
        };
    }
    //使用默認(rèn)編碼UTF-8
    public static Parser satisfy(Predicate<Character> predicate) {
        return satisfy(predicate, StandardCharsets.UTF_8);
    }
    //解析一個(gè)特定編碼的特定字符
    public static Parser one(char ch, Charset charset) {
        ...
    }
    ... //其他的各種基礎(chǔ)解析器
}

public class NumberParsers {
    //解析一個(gè)字符串表示的指定整數(shù)
    public static Parser intStr(int a) {
    }
    //解析一個(gè)字符表示的任意整數(shù)
    public static Parser anyIntStr() {
    }
    //解析一個(gè)小端序編碼的整數(shù)
    public static Parser intLE(int a) {
    }
    //解析一個(gè)大端序編碼的整數(shù)
    public static Parser intBE(int a) {
    }
    ... //其他的解析器
}

public abstract class Parser{
    ...  
    //重復(fù)0到無(wú)限次
    public Parser many() {
        ....
    }
    //連接另一個(gè)Parser，先執(zhí)行當(dāng)前解析器，再執(zhí)行被連接的解析器
    //如果當(dāng)前解析器失敗則直接失敗，被連接的解析器不一定會(huì)用到
    //所以使用Supplier來(lái)模擬惰性求值
    public Parser chain(Supplier<Parser> parser) {
       ...
    }
    //如果當(dāng)前解析器失敗，則嘗試使用另一個(gè)解析器
    public Parser or(Supplier<Parser> parser) {
        ...
    }
    //使用一個(gè)函數(shù)將解析結(jié)果轉(zhuǎn)換成任意數(shù)據(jù)結(jié)構(gòu)
    public Parser map(Function<List, ?> mapper) {
        ...
    }
    //重復(fù)當(dāng)前解析器n次
    public Parser repeat(int n) {
        ...
    }
    //添加了停止條件的many
    //當(dāng)遇到參數(shù)中指定的Parser可以解析的內(nèi)容時(shí)就停止重復(fù)操作
    public Parser manyTill(Parser parser) {
        ...
    }
    //去掉前后的空格
    public Parser trim(boolean includeNewline) {
        ...
    }
    ... //其他的組合函數(shù)
}

J = E
E = O | A | S | N | B | Null
O = '{' [ (S ':' E) { ',' (S ':' E) } ] '}'
A = '[' [ E { ',' E } ] ']'
S = "string"
N = "number"
B = "true" | "false"
Null = "null"

public class JsonValue {
    /**
     * type of json value
     */
    JsonType type;
    /**
     * value
     */
    Object value;
}

...
   public static Parser jsonParser() {
       return stringParser()
               .or(() -> objectParser().trim(true))
               .or(() -> arrayParser().trim(true))
               .or(() -> nullParser().trim(true))
               .or(() -> boolParser().trim(true))
               .or(() -> numberParser().trim(true))
               .trim(true);
   }
   //stringParser
   ...
   //objectParser
   ...
   //nullParser
   ...
   //boolParser
   ...
   //numberParser
   ...

R = E ;
E = T { "|" T } ;
T = F { F } ;
F = A [ Q ] ;
A = C | "." | "(" E ")" | "[" [ "^" ] CC "]" ;
C = <non-meta character> | "\\" <any character> ;
Q = "*" | "+" | "?" | "{" N [ "," [ N ] ] "}" ;
CC = { CR } ;
CR = <non-hyphen character> | <non-hyphen character> "-" <non-hyphen character> ;
N = <non-zero sequence of digits> ;

public class RParser {
    private ParserType type;
    private int quoteId;
    private int groupId;
    private Parser parser;
    private Function<Parser, Parser> func;
    public RParser apply(Function<Parser, Parser> func) {
        if (this.parser != null) {
            this.parser = func.apply(this.parser);
        }
        this.func = func;
        return this;
    }
    public enum ParserType {
        PARSER,
        QUOTE,
        GROUP;
    }
}

public Parser parser() {
        return Parser.choose(
                () -> many(),  // *號(hào)重復(fù)
                () -> some(),  // +號(hào)重復(fù)
                () -> range(), //{m,n}重復(fù)
                () -> repeat(),//{n}重復(fù)
                () -> optional(), //?可有可無(wú)
                () -> validToken() //普通合法的token
        ).many().map(s -> {
            return RParser.builder().parser(chainParsers(s))
                    .type(RParser.ParserType.PARSER)
                    .build();
        });
    }

import Z.Data.Parser
    ( anyCharUTF8, char8, parse', satisfy, text, Parser )
import Text.Printf (printf)
import Control.Applicative.Combinators ( some, (<|>), many, sepBy )
import Data.Functor (($>))
import Z.Data.CBytes (unpack)
import Z.Data.ASCII (w2c)
import Z.Data.Vector.Base (packASCII, elem)
import Prelude hiding (elem)
import Control.Monad (replicateM_)
data JsonMember = JsonMember String JsonValue deriving (Show)
data JsonValue = JsonString String
               | JsonNull
               | JsonNumber Double
               | JsonObject [JsonMember]
               | JsonArray [JsonValue] deriving (Show)
jsonParser :: Parser JsonValue
jsonParser = JsonString <$> stringParser <|> nullParser <|> numberParser <|> objectParser <|> arrayParser
nullParser :: Parser JsonValue
nullParser = text "null" $> JsonNull
stringParser :: Parser String
stringParser = char8 '"' *> contentParser <* char8 '"'
  where charParser = do
          ch <- anyCharUTF8
          if ch == '\\' || ch == '"'
             then fail $ printf "unexpect char %c" ch
             else pure ch
        escapeParser = char8 '\\' *> char8' '"' <|> char8 '\\' *> char8' '\\'
        contentParser = some (charParser <|> escapeParser)
        char8' c = char8 c $> c
memberParser :: Parser JsonMember
memberParser = JsonMember <$> stringParser <* char8 ':'
                          <*> jsonParser 
arrayParser :: Parser JsonValue
arrayParser = JsonArray <$> (char8 '[' *> jsonParser `sepBy` char8 ',' <* char8 ']')
objectParser ::Parser JsonValue 
objectParser = JsonObject <$> (char8 '{' *> memberParser `sepBy` char8 ',' <* char8 '}')
numberParser :: Parser JsonValue 
numberParser = JsonNumber . read <$> some validChar
  where validChar = w2c <$> satisfy (`elem` packASCII ".-0123456789e")

<expr> ::= <term> | <term> "+" <expr> | <term> "-" <expr>
<term> ::= <factor> | <factor> "*" <term> | <factor> "/" <term>
<factor> ::= <number> | "(" <expr> ")"
<number> ::= <digit> | <digit> <number>
<digit> ::= "0" | "1" | "2" | ... | "9"

public class Calculator {
    @Test
    public void testCalc() {
        Result result = expr().parse(Buffer.builder().data("(1+2)*3-(4*2)".getBytes()).build());
        assert result.<Double>get(0).compareTo(1.0) == 0;
        result = expr().parse(Buffer.builder().data("1+2*3-(4*2)".getBytes()).build());
        assert result.<Double>get(0).compareTo(-1.0) == 0;
    }
    public Parser expr() {
        return Parser.choose(
                () -> term().chain(TextParsers.one('+').ignore())
                        .chain(() -> expr()).map(s -> (double)s.get(0) + (double)s.get(1)),
                () -> term().chain(TextParsers.one('-').ignore())
                        .chain(() -> expr()).map(s -> (double)s.get(0) - (double)s.get(1)),
                () -> term()
        );
    }
    public Parser term() {
        return Parser.choose(
                () -> factor().chain(TextParsers.one('*').trim(false).ignore())
                        .chain(() -> term()).map(s -> (double)s.get(0) * (double)s.get(1)),
                () -> factor().chain(TextParsers.one('/').trim(false).ignore())
                        .chain(() -> term()).map(s -> (double)s.get(0) / (double)s.get(1)),
                () -> factor()
        );
    }
    public Parser factor() {
        return Parser.choose(
                TextParsers.one('(').ignore()
                        .chain(() -> expr())
                        .chain(TextParsers.one(')').ignore()),
                number()
        );
    }
    public Parser number() {
        return NumberParsers.anyDoubleStr();
    }
}