🥮 mooncakes.io
README

#symcore

CAIMEOX/symbit/symcore is the public import path for this package.

The foundational expression package for Symbit. It defines the symbolic expression tree, exact numeric leaves, callable heads, and structural traversal primitives used everywhere else in the module.

#When To Use This Package

  • Import CAIMEOX/symbit/symcore directly when your code depends on this package's subsystem-specific types or algorithms.
  • Prefer this package over the root facade when you want the focused API surface listed below rather than a convenience wrapper.

#Key Public Entry Points

  • add
  • application_args
  • application_has_name
  • application_name
  • application_parts
  • applied_parts
  • applied_undefined_function
  • apply

#Example

///|
test "symcore builds structured expressions" {
  let x = Expr::Symbol("x")
  let expr = add([x, int(1)])
  inspect(@symprint.pretty_string(expr), content="x + 1")
}

#Related Packages

  • CAIMEOX/symbit
  • CAIMEOX/symbit/symsimplify

#Further Reading

#
FuzzyBool

source
type FuzzyBool = Bool?

#
MatchEnv

source
type MatchEnv = Map[Expr, Expr]

Mutable linked hash map that maintains the order of insertion, not thread safe.

Example

test {
  let map = { 3: "three", 8: "eight", 1: "one" }
  assert_eq(map.get(2), None)
  assert_eq(map.get(3), Some("three"))
  map.set(3, "updated")
  assert_eq(map.get(3), Some("updated"))
}

#
WildPropertyResolver

source
type WildPropertyResolver = (WildProperty, Expr) -> Bool?

#
ComplexFloat

source
pub struct ComplexFloat {
  value : 
RawMpc
  prec : Int
} derive(Eq)

Minimal arbitrary-precision complex floating literal backed by symnum's mpmath-compatible Mpc.
impl Add for ComplexFloat
impl Mul for ComplexFloat
impl Neg for ComplexFloat

#
ComplexFloat::format

source
fn ComplexFloat::format(self : ComplexFloat, dps? : Int) -> String

#
ComplexFloat::from_exact_parts

source

#
ComplexFloat::from_mpc

source

#
ComplexFloat::from_parts

source

#
ComplexFloat::from_real

source
fn ComplexFloat::from_real(real : Float, imag? : Float) -> ComplexFloat

#
ComplexFloat::imag_part

source
fn ComplexFloat::imag_part(self : ComplexFloat) -> Float

#
ComplexFloat::is_finite

source
fn ComplexFloat::is_finite(self : ComplexFloat) -> Bool

#
ComplexFloat::precision

source
fn ComplexFloat::precision(self : ComplexFloat) -> Int

#
ComplexFloat::real_part

source
fn ComplexFloat::real_part(self : ComplexFloat) -> Float

#
ComplexFloat::reciprocal

source
fn ComplexFloat::reciprocal(self : ComplexFloat) -> ComplexFloat

#
ComplexFloat::to_mpc

source

#
ComplexFloat::to_rational_parts

source

#
ExactNumberKind

source
pub(all) enum ExactNumberKind {
  Zero
  One
  NegativeOne
  Half
  Integer
  Rational
}

#
Expr

source
pub(all) enum Expr {
  Number(
BigRational)
  Float(Float)
  ComplexFloat(ComplexFloat)
  NumberSymbol(NumberSymbolKind)
  Boolean(Bool)
  IdentityFunction
  Symbol(String)
  Dummy(String, Int)
  Wild(String, Array[Expr], Array[WildProperty])
  WildFunction(String, Array[Int])
  FunctionHead(String)
  UndefinedFunction(String)
  Apply(Expr, Array[Expr])
  Add(Array[Expr])
  Mul(Array[Expr])
  Pow(Expr, Expr)
  Mod(Expr, Expr)
  Tuple(Array[Expr])
  Dict(Array[(Expr, Expr)])
  Relational(RelOp, Expr, Expr)
  Derivative(Expr, Array[Expr])
  Subs(Expr, Expr, Expr)
  Lambda(Expr, Expr)
  Function(String, Array[Expr])
}

Core symbolic expression tree used across Symbit.

Current Limits:
  • symcore defines structure and canonical construction, not the full mathematical behavior of every subsystem.
  • textual mathematics should go through symparse rather than raw head construction.
  • several higher-level object families are easier to use through their own package front doors.
