🥮 mooncakes.io

pinyin-toolkit

Deterministic Chinese Pinyin normalization and text matching toolkit for MoonBit

pinyin
chinese
text
normalization
matching
moon add wjhfather/pinyin-toolkit@0.1.0
Download zip
Author
Version
0.1.0
License
Apache-2.0
Repository
Last updated
11 days ago
Downloads
3
README

#MoonBit Pinyin Toolkit

This package provides deterministic Unicode Pinyin reading lookup, validated phrase overrides, mixed-text conversion, traceable search keys, and bounded explainable matching for MoonBit applications.

The package uses Unicode 17.0 Unihan kMandarin and kHanyuPinyin data. The data provenance and split licensing are documented in the repository README. Context-dependent polyphone inference is represented as explicit caller phrase overrides rather than inferred silently.

#
AlignmentIntegrity

source
pub struct AlignmentIntegrity {
  left_covered_value : Int
  right_covered_value : Int
  step_count_value : Int
  total_cost_value : Double
  full_coverage_value : Bool
} derive(Eq, 
Debug)

Facts proven by validating alignment coverage, costs, and counters.

#
AlignmentIntegrity::has_full_coverage

source
fn AlignmentIntegrity::has_full_coverage(self : AlignmentIntegrity) -> Bool

#
AlignmentIntegrity::left_covered

source
fn AlignmentIntegrity::left_covered(self : AlignmentIntegrity) -> Int

#
AlignmentIntegrity::right_covered

source
fn AlignmentIntegrity::right_covered(self : AlignmentIntegrity) -> Int

#
AlignmentIntegrity::steps

source
fn AlignmentIntegrity::steps(self : AlignmentIntegrity) -> Int

#
AlignmentIntegrity::total_cost

source
fn AlignmentIntegrity::total_cost(self : AlignmentIntegrity) -> Double

#
AlignmentKind

source
pub(all) enum AlignmentKind {
  AlignmentMatch
  AlignmentInsertion
  AlignmentDeletion
  AlignmentSubstitution
  AlignmentEquivalence
} derive(Eq, 
Debug)

Classification of one deterministic alignment step.

#
AlignmentStep

source
pub struct AlignmentStep {
  kind_value : AlignmentKind
  left_start_value : Int
  left_end_value : Int
  right_start_value : Int
  right_end_value : Int
  left_fragment_value : String
  right_fragment_value : String
  cost_value : Double
} derive(Eq, 
Debug)

One immutable step in a normalized Pinyin alignment.

#
AlignmentStep::cost

source
fn AlignmentStep::cost(self : AlignmentStep) -> Double

#
AlignmentStep::kind

source

#
AlignmentStep::left_end

source
fn AlignmentStep::left_end(self : AlignmentStep) -> Int

#
AlignmentStep::left_fragment

source
fn AlignmentStep::left_fragment(self : AlignmentStep) -> String

#
AlignmentStep::left_start

source
fn AlignmentStep::left_start(self : AlignmentStep) -> Int

#
AlignmentStep::right_end

source
fn AlignmentStep::right_end(self : AlignmentStep) -> Int

#
AlignmentStep::right_fragment

source
fn AlignmentStep::right_fragment(self : AlignmentStep) -> String

#
AlignmentStep::right_start

source
fn AlignmentStep::right_start(self : AlignmentStep) -> Int

#
AmbiguityPolicy

source
pub(all) enum AmbiguityPolicy {
  SelectFirstReading
  PreserveAllReadings
  RejectAmbiguous
} derive(Eq, 
Debug)

Controls how multiple documented readings are exposed.

#
BatchItem

source
pub struct BatchItem {
  identifier_value : String
  source_value : String
} derive(Eq, 
Debug)

One validated batch input with a caller-controlled stable identifier.

#
BatchItem::identifier

source
fn BatchItem::identifier(self : BatchItem) -> String

#
BatchItem::source

source
fn BatchItem::source(self : BatchItem) -> String

#
BatchItemResult

source
pub struct BatchItemResult {
  item_value : BatchItem
  outcome_value : BatchOutcome
} derive(Eq, 
Debug)

One auditable batch output in the same position as its input.

#
BatchItemResult::conversion

source

#
BatchItemResult::error

source

#
BatchItemResult::is_success

source
fn BatchItemResult::is_success(self : BatchItemResult) -> Bool

#
BatchItemResult::item

source

#
BatchItemResult::outcome

source

#
BatchOutcome

source
pub(all) enum BatchOutcome {
  BatchSucceeded(ConversionResult)
  BatchFailed(PinyinError)
} derive(Eq, 
Debug)

Per-item outcome; failures do not discard successful neighbors.

#
BatchResult

source
pub struct BatchResult {
  item_values : Array[BatchItemResult]
  summary_value : ConversionSummary
} derive(Eq, 
Debug)

Ordered per-item outcomes plus a precomputed summary.

#
BatchResult::items

source

#
BatchResult::summary

source

#
ConversionIntegrity

source
pub struct ConversionIntegrity {
  source_scalar_value : Int
  covered_scalar_value : Int
  dropped_scalar_value : Int
  token_value : Int
  candidate_value : Int
  diagnostic_value : Int
} derive(Eq, 
Debug)

