🥮 mooncakes.io

moonbit-icd

MoonBit ICD-10/ICD-11 parsing, catalog queries, delimited import, batch validation, deterministic reports, and CLI workflows.

icd
healthcare
validation
catalog
cli
parser
moon add Ycq-68798/moonbit-icd@0.2.2
Download zip
Author
Version
0.2.2
License
Apache-2.0
Repository
Last updated
4 hours ago
Downloads
5
README

#moonbit-icd

moonbit-icd is a reusable MoonBit toolkit for structured ICD coding workflows. It covers code normalization and parsing, chapter/range resolution, catalog queries, authorized data import/export, batch validation, deterministic reports, and a small icd-check command-line interface.

The library is designed for health-information prototypes, claims-data preprocessing, research annotation, teaching tools, and other software that needs structural coding checks. It is not a diagnostic system and does not replace jurisdiction-specific coding guidance.

#Core capabilities

  • Strict ICD-10 category/subcategory parsing and ICD-11 stem/extension parsing.
  • Canonical normalization for user-entered codes and safe invalid-input errors.
  • ICD-10 chapter boundaries, code ranges, overlap checks, and partitioning.
  • Catalog construction with duplicate, chapter, parent, and exclusion checks.
  • Exact, prefix, title, chapter, hierarchy, exclusion, and ranked-search queries.
  • CSV/TSV import/export with quoted-field support and line/column diagnostics.
  • Batch validation with valid/unknown/invalid counts and chapter distributions.
  • Text, TSV, and JSON-like deterministic report rendering.
  • A representative, hand-authored fixture catalog used by tests and examples.

#Quick start

Install the MoonBit toolchain, then run the project from its module root:

moon check --target all --deny-warn
moon test --target all --deny-warn
moon run cmd/main -- check I10
moon run cmd/main -- chapter J45
moon run cmd/main -- prefix A00
moon run cmd/main -- search diabetes
moon run cmd/main -- batch I10,B20,bad
moon run cmd/main -- stats

The package namespace is Ycq-68798/moonbit-icd. A consumer can depend on the module through moon.mod and use the public root package APIs.

#Library example

///|
test {
  let code = parse_icd10(" a00.0 ")
  inspect(code.canonical(), content="A00.0")

  let report = validate_icd10("B20")
  debug_inspect(report.status, content="Valid")
  assert_true(format_report(report).contains("exclusion hint"))
}

For an application-provided catalog, construct entries with IcdEntry::new, validate it with Catalog::from_entries, and then call validate_against or validate_batch. import_entries accepts the same six-column schema emitted by export_entries:

code,title,chapter_id,parent,excludes,note
I10,Essential hypertension,IX,,,example

#CLI

The executable is intentionally thin and delegates to the library:

moon run cmd/main -- check I10
moon run cmd/main -- chapter J45
moon run cmd/main -- prefix A00
moon run cmd/main -- search diabetes
moon run cmd/main -- batch I10,B20,bad
moon run cmd/main -- stats

check distinguishes invalid syntax, syntactically valid codes absent from the current catalog, and catalog entries that are valid for the structural workflow. batch keeps input order so callers can correlate each result with an imported row.

#Architecture

AreaFilesResponsibility
Domain modeltypes.mbt, errors.mbtPublic records, statuses, and errors
Parsingnormalization.mbt, parser.mbtCanonical forms and ICD syntax
Rangesranges.mbt, range_tools.mbtChapters, rank boundaries, partitions
Catalogcatalog*.mbt, advanced_query.mbtInvariants, queries, search, fixtures
Data pipelinedelimited_reader.mbt, delimited_writer.mbtCSV/TSV import and export
Validationvalidate.mbt, batch_validation.mbt, validation_policy.mbtSingle and batch workflows
Reportinganalytics.mbt, report_rendering.mbt, data_quality.mbtMetrics, audits, deterministic output
Executablescmd/main, cmd/benchmarkCLI usage and reproducible workload

The root package has no external dependencies. This keeps consumers free to choose their own data source and serialization boundary.

#Data boundary and licensing

The repository contains representative hand-authored fixtures for software behavior, not a complete official ICD release. It does not redistribute a full WHO, ICD-10-CM, or national table. Production deployments should import data that they are authorized to use and should preserve that data's jurisdiction, version, attribution, and license metadata.

Repository source is licensed under Apache-2.0. See DATA-SOURCES.md for provenance and redistribution guidance.

#Benchmark

Run the deterministic benchmark workload locally:

moon run cmd/benchmark -- --rounds 1000

The command reports the actual rounds, workload size, status totals, and a checksum. It is paired with an external wall-clock measurement so results can be reproduced on a stated toolchain and machine; see BENCHMARKS.md.

#Testing and CI

Local checks matching CI are:

moon version --all
moon update
moon fmt --check
moon check --target all --deny-warn
moon test --target all --deny-warn
moon test --target native --enable-coverage --deny-warn
moon info
git diff --exit-code

GitHub Actions runs the MoonBit stable installer on Ubuntu, macOS, and Windows, checks all supported backends, runs native coverage where available, and rejects formatting or generated-interface drift.