impl Add for Expr
impl BitXOr for Expr
impl Compare for Expr
impl Eq for Expr
impl Hash for Expr
impl Mul for Expr
impl Sub for Expr
impl Debug for Expr

#
ExprForm

source
pub enum ExprForm {
  Number(
BigRational)
  Float(Float)
  ComplexFloat(ComplexFloat)
  NumberSymbol(NumberSymbolKind)
  Symbol(String)
  Dummy(String, Int)
  Wild(String, Array[Expr], Array[WildProperty])
  WildFunction(String, Array[Int])
  IdentityFunction
  FunctionHead(String)
  UndefinedFunction(String)
  Apply(Expr, Array[Expr])
  Boolean(Bool)
  Add(Array[Expr])
  Mul(Array[Expr])
  Pow(Expr, Expr)
  Mod(Expr, Expr)
  Tuple(Array[Expr])
  Dict(Array[(Expr, Expr)])
  Relational(RelOp, Expr, Expr)
  Derivative(Expr, Array[Expr])
  Subs(Expr, Expr, Expr)
  Lambda(Expr, Expr)
}

#
Float

source
pub struct Float {
  value : 
RawMpf
  prec : Int
} derive(Eq)

Minimal arbitrary-precision floating literal backed by symnum's mpmath-compatible Mpf.
impl Add for Float
impl Mul for Float
impl Neg for Float
impl Show for Float

#
Float::format

source
fn Float::format(self : Float, dps? : Int) -> String

Render the floating literal with a stable decimal representation.

#
Float::from_double

source
fn Float::from_double(value : Double, prec? : Int, rnd? : 
RoundMode) -> Float

Convert a machine Double into a core Float.

#
Float::from_exact

source

Convert a BigRational into a floating literal.

#
Float::from_int

source
fn Float::from_int(value : Int, prec? : Int) -> Float

Construct a floating literal from an integer.

#
Float::from_mpf

source
fn Float::from_mpf(value : 
RawMpf, prec? : Int) -> Float

Wrap an existing raw Mpf together with the precision it should carry in Symbit's core object layer.

#
Float::from_rational

source

Convert an exact rational into a core Float at the requested precision.

#
Float::from_str

source

Parse a decimal string into a core Float.

#
Float::is_finite

source
fn Float::is_finite(self : Float) -> Bool

True when the underlying payload is finite.

#
Float::precision

source
fn Float::precision(self : Float) -> Int

Return the tracked binary precision.

#
Float::reciprocal

source

#
Float::to_double

source

Convert the floating literal to a machine Double.

#
Float::to_mpf

source

Return the underlying raw Mpf payload.

#
Float::to_rational

source

Convert the floating literal back into an exact rational pair when finite.

#
Kind

source
pub(all) enum Kind {
  NumberKind
  BooleanKind
  TupleKind(Array[Kind])
  UndefinedKind
}

#
NumberSymbolKind

source
pub(all) enum NumberSymbolKind {
  ImaginaryUnit
  Pi
  Exp1
  EulerGamma
  GoldenRatio
  Catalan
  Infinity
  NegativeInfinity
  ComplexInfinity
  NaN
}

#
RelOp

source
pub(all) enum RelOp {
  Eq
  Ne
  Lt
  Le
  Gt
  Ge
}

#
SympifyInput

source
pub(all) enum SympifyInput {
  FromExpr(Expr)
  FromBool(Bool)
  FromInt(Int)
  FromRational(
BigRational)
  FromFloat(Float)
  FromComplexFloat(ComplexFloat)
  NumberSymbol(NumberSymbolKind)
  SymbolName(String)
  DummyName(String)
  WildName(String)
  WildSpec(String, Array[SympifyInput], Array[WildProperty])
  FunctionHeadName(String)
  UndefinedFunctionName(String)
  Application(SympifyInput, Array[SympifyInput])
  Tuple(Array[SympifyInput])
  Dict(Array[(SympifyInput, SympifyInput)])
}

Typed inputs accepted by the sympify coercion entrypoint.

#
WildProperty

source
pub(all) enum WildProperty {
  Symbol
  Integer
  Rational
  Real
  Positive
  Negative
  Finite
  Nonzero
}

#
add