Facts proven by validating one structured conversion result.

#
ConversionIntegrity::covered_scalars

source
fn ConversionIntegrity::covered_scalars(self : ConversionIntegrity) -> Int

#
ConversionIntegrity::diagnostics

source
fn ConversionIntegrity::diagnostics(self : ConversionIntegrity) -> Int

#
ConversionIntegrity::dropped_scalars

source
fn ConversionIntegrity::dropped_scalars(self : ConversionIntegrity) -> Int

#
ConversionIntegrity::has_full_coverage

source
fn ConversionIntegrity::has_full_coverage(self : ConversionIntegrity) -> Bool

#
ConversionIntegrity::source_scalars

source
fn ConversionIntegrity::source_scalars(self : ConversionIntegrity) -> Int

#
ConversionIntegrity::tokens

source
fn ConversionIntegrity::tokens(self : ConversionIntegrity) -> Int

#
ConversionIntegrity::validated_candidates

source
fn ConversionIntegrity::validated_candidates(self : ConversionIntegrity) -> Int

#
ConversionResult

source
pub struct ConversionResult {
  source_value : String
  rendered_value : String
  token_values : Array[ConvertedToken]
  diagnostic_values : Array[Diagnostic]
} derive(Eq, 
Debug)

Structured conversion result with output and decision evidence.

#
ConversionResult::diagnostics

source

#
ConversionResult::rendered

source
fn ConversionResult::rendered(self : ConversionResult) -> String

#
ConversionResult::source

source
fn ConversionResult::source(self : ConversionResult) -> String

#
ConversionResult::tokens

source

#
ConversionStats

source
pub struct ConversionStats {
  source_scalar_value : Int
  output_token_value : Int
  pinyin_token_value : Int
  literal_token_value : Int
  phrase_decision_value : Int
  unicode_decision_value : Int
  preserved_unknown_value : Int
  diagnostic_value : Int
  ambiguous_diagnostic_value : Int
} derive(Eq, 
Debug)

Counts derived from one immutable conversion result.

#
ConversionStats::ambiguous_diagnostics

source
fn ConversionStats::ambiguous_diagnostics(self : ConversionStats) -> Int

#
ConversionStats::diagnostics

source
fn ConversionStats::diagnostics(self : ConversionStats) -> Int

#
ConversionStats::literal_tokens

source
fn ConversionStats::literal_tokens(self : ConversionStats) -> Int

#
ConversionStats::output_tokens

source
fn ConversionStats::output_tokens(self : ConversionStats) -> Int

#
ConversionStats::phrase_decisions

source
fn ConversionStats::phrase_decisions(self : ConversionStats) -> Int

#
ConversionStats::pinyin_tokens

source
fn ConversionStats::pinyin_tokens(self : ConversionStats) -> Int

#
ConversionStats::preserved_unknown

source
fn ConversionStats::preserved_unknown(self : ConversionStats) -> Int

#
ConversionStats::source_scalars

source
fn ConversionStats::source_scalars(self : ConversionStats) -> Int

#
ConversionStats::unicode_decisions

source
fn ConversionStats::unicode_decisions(self : ConversionStats) -> Int

#
ConversionSummary

source
pub struct ConversionSummary {
  total_value : Int
  succeeded_value : Int
  failed_value : Int
  unknown_failure_value : Int
  ambiguous_failure_value : Int
  rendered_token_value : Int
  diagnostic_value : Int
} derive(Eq, 
Debug)

Aggregate conversion counts derived from item outcomes.

#
ConversionSummary::ambiguous_failures

source
fn ConversionSummary::ambiguous_failures(self : ConversionSummary) -> Int

#
ConversionSummary::diagnostics

source
fn ConversionSummary::diagnostics(self : ConversionSummary) -> Int

#
ConversionSummary::failed

source
fn ConversionSummary::failed(self : ConversionSummary) -> Int

#
ConversionSummary::rendered_tokens

source
fn ConversionSummary::rendered_tokens(self : ConversionSummary) -> Int

#
ConversionSummary::succeeded

source
fn ConversionSummary::succeeded(self : ConversionSummary) -> Int

#
ConversionSummary::total

source
fn ConversionSummary::total(self : ConversionSummary) -> Int

#
ConversionSummary::unknown_failures

source
fn ConversionSummary::unknown_failures(self : ConversionSummary) -> Int

#
ConvertOptions

source
pub struct ConvertOptions {
  output_style : ToneStyle
  token_separator : String
  output_case : TextCase
  unknown_behavior : UnknownPolicy
  ambiguity_behavior : AmbiguityPolicy
} derive(Eq, 
Debug)

Immutable options shared by conversion and rendering operations.

#
ConvertOptions::ambiguity_policy

source
fn ConvertOptions::ambiguity_policy(self : ConvertOptions) -> AmbiguityPolicy

#
ConvertOptions::separator

source
fn ConvertOptions::separator(self : ConvertOptions) -> String

#
ConvertOptions::text_case

source
fn ConvertOptions::text_case(self : ConvertOptions) -> TextCase

#
ConvertOptions::tone_style

