[−][src]Trait abi_stable::reexports::SelfOps
Extension trait for every type.
The most importand methods in this are:
-
piped: Allows emulating the pipeline operator.
-
mutated: Allows mutating
self
with a closure passing it along the method chain -
observe: Observes the value of
self
with a closure passing it along the method chain unmodified. -
into_, as_ref_, as_mut_: Alternative syntax for the standard conversion methods.
Associated Constants
const T: PhantomData<fn() -> Self>
Represents Self by using a VariantPhantomType::T
to pass it in methods with _:VariantPhantom<T>
parameters.
Example
use core_extensions::{SelfOps,IteratorExt}; assert_eq!((0..4).collect_(Vec::T ),vec![0,1,2,3]); assert_eq!((0..4).collect_(Vec::<_>::T ),vec![0,1,2,3]); assert_eq!((0..4).collect_(Vec::<i32>::T),vec![0,1,2,3]);
const T_D: PhantomData<Self>
Represents Self by using a VariantDropPhantom
For advanced use cases when one needs a drop check on a PhantomData.
Provided methods
fn assert_ty(self, _other: PhantomData<fn() -> Self>) -> Self
Asserts that other
is the same type as self
.
fn assert_ty_ref(&self, _other: PhantomData<fn() -> Self>) -> &Self
Asserts that other
is the same type as self
.
fn assert_ty_mut(&mut self, _other: PhantomData<fn() -> Self>) -> &mut Self
Asserts that other
is the same type as self
.
fn ty_(&self) -> PhantomData<fn() -> Self>
Equivalent to SelfOps::T,as a method.
Reasons for calling this method instead:
-
The type is longer that the code required to instantiate it.
-
To assert that 2 variables have the same type,using
var0.ty_()==var1.ty_()
.
fn ty_d(&self) -> PhantomData<Self>
Equivalent to [Self::ty_],for specialized cases.
For specialized cases when one needs a drop check on a PhantomData.
fn ty_inv(&self) -> PhantomData<fn(Self) -> Self>
Equivalent to [Self::ty_] with an invariant type.
fn ty_inv_ref(&self) -> PhantomData<Cell<&Self>>
Equivalent to [Self::ty_] with an invariant lifetime.
fn eq_id(&self, other: &Self) -> bool
Identity comparison to another value of the same type.
Comparing the address of self
with the address of other
.
Example
use core_extensions::SelfOps; let a=5.to_string(); let b=5.to_string(); assert!(!a.eq_id(&b)); assert!(!b.eq_id(&a)); assert!( a.eq_id(&a)); assert!( b.eq_id(&b)); assert_eq!(a,b);
fn piped<F, U>(self, f: F) -> U where
F: FnOnce(Self) -> U,
F: FnOnce(Self) -> U,
Emulates the pipeline operator,allowing method syntax in more places.
Allows calling functions as part of a method chain.
Example
use core_extensions::SelfOps; use std::sync::{Mutex,Arc}; let hello="hello" .to_string() .mutated(|s| s.push_str("_world") ) .piped(Mutex::new) .piped(Arc::new); assert_eq!(hello.lock().unwrap().as_str(),"hello_world");
Example,calling functions
use core_extensions::SelfOps; "what" .piped(|x|opposed(x)+"-") .observe(|s| assert_eq!(s,"whattahw-") ) .piped(opposed) .observe(|s| assert_eq!(s,"whattahw--whattahw") );
fn piped_ref<'a, F, U>(&'a self, f: F) -> U where
F: FnOnce(&'a Self) -> U,
F: FnOnce(&'a Self) -> U,
The same as piped
except that the function takes &Self
Useful for functions that take &Self
instead of Self
.
Example
use core_extensions::SelfOps; let problem="air".to_string(); let edited=problem.piped_ref(|s| format!("{} problems.",s) ); println!("{:?}",problem); // problem wasn't consumed by `.piped_ref` assert_eq!(edited,"air problems.");
fn piped_mut<'a, F, U>(&'a mut self, f: F) -> U where
F: FnOnce(&'a mut Self) -> U,
F: FnOnce(&'a mut Self) -> U,
The same as piped
except that the function takes &mut Self
.
Useful for functions that take &mut Self
instead of Self
.
fn mutated<F>(self, f: F) -> Self where
F: FnOnce(&mut Self),
F: FnOnce(&mut Self),
Mutates self using a closure taking self by mutable reference, passing it along the method chain.
This is useful for initializing a variable and then freezing it.
Example of initialization
use core_extensions::SelfOps; let list=Vec::new().mutated(|v|{ v.push("This"); v.push("is"); v.push("[redacted]"); }); assert_eq!(list.join(" "),"This is [redacted]");
Example of mutating in a method chain
use core_extensions::SelfOps; "what".to_string() .mutated(|v| v.push_str(" the") ) .observe(|v| assert_eq!(v,"what the") );
fn observe<F>(self, f: F) -> Self where
F: FnOnce(&Self),
F: FnOnce(&Self),
Observes the value of self passing it along unmodified. Useful in a long method chain.
Example
use core_extensions::SelfOps; let v="1234" .parse() .observe(|d|assert_eq!(&Ok(1234),d)) .unwrap(); assert_eq!(v,1234);
fn into_<T>(self, PhantomData<fn() -> T>) -> T where
Self: Into<T>,
Self: Into<T>,
Performs a conversion using Into.
This method is defined to allow using the .into_(String::T)
syntax.
type::T is an associated constant defined for every type here.
Example
use core_extensions::SelfOps; use std::borrow::Cow; let word="hello"; assert_eq!(word,word.into_(Cow::T)); assert_eq!(word,word.into_(Cow::<str>::T)); assert_eq!(word,word.into_(String::T)); let vec_=||vec![0,1,2,3]; assert_eq!(vec_().into_(Cow::T) ,vec_()); assert_eq!(vec_().into_(Cow::<[usize]>::T),vec_()); assert_eq!(vec_().into_(Vec::T) ,vec_()); assert_eq!(vec_().into_(Vec::<usize>::T) ,vec_());
fn as_ref_<T>(&self) -> &T where
Self: AsRef<T>,
T: ?Sized,
Self: AsRef<T>,
T: ?Sized,
Performs a reference to reference conversion using AsRef,
using the turbofish .as_ref_::<_>()
syntax.
Example
use core_extensions::SelfOps; let s="the path"; assert_eq!( s,s.as_ref_::<str>());
fn as_mut_<T>(&mut self) -> &mut T where
Self: AsMut<T>,
T: ?Sized,
Self: AsMut<T>,
T: ?Sized,
Performs a mutable reference to mutable reference conversion using AsMut,
using the turbofish .as_mut_::<_>()
syntax.
Example
use core_extensions::SelfOps; let mut s_0=vec![1,2,3,4]; let mut s_1=s_0.clone(); assert_eq!(s_1,s_0.as_mut_::<[_]>());
fn drop_(self)
Drops self
using method notation.
Alternative to std::mem::drop
.
Example,ignore #[must_use] values.
#![deny(unused_must_use)] use std::fmt::Write; use core_extensions::SelfOps; let mut buff=String::new(); buff.write_str("hello_").drop_(); buff.write_str("world").drop_(); assert_eq!(buff,"hello_world");