source
fn add(args : Array[Expr]) -> Expr

Build a symbolic sum and apply standard constructor canonicalization.

  • Does: Constructs an additive expression from child expressions.
  • Input: Array[Expr].
  • Returns: A single canonicalized Expr.
  • Limits: This is expression construction, not a full simplification pass.

test "symcore add constructs readable sums" {
  let x = Expr::Symbol("x")
  inspect(@symprint.pretty_string(add([x, int(1)])), content="x + 1")
}

#
application_args

source
fn application_args(expr : Expr) -> Array[Expr]?

#
application_has_name

source
fn application_has_name(expr : Expr, name : String, arity? : Int) -> Bool

#
application_name

source
fn application_name(expr : Expr) -> String?

#
application_parts

source
fn application_parts(expr : Expr) -> (Expr, Array[Expr])?

#
applied_parts

source
fn applied_parts(expr : Expr) -> (String, Array[Expr])?

#
applied_undefined_function

source
fn applied_undefined_function(name : String, args : Array[Expr]) -> Expr

#
apply

source
fn apply(head : Expr, args : Array[Expr]) -> Expr?

#
apply_lambda_expr

source
fn apply_lambda_expr(vars : Expr, body : Expr, args : Array[Expr]) -> Expr?

#
arbitrary_array_use_gen

source
fn[T] arbitrary_array_use_gen(bound : Int, elem_gen : 
Gen[T]) -> 
Gen[Array[T]]

#
arbitrary_polys

source
fn arbitrary_polys() -> 
Gen[Expr]

#
args

source
fn args(expr : Expr) -> Array[Expr]

#
atoms

source
fn atoms(expr : Expr) -> Array[Expr]

#
bool_value

source
fn bool_value(expr : Expr) -> Bool?

#
canonical_derivative_args

source
fn canonical_derivative_args(deriv_args : ArrayView[Expr]) -> Array[Expr]

#
children

source
fn children(expr : Expr) -> ArrayView[Expr]

#
clear_wild_property_resolver

source
fn clear_wild_property_resolver() -> Unit

#
common_kind

source
fn common_kind(kinds : Array[Kind]) -> Kind

#
compare_expr

source
fn compare_expr(a : Expr, b : Expr) -> Int

#
compare_expr_normalized

source
fn compare_expr_normalized(a : Expr, b : Expr) -> Int

#
complex_float_from_exact_parts

source
fn complex_float_from_exact_parts(real : 
BigRational, imag : 
BigRational, prec? : Int) -> ComplexFloat

#
current_distribute

source
fn current_distribute() -> Bool

#
current_evaluate

source
fn current_evaluate() -> Bool

#
current_exp_is_pow

source
fn current_exp_is_pow() -> Bool

#
derivative

source
fn derivative(expr : Expr, wrt : Expr, order? : Expr) -> Expr

Build a derivative expression over a variable and optional order.

  • Does: Constructs a core derivative node.
  • Input: An expression, a differentiation variable, and an optional order.
  • Returns: Expr::Derivative.
  • Limits: This front door builds the expression object only; analytical calculus routines live in higher-level packages.

#
derivative_constructor_expr

source
fn derivative_constructor_expr(expr : Expr, deriv_args : ArrayView[Expr]) -> Expr

#
derivative_parts

source
fn derivative_parts(expr : Expr) -> (Expr, Array[Expr])?

#
derivative_signature_error

source
fn derivative_signature_error(deriv_args : ArrayView[Expr]) -> String?

#
dict_items

source
fn dict_items(expr : Expr) -> Array[(Expr, Expr)]?

#
dummy

source
fn dummy(name? : String) -> Expr

#
dummy_display_name

source
fn dummy_display_name(name : String) -> String

#
dummy_parts

source
fn dummy_parts(expr : Expr) -> (String, Int)?

#
evalf

source
fn evalf(expr : Expr, prec? : Int) -> Expr

Evaluate exact numeric leaves and common transcendental constants/functions into Expr::Float or Expr::ComplexFloat at the requested precision.

#
exact_number_head_name

source
fn exact_number_head_name(kind : ExactNumberKind) -> String

#
exact_number_kind

source
fn exact_number_kind(expr : Expr) -> ExactNumberKind?

#
exact_number_num_den

source

#
exact_numeric_expr_num_den

