goP2

package module
v0.0.0-...-cc6ff7a Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 11, 2021 License: Apache-2.0 Imports: 4 Imported by: 4

README

Go Parsec2

Go Parsec2 改写了 goParsec 。在性能上作出一定让步后，对结构和形式做出了改良。

Go Parsec2中，bind 不再是一个 Parsec 算子，而是所有 Parsec 算子的 Monad 特征。所有的 Parsec 算子都组合为带 Bind/Then/Over 的结构。 Go Parsec 2 提供了一些方法简化这些封装操作。

提供了 Do 形式。

使用 Go Parsec2 编写的解析器

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AsFloat32 

func AsFloat32(state State) (interface{}, error)

AsFloat32 判断当前元素是否为 float32

func AsFloat64 

func AsFloat64(state State) (interface{}, error)

AsFloat64 判断当前元素是否为 float64

func AsInt 

func AsInt(state State) (interface{}, error)

AsInt 判断当前元素是否为一个 int

func AsRune 

func AsRune(state State) (interface{}, error)

AsRune 判断当前元素是否为一个 rune

func AsString 

func AsString(state State) (interface{}, error)

AsString 判断当前元素是否为 string

func Crlf 

func Crlf(state State) (interface{}, error)

Crlf 构造一个 \n\r 校验算子

func Digit 

func Digit(state State) (interface{}, error)

Digit 构造一个数字字符校验算子

func EOF 

func EOF(state State) (interface{}, error)

EOF 仅仅到达结尾时匹配成功

func EndOfLine 

func EndOfLine(state State) (interface{}, error)

EndOfLine 匹配 \n\r 或 \n 。

func Env 

func Env(fn func() interface{}) (re interface{}, err error)

Env 函数与 P 算子的 Exec 方法对应，将其抛出的 error 还原为无 panic 的流程，用于模拟 Haskell Monad Do 。需要注意的是，捕获的非 error 类型的panic会重新抛出。

func Float 

func Float(state State) (interface{}, error)

Float 返回一个有符号实数的解析算子

func Int 

func Int(state State) (interface{}, error)

Int 返回一个有符号整型的解析算子

func Letter 

func Letter(state State) (interface{}, error)

Letter 构造一个字母校验算子

func Newline 

func Newline(state State) (interface{}, error)

Newline 构造一个 newline 校验算子

func Nil 

func Nil(state State) (interface{}, error)

Nil 判断当前元素是否为 nil

func Number 

func Number(state State) (interface{}, error)

Number 构造一个 Number 校验算子

func One 

func One(state State) (interface{}, error)

One 仅仅简单的返回下一个迭代结果，或者得到 eof 错误

func Space 

func Space(state State) (interface{}, error)

Space 构造一个空格校验算子

func ToInterfaces 

func ToInterfaces(input string) []interface{}

ToInterfaces 将string 转为 []interface{} ，如果输入数据与前面提到的规范不符，会 panic

func ToString 

func ToString(input interface{}) string

ToString 将封装为 interface{} 的 []interface{} 转成 string，如果输入数据与前面提到的规范不符，会 panic

func UFloat 

func UFloat(state State) (interface{}, error)

UFloat 返回一个无符号实数的解析算子

func UInt 

func UInt(state State) (interface{}, error)

UInt 返回一个无符号整型的解析算子

func Whitespace 

func Whitespace(state State) (interface{}, error)

Whitespace 构造一个空白校验算子

Types

type BasicState 

type BasicState struct {
	// contains filtered or unexported fields
}

BasicState 实现最基本的 State 操作

func BasicStateFromText 

func BasicStateFromText(str string) BasicState

BasicStateFromText 构造一个新的 BasicState

func NewBasicState 

func NewBasicState(data []interface{}) BasicState

NewBasicState 构造一个新的 BasicState

func (*BasicState) Begin 

func (state *BasicState) Begin() int

Begin 开始一个事务并返回事务号，State 的 Begin 总是记录比较靠后的位置。

func (*BasicState) Commit 

func (state *BasicState) Commit(tran int)

Commit 提交一个事务，将其从注册状态中删除，将事务位置保存为比较靠前的位置

func (*BasicState) Next 

func (state *BasicState) Next() (interface{}, error)

Next 实现迭代逻辑

func (*BasicState) Pos 

func (state *BasicState) Pos() int

Pos 返回 state 的当前位置

func (*BasicState) Rollback 

func (state *BasicState) Rollback(tran int)

Rollback 取消一个事务，将 pos 移动到 该位置，将事务位置保存为比较靠前的位置

func (*BasicState) SeekTo 

func (state *BasicState) SeekTo(pos int) bool

SeekTo 将指针移动到指定位置

func (*BasicState) Trap 

func (state *BasicState) Trap(message string, args ...interface{}) error

Trap 是构造错误信息的辅助函数，它传递错误的位置，并提供字符串格式化功能

type Error 

type Error struct {
	Pos     int
	Message string
}

Error 实现基本的错误信息结构

func (Error) Error 

func (e Error) Error() string

type P 

type P func(state State) (interface{}, error)

P 是算子的公共抽象类型，实现 Monad 和解析逻辑

func AtLeast 

func AtLeast(x int, psc P) P

AtLeast 函数匹配至少 x 次 psc

func AtMost 

func AtMost(x int, psc P) P

AtMost 函数匹配至多 x 次 psc ，如果后续的数据仍然匹配成功，返回错误信息

func Between 

func Between(open, close, psc P) P

Between 构造一个有边界算子的 P

func Byte 

func Byte(val byte) P

Byte 判断下一个字节是否与给定值相等

func ByteNone 

func ByteNone(str string) P

ByteNone 检查后续的字符是否不是给定值中的任一个

func ByteOf 

func ByteOf(str string) P

ByteOf 检查后续的字符是否是给定值中的某一个

func ByteP 

func ByteP(name string, pred func(r byte) bool) P

ByteP 通过一个谓词参数，提供通用的 rune 算子生成判断

func Bytes 

func Bytes(str string) P

Bytes 判断后续的字节串是否匹配给定的串

func Choice 

func Choice(Ps ...P) P

Choice 逐个尝试给定的算子，直到某个成功或者 state 无法复位，或者全部失败

func Chr 

func Chr(val rune) P

Chr 判断下一个字符是否与给定值相等

func Do 

func Do(fn func(State) interface{}) P

Do 构造一个算子，其内部类似 Monad Do Environment ，将 Exec 形式恢复成 Parse 形式。 需要注意的是，捕获的非 error 类型的panic会重新抛出。

func Eq 

func Eq(val interface{}) P

Eq 判断下一个数据是否与给定值相等，这里简单的使用了反射

func Fail 

func Fail(message string, args ...interface{}) P

Fail 生成的算子总是返回给定错误

func FailIf 

func FailIf(psc P) P

FailIf 是算子的否定检查，如果给定算子匹配成功，返回错误信息。否则退换复位并且返回 nil， 可以用于边界检查。

func InRange 

func InRange(x, y int, psc P) P

InRange 函数生成一个 P 算子，它匹配指定算子x到y次。如果第 y+1 次仍然成功，返回错误信息

func Many 

func Many(psc P) P

Many 匹配 0 到若干次 psc 并返回结果序列

func Many1 

func Many1(psc P) P

Many1 匹配 1 到若干次 psc 并返回结果序列

func ManyTill 

func ManyTill(p, e P) P

ManyTill 返回以指定算子结尾的 Many

func Maybe 

func Maybe(p P) P

Maybe 在算子失败时返回 nil

func NByte 

func NByte(val byte) P

NByte 判断下一个字符是否与给定值不相等

func NChr 

func NChr(val rune) P

NChr 判断下一个字符是否与给定值不相等

func Ne 

func Ne(val interface{}) P

Ne 判断下一个数据是否与给定值不相等，这里简单的使用了反射

func NoneOf 

func NoneOf(args ...interface{}) P

NoneOf 期待下一个元素不属于给定的参数中的任一个

func OneOf 

func OneOf(args ...interface{}) P

OneOf 期待下一个元素属于给定的参数中的一个

func Option 

func Option(v interface{}, x P) P

Option 实现一个默认值封装，如果给定算子失败，返回默认值 x

func Repeat 

func Repeat(x, y int, psc P) P

Repeat 函数生成一个 P 算子，它匹配指定算子x到y次。

func Return 

func Return(val interface{}) P

Return 生成的算子总是返回给定值

func ReturnString 

func ReturnString(input interface{}) P

ReturnString 用 Return 包装 ToString，使其适用于组合子表达式。

func RuneNone 

func RuneNone(str string) P

RuneNone 检查后续的字符是否不是给定值中的任一个

func RuneOf 

func RuneOf(str string) P

RuneOf 检查后续的字符是否是给定值中的某一个

func RuneP 

func RuneP(name string, pred func(r rune) bool) P

RuneP 通过一个谓词参数，提供通用的 rune 算子生成判断

func SepBy 

func SepBy(p, sep P) P

SepBy 返回匹配 0 到若干次的带分隔符的算子

func SepBy1 

func SepBy1(p, sep P) P

SepBy1 返回匹配 1 到若干次的带分隔符的算子

func Skip 

func Skip(p P) P

Skip 忽略 0 到若干次指定算子

func Skip1 

func Skip1(p P) P

Skip1 忽略 1 到若干次指定算子

func Str 

func Str(str string) P

Str 判断后续的字符串是否匹配给定的串

func Times 

func Times(x int, psc P) P

Times 函数生成一个 P 算子，它匹配指定算子x次。我们在这里用它构造一个不严谨的ip判定

func Try 

func Try(psc P) P

Try 尝试运行给定算子，如果给定算子报错，将state复位再返回错误信息

func Union 

func Union(parsers ...P) P

Union 逐个执行每个给定的算子，直到出错或者完整，将结果中非空值合成一个 []interface{} 返回

func UnionAll 

func UnionAll(parsers ...P) P

UnionAll 逐个执行每个给定的算子，直到出错或者完整，将结果合成一个 []interface{} 返回

func UpTo 

func UpTo(x int, psc P) P

UpTo 函数匹配 0 到 x 次 psc

func (P) Bind 

func (p P) Bind(binder func(interface{}) P) P

Bind 方法实现 Monad >>= 运算

func (P) Exec 

func (p P) Exec(state State) interface{}

Exec 调用被封装的算子，如果返回错误，用panic抛出

func (P) Over 

func (p P) Over(psc P) P

Over 方法实现一个简化的 bind 逻辑，如果两个算子都成功，返回前一个算子的结果，否则返回第一个发生的错误

func (P) Parse 

func (p P) Parse(state State) (interface{}, error)

Parse 简单的调用被封装的算子逻辑

func (P) Then 

func (p P) Then(psc P) P

Then 方法实现 Monad 的 >> 运算

type State 

type State interface {
	Pos() int
	SeekTo(int) bool
	Next() (interface{}, error)
	Trap(message string, args ...interface{}) error
	Begin() int
	Commit(int)
	Rollback(int)
}

State 是基本的状态操作接口

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.