trait MyTrait {
    fn trait_hello(&self);
    fn as_any(&self) -> &dyn std::any::Any;
}

struct MyStruct1;

impl MyStruct1 {
    fn struct_hello(&self) {
        println!("Hello, world! from MyStruct1");
    }
}

impl MyTrait for MyStruct1 {
    fn trait_hello(&self) {
        self.struct_hello();
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

struct MyStruct2;

impl MyStruct2 {
    fn struct_hello(&self) {
        println!("Hello, world! from MyStruct2");
    }
}

impl MyTrait for MyStruct2 {
    fn trait_hello(&self) {
        self.struct_hello();
    }

      fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

 fn try_to_write_to_file() {
    match write_to_file() {
        Ok(()) => println!("Write succeeded"),
        Err(err) => println!("Write failed: {}", err.to_string()),
    }
}

#[derive(Debug, Clone)]
pub struct Pizza {
    pub toppings: Vec<String>,
}

impl Pizza {
   pub fn new(toppings: Vec<String>) -> Self {
         Self { toppings }
    }
     pub fn replace_toppings(
          &mut self,
         toppings: Vec<String>,
    ) -> Vec<String> {
         std::mem::replace(&mut self.toppings, toppings)
   }
}

macro_rules! dog_struct {
    ($breed:ident) => {
        struct $breed {
            name: String,
            age: i32,
            breed: String,
        }
        impl $breed {
            fn new(name: &str, age: i32) -> Self {
                Self {
                    name: name.into(),
                    age,
                    breed: stringify!($breed).into(),
                }
            }
        }
        impl Dog for $breed {
            fn name(&self) -> &String {
                &self.name
            }
            fn age(&self) -> i32 {
                self.age
            }
            fn breed(&self) -> &String {
                &self.breed
            }
        }
    };
}

pub trait Observable {
    type Observer;
    fn update(&self);
    fn attach(&mut self, observer: Self::Observer);
    fn detach(&mut self, observer: Self::Observer);
}

impl ReadFile {
     fn new(receiver: File) -> Box<Self> {
       Box::new(Self { receiver })
     }
}

#[derive(Debug)]
struct BitCount(u32);
 #[derive(Debug)]
struct ByteCount(u32);
 impl BitCount {
    fn to_bytes(&self) -> ByteCount {
     ByteCount(self.0 / 8)
   }
}

 /// Provides a singly linked list implementation with iterator access.
pub struct LinkedList<T> {
    head: Option<ListItemPtr<T>>,
 }

impl<T> LinkedList<T> {
    /// Constructs a new, empty [`LinkedList<T>`].
    pub fn new() -> Self {
         Self { head: None }
   }
    /// Appends an element to the end of the list. If the list is empty,
    /// the element becomes the first element of the list.
     pub fn append(&mut self, t: T) {
       match &self.head {
          Some(head) => {
              let mut next = head.clone();
                while next.as_ref().borrow().next.is_some() {
                 let n = next.as_ref().borrow()
                      .next.as_ref().unwrap().clone();
                    next = n;
              }
                 next.as_ref().borrow_mut().next =
                    Some(Rc::new(RefCell::new(ListItem::new(t))));
           }
            None => {
                 self.head = Some(Rc::new(RefCell::new(ListItem::new(t))));
             }
        }
   }
 }

  impl<T: Default + Copy, const LENGTH: usize> From<Vec<T>>
    for Buffer<T, LENGTH> {
    fn from(v: Vec<T>) -> Self {
      assert_eq!(LENGTH, v.len());
         let mut ret = Self {
             buf: [T::default(); LENGTH],
        };
         ret.buf.copy_from_slice(&v);
       ret
    }
}

    #[derive(
     Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd,
 )]
struct KitchenSink;
trait FullFeatured {}
impl<T> FullFeatured for T where
     T: Clone
         + Copy
         + std::fmt::Debug
          + Default
         + Eq
         + std::hash::Hash
         + Ord
         + PartialEq
         + PartialOrd { }

    trait BulbState {}
struct LightBulb<State: BulbState> {
     phantom: PhantomData<State>,
}
  struct On {}
  struct Off {}
  impl BulbState for On {}
  impl BulbState for Off {}

#[derive(Debug)]
pub enum ResumeResult {
    Invalid,
   Anonymous(Session<Anonymous>),
    Authenticated(Session<Authenticated>),
}

impl Session<Initial> {
    /// Returns a new session, defaulting to the anonymous state
    pub fn new() -> Session<Anonymous> {
        Session::<Anonymous> {
            session_id: Uuid::new_v4(),
           props: HashMap::new(),
        }
     }
}

use core::f64::consts::PI;
use std::ops::{Coroutine, CoroutineState};
 use std::pin::Pin;

 fn main() {
    let mut yield_pi = #[coroutine]
         || {
            yield PI;
            "Coroutine complete!"
         };
    loop {
         match Pin::new(&mut yield_pi).resume(()) {
             CoroutineState::Yielded(val) => {
                  dbg!(&val);
            }
             CoroutineState::Complete(val) => {
                dbg!(&val);
               break;
            }
         }
    }
}

pub trait ToOwned {
    type Owned: Borrow<Self>;

    fn to_owned(&self) -> Self::Owned;
   fn clone_into(&self, target: &mut Self::Owned) { /* ... */ }
}

   fn insert(&mut self, index: usize, element: T) {
     #[cold]
     #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
      #[track_caller]
       fn assert_failed(index: usize, len: usize) -> ! {
        panic!("insertion index (is {index}) should be <= len (is {len})");
        }

     let len = self.len();
     if len == self.buf.capacity() {
        self.reserve(1);
        }
    unsafe {
       let p = self.as_mut_ptr().add(index);
           if index < len {
             ptr::copy(p, p.add(1), len - index);
        } else if index == len {

       } else {
             assert_failed(index, len);
            }
    }
 }

    trait Animal {
        fn speak(&self) -> &str;
        fn name(&self) -> &str;
      }

      struct Dog {
        name: String,
    }

     impl Dog {
       fn new(name: &str) -> Self {
             Self {
               name: name.to_string(),
          }
        }
     }

     impl Animal for Dog {
        fn speak(&self) -> &str {
             "Woof!"
        }
         fn name(&self) -> &str {
              &self.name
         }
    }