fast-way-to-implment-object-trait

[package]
name = "rust_codewar"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[[bin]]
name = "codewar"
path = "src/main.rs"
[dependencies]
thin_trait_object = "1.1.2"
[workspace]
[profile.release]
opt-level = 'z'
lto = true
codegen-units = 1
panic = 'abort'
[features]

code

#![allow(unused)]
fn main() {
/**
* trait_object
*/
pub mod trait_object {
use std::fmt;
use std::fmt::Write;
pub fn run() {
fn dyn_obj_vec() {
//trait slug
use dyn_clone::DynClone;
pub trait Dyn_Vec: fmt::Display + fmt::Debug + DynClone {
fn slugify(&self) -> String;
fn tostring(&self) -> String;
fn prinln(&self);
}
impl Dyn_Vec for String {
fn slugify(&self) -> String {
format!("{}", self.replace(" ", "_"))
}
fn tostring(&self) -> String {
format!("{}", self)
}
fn prinln(&self) {
println!("{}", self);
}
}
impl Dyn_Vec for &str {
fn slugify(&self) -> String {
format!("{}", self.to_string().replace(" ", "_"))
}
fn tostring(&self) -> String {
format!("{}", self)
}
fn prinln(&self) {
println!("{}", self);
}
}
//int
impl Dyn_Vec for i8 {
fn slugify(&self) -> String {
format!("{}", self.to_string().replace(" ", "_"))
}
fn tostring(&self) -> String {
format!("{}", self)
}
fn prinln(&self) {
println!("{}", self);
}
}
impl Dyn_Vec for i16 {
fn slugify(&self) -> String {
format!("{}", self.to_string().replace(" ", "_"))
}
fn tostring(&self) -> String {
format!("{}", self)
}
fn prinln(&self) {
println!("{}", self);
}
}
impl Dyn_Vec for i32 {
fn slugify(&self) -> String {
format!("{}", self.to_string().replace(" ", "_"))
}
fn tostring(&self) -> String {
format!("{}", self)
}
fn prinln(&self) {
println!("{}", self);
}
}
impl Dyn_Vec for i64 {
fn slugify(&self) -> String {
format!("{}", self.to_string().replace(" ", "_"))
}
fn tostring(&self) -> String {
format!("{}", self)
}
fn prinln(&self) {
println!("{}", self);
}
}
impl Dyn_Vec for i128 {
fn slugify(&self) -> String {
format!("{}", self.to_string().replace(" ", "_"))
}
fn tostring(&self) -> String {
format!("{}", self)
}
fn prinln(&self) {
println!("{}", self);
}
}
//float
impl Dyn_Vec for f32 {
fn slugify(&self) -> String {
format!("{}", self.to_string().replace(" ", "_"))
}
fn tostring(&self) -> String {
format!("{}", self)
}
fn prinln(&self) {
println!("{}", self);
}
}
impl Dyn_Vec for f64 {
fn slugify(&self) -> String {
format!("{}", self.to_string().replace(" ", "_"))
}
fn tostring(&self) -> String {
format!("{}", self)
}
fn prinln(&self) {
println!("{}", self);
}
}
//the same type of vec slice impl trait
//slice item  is a thing has implmented trait slug
fn same(h: &[impl Dyn_Vec]) {
//is short cut of same1()
for s in h {
println!("{}", s.tostring());
}
}
//slice item  is a thing has implmented trait slug and need to be the same type
fn same1<H: Dyn_Vec>(h: &[H]) {
for s in h {
s.prinln();
}
}
same(&["a", "b", "c"]);
same1(&[format!("s0"), format!("s1"), format!("s2")]);
//diffrent type of vec slice impl trait
//slice item  is a thing has implmented trait slug canbe diffrent type
//vec contain diffrent type
pub fn new_Dyn_Vec() -> Vec<Box<dyn Dyn_Vec>> {
vec![Box::new("default") as Box<dyn Dyn_Vec>]
}
let mut Dyn_Vec: Vec<Box<dyn Dyn_Vec>> = new_Dyn_Vec();
Dyn_Vec.push(Box::new("151515"));
Dyn_Vec.push(Box::new(15));
Dyn_Vec.push(Box::new(String::from("string")));
Dyn_Vec.push(Box::new(1.02));
//println dyn obj
fn println_Dyn_Vec(h: &[Box<dyn Dyn_Vec>]) {
for s in h {
println!("{}", s.tostring());
}
}
println_Dyn_Vec(&Dyn_Vec);
println!("{:?}", Dyn_Vec);
//impl Clone for trait object
dyn_clone::clone_trait_object!(Dyn_Vec);
#[derive(Clone)]
struct Each_Dyn_Vec(Box<dyn Dyn_Vec>);
let first = Dyn_Vec[0].clone();
println!("{}", first);
// fast way to implment object trait
use thin_trait_object::*;
#[thin_trait_object]
trait Addable {
fn add(&self, other: &str) -> String;
}
impl Addable for String {
fn add(&self, other: &str) -> String {
format!("{}{}", self, other)
}
}
impl Addable for &str {
fn add(&self, other: &str) -> String {
format!("{}{}", self, other)
}
}
impl Addable for Vec<i32> {
fn add(&self, other: &str) -> String {
let mut v = self.clone();
let re = match other.parse::<i32>() {
Ok(r) => {
v.push(r);
v
}
Err(r) => v,
};
format!("{:?}", re)
}
}
impl Addable for Vec<String> {
fn add(&self, other: &str) -> String {
let mut v = self.clone();
v.push(other.to_string());
format!("{:?}", v)
}
}
//move occurs because value has type `String`, which does not implement the `Copy` trait
//when this error ust yhe trait
#[thin_trait_object]
trait Cloneable {
fn clone_by_index(&self, index: usize) -> String;
}
impl Cloneable for Vec<String> {
fn clone_by_index(&self, index: usize) -> String {
let s = self.to_owned();
format!("{}", &s[index])
}
}
let s1 = BoxedAddable::new("String".to_string()).add("add");
let s2 = BoxedAddable::new("&str").add("add");
let s3 = "ok".add("add");
let s4 = vec![15, 2].add("15151"); //[15, 2, 15151]
let s5 = vec![format!("ok")].add("add str"); //[15, 2, 15151]
let s6 = vec![format!("ok")].clone_by_index(0);
println!("{}", s1);
println!("{}", s2);
println!("{}", s3);
println!("{}", s4);
println!("{}", s5);
println!("{}", s6);
}
dyn_obj_vec();
}
}
}