vic1707
commented
3 weeks ago I think its good
lib.rs
use nutype::nutype;
#[nutype(validate(finite))]
struct A(f32);Cargo.toml
[dependencies]
nutype = { path = "../nutype/nutype" }Outputs of cargo expand
1.81.0
```rs
#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use nutype::nutype;
#[doc(hidden)]
mod __nutype_A__ {
use super::*;
pub struct A(f32);
#[allow(clippy::enum_variant_names)]
pub enum AError {
FiniteViolated,
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::fmt::Debug for AError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f, "FiniteViolated")
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::clone::Clone for AError {
#[inline]
fn clone(&self) -> AError {
AError::FiniteViolated
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::marker::StructuralPartialEq for AError {}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::PartialEq for AError {
#[inline]
fn eq(&self, other: &AError) -> bool {
true
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::Eq for AError {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_receiver_is_total_eq(&self) -> () {}
}
impl ::core::fmt::Display for AError {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
match self {
AError::FiniteViolated => {
f.write_fmt(format_args!("{0} is not finite.", "A"))
}
}
}
}
impl ::core::error::Error for AError {
fn source(&self) -> Option<&(dyn ::core::error::Error + 'static)> {
None
}
}
impl A {
pub fn try_new(raw_value: f32) -> ::core::result::Result {
let sanitized_value: f32 = Self::__sanitize__(raw_value);
Self::__validate__(&sanitized_value)?;
Ok(A(sanitized_value))
}
fn __sanitize__(mut value: f32) -> f32 {
value
}
fn __validate__(val: &f32) -> core::result::Result<(), AError> {
let val = *val;
if !val.is_finite() {
return Err(AError::FiniteViolated);
}
Ok(())
}
#[deprecated(since = "0.4.3", note = "\nUse `try_new` instead.")]
pub fn new(raw_value: f32) -> ::core::result::Result {
Self::try_new(raw_value)
}
}
impl A {
#[inline]
pub fn into_inner(self) -> f32 {
self.0
}
}
}
use __nutype_A__::A;
use __nutype_A__::AError;
```
```rs
#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use nutype::nutype;
#[doc(hidden)]
mod __nutype_A__ {
use super::*;
pub struct A(f32);
#[allow(clippy::enum_variant_names)]
pub enum AError {
FiniteViolated,
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::fmt::Debug for AError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f, "FiniteViolated")
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::clone::Clone for AError {
#[inline]
fn clone(&self) -> AError {
AError::FiniteViolated
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::marker::StructuralPartialEq for AError {}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::PartialEq for AError {
#[inline]
fn eq(&self, other: &AError) -> bool {
true
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::Eq for AError {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_receiver_is_total_eq(&self) -> () {}
}
impl ::core::fmt::Display for AError {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
match self {
AError::FiniteViolated => {
f.write_fmt(format_args!("{0} is not finite.", "A"))
}
}
}
}
impl ::core::error::Error for AError {
fn source(&self) -> Option<&(dyn ::core::error::Error + 'static)> {
None
}
}
impl A {
pub fn try_new(raw_value: f32) -> ::core::result::Result {
let sanitized_value: f32 = Self::__sanitize__(raw_value);
Self::__validate__(&sanitized_value)?;
Ok(A(sanitized_value))
}
fn __sanitize__(mut value: f32) -> f32 {
value
}
fn __validate__(val: &f32) -> core::result::Result<(), AError> {
let val = *val;
if !val.is_finite() {
return Err(AError::FiniteViolated);
}
Ok(())
}
#[deprecated(since = "0.4.3", note = "\nUse `try_new` instead.")]
pub fn new(raw_value: f32) -> ::core::result::Result {
Self::try_new(raw_value)
}
}
impl A {
#[inline]
pub fn into_inner(self) -> f32 {
self.0
}
}
}
use __nutype_A__::A;
use __nutype_A__::AError;
```
1.80.0
```rs
#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use nutype::nutype;
#[doc(hidden)]
mod __nutype_A__ {
use super::*;
pub struct A(f32);
#[allow(clippy::enum_variant_names)]
pub enum AError {
FiniteViolated,
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::fmt::Debug for AError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f, "FiniteViolated")
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::clone::Clone for AError {
#[inline]
fn clone(&self) -> AError {
AError::FiniteViolated
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::marker::StructuralPartialEq for AError {}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::PartialEq for AError {
#[inline]
fn eq(&self, other: &AError) -> bool {
true
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::Eq for AError {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_receiver_is_total_eq(&self) -> () {}
}
impl ::core::fmt::Display for AError {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
match self {
AError::FiniteViolated => {
f.write_fmt(format_args!("{0} is not finite.", "A"))
}
}
}
}
impl ::std::error::Error for AError {
fn source(&self) -> Option<&(dyn ::std::error::Error + 'static)> {
None
}
}
impl A {
pub fn try_new(raw_value: f32) -> ::core::result::Result {
let sanitized_value: f32 = Self::__sanitize__(raw_value);
Self::__validate__(&sanitized_value)?;
Ok(A(sanitized_value))
}
fn __sanitize__(mut value: f32) -> f32 {
value
}
fn __validate__(val: &f32) -> core::result::Result<(), AError> {
let val = *val;
if !val.is_finite() {
return Err(AError::FiniteViolated);
}
Ok(())
}
#[deprecated(since = "0.4.3", note = "\nUse `try_new` instead.")]
pub fn new(raw_value: f32) -> ::core::result::Result {
Self::try_new(raw_value)
}
}
impl A {
#[inline]
pub fn into_inner(self) -> f32 {
self.0
}
}
}
use __nutype_A__::A;
use __nutype_A__::AError;
```
```rs
#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use nutype::nutype;
#[doc(hidden)]
mod __nutype_A__ {
use super::*;
pub struct A(f32);
#[allow(clippy::enum_variant_names)]
pub enum AError {
FiniteViolated,
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::fmt::Debug for AError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f, "FiniteViolated")
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::clone::Clone for AError {
#[inline]
fn clone(&self) -> AError {
AError::FiniteViolated
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::marker::StructuralPartialEq for AError {}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::PartialEq for AError {
#[inline]
fn eq(&self, other: &AError) -> bool {
true
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::Eq for AError {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_receiver_is_total_eq(&self) -> () {}
}
impl ::core::fmt::Display for AError {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
match self {
AError::FiniteViolated => {
f.write_fmt(format_args!("{0} is not finite.", "A"))
}
}
}
}
impl A {
pub fn try_new(raw_value: f32) -> ::core::result::Result {
let sanitized_value: f32 = Self::__sanitize__(raw_value);
Self::__validate__(&sanitized_value)?;
Ok(A(sanitized_value))
}
fn __sanitize__(mut value: f32) -> f32 {
value
}
fn __validate__(val: &f32) -> core::result::Result<(), AError> {
let val = *val;
if !val.is_finite() {
return Err(AError::FiniteViolated);
}
Ok(())
}
#[deprecated(since = "0.4.3", note = "\nUse `try_new` instead.")]
pub fn new(raw_value: f32) -> ::core::result::Result {
Self::try_new(raw_value)
}
}
impl A {
#[inline]
pub fn into_inner(self) -> f32 {
self.0
}
}
}
use __nutype_A__::A;
use __nutype_A__::AError;
```
1.83.0-nightly
```rs
#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use nutype::nutype;
#[doc(hidden)]
mod __nutype_A__ {
use super::*;
pub struct A(f32);
#[allow(clippy::enum_variant_names)]
pub enum AError {
FiniteViolated,
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::fmt::Debug for AError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f, "FiniteViolated")
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::clone::Clone for AError {
#[inline]
fn clone(&self) -> AError {
AError::FiniteViolated
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::marker::StructuralPartialEq for AError {}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::PartialEq for AError {
#[inline]
fn eq(&self, other: &AError) -> bool {
true
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::Eq for AError {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_receiver_is_total_eq(&self) -> () {}
}
impl ::core::fmt::Display for AError {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
match self {
AError::FiniteViolated => {
f.write_fmt(format_args!("{0} is not finite.", "A"))
}
}
}
}
impl ::core::error::Error for AError {
fn source(&self) -> Option<&(dyn ::core::error::Error + 'static)> {
None
}
}
impl A {
pub fn try_new(raw_value: f32) -> ::core::result::Result {
let sanitized_value: f32 = Self::__sanitize__(raw_value);
Self::__validate__(&sanitized_value)?;
Ok(A(sanitized_value))
}
fn __sanitize__(mut value: f32) -> f32 {
value
}
fn __validate__(val: &f32) -> core::result::Result<(), AError> {
let val = *val;
if !val.is_finite() {
return Err(AError::FiniteViolated);
}
Ok(())
}
#[deprecated(since = "0.4.3", note = "\nUse `try_new` instead.")]
pub fn new(raw_value: f32) -> ::core::result::Result {
Self::try_new(raw_value)
}
}
impl A {
#[inline]
pub fn into_inner(self) -> f32 {
self.0
}
}
}
use __nutype_A__::A;
use __nutype_A__::AError;
```
```rs
#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use nutype::nutype;
#[doc(hidden)]
mod __nutype_A__ {
use super::*;
pub struct A(f32);
#[allow(clippy::enum_variant_names)]
pub enum AError {
FiniteViolated,
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::fmt::Debug for AError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f, "FiniteViolated")
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::clone::Clone for AError {
#[inline]
fn clone(&self) -> AError {
AError::FiniteViolated
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::marker::StructuralPartialEq for AError {}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::PartialEq for AError {
#[inline]
fn eq(&self, other: &AError) -> bool {
true
}
}
#[automatically_derived]
#[allow(clippy::enum_variant_names)]
impl ::core::cmp::Eq for AError {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_receiver_is_total_eq(&self) -> () {}
}
impl ::core::fmt::Display for AError {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
match self {
AError::FiniteViolated => {
f.write_fmt(format_args!("{0} is not finite.", "A"))
}
}
}
}
impl ::core::error::Error for AError {
fn source(&self) -> Option<&(dyn ::core::error::Error + 'static)> {
None
}
}
impl A {
pub fn try_new(raw_value: f32) -> ::core::result::Result {
let sanitized_value: f32 = Self::__sanitize__(raw_value);
Self::__validate__(&sanitized_value)?;
Ok(A(sanitized_value))
}
fn __sanitize__(mut value: f32) -> f32 {
value
}
fn __validate__(val: &f32) -> core::result::Result<(), AError> {
let val = *val;
if !val.is_finite() {
return Err(AError::FiniteViolated);
}
Ok(())
}
#[deprecated(since = "0.4.3", note = "\nUse `try_new` instead.")]
pub fn new(raw_value: f32) -> ::core::result::Result {
Self::try_new(raw_value)
}
}
impl A {
#[inline]
pub fn into_inner(self) -> f32 {
self.0
}
}
}
use __nutype_A__::A;
use __nutype_A__::AError;
```
greyblake
rust 1.81.0 made
std::error::Erroravailable in core. Users with that version or higher should be getting theErrorimpl no matter ifstdfeature is enabled. fixes #179 without introducing a breaking change