rust·ºÐͺÍÌØÕ÷

use std::fmt::Debug;

fn test1<T>(value:T) {
    let _ = value;
}


enum Tsss<T> {
    Signal(T),
    Nosignal
}


struct GenericS2<T>{
    item:T
}

impl<T> GenericS2<T> {
    fn newGenericS2(i :T) -> Self {
        GenericS2{item:i}
    }
}

impl GenericS2<u32> {
    fn newGenericS2Int(i :u32) -> Self {
        GenericS2{item:i}
    }
}

trait Playable {
    fn play(&self);
    fn pause() {
        println!("Paused");
    }
}

struct Audio(String);
struct Video(String);
impl Playable for Audio {
    fn play(&self){
        println!("audio {}", self.0)
    }
}

impl Playable for Video {
    fn play(&self){
        println!("video {}", self.0)
    }
}

struct A;
struct B;
struct C;

trait InitA{
    fn init(&self);
}
impl InitA for A{
    fn init(&self){
        println!("init a");
    }
}

impl InitA for B{
    fn init(&self){
        println!("init b");
    }
}

impl C {
    fn ainit<T: InitA>(&self, s:T) {
        s.init();
    }
}

trait A1{
    fn a1(&self) {
        println!("a1")
    }
}

trait A2{
    fn a2(&self) {
        println!("a2")
    }
}
trait A3{
    fn a3(&self) {
        println!("a3")
    }
}

trait A4 : A1+A2+A3{
    fn a4(&self) {
        self.a1();
        self.a2();
        self.a3();
        println!("repeat!")
    }
}

struct Bb;
impl A1 for Bb{}
impl A2 for Bb{}
impl A3 for Bb{}
impl A4 for Bb{}

trait Entable {
    fn eat(&self);
}
#[derive(Debug)]
struct Food<T>(T);
#[derive(Debug)]
struct Apple;
impl<T> Entable for Food<T> where T:Debug {
    fn eat(&self) {
        println!("eater {:?}", self);
    }
}

fn eat<T>(val:T) where T:Entable {
    val.eat();
}



fn main() {

    let apple = Food(Apple);
    eat(apple);


    println!("Hello, world!");
    test1(12);
    test1("a");

    let s2 = GenericS2::newGenericS2(123);

    let mut vec1:Vec<u8> = Vec::new();
    vec1.push(1);

    let video1 = Audio("abc".to_string());
    video1.play();

    let cx = C;
    cx.ainit(A);
    cx.ainit(B);


    Bb.a4();

}