source
fn ConvertOptions::tone_style(self : ConvertOptions) -> ToneStyle

#
ConvertOptions::unknown_policy

source
fn ConvertOptions::unknown_policy(self : ConvertOptions) -> UnknownPolicy

#
ConvertedToken

source
pub struct ConvertedToken {
  original_value : String
  rendered_value : String
  token_kind : TokenKind
  decision_value : DecisionSource
  source_span : SourceSpan
  candidate_values : Array[String]
} derive(Eq, 
Debug)

One auditable output token tied to a scalar span in the source.

#
ConvertedToken::candidates

source
fn ConvertedToken::candidates(self : ConvertedToken) -> Array[String]

#
ConvertedToken::decision_source

source
fn ConvertedToken::decision_source(self : ConvertedToken) -> DecisionSource

#
ConvertedToken::kind

source

#
ConvertedToken::original

source
fn ConvertedToken::original(self : ConvertedToken) -> String

#
ConvertedToken::rendered

source
fn ConvertedToken::rendered(self : ConvertedToken) -> String

#
ConvertedToken::span

source

#
DatasetStats

source
pub struct DatasetStats {
  code_point_count : Int
  reading_count : Int
  ambiguous_count : Int
  maximum_reading_count : Int
  first_code_value : Int
  last_code_value : Int
} derive(Eq, 
Debug)

Counts and boundaries proven by a full generated-data validation pass.

#
DatasetStats::ambiguous_code_points

source
fn DatasetStats::ambiguous_code_points(self : DatasetStats) -> Int

#
DatasetStats::code_points

source
fn DatasetStats::code_points(self : DatasetStats) -> Int

#
DatasetStats::first_code_point

source
fn DatasetStats::first_code_point(self : DatasetStats) -> Int

#
DatasetStats::last_code_point

source
fn DatasetStats::last_code_point(self : DatasetStats) -> Int

#
DatasetStats::maximum_readings_per_code_point

source
fn DatasetStats::maximum_readings_per_code_point(self : DatasetStats) -> Int

#
DatasetStats::readings

source
fn DatasetStats::readings(self : DatasetStats) -> Int

#
DecisionSource

source
pub(all) enum DecisionSource {
  PhraseLexicon
  UnicodeReading
  UnknownPreserved
} derive(Eq, 
Debug)

#
Diagnostic

source
pub struct Diagnostic {
  code_value : String
  message_value : String
  source_span : SourceSpan?
} derive(Eq, 
Debug)

Structured warning or decision note emitted by an operation.

#
Diagnostic::code

source
fn Diagnostic::code(self : Diagnostic) -> String

#
Diagnostic::message

source
fn Diagnostic::message(self : Diagnostic) -> String

#
Diagnostic::span

source
fn Diagnostic::span(self : Diagnostic) -> SourceSpan?

#
DistanceResult

source
pub struct DistanceResult {
  total_value : Double
  insertion_count : Int
  deletion_count : Int
  substitution_count : Int
  equivalence_count : Int
} derive(Eq, 
Debug)

Weighted distance and operation counts for auditability.

#
DistanceResult::cost

source
fn DistanceResult::cost(self : DistanceResult) -> Double

#
DistanceResult::deletions

source
fn DistanceResult::deletions(self : DistanceResult) -> Int

#
DistanceResult::equivalences

source
fn DistanceResult::equivalences(self : DistanceResult) -> Int

#
DistanceResult::insertions

source
fn DistanceResult::insertions(self : DistanceResult) -> Int

#
DistanceResult::operations

source
fn DistanceResult::operations(self : DistanceResult) -> Int

#
DistanceResult::substitutions

source
fn DistanceResult::substitutions(self : DistanceResult) -> Int

#
FuzzyProfile

source
pub struct FuzzyProfile {
  insertion_value : Double
  deletion_value : Double
  substitution_value : Double
  equivalence_value : Double
  rule_values : FuzzyRules
} derive(Eq, 
Debug)

Validated edit costs and equivalence rules.

#
FuzzyProfile::deletion_cost

source
fn FuzzyProfile::deletion_cost(self : FuzzyProfile) -> Double

#
FuzzyProfile::equivalence_cost

source
fn FuzzyProfile::equivalence_cost(self : FuzzyProfile) -> Double

#
FuzzyProfile::insertion_cost

source
fn FuzzyProfile::insertion_cost(self : FuzzyProfile) -> Double

#
FuzzyProfile::rules

source
fn FuzzyProfile::rules(self : FuzzyProfile) -> FuzzyRules

#
FuzzyProfile::substitution_cost

source
fn FuzzyProfile::substitution_cost(self : FuzzyProfile) -> Double

#
FuzzyRules

source
pub struct FuzzyRules {
  zh_z_enabled : Bool
  ch_c_enabled : Bool
  sh_s_enabled : Bool
  n_l_enabled : Bool
} derive(Eq, 
Debug)

Switches for common Pinyin input confusions.

#
FuzzyRules::ch_c_enabled

source
fn FuzzyRules::ch_c_enabled(self : FuzzyRules) -> Bool

#
FuzzyRules::n_l_enabled

source
fn FuzzyRules::n_l_enabled(self : FuzzyRules) -> Bool