#Contributing

See CONTRIBUTING.md for the development loop, test expectations, and data-source requirements. Bug reports should include the smallest reproducible code, toolchain version, target backend, and command output. Never include private clinical records or other sensitive data.

#License

Apache-2.0. See LICENSE.

#
CatalogError

source
pub(all) suberror CatalogError {
  DuplicateCode(String)
  InvalidEntry(String, String)
  MissingReference(String, String)
} derive(Eq, ToJson, 
Debug)

#
IcdParseError

source
pub(all) suberror IcdParseError {
  EmptyInput
  UnsupportedEdition(String)
  InvalidCode(String)
} derive(Eq, ToJson, 
Debug)

#
BatchItem

source
pub struct BatchItem {
  line : Int
  input : String
  report : ValidationReport
} derive(Eq, ToJson, 
Debug)

#
BatchReport

source
pub struct BatchReport {
  items : Array[BatchItem]
  summary : BatchSummary
} derive(Eq, ToJson, 
Debug)

#
BatchSummary

source
pub struct BatchSummary {
  total : Int
  valid : Int
  unknown : Int
  invalid : Int
  chapters : Array[ChapterCount]
} derive(Eq, ToJson, 
Debug)

#
Catalog

source
pub struct Catalog {
  entries : Array[IcdEntry]
} derive(
Debug)

#
Catalog::all

source
fn Catalog::all(self : Catalog) -> Array[IcdEntry]

#
Catalog::ancestors

source
fn Catalog::ancestors(self : Catalog, code : String) -> Array[IcdEntry]

#
Catalog::children

source
fn Catalog::children(self : Catalog, parent : String) -> Array[IcdEntry]

#
Catalog::exclusions

source
fn Catalog::exclusions(self : Catalog, code : String) -> Array[IcdEntry]

#
Catalog::from_entries

source
fn Catalog::from_entries(entries : Array[IcdEntry]) -> Catalog raise CatalogError

#
Catalog::in_chapter

source
fn Catalog::in_chapter(self : Catalog, chapter_id : String) -> Array[IcdEntry]

#
Catalog::len

source
fn Catalog::len(self : Catalog) -> Int

#
Catalog::lookup

source
fn Catalog::lookup(self : Catalog, code : String) -> IcdEntry?

#
Catalog::prefix

source
fn Catalog::prefix(self : Catalog, prefix : String) -> Array[IcdEntry]

fn Catalog::ranked_search(self : Catalog, query : String, limit : Int) -> Array[SearchHit]

#
Catalog::search_title

source
fn Catalog::search_title(self : Catalog, query : String) -> Array[IcdEntry]

#
CatalogAudit

source
pub struct CatalogAudit {
  entries : Int
  chapter_coverage : Int
  missing_parents : Int
  missing_exclusions : Int
  duplicate_codes : Int
  invalid_codes : Int
} derive(Eq, ToJson, 
Debug)

#
CatalogAudit::is_healthy

source
fn CatalogAudit::is_healthy(self : CatalogAudit) -> Bool

#
ChapterCount

source
pub struct ChapterCount {
  chapter_id : String
  total : Int
  valid : Int
  unknown : Int
  invalid : Int
} derive(Eq, ToJson, 
Debug)

#
CodeRange

source
pub struct CodeRange {
  start : String
  end : String
  start_rank : Int
  end_rank : Int
} derive(Eq, ToJson, 
Debug)

#
CodeRange::contains

source
fn CodeRange::contains(self : CodeRange, code : String) -> Bool

#
CodeRange::new

source
fn CodeRange::new(start : String, end : String) -> CodeRange raise IcdParseError

#
CodeRange::overlaps

source
fn CodeRange::overlaps(self : CodeRange, other : CodeRange) -> Bool

#
CodeRange::partition

source
fn CodeRange::partition(self : CodeRange, codes : Array[String]) -> RangePartition

#
Delimiter

source
pub enum Delimiter {
  Comma
  Tab
} derive(Eq, ToJson, 
Debug)

#
Delimiter::comma

source
fn Delimiter::comma() -> Delimiter

#
Delimiter::tab

source
fn Delimiter::tab() -> Delimiter

#
IcdChapter

source
pub struct IcdChapter {
  id : String
  title : String
  start : String
  end : String
  note : String
} derive(Eq, ToJson, 
Debug)

#
IcdChapter::contains

source
fn IcdChapter::contains(self : IcdChapter, code : IcdCode) -> Bool

#
IcdCode

source
pub struct IcdCode {
  edition : IcdEdition
  raw : String
  stem : String
  category : String
  subcategory : String?
  numeric : Int
  extension : String?
} derive(Eq, ToJson, 
Debug)

#
IcdCode::canonical

source
fn IcdCode::canonical(self : IcdCode) -> String

#
IcdEdition

source
pub enum IcdEdition {
  ICD10
  ICD11
} derive(Eq, ToJson, 
Debug)

#
IcdEntry

source
pub struct IcdEntry {
  code : String
  title : String
  chapter_id : String
  parent : String?
  excludes : Array[String]
  note : String
} derive(Eq, ToJson, 
Debug)

