[package]
name = "mech-interpreter"
version = "0.3.5"
authors = ["Corey Montella <corey@mech-lang.org>"]
description = "The Mech language runtime."
documentation = "http://docs.mech-lang.org"
homepage = "https://mech-lang.org"
repository = "https://github.com/mech-lang/mech"
keywords = ["mech", "language", "programming", "dataflow", "runtime"]
categories = ["no-std", "science::robotics", "science", "game-engines", "database-implementations"]
license = "Apache-2.0"
readme = "README.md"
edition = "2024"
rust-version = "1.92"

[badges]
gitlab = { repository = "mech-lang/mech", branch = "main" }
maintenance = { status = "actively-developed" }

[features]
no_std = ["mech-core/no_std", "mech-math/no_std", "mech-compare/no_std", "mech-combinatorics/no_std", "mech-logic/no_std", "mech-matrix/no_std", "mech-io/no_std", "mech-stats/no_std", "mech-range/no_std"]

default = ["baselib", "pretty_print", "serde", "compiler", "program", "mika",
  "u8", "u16", "u32", "u64", "u128", 
  "i8", "i16", "i32", "i64", "i128", 
  "f32", "f64", "c64", "r64", 
  "set_default", "math_default", "compare_default", "combinatorics_default", "logic_default",
  "matrix_default", "io_default", "range_default", "stats_default", "string_default",
  "statements_default", "subscript_default", "state_machines",
  "mech-core/default",
  "mech-set/default", "mech-math/default", "mech-compare/default", "mech-combinatorics/default", "mech-logic/default", "mech-matrix/default", "mech-io/default", "mech-stats/default", "mech-range/default", "mech-string/default",
  ]
base = ["baselib", "pretty_print", "serde", "compiler", "program", "mika",
      "set_default", "math_default", "compare_default", "combinatorics_default", "logic_default",
      "matrix_default", "io_default", "range_default", "stats_default", "string_default",
      "statements_default", "subscript_default", "state_machines",
      "mech-core/base", "mech-set/base", "mech-math/base", "mech-compare/base", "mech-combinatorics/base", "mech-logic/base", "mech-matrix/base", "mech-io/base", "mech-stats/base", "mech-range/base", "mech-string/base",
      ]    

trace = []
  
statements_default = ["variable_assign","variable_define","kind_define",
    "mech-core/statements_default", "mech-set/statements_default", "mech-math/statements_default", "mech-compare/statements_default", "mech-combinatorics/statements_default", "mech-logic/statements_default", "mech-matrix/statements_default", "mech-io/statements_default", "mech-stats/statements_default", "mech-range/statements_default", "mech-string/statements_default"]
subscript_default = ["subscript_slice", "subscript_range", "logical_indexing", "swizzle", "subscript_formula", "dot_indexing",
    "mech-core/subscript_default", "mech-set/subscript_default", "mech-math/subscript_default", "mech-compare/subscript_default", "mech-combinatorics/subscript_default", "mech-logic/subscript_default", "mech-matrix/subscript_default", "mech-io/subscript_default", "mech-stats/subscript_default", "mech-range/subscript_default", "mech-string/subscript_default"]

stdlib = ["bool", "string", 
  "u8", "u16", "u32", "u64", "u128", 
  "i8", "i16", "i32", "i64", "i128", 
  "f32", "f64", "c64", "r64", 
  "set", "map", "table", "tuple", "record", "atom",
  "matrix1", "matrix2", "matrix3", "matrix4", "matrix2x3", "matrix3x2",
  "row_vector2", "row_vector3", "row_vector4",
  "vector2", "vector3", "vector4",
  "row_vectord", "vectord", "matrixd",
  "subscript_range", "logical_indexing", "swizzle",
  "subscript_formula", "dot_indexing",
  "variable_define", "variable_assign", "kind_define",
  "kind_annotation", "variables",
  "functions", "formulas",
  "access", "assign", "convert",
  "mech-core/stdlib", "mech-set/stdlib", "mech-math/stdlib", "mech-compare/stdlib", "mech-combinatorics/stdlib", "mech-logic/stdlib", "mech-matrix/stdlib", "mech-io/stdlib", "mech-stats/stdlib", "mech-range/stdlib", "mech-string/stdlib"
    ]

baselib = ["bool", "string", 
      "f64", "c64", "r64",
      "set", "map", "table", "tuple", "record", "atom", "enum",
      "row_vectord", "vectord", "matrixd",
      "subscript_range", "logical_indexing", 
      "subscript_formula",
      "variable_define", "variable_assign", 
      "kind_define",
      "kind_annotation", "variables",
      "access", "assign", "convert",
      "functions", "formulas",
      "mech-core/baselib", "mech-set/baselib", "mech-math/baselib", "mech-compare/baselib", "mech-combinatorics/baselib", "mech-logic/baselib", "mech-matrix/baselib", "mech-io/baselib", "mech-stats/baselib", "mech-range/baselib", "mech-string/baselib"
    ]