#
FuzzyRules::sh_s_enabled

source
fn FuzzyRules::sh_s_enabled(self : FuzzyRules) -> Bool

#
FuzzyRules::zh_z_enabled

source
fn FuzzyRules::zh_z_enabled(self : FuzzyRules) -> Bool

#
IndexKey

source
pub struct IndexKey {
  key_text : String
  profile_value : IndexProfile
  segment_values : Array[IndexSegment]
} derive(Eq, 
Debug)

A normalized key plus auditable source mapping.

#
IndexKey::key

source
fn IndexKey::key(self : IndexKey) -> String

#
IndexKey::profile

source
fn IndexKey::profile(self : IndexKey) -> IndexProfile

#
IndexKey::segments

source
fn IndexKey::segments(self : IndexKey) -> Array[IndexSegment]

#
IndexProfile

source
pub(all) enum IndexProfile {
  ExactNormalized
  FullPinyin
  Initials
  Compact
} derive(Eq, 
Debug)

Selects one deterministic search-key representation.

#
IndexSegment

source
pub struct IndexSegment {
  value_text : String
  source_span : SourceSpan
  source_kind : TokenKind
} derive(Eq, 
Debug)

One search-key fragment tied to its original source span.

#
IndexSegment::kind

source
fn IndexSegment::kind(self : IndexSegment) -> TokenKind

#
IndexSegment::span

source

#
IndexSegment::value

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

#
Lexicon

source
pub struct Lexicon {
  nodes : Array[LexiconNode]
  values : Array[LexiconEntry]
}

Immutable phrase resolver backed by a flattened Trie.

#
Lexicon::longest_match

source
fn Lexicon::longest_match(self : Lexicon, source : Array[Int], start : Int) -> LexiconMatch?

Returns the longest phrase beginning at a scalar offset.

#
LexiconBuilder

source
pub struct LexiconBuilder {
  values : Array[LexiconEntry]
}

Mutable construction surface with validation on every insertion.

#
LexiconBuilder::add

source
fn LexiconBuilder::add(self : LexiconBuilder, phrase : String, readings : Array[String]) -> Result[Unit, PinyinError]

Adds one phrase after validating scalar and reading counts.

#
LexiconBuilder::build

source

Freezes entries into deterministic Trie nodes.

#
LexiconBuilder::new

source

#
LexiconEntry

source
type LexiconEntry derive(Eq, 
Debug)

#
LexiconMatch

source
pub struct LexiconMatch {
  phrase_value : String
  consumed : Int
  reading_values : Array[Syllable]
} derive(Eq, 
Debug)

Evidence returned for one longest phrase match.

#
LexiconMatch::length

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

#
LexiconMatch::phrase

source
fn LexiconMatch::phrase(self : LexiconMatch) -> String

#
LexiconMatch::readings

source
fn LexiconMatch::readings(self : LexiconMatch) -> Array[Syllable]

#
LexiconNode

source
type LexiconNode

#
MatchCandidate

source
pub struct MatchCandidate {
  label_text : String
  full_key_value : IndexKey
  initials_key_value : IndexKey
} derive(Eq, 
Debug)

Precomputed searchable representations for one caller-labelled value.

#
MatchCandidate::full_key

source
fn MatchCandidate::full_key(self : MatchCandidate) -> IndexKey

#
MatchCandidate::initials_key

source
fn MatchCandidate::initials_key(self : MatchCandidate) -> IndexKey

#
MatchCandidate::label

source
fn MatchCandidate::label(self : MatchCandidate) -> String

#
MatchExplanation

source
pub struct MatchExplanation {
  query_text : String
  full_key_text : String
  initials_key_text : String
  exact_value : Double
  prefix_value : Double
  initials_value : Double
  fuzzy_value : Double
  final_value : Double
  distance_value : DistanceResult
} derive(Eq, 
Debug)

Score components and fuzzy-distance evidence for one candidate.

#
MatchExplanation::distance

source

#
MatchExplanation::exact_component

source
fn MatchExplanation::exact_component(self : MatchExplanation) -> Double

#
MatchExplanation::full_key

source
fn MatchExplanation::full_key(self : MatchExplanation) -> String

#
MatchExplanation::fuzzy_component

source
fn MatchExplanation::fuzzy_component(self : MatchExplanation) -> Double

#
MatchExplanation::initials_component

source
fn MatchExplanation::initials_component(self : MatchExplanation) -> Double

#
MatchExplanation::initials_key

source
fn MatchExplanation::initials_key(self : MatchExplanation) -> String

#
MatchExplanation::prefix_component

source
fn MatchExplanation::prefix_component(self : MatchExplanation) -> Double

#
MatchExplanation::query

source
fn MatchExplanation::query(self : MatchExplanation) -> String

#
MatchExplanation::score

source
fn MatchExplanation::score(self : MatchExplanation) -> Double

#
Orthography

source
pub(all) enum Orthography {
  PlainInput
  ToneNumberInput
  ToneMarkInput
} derive(Eq, 
Debug)

Records the notation recognized by the parser.

#
PinyinAlignment