#
IcdEntry::new

source
fn IcdEntry::new(code : String, title : String, chapter_id : String, parent : String?, excludes : Array[String], note : String) -> IcdEntry

#
ImportDiagnostic

source
pub struct ImportDiagnostic {
  line : Int
  column : Int
  message : String
  hint : String
} derive(Eq, ToJson, 
Debug)

#
ImportOptions

source
pub struct ImportOptions {
  has_header : Bool
  delimiter : Delimiter
  reject_unknown_columns : Bool
} derive(Eq, ToJson, 
Debug)

#
ImportOptions::csv

source

#
ImportOptions::new

source
fn ImportOptions::new(has_header : Bool, delimiter : Delimiter, reject_unknown_columns : Bool) -> ImportOptions

#
ImportOptions::tsv

source

#
ImportResult

source
pub struct ImportResult {
  entries : Array[IcdEntry]
  diagnostics : Array[ImportDiagnostic]
} derive(Eq, ToJson, 
Debug)

#
NormalizationResult

source
pub struct NormalizationResult {
  accepted : Array[String]
  rejected : Array[String]
} derive(Eq, ToJson, 
Debug)

#
RangePartition

source
pub struct RangePartition {
  inside : Array[String]
  outside : Array[String]
  invalid : Array[String]
} derive(Eq, ToJson, 
Debug)

#
SearchHit

source
pub struct SearchHit {
  code : String
  title : String
  score : Int
} derive(Eq, ToJson, 
Debug)

#
ValidationIssue

source
pub struct ValidationIssue {
  code : String
  message : String
  hint : String
} derive(Eq, ToJson, 
Debug)

#
ValidationPolicy

source
pub struct ValidationPolicy {
  require_catalog_membership : Bool
} derive(Eq, ToJson, 
Debug)

#
ValidationPolicy::permissive

source

#
ValidationPolicy::strict

source

#
ValidationReport

source
pub struct ValidationReport {
  input : String
  normalized : String?
  status : ValidationStatus
  chapter : IcdChapter?
  entry : IcdEntry?
  issues : Array[ValidationIssue]
} derive(Eq, ToJson, 
Debug)

#
ValidationStatus

source
pub enum ValidationStatus {
  Valid
  Unknown
  Invalid
} derive(Eq, ToJson, 
Debug)

#
audit_catalog

source
fn audit_catalog(catalog : Catalog) -> CatalogAudit

#
audit_entries

source
fn audit_entries(entries : Array[IcdEntry]) -> CatalogAudit

#
bundled_catalog

source
fn bundled_catalog() -> Catalog

#
canonicalize_lines

source
fn canonicalize_lines(text : String) -> NormalizationResult

#
chapters_for_range

source
fn chapters_for_range(start : String, end : String) -> Array[IcdChapter]

#
children_of

source
fn children_of(parent : String) -> Array[IcdEntry]

#
exclusion_hints

source
fn exclusion_hints(entry : IcdEntry) -> Array[IcdEntry]

#
execute_cli

source
fn execute_cli(args : Array[String]) -> String

#
export_entries

source
fn export_entries(entries : Array[IcdEntry], delimiter : Delimiter) -> String

#
find_chapter

source
fn find_chapter(code : IcdCode) -> IcdChapter?

#
find_entry

source
fn find_entry(code : String) -> IcdEntry?

#
format_report

source
fn format_report(report : ValidationReport) -> String

#
icd10_chapters

source
fn icd10_chapters() -> Array[IcdChapter]

#
import_entries

source
fn import_entries(text : String, options : ImportOptions) -> ImportResult

#
is_valid_category

source
fn is_valid_category(code : String) -> Bool

#
normalize_code

source
fn normalize_code(input : String) -> String

#
normalize_codes

source
fn normalize_codes(inputs : Array[String]) -> NormalizationResult

#
parse_code

source
fn parse_code(input : String, edition? : IcdEdition) -> IcdCode raise IcdParseError

#
parse_icd10

source
fn parse_icd10(input : String) -> IcdCode raise IcdParseError

#
parse_icd11

source
fn parse_icd11(input : String) -> IcdCode raise IcdParseError

#
query_prefix

source
fn query_prefix(prefix : String) -> Array[IcdEntry]

#
render_batch_json

source
fn render_batch_json(report : BatchReport) -> String

#
render_batch_text

source
fn render_batch_text(report : BatchReport) -> String

#
render_batch_tsv

source
fn render_batch_tsv(report : BatchReport) -> String

#
sample_entries

source
fn sample_entries() -> Array[IcdEntry]

#
summarize

source
fn summarize(reports : Array[ValidationReport]) -> BatchSummary

#
validate_against

source
fn validate_against(catalog : Catalog, input : String) -> ValidationReport

#
validate_batch

source
fn validate_batch(catalog : Catalog, inputs : Array[String]) -> BatchReport

#
validate_icd10

source
fn validate_icd10(input : String) -> ValidationReport

#
validate_with_policy

source
fn validate_with_policy(catalog : Catalog, input : String, policy : ValidationPolicy) -> ValidationReport

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io