示例

use seoul::Reflica;

// struct
#[derive(Reflica)]
// attribute for derive implementation for the reflica 
#[reflica(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
struct AB<I> {
  a: u8,
  b: I
}

// RefAB delcared
let _: RefAB<String> = RefAB { a: &8, b: &String::from("ab") };

// check Into<RefAB> for &AB
let x = AB { a: 0, b: String::from("x")};
let _: RefAB<String> = (&x).into();

// check derive `Ord`
let a: RefAB<u8> = RefAB { a: &2, b: &10 };
let b: RefAB<u8> = RefAB { a: &2, b: &11 };
let c: RefAB<u8> = RefAB { a: &3, b: &10 };
let x = vec![a, b, c];
let mut y = x.clone();
y.sort();
assert_eq!(x, y);


// enum, use prefix other than basic `Ref`
#[derive(Reflica)]
// `prefix` attribute's string value will be used for reflica's prefix, other than the basic prefix `Ref`
#[reflica(Clone, Copy, Debug, prefix="Ref2")]
enum ABC<I> where I: Clone {
  A,
  B { a: u8, b: I },
  C(u8)
}

// Ref2AB delcared
let _: Ref2ABC<u8> = Ref2ABC::A;
let _: Ref2ABC<String> = Ref2ABC::B { a: &8, b: &String::from("ab") };

// check Into<Ref2AB>
let x = ABC::B { a: 0, b: String::from("x")};
let _: Ref2ABC<String> = (&x).into();

let x = ABC::<u8>::C(0);
let _: Ref2ABC<u8> = (&x).into();

IntoWrap trait

• 为枚举类型数据中的每个变体实现 From traits，当变体有一个未命名字段时，将字段数据转换为枚举数据。

• 因此，每个变体不应有任何冗余类型或泛型，以避免任何冲突实现。

• IntoWrap 可以被视为为枚举的包装变体而设计的 Tuplike 的非元组单变量版本。

示例

use seoul::IntoWrap;

#[derive(Debug, Clone, PartialEq, IntoWrap)]
enum ABCD {
  A, // skip
  B(i32), // impl From<i32> for ABCD
  C { a: i32 }, // skip
  D(String) // impl From<String> for ABCD
}

let _ = ABCD::A;
let _ = ABCD::C { a: 10 };

let b: i32 = 10;
let b: ABCD = b.into();

let d = "string".to_string();
let d: ABCD = d.into();

assert_eq!(b, ABCD::B(10));
assert_eq!(d, ABCD::D("string".to_string()));


#[derive(Debug, Clone, PartialEq, IntoWrap)]
enum AB<X: Clone, Y> where Y: Clone {
  A((X, X)), // impl<X: Clone, Y> From<X, X> for AB where Y: Clone
  B(Vec<Y>) // impl<X: Clone, Y> From<Vec<X>> for AB where Y: Clone
}

let a: (String, String) = ("x".to_string(), "x".to_string());
let a: AB<String, i32> = a.into();

let b: Vec<i32> = vec![0, 1, 2];
let b: AB<String, i32> = b.into();

assert_eq!(a, AB::<String, i32>::A(("x".to_string(), "x".to_string())));
assert_eq!(b, AB::<String, i32>::B(vec![0, 1, 2]));


// This case won't work due to conflicting implementations.
/*#[derive(Debug, Clone, PartialEq, IntoWrap)]
enum AB<X: Clone, Y> where Y: Clone {
  A(X),
  B(Vec<Y>)
}*/

开发日志

- ver.0.2.0
  - `From<T>` implemented only with `has_default` attribute syntax when `Default` is implemented.
- ver 0.2.1~2
  - correct some typos

- ver 0.3.0
  - Add `Tuplike`.
- ver 0.3.1
  - Add an associated type `Tuple` to the trait `Tuplike`

- ver 0.3.2
  - Add `Reflica`

- ver 0.3.3
  - On `Tuplike`:
    - delete associated type `Tuple` from the trait.
    - derive macro now works on the enum type too: but only `From<T>` trait will be implemented for each variant.
  - Add `IntoWrap`

- ver 0.3.5
  - On `Isomorphism`:
    - Reinforced derive macro's generic parsing ability.
    - For struct type, the derive macro would only implement the Isormophism trait with each methods of it returning default values.