source
pub struct PinyinAlignment {
  left_normalized_value : String
  right_normalized_value : String
  step_values : Array[AlignmentStep]
  total_cost_value : Double
  match_count : Int
  insertion_count : Int
  deletion_count : Int
  substitution_count : Int
  equivalence_count : Int
} derive(Eq, 
Debug)

Ordered edit evidence and aggregate operation counts.

#
PinyinAlignment::deletions

source
fn PinyinAlignment::deletions(self : PinyinAlignment) -> Int

#
PinyinAlignment::equivalences

source
fn PinyinAlignment::equivalences(self : PinyinAlignment) -> Int

#
PinyinAlignment::insertions

source
fn PinyinAlignment::insertions(self : PinyinAlignment) -> Int

#
PinyinAlignment::left_normalized

source
fn PinyinAlignment::left_normalized(self : PinyinAlignment) -> String

#
PinyinAlignment::matches

source
fn PinyinAlignment::matches(self : PinyinAlignment) -> Int

#
PinyinAlignment::operations

source
fn PinyinAlignment::operations(self : PinyinAlignment) -> Int

#
PinyinAlignment::right_normalized

source
fn PinyinAlignment::right_normalized(self : PinyinAlignment) -> String

#
PinyinAlignment::steps

source

#
PinyinAlignment::substitutions

source
fn PinyinAlignment::substitutions(self : PinyinAlignment) -> Int

#
PinyinAlignment::total_cost

source
fn PinyinAlignment::total_cost(self : PinyinAlignment) -> Double

#
PinyinError

source
pub(all) enum PinyinError {
  InvalidSeparator(String)
  InvalidSyllable(String, String)
  UnknownCharacter(Int)
  AmbiguousCharacter(Int, Int)
  InvalidSourceSpan(Int, Int)
  InvalidLexiconEntry(String, String)
  ConflictingLexiconEntry(String)
  InvalidLexiconText(String)
  InvalidBatchItem(String, String)
  InvalidSearchDocument(String, String)
  InvalidSearchOptions(String, String)
  InvalidSearchQuery(String)
  InvalidVariantLimit(Int)
  InvalidConversionResult(String)
  InvalidAlignment(String)
  InvalidWeight(String, Double)
  InvalidGeneratedData(String)
} derive(Eq, 
Debug)

Stable errors returned by parsing, configuration, and conversion APIs.

#
PinyinProcessor

source
pub struct PinyinProcessor {
  lexicon_value : Lexicon
  conversion_value : ConvertOptions
  fuzzy_value : FuzzyProfile
}

Reusable immutable configuration for common toolkit operations.

#
PinyinProcessor::candidate

source
fn PinyinProcessor::candidate(self : PinyinProcessor, identifier : String, source : String) -> Result[MatchCandidate, PinyinError]

#
PinyinProcessor::compare

source
fn PinyinProcessor::compare(self : PinyinProcessor, left : String, right : String) -> Result[TextComparison, PinyinError]

#
PinyinProcessor::conversion_options

source
fn PinyinProcessor::conversion_options(self : PinyinProcessor) -> ConvertOptions

#
PinyinProcessor::convert

source
fn PinyinProcessor::convert(self : PinyinProcessor, source : String) -> Result[ConversionResult, PinyinError]

#
PinyinProcessor::fuzzy_profile

source
fn PinyinProcessor::fuzzy_profile(self : PinyinProcessor) -> FuzzyProfile

#
PinyinProcessor::inspect

source
fn PinyinProcessor::inspect(self : PinyinProcessor, source : String) -> ReadingInspection

#
PinyinProcessor::variants

source
fn PinyinProcessor::variants(self : PinyinProcessor, source : String, style : ToneStyle, separator : String, limit : Int) -> Result[VariantExpansion, PinyinError]

#
RankedCandidate

source
pub struct RankedCandidate {
  candidate_value : MatchCandidate
  explanation_value : MatchExplanation
  caller_position : Int
} derive(Eq, 
Debug)

One ranked result retaining the caller's original position.

#
RankedCandidate::explanation

source

#
RankedCandidate::label

source
fn RankedCandidate::label(self : RankedCandidate) -> String

#
RankedCandidate::original_position

source
fn RankedCandidate::original_position(self : RankedCandidate) -> Int

#
RankedCandidate::score

source
fn RankedCandidate::score(self : RankedCandidate) -> Double

#
ReadingInspection

source
pub struct ReadingInspection {
  entry_values : Array[ScalarReadingEvidence]
  known_value : Int
  unknown_value : Int
  ambiguous_value : Int
} derive(Eq, 
Debug)

Ordered scalar evidence and aggregate lookup counts.

#
ReadingInspection::ambiguous_scalars

source
fn ReadingInspection::ambiguous_scalars(self : ReadingInspection) -> Int

#
ReadingInspection::entries

source

#
ReadingInspection::known_scalars

source
fn ReadingInspection::known_scalars(self : ReadingInspection) -> Int

#
ReadingInspection::total_scalars

source
fn ReadingInspection::total_scalars(self : ReadingInspection) -> Int

#
ReadingInspection::unknown_scalars

source
fn ReadingInspection::unknown_scalars(self : ReadingInspection) -> Int

#
ReadingSet

