🥮 mooncakes.io
    Sign in

    moonbit-chemreport

    A reusable report layer for MoonBit chemical-engineering calculations.

    chemical-engineering
    report
    benchmark
    bundle
    markdown
    html
    json
    Download zip
    Author
    Version
    0.3.1
    License
    Apache-2.0
    Repository
    Last updated
    last month
    Downloads
    15

    #moonbit-chemreport

    MoonBit chemical-engineering calculations often start in focused packages: reactor sizing, distillation, mass balance, energy balance, property lookup, and equipment checks. moonbit-chemreport provides the report layer that those packages can share: a stable model for inputs, assumptions, formulas, results, warnings, and data sources, plus Markdown, HTML, and JSON exporters.

    The project is intentionally small at the boundary and expandable inside. It is not a process simulator. It is the part a simulator, spreadsheet importer, or operator-facing CLI can call after the numbers are already computed.

    #Core capabilities

    • A reusable ChemReport data model.
    • Constructors for quantities, calculation inputs, assumptions, formulas, results, warnings, and data sources.
    • Markdown export for lab notes, GitHub issues, and handoff documents.
    • HTML export for dashboards and static report previews.
    • JSON export for integration tests, web frontends, and downstream tools.
    • Validation helpers that catch missing and empty report fields and highlight hazard-level warnings.
    • ReportMetrics for completeness counts and ReportBundle for batch validation, aggregate metrics, and combined Markdown/JSON output.
    • Worked examples for mass balance, energy balance, binary distillation, and reactor conversion.
    • Three NIST SRD 69 Antoine-equation benchmark records for water, ethanol, and benzene, each carrying CAS number, temperature range, coefficient values, and source URL.
    • Unit-aware scalar parsing and conversion for common engineering dimensions.
    • Deterministic report comparison, quality policies, CSV summaries, and JSONL.
    • CSV summary import with quoted-field handling, fixed-point quantity arithmetic, ordered provenance ledgers, composable report builders, and bundle selection.
    • Rule-based checks for units, duplicate names, formula variables, and source citations, plus six additional engineering report templates.

    #CLI

    moon run cmd/main

    The CLI prints a Markdown example followed by the cited NIST benchmark bundle. The library benchmark runner measures export workload and output size locally; it does not make hardware-independent performance claims.

    #Quick Start

    moon check --deny-warn
moon test --deny-warn
moon run cmd/main

    The CLI prints the built-in CSTR mass-balance report as Markdown.

    It also prints the NIST benchmark bundle summary so the repository has a repeatable, source-aware data path that can be exercised without network access.

    #API Sketch

    ///|
    let r = report(
      "CSTR A-101 Mass Balance",
      summary="A stable report record for a reactor inlet/outlet balance.",
      inputs=[
        input(
          "feed flow",
          quantity("100.0", "kmol/h"),
          note="measured at battery limit",
        ),
      ],
      assumptions=[assumption("steady state", "accumulation term is zero")],
      formulas=[formula("A in", "F_A,in = F_feed * z_A", ["F_feed", "z_A"])],
      results=[
        result("A feed", quantity("42.0", "kmol/h"), procedure="100.0 * 0.42"),
      ],
      warnings=[caution("conversion target should be reconciled before scale-up")],
      sources=[source("design basis", "internal design basis document")],
    )

    ///|
    let markdown = r.to_markdown()

    ///|
    let html = r.to_html_document()

    ///|
    let json = r.to_json()

    #Architecture

    • model.mbt: report records and constructors.
    • validate.mbt: consistency checks and blocking issue detection.
    • markdown.mbt: Markdown renderer.
    • html.mbt: HTML fragment/document renderer.
    • json_export.mbt: stable JSON string renderer.
    • metrics.mbt: completeness metrics for one report.
    • bundle.mbt: batch report validation, aggregation, and export.
    • examples.mbt: mass-balance, energy-balance, distillation, and reactor examples.
    • benchmarks.mbt: NIST SRD 69 Antoine benchmark records.
    • units.mbt and scalars.mbt: dimensions, unit catalog, parsing, and conversion.
    • query.mbt, diff.mbt, policy.mbt: discovery, comparison, and quality gates.
    • csv.mbt, benchmark_runner.mbt: tabular interchange and deterministic workloads.
    • csv_import.mbt, quantity_math.mbt, balance.mbt: ingestion, fixed-point arithmetic, and closure checks.
    • builder.mbt, bundle_ops.mbt, rules.mbt: composable construction, batch selection, and quality rules.
    • pipeline.mbt, provenance.mbt, source_audit.mbt: typed rendering, ordered provenance, and source audits.
    • series.mbt, report_index.mbt, archive.mbt: numeric summaries, searchable report indexes, and revision snapshots.
    • bundle_analytics.mbt, bundle_export.mbt, schema.mbt, diff_details.mbt: batch quality summaries, stable exports, schema checks, and readable change risk.
    • cmd/main: simple runnable entry point.

    #Design scope

    The package targets reusable engineering infrastructure. It avoids reimplementing chemical calculations already owned by future domain packages; instead it supplies the common reporting surface those packages need to present assumptions, formulas, warnings, and source traceability in one place.

    Benchmark data is deliberately kept as report fixtures rather than a new property database, so the project complements future chemical calculation packages while keeping the report schema independent.

    #Benchmarks, tests, and CI

    The repository is prepared for the current MoonBit toolchain flow:

    moon fmt --check
