how-to-use-vital-text-parser.vim

"
" how to use Vital.Text.Parser
"
let s:V= vital#of('vital')
let s:L= s:V.import('Text.Lexer')
let s:P= s:V.import('Text.Parser')
unlet s:V

try
    " instantiate an lexer object with token definitions (list of list)
    " each elements of this list are [{label}, {regex}]
    let s:lexer= s:L.lexer([
    \   ['type/str',   '\<Str\>'    ],
    \   ['type/num',   '\<Num\>'    ],
    \   ['type/float', '\<Float\>'  ],
    \   ['type/list',  '\<List\>'   ],
    \   ['type/dict',  '\<Dict\>'   ],
    \   ['type/func',  '\<Funcref\>'],
    \   ['or',         '|'   ],
    \   ['whitespace', '\s\+'],
    \   ['undefined',  '.*'  ],
    \])

    " instantiate a parser object with lexed tokens
    let s:parser= s:P.parser().exec(s:lexer.exec('Str | List'))

    " configuration for ignoring token labeled whitespace
    call s:parser.config({'ignore_labels': ['whitespace']})

    " this variable will be built by tokens for eval()
    let s:checker= ''
    " until end of token
    while !s:parser.end()
        " consume for ignoring tokens have whitespace label
        call s:parser.ignore()

        " check next label and so on
        if s:parser.next_is('type/str')
            let s:checker.= 'type(v:val) == type("")'
        elseif s:parser.next_is('type/num')
            let s:checker.= 'type(v:val) == type(0)'
        elseif s:parser.next_is('type/float')
            let s:checker.= 'type(v:val) == type(0.0)'
        elseif s:parser.next_is('type/list')
            let s:checker.= 'type(v:val) == type([])'
        elseif s:parser.next_is('type/dict')
            let s:checker.= 'type(v:val) == type({})'
        elseif s:parser.next_is('type/func')
            let s:checker.= 'type(v:val) == type(function("tr"))'
        elseif s:parser.next_is('or')
            let s:checker.= '||'
        else
            throw 'illegal expression: ' . s:parser.consume().matched_text
        endif

        " consume a token
        call s:parser.consume()
    endwhile

    echo 'generated: ' . s:checker

    let s:expr= substitute(s:checker, '\<v:val\>', '"hoge"', 'g')
    echo 'test - pass Str'
    echo '    expr: ' . s:expr
    echo '    eval: ' . eval(s:expr)

    let s:expr= substitute(s:checker, '\<v:val\>', '3', 'g')
    echo 'test - pass Num'
    echo '    expr: ' . s:expr
    echo '    eval: ' . eval(s:expr)

    let s:expr= substitute(s:checker, '\<v:val\>', '9.9', 'g')
    echo 'test - pass Float'
    echo '    expr: ' . s:expr
    echo '    eval: ' . eval(s:expr)

    let s:expr= substitute(s:checker, '\<v:val\>', '[]', 'g')
    echo 'test - pass List'
    echo '    expr: ' . s:expr
    echo '    eval: ' . eval(s:expr)

    let s:expr= substitute(s:checker, '\<v:val\>', '{}', 'g')
    echo 'test - pass Dict'
    echo '    expr: ' . s:expr
    echo '    eval: ' . eval(s:expr)

    let s:expr= substitute(s:checker, '\<v:val\>', 'function("substitute")', 'g')
    echo 'test - pass Funcref'
    echo '    expr: ' . s:expr
    echo '    eval: ' . eval(s:expr)
catch /.*/
    echo v:exception
endtry