compiler = ["mech-core/compiler", "mech-set/compiler", "mech-math/compiler", "mech-compare/compiler", "mech-combinatorics/compiler", "mech-logic/compiler", "mech-matrix/compiler", "mech-io/compiler", "mech-stats/compiler", "mech-range/compiler", "mech-string/compiler"]
program = ["mech-core/program", "mech-set/program", "mech-math/program", "mech-compare/program", "mech-combinatorics/program", "mech-logic/program", "mech-matrix/program", "mech-io/program", "mech-stats/program", "mech-range/program", "mech-string/program"]
pretty_print = ["mech-core/pretty_print", "mech-set/pretty_print", "mech-math/pretty_print", "mech-compare/pretty_print", "mech-combinatorics/pretty_print", "mech-logic/pretty_print", "mech-matrix/pretty_print", "mech-io/pretty_print", "mech-stats/pretty_print", "mech-range/pretty_print", "mech-string/pretty_print"]
serde = ["mech-core/serde", "mech-set/serde", "mech-math/serde", "mech-compare/serde", "mech-combinatorics/serde", "mech-logic/serde", "mech-matrix/serde", "mech-io/serde", "mech-stats/serde", "mech-range/serde", "mech-string/serde"]
mika = ["mech-core/mika"]

statements = ["mech-core/statements", "mech-set/statements", "mech-math/statements", "mech-compare/statements", "mech-combinatorics/statements", "mech-logic/statements", "mech-matrix/statements", "mech-io/statements", "mech-stats/statements", "mech-range/statements", "mech-string/statements"]
variables = ["variable_define", "symbol_table", "mech-core/variables", "mech-set/variables", "mech-math/variables", "mech-compare/variables", "mech-combinatorics/variables", "mech-logic/variables", "mech-matrix/variables", "mech-io/variables", "mech-stats/variables", "mech-range/variables", "mech-string/variables"]
variable_define = ["statements", "functions", "mech-core/variable_define", "mech-set/variable_define", "mech-math/variable_define", "mech-compare/variable_define", "mech-combinatorics/variable_define", "mech-logic/variable_define", "mech-matrix/variable_define", "mech-io/variable_define", "mech-stats/variable_define", "mech-range/variable_define", "mech-string/variable_define"]
variable_assign = ["assign", "statements", "mech-core/variable_assign", "mech-set/variable_assign", "mech-math/variable_assign", "mech-compare/variable_assign", "mech-combinatorics/variable_assign", "mech-logic/variable_assign", "mech-matrix/variable_assign", "mech-io/variable_assign", "mech-stats/variable_assign", "mech-range/variable_assign", "mech-string/variable_assign"]
kind_define = ["kind_annotation", "functions", "statements", "mech-core/kind_define", "mech-set/kind_define", "mech-math/kind_define", "mech-compare/kind_define", "mech-combinatorics/kind_define", "mech-logic/kind_define", "mech-matrix/kind_define", "mech-io/kind_define", "mech-stats/kind_define", "mech-range/kind_define", "mech-string/kind_define"]
kind_annotation = ["functions", "mech-core/kind_annotation", "mech-set/kind_annotation", "mech-math/kind_annotation", "mech-compare/kind_annotation", "mech-combinatorics/kind_annotation", "mech-logic/kind_annotation", "mech-matrix/kind_annotation", "mech-io/kind_annotation", "mech-stats/kind_annotation", "mech-range/kind_annotation", "mech-string/kind_annotation"]
formulas = ["mech-core/formulas", "mech-set/formulas", "mech-math/formulas", "mech-compare/formulas", "mech-combinatorics/formulas", "mech-logic/formulas", "mech-matrix/formulas", "mech-io/formulas", "mech-stats/formulas", "mech-range/formulas", "mech-string/formulas"]
functions = ["symbol_table", "mech-core/functions", "mech-set/functions", "mech-math/functions", "mech-compare/functions", "mech-combinatorics/functions", "mech-logic/functions", "mech-matrix/functions", "mech-io/functions", "mech-stats/functions", "mech-range/functions", "mech-string/functions"]
state_machines = ["functions", "statements", "atom", "tuple", "formulas"]
symbol_table = ["mech-core/symbol_table", "mech-set/symbol_table", "mech-math/symbol_table", "mech-compare/symbol_table", "mech-combinatorics/symbol_table", "mech-logic/symbol_table", "mech-matrix/symbol_table", "mech-io/symbol_table", "mech-stats/symbol_table", "mech-range/symbol_table", "mech-string/symbol_table"]

access = ["functions"]
assign = ["functions"]
convert = ["functions"]

