# Logical And A logical and operator for all you conjunctive needs. It would short circuit if that were possible, but here we are. ```rust # use tra

The bool type (`true`, `false`)

# Equality testing ```rust # use trait_eval::*; type TwoPlusTwo = <Two as Plus<Two>>::Result; type IsFour = <TwoPlusTwo as Equals<Four>>::Result; ass

# `trait_eval` to Rust conversion Here's a magic trait for getting your data out of `trait_eval` and into Rust. Don't worry - it doesn't actually eva

# Factorial! Did I hear shouting? Or was that just this epic compile-time factorial operator?! ```rust # #![recursion_limit = "20000000"] # use trai

False (`false`)

# Built-in Fibonacci sequence Of course, every programmer uses the Fibonacci sequence on the daily, so we've built it right into the library. Now you

# Conditional execution! The syntax is kind of clunky, but write `<(Then, Else) as If<Cond>::Result`. The condition can be any boolean expression bui

# Integer comparison I honestly can't be bothered to implement `<=`, `>=` and `>`, so you're just going to have to make do with this and [`Not`](trai

# Saturating Subtraction It's 2:30AM and I've completely run out of snappy sales pitches. It's subtraction - wow. ```rust # use trait_eval::*; asser

# Remainders GCD is left as an exercise for the reader... ```rust # use trait_eval::*; assert_eq!(<Five as Mod<Three>>::Result::eval(), 2); assert_e

The type of natural numbers (`0..`)

# Logical Not Negate any boolean you like at compile-time. (`¬¬(P V ¬P)` - just saying.) ```rust # use trait_eval::*; assert_eq!(<True as Not>::Res

# Logical Or A logical or operator for all you disjunctive needs. It would short circuit if that were possible, but here we are. ```rust # use trait

# Addition Addition at compile-time. That's right. Only limited by your imagination (and maybe your `#[recursion_limit]`). ```rust # use trait_eval:

# Saturating Decrement See, this is engineering at its finest, compile-time execution and no undefined behaviour! ```rust # use trait_eval::*; asser

# Peano-style increment operator ```rust # use trait_eval::*; assert_eq!(Succ::<Six>::eval(), 7); ```

# Multiplication It's time to get timesing at compile-time! That sounded way cooler in my head. ```rust # use trait_eval::*; assert_eq!(<Four as Tim

True (`true`)

Constant zero (`0`)