source
pub struct ReadingSet {
  code_value : Int
  readings_value : Array[String]
} derive(Eq, 
Debug)

Readings attached to one Unicode scalar value.

#
ReadingSet::code_point

source
fn ReadingSet::code_point(self : ReadingSet) -> Int

#
ReadingSet::is_ambiguous

source
fn ReadingSet::is_ambiguous(self : ReadingSet) -> Bool

#
ReadingSet::readings

source
fn ReadingSet::readings(self : ReadingSet) -> Array[String]

#
ScalarReadingEvidence

source
pub struct ScalarReadingEvidence {
  code_value : Int
  original_value : String
  source_span : SourceSpan
  candidate_values : Array[String]
} derive(Eq, 
Debug)

Reading evidence for one Unicode scalar from the source text.

#
ScalarReadingEvidence::candidates

source
fn ScalarReadingEvidence::candidates(self : ScalarReadingEvidence) -> Array[String]

#
ScalarReadingEvidence::code_point

source
fn ScalarReadingEvidence::code_point(self : ScalarReadingEvidence) -> Int

#
ScalarReadingEvidence::is_ambiguous

source
fn ScalarReadingEvidence::is_ambiguous(self : ScalarReadingEvidence) -> Bool

#
ScalarReadingEvidence::is_known

source
fn ScalarReadingEvidence::is_known(self : ScalarReadingEvidence) -> Bool

#
ScalarReadingEvidence::original

source
fn ScalarReadingEvidence::original(self : ScalarReadingEvidence) -> String

#
ScalarReadingEvidence::span

source

#
SearchDocument

source
type SearchDocument

#
SearchHit

source
pub struct SearchHit {
  identifier_value : String
  source_value : String
  explanation_value : MatchExplanation
  source_position : Int
} derive(Eq, 
Debug)

One ranked hit with source text and score evidence.

#
SearchHit::explanation

source
fn SearchHit::explanation(self : SearchHit) -> MatchExplanation

#
SearchHit::identifier

source
fn SearchHit::identifier(self : SearchHit) -> String

#
SearchHit::original_position

source
fn SearchHit::original_position(self : SearchHit) -> Int

#
SearchHit::score

source
fn SearchHit::score(self : SearchHit) -> Double

#
SearchHit::source

source
fn SearchHit::source(self : SearchHit) -> String

#
SearchIndex

source
pub struct SearchIndex {
  document_values : Array[SearchDocument]
}

Immutable collection of precomputed Pinyin match candidates.

#
SearchIndex::length

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

#
SearchIndex::search

source
fn SearchIndex::search(self : SearchIndex, query : String, options : SearchOptions, profile : FuzzyProfile) -> Result[Array[SearchHit], PinyinError]

Queries precomputed candidates with stable caller-order tie breaking.

#
SearchIndexBuilder

source
pub struct SearchIndexBuilder {
  document_values : Array[SearchDocument]
}

Mutable validated builder for a reusable search index.

#
SearchIndexBuilder::add

source
fn SearchIndexBuilder::add(self : SearchIndexBuilder, identifier : String, source : String, lexicon : Lexicon, options : ConvertOptions) -> Result[Unit, PinyinError]

Converts and precomputes one document before inserting it.

#
SearchIndexBuilder::build

source

Freezes the current insertion order into an immutable index.

#
SearchIndexBuilder::length

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

#
SearchIndexBuilder::new

source

#
SearchOptions

source
pub struct SearchOptions {
  limit_value : Int
  minimum_score_value : Double
} derive(Eq, 
Debug)

Query limits and minimum accepted score.

#
SearchOptions::limit

source
fn SearchOptions::limit(self : SearchOptions) -> Int

#
SearchOptions::minimum_score

source
fn SearchOptions::minimum_score(self : SearchOptions) -> Double

#
SourceSpan

source
pub struct SourceSpan {
  start_offset : Int
  end_offset : Int
} derive(Eq, 
Debug)

Half-open character offsets in the caller's source text.

#
SourceSpan::end

source
fn SourceSpan::end(self : SourceSpan) -> Int

#
SourceSpan::length

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

#
SourceSpan::start

source
fn SourceSpan::start(self : SourceSpan) -> Int

#
Syllable

source
pub struct Syllable {
  base_value : String
  initial_value : String
  final_value : String
  tone_value : Int
  input_form : Orthography
} derive(Eq, 
Debug)

A validated Pinyin syllable in canonical lowercase form.

#
Syllable::final_part

source
fn Syllable::final_part(self : Syllable) -> String

#
Syllable::format

source
fn Syllable::format(self : Syllable, style : ToneStyle, text_case : TextCase) -> String

#
Syllable::initial

source
fn Syllable::initial(self : Syllable) -> String

#
Syllable::orthography

source
fn Syllable::orthography(self : Syllable) -> Orthography

#
Syllable::plain

source
fn Syllable::plain(self : Syllable) -> String

#
Syllable::tone_number

source
fn Syllable::tone_number(self : Syllable) -> Int

#
TextCase

source
pub(all) enum TextCase {
  Lowercase
  Uppercase
} derive(Eq, 
Debug)

Controls casing after a syllable has been normalized.

#
TextComparison