source

#
expr_display

source
fn expr_display(expr : Expr) -> String

#
expr_form

source
fn expr_form(expr : Expr) -> ExprForm

Expose the structural view of an expression.

  • Does: Converts Expr into its public structural discriminator.
  • Input: Any Expr.
  • Returns: An ExprForm.
  • Limits: This is for branching and inspection, not a stable serialization format.

#
expr_kind

source
fn expr_kind(expr : Expr) -> Kind

#
expr_match

source
fn expr_match(pattern : Expr, expr : Expr, repl_dict? : Map[Expr, Expr]) -> Map[Expr, Expr]?

#
float_from_double

source
fn float_from_double(value : Double, prec? : Int, rnd? : 
RoundMode) -> Float

Top-level convenience wrapper from Double.

#
float_from_exact

source

Top-level convenience wrapper from an exact rational.

#
float_from_str

source

Top-level convenience wrapper matching the rest of symcore.

#
free_symbols

source
fn free_symbols(expr : Expr) -> Array[Expr]

Collect the free symbolic variables occurring in an expression.

  • Does: Walks an expression and extracts its free symbols.
  • Input: Any Expr.
  • Returns: Array[Expr], typically containing Expr::Symbol items.
  • Limits: The order is canonicalized rather than source-order oriented.

#
func

source
fn func(expr : Expr) -> Expr?

#
function

source
fn function(name : String, args : Array[Expr]) -> Expr

Build a named symbolic function application.

  • Does: Constructs expressions such as sin(x), log(x), or f(x).
  • Input: A function name String and Array[Expr] arguments.
  • Returns: A single application Expr.
  • Limits: The head name is taken literally; this front door does not parse textual mathematics.

test "symcore function builds named applications" {
  let x = Expr::Symbol("x")
  inspect(@symprint.pretty_string(function("sin", [x])), content="sin(x)")
}

#
function_head_name

source
fn function_head_name(expr : Expr) -> String?

#
fuzzy_and

source
fn fuzzy_and(args : Array[Bool?]) -> Bool?

#
fuzzy_bool

source
fn fuzzy_bool(value : Bool?) -> Bool?

#
fuzzy_group

source
fn fuzzy_group(args : Array[Bool?], quick_exit? : Bool) -> Bool?

#
fuzzy_nand

source
fn fuzzy_nand(args : Array[Bool?]) -> Bool?

#
fuzzy_not

source
fn fuzzy_not(value : Bool?) -> Bool?

#
fuzzy_or

source
fn fuzzy_or(args : Array[Bool?]) -> Bool?

#
fuzzy_xor

source
fn fuzzy_xor(args : Array[Bool?]) -> Bool?

#
has

source
fn has(expr : Expr, needle : Expr) -> Bool

#
hash_expr_normalized

source
fn hash_expr_normalized(expr : Expr) -> Int

#
head_name

source
fn head_name(expr : Expr) -> String

#
int

source
fn int(value : Int) -> Expr

Build an exact integer atom.

  • Does: Creates a number expression representing an exact integer.
  • Input: A MoonBit Int.
  • Returns: Expr::Number.
  • Limits: This front door accepts machine-sized Int input only.

test "symcore int builds an exact integer expression" {
  inspect(@symprint.pretty_string(int(3)), content="3")
}

#
is_application

source
fn is_application(expr : Expr) -> Bool

#
is_atomic

source
fn is_atomic(expr : Expr) -> Bool

#
is_complex_number_atom

source
fn is_complex_number_atom(expr : Expr) -> Bool

#
is_false

source
fn is_false(expr : Expr) -> Bool

#
is_finite_number_atom

source
fn is_finite_number_atom(expr : Expr) -> Bool

#
is_function_head

source
fn is_function_head(expr : Expr) -> Bool

#
is_infinite

source
fn is_infinite(expr : Expr) -> Bool

#
is_nan

source
fn is_nan(expr : Expr) -> Bool

#
is_number_atom

source
fn is_number_atom(expr : Expr) -> Bool

#
is_number_symbol

source
fn is_number_symbol(expr : Expr) -> Bool

#
is_one

source
fn is_one(expr : Expr) -> Bool

#
is_real_number_atom

source
fn is_real_number_atom(expr : Expr) -> Bool

