v0.9.0

Cargo.toml

@@ -6,18 +6,18 @@ license = "MIT OR Apache-2.0"
 name = "hs-bindgen"
 repository = "https://github.com/yvan-sraka/hs-bindgen"
 rust-version = "1.64.0"
-version = "0.8.0"
+version = "0.9.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [lib]
 
 [dependencies]
-hs-bindgen-attribute = { version = "0.8", default-features = false }
-hs-bindgen-traits = { version = "0.8", default-features = false }
+hs-bindgen-attribute = { version = "0.9", default-features = false }
+hs-bindgen-traits = { version = "0.9", default-features = false }
 
 [features]
 default = ["std"]
-full = ["antlion", "std"]
-antlion = ["hs-bindgen-attribute/antlion"]
+full = ["reflexive", "std"]
+reflexive = ["hs-bindgen-attribute/reflexive"]
 std = ["hs-bindgen-traits/std"]

README.md

@@ -39,19 +39,19 @@ fn greetings(name: &str) {
 extern "C" fn __c_greetings(__0: *const core::ffi::c_char) -> () {
     // `traits` module is `hs-bindgen::hs-bindgen-traits`
     // n.b. do not forget to import it, e.g., with `use hs-bindgen::*`
-    traits::ReprC::from(greetings(traits::ReprRust::from(__0),))
+    traits::FromReprC::from(greetings(traits::FromReprRust::from(__0),))
 }
 ```
 
 A more complete example, when we now try to pass a custom type to our
 interface:
 
 ```rust
-use hs_bindgen::{traits::ReprRust, *};
+use hs_bindgen::{traits::FromReprRust, *};
 use std::marker::PhantomData;
 
 /// A custom Rust data-type, `#[repr(transparent)]` is not useful here
-/// since `ReprRust` trait will offers the constructor we need to construct
+/// since `FromReprRust` trait will offers the constructor we need to construct
 /// our type out of a C-FFI safe primitive data-structure.
 struct User<T: Kind> {
     name: String,
@@ -86,10 +86,10 @@ expansion during compilation, and how rustc assign unmangled symbols to
 monomorphised methods are AFAIK not a publicly specified behavior), but
 this limitation didn’t apply to `hs-bindgen-traits` implementations! */
 
-impl<T: Kind> ReprRust<*const i8> for User<T> {
+impl<T: Kind> FromReprRust<*const i8> for User<T> {
     fn from(ptr: *const i8) -> Self {
         User::<T> {
-            name: <String as ReprRust<*const i8>>::from(ptr),
+            name: <String as FromReprRust<*const i8>>::from(ptr),
             kind: PhantomData::<T>
         }
     }

src/lib.rs

@@ -37,19 +37,19 @@
 //! extern "C" fn __c_greetings(__0: *const core::ffi::c_char) -> () {
 //!     // `traits` module is `hs-bindgen::hs-bindgen-traits`
 //!     // n.b. do not forget to import it, e.g., with `use hs-bindgen::*`
-//!     traits::ReprC::from(greetings(traits::ReprRust::from(__0),))
+//!     traits::FromReprC::from(greetings(traits::FromReprRust::from(__0),))
 //! }
 //! ```
 //!
 //! A more complete example, when we now try to pass a custom type to our
 //! interface:
 //!
 //! ```rust
-//! use hs_bindgen::{traits::ReprRust, *};
+//! use hs_bindgen::{traits::FromReprRust, *};
 //! use std::marker::PhantomData;
 //!
 //! /// A custom Rust data-type, `#[repr(transparent)]` is not useful here
-//! /// since `ReprRust` trait will offers the constructor we need to construct
+//! /// since `FromReprRust` trait will offers the constructor we need to construct
 //! /// our type out of a C-FFI safe primitive data-structure.
 //! struct User<T: Kind> {
 //!     name: String,
@@ -84,10 +84,10 @@
 //! monomorphised methods are AFAIK not a publicly specified behavior), but
 //! this limitation didn’t apply to `hs-bindgen-traits` implementations! */
 //!
-//! impl<T: Kind> ReprRust<*const i8> for User<T> {
+//! impl<T: Kind> FromReprRust<*const i8> for User<T> {
 //!     fn from(ptr: *const i8) -> Self {
 //!         User::<T> {
-//!             name: <String as ReprRust<*const i8>>::from(ptr),
+//!             name: <String as FromReprRust<*const i8>>::from(ptr),
 //!             kind: PhantomData::<T>
 //!         }
 //!     }