source
pub struct TextComparison {
  left_result : ConversionResult
  right_result : ConversionResult
  left_key_value : String
  right_key_value : String
  left_initials_value : String
  right_initials_value : String
  distance_value : DistanceResult
  similarity_value : Double
  forward_score_value : MatchExplanation
  reverse_score_value : MatchExplanation
} derive(Eq, 
Debug)

Symmetric key comparison plus both original conversion results.

#
TextComparison::distance

source

#
TextComparison::forward_score

source
fn TextComparison::forward_score(self : TextComparison) -> MatchExplanation

#
TextComparison::left_conversion

source
fn TextComparison::left_conversion(self : TextComparison) -> ConversionResult

#
TextComparison::left_initials

source
fn TextComparison::left_initials(self : TextComparison) -> String

#
TextComparison::left_key

source
fn TextComparison::left_key(self : TextComparison) -> String

#
TextComparison::reverse_score

source
fn TextComparison::reverse_score(self : TextComparison) -> MatchExplanation

#
TextComparison::right_conversion

source
fn TextComparison::right_conversion(self : TextComparison) -> ConversionResult

#
TextComparison::right_initials

source
fn TextComparison::right_initials(self : TextComparison) -> String

#
TextComparison::right_key

source
fn TextComparison::right_key(self : TextComparison) -> String

#
TextComparison::same_full_pinyin

source
fn TextComparison::same_full_pinyin(self : TextComparison) -> Bool

#
TextComparison::same_initials

source
fn TextComparison::same_initials(self : TextComparison) -> Bool

#
TextComparison::similarity

source
fn TextComparison::similarity(self : TextComparison) -> Double

#
TokenKind

source
pub(all) enum TokenKind {
  PinyinToken
  LiteralToken
} derive(Eq, 
Debug)

#
ToneStyle

source
pub(all) enum ToneStyle {
  ToneMarks
  ToneNumbers
  PlainPinyin
} derive(Eq, 
Debug)

Selects the rendered representation of a Pinyin syllable.

#
UnknownPolicy

source
pub(all) enum UnknownPolicy {
  PreserveUnknown
  DropUnknown
  RejectUnknown
} derive(Eq, 
Debug)

Controls how text without a known Pinyin reading is handled.

#
VariantExpansion

source
pub struct VariantExpansion {
  variant_values : Array[String]
  truncated_value : Bool
} derive(Eq, 
Debug)

Bounded candidate strings produced from recorded token readings.

#
VariantExpansion::generated

source
fn VariantExpansion::generated(self : VariantExpansion) -> Int

#
VariantExpansion::truncated

source
fn VariantExpansion::truncated(self : VariantExpansion) -> Bool

#
VariantExpansion::values

source
fn VariantExpansion::values(self : VariantExpansion) -> Array[String]

#
align_pinyin

source
fn align_pinyin(left_input : String, right_input : String, profile : FuzzyProfile) -> PinyinAlignment

Aligns two normalized Pinyin inputs with deterministic edit evidence.

#
analyze_conversion

source
fn analyze_conversion(result : ConversionResult) -> ConversionStats

Summarizes token decisions without rerunning conversion.

#
batch_item

source
fn batch_item(identifier : String, source : String) -> Result[BatchItem, PinyinError]

#
batch_report_json

source
fn batch_report_json(result : BatchResult) -> String

Produces stable compact JSON using a structured encoder.

#
batch_report_text

source
fn batch_report_text(result : BatchResult) -> String

Produces a stable line-oriented report in caller input order.

#
code_points_text

source
fn code_points_text(values : Array[Int]) -> String

Encodes Unicode scalar values as MoonBit strings.

#
compare_texts

source
fn compare_texts(left_source : String, right_source : String, lexicon : Lexicon, options : ConvertOptions, profile : FuzzyProfile) -> Result[TextComparison, PinyinError]

Converts and compares two texts with the same explicit configuration.

#
conversion_report_json

source
fn conversion_report_json(result : ConversionResult) -> String

Emits conversion tokens, decisions, candidates, spans, and diagnostics.

#
convert_batch

source
fn convert_batch(items : Array[BatchItem], lexicon : Lexicon, options : ConvertOptions) -> BatchResult

Converts all items without short-circuiting after an item failure.

#
convert_options

source
fn convert_options(style : ToneStyle, separator : String, text_case : TextCase, unknown_policy : UnknownPolicy, ambiguity_policy : AmbiguityPolicy) -> Result[ConvertOptions, PinyinError]

Builds a validated conversion configuration.

#
convert_text

source
fn convert_text(source : String, lexicon : Lexicon, options : ConvertOptions) -> Result[ConversionResult, PinyinError]

Converts mixed text using phrase overrides before Unicode character lookup.

#
default_convert_options

source
fn default_convert_options() -> ConvertOptions

Returns conservative display defaults without hiding ambiguity metadata.

#
default_fuzzy_profile

source
fn default_fuzzy_profile() -> FuzzyProfile

#
default_fuzzy_rules

source
fn default_fuzzy_rules() -> FuzzyRules

#
default_pinyin_processor

source
fn default_pinyin_processor() -> PinyinProcessor

#
default_search_options

