Trait flexstr::ToFlex

pub trait ToFlex<const N: usize, T> {
    fn to_flex(&self) -> FlexStr<N, T>;
}

A trait that converts the source to a FlexStr<N, T> without consuming it

use flexstr::{FlexStr, ToFlex};

let a: FlexStr = "This is a heap allocated string!!!!!".to_string().to_flex();
assert!(a.is_heap());

Required methods

fn to_flex(&self) -> FlexStr<N, T>

Converts the source to a FlexStr<N, T> without consuming it

Implementations on Foreign Types

impl<const N: usize, T> ToFlex<N, T> for str where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{AFlexStr, FlexStr, ToFlex};

// *** Don't do this - use `into_flex` on literals ***
let a: AFlexStr = "inlined".to_flex();
assert!(a.is_inlined());

let b: FlexStr = "This is too long to be inlined!!!!!!".to_flex();
assert!(b.is_heap())

impl<const N: usize, T> ToFlex<N, T> for bool where
    T: Deref<Target = str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = false.to_flex();
assert!(s.is_static());
assert_eq!(s, "false");

impl<const N: usize, T> ToFlex<N, T> for char where
    T: for<'a> From<&'a str> + From<String> + Deref<Target = str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = '☺'.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "☺");

impl<const N: usize, T> ToFlex<N, T> for i8 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123i8.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for u8 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123u8.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for i16 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123i16.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for u16 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123u16.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for i32 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123i32.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for u32 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123u32.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for i64 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123i64.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for u64 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123u64.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for i128 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123i128.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for u128 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123u128.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for isize where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123isize.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for usize where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123usize.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123");

impl<const N: usize, T> ToFlex<N, T> for f32 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123.456f32.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123.456");

impl<const N: usize, T> ToFlex<N, T> for f64 where
    T: for<'a> From<&'a str>, 

fn to_flex(&self) -> FlexStr<N, T>

use flexstr::{FlexStr, ToFlex};

let s: FlexStr = 123.456f64.to_flex();
assert!(s.is_inlined());
assert_eq!(s, "123.456");

Implementors

impl<const N: usize, T, T2> ToFlex<N, T> for FlexStr<N, T2> where
    T: for<'a> From<&'a str>,
    T2: Clone + Deref<Target = str>,