Skip to content
RustUse

use-math

Set + facade

Math stays clearer when crates stay narrow.

The initial use-math surface stays intentionally narrow: use-math provides the facade layer, while use-geometry and use-combinatorics stay focused crates inside the set.

This page tracks the current public crate tracks in the use-math set and the role the use-math facade crate plays across them.

Scaffolded Pre-1.0 facade crate with canonical RustUse-hosted API docs.

Overview

Section titled “Overview”

The initial use-math set currently surfaces three public crate tracks. use-math is the facade crate for feature-flagged re-exports and a prelude module, use-geometry provides direct 2D primitives and common measurement helpers, and use-combinatorics provides the discrete-math counting track.

Use this page as the combined entry point for the set overview and the use-math facade crate itself.

Supported crates

Section titled “Supported crates”

Facade role

Section titled “Facade role”

Use use-math when you want a curated entry point instead of depending on focused crates one by one.

  • Feature-flagged re-exports from supported crates such as use-geometry
  • A prelude module for common imports
  • Shared convenience helpers that belong at the facade layer
  • Set-level documentation that shows how the supported crates compose

Design direction

Section titled “Design direction”

The facade should stay thin. It should expose high-value conveniences, keep feature flags explicit, and avoid turning the set into a mandatory all-in-one dependency.

Shared conventions and helper types that support the facade belong here only when they make the public surface clearer. They should not become a separate public crate.

Generated Rustdocs

Section titled “Generated Rustdocs”

Copyable source

Copy use-math into your codebase

Copy the scaffolded facade crate as a full source bundle or browse the individual files that define the current use-math facade surface.

Cargo.toml

8 files TOML

Browse crate files 
            [package]
name = "use-math"
description = "Utility-first facade crate for RustUse math utilities"
publish = true
authors.workspace = true
version.workspace = true
edition.workspace = true
license.workspace = true
repository.workspace = true
rust-version.workspace = true
readme = "README.md"
homepage = "https://github.com/RustUse/use-math"
documentation = "https://docs.rs/use-math"
keywords = ["math", "geometry", "facade", "prelude", "utilities"]
categories = ["mathematics", "science"]

[package.metadata.docs.rs]
all-features = true

[features]
default = ["full"]
algebra = ["dep:use-algebra"]
calculus = ["dep:use-calculus"]
catalan = ["dep:use-catalan"]
combinatorics = ["dep:use-combinatorics"]
complex = ["dep:use-complex"]
geometry = ["dep:use-geometry"]
integer = ["dep:use-integer"]
linear = ["dep:use-linear"]
logic = ["dep:use-logic"]
number = ["dep:use-number"]
probability = ["dep:use-probability"]
rational = ["dep:use-rational"]
real = ["dep:use-real"]
series = ["dep:use-series"]
set = ["dep:use-set"]
statistics = ["dep:use-statistics"]
trigonometry = ["dep:use-trigonometry"]
full = [
	"number",
	"integer",
	"rational",
	"real",
	"complex",
	"geometry",
	"combinatorics",
	"series",
	"catalan",
	"algebra",
	"linear",
	"calculus",
	"probability",
	"statistics",
	"trigonometry",
	"logic",
	"set",
]

[dependencies]
use-algebra = { version = "0.0.1", path = "../use-algebra", optional = true }
use-calculus = { version = "0.0.1", path = "../use-calculus", optional = true }
use-catalan = { version = "0.0.1", path = "../use-catalan", optional = true }
use-combinatorics = { version = "0.0.1", path = "../use-combinatorics", optional = true }
use-complex = { version = "0.0.1", path = "../use-complex", optional = true }
use-geometry = { version = "0.0.1", path = "../use-geometry", optional = true }
use-integer = { version = "0.0.1", path = "../use-integer", optional = true }
use-linear = { version = "0.0.1", path = "../use-linear", optional = true }
use-logic = { version = "0.0.1", path = "../use-logic", optional = true }
use-number = { version = "0.0.1", path = "../use-number", optional = true }
use-probability = { version = "0.0.1", path = "../use-probability", optional = true }
use-rational = { version = "0.0.1", path = "../use-rational", optional = true }
use-real = { version = "0.0.1", path = "../use-real", optional = true }
use-series = { version = "0.0.1", path = "../use-series", optional = true }
use-set = { version = "0.0.1", path = "../use-set", optional = true }
use-statistics = { version = "0.0.1", path = "../use-statistics", optional = true }
use-trigonometry = { version = "0.0.1", path = "../use-trigonometry", optional = true }

[[example]]
name = "facade_combinatorics"
required-features = ["combinatorics"]

[[example]]
name = "facade_validated_geometry"
required-features = ["geometry"]

[[test]]
name = "facade_combinatorics"
required-features = ["combinatorics"]

[[test]]
name = "facade_geometry"
required-features = ["geometry"]

[lints]
workspace = true

Composition

Section titled “Composition”

Start with use-geometry when you want direct access to geometry primitives without extra surface area. Reach for use-combinatorics when your work centers on counting, permutations, combinations, or other discrete helpers. Reach for use-math when you want a curated entry point that can re-export selected functionality behind features.

Example API sketch

Section titled “Example API sketch”

The sketch below is illustrative only. Names and signatures are not final.

use use_math::prelude::*;
use use_math::{distance, Point2};


let start = Point2::new(0.0, 0.0);
let end = Point2::new(3.0, 4.0);


assert_eq!(distance(start, end), 5.0);

Status

Section titled “Status”

use-math is a scaffolded public facade crate in the RustUse docs surface. The API remains pre-1.0, and the RustUse-hosted generated rustdocs stay canonical while external crates.io and docs.rs pages remain staged.