Help us shape the future of Go! Take the 2026 Go Developer Survey

Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
- API
  
  Reference documentation for the pkg.go.dev API
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

parser

package

Go to main page

Versions in this module

v2

v2.2.2

Oct 14, 2026

v2.2.1

Oct 13, 2026

retracted

Changes in this version

+ var BiscuitLexerRules = []lexer.SimpleRule

+ var DefaultParserOptions = []participle.Option

+ var ErrVariableInFact = errors.New("parser: a fact cannot contain any variables")

+ var ErrVariableInSet = errors.New("parser: a set cannot contain any variables")

+ func FromStringAuthorizer(input string) (biscuit.ParsedAuthorizer, error)

+ func FromStringAuthorizerWithParams(input string, parameters ParametersMap) (biscuit.ParsedAuthorizer, error)

+ func FromStringBlock(input string) (biscuit.ParsedBlock, error)

+ func FromStringBlockWithParams(input string, parameters ParametersMap) (biscuit.ParsedBlock, error)

+ func FromStringCheck(input string) (biscuit.Check, error)

+ func FromStringCheckWithParams(input string, parameters ParametersMap) (biscuit.Check, error)

+ func FromStringFact(input string) (biscuit.Fact, error)

+ func FromStringFactWithParams(input string, parameters ParametersMap) (biscuit.Fact, error)

+ func FromStringPolicy(input string) (biscuit.Policy, error)

+ func FromStringPolicyWithParams(input string, parameters ParametersMap) (biscuit.Policy, error)

+ func FromStringRule(input string) (biscuit.Rule, error)

+ func FromStringRuleWithParams(input string, parameters ParametersMap) (biscuit.Rule, error)

+ type Allow struct

+ Queries []*CheckQuery

+ type Authorizer struct

+ Body []*AuthorizerElement

+ Comments []*Comment

+ func (b *Authorizer) ToBiscuit(parameters ParametersMap) (*biscuit.ParsedAuthorizer, error)

+ type AuthorizerElement struct

+ BlockElement *BlockElement

+ Policy *Policy

+ type Block struct

+ Body []*BlockElement

+ Comments []*Comment

+ func (b *Block) ToBiscuit(parameters ParametersMap) (*biscuit.ParsedBlock, error)

+ type BlockElement struct

+ Check *Check

+ Predicate *Predicate

+ RuleBody []*RuleElement

+ type Bool bool

+ func (b *Bool) Capture(values []string) error

+ type Check struct

+ Queries []*CheckQuery

+ func (c *Check) ToBiscuit(parameters ParametersMap) (*biscuit.Check, error)

+ type CheckQuery struct

+ Body []*RuleElement

+ func (r *CheckQuery) ToBiscuit(parameters ParametersMap) (*biscuit.Rule, error)

+ type Comment string

+ func (c *Comment) Capture(values []string) error

+ type Deny struct

+ Queries []*CheckQuery

+ type Expr1 struct

+ Left *Expr2

+ Right []*OpExpr2

+ func (e *Expr1) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type Expr2 struct

+ Left *Expr3

+ Right *OpExpr3

+ func (e *Expr2) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type Expr3 struct

+ Left *Expr4

+ Right []*OpExpr4

+ func (e *Expr3) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type Expr4 struct

+ Left *Expr5

+ Right []*OpExpr5

+ func (e *Expr4) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type Expr5 struct

+ Expr6 *Expr6

+ Operator *Operator

+ func (e *Expr5) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type Expr6 struct

+ Left *ExprTerm

+ Right []*OpExpr7

+ func (e *Expr6) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type ExprTerm struct

+ Expression *Expression

+ Term *Term

+ func (e *ExprTerm) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type Expression struct

+ Left *Expr1

+ Right []*OpExpr1

+ func (e *Expression) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type HexString string

+ func (h *HexString) Decode() ([]byte, error)

+ func (h *HexString) Parse(lex *lexer.PeekingLexer) error