#
is_singleton_expr

source
fn is_singleton_expr(expr : Expr) -> Bool

#
is_true

source
fn is_true(expr : Expr) -> Bool

#
is_zero

source
fn is_zero(expr : Expr) -> Bool

#
kind_name

source
fn kind_name(kind : Kind) -> String

#
lambda_arity

source
fn lambda_arity(vars : Expr) -> Int?

#
lambda_expr

source
fn lambda_expr(vars : Expr, body : Expr) -> Expr

#
lambda_parts

source
fn lambda_parts(expr : Expr) -> (Expr, Expr)?

#
lambda_signature_error

source
fn lambda_signature_error(vars : Expr) -> String?

#
map_children

source
fn map_children(expr : Expr, f : (Expr) -> Expr) -> Expr

#
mod_expr

source
fn mod_expr(lhs : Expr, rhs : Expr) -> Expr

#
mul

source
fn mul(args : Array[Expr]) -> Expr

Build a symbolic product and apply standard constructor canonicalization.

  • Does: Constructs a multiplicative expression from child expressions.
  • Input: Array[Expr].
  • Returns: A single canonicalized Expr.
  • Limits: It does not replace targeted simplifiers such as rational or trigonometric normalization.

#
normalize_legacy_expr

source
fn normalize_legacy_expr(expr : Expr) -> Expr

#
number_symbol_kind

source
fn number_symbol_kind(expr : Expr) -> NumberSymbolKind?

#
number_symbol_kind_from_name

source
fn number_symbol_kind_from_name(name : String) -> NumberSymbolKind?

#
number_symbol_name

source
fn number_symbol_name(kind : NumberSymbolKind) -> String

#
postorder

source
fn postorder(expr : Expr) -> Array[Expr]

#
pow

source
fn pow(base : Expr, exp : Expr) -> Expr

Build a symbolic power expression.

  • Does: Constructs base**exp using the core power front door.
  • Input: A base Expr and an exponent Expr.
  • Returns: A single Expr.
  • Limits: Advanced algebraic normalization lives in higher-level packages.

#
preorder

source
fn preorder(expr : Expr) -> Array[Expr]

#
rational_from_ints

source
fn rational_from_ints(num : Int, den : Int) -> Expr raise 
RationalError

Build an exact rational atom from a numerator and denominator.

  • Does: Creates a rational expression with exact arithmetic.
  • Input: Two MoonBit Int values.
  • Returns: Expr::Number.
  • Limits: Raises @symnum.RationalError when the denominator is zero.

#
raw_add

source
fn raw_add(args : Array[Expr]) -> Expr

Build Add directly without flattening, sorting, or constant folding.

#
raw_apply

source
fn raw_apply(head : Expr, args : Array[Expr]) -> Expr?

#
raw_derivative

source
fn raw_derivative(expr : Expr, deriv_args : ArrayView[Expr]) -> Expr

#
raw_dict_expr

source
fn raw_dict_expr(items : Array[(Expr, Expr)]) -> Expr

#
raw_function

source
fn raw_function(name : String, args : Array[Expr]) -> Expr

#
raw_mod_expr

source
fn raw_mod_expr(lhs : Expr, rhs : Expr) -> Expr

#
raw_mul

source
fn raw_mul(args : Array[Expr]) -> Expr

#
raw_pow

source
fn raw_pow(base : Expr, exp : Expr) -> Expr

#
rebuild_application

source
fn rebuild_application(expr : Expr, args : Array[Expr]) -> Expr?

#
relational_parts

source
fn relational_parts(expr : Expr) -> (RelOp, Expr, Expr)?

#
replace

source
fn replace(expr : Expr, query : (Expr) -> Bool, value : (Expr) -> Expr) -> Expr

fn s(input : SympifyInput) -> Expr

#
set_wild_property_resolver

source
fn set_wild_property_resolver(resolver : (WildProperty, Expr) -> Bool?) -> Unit

#
singleton_expr_by_name

source
fn singleton_expr_by_name(name : String) -> Expr?

#
singleton_head

source
fn singleton_head(expr : Expr) -> Expr?

#
singleton_instance_name

source
fn singleton_instance_name(expr : Expr) -> String?

#
sort_exprs_in_place

source
fn sort_exprs_in_place(args : Array[Expr]) -> Unit

