Introduction to Lark-Parser

Lark-Parser is a powerful parsing library in Python that enables users to transform structured data into a readable format. It’s commonly used for interpreting domain-specific languages and configuration files.

Creating a Simple Parser

Here’s how you can create a basic parser with Lark:

from lark import Lark

parser = Lark('''
    start: word+
    word: /\\w+/
''')

parse_tree = parser.parse("Hello world")
print(parse_tree.pretty())

API Usage Examples

Loading Grammar from a File

with open('grammar.lark', 'r') as file:
    grammar = file.read()

parser = Lark(grammar)

Using Terminals and Non-terminals

from lark import Lark, Transformer

grammar = '''
    start: noun verb adj
    noun: "cat" | "dog"
    verb: "runs" | "jumps"
    adj: "fast" | "slow"
'''

parser = Lark(grammar)

class ProcessTree(Transformer):
    def noun(self, items):
        return str(items[0])

    def verb(self, items):
        return str(items[0]) + 's'

    def adj(self, items):
        return str(items[0])

tree = parser.parse("cat runs fast")
result = ProcessTree().transform(tree)
print(result)

Parsing JSON Data

from lark import Lark

json_grammar = '''
    ?value: dict
           | list
           | string
           | number
    dict: "{" [pair ("," pair)*] "}"
    pair: string ":" value
    list: "[" [value ("," value)*] "]"
    string: ESCAPED_STRING
    number: SIGNED_NUMBER
'''

parser = Lark(json_grammar, parser='lalr')
json_tree = parser.parse('{"key": 1, "list": [2, 3]}')
print(json_tree.pretty())

Example Application

Let’s build a simple calculator using Lark:

from lark import Lark, Transformer, v_args

calc_grammar = '''
    start: sum
    ?sum: product
        | sum "+" product
        | sum "-" product
    ?product: atom
        | product "*" atom
        | product "/" atom
    ?atom: NUMBER
         | "-" atom
         | "(" sum ")"
    %import common.NUMBER
    %ignore " "
'''

parser = Lark(calc_grammar)

@v_args(inline=True)
class CalculateTree(Transformer):
    def NUMBER(self, token):
        return float(token)

    def sum(self, a, b):
        return a + b

    def product(self, a, b):
        return a * b

    def __add__(self, other):
        raise TypeError("cannot concatenate 'float' and 'int' objects")

def evaluate(expression):
    tree = parser.parse(expression)
    result = CalculateTree().transform(tree)
    return result

print(evaluate("3 + 5 * (10 - 5)"))

With this code, you can create a simple arithmetic calculator that can parse and calculate mathematical expressions.

Hash: 0dca9558c926364dbbfb43e783a52d612a476b845a161686f0238807a66a475e