moon check --deny-warn
moon info
moon test --deny-warn

    CI installs the current stable MoonBit toolchain and checks formatting, all-target type checking, native compilation, interface drift, and tests on Linux, macOS, and Windows. Benchmark provenance and limitations are documented in docs/benchmarks.md.

    #Source And Maintenance Notes

    All source code in this repository is original for moonbit-chemreport, except for the initial project scaffold generated by moon new and the Apache-2.0 license text. The worked-example numbers are demonstration data, not design advice. The three Antoine coefficient records are source-aware benchmark fixtures transcribed from NIST Chemistry WebBook SRD 69; see docs/benchmarks.md for provenance, ranges, and limitations. The intended maintenance path is to add typed adapters for MoonBit chemical-engineering libraries as those packages appear, while keeping the core report schema stable.

    #License

    Apache-2.0.

    ArchiveError

    source
    pub enum ArchiveError {
      NonIncreasingRevision
      EmptyNote
    } derive(Eq, 
    Debug    )

    Assumption

    source
    pub struct Assumption {
      title : String
      detail : String
    } derive(Eq, 
    Debug    )

    BalanceCheck

    source
    pub struct BalanceCheck {
      status : BalanceStatus
      inlet : String
      outlet : String
      difference : String
      tolerance : String
    } derive(Eq, 
    Debug    )

    BalanceCheck::is_balanced

    source
    fn BalanceCheck::is_balanced(self : BalanceCheck) -> Bool

    BalanceStatus

    source
    pub enum BalanceStatus {
      Balanced
      Unbalanced
      Invalid
    } derive(Eq, 
    Debug    )

    BenchmarkCase

    source
    pub struct BenchmarkCase {
      id : String
      category : String
      report : ChemReport
    } derive(Eq, 
    Debug    )

    BenchmarkResult

    source
    pub struct BenchmarkResult {
      suite : String
      case_count : Int
      iterations : Int
      total_bytes : Int
      publishable_cases : Int
    } derive(Eq, 
    Debug    )

    BenchmarkSuite

    source
    pub struct BenchmarkSuite {
      name : String
      cases : Array[BenchmarkWork]
    } derive(Eq, 
    Debug    )

    BenchmarkSuite::run

    source
    fn BenchmarkSuite::run(self : BenchmarkSuite, iterations : Int) -> BenchmarkResult

    BenchmarkWork

    source
    pub struct BenchmarkWork {
      id : String
      report : ChemReport
    } derive(Eq, 
    Debug    )

    BundleIssue

    source
    pub struct BundleIssue {
      report_index : Int
      issue : ReportIssue
    } derive(Eq, 
    Debug    )

    BundleMetrics

    source
    pub struct BundleMetrics {
      report_count : Int
      publishable_count : Int
      blocking_count : Int
      input_count : Int
      result_count : Int
      source_count : Int
      warning_count : Int
      hazard_count : Int
    } derive(Eq, 
    Debug    )

    BundleSelection

    source
    pub enum BundleSelection {
      AllReports
      PublishableOnly
      NeedsReview
    } derive(Eq, 
    Debug    )

    BundleSummary

    source
    pub struct BundleSummary {
      report_count : Int
      publishable_count : Int
      blocking_count : Int
      input_count : Int
      result_count : Int
      warning_count : Int
      source_count : Int
    } derive(Eq, 
    Debug    )

    ChangeDetail

    source
    pub struct ChangeDetail {
      section : String
      severity : ChangeSeverity
      message : String
    } derive(Eq, 
    Debug    )

    ChangeDetail::is_high_risk

    source
    fn ChangeDetail::is_high_risk(self : ChangeDetail) -> Bool

    ChangeSeverity

    source
    pub enum ChangeSeverity {
      Low
      Medium
      High
    } derive(Eq, 
    Debug    )

    ChemInput

    source
    pub struct ChemInput {
      name : String
      value : Quantity
      note : String
    } derive(Eq, 
    Debug    )

    ChemReport

    source
    pub struct ChemReport {
      title : String
      summary : String
      inputs : Array[ChemInput]
      assumptions : Array[Assumption]
      formulas : Array[Formula]
      results : Array[ChemResult]
      warnings : Array[ReportWarning]
      sources : Array[DataSource]
    } derive(Eq, 
    Debug    )

    ChemReport::check_rules

    source
    fn ChemReport::check_rules(self : ChemReport, rules : Array[RuleKind]) -> Array[RuleIssue]

    ChemReport::find_input

    source
    fn ChemReport::find_input(self : ChemReport, name : String) -> ChemInput?

    ChemReport::find_result

    source
    fn ChemReport::find_result(self : ChemReport, name : String) -> ChemResult?

    ChemReport::has_blocking_issue

    source
    fn ChemReport::has_blocking_issue(self : ChemReport) -> Bool

    ChemReport::is_publishable

    source
    fn ChemReport::is_publishable(self : ChemReport) -> Bool

    ChemReport::metrics

    source
    fn ChemReport::metrics(self : ChemReport) -> ReportMetrics

    ChemReport::section_counts

    source
    fn ChemReport::section_counts(self : ChemReport) -> Array[SectionCount]

    ChemReport::to_html_document

    source
    fn ChemReport::to_html_document(self : ChemReport) -> String

    ChemReport::to_html_fragment

    source
    fn ChemReport::to_html_fragment(self : ChemReport) -> String

    ChemReport::to_json

    source
    fn ChemReport::to_json(self : ChemReport) -> String

    ChemReport::to_markdown

    source
    fn ChemReport::to_markdown(self : ChemReport) -> String

    ChemReport::validate

    source
    fn ChemReport::validate(self : ChemReport) -> Array[ReportIssue]

    ChemReport::warnings_with_severity

    source
    fn ChemReport::warnings_with_severity(self : ChemReport, severity : Severity) -> Array[ReportWarning]

    ChemResult

    source
    pub struct ChemResult {
      name : String
      value : Quantity
      procedure : String
    } derive(Eq, 
    Debug    )

    CsvParseError

    source
    pub enum CsvParseError {
      EmptyCsv
      UnterminatedQuote
      UnexpectedCharacter
      InvalidHeader
      InvalidNumber
    } derive(Eq, 
    Debug    )

    DataSource

    source
    pub struct DataSource {
      label : String
      citation : String
      url : String
    } derive(Eq, 
    Debug    )

    Formula

    source
    pub struct Formula {
      name : String
      expression : String
      variables : Array[String]
    } derive(Eq, 
    Debug    )

    NumericSeries

    source
    pub struct NumericSeries {
      label : String
      unit : String
      values : Array[String]
    } derive(Eq, 
    Debug    )

    NumericSeries::is_monotonic

    source
    fn NumericSeries::is_monotonic(self : NumericSeries) -> Bool

    NumericSeries::statistics

    source
    fn NumericSeries::statistics(self : NumericSeries) -> Result[SeriesStatistics, SeriesError]

    PolicyIssue

    source
    pub struct PolicyIssue {
      code : String
      message : String
    } derive(Eq, 
    Debug    )

    ProvenanceError

    source
    pub enum ProvenanceError {
      InvalidStage
      StageOutOfOrder
      EmptyActor
      EmptyDetail
    } derive(Eq, 
    Debug    )

    ProvenanceEvent

    source
    pub struct ProvenanceEvent {
      stage : String
      actor : String
      detail : String
    } derive(Eq, 
    Debug    )

    ProvenanceLedger

    source
    pub struct ProvenanceLedger {
      report_id : String
      entries : Array[ProvenanceEvent]
    } derive(Eq, 
    Debug    )

    ProvenanceLedger::events

    source

    ProvenanceLedger::is_complete

    source
    fn ProvenanceLedger::is_complete(self : ProvenanceLedger) -> Bool

    ProvenanceLedger::record

    source

    QualityPolicy

    source
    pub struct QualityPolicy {
      min_inputs : Int
      min_formulas : Int
      min_results : Int
      require_source_url : Bool
      reject_hazards : Bool
    } derive(Eq, 
    Debug    )

    QualityPolicy::evaluate

    source
    fn QualityPolicy::evaluate(self : QualityPolicy, report : ChemReport) -> Array[PolicyIssue]

    Quantity

    source
    pub struct Quantity {
      value : String
      unit : String
    } derive(Eq, 
    Debug    )

    QuantityMathError

    source
    pub enum QuantityMathError {
      InvalidNumber
      IncompatibleUnits
      DivideByZero
    } derive(Eq, 
    Debug    )

    RenderError

    source
    pub enum RenderError {
      InvalidReport
      EmptyOutput
    } derive(Eq, 
    Debug    )

    RenderedReport

    source
    pub struct RenderedReport {
      format : ReportFormat
      content : String
    } derive(Eq, 
    Debug    )

    RenderedReport::is_nonempty

    source
    fn RenderedReport::is_nonempty(self : RenderedReport) -> Bool

    ReportArchive

    source
    pub struct ReportArchive {
      id : String
      snapshots : Array[ReportSnapshot]
    } derive(Eq, 
    Debug    )

    ReportArchive::append

    source
    fn ReportArchive::append(self : ReportArchive, value : ReportSnapshot) -> Result[ReportArchive, ArchiveError]

    ReportArchive::history

    source

    ReportArchive::latest

    source

    ReportBuilder

    source
    pub struct ReportBuilder {
      title : String
      summary : String
      inputs : Array[ChemInput]
      assumptions : Array[Assumption]
      formulas : Array[Formula]
      results : Array[ChemResult]
      warnings : Array[ReportWarning]
      sources : Array[DataSource]
    } derive(Eq, 
    Debug    )

    ReportBuilder::add_assumption

    source
    fn ReportBuilder::add_assumption(self : ReportBuilder, value : Assumption) -> ReportBuilder

    ReportBuilder::add_formula

    source
    fn ReportBuilder::add_formula(self : ReportBuilder, value : Formula) -> ReportBuilder

    ReportBuilder::add_input

    source
    fn ReportBuilder::add_input(self : ReportBuilder, value : ChemInput) -> ReportBuilder

    ReportBuilder::add_result

    source
    fn ReportBuilder::add_result(self : ReportBuilder, value : ChemResult) -> ReportBuilder

    ReportBuilder::add_source

    source
    fn ReportBuilder::add_source(self : ReportBuilder, value : DataSource) -> ReportBuilder

    ReportBuilder::add_warning

    source
    fn ReportBuilder::add_warning(self : ReportBuilder, value : ReportWarning) -> ReportBuilder

    ReportBuilder::build

    source

    ReportBundle

    source
    pub struct ReportBundle {
      title : String
      reports : Array[ChemReport]
    } derive(Eq, 
    Debug    )

    ReportBundle::contains_hazard

    source
    fn ReportBundle::contains_hazard(self : ReportBundle) -> Bool

    ReportBundle::find_title

    source
    fn ReportBundle::find_title(self : ReportBundle, title : String) -> ChemReport?

    ReportBundle::has_blocking_issue

    source
    fn ReportBundle::has_blocking_issue(self : ReportBundle) -> Bool

    ReportBundle::merge

    source
    fn ReportBundle::merge(self : ReportBundle, other : ReportBundle) -> ReportBundle

    ReportBundle::metrics

    source
    fn ReportBundle::metrics(self : ReportBundle) -> BundleMetrics

    ReportBundle::publishable_csv

    source
    fn ReportBundle::publishable_csv(self : ReportBundle) -> String

    ReportBundle::reports

    source
    fn ReportBundle::reports(self : ReportBundle) -> Array[ChemReport]

    ReportBundle::review_markdown

    source
    fn ReportBundle::review_markdown(self : ReportBundle) -> String

    ReportBundle::select

    source
    fn ReportBundle::select(self : ReportBundle, selection : BundleSelection) -> Array[ChemReport]

    ReportBundle::summary

    source
    fn ReportBundle::summary(self : ReportBundle) -> BundleSummary

    ReportBundle::summary_markdown

    source
    fn ReportBundle::summary_markdown(self : ReportBundle) -> String

    ReportBundle::titles

    source
    fn ReportBundle::titles(self : ReportBundle) -> Array[String]

    ReportBundle::to_csv

    source
    fn ReportBundle::to_csv(self : ReportBundle) -> String

    ReportBundle::to_json

    source
    fn ReportBundle::to_json(self : ReportBundle) -> String

    ReportBundle::to_jsonl

    source
    fn ReportBundle::to_jsonl(self : ReportBundle) -> String

    ReportBundle::to_markdown

    source
    fn ReportBundle::to_markdown(self : ReportBundle) -> String

    ReportBundle::validate

    source
    fn ReportBundle::validate(self : ReportBundle) -> Array[BundleIssue]

    ReportChange

    source
    pub enum ReportChange {
      TitleChanged
      SummaryChanged
      InputsChanged
      AssumptionsChanged
      FormulasChanged
      ResultsChanged
      WarningsChanged
      SourcesChanged
    } derive(Eq, 
    Debug    )

    ReportFormat

    source
    pub enum ReportFormat {
      Markdown
      Html
      Json
    } derive(Eq, 
    Debug    )

    ReportIndex

    source
    pub struct ReportIndex {
      entries : Array[ReportIndexEntry]
    } derive(Eq, 
    Debug    )

    ReportIndex::add

    source
    fn ReportIndex::add(self : ReportIndex, id : String, report : ChemReport, keywords : Array[String]) -> ReportIndex

    ReportIndex::entries

    source

    ReportIndex::publishable

    source
    fn ReportIndex::publishable(self : ReportIndex) -> Array[ReportIndexEntry]

    ReportIndex::search

    source
    fn ReportIndex::search(self : ReportIndex, term : String) -> Array[ChemReport]

    ReportIndexEntry

    source
    pub struct ReportIndexEntry {
      id : String
      title : String
      keywords : Array[String]
      report : ChemReport
    } derive(Eq, 
    Debug    )

    ReportIssue

    source
    pub struct ReportIssue {
      kind : ReportIssueKind
      message : String
    } derive(Eq, 
    Debug    )

    ReportIssueKind

    source
    pub enum ReportIssueKind {
      MissingTitle
      MissingInput
      MissingResult
      MissingSource
      HazardWarning
      EmptyInputName
      EmptyInputValue
      EmptyResultName
      EmptyResultValue
      EmptySourceCitation
    } derive(Eq, 
    Debug    )

    ReportMetrics

    source
    pub struct ReportMetrics {
      input_count : Int
      assumption_count : Int
      formula_count : Int
      result_count : Int
      warning_count : Int
      source_count : Int
      issue_count : Int
      hazard_count : Int
    } derive(Eq, 
    Debug    )

    ReportSnapshot

    source
    pub struct ReportSnapshot {
      revision : Int
      report : ChemReport
      note : String
    } derive(Eq, 
    Debug    )

    ReportSummaryRow

    source
    pub struct ReportSummaryRow {
      title : String
      input_count : Int
      result_count : Int
      warning_count : Int
      source_count : Int
      publishable : Bool
    } derive(Eq, 
    Debug    )

    ReportWarning

    source
    pub struct ReportWarning {
      severity : Severity
      message : String
    } derive(Eq, 
    Debug    )

    RuleIssue

    source
    pub struct RuleIssue {
      rule : RuleKind
      location : String
      message : String
    } derive(Eq, 
    Debug    )

    RuleKind

    source
    pub enum RuleKind {
      RequiredUnits
      UniqueInputNames
      UniqueResultNames
      FormulaVariables
      SourceCitations
    } derive(Eq, 
    Debug    )

    ScalarError

    source
    pub enum ScalarError {
      EmptyScalar
      InvalidNumber
      UnknownUnit(String)
      IncompatibleUnits(String, String)
      InvalidConversion
    } derive(Eq, 
    Debug    )

    ScalarValue

    source
    pub struct ScalarValue {
      value : String
      unit : String
    } derive(Eq, 
    Debug    )

    Scenario

    source
    pub struct Scenario {
      name : String
      report : ChemReport
    } derive(Eq, 
    Debug    )

    ScenarioSet

    source
    pub struct ScenarioSet {
      name : String
      scenarios : Array[Scenario]
    } derive(Eq, 
    Debug    )

    ScenarioSet::add

    source
    fn ScenarioSet::add(self : ScenarioSet, value : Scenario) -> ScenarioSet

    ScenarioSet::best

    source
    fn ScenarioSet::best(self : ScenarioSet) -> Scenario?

    ScenarioSet::names

    source
    fn ScenarioSet::names(self : ScenarioSet) -> Array[String]

    ScenarioSet::review_required

    source
    fn ScenarioSet::review_required(self : ScenarioSet) -> Array[Scenario]

    ScenarioSet::to_bundle

    source
    fn ScenarioSet::to_bundle(self : ScenarioSet) -> ReportBundle

    SchemaCompatibility

    source
    pub enum SchemaCompatibility {
      Current
      Older
      Unsupported
    } derive(Eq, 
    Debug    )

    SectionCount

    source
    pub struct SectionCount {
      name : String
      count : Int
    } derive(Eq, 
    Debug    )

    SeriesError

    source
    pub enum SeriesError {
      EmptySeries
      InvalidValue
    } derive(Eq, 
    Debug    )

    SeriesStatistics

    source
    pub struct SeriesStatistics {
      minimum : String
      maximum : String
      mean : String
      count : Int
    } derive(Eq, 
    Debug    )

    Severity

    source
    pub enum Severity {
      Info
      Caution
      Hazard
    } derive(Eq, 
    Debug    )

    SourceAudit

    source
    pub struct SourceAudit {
      total : Int
      with_url : Int
      missing_citation : Int
      duplicate_citations : Int
    } derive(Eq, 
    Debug    )

    SourceAudit::is_traceable

    source
    fn SourceAudit::is_traceable(self : SourceAudit) -> Bool

    SourceRegistry

    source
    pub struct SourceRegistry {
      entries : Array[DataSource]
    } derive(Eq, 
    Debug    )

    SourceRegistry::add

    source

    SourceRegistry::add_all

    source
    fn SourceRegistry::add_all(self : SourceRegistry, values : Array[DataSource]) -> SourceRegistry

    SourceRegistry::has_url

    source
    fn SourceRegistry::has_url(self : SourceRegistry, url : String) -> Bool

    SourceRegistry::sources

    source

    SourceRegistry::to_markdown

    source
    fn SourceRegistry::to_markdown(self : SourceRegistry) -> String

    Tolerance

    source
    pub struct Tolerance {
      scaled : Int
    } derive(Eq, 
    Debug    )

    UnitDimension

    source
    pub enum UnitDimension {
      Mass
      Amount
      Volume
      Time
      Temperature
      Energy
      Power
      Pressure
      Dimensionless
    } derive(Eq, 
    Debug    )

    UnitSpec

    source
    pub struct UnitSpec {
      symbol : String
      dimension : UnitDimension
      to_base : String
      offset : String
    } derive(Eq, 
    Debug    )

    add_quantities

    source
    fn add_quantities(left : Quantity, right : Quantity) -> Result[Quantity, QuantityMathError]

    assumption

    source
    fn assumption(title : String, detail : String) -> Assumption

    audit_sources

    source
    fn audit_sources(report : ChemReport) -> SourceAudit

    benchmark_case

    source
    fn benchmark_case(id : String, report : ChemReport) -> BenchmarkWork

    benchmark_suite

    source
    fn benchmark_suite(name : String, cases : Array[BenchmarkWork]) -> BenchmarkSuite

    bundle_selections

    source
    fn bundle_selections() -> Array[BundleSelection]

    caution

    source
    fn caution(message : String) -> ReportWarning

    change_text

    source
    fn change_text(change : ReportChange) -> String

    check_balance

    source
    fn check_balance(inlet : String, outlet : String, tolerance : Tolerance) -> BalanceCheck

    compare_reports

    source
    fn compare_reports(left : ChemReport, right : ChemReport) -> Array[ReportChange]

    compatible_units

    source
    fn compatible_units(left : String, right : String) -> Bool

    convert_scalar

    source
    fn convert_scalar(value : ScalarValue, target : String) -> Result[ScalarValue, ScalarError]

    describe_report_changes

    source
    fn describe_report_changes(left : ChemReport, right : ChemReport) -> Array[ChangeDetail]

    distillation_stage_report

    source
    fn distillation_stage_report() -> ChemReport

    divide_quantity

    source
    fn divide_quantity(value : Quantity, divisor : String) -> Result[Quantity, QuantityMathError]

    drying_report

    source
    fn drying_report() -> ChemReport

    filtration_report

    source
    fn filtration_report() -> ChemReport

    flash_split_report

    source
    fn flash_split_report() -> ChemReport

    formula

    source
    fn formula(name : String, expression : String, variables : Array[String]) -> Formula

    hazard

    source
    fn hazard(message : String) -> ReportWarning

    heat_exchanger_report

    source
    fn heat_exchanger_report() -> ChemReport

    high_risk_changes

    source
    fn high_risk_changes(changes : Array[ChangeDetail]) -> Array[ChangeDetail]

    info

    source
    fn info(message : String) -> ReportWarning

    input

    source
    fn input(name : String, value : Quantity, note? : String) -> ChemInput

    issue

    source
    fn issue(kind : ReportIssueKind, message : String) -> ReportIssue

    known_units

    source
    fn known_units(dimension : UnitDimension) -> Array[UnitSpec]

    mixing_report

    source
    fn mixing_report() -> ChemReport

    nist_benchmark_bundle

    source
    fn nist_benchmark_bundle() -> ReportBundle

    nist_vapor_pressure_benchmarks

    source
    fn nist_vapor_pressure_benchmarks() -> Array[BenchmarkCase]

    numeric_series

    source
    fn numeric_series(label : String, unit : String, values : Array[String]) -> NumericSeries

    parse_report_summary_csv

    source
    fn parse_report_summary_csv(text : String) -> Result[Array[ReportSummaryRow], CsvParseError]

    parse_scalar

    source
    fn parse_scalar(text : String) -> Result[ScalarValue, ScalarError]

    pressure_drop_report

    source
    fn pressure_drop_report() -> ChemReport

    provenance_event

    source
    fn provenance_event(stage : String, actor : String, detail : String) -> ProvenanceEvent

    provenance_ledger

    source
    fn provenance_ledger(report_id : String) -> ProvenanceLedger

    pump_power_report

    source
    fn pump_power_report() -> ChemReport

    quality_policy

    source
    fn quality_policy(min_inputs? : Int, min_formulas? : Int, min_results? : Int, require_source_url? : Bool, reject_hazards? : Bool) -> QualityPolicy

    quantity

    source
    fn quantity(value : String, unit : String) -> Quantity

    quantity_difference

    source
    fn quantity_difference(left : Quantity, right : Quantity) -> Result[Quantity, QuantityMathError]

    quantity_math_errors

    source
    fn quantity_math_errors() -> Array[QuantityMathError]

    reaction_rate_report

    source
    fn reaction_rate_report() -> ChemReport

    render_report

    source
    fn render_report(report : ChemReport, format : ReportFormat) -> Result[RenderedReport, RenderError]

    report

    source
    fn report(title : String, summary? : String, inputs? : Array[ChemInput], assumptions? : Array[Assumption], formulas? : Array[Formula], results? : Array[ChemResult], warnings? : Array[ReportWarning], sources? : Array[DataSource]) -> ChemReport

    report_archive

    source
    fn report_archive(id : String) -> ReportArchive

    report_builder

    source
    fn report_builder(title : String, summary? : String) -> ReportBuilder

    report_bundle

    source
    fn report_bundle(title : String, reports : Array[ChemReport]) -> ReportBundle

    report_formats

    source
    fn report_formats() -> Array[ReportFormat]

    report_index

    source
    fn report_index() -> ReportIndex

    report_schema_version

    source
    fn report_schema_version() -> String

    report_summary_csv

    source
    fn report_summary_csv(reports : Array[ChemReport]) -> String

    reports_jsonl

    source
    fn reports_jsonl(reports : Array[ChemReport]) -> String

    result

    source
    fn result(name : String, value : Quantity, procedure? : String) -> ChemResult

    rule_kinds

    source
    fn rule_kinds() -> Array[RuleKind]

    sample_distillation_report

    source
    fn sample_distillation_report() -> ChemReport

    sample_energy_balance_report

    source
    fn sample_energy_balance_report() -> ChemReport

    sample_mass_balance_report

    source
    fn sample_mass_balance_report() -> ChemReport

    sample_reactor_conversion_report

    source
    fn sample_reactor_conversion_report() -> ChemReport

    scalar

    source
    fn scalar(value : String, unit : String) -> ScalarValue

    scale_quantity

    source
    fn scale_quantity(value : Quantity, factor : String) -> Result[Quantity, QuantityMathError]

    scenario

    source
    fn scenario(name : String, report : ChemReport) -> Scenario

    scenario_set

    source
    fn scenario_set(name : String) -> ScenarioSet

    schema_accepts

    source
    fn schema_accepts(version : String) -> Bool

    schema_compatibility

    source
    fn schema_compatibility(version : String) -> SchemaCompatibility

    schema_versions

    source
    fn schema_versions() -> Array[String]

    snapshot

    source
    fn snapshot(revision : Int, report : ChemReport, note : String) -> ReportSnapshot

    source

    source
    fn source(label : String, citation : String, url? : String) -> DataSource

    source_registry

    source
    fn source_registry() -> SourceRegistry

    stoichiometric_yield_report

    source
    fn stoichiometric_yield_report() -> ChemReport

    subtract_quantities

    source
    fn subtract_quantities(left : Quantity, right : Quantity) -> Result[Quantity, QuantityMathError]

    tolerance

    source
    fn tolerance(value : String) -> Tolerance

    unit_catalog

    source
    fn unit_catalog() -> Array[UnitSpec]

    unit_dimension

    source
    fn unit_dimension(symbol : String) -> UnitDimension?

    unit_spec

    source
    fn unit_spec(symbol : String, dimension : UnitDimension, to_base : String, offset? : String) -> UnitSpec

    warning

    source
    fn warning(severity : Severity, message : String) -> ReportWarning

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io