#
sorted_dict_entries

source
fn sorted_dict_entries(items : Array[(Expr, Expr)]) -> Array[(Expr, Expr)]

#
standalone_function_head_display_name

source
fn standalone_function_head_display_name(name : String) -> String

#
subs_expr

source
fn subs_expr(expr : Expr, variable : Expr, value : Expr) -> Expr

Build or extend a structural substitution expression.

  • Does: Replaces one exact subexpression with another exact subexpression.
  • Input: The target expression, the variable expression, and the replacement expression.
  • Returns: A rewritten Expr, often a Subs node.
  • Limits: Matching is structural; it does not perform algebraic equivalence matching.

test "symcore subs_expr performs structural replacement" {
  let x = Expr::Symbol("x")
  let expr = add([x, int(1)])
  inspect(
    @symprint.pretty_string(subs_expr(expr, x, int(3))),
    content="Subs(x + 1, x, 3)",
  )
}

#
subs_parts

source
fn subs_parts(expr : Expr) -> (Expr, Expr, Expr)?

#
subs_signature_error

source
fn subs_signature_error(variable : Expr, value : Expr) -> String?

#
subst

source
fn subst(expr : Expr, env : Map[String, Expr]) -> Expr

#
sympify

source
fn sympify(input : SympifyInput) -> Expr

Convert a typed value into a core symbolic expression.

  • Does: Lifts a supported host-side input into Expr.
  • Input: A SympifyInput.
  • Returns: A single Expr.
  • Limits: This is typed lifting, not full textual parsing; text parsing belongs in symparse.

test "symcore sympify lifts typed inputs into expr" {
  let expr = sympify(
    SympifyInput::Tuple([
      SympifyInput::FromInt(1),
      SympifyInput::SymbolName("x"),
    ]),
  )
  inspect(@symprint.pretty_string(expr), content="(1, x)")
}

#
sympify_dict

source
fn sympify_dict(items : Array[(SympifyInput, SympifyInput)]) -> Expr

Lift dictionary-like key/value pairs into a first-class core dict node.

#
sympify_name

source
fn sympify_name(name : String) -> Expr

Treat a string as a symbolic name and lift it into Expr.

#
sympify_tuple

source
fn sympify_tuple(items : Array[SympifyInput]) -> Expr

Lift a tuple payload into a first-class core tuple node.

#
torf

source
fn torf(args : Array[Bool?]) -> Bool?

#
tuple_items

source
fn tuple_items(expr : Expr) -> Array[Expr]?

#
undefined_application_parts

source
fn undefined_application_parts(expr : Expr) -> (String, Array[Expr])?

#
wild_display_name

source
fn wild_display_name(name : String) -> String

#
wild_function_matches

source
fn wild_function_matches(pattern : Expr, expr : Expr, repl_dict? : Map[Expr, Expr]) -> Map[Expr, Expr]?

#
wild_function_parts

source
fn wild_function_parts(expr : Expr) -> (String, Array[Int])?

#
wild_matches

source
fn wild_matches(pattern : Expr, expr : Expr, repl_dict? : Map[Expr, Expr]) -> Map[Expr, Expr]?

#
wild_name

source
fn wild_name(expr : Expr) -> String?

#
wild_parts

source
fn wild_parts(expr : Expr) -> (String, Array[Expr], Array[WildProperty])?

#
wild_property_name

source
fn wild_property_name(property : WildProperty) -> String

#
with_distribute

source
fn[T] with_distribute(value : Bool, thunk : () -> T) -> T

#
with_distribute_raise

source
fn[T] with_distribute_raise(value : Bool, thunk : () -> T raise) -> T raise

#
with_evaluate

source
fn[T] with_evaluate(value : Bool, thunk : () -> T) -> T

#
with_evaluate_raise

source
fn[T] with_evaluate_raise(value : Bool, thunk : () -> T raise) -> T raise

#
with_exp_is_pow

source
fn[T] with_exp_is_pow(value : Bool, thunk : () -> T) -> T

#
with_exp_is_pow_raise

source
fn[T] with_exp_is_pow_raise(value : Bool, thunk : () -> T raise) -> T raise

#
xreplace

source
fn xreplace(expr : Expr, rules : Array[(Expr, Expr)]) -> Expr

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io