Struct rust_examples::typing::Positive

pub struct Positive(_);

Opaque wrapper around f64 which adds static semantics that the float has positive value.

The benefit of such abstraction is two fold:

1. It adds static information about legal values that the compiler can’t possibly know about
2. while it incurs zero cost at runtime (it gets “compiled away” and behaves as an ordinary f64)

While it might seem annoying to work with Positive instead of plain f64, one can derive many traits implemented for f64 so that instances of Positive can be a drop-in replacement for it in many cases.

Additionally, there is an incentive in the Rust team to further mitigate the pain to work with these wrappers by introducing something like a #[newtype_derive] macro inspired by the newtype pattern from Haskell.

Note this could be generalized with the num crate:

use num::Float;

struct Positive<F: Float>(F);

Implementations

impl Positive

pub fn new(number: f64) -> Option<Self>

This forces clients to always check if it’s ok. One cannot initialize a tuple struct which contains private fields.

So the following code does not compile because f64 is a private field in Positive.

use rust_examples::typing::Positive;

let _ = Positive(-24.);

The only option is then to use this factory method and therefore check the result.

use rust_examples::typing::Positive;

assert_eq!(Positive::new(-24.), None)

pub unsafe fn as_u32(&self) -> u32

Interprets Positive as an u32

Note that this is not OOP, one can call Positive::as_u32 as an ordinary function:

use rust_examples::typing::Positive;

let pos = Positive::new(42.).expect("positive number");
let int = unsafe { Positive::as_u32(&pos) };
assert_eq!(int, 42);

Safety

The safety is guaranteed by the construction of Positive instances via Positive::new.

Trait Implementations

impl Clone for Positive

fn clone(&self) -> Positive

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Positive

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<Positive> for Positive

fn eq(&self, other: &Positive) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Positive) -> bool

This method tests for !=.

impl PartialOrd<Positive> for Positive

fn partial_cmp(&self, other: &Positive) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Positive

impl StructuralPartialEq for Positive