bool = ["mech-core/bool", "mech-set/bool", "mech-compare/bool", "mech-math/bool", "mech-combinatorics/bool", "mech-logic/bool", "mech-matrix/bool", "mech-io/bool", "mech-stats/bool", "mech-range/bool", "mech-string/bool"]
string = ["mech-string", "mech-core/string", "mech-set/string", "mech-math/string", "mech-compare/string", "mech-combinatorics/string", "mech-logic/string", "mech-matrix/string", "mech-io/string", "mech-stats/string", "mech-range/string", "mech-string/string"]

# Numbers
numbers = ["mech-core/numbers", "mech-set/numbers", "mech-math/numbers", "mech-compare/numbers", "mech-combinatorics/numbers", "mech-logic/numbers", "mech-matrix/numbers", "mech-io/numbers", "mech-stats/numbers", "mech-range/numbers", "mech-string/numbers"]
complex = ["f64", "numbers", "mech-core/complex", "mech-set/complex", "mech-math/complex", "mech-compare/complex", "mech-combinatorics/complex", "mech-logic/complex", "mech-matrix/complex", "mech-io/complex", "mech-stats/complex", "mech-range/complex", "mech-string/complex"]
rational = ["i64", "numbers", "mech-core/rational", "mech-set/rational", "mech-math/rational", "mech-compare/rational", "mech-combinatorics/rational", "mech-logic/rational", "mech-matrix/rational", "mech-io/rational", "mech-stats/rational", "mech-range/rational", "mech-string/rational"]
signed_ints = ["numbers", "mech-core/signed_ints", "mech-set/signed_ints", "mech-math/signed_ints", "mech-compare/signed_ints", "mech-combinatorics/signed_ints", "mech-logic/signed_ints", "mech-matrix/signed_ints", "mech-io/signed_ints", "mech-stats/signed_ints", "mech-range/signed_ints", "mech-string/signed_ints"]
unsigned_ints = ["numbers", "mech-core/unsigned_ints", "mech-set/unsigned_ints", "mech-math/unsigned_ints", "mech-compare/unsigned_ints", "mech-combinatorics/unsigned_ints", "mech-logic/unsigned_ints", "mech-matrix/unsigned_ints", "mech-io/unsigned_ints", "mech-stats/unsigned_ints", "mech-range/unsigned_ints", "mech-string/unsigned_ints"]
floats = ["numbers", "mech-core/floats", "mech-set/floats", "mech-math/floats", "mech-compare/floats", "mech-combinatorics/floats", "mech-logic/floats", "mech-matrix/floats", "mech-io/floats", "mech-stats/floats", "mech-range/floats", "mech-string/floats"]
u8 = ["unsigned_ints", "mech-core/u8", "mech-set/u8", "mech-math/u8", "mech-compare/u8", "mech-combinatorics/u8", "mech-logic/u8", "mech-matrix/u8", "mech-io/u8", "mech-stats/u8", "mech-range/u8", "mech-string/u8"]
u16 = ["unsigned_ints", "mech-core/u16", "mech-set/u16", "mech-math/u16", "mech-compare/u16", "mech-combinatorics/u16", "mech-logic/u16", "mech-matrix/u16", "mech-io/u16", "mech-stats/u16", "mech-range/u16", "mech-string/u16"]
u32 = ["unsigned_ints", "mech-core/u32", "mech-set/u32", "mech-math/u32", "mech-compare/u32", "mech-combinatorics/u32", "mech-logic/u32", "mech-matrix/u32", "mech-io/u32", "mech-stats/u32", "mech-range/u32", "mech-string/u32"]
u64 = ["unsigned_ints", "mech-core/u64", "mech-set/u64", "mech-math/u64", "mech-compare/u64", "mech-combinatorics/u64", "mech-logic/u64", "mech-matrix/u64", "mech-io/u64", "mech-stats/u64", "mech-range/u64", "mech-string/u64"]
u128 = ["unsigned_ints", "mech-core/u128", "mech-set/u128", "mech-math/u128", "mech-compare/u128", "mech-combinatorics/u128", "mech-logic/u128", "mech-matrix/u128", "mech-io/u128", "mech-stats/u128", "mech-range/u128", "mech-string/u128"]
i8 = ["signed_ints", "mech-core/i8", "mech-set/i8", "mech-math/i8", "mech-compare/i8", "mech-combinatorics/i8", "mech-logic/i8", "mech-matrix/i8", "mech-io/i8", "mech-stats/i8", "mech-range/i8", "mech-string/i8"]
i16 = ["signed_ints", "mech-core/i16", "mech-set/i16", "mech-math/i16", "mech-compare/i16", "mech-combinatorics/i16", "mech-logic/i16", "mech-matrix/i16", "mech-io/i16", "mech-stats/i16", "mech-range/i16", "mech-string/i16"]
i32 = ["signed_ints", "mech-core/i32", "mech-set/i32", "mech-math/i32", "mech-compare/i32", "mech-combinatorics/i32", "mech-logic/i32", "mech-matrix/i32", "mech-io/i32", "mech-stats/i32", "mech-range/i32", "mech-string/i32"]
i64 = ["signed_ints", "mech-core/i64", "mech-set/i64", "mech-math/i64", "mech-compare/i64", "mech-combinatorics/i64", "mech-logic/i64", "mech-matrix/i64", "mech-io/i64", "mech-stats/i64", "mech-range/i64", "mech-string/i64"]
i128 = ["signed_ints", "mech-core/i128", "mech-set/i128", "mech-math/i128", "mech-compare/i128", "mech-combinatorics/i128", "mech-logic/i128", "mech-matrix/i128", "mech-io/i128", "mech-stats/i128", "mech-range/i128", "mech-string/i128"]
f32 = ["floats", "mech-core/f32", "mech-set/f32", "mech-math/f32", "mech-compare/f32", "mech-combinatorics/f32", "mech-logic/f32", "mech-matrix/f32", "mech-io/f32", "mech-stats/f32", "mech-range/f32", "mech-string/f32"]
f64 = ["floats", "mech-core/f64", "mech-set/f64", "mech-math/f64", "mech-compare/f64", "mech-combinatorics/f64", "mech-logic/f64", "mech-matrix/f64", "mech-io/f64", "mech-stats/f64", "mech-range/f64", "mech-string/f64"]
c64 = ["complex", "mech-core/c64", "mech-set/c64", "mech-math/c64", "mech-compare/c64", "mech-combinatorics/c64", "mech-logic/c64", "mech-matrix/c64", "mech-io/c64", "mech-stats/c64", "mech-range/c64", "mech-string/c64"]
r64 = ["rational", "mech-core/r64", "mech-set/r64", "mech-math/r64", "mech-compare/r64", "mech-combinatorics/r64", "mech-logic/r64", "mech-matrix/r64", "mech-io/r64", "mech-stats/r64", "mech-range/r64", "mech-string/r64"]