source
fn default_search_options() -> SearchOptions

#
diagnostic

source
fn diagnostic(code : String, message : String, span : SourceSpan?) -> Diagnostic

Creates a structured diagnostic without interpreting its message.

#
expand_conversion_variants

source
fn expand_conversion_variants(result : ConversionResult, style : ToneStyle, separator : String, limit : Int) -> Result[VariantExpansion, PinyinError]

Expands recorded alternatives without performing contextual inference.

#
fuzzy_profile

source
fn fuzzy_profile(insertion : Double, deletion : Double, substitution : Double, equivalence : Double) -> Result[FuzzyProfile, PinyinError]

Builds a profile with the standard Pinyin equivalence groups enabled.

#
fuzzy_profile_with_rules

source
fn fuzzy_profile_with_rules(insertion : Double, deletion : Double, substitution : Double, equivalence : Double, rules : FuzzyRules) -> Result[FuzzyProfile, PinyinError]

Builds a profile with caller-selected Pinyin equivalence groups.

#
fuzzy_rules

source
fn fuzzy_rules(zh_z : Bool, ch_c : Bool, sh_s : Bool, n_l : Bool) -> FuzzyRules

#
generate_index_key

source
fn generate_index_key(converted : ConversionResult, profile : IndexProfile) -> IndexKey

Generates a deterministic search key from an existing conversion result.

#
inspect_text_readings

source
fn inspect_text_readings(source : String) -> ReadingInspection

Inspects Unicode readings without applying phrase or ambiguity policies.

#
lexicon_from_text

source
fn lexicon_from_text(text : String) -> Result[Lexicon, PinyinError]

Imports the stable text format through the same LexiconBuilder validation.

#
lexicon_to_text

source
fn lexicon_to_text(lexicon : Lexicon) -> String

Exports entries in stable insertion order for reviewable configuration.

#
lookup_readings

source
fn lookup_readings(code_point : Int) -> ReadingSet?

Finds a sorted code point in the generated Unicode table.

#
match_candidate

source
fn match_candidate(label : String, converted : ConversionResult) -> MatchCandidate

Builds search representations once for repeated queries.

#
package_version

source
fn package_version() -> String

Return the package release version.

#
parse_syllable

source
fn parse_syllable(input : String) -> Result[Syllable, PinyinError]

Parses plain, numbered, or precomposed tone-mark Pinyin.

#
pinyin_processor

source
fn pinyin_processor(lexicon : Lexicon, options : ConvertOptions, fuzzy : FuzzyProfile) -> PinyinProcessor

#
rank_matches

source
fn rank_matches(query : String, candidates : Array[MatchCandidate], profile : FuzzyProfile) -> Array[RankedCandidate]

Ranks candidates by descending score and preserves caller order for ties.

#
reading_inspection_report_json

source
fn reading_inspection_report_json(inspection : ReadingInspection) -> String

Emits source coverage and per-scalar Unicode reading candidates.

#
score_match

source
fn score_match(query_input : String, candidate : MatchCandidate, profile : FuzzyProfile) -> MatchExplanation

Scores one candidate and returns independently inspectable components.

#
search_hits_report_json

source
fn search_hits_report_json(query : String, hits : Array[SearchHit]) -> String

Emits ranked hits and all score components in stable order.

#
search_options

source
fn search_options(limit : Int, minimum_score : Double) -> Result[SearchOptions, PinyinError]

#
select_reading

source
fn select_reading(code_point : Int, policy : AmbiguityPolicy) -> Result[String, PinyinError]

Selects a reading while making the ambiguity policy observable.

#
source_span

source
fn source_span(start : Int, end : Int) -> Result[SourceSpan, PinyinError]

Creates a validated half-open source span.

#
text_code_points

source
fn text_code_points(text : String) -> Array[Int]

Decodes UTF-16 storage into Unicode scalar values, preserving unpaired units.

#
unihan_data_license

source
fn unihan_data_license() -> String

SPDX identifier governing bundled generated Unicode data.

#
unihan_entry_total

source
fn unihan_entry_total() -> Int

Number of code points with at least one selected reading.

#
unihan_source_sha256

source
fn unihan_source_sha256() -> String

SHA-256 of the exact official Unihan source archive.

#
unihan_version

source
fn unihan_version() -> String

Unicode release used to generate the bundled reading tables.

#
validate_conversion_result

source
fn validate_conversion_result(result : ConversionResult) -> Result[ConversionIntegrity, PinyinError]

Validates spans, token decisions, and candidate syllables without rerunning conversion.

#
validate_pinyin_alignment

source
fn validate_pinyin_alignment(alignment : PinyinAlignment, profile : FuzzyProfile) -> Result[AlignmentIntegrity, PinyinError]

Validates path continuity, fragments, enabled rules, costs, and counters.

#
validate_unihan_dataset

source
fn validate_unihan_dataset() -> Result[DatasetStats, PinyinError]

Validates every bundled code point and reading, then returns dataset facts.

#
weighted_pinyin_distance

source
fn weighted_pinyin_distance(left_input : String, right_input : String, profile : FuzzyProfile) -> DistanceResult

Computes weighted Levenshtein distance with optional Pinyin initial rules.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io