+ func (h *HexString) String() string

+ type MustParser interface

+ Authorizer func(authorizer string, parameters ParametersMap) biscuit.ParsedAuthorizer

+ Block func(block string, parameters ParametersMap) biscuit.ParsedBlock

+ Check func(check string, parameters ParametersMap) biscuit.Check

+ Fact func(fact string, parameters ParametersMap) biscuit.Fact

+ Policy func(policy string, parameters ParametersMap) biscuit.Policy

+ Rule func(rule string, parameters ParametersMap) biscuit.Rule

+ type OpExpr1 struct

+ Expr1 *Expr1

+ Operator Operator

+ func (e *OpExpr1) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type OpExpr2 struct

+ Expr2 *Expr2

+ Operator Operator

+ func (e *OpExpr2) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type OpExpr3 struct

+ Expr3 *Expr3

+ Operator Operator

+ func (e *OpExpr3) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type OpExpr4 struct

+ Expr4 *Expr4

+ Operator Operator

+ func (e *OpExpr4) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type OpExpr5 struct

+ Expr5 *Expr5

+ Operator Operator

+ func (e *OpExpr5) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type OpExpr7 struct

+ Expression *Expression

+ Operator Operator

+ func (e *OpExpr7) ToExpr(expr *biscuit.Expression, parameters ParametersMap)

+ type Operator int

+ const OpAdd

+ const OpAnd

+ const OpContains

+ const OpDiv

+ const OpEqual

+ const OpGreaterOrEqual

+ const OpGreaterThan

+ const OpIntersection

+ const OpLength

+ const OpLessOrEqual

+ const OpLessThan

+ const OpMatches

+ const OpMul

+ const OpNegate

+ const OpOr

+ const OpPrefix

+ const OpSub

+ const OpSuffix

+ const OpUnion

+ func (o *Operator) Capture(s []string) error

+ func (op *Operator) ToExpr(expr *biscuit.Expression)

+ type Parameter string

+ func (p *Parameter) Capture(values []string) error

+ type ParametersMap map[string]biscuit.Term

+ type Parser interface

+ Authorizer func(authorizer string, parameters ParametersMap) (biscuit.ParsedAuthorizer, error)

+ Block func(block string, parameters ParametersMap) (biscuit.ParsedBlock, error)

+ Check func(check string, parameters ParametersMap) (biscuit.Check, error)

+ Fact func(fact string, parameters ParametersMap) (biscuit.Fact, error)

+ Must func() MustParser

+ Policy func(policy string, parameters ParametersMap) (biscuit.Policy, error)

+ Rule func(rule string, parameters ParametersMap) (biscuit.Rule, error)

+ func New() Parser

+ type Policy struct

+ Allow *Allow

+ Deny *Deny

+ func (p *Policy) ToBiscuit(parameters ParametersMap) (*biscuit.Policy, error)

+ type Predicate struct

+ IDs []*Term

+ Name *string

+ func (p *Predicate) ToBiscuit(parameters ParametersMap) (*biscuit.Predicate, error)

+ type Rule struct

+ Body []*RuleElement

+ Comments []*Comment

+ Head *Predicate

+ func (r *Rule) ToBiscuit(parameters ParametersMap) (*biscuit.Rule, error)

+ type RuleElement struct

+ Expression *Expression

+ Predicate *Predicate

+ type Set struct

+ Bytes []HexString

+ Int []int64

+ Not bool

+ String []string

+ type Term struct

+ Bool *Bool

+ Bytes *HexString

+ Date *string

+ Integer *int64

+ Parameter *Parameter

+ Set []*Term

+ String *string

+ Variable *Variable

+ func (a *Term) ToBiscuit(parameters ParametersMap) (biscuit.Term, error)

+ type Value struct

+ Number *float64

+ Parameter *Parameter

+ Subexpression *Expression

+ Variable *string

+ type Variable string

+ func (v *Variable) Capture(values []string) error