# Structs
set = ["indexmap", "mech-core/set", "mech-set/set", "mech-math/set", "mech-compare/set", "mech-combinatorics/set", "mech-logic/set", "mech-matrix/set", "mech-io/set", "mech-stats/set", "mech-range/set", "mech-string/set", "functions"]
map = ["indexmap", "mech-core/map", "mech-set/map", "mech-math/map", "mech-compare/map", "mech-combinatorics/map", "mech-logic/map", "mech-matrix/map", "mech-io/map", "mech-stats/map", "mech-range/map", "mech-string/map"]
table = ["indexmap", "vectord", "record", "mech-core/table", "mech-set/table", "mech-math/table", "mech-compare/table", "mech-combinatorics/table", "mech-logic/table", "mech-matrix/table", "mech-io/table", "mech-stats/table", "mech-range/table", "mech-string/table"]
tuple = ["mech-core/tuple", "mech-set/tuple", "mech-math/tuple", "mech-compare/tuple", "mech-combinatorics/tuple", "mech-logic/tuple", "mech-matrix/tuple", "mech-io/tuple", "mech-stats/tuple", "mech-range/tuple", "mech-string/tuple"]
enum = ["mech-core/enum", "mech-set/enum", "mech-math/enum", "mech-compare/enum", "mech-combinatorics/enum", "mech-logic/enum", "mech-matrix/enum", "mech-io/enum", "mech-stats/enum", "mech-range/enum", "mech-string/enum"]
record = ["indexmap", "tuple", "mech-core/record", "mech-set/record", "mech-math/record", "mech-compare/record", "mech-combinatorics/record", "mech-logic/record", "mech-matrix/record", "mech-io/record", "mech-stats/record", "mech-range/record", "mech-string/record"]
atom = ["mech-core/atom", "mech-set/atom", "mech-math/atom", "mech-compare/atom", "mech-combinatorics/atom", "mech-logic/atom", "mech-matrix/atom", "mech-io/atom", "mech-stats/atom", "mech-range/atom", "mech-string/atom"]

