[][src]Module core_extensions::type_level_bool

Module containing definitions and operations for type level booleans

All operations are type aliases for convenience

Example

Access of privileges based on renamed Boolean types.

use std::mem;
use std::marker::PhantomData;
use core_extensions::VariantPhantom;
pub use core_extensions::type_level_bool::{
    Boolean as PrivilegeLevel,
    False as Unprivileged ,
    True as Privileged ,
};



#[derive(Debug)]
struct User<P>{
    name:String,
    privilege_level:VariantPhantom<P>,
}

impl<P:PrivilegeLevel> User<P>{
    fn new(name:String,privilege_level:P)->Self{
        Self{ name , privilege_level:PhantomData }
    }
    fn name(&self)->&str{
        &self.name
    }
    fn into_unprivileged(self)->User<Unprivileged>{
        User{ name:self.name , privilege_level:PhantomData }
    }
    fn as_unprivileged(self:&mut User<P>)->&mut User<Unprivileged>{
        // Only the type parameter P changes here,which is itself a MarkerType.
        unsafe{ mem::transmute(self) }
    }
}

impl User<Privileged>{
    fn set_name(&mut self,name:String){
        self.name=name;
    }
}

let mut user:User<Privileged>=
    User::new("bob".into(),Privileged);
assert_eq!(user.name(),"bob");

user.set_name("paul".into());
assert_eq!(user.name(),"paul");

{
    let user:&mut User<Unprivileged>=
        user.as_unprivileged();

    // Unprivileged Users can't change their name.
    // user.set_name("james".into());

    assert_eq!(user.name(),"paul");
}

user.set_name("john".into());
assert_eq!(user.name(),"john");

Re-exports

pub use self::internals::*;

Modules

internals

Structs

BooleanType

Used to represent a type-level boolean when used as a type parameter.

False

Represents a type-level false

True

Represents a type-level true

Traits

Boolean

Represents a type-level bool

Type Definitions

And

Ands two Booleans

IfElse

Type level conditional.

Implies

Logical implication

Nand

Nands two Booleans

NonImp

Material non-implication

Nor

Nors two Booleans

Not

Negates a Boolean.

Or

Ors two Booleans

Xnor

Xnors two Booleans

Xor

Xors two Booleans