Sizedness In Rust Jun 15, 2022

// normally we do:

fn func<T>(t: T) {}  // ✅



// de-sugar version:

fn func<T: Sized>(t: T) {} // ✅



// try mark `?Sized` ?

fn func<T: ?Sized>(t: T) {} // ❌ the size for values of type `T` 

                            // cannot be known at compilation time



// we can use ?Sized to mark a ref params:

fn func<T: ?Sized>(t: &T) {} // ✅

fn func<T: ?Sized>(t: Box<T>) {} // ✅

use std::fmt::Debug;



fn debug<T: Debug>(t: T) { // T: Debug + Sized

    println!("{:?}", t);

}



fn main() {

    debug("my str"); // T = &str, &str: Debug + Sized ✅

}

use std::fmt::Debug;



fn debug<T: Debug>(t: &T) {

    // T: Debug + Sized

    println!("{:?}", t);

}



fn main() {

    debug("my str"); // now &T = &str,

                     // so   T =  str,

                     // str: Debug + ?Sized ❌

}

 --> src/main.rs:3:10

  |

3 | fn debug<T: Debug>(t: &T) {

  |          ^ required by this bound in `debug`

help: consider relaxing the implicit `Sized` restriction

  |

3 | fn debug<T: Debug + ?Sized>(t: &T) {

  |                   ++++++++

use std::fmt::Debug;



fn debug<T: Debug + ?Sized>(t: &T) {

    // T: Debug + ?Sized

    println!("{:?}", t);

}



fn main() {

    debug("my str"); // &T = &str, T = str, str: Debug + !Sized ✅

}

trait Trait {

    fn method(&self) {}

}



impl Trait for str {

    // we can call method on

    // 1. str

    // 2. String (due to String: Deref<Target = str>)

}



impl<T> Trait for [T] {

    // we can call method on

    // 1. any &[T]

    // 2. any U where U: Deref<Target = [T]>,  e.g. Vec<T>

    // 3. [T; N], since [T; N]: Unsize<[T]>

}



fn str_func(_s: &str) {}



fn slice_func<T>(_s: &[T]) {}



fn main() {

    // 1. str slice

    let str_slice: &str = "str_slice";

    let string: String = "string".to_owned();



    // function calls:

    str_func(str_slice);

    str_func(&string); // deref coercion



    // method calls:

    str_slice.method();

    string.method();



    // 2. array slice



    let slice: &[i32] = &[1];

    let three_arr: [i32; 3] = [1, 2, 3];

    let vec: Vec<i32> = vec![1];



    // function calls:

    slice_func(slice);

    slice_func(&three_arr); // unsized coercion

    slice_func(&vec); // deref coercion



    // method calls

    slice.method();

    three_arr.method(); // unsized coercion

    vec.method(); // deref coercion

}

trait Trait: ?Sized {} // compile error ❌

// `?Trait` is not premitted in supertraits. traits are `?Sized` by default

trait Trait where Self: ?Sized {}

trait Trait {

    fn method(self) {} // compile error ❌

    // the size for values of type `Self` cannot be known at compilation time

    // help: consider further restricting `Self`

    //   |

    // 2 |     fn method(self) where Self: Sized {}

    //   |                     +++++++++++++++++

}

trait Trait: Sized { 

    fn method(self) {} // ✅

}



impl Trait for str { // compile error ❌

    // we don't knonw size of `str` 

}

trait Trait {

    fn method(self) where Self: Sized, {

    } 

}



impl Trait for str { // ✅

    

}

impl Trait for str { // ✅

    fn method(self) {} // compile error ❌

}

trait Trait {

    fn method(self) where Self: Sized {}

    fn method2(&self) {}

}



impl Trait for str {} // ✅



fn main() {

    // we never call "method" so no errors

    "str".method2(); // ✅

}

trait Trait {}

trait Trait: ?Sized {}



impl Trait for dyn Trait {

    // compiler magic here

}

trait Trait {

    fn method(self) where Self:Sized {}

    fn method2(&self) {}

}



fn function(arg: &dyn Trait) {

  arg.method();  // compile error ❌

  arg.method2(); // ✅

}

trait Trait: Sized {}



impl Trait for dyn Trait {} // compile error ❌

struct Unsized {

    unsized_field: [i32],

}

struct MaybeUnSized<T: ?Sized> {

    field: T,

}



fn main() {

    let s: &MaybeUnSized<[i32]> = &MaybeUnSized { field: [1, 2, 3] };

}

pub struct OsStr {

    inner: Slice,

}



pub struct Path {

    inner: OsStr,

}



impl Path {

    pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &Path {

        unsafe { &*(s.as_ref() as *const OsStr as *const Path) }

    }

}

fn main() {

    let a: () = {};

    let b: () = {

        5; // here 5 means nothing. b == ()

    };

}

// with sugar

fn function() {}



// desugared

fn function() -> () {}

#[stable(feature = "rust1", since = "1.0.0")]

#[rustc_const_unstable(feature = "const_default_impls", issue = "87864")]

impl const Default for () {

    #[inline]

    #[doc = "Returns the default value of `()`"]

    fn default() -> () {

        ()

    }

}



#[stable(feature = "rust1", since = "1.0.0")]

impl PartialEq for () {

    #[inline]

    fn eq(&self, _other: &()) -> bool {

        true

    }

    #[inline]

    fn ne(&self, _other: &()) -> bool {

        false

    }

}



#[stable(feature = "rust1", since = "1.0.0")]

impl Ord for () {

    #[inline]

    fn cmp(&self, _other: &()) -> Ordering {

        Ordering::Equal

    }

}

fn main() {

    // zero capacity is all the capacity we need to "store" infinitely many ()

    let mut vec: Vec<()> = Vec::with_capacity(0);



    // causes no heap allocations or vec capacity changes

    vec.push(()); // len++

    vec.push(()); // len++

    vec.push(()); // len++

    vec.pop(); // len--



    assert_eq!(2, vec.len());



    assert_eq!(usize::MAX, vec.capacity());

    // pub fn capacity(&self) -> usize {

    //     if mem::size_of::<T>() == 0 { usize::MAX } else { self.cap }

    // }

}

pub struct HashSet<T> {

    map: HashMap<T, ()>,

}

struct Struct;

fn function() -> Result<Success, !>;

fn function() -> Result<!, Error>;

#![feature(never_type)]

use std::str::FromStr;



impl FromStr for String {

    type Err = !; // actually here uses `Infallible` , will be illustrated later.

    fn from_str(s: &str) -> Result<String, Self::Err> {

        Ok(String::from(s))

    }

}

#![feature(never_type)]

fn run_server() -> Result<!, ConnectionError> {

    loop {

        let (request, response) = get_request()?;

        let result = request.process();

        response.send(result);

    }

}

enum Void {}

enum Void {}



// example 1

impl FromStr for String {

    type Err = Void;

    fn from_str(s: &str) -> Result<String, Self::Err> {

        Ok(String::from(s))

    }

}



// example 2

fn run_server() -> Result<Void, ConnectionError> {

    loop {

        let (request, response) = get_request()?;

        let result = request.process();

        response.send(result);

    }

}

pub enum Infallible {}