# Matrix
matrix = ["nalgebra", "mech-core/matrix", "mech-set/matrix", "mech-math/matrix", "mech-compare/matrix", "mech-combinatorics/matrix", "mech-logic/matrix", "mech-matrix/matrix", "mech-io/matrix", "mech-stats/matrix", "mech-range/matrix", "mech-string/matrix"]
fixed_row_vector = ["row_vector4", "row_vector3", "row_vector2", "mech-core/fixed_row_vector", "mech-set/fixed_row_vector", "mech-math/fixed_row_vector", "mech-compare/fixed_row_vector", "mech-combinatorics/fixed_row_vector", "mech-logic/fixed_row_vector", "mech-matrix/fixed_row_vector", "mech-io/fixed_row_vector", "mech-stats/fixed_row_vector", "mech-range/fixed_row_vector", "mech-string/fixed_row_vector", "matrix"]
fixed_vector = ["vector4", "vector3", "vector2", "mech-core/fixed_vector", "mech-set/fixed_vector", "mech-math/fixed_vector", "mech-compare/fixed_vector", "mech-combinatorics/fixed_vector", "mech-logic/fixed_vector", "mech-matrix/fixed_vector", "mech-io/fixed_vector", "mech-stats/fixed_vector", "mech-range/fixed_vector", "mech-string/fixed_vector", "matrix"]
fixed_matrix = ["matrix4", "matrix3", "matrix2", "matrix1", "matrix2x3", "matrix3x2", "mech-core/fixed_matrix", "mech-set/fixed_matrix", "mech-math/fixed_matrix", "mech-compare/fixed_matrix", "mech-combinatorics/fixed_matrix", "mech-logic/fixed_matrix", "mech-matrix/fixed_matrix", "mech-io/fixed_matrix", "mech-stats/fixed_matrix", "mech-range/fixed_matrix", "mech-string/fixed_matrix", "matrix"]
dynamic_matrix = ["matrixd", "vectord", "row_vectord", "mech-core/dynamic_matrix", "mech-set/dynamic_matrix", "mech-math/dynamic_matrix", "mech-compare/dynamic_matrix", "mech-combinatorics/dynamic_matrix", "mech-logic/dynamic_matrix", "mech-matrix/dynamic_matrix", "mech-io/dynamic_matrix", "mech-stats/dynamic_matrix", "mech-range/dynamic_matrix", "mech-string/dynamic_matrix", "matrix"]
row_vector4 = ["matrix", "matrix_horzcat", "mech-core/row_vector4", "mech-set/row_vector4", "mech-math/row_vector4", "mech-compare/row_vector4", "mech-combinatorics/row_vector4", "mech-logic/row_vector4", "mech-matrix/row_vector4", "mech-io/row_vector4", "mech-stats/row_vector4", "mech-range/row_vector4", "mech-string/row_vector4"]
row_vector3 = ["matrix", "matrix_horzcat", "mech-core/row_vector3", "mech-set/row_vector3", "mech-math/row_vector3", "mech-compare/row_vector3", "mech-combinatorics/row_vector3", "mech-logic/row_vector3", "mech-matrix/row_vector3", "mech-io/row_vector3", "mech-stats/row_vector3", "mech-range/row_vector3", "mech-string/row_vector3"]
row_vector2 = ["matrix", "matrix_horzcat", "mech-core/row_vector2", "mech-set/row_vector2", "mech-math/row_vector2", "mech-compare/row_vector2", "mech-combinatorics/row_vector2", "mech-logic/row_vector2", "mech-matrix/row_vector2", "mech-io/row_vector2", "mech-stats/row_vector2", "mech-range/row_vector2", "mech-string/row_vector2"]
vector4 = ["matrix", "matrix_vertcat", "mech-core/vector4", "mech-set/vector4", "mech-math/vector4", "mech-compare/vector4", "mech-combinatorics/vector4", "mech-logic/vector4", "mech-matrix/vector4", "mech-io/vector4", "mech-stats/vector4", "mech-range/vector4", "mech-string/vector4"]
vector3 = ["matrix", "matrix_vertcat", "mech-core/vector3", "mech-set/vector3", "mech-math/vector3", "mech-compare/vector3", "mech-combinatorics/vector3", "mech-logic/vector3", "mech-matrix/vector3", "mech-io/vector3", "mech-stats/vector3", "mech-range/vector3", "mech-string/vector3"]
vector2 = ["matrix", "matrix_vertcat", "mech-core/vector2", "mech-set/vector2", "mech-math/vector2", "mech-compare/vector2", "mech-combinatorics/vector2", "mech-logic/vector2", "mech-matrix/vector2", "mech-io/vector2", "mech-stats/vector2", "mech-range/vector2", "mech-string/vector2"]
matrix4 = ["matrix", "matrix_horzcat", "matrix_vertcat", "mech-core/matrix4", "mech-set/matrix4", "mech-math/matrix4", "mech-compare/matrix4", "mech-combinatorics/matrix4", "mech-logic/matrix4", "mech-matrix/matrix4", "mech-io/matrix4", "mech-stats/matrix4", "mech-range/matrix4", "mech-string/matrix4"]
matrix3 = ["matrix", "matrix_horzcat", "matrix_vertcat", "mech-core/matrix3", "mech-set/matrix3", "mech-math/matrix3", "mech-compare/matrix3", "mech-combinatorics/matrix3", "mech-logic/matrix3", "mech-matrix/matrix3", "mech-io/matrix3", "mech-stats/matrix3", "mech-range/matrix3", "mech-string/matrix3"]
matrix2 = ["matrix", "matrix_horzcat", "matrix_vertcat", "mech-core/matrix2", "mech-set/matrix2", "mech-math/matrix2", "mech-compare/matrix2", "mech-combinatorics/matrix2", "mech-core/matrix", "mech-logic/matrix2", "mech-matrix/matrix2", "mech-io/matrix2", "mech-stats/matrix2", "mech-range/matrix2", "mech-string/matrix2"]
matrix1 = ["matrix", "matrix_horzcat", "matrix_vertcat", "mech-core/matrix1", "mech-set/matrix1", "mech-math/matrix1", "mech-compare/matrix1", "mech-combinatorics/matrix1", "mech-logic/matrix1", "mech-matrix/matrix1", "mech-io/matrix1", "mech-stats/matrix1", "mech-range/matrix1", "mech-string/matrix1"]
matrix2x3 = ["matrix", "matrix_horzcat", "matrix_vertcat", "mech-core/matrix2x3", "mech-set/matrix2x3", "mech-math/matrix2x3", "mech-compare/matrix2x3", "mech-combinatorics/matrix2x3", "mech-logic/matrix2x3", "mech-matrix/matrix2x3", "mech-io/matrix2x3", "mech-stats/matrix2x3", "mech-range/matrix2x3", "mech-string/matrix2x3"]
matrix3x2 = ["matrix", "matrix_horzcat", "matrix_vertcat", "mech-core/matrix3x2", "mech-set/matrix3x2", "mech-math/matrix3x2", "mech-compare/matrix3x2", "mech-combinatorics/matrix3x2", "mech-logic/matrix3x2", "mech-matrix/matrix3x2", "mech-io/matrix3x2", "mech-stats/matrix3x2", "mech-range/matrix3x2", "mech-string/matrix3x2"]
row_vectord =["matrix", "matrix_horzcat", "mech-core/row_vectord", "mech-set/row_vectord", "mech-math/row_vectord", "mech-compare/row_vectord", "mech-combinatorics/row_vectord", "mech-logic/row_vectord", "mech-matrix/row_vectord", "mech-io/row_vectord", "mech-stats/row_vectord", "mech-range/row_vectord", "mech-string/row_vectord"]
vectord = ["matrix", "matrix_vertcat", "mech-core/vectord", "mech-set/vectord", "mech-math/vectord", "mech-compare/vectord", "mech-combinatorics/vectord", "mech-logic/vectord", "mech-matrix/vectord", "mech-io/vectord", "mech-stats/vectord", "mech-range/vectord", "mech-string/vectord"]
matrixd = ["matrix", "matrix_horzcat", "matrix_vertcat", "mech-core/matrixd", "mech-set/matrixd", "mech-math/matrixd", "mech-compare/matrixd", "mech-combinatorics/matrixd", "mech-logic/matrixd", "mech-matrix/matrixd", "mech-io/matrixd", "mech-stats/matrixd", "mech-range/matrixd", "mech-string/matrixd"]

# Subscripts
subscript = ["mech-core/subscript", "mech-set/subscript", "mech-math/subscript", "mech-compare/subscript", "mech-combinatorics/subscript", "mech-logic/subscript", "mech-matrix/subscript", "mech-io/subscript", "mech-stats/subscript", "mech-range/subscript", "mech-string/subscript"]
subscript_slice = ["subscript", "vectord", "mech-core/subscript_slice", "mech-set/subscript_slice", "mech-math/subscript_slice", "mech-compare/subscript_slice", "mech-combinatorics/subscript_slice", "mech-logic/subscript_slice", "mech-matrix/subscript_slice", "mech-io/subscript_slice", "mech-stats/subscript_slice", "mech-range/subscript_slice", "mech-string/subscript_slice"]
subscript_range = ["range", "subscript_slice", "vectord", "mech-core/subscript_range", "mech-set/subscript_range", "mech-math/subscript_range", "mech-compare/subscript_range", "mech-combinatorics/subscript_range", "mech-logic/subscript_range", "mech-matrix/subscript_range", "mech-io/subscript_range", "mech-stats/subscript_range", "mech-range/subscript_range", "mech-string/subscript_range"]
subscript_formula = ["subscript_slice", "formulas", "mech-core/subscript_formula", "mech-set/subscript_formula", "mech-math/subscript_formula", "mech-compare/subscript_formula", "mech-combinatorics/subscript_formula", "mech-logic/subscript_formula", "mech-matrix/subscript_formula", "mech-io/subscript_formula", "mech-stats/subscript_formula", "mech-range/subscript_formula", "mech-string/subscript_formula"]
logical_indexing = ["subscript", "vectord", "bool", "mech-core/logical_indexing", "mech-set/logical_indexing", "mech-math/logical_indexing", "mech-compare/logical_indexing", "mech-combinatorics/logical_indexing", "mech-logic/logical_indexing", "mech-matrix/logical_indexing", "mech-io/logical_indexing", "mech-stats/logical_indexing", "mech-range/logical_indexing", "mech-string/logical_indexing"]
dot_indexing = ["subscript", "mech-core/dot_indexing", "mech-set/dot_indexing", "mech-math/dot_indexing", "mech-compare/dot_indexing", "mech-combinatorics/dot_indexing", "mech-logic/dot_indexing", "mech-matrix/dot_indexing", "mech-io/dot_indexing", "mech-stats/dot_indexing", "mech-range/dot_indexing", "mech-string/dot_indexing"]
swizzle = ["subscript", "mech-core/swizzle", "mech-set/swizzle", "mech-math/swizzle", "mech-compare/swizzle", "mech-combinatorics/swizzle", "mech-logic/swizzle", "mech-matrix/swizzle", "mech-io/swizzle", "mech-stats/swizzle", "mech-range/swizzle", "mech-string/swizzle"]

# Libs
# -----------------------------------------------------------------------------

# Stats
stats_default = ["stats_sum"]
stats = ["num-traits", "functions", "mech-stats/stats"]
stats_sum = ["stats", "mech-stats/sum"]

# Io
io_default = ["io_print", "io_println", "mech-io/io_default"]
io = ["functions"]
io_print = ["io", "mech-io/print"]
io_println = ["io", "mech-io/println"]

# Matrix
matrix_default = ["matrix_solve", "matrix_dot", "matrix_horzcat", "matrix_vertcat", "matrix_matmul", "matrix_transpose", "mech-matrix/matrix_default", "matrix_comprehensions"]
matrix_comprehensions = ["functions", "matrix", "mech-matrix/comprehensions"]              
matrix_horzcat = ["matrix", "functions"]
matrix_vertcat = ["matrix", "functions"]
matrix_solve = ["matrix", "mech-matrix/solve"]
matrix_matmul = ["matrix", "mech-matrix/matmul"]
matrix_transpose = ["matrix", "mech-matrix/transpose"]
matrix_dot = ["matrix", "mech-matrix/dot"]

# Logic
logic_default = ["logic_and", "logic_or", "logic_not", "logic_xor", "mech-logic/logic_default"]
logic = ["bool", "mech-logic/logic"]
logic_and = ["logic", "mech-logic/and"]
logic_or = ["logic", "mech-logic/or"]
logic_not = ["logic", "mech-logic/not"]
logic_xor = ["logic", "mech-logic/xor"]

# Combinatorics
combinatorics_default = ["combinatorics_n_choose_k", "mech-combinatorics/combinatorics_default"]
combinatorics = ["num-traits", "functions", "mech-combinatorics/combinatorics"]
combinatorics_n_choose_k = ["combinatorics", "mech-combinatorics/n_choose_k"]

# Compare
compare_default = ["compare_lt", "compare_gt", "compare_lte", "compare_gte", "compare_eq", "compare_neq", "mech-compare/compare_default"]
compare = ["functions", "bool", "mech-compare/compare"]
compare_eq = ["compare", "mech-compare/eq"]
compare_neq = ["compare", "mech-compare/neq"]
compare_lt = ["compare", "mech-compare/lt"]
compare_gt = ["compare", "mech-compare/gt"]
compare_lte = ["compare", "mech-compare/lte"]
compare_gte = ["compare", "mech-compare/gte"]

# Range
range_default = ["range_inclusive", "range_exclusive", "mech-range/range_default"]
range = ["functions", "formulas", "mech-range/range"]
range_inclusive = ["range", "mech-range/inclusive"]
range_exclusive = ["range", "mech-range/exclusive"]

# Math
math_default = ["math_ops_default", "math_root_default", "math_ops_assign_default", "math_trig_default", "mech-math/math_default"]
math = ["mech-math/math", "formulas", "functions"]
math_ops_default = ["math_add", "math_sub", "math_mul", "math_div", "math_pow", "math_mod", "math_neg"]
math_root_default = ["math_sqrt", "mech-math/root_default"]
math_ops_assign_default = ["math_add_assign", "math_sub_assign", "math_mul_assign", "math_div_assign"]
math_trig_default = ["math_acos", "math_acosh", "math_acot", "math_acsc", "math_asec", "math_asin", "math_asinh", "math_atan", "math_atan2", "math_atanh", "math_cos", "math_cosh", "math_cot", "math_csc", "math_sec", "math_sin", "math_sinh", "math_tan", "math_tanh"]
math_trig = ["math", "mech-math/trig"]
math_root = ["math", "mech-math/root"]
math_ops = ["math", "mech-math/ops"]
math_op_assign = ["math", "mech-math/op_assign"]
math_add_assign = ["math_op_assign", "mech-math/add_assign"]
math_sub_assign = ["math_op_assign", "mech-math/sub_assign"]
math_mul_assign = ["math_op_assign", "mech-math/mul_assign"]
math_div_assign = ["math_op_assign", "mech-math/div_assign"]
math_acos = ["math_trig", "mech-math/acos"]
math_acosh = ["math_trig", "mech-math/acosh"]
math_acot = ["math_trig", "mech-math/acot"]
math_acsc = ["math_trig", "mech-math/acsc"]
math_asec = ["math_trig", "mech-math/asec"]
math_asin = ["math_trig", "mech-math/asin"]
math_asinh = ["math_trig", "mech-math/asinh"]
math_atan = ["math_trig", "mech-math/atan"]
math_atan2 = ["math_trig", "mech-math/atan2"]
math_atanh = ["math_trig", "mech-math/atanh"]
math_cos = ["math_trig", "mech-math/cos"]
math_cosh = ["math_trig", "mech-math/cosh"]
math_cot = ["math_trig", "mech-math/cot"]
math_csc = ["math_trig", "mech-math/csc"]
math_sec = ["math_trig", "mech-math/sec"]
math_sin = ["math_trig", "mech-math/sin"]
math_sinh = ["math_trig", "mech-math/sinh"]
math_tan = ["math_trig", "mech-math/tan"]
math_tanh = ["math_trig", "mech-math/tanh"]
math_add = ["math_ops", "mech-math/add"]
math_sub = ["math_ops", "mech-math/sub"]
math_mul = ["math_ops", "mech-math/mul"]
math_div = ["math_ops", "mech-math/div"]
math_pow = ["math_ops", "mech-math/pow"]
math_mod = ["math_ops", "mech-math/mod"]
math_neg = ["math_ops", "mech-math/neg"]
math_sqrt = ["math_root", "mech-math/sqrt"]

# Set
set_default = ["set_membership_default", "set_modify_default",
              "set_operations_default", "set_relations_default",
              "set_comprehensions", "set_setdata_default"]
set_comprehensions = ["functions", "set", "mech-set/comprehensions"]              
set_membership_default = ["set_element_of", "set_not_element_of"]
set_modify_default = ["set_insert", "set_remove"]
set_operations_default = ["set_cartesian_product", "set_difference", "set_intersection", "set_powerset", "set_symmetric_difference", "set_union"]
set_relations_default = ["set_disjoint", "set_equals", "set_not_equals", "set_proper_subset", "set_proper_superset", "set_subset", "set_superset"]
set_setdata_default = ["set_size"]
set_size = ["set", "mech-set/size"]
set_insert = ["set", "mech-set/insert"]
set_remove = ["set", "mech-set/remove"]
set_powerset = ["set", "mech-set/powerset"]
set_symmetric_difference = ["set", "mech-set/symmetric_difference"]
set_disjoint = ["set", "mech-set/disjoint"]
set_equals = ["set", "mech-set/equals"]
set_not_equals = ["set", "mech-set/not_equals"]
set_element_of = ["set", "mech-set/element_of"]
set_not_element_of = ["set", "mech-set/not_element_of"]
set_proper_subset = ["set", "mech-set/proper_subset"]
set_proper_superset = ["set", "mech-set/proper_superset"]
set_subset = ["set", "mech-set/subset"]
set_superset = ["set", "mech-set/superset"]
set_difference = ["set", "mech-set/difference"]
set_intersection = ["set", "mech-set/intersection"]
set_union = ["set", "mech-set/union"]
set_cartesian_product = ["set", "mech-set/cartesian_product"]

# String
string_default = ["string_concat", "mech-string/string_default"]
string_concat = ["string", "mech-string/concat"]

[dependencies]
mech-core = {version = "0.3.5", default-features = false}
mech-math = { version = "0.3.5", default-features = false, optional = true}
mech-logic = { version = "0.3.5", default-features = false, optional = true }
mech-range = { version = "0.3.5", default-features = false, optional = true }
mech-matrix = { version = "0.3.5", default-features = false, optional = true }
mech-compare = { version = "0.3.5", default-features = false, optional = true }
mech-stats = { version = "0.3.5", default-features = false, optional = true }
mech-io = { version = "0.3.5", default-features = false, optional = true }
mech-set = { version = "0.3.5", default-features = false, optional = true }
mech-combinatorics = { version = "0.3.5", default-features = false, optional = true }
mech-string = { version = "0.3.5", default-features = false, optional = true }

paste = "1.0.15"
byteorder = "1.5.0"
inventory = "0.3.22"
nalgebra = {version = "0.34.1", optional = true}
indexmap = {version = "2.13.0", optional = true}
bincode = {version = "2.0.1", optional = true}

[dependencies.num-traits]
version = "0.2.19"
default-features = false
features = ["libm"]
optional = true
