🥮 mooncakes.io
    Sign in

    moonttl

    MoonTTL is a high-performance RDF parsing and serialization library for MoonBit.

    nquads
    rdf
    Download zip
    Author
    Version
    0.1.6
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    400

    #MoonTTL

    MoonTTL 是一个使用 MoonBit 语言编写的高性能 RDF 解析与序列化库。本项目参考自 Rust 生态中的优秀库 Oxttl，旨在为 MoonBit 生态提供一套标准化、轻量级的语义网数据处理引擎。

    #特性

    • 多格式支持：完整支持 Turtle, TriG, N-Triples, N-Quads 和 N3 格式的解析与序列化（目前仅支持 N-Quads 格式）。
    • RDF 1.2 兼容：全面支持最新的 RDF 1.2 国际标准规范。
    • 高性能：基于状态机的词法分析器设计，提供高效的解析性能。
    • 轻量级：专注于核心解析功能，保持依赖最小化。

    #安装

    确保你的环境中已经安装了 MoonBit 工具链。

    在你的 moon.mod.json 中添加依赖：

    {
  "name": "your_username/your_project",
  "deps": [
    "thy1016/moonttl"
  ]
}

    #命令行工具

    #从字符串解析

    moon run src/cmd/main -- "<http://example.org/s> <http://example.org/p> <http://example.org/o> ."

    #从文件解析

    echo '<http://example.org/s> <http://example.org/p> <http://example.org/o> .' > test.nq
moon run src/cmd/main -- -f test.nq

    #详细输出模式

    moon run src/cmd/main -- -v -f test.nq

    #命令行选项

    • -f, --file <path> - 指定输入文件路径
    • -v, --verbose - 启用详细输出模式
    • <input> - 直接输入 N-Quads 格式的字符串

    #N-Quads 格式说明

    N-Quads 是一种简洁的 RDF 四元组格式，每行一个语句：

    .

    其中 graph 部分可选，默认为默认图。

    示例：
    <http://example.org/s> <http://example.org/p> <http://example.org/o> .

    #示例代码

    let content = "<http://example.org/s> <http://example.org/p> <http://example.org/o> .\n"
    let data = @utf8.encode(content).to_array()

    let lexer = @lib.Lexer::Lexer(
      @lib.RdfLexer::RdfLexer(@lib.RdfLexerMode::NTriples, false, []),
      data,
      true,
      @lib.MIN_BUFFER_SIZE,
      @lib.MAX_BUFFER_SIZE,
      Some(b"#"),
      0,
      0,
    )

    let logger = @lib.make_console_logger()

    let machine = @lib.NQuadsRecognizer::{
      current_state: @lib.NQuadsState::ExpectSubject,
      stack: [@lib.NQuadsState::ExpectSubject],
      emit_quad: false,
      temp_literal: None,
      lenient: false,
      debug_logger: logger,
      last_range: @lib.Range::default(),
      errors: [],
    }

    let context = @lib.RdfContext::NQuadsRecognizerContext(@lib.NQuadsRecognizerContext::{
      with_graph_name: true,
      lexer_options: { base_iri: None },
    })

    let generic_machine = @lib.GenericStateMachine::GenericStateMachine(
      machine,
      context,
      debug_logger=logger,
    )
    let parser = @lib.Parser::{
      lexer,
      engine: generic_machine,
      context,
      errors: [],
    }


    for ;; {
      match parser.parse_next() {
        Some(Ok(quad)) => println("Parsed: \{quad}")
        Some(Err(e)) => println("Error: \{e}")
        None => break
      }
    }

    #项目结构

    src/
├── lexer_*.mbt      # 词法分析器
├── parser_*.mbt      # 语法分析器
├── iri.mbt          # IRI 处理
├── literal.mbt      # 字面量处理
├── langtag.mbt      # 语言标签处理
└── tests/           # 测试文件

    #Examples

    #解析 N-Quads 文件

    运行示例程序：

    moon run src/examples/nquads

    输出示例：

    Written N-Quads content to: ./example.nq
Parsing N-Quads file...
[1] Quad<http://example.org/s1, http://example.org/p1, http://example.org/o1>
[2] Quad<http://example.org/s2, http://example.org/p2, http://example.org/o2>
[3] Quad<http://example.org/s3, http://example.org/p3, http://example.org/o3>
[4] Error: InvalidTurtleToken - Unexpected end of input turtle .

=== Summary ===
Total quads parsed: 3

    该示例展示了：
    • 从字符串创建 N-Quads 内容并写入文件
    • 从文件读取并解析为二进制数据
    • 使用词法分析器和状态机解析 RDF 四元组
    • 错误处理和结果汇总

    #许可证声明

    W3C 测试套件中的测试文件在以下两种许可证下分发，使用时由被许可方二选一：

    • W3C 3-clause BSD License — 允许修改和集成到开发工具中，但禁止对修改后的测试断言性能声明或规范一致性。
    • W3C Test Suite License — 要求测试文件保持未修改状态，方可对外发布性能声明。

    本项目在开发测试和 CI 回归测试中采用 BSD 许可证 使用这些测试用例，并根据项目需求对测试框架进行了适配包装。如需了解 完整版权条款，请参阅 W3C Test Suites Licenses 官方页面。

    #测试覆盖范围

    当前 W3C 测试套件的覆盖情况：

    测试类别 总数 通过 状态 ━━━━━━━━━━━━━━━━━━ ━━━━━━ ━━━━━━ ━━━━━━━━━━━━━ N-Quads 正向测试 45 45 ✅ 全部通过 ────────────────── ────── ────── ───────────── N-Quads 负向测试 12 12 ✅ 全部通过 ────────────────── ────── ────── ───────────── 语法边界测试 8 8 ✅ 全部通过

    #性能基准

    MoonTTL 专注于提供高性能的 RDF 解析体验：

    • 零拷贝设计：词法分析器基于字节数组切片，避免不必要的内存分配
    • 状态机驱动：使用有限状态机进行语法解析，保证 O(n) 时间复杂度
    • 缓冲区管理：可配置的缓冲区大小，平衡内存使用和解析效率

    #贡献指南

    欢迎贡献代码、报告问题或提出建议！

    1. Fork 本仓库
    2. 创建您的特性分支 (git checkout -b feature/amazing-feature)
    3. 提交您的更改 (git commit -m 'Add some amazing feature')
    4. 推送到分支 (git push origin feature/amazing-feature)
    5. 开启一个 Pull Request

    #开发环境设置

    #克隆仓库

    git clone https://github.com/thy1016/moonttl.git cd moonttl

    #安装依赖

    moon update

    #运行测试

    moon test

    #构建项目

    moon build

    #许可证

    本项目采用以下许可证：

    • Apache License, Version 2.0, (LICENSE-APACHE or <http://www.apache.org/licenses/LICENSE-2.0>)

    您可自行选择适用的许可证。

    #贡献

    除非您另有明确声明，否则您有意提交给 MoonTTL 的任何贡献（按 Apache-2.0 许可证的定义）均应按上述方式双重许可，不附加任何其他条款或条件。

    IriParser

    source
    type IriParser[A] = 
    Parser    [Char, Result[A, IriError]]

    A parser combinator

    Ref

    source
    using @moonbitlang/core/ref { type Ref }

    A simple mutable reference type that allows you to store and modify a value of any type.

    test {
      let x = @ref.Ref(42)
      @test.assert_eq(x.val, 42)
      x.val = 100
      @test.assert_eq(x.val, 100)
    }

    ResParser

    source
    type ResParser[A] = (Result[A, IriError], 
    Seq    [Char])?

    TransitionResult

    source
    type TransitionResult[TR, S, O] = Result[(TR, S, O), RuleRecognizerError]

    DebugLogger

    source
    pub trait DebugLogger {
      fn info(Self, String) -> Unit
      fn error(Self, String) -> Unit
      fn warn(Self, String) -> Unit
    }

    ErrOut

    source
    pub trait ErrOut {
      fn message(self : Self) -> String
      fn err_kind(self : Self) -> String
    }

    GenMachine

    source
    pub trait GenMachine {
      fn initial_state(Self) -> RdfState
      fn transition(Self, state : RdfState, event : LocatedToken, context : RdfContext) -> Result[(Self, RdfState, DataAction), RuleRecognizerError]
      fn current_state(Self) -> RdfState
      fn step(Self, event : LocatedToken) -> Self
      fn reset(Self) -> Self
      fn is_accepting(Self) -> Bool
      fn context(Self) -> RdfContext
      fn[ST : StateWrapper] set_current_state(Self, state : ST) -> Self
      fn error_recovery_statemachine(Self) -> Self
      fn accumulate(Self, dw : DataWorld, action : DataAction) -> (Self, DataWorld)
      fn get_and_clear_output(Self, dw : DataWorld) -> (Self, RdfOut?)
    }

    RuleRecognizer

    source
    pub trait RuleRecognizer {
      fn error_recovery_state(Self) -> Self
      fn recognize_end(Self, context : RdfContext, results : Array[RdfOut]) -> Unit
      fn lexer_options(context : RdfContext) -> LexerOptions?
    }

    StateWrapper

    source
    pub trait StateWrapper {
      fn as_state_enum(Self) -> RdfState
    }

    TokenRecognizer

    source
    pub trait TokenRecognizer {
      fn recognize_next_token(Self, data : ArrayView[Byte], is_ending : Bool, options : LexerOptions?, location_pos : SourcePos) -> (Int, Result[LocatedToken, TokenRecognizerError])?
    }

    IriError

    source
    pub(all) suberror IriError {
      NoScheme(Int)
      InvalidScheme(Char, Int)
      InvalidCharacter(Char, Int)
      InvalidPath(Int)
      InvalidAuthority(String)
      InvalidPercentEncoding(Int)
      UnexpectedEnd(Int)
    } derive(
    Debug    )

    impl Show for IriError
    impl ErrOut for IriError

    IriError::position

    source
    fn IriError::position(self : IriError) -> Int

    LanguageTagParseError

    source
    pub(all) suberror LanguageTagParseError {
      TagParseErr(TagParseErr)
    } derive(
    Debug    )

    LexerError

    source
    pub(all) suberror LexerError {
      OutOfMemory(String)
      IoReadError(String)
      SyntaxError(String)
    }

    impl Show for LexerError

    RuleRecognizerError

    source
    pub(all) suberror RuleRecognizerError {
      SyntaxError(String, Range)
      BlankNodeOrIriError
      PredicateNotAnIRI
      LiteralDatatypeError
      TripleMissingDot
      InvalidLanguageTag
      BlankNodePropertyListMissingEndBracket
      NOCARE
    } derive(
    Debug    )

    RuleRecognizerError::text_range

    source

    TagParseErr

    source
    pub(all) suberror TagParseErr {
      EmptyExtension
      EmptyPrivateUse
      ForbiddenChar
      InvalidSubtag(Int, StringView)
      InvalidLanguage
      SubtagTooLong
      EmptySubtag
      TooManyExtlangs
      InvalidLanguageLength
    } derive(
    Debug    )

    impl Show for TagParseErr

    TokenRecognizerError

    source
    pub(all) suberror TokenRecognizerError {
      Invalid
      InvalidFormat(ArrayView[Byte], Range)
      InvalidToken(String, ArrayView[Byte], Range)
      InvalidCharacter(ArrayView[Byte], Range)
      IncompleteEscapeSequence(ArrayView[Byte], Range)
      InvalidEscapeSequence(ArrayView[Byte], Range)
      UnsupportedFeature(ArrayView[Byte], Range)
      IriTruncated(ArrayView[Byte], Range)
      IriParsingError(String, Range)
      UnexpectedEndOfInput(ArrayView[Byte], Range)
      InvalidErrMessage(ArrayView[Byte], Range, String)
    } derive(
    Debug    )

    TokenRecognizerError::range

    source

    TurtleError

    source
    pub(all) suberror TurtleError {
      TurtleParseError(String, Range)
      TurtleSyntaxError(String, Range)
      InvalidEscapeSequence
      InvalidCharacter(String)
      InvalidTurtleToken(SourcePos, String)
      UnexpectedEndOfInput(SourcePos, String)
    } derive(
    Debug    )

    impl Show for TurtleError

    Anonymous

    source
    pub(all) struct Anonymous {
      id : UInt64
      str : String
    } derive(Eq, Hash, ToJson, 
    Debug    )

    Anonymous::Anonymous

    source
    fn Anonymous::Anonymous(id : UInt64, str : String) -> Anonymous

    Anonymous::default

    source
    fn Anonymous::default() -> Anonymous

    AsyncReaderIterator

    source
    pub struct AsyncReaderIterator[TR, RR] {
      reader : &
    Reader
      parser : Parser[TR, RR]
    }

    AsyncReaderIterator::next

    source
    async fn[TR : TokenRecognizer, RR : GenMachine] AsyncReaderIterator::next(self : AsyncReaderIterator[TR, RR]) -> Result[RdfOut, LexerError]?

    AsyncReaderNQuadsParser

    source
    pub struct AsyncReaderNQuadsParser[RL] {
      inner : AsyncReaderIterator[RL, NQuadsRecognizer]
    }

    AsyncReaderNQuadsParser::next

    source

    AsyncReaderNTriplesParser

    source
    pub struct AsyncReaderNTriplesParser[RL] {
      inner : AsyncReaderIterator[RL, NQuadsRecognizer]
    }

    AsyncReaderNTriplesParser::next

    source

    AsyncWriterNQuadsSerializer

    source
    pub struct AsyncWriterNQuadsSerializer[W] {
      buffer_writer : 
    BufferedWriter    [W]
      low_level_writer : LowLevelNQuadsSerializer
    }

    AsyncWriterNQuadsSerializer::finish

    source

    AsyncWriterNQuadsSerializer::serialize_quad

    source

    AsyncWriterNTriplesSerializer

    source
    pub struct AsyncWriterNTriplesSerializer[W] {
      buffer_writer : 
    BufferedWriter    [W]
      low_level_writer : LowLevelNTriplesSerializer
    }

    AsyncWriterNTriplesSerializer::finish

    source

    AsyncWriterNTriplesSerializer::serialize_triple

    source
    fn[W] AsyncWriterNTriplesSerializer::serialize_triple(self : AsyncWriterNTriplesSerializer[W], t : Triple) -> Result[String, Unit]

    BaseDirection

    source
    pub(all) enum BaseDirection {
      Ltr
      Rtl
    } derive(Eq, Hash, ToJson, 
    Debug    )

    BlankNode

    source
    pub(all) enum BlankNode {
      Named(String)
      Anonymous(Anonymous)
    } derive(Eq, Hash, ToJson, 
    Debug    )

    BlankNode::as_enum

    source
    fn BlankNode::as_enum(self : BlankNode) -> NamedOrBlankNode

    BlankNode::as_ref

    source
    fn BlankNode::as_ref(self : BlankNode) -> BlankNodeRef

    BlankNode::default

    source
    fn BlankNode::default() -> BlankNode

    BlankNode::new

    source
    fn BlankNode::new(content : BlankNode) -> BlankNode

    BlankNode::new_from_unique_id

    source
    fn BlankNode::new_from_unique_id(id : UInt64) -> BlankNode

    BlankNodeRef

    source
    pub(all) enum BlankNodeRef {
      Named(StringView)
      Anonymous(Anonymous)
    } derive(Eq, Hash, 
    Debug    )

    BlankNodeRef::as_enum

    source

    BlankNodeRef::as_term

    source
    fn BlankNodeRef::as_term(self : BlankNodeRef) -> TermRef

    BlankNodeRef::default

    source
    fn BlankNodeRef::default() -> BlankNodeRef

    BlankNodeRef::new_unchecked

    source
    fn BlankNodeRef::new_unchecked(iri : String) -> BlankNodeRef

    CharClass

    source
    pub(all) enum CharClass {
      Other
      Space
      Newline
      LAngle
      RAngle
      Colon
      Semicolon
      Period
      Comma
      LParen
      RParen
      LBracket
      RBracket
      LBrace
      RBrace
      Quote
      TripleQuote
      At
      QuestionMark
      Plus
      Minus
      Underscore
      Percent
      Hash
      Slash
      Backslash
      Star
      Eq
      Less
      Greater
      Caret
      Pipe
      Tilde
      Exclamation
      Dollar
      Ampersand
      Apostrophe
      LtLt
      GtGt
      CaretCaret
      LBracePipe
      PipeRBrace
      LtLtLParen
      RParenGtGt
      LtMinus
      EqGt
      LtEq
      LtLtRParen
      ColonColon
      ColonSlash
      Digit
      LowerU
      UpperU
    } derive(Eq, Hash, 
    Debug    )

    字符分类
    impl Show for CharClass

    Command

    source

    ConsoleLogger

    source
    type ConsoleLogger

    DataAction

    source
    pub(all) enum DataAction {
      NoOp
      AddSubject(NamedOrBlankNodeRef)
      AddPredicate(NamedNodeRef)
      AddObject(TermRef)
      SetTempLiteral(String)
      SetGraphName(GraphNameRef)
      EmitQuad
      EmitQuadWithLiteral(LiteralKind)
      EmitQuadWithTempLiteral(NamedNodeRef)
      PushStack(NQuadsState)
      ClearAccumulator
      FinalizeLiteral(LiteralKind)
      FinalizeQuotedTriple
    }

    DataWorld

    source
    pub(all) struct DataWorld {
      subjects : Array[NamedOrBlankNodeRef]
      predicates : Array[NamedNodeRef]
      objects : Array[TermRef]
      temp_literal : String?
      finalize_literal : LiteralKind?
      graph_name : GraphNameRef?
    } derive(Eq, Hash, 
    Debug    )

    DataWorld::DataWorld

    source
    fn DataWorld::DataWorld(subjects : Array[NamedOrBlankNodeRef], predicates : Array[NamedNodeRef], objects : Array[TermRef], temp_literal : String?, finalize_literal : LiteralKind?, graph_name : GraphNameRef?) -> DataWorld

    DataWorld::default

    source
    fn DataWorld::default() -> DataWorld

    EscapeQuote

    source
    pub(all) enum EscapeQuote {
      None
      StartDouble(Int)
      StartSingle(Int)
      Content
      NestDouble(Int)
      NestSingle(Int)
      EndDouble(Int)
      EndSingle(Int)
    } derive(Eq, Hash, 
    Debug    )

    追踪长字符串引号匹配状态
    impl Show for EscapeQuote

    EscapeQuote::default

    source
    fn EscapeQuote::default() -> EscapeQuote

    ExtensionsIterator

    source
    pub(all) struct ExtensionsIterator {
      input : StringView
      subtags : Array[StringView]
      index : Int
    }

    GenericStateMachine

    source
    pub(all) struct GenericStateMachine[M] {
      machine : M
      context : RdfContext
      outputs : Array[RdfOut]
      data_world : DataWorld
      debug_logger : &DebugLogger
      lexer_errors : Array[(String, ArrayView[Byte], Range)]
    }

    GenericStateMachine::GenericStateMachine

    source
    fn[M] GenericStateMachine::GenericStateMachine(machine : M, context : RdfContext, debug_logger? : &DebugLogger) -> GenericStateMachine[M]

    GenericStateMachine::remove_first_output

    source
    fn[M] GenericStateMachine::remove_first_output(self : GenericStateMachine[M]) -> GenericStateMachine[M]

    GenericStateMachine::run

    source

    GenericStateMachine::set_context

    source
    fn[M] GenericStateMachine::set_context(self : GenericStateMachine[M], new_context : RdfContext) -> GenericStateMachine[M]

    GraphName

    source
    pub(all) enum GraphName {
      DefaultGraph
      NamedNode(NamedNode)
      BlankNode(BlankNode)
    } derive(Eq, Hash, ToJson, 
    Debug    )

    GraphName::as_ref

    source
    fn GraphName::as_ref(self : GraphName) -> GraphNameRef

    GraphName::default

    source
    fn GraphName::default() -> GraphName

    GraphName::into_owned

    source
    fn GraphName::into_owned(self : GraphName) -> GraphName

    GraphName::is_blank_node

    source
    fn GraphName::is_blank_node(self : GraphName) -> Bool

    GraphName::is_default_graph

    source
    fn GraphName::is_default_graph(self : GraphName) -> Bool

    GraphName::is_named_node

    source
    fn GraphName::is_named_node(self : GraphName) -> Bool

    GraphNameRef

    source
    pub(all) enum GraphNameRef {
      DefaultGraph
      NamedNodeRef(NamedNodeRef)
      BlankNodeRef(BlankNodeRef)
    } derive(Eq, Hash, 
    Debug    )

    IriR

    source
    pub(all) struct IriR {
      scheme : StringView
      authority : StringView?
      path : StringView
      query : StringView?
      fragment : StringView?
    } derive(Default, Eq, 
    Debug    )

    IriR::IriR

    source
    fn IriR::IriR(scheme : StringView, authority : StringView?, path : StringView, query : StringView?, fragment : StringView?) -> IriR

    IriR::into_string

    source
    fn IriR::into_string(self : IriR) -> String

    IriR::parse

    source
    fn IriR::parse(_self : IriR, s : String) -> Result[IriR, IriError]

    IriR::parse_unchecked

    source
    fn IriR::parse_unchecked(_self : IriR, s : String) -> IriR

    IriR::relativize

    source
    fn IriR::relativize(self : IriR, target : IriR) -> Result[IriR, IriError]

    IriR::resolve

    source
    fn IriR::resolve(self : IriR, ref_iri : String, remove_dot_segments? : Bool) -> Result[IriR, IriError]

    合并 IRI

    IriR::resolve_unchecked

    source
    fn IriR::resolve_unchecked(self : IriR, ref_iri : String, remove_dot_segments? : Bool) -> IriR

    LanguageTag

    source
    pub(all) struct LanguageTag {
      tag : StringView
      positions : TagElementsPositions
    } derive(Default, Eq, Hash, 
    Debug    )

    impl Show for LanguageTag

    LanguageTag::extended_language

    source
    fn LanguageTag::extended_language(self : LanguageTag) -> StringView?

    LanguageTag::extended_language_subtags

    source
    fn LanguageTag::extended_language_subtags(self : LanguageTag) -> Array[StringView]

    LanguageTag::extension

    source
    fn LanguageTag::extension(self : LanguageTag) -> StringView?

    LanguageTag::extension_subtags

    source
    fn LanguageTag::extension_subtags(self : LanguageTag) -> ExtensionsIterator

    LanguageTag::full_language

    source
    fn LanguageTag::full_language(self : LanguageTag) -> StringView

    LanguageTag::into_str

    source
    fn LanguageTag::into_str(self : LanguageTag) -> String

    LanguageTag::parse

    source
    fn LanguageTag::parse(tag : StringView) -> Result[LanguageTag, TagParseErr]

    LanguageTag::parse_and_normalize

    source
    fn LanguageTag::parse_and_normalize(tag : StringView) -> Result[LanguageTag, TagParseErr]

    LanguageTag::primary_language

    source
    fn LanguageTag::primary_language(self : LanguageTag) -> StringView?

    LanguageTag::private_use

    source
    fn LanguageTag::private_use(self : LanguageTag) -> StringView?

    LanguageTag::private_use_subtags

    source
    fn LanguageTag::private_use_subtags(self : LanguageTag) -> Array[StringView]

    LanguageTag::region

    source
    fn LanguageTag::region(self : LanguageTag) -> StringView?

    LanguageTag::script

    source
    fn LanguageTag::script(self : LanguageTag) -> StringView?

    LanguageTag::variant

    source
    fn LanguageTag::variant(self : LanguageTag) -> StringView?

    LanguageTag::variant_subtags

    source
    fn LanguageTag::variant_subtags(self : LanguageTag) -> Array[StringView]

    LexAction

    source
    pub(all) enum LexAction {
      Continue
      Skip
      EmitToken
      EmitTokenWithDirection(BaseDirection?)
      SetState(LexStateMachine)
      StartCapture
      AppendCapture
      EndCapture
      EndLongStringCapture
      EmitError(String)
      Done
    } derive(Eq, Hash, 
    Debug    )

    词法动作
    impl Show for LexAction

    LexContext

    source
    pub(all) struct LexContext {
      data_buffer : ArrayView[Byte]
      position : Int
      state : LexStateMachine
      capture_start : Int
      capture_current : Int
      state_stack : Array[LexStateMachine]
      is_ending : Bool
      captured : String?
      escape_quote : EscapeQuote
      has_error : Bool
      error_message : String?
      prev_char : Byte?
    }

    ===== 状态机上下文 =====
    impl Show for LexContext

    LexContext::advance

    source
    fn LexContext::advance(self : LexContext) -> Unit

    LexContext::current_char

    source
    fn LexContext::current_char(self : LexContext) -> Byte?

    LexContext::default

    source
    fn LexContext::default() -> LexContext

    LexContext::get_capture

    source
    fn LexContext::get_capture(self : LexContext) -> String

    LexContext::new

    source
    fn LexContext::new(data_buffer : ArrayView[Byte], is_ending? : Bool) -> LexContext

    LexContext::peek_char

    source
    fn LexContext::peek_char(self : LexContext) -> Byte?

    LexStateMachine

    source
    pub(all) enum LexStateMachine {
      Start
      InIri
      InEsc
      InStringEscHex4
      InStringEscHex8
      InBlank
      InBlankLabel
      InString
      InStringEsc
      InLongStringEsc
      InLongStringQuote
      InLongStringQuoteContent
      InLongStringQuoteEnd
      InLongStringSingleQuote
      InLongStringSingleQuoteContent
      InLongStringSingleQuoteEnd
      InNumber
      InInteger
      InDecimal
      InDecimalStart
      InDouble
      InExponent
      InLangTag
      InLangTagExt
      InVariable
      InPnamePrefix
      InPnameLocalStart
      InPnameLocal
      InKeyword
      InPunct
      SkipLineComment
      SkipBlockComment(Int)
      Error
      Done
    } derive(Eq, Hash, 
    Debug    )

    词法分析器状态

    Lexer

    source
    pub(all) struct Lexer[RL] {
      parser : RL
      data : Array[Byte]
      position : Position
      previous_position : Position
      is_ending : Bool
      min_buffer_size : Int
      max_buffer_size : Int
      line_comment_start : Bytes?
      current_token_start : Int
      current_token_end : Int
    }

    Lexer::Lexer

    source
    fn[RL] Lexer::Lexer(parser : RL, data : Array[Byte], is_ending : Bool, min_buffer_size : Int, max_buffer_size : Int, line_comment_start : Bytes?, current_token_start : Int, current_token_end : Int) -> Lexer[RL]

    Lexer::current_line

    source
    fn[T] Lexer::current_line(self : Lexer[T]) -> Int

    获取当前行号

    Lexer::current_position

    source
    fn[T] Lexer::current_position(self : Lexer[T]) -> SourcePos

    获取当前位置（完整信息）

    Lexer::current_token_end_location

    source
    fn[RL] Lexer::current_token_end_location(self : Lexer[RL]) -> SourcePos

    获取当前 Token 的结束位置 (即 Lexer 指针当前位置)

    Lexer::current_token_range

    source
    fn[T] Lexer::current_token_range(self : Lexer[T]) -> Range

    获取 token 范围

    Lexer::current_token_start_location

    source
    fn[RL] Lexer::current_token_start_location(self : Lexer[RL]) -> SourcePos

    Lexer::end

    source
    fn[RL] Lexer::end(self : Lexer[RL]) -> Unit

    Lexer::extend_from_async_read

    source
    async fn[RL] Lexer::extend_from_async_read(self : Lexer[RL], reader : &
    Reader    ) -> Result[Int, LexerError]

    Lexer::extend_from_reader

    source
    async fn[RL] Lexer::extend_from_reader(self : Lexer[RL], reader : &
    Reader    ) -> Result[Int, LexerError]

    Lexer::extend_from_slice

    source
    fn[RL] Lexer::extend_from_slice(self : Lexer[RL], other : Array[Byte]) -> Unit

    Lexer::find_line_end

    source
    fn Lexer::find_line_end(buf : ArrayView[Byte], start : Int) -> Int?

    Lexer::is_end

    source
    fn[RL] Lexer::is_end(self : Lexer[RL]) -> Bool

    Lexer::last_token_end

    source
    fn[RL] Lexer::last_token_end(self : Lexer[RL]) -> SourcePos

    获取上一个 token 的结束位置

    Lexer::last_token_range

    source
    fn[RL] Lexer::last_token_range(self : Lexer[RL]) -> SourceRange

    Lexer::last_token_start

    source
    fn[RL] Lexer::last_token_start(self : Lexer[RL]) -> SourcePos

    获取上一个 token 的起始位置（解析完成后）

    Lexer::location_from_buffer_offset_range

    source
    fn[RL] Lexer::location_from_buffer_offset_range(self : Lexer[RL], offset_range : Range) -> SourceRange

    Lexer::parse_next

    source
    fn[RL : TokenRecognizer] Lexer::parse_next(self : Lexer[RL], options : LexerOptions?) -> Result[LocatedToken, TokenRecognizerError]?

    Lexer::position_from_range

    source
    fn[RL] Lexer::position_from_range(self : Lexer[RL], range : Range) -> SourcePos

    从 Range 计算 SourcePos（使用 position 的全局行号）

    Lexer::range_to_bytes

    source
    fn[RL] Lexer::range_to_bytes(self : Lexer[RL], range : Range) -> ArrayView[Byte]

    从 Range 获取 bytes

    Lexer::record_token_end

    source
    fn[T] Lexer::record_token_end(self : Lexer[T]) -> Unit

    记录 token 结束

    Lexer::record_token_start

    source
    fn[T] Lexer::record_token_start(self : Lexer[T]) -> Unit

    记录 token 起始

    Lexer::shrink_data

    source
    fn[RL] Lexer::shrink_data(self : Lexer[RL]) -> Unit

    Lexer::skip_whitespace

    source
    fn[RL] Lexer::skip_whitespace(self : Lexer[RL]) -> Int

    跳过空白字符，返回跳过的数量

    Lexer::skip_whitespaces_and_comments

    source
    fn[RL] Lexer::skip_whitespaces_and_comments(self : Lexer[RL]) -> Bool

    跳过空白和注释

    LexerOptions

    source
    pub(all) struct LexerOptions {
      base_iri : IriR?
    } derive(
    Debug    )

    Literal

    source
    pub(all) struct Literal(LiteralContent) derive(Eq, Hash, ToJson, 
    Debug    )

    impl Show for Literal

    Literal::as_ref

    source
    fn Literal::as_ref(self : Literal) -> LiteralRef

    Literal::datatype

    source
    fn Literal::datatype(self : Literal) -> NamedNodeRef

    Literal::destruct

    source
    fn Literal::destruct(self : Literal) -> (StringView, NamedNode?, String?, BaseDirection?)

    Literal::direction

    source
    fn Literal::direction(self : Literal) -> BaseDirection?

    Literal::language

    source
    fn Literal::language(self : Literal) -> String?

    Literal::new_directional_language_tagged_literal

    source
    fn Literal::new_directional_language_tagged_literal(value : String, language : String, direction : BaseDirection) -> Result[Literal, LanguageTagParseError]

    Literal::new_directional_language_tagged_literal_unchecked

    source
    fn Literal::new_directional_language_tagged_literal_unchecked(value : StringView, language : LanguageTag, direction : BaseDirection) -> Literal

    Literal::new_language_tagged_literal

    source
    fn Literal::new_language_tagged_literal(value : String, language : String) -> Result[Literal, LanguageTagParseError]

    Literal::new_language_tagged_literal_unchecked

    source
    fn Literal::new_language_tagged_literal_unchecked(value : String, language : String) -> Literal

    Literal::new_simple_literal

    source
    fn Literal::new_simple_literal(value : String) -> Literal

    Literal::value

    source
    fn Literal::value(self : Literal) -> String

    LiteralContent

    source
    pub(all) enum LiteralContent {
      String(String)
      LanguageTaggedString(value~ : String, language~ : String)
      DirectionalLanguageTaggedString(value~ : StringView, language~ : String, direction~ : BaseDirection)
      TypedLiteral(value~ : String, datatype~ : NamedNode)
    } derive(Eq, Hash, ToJson, 
    Debug    )

    LiteralKind

    source
    pub(all) enum LiteralKind {
      Simple
      Lang(LanguageTag, BaseDirection)
      Typed(String, NamedNodeRef)
    } derive(Eq, Hash, 
    Debug    )

    impl Show for LiteralKind

    LiteralRef

    source
    pub(all) struct LiteralRef(LiteralRefContent) derive(Eq, Hash, 
    Debug    )

    impl Show for LiteralRef

    LiteralRef::as_term

    source
    fn LiteralRef::as_term(self : LiteralRef) -> TermRef

    LiteralRef::datatype

    source
    fn LiteralRef::datatype(self : LiteralRef) -> NamedNodeRef

    LiteralRef::direction

    source
    fn LiteralRef::direction(self : LiteralRef) -> BaseDirection?

    LiteralRef::into_owned

    source
    fn LiteralRef::into_owned(self : LiteralRef) -> Literal

    LiteralRef::into_value

    source
    fn LiteralRef::into_value(self : LiteralRef) -> StringView

    LiteralRef::language

    source
    fn LiteralRef::language(self : LiteralRef) -> String?

    LiteralRef::new_directional_language_tagged_literal_unchecked

    source
    fn LiteralRef::new_directional_language_tagged_literal_unchecked(value : String, language : LanguageTag, direction : BaseDirection) -> LiteralRef

    LiteralRef::new_language_tagged_literal_unchecked

    source
    fn LiteralRef::new_language_tagged_literal_unchecked(value : String, language : StringView) -> LiteralRef

    LiteralRef::new_simple_literal

    source
    fn LiteralRef::new_simple_literal(value : StringView) -> LiteralRef

    LiteralRef::new_typed_literal

    source
    fn LiteralRef::new_typed_literal(value : String, datatype : NamedNodeRef) -> LiteralRef

    LiteralRefContent

    source
    pub(all) enum LiteralRefContent {
      String(StringView)
      LanguageTaggedString(value~ : String, language~ : StringView)
      DirectionalLanguageTaggedString(value~ : StringView, language~ : StringView, direction~ : BaseDirection)
      TypedLiteral(value~ : String, datatype~ : NamedNodeRef)
    } derive(Eq, Hash, 
    Debug    )

    LocatedToken

    source
    #alias(Event)
    pub struct LocatedToken(N3Token, Range) derive(
    Debug    )

    LocatedToken::into_token

    source
    fn LocatedToken::into_token(self : LocatedToken) -> N3Token

    LocatedToken::new

    source
    fn LocatedToken::new(token : N3Token, range : Range) -> LocatedToken

    LowLevelNQuadsParser

    source
    pub struct LowLevelNQuadsParser[RL] {
      parser : Parser[RL, NQuadsRecognizer]
    }

    LowLevelNQuadsParser::end

    source
    fn[RL] LowLevelNQuadsParser::end(self : LowLevelNQuadsParser[RL]) -> Unit

    LowLevelNQuadsParser::extend_from_slice

    source
    fn[RL] LowLevelNQuadsParser::extend_from_slice(self : LowLevelNQuadsParser[RL], other : Array[Byte]) -> Unit

    LowLevelNQuadsParser::is_end

    source
    fn[RL] LowLevelNQuadsParser::is_end(self : LowLevelNQuadsParser[RL]) -> Bool

    LowLevelNQuadsParser::parse_next

    source
    fn[RL : TokenRecognizer] LowLevelNQuadsParser::parse_next(self : LowLevelNQuadsParser[RL]) -> Result[Quad, TurtleError]?

    LowLevelNQuadsSerializer

    source
    pub struct LowLevelNQuadsSerializer {
    } derive(Default)

    LowLevelNQuadsSerializer::serialize_quad

    source
    fn LowLevelNQuadsSerializer::serialize_quad(_self : LowLevelNQuadsSerializer, q : Quad) -> Result[String, Unit]

    LowLevelNTriplesParser

    source
    pub struct LowLevelNTriplesParser[RL] {
      parser : Parser[RL, NQuadsRecognizer]
    }

    LowLevelNTriplesParser::end

    source

    LowLevelNTriplesParser::extend_from_slice

    source
    fn LowLevelNTriplesParser::extend_from_slice(self : LowLevelNTriplesParser[RdfLexer], other : Array[Byte]) -> Unit

    LowLevelNTriplesParser::is_end

    source

    LowLevelNTriplesParser::parse_next

    source

    LowLevelNTriplesSerializer

    source
    pub struct LowLevelNTriplesSerializer {
    } derive(Default)

    LowLevelNTriplesSerializer::serialize_triple

    source
    fn LowLevelNTriplesSerializer::serialize_triple(_self : LowLevelNTriplesSerializer, t : Triple) -> Result[String, Unit]

    Model

    source
    pub(all) struct Model {
      quads : Array[Quad]
    } derive(
    Debug    )

    纯模型：N-Quads 文档"应该"包含的内容

    MuteLogger

    source
    type MuteLogger

    N3Token

    source
    pub(all) enum N3Token {
      Iri(String)
      PrefixedName(prefix~ : String, localx~ : String, might_be_invalid_iri~ : Bool)
      Variable(String)
      BlankNodeLabel(String)
      String(String)
      LongString(String)
      Integer(String)
      Decimal(String)
      Double(String)
      LangTag(language~ : String, direction~ : BaseDirection?)
      Punctuation(String)
      PlainKeyword(String)
      LineJump
      End
    } derive(Eq, 
    Debug    )

    impl Show for N3Token

    NQuadsAction

    source
    pub(all) enum NQuadsAction {
      PushSubject(NamedOrBlankNodeRef)
      PushPredicate(NamedNodeRef)
      PushObject(TermRef)
      SetTempLiteral(String)
      FinalizeSimpleLiteral
      FinalizeLangLiteral(String, BaseDirection)
      SetGraphName(NamedOrBlankNodeRef)
      EmitQuad
      EmitQuadWithGraphName
      PushStack(NQuadsState)
      PopStack
      FinalizeQuotedTriple
      SetError(RuleRecognizerError)
      ClearAccumulator
    }

    NQuadsParser

    source
    pub struct NQuadsParser {
      lenient : Bool
    } derive(Default)

    NQuadsParser::for_async_reader

    source

    NQuadsParser::for_reader

    source

    NQuadsParser::for_slice

    source
    fn NQuadsParser::for_slice(self : NQuadsParser, slice : BytesView) -> SliceNQuadsParser[NQuadsRecognizer]

    NQuadsParser::lenient

    source
    fn NQuadsParser::lenient(self : NQuadsParser) -> NQuadsParser

    NQuadsParser::low_level

    source

    NQuadsParser::new

    source

    NQuadsParser::split_file_for_parallel_parsing

    source
    async fn NQuadsParser::split_file_for_parallel_parsing(self : NQuadsParser, path : String, target_parallelism : Int64) -> Result[Array[SliceNQuadsParser[NQuadsRecognizer]], String]

    NQuadsParser::split_slice_for_parallel_parsing

    source
    fn NQuadsParser::split_slice_for_parallel_parsing(self : NQuadsParser, slice : BytesView, target_parallelism : Int) -> Array[SliceNQuadsParser[NQuadsRecognizer]]

    NQuadsRecognizer

    source
    pub(all) struct NQuadsRecognizer {
      current_state : NQuadsState
      stack : Array[NQuadsState]
      emit_quad : Bool
      temp_literal : String?
      lenient : Bool
      debug_logger : &DebugLogger
      last_range : Range
      errors : Array[RuleRecognizerError]
    }

    NQuadsRecognizer::new_parser

    source
    fn NQuadsRecognizer::new_parser(data : Array[Byte], with_graph_name : Bool, lenient : Bool, debug_logger? : &DebugLogger) -> Parser[RdfLexer, NQuadsRecognizer]

    NQuadsRecognizerContext

    source
    pub(all) struct NQuadsRecognizerContext {
      with_graph_name : Bool
      lexer_options : LexerOptions
    }

    NQuadsSerializer

    source
    pub struct NQuadsSerializer {
    } derive(Default)

    NQuadsSerializer::for_async_writer

    source

    NQuadsSerializer::for_writer

    source
    fn[W] NQuadsSerializer::for_writer(self : NQuadsSerializer, writer : W) -> WriterNQuadsSerializer[W]

    NQuadsSerializer::low_level

    source

    NQuadsSerializer::new

    source

    NQuadsSerializer::to_string

    source
    fn NQuadsSerializer::to_string(self : NQuadsSerializer, q : Quad) -> String

    NQuadsState

    source
    pub(all) enum NQuadsState {
      Start
      ExpectSubject
      ExpectPredicate
      ExpectObject
      ExpectDotOrGraphName
      ExpectGraphName
      ExpectDot
      ExpectLiteralSuffix
      ExpectDatatype
      ExpectLineJump
    } derive(Eq, Hash, 
    Debug    )

    NQuadsState::to_str

    source
    fn NQuadsState::to_str(self : NQuadsState) -> String

    NQuadsSystem

    source
    pub(all) struct NQuadsSystem {
      quads : Array[Quad]
      line_number : Int
    }

    包装真实 N-Quads 解析器 这里用简单状态模拟，实际替换为你的解析器

    NTriplesParser

    source
    pub struct NTriplesParser {
      lenient : Bool
    } derive(Default)

    NTriplesParser::for_async_reader

    source

    NTriplesParser::for_reader

    source

    NTriplesParser::for_slice

    source
    fn NTriplesParser::for_slice(self : NTriplesParser, slice : BytesView) -> SliceNTriplesParser[NQuadsRecognizer]

    NTriplesParser::lenient

    source

    NTriplesParser::low_level

    source

    NTriplesParser::new

    source

    NTriplesParser::split_file_for_parallel_parsing

    source
    async fn NTriplesParser::split_file_for_parallel_parsing(self : NTriplesParser, path : String, target_parallelism : Int64) -> Result[Array[SliceNTriplesParser[NQuadsRecognizer]], String]

    NTriplesParser::split_slice_for_parallel_parsing

    source
    fn NTriplesParser::split_slice_for_parallel_parsing(self : NTriplesParser, slice : BytesView, target_parallelism : Int) -> Array[SliceNTriplesParser[NQuadsRecognizer]]

    NTriplesSerializer

    source
    pub struct NTriplesSerializer {
    } derive(Default)

    NTriplesSerializer::for_async_writer

    source

    NTriplesSerializer::for_writer

    source
    fn[W] NTriplesSerializer::for_writer(self : NTriplesSerializer, writer : W) -> WriterNTriplesSerializer[W]

    NTriplesSerializer::low_level

    source

    NTriplesSerializer::new

    source

    NTriplesSerializer::to_string

    source
    fn NTriplesSerializer::to_string(self : NTriplesSerializer, t : Triple) -> String

    NamedNode

    source
    pub(all) struct NamedNode {
      iri : String
    } derive(Default, Eq, Hash, ToJson, 
    Debug    )

    NamedNode::as_enum

    source
    fn NamedNode::as_enum(self : NamedNode) -> NamedOrBlankNode

    NamedNode::as_ref

    source
    fn NamedNode::as_ref(self : NamedNode) -> NamedNodeRef

    NamedNode::as_term

    source
    fn NamedNode::as_term(self : NamedNode) -> Term

    NamedNodeRef

    source
    pub(all) struct NamedNodeRef {
      iri : StringView
    } derive(Eq, Hash, 
    Debug    )

    NamedNodeRef::NamedNodeRef

    source
    fn NamedNodeRef::NamedNodeRef(iri : StringView) -> NamedNodeRef

    NamedNodeRef::as_enum

    source

    NamedNodeRef::as_term

    source
    fn NamedNodeRef::as_term(self : NamedNodeRef) -> TermRef

    NamedNodeRef::into_datatype

    source
    fn NamedNodeRef::into_datatype(self : NamedNodeRef, value : String) -> VarDataType

    NamedNodeRef::into_owned

    source
    fn NamedNodeRef::into_owned(self : NamedNodeRef) -> NamedNode

    NamedNodeRef::new_unchecked

    source
    fn NamedNodeRef::new_unchecked(iri : StringView) -> NamedNodeRef

    NamedOrBlankNode

    source
    pub(all) enum NamedOrBlankNode {
      NamedNode(NamedNode)
      BlankNode(BlankNode)
    } derive(Eq, Hash, ToJson, 
    Debug    )

    NamedOrBlankNode::as_ref

    source

    NamedOrBlankNode::is_blank_node

    source
    fn NamedOrBlankNode::is_blank_node(self : NamedOrBlankNode) -> Bool

    NamedOrBlankNode::is_named_node

    source
    fn NamedOrBlankNode::is_named_node(self : NamedOrBlankNode) -> Bool

    NamedOrBlankNodeRef

    source
    pub enum NamedOrBlankNodeRef {
      NamedNodeRef(NamedNodeRef)
      BlankNodeRef(BlankNodeRef)
    } derive(Eq, Hash, 
    Debug    )

    NamedOrBlankNodeRef::as_term

    source

    NamedOrBlankNodeRef::into_graph

    source

    NamedOrBlankNodeRef::into_owned

    source

    NamedOrBlankNodeRef::is_blank_node

    source
    fn NamedOrBlankNodeRef::is_blank_node(self : NamedOrBlankNodeRef) -> Bool

    NamedOrBlankNodeRef::is_named_node

    source
    fn NamedOrBlankNodeRef::is_named_node(self : NamedOrBlankNodeRef) -> Bool

    Parser

    source
    pub(all) struct Parser[TR, M] {
      lexer : Lexer[TR]
      engine : GenericStateMachine[M]
      context : RdfContext
      errors : Array[RuleRecognizerError]
    }

    Parser::Parser

    source
    fn[TR, M] Parser::Parser(lexer : Lexer[TR], engine : GenericStateMachine[M], context : RdfContext) -> Parser[TR, M]

    Parser::end

    source
    fn[TR, M] Parser::end(self : Parser[TR, M]) -> Unit

    Parser::extend_from_slice

    source
    fn[TR, RR] Parser::extend_from_slice(self : Parser[TR, RR], other : Array[Byte]) -> Unit

    Parser::for_async_reader

    source
    fn[TR, RR] Parser::for_async_reader(self : Parser[TR, RR], reader : &
    Reader    ) -> AsyncReaderIterator[TR, RR]

    Parser::for_reader

    source
    fn[TR, RR] Parser::for_reader(self : Parser[TR, RR], reader : &
    Reader    ) -> ReaderIterator[TR, RR]

    Parser::is_end

    source
    fn[TR, M : GenMachine] Parser::is_end(self : Parser[TR, M]) -> Bool

    Parser::lexer_options

    source
    fn[TR, RR] Parser::lexer_options(self : Parser[TR, RR]) -> LexerOptions?

    Parser::parse_next

    source
    fn[TR : TokenRecognizer, M : GenMachine] Parser::parse_next(self : Parser[TR, M]) -> Result[RdfOut, TokenRecognizerError]?

    Parser::try_finish

    source
    fn[TR, M : GenMachine] Parser::try_finish(self : Parser[TR, M]) -> Result[RdfOut, TokenRecognizerError]?

    检查并处理完成状态

    Parser::try_output

    source
    fn[TR, M] Parser::try_output(self : Parser[TR, M]) -> Result[RdfOut, TokenRecognizerError]?

    尝试返回一个输出

    Position

    source
    pub(all) struct Position {
      line_start_buffer_offset : Int
      buffer_offset : Int
      global_offset : Int
      global_line : Int
    } derive(Default, 
    Debug    )

    Quad

    source
    pub struct Quad {
      subject : NamedOrBlankNode
      predicate : NamedNode
      object : Term
      graph_name : GraphName
    } derive(Eq, Hash, ToJson, 
    Debug    )

    Quad::Quad

    source
    fn Quad::Quad(subject : NamedOrBlankNode, predicate : NamedNode, object : Term, graph_name : GraphName) -> Quad

    Quad::as_ref

    source
    fn Quad::as_ref(self : Quad) -> QuadRef

    QuadRef

    source
    pub struct QuadRef {
      subject : NamedOrBlankNodeRef
      predicate : NamedNodeRef
      object : TermRef
      graph_name : GraphNameRef
    }

    QuadRef::into_owned

    source
    fn QuadRef::into_owned(self : QuadRef) -> Quad

    Range

    source
    pub(all) struct Range {
      start : Int
      end : Int
    } derive(Default, Eq, 
    Debug    )

    impl Show for Range

    Range::Range

    source
    fn Range::Range(start : Int, end : Int) -> Range

    Range::contains

    source
    fn Range::contains(self : Range, pos : Int) -> Bool

    Range::length

    source
    fn Range::length(self : Range) -> Int

    Range::single

    source
    fn Range::single(pos : Int) -> Range

    Range::utf8_range

    source
    fn Range::utf8_range(self : Range, data : ArrayView[Byte]) -> String

    RdfContext

    source
    #alias(Ctx)
    pub(all) enum RdfContext {
      NQuadsRecognizerContext(NQuadsRecognizerContext)
    }

    RdfFeature

    source
    pub(all) enum RdfFeature {
      RelativeIri
      Numbers
      Prefixes
      Variables
      NonAsciiIri
      StringEscapes
      LangTags
      LongStrings
      PunctuationList
    }

    RdfLexer

    source
    pub(all) struct RdfLexer {
      mode : RdfLexerMode
      lenient : Bool
      debug_logger : &DebugLogger
    }

    RdfLexer::RdfLexer

    source
    fn RdfLexer::RdfLexer(mode : RdfLexerMode, lenient : Bool, _data_buffer : ArrayView[Byte], debug_logger? : &DebugLogger) -> RdfLexer

    RdfLexer::default

    source
    fn RdfLexer::default() -> RdfLexer

    RdfLexer::execute_action

    source
    fn RdfLexer::execute_action(self : RdfLexer, action : LexAction, ctx : LexContext, current : Byte, _data_buffer : ArrayView[Byte]) -> (LexAction, LexContext)

    ===== 状态机执行器 =====

    RdfLexer::find_transition

    source
    fn RdfLexer::find_transition(_self : RdfLexer, ctx : LexContext, char_class : CharClass) -> Transition?

    RdfLexerMode

    source
    pub(all) enum RdfLexerMode {
      NTriples
      Turtle
      N3
    } derive(Eq)

    RdfOut

    source
    #alias(O)
    pub(all) enum RdfOut {
      Quad(Quad)
      Triple(Triple)
    } derive(
    Debug    )

    impl Show for RdfOut

    RdfOut::new

    source
    fn RdfOut::new(quad : Quad) -> RdfOut

    RdfState

    source
    pub(all) enum RdfState {
      NQuadsState(NQuadsState)
    } derive(Eq, Hash)

    impl Show for RdfState

    ReaderIterator

    source
    pub struct ReaderIterator[TR, RR] {
      reader : &
    Reader
      parser : Parser[TR, RR]
    }

    ReaderIterator::next

    source
    async fn[RR : GenMachine] ReaderIterator::next(self : ReaderIterator[RdfLexer, RR]) -> Result[RdfOut, LexerError]?

    ReaderNQuadsParser

    source
    pub struct ReaderNQuadsParser[RL] {
      inner : ReaderIterator[RL, NQuadsRecognizer]
    }

    ReaderNTriplesParser

    source
    pub struct ReaderNTriplesParser[RL] {
      inner : ReaderIterator[RL, NQuadsRecognizer]
    }

    Response

    source
    pub(all) enum Response {
      QuadParsed
      TripleParsed
      LiteralParsed
      TypedLiteralParsed
      BlankSubjectParsed
      BlankObjectParsed
    } derive(Eq, 
    Debug    )

    解析响应

    SerializationError

    source
    pub(all) enum SerializationError {
      FormatError(String)
      IoError(String)
    }

    SliceIterator

    source
    pub(all) struct SliceIterator[TR, RR] {
      parser : Parser[TR, RR]
    }

    SliceIterator::next

    source
    fn[TR : TokenRecognizer, RR : GenMachine] SliceIterator::next(self : SliceIterator[TR, RR]) -> Result[RdfOut, LexerError]?

    SliceNQuadsParser

    source
    pub struct SliceNQuadsParser[RL] {
      inner : SliceIterator[RdfLexer, RL]
    }

    SliceNTriplesParser

    source
    pub struct SliceNTriplesParser[RL] {
      inner : SliceIterator[RdfLexer, RL]
    }

    SourcePos

    source
    pub struct SourcePos {
      line : Int
      column : Int
      offset : Int
    } derive(
    Debug    )

    SourcePos::end_position

    source
    fn SourcePos::end_position(self : SourcePos, consumed_bytes : Int) -> SourcePos

    SourcePos::start_position

    source
    fn SourcePos::start_position(self : SourcePos) -> SourcePos

    SourcePos::to_range

    source
    fn SourcePos::to_range(self : SourcePos) -> Range

    SourcePos 转换为 Range（字节偏移范围）

    SourcePos::to_range_with_length

    source
    fn SourcePos::to_range_with_length(self : SourcePos, length : Int) -> Range

    带长度的 Range

    SourceRange

    source
    pub(all) struct SourceRange {
      start : SourcePos
      end : SourcePos
    } derive(
    Debug    )

    impl Show for SourceRange

    SourceRange::to_range

    source
    fn SourceRange::to_range(self : SourceRange) -> Range

    SubtagType

    source
    pub(all) enum SubtagType {
      PrivateUseIntro
      ExtensionIntro(Char)
      Alphabetic(Int)
      Numeric(Int)
      Alphanumeric(Int)
      Invalid
    }

    TagElementsPositions

    source
    type TagElementsPositions derive(Default, Eq, Hash, 
    Debug    )

    Term

    source
    pub(all) enum Term {
      NamedNode(NamedNode)
      BlankNode(BlankNode)
      Literal(Literal)
      Triple(Triple)
    } derive(Eq, Hash, ToJson, 
    Debug    )

    Term::as_ref

    source
    fn Term::as_ref(self : Term) -> TermRef

    Term::is_blank_node

    source
    fn Term::is_blank_node(self : Term) -> Bool

    Term::is_literal

    source
    fn Term::is_literal(self : Term) -> Bool

    Term::is_named_node

    source
    fn Term::is_named_node(self : Term) -> Bool

    Term::is_triple

    source
    fn Term::is_triple(self : Term) -> Bool

    TermRef

    source
    pub(all) enum TermRef {
      NamedNodeRef(NamedNodeRef)
      BlankNodeRef(BlankNodeRef)
      LiteralRef(LiteralRef)
      TripleRef(TripleRef)
    } derive(Eq, Hash, 
    Debug    )

    TermRef::into_owned

    source
    fn TermRef::into_owned(self : TermRef) -> Term

    Transition

    source
    pub(all) struct Transition {
      from : LexStateMachine
      char_class : CharClass
      to : LexStateMachine
      action : LexAction
      priority : Int
    } derive(Eq, Hash, 
    Debug    )

    转换规则
    impl Show for Transition

    Transition::Transition

    source
    fn Transition::Transition(from : LexStateMachine, char_class : CharClass, to : LexStateMachine, action : LexAction, priority? : Int) -> Transition

    Triple

    source
    pub struct Triple {
      subject : NamedOrBlankNode
      predicate : NamedNode
      object : Term
    } derive(Eq, Hash, ToJson, 
    Debug    )

    impl Show for Triple

    Triple::Triple

    source
    fn Triple::Triple(subject : NamedOrBlankNode, predicate : NamedNode, object : Term) -> Triple

    Triple::as_enum

    source
    fn Triple::as_enum(self : Triple) -> Term

    Triple::as_ref

    source
    fn Triple::as_ref(self : Triple) -> TripleRef

    Triple::as_term

    source
    fn Triple::as_term(self : Triple) -> Term

    Triple::from_terms

    source
    fn Triple::from_terms(subject : NamedOrBlankNode, predicate : NamedNode, object : Term) -> Result[Triple, TryFromTermError]

    Triple::in_graph

    source
    fn Triple::in_graph(self : Triple, graph_name : GraphNameRef) -> Quad

    TripleRef

    source
    pub struct TripleRef {
      subject : NamedOrBlankNodeRef
      predicate : NamedNodeRef
      object : TermRef
    } derive(Eq, Hash, 
    Debug    )

    TripleRef::TripleRef

    source
    fn TripleRef::TripleRef(subject : NamedOrBlankNodeRef, predicate : NamedNodeRef, object : TermRef) -> TripleRef

    TripleRef::in_graph

    source
    fn TripleRef::in_graph(self : TripleRef, graph_name : GraphNameRef) -> QuadRef

    TripleRef::into_owned

    source
    fn TripleRef::into_owned(self : TripleRef) -> Triple

    TryFromTermError

    source
    pub struct TryFromTermError {
      term : Term
      target : String
    } derive(
    Debug    )

    TryFromTermError::TryFromTermError

    source
    fn TryFromTermError::TryFromTermError(term : Term, target : String) -> TryFromTermError

    TryFromTermError::as_term

    source
    fn TryFromTermError::as_term(self : TryFromTermError) -> Term

    VarDataType

    source
    pub(all) enum VarDataType {
      IntVar(String)
      IntegerVar(String)
      DoubleVar(String)
      StringVar(String)
      FalseVar
      TrueVar
      DecimalVar(StringView)
      DateVar(String)
      TimeVar(String)
      DateTimeVar(String)
      DurationVar(String)
    } derive(Eq, Hash, ToJson, 
    Debug    )

    impl Show for VarDataType

    WriterNQuadsSerializer

    source
    pub struct WriterNQuadsSerializer[W] {
      writer : W
      low_level_writer : LowLevelNQuadsSerializer
    }

    WriterNQuadsSerializer::finish

    source
    fn[W] WriterNQuadsSerializer::finish(self : WriterNQuadsSerializer[W]) -> W

    WriterNQuadsSerializer::serialize_quad

    source
    fn[W] WriterNQuadsSerializer::serialize_quad(self : WriterNQuadsSerializer[W], q : Quad) -> Result[String, Unit]

    WriterNTriplesSerializer

    source
    pub struct WriterNTriplesSerializer[W] {
      writer : W
      low_level_writer : LowLevelNTriplesSerializer
    }

    WriterNTriplesSerializer::finish

    source

    WriterNTriplesSerializer::serialize_triple

    source
    fn[W] WriterNTriplesSerializer::serialize_triple(self : WriterNTriplesSerializer[W], t : Triple) -> Result[String, Unit]

    MAX_BUFFER_SIZE

    source
    let MAX_BUFFER_SIZE : Int

    MIN_BUFFER_SIZE

    source
    let MIN_BUFFER_SIZE : Int

    MIN_PARALLEL_CHUNK_SIZE

    source
    let MIN_PARALLEL_CHUNK_SIZE : Int

    array_to_view

    source
    fn array_to_view(arr : ArrayView[Byte]) -> BytesView

    array_view_has_prefix

    source
    fn array_view_has_prefix(data : ArrayView[Byte], prefix : Bytes) -> Bool

    array_view_memchr

    source
    fn array_view_memchr(target : Byte, data : ArrayView[Byte]) -> Int?

    array_view_memchr2

    source
    fn array_view_memchr2(c1 : Byte, c2 : Byte, data : ArrayView[Byte]) -> Int?

    classify_byte

    source
    fn classify_byte(b : Byte) -> CharClass

    快速字符分类 - O(1)

    classify_subtag

    source
    fn classify_subtag(s : StringView) -> SubtagType

    find_newline_in_range

    source
    fn find_newline_in_range(bytes : BytesView, start : Int, end : Int) -> Int?

    在指定范围内搜索换行符，返回换行符的绝对位置

    fn_remove_dot_segments

    source
    fn fn_remove_dot_segments(path : StringView) -> StringView

    from_str_radix

    source
    fn from_str_radix(s : String, radix : Int) -> Result[UInt, String]

    get_ntriples_file_chunks

    source
    async fn get_ntriples_file_chunks(file : 
    File    , file_size : Int64, n_chunks : Int) -> Result[Array[(Int64, Int64)], String]

    get_ntriples_slice_chunks

    source
    fn get_ntriples_slice_chunks(bytes : Array[Byte], n_chunks : Int) -> Array[(Int, Int)]

    get_turtle_slice_chunks

    source
    fn get_turtle_slice_chunks(bytes : Array[Byte], n_chunks : Int) -> Array[(Int, Int)]

    initialize_char_class_table

    source
    let initialize_char_class_table : FixedArray[CharClass]

    256 字节的字符分类表

    initialize_transitions

    source
    let initialize_transitions : FixedArray[Transition]

    状态转移表

    is_pchar

    source
    fn is_pchar(c : Char) -> Bool

    is_unreserved

    source
    fn is_unreserved(c : Char) -> Bool

    is_valid_hex_string

    source
    fn is_valid_hex_string(hex : String) -> Bool

    lwALT

    source
    let lwALT : NamedNodeRef

    lwANY_URI

    source
    let lwANY_URI : NamedNodeRef

    lwBAG

    source
    let lwBAG : NamedNodeRef

    lwBASE_64_BINARY

    source
    let lwBASE_64_BINARY : NamedNodeRef

    lwBOOLEAN

    source
    let lwBOOLEAN : NamedNodeRef

    lwBYTE

    source
    let lwBYTE : NamedNodeRef

    lwCLASS

    source
    let lwCLASS : NamedNodeRef

    lwCOMMENT

    source
    let lwCOMMENT : NamedNodeRef

    lwCONTAINER

    source
    let lwCONTAINER : NamedNodeRef

    lwCONTAINER_MEMBERSHIP_PROPERTY

    source
    let lwCONTAINER_MEMBERSHIP_PROPERTY : NamedNodeRef

    lwDATATYPE

    source
    let lwDATATYPE : NamedNodeRef

    lwDATE

    source
    let lwDATE : NamedNodeRef

    lwDATE_TIME

    source
    let lwDATE_TIME : NamedNodeRef

    lwDATE_TIME_STAMP

    source
    let lwDATE_TIME_STAMP : NamedNodeRef

    lwDAY_TIME_DURATION

    source
    let lwDAY_TIME_DURATION : NamedNodeRef

    lwDECIMAL

    source
    let lwDECIMAL : NamedNodeRef

    lwDIR_LANG_STRING

    source
    let lwDIR_LANG_STRING : NamedNodeRef

    lwDOMAIN

    source
    let lwDOMAIN : NamedNodeRef

    lwDOUBLE

    source
    let lwDOUBLE : NamedNodeRef

    lwDURATION

    source
    let lwDURATION : NamedNodeRef

    lwFIRST

    source
    let lwFIRST : NamedNodeRef

    lwFLOAT

    source
    let lwFLOAT : NamedNodeRef

    lwG_DAY

    source
    let lwG_DAY : NamedNodeRef

    lwG_MONTH

    source
    let lwG_MONTH : NamedNodeRef

    lwG_MONTH_DAY

    source
    let lwG_MONTH_DAY : NamedNodeRef

    lwG_YEAR

    source
    let lwG_YEAR : NamedNodeRef

    lwG_YEAR_MONTH

    source
    let lwG_YEAR_MONTH : NamedNodeRef

    lwHEX_BINARY

    source
    let lwHEX_BINARY : NamedNodeRef

    lwHTML

    source
    let lwHTML : NamedNodeRef

    lwINT

    source
    let lwINT : NamedNodeRef

    lwINTEGER

    source
    let lwINTEGER : NamedNodeRef

    lwIS_DEFINED_BY

    source
    let lwIS_DEFINED_BY : NamedNodeRef

    lwJSON

    source
    let lwJSON : NamedNodeRef

    lwLABEL

    source
    let lwLABEL : NamedNodeRef

    lwLANGUAGE

    source
    let lwLANGUAGE : NamedNodeRef

    lwLANG_STRING

    source
    let lwLANG_STRING : NamedNodeRef

    lwLIST

    source
    let lwLIST : NamedNodeRef

    lwLITERAL

    source
    let lwLITERAL : NamedNodeRef

    lwLONG

    source
    let lwLONG : NamedNodeRef

    lwMEMBER

    source
    let lwMEMBER : NamedNodeRef

    lwNAME

    source
    let lwNAME : NamedNodeRef

    lwNC_NAME

    source
    let lwNC_NAME : NamedNodeRef

    lwNEGATIVE_INTEGER

    source
    let lwNEGATIVE_INTEGER : NamedNodeRef

    lwNIL

    source
    let lwNIL : NamedNodeRef

    lwNMTOKEN

    source
    let lwNMTOKEN : NamedNodeRef

    lwNON_NEGATIVE_INTEGER

    source
    let lwNON_NEGATIVE_INTEGER : NamedNodeRef

    lwNON_POSITIVE_INTEGER

    source
    let lwNON_POSITIVE_INTEGER : NamedNodeRef

    lwNORMALIZED_STRING

    source
    let lwNORMALIZED_STRING : NamedNodeRef

    lwOBJECT

    source
    let lwOBJECT : NamedNodeRef

    lwPOSITIVE_INTEGER

    source
    let lwPOSITIVE_INTEGER : NamedNodeRef

    lwPREDICATE

    source
    let lwPREDICATE : NamedNodeRef

    lwPROPERTY

    source
    let lwPROPERTY : NamedNodeRef

    lwRANGE

    source
    let lwRANGE : NamedNodeRef

    lwREIFIES

    source
    let lwREIFIES : NamedNodeRef

    lwRESOURCE

    source
    let lwRESOURCE : NamedNodeRef

    lwREST

    source
    let lwREST : NamedNodeRef

    lwSEE_ALSO

    source
    let lwSEE_ALSO : NamedNodeRef

    lwSEQ

    source
    let lwSEQ : NamedNodeRef

    lwSHORT

    source
    let lwSHORT : NamedNodeRef

    lwSTATEMENT

    source
    let lwSTATEMENT : NamedNodeRef

    lwSTRING

    source
    let lwSTRING : NamedNodeRef

    lwSUBJECT

    source
    let lwSUBJECT : NamedNodeRef

    lwSUB_CLASS_OF

    source
    let lwSUB_CLASS_OF : NamedNodeRef

    lwSUB_PROPERTY_OF

    source
    let lwSUB_PROPERTY_OF : NamedNodeRef

    lwTIME

    source
    let lwTIME : NamedNodeRef

    lwTOKEN

    source
    let lwTOKEN : NamedNodeRef

    lwTYPE

    source
    let lwTYPE : NamedNodeRef

    lwUNSIGNED_BYTE

    source
    let lwUNSIGNED_BYTE : NamedNodeRef

    lwUNSIGNED_INT

    source
    let lwUNSIGNED_INT : NamedNodeRef

    lwUNSIGNED_LONG

    source
    let lwUNSIGNED_LONG : NamedNodeRef

    lwUNSIGNED_SHORT

    source
    let lwUNSIGNED_SHORT : NamedNodeRef

    lwVALUE

    source
    let lwVALUE : NamedNodeRef

    lwWKT_LITERAL

    source
    let lwWKT_LITERAL : NamedNodeRef

    lwXML_LITERAL

    source
    let lwXML_LITERAL : NamedNodeRef

    lwYEAR_MONTH_DURATION

    source
    let lwYEAR_MONTH_DURATION : NamedNodeRef

    make_console_logger

    source
    fn make_console_logger() -> ConsoleLogger

    make_mute_logger

    source
    fn make_mute_logger() -> MuteLogger

    make_token

    source
    fn make_token(ctx : LexContext, content : String) -> Result[N3Token, String]

    创建 Token（包含完整的 LangTag）

    parse_duration

    source
    fn parse_duration(s : String) -> Result[String, String]

    parse_iri

    source
    let parse_iri : 
    Parser    [Char, Result[IriR, IriError]]

    完整的 IRI 解析器

    parse_primary_language

    source
    fn parse_primary_language(subtag : StringView) -> Result[StringView, TagParseErr]

    fn print_quoted_str(f : StringBuilder, string : StringView) -> String

    remove_dot_segments_from_array

    source
    fn remove_dot_segments_from_array(segments : Array[String]) -> Array[String]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io