### Seq Combinator for Sequential Matching
Source: https://context7.com/vektah/goparsify/llms.txt
Shows how the `Seq` combinator matches multiple parsers in order, storing their results in `Child`. Includes an example of mapping results to a custom type and handling sequence failures.
```go
package main
import (
"fmt"
. "github.com/vektah/goparsify"
)
func main() {
// Match key=value pairs
kvParser := Seq(Chars("a-zA-Z"), "=", Chars("a-zA-Z0-9")).Map(func(n *Result) {
n.Result = map[string]string{
n.Child[0].Token: n.Child[2].Token,
}
})
result, err := Run(kvParser, "color=blue")
if err != nil {
panic(err)
}
fmt.Println(result) // map[color:blue]
// If any parser in the sequence fails, the whole Seq fails and Pos is restored
_, err2 := Run(kvParser, "color")
fmt.Println(err2) // offset 5: expected =
}
```
--------------------------------
### Example Debug Output from HTML Parser Test
Source: https://github.com/vektah/goparsify/blob/master/readme.md
This output shows the detailed step-by-step execution of the HTML parser when run with debugging enabled. It logs the state of the parser, tokens found, and expected tokens.
```text
adam:goparsify(master)$ go test -tags debug ./html -v
=== RUN TestParse
hTml.go:48 | hello hello
hello
hello
hello
hello
hello
hello
hello
found >
hTml.go:43 | hello
]
hTml.go:24 | hello
hTml.go:48 |
| < found <
hTml.go:20 | color="blue">w | identifier found p
hTml.go:33 | color="blue">w | attrs {
hTml.go:32 | color="blue">w | attr {
hTml.go:20 | ="blue">worldworldworld
worldworldworldworldworld found >
hTml.go:43 | world ]
hTml.go:24 | world | text found world
hTml.go:23 | | } found "world"
hTml.go:23 | | element {
hTml.go:21 | | text did not find <>
hTml.go:48 | | tag {
hTml.go:43 | | tstart {
hTml.go:43 | /p> | < found <
hTml.go:20 | /p> | identifier did not find [a-zA-Z][a-zA-Z0-9]*
hTml.go:43 | | } did not find [a-zA-Z][a-zA-Z0-9]*
hTml.go:48 | | } did not find [a-zA-Z][a-zA-Z0-9]*
hTml.go:23 | | } did not find [a-zA-Z][a-zA-Z0-9]*
hTml.go:24 | | } found ["world"]
hTml.go:44 | | tend {
hTml.go:44 | p> | | identifier found p
hTml.go:44 | | > found >
hTml.go:44 | | } found []
hTml.go:48 | | } found "hello "
hTml.go:23 | | } found html.htmlTag{Name:"p", Attributes:map[string]string{"color":"blue"}, Body:[]interface {}{"world"}}
hTml.go:23 | | element {
hTml.go:48 | | tag {
hTml.go:43 | | tstart {
hTml.go:43 | /body> | < found <
hTml.go:20 | /body> | identifier did not find [a-zA-Z][a-zA-Z0-9]*
hTml.go:43 | | } did not find [a-zA-Z][a-zA-Z0-9]*
hTml.go:48 | | } did not find [a-zA-Z][a-zA-Z0-9]*
hTml.go:21 | | text did not find <>
hTml.go:23 | | } did not find [a-zA-Z][a-zA-Z0-9]*
hTml.go:24 | | } found ["hello ",html.htmlTag{Name:"p", Attributes:map[string]string{"color":"blue"}, Body:[]interface {}{"world"}}]
hTml.go:44 | | tend {
hTml.go:44 | body> | | identifier found body
hTml.go:44 | | > found >
hTml.go:44 | | } found []
hTml.go:48 | | } found [[<,body,,map[string]string{},>],,[]interface {}{"hello ", html.htmlTag{Name:"p", Attributes:map[string]string{"color":"blue"}, Body:[]interface {}{"world"}}},[]]
--- PASS: TestParse (0.00s)
PASS
ok github.com/vektah/goparsify/html 0.117s
```
--------------------------------
### Test Calculator Number Parsing
Source: https://github.com/vektah/goparsify/blob/master/readme.md
Tests the basic parsing of numbers in the calculator example. Ensures that single numeric literals are correctly parsed.
```go
func TestNumbers(t *testing.T) {
result, err := Calc(`1`)
require.NoError(t, err)
require.EqualValues(t, 1, result)
}
```
--------------------------------
### Basic Parser Usage with Exact
Source: https://context7.com/vektah/goparsify/llms.txt
Demonstrates creating a parser for a literal string and using it with `NewState` and `Result`. Shows how to access the matched token and remaining input.
```go
package main
import (
"fmt"
. "github.com/vektah/goparsify"
)
func main() {
// A Parser is just a func(*State, *Result).
// String literals are auto-converted to Exact parsers via Parsify.
hello := Exact("hello")
ps := NewState("hello world")
var r Result
hello(ps, &r)
fmt.Println(r.Token) // hello
fmt.Println(ps.Get()) // " world" (remaining input)
}
```
--------------------------------
### Running Parsers with Run
Source: https://context7.com/vektah/goparsify/llms.txt
Demonstrates the `Run` function for executing a parser over an entire string. Shows default unicode whitespace skipping, ASCII whitespace mode, and error handling for unconsumed input and parse failures.
```go
package main
import (
"fmt"
. "github.com/vektah/goparsify"
)
func main() {
word := Chars("a-zA-Z")
// Default: unicode whitespace skipping
result, err := Run(word, " hello ")
fmt.Println(result, err) // hello