Here's a short example of combinator parsing using a hypothetical parser combinator library in Python-like pseudocode:

Let's say we want to parse simple arithmetic expressions like "2 + 3 * 4" and build a parse tree from them.

First, we define basic parsers for integers, addition, and multiplication:

```python
# Parser for integers
def integer_parser(input_string):
    num = ""
    while input_string and input_string[0].isdigit():
        num += input_string[0]
        input_string = input_string[1:]
    return (int(num), input_string)

# Parser for addition
def addition_parser(input_string):
    if input_string and input_string[0] == '+':
        return ('+', input_string[1:])
    else:
        return None

# Parser for multiplication
def multiplication_parser(input_string):
    if input_string and input_string[0] == '*':
        return ('*', input_string[1:])
    else:
        return None
```

Next, we create higher-order functions that combine the basic parsers to build more complex parsers:

```python
# Combinator for parsing arithmetic expressions
def expression_parser(input_string):
    # Try parsing an integer first
    result = integer_parser(input_string)
    if result:
        return result

    # If not an integer, try parsing addition or multiplication
    add_result = addition_parser(input_string)
    if add_result:
        # Recursively parse expressions on both sides of the addition operator
        left, rest = expression_parser(add_result[1])
        right, rest = expression_parser(rest)
        return (add_result[0], left, right), rest

    mul_result = multiplication_parser(input_string)
    if mul_result:
        # Recursively parse expressions on both sides of the multiplication operator
        left, rest = expression_parser(mul_result[1])
        right, rest = expression_parser(rest)
        return (mul_result[0], left, right), rest

    return None

# Function to simplify parsing expressions
def parse_expression(input_string):
    result, rest = expression_parser(input_string)
    if rest:
        raise ValueError("Parsing error")
    return result
```

Finally, we can use the `parse_expression` function to parse and build a parse tree for an arithmetic expression:

```python
expression = "2 + 3 * 4"
parse_tree = parse_expression(expression)
print(parse_tree)  # Output: ('+', 2, ('*', 3, 4))
```

In this example, we use parser combinators to build a recursive descent parser for arithmetic expressions. The `expression_parser` function tries to parse an integer first and, if unsuccessful, tries to parse addition or multiplication, recursively parsing sub-expressions on both sides of the operators. The result is a parse tree representing the structure of the arithmetic expression.
spam fails_task lang_mismatch pii not_appropriate hate_speech sexual_content quality toxicity humor helpfulness creativity violence