strval

Check-in Differences
Login

Check-in Differences

Invert Patch Path Unified Diff

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Difference From strval-0.3.0 To strval-0.3.1

2025-08-03
00:41
Some FromStr implementations were missing validation calls. check-in: 1fe47acddf user: jan tags: trunk
2025-07-30
00:47
Add missing date. check-in: 8cf0fe0bcc user: jan tags: strval-0.3.1, trunk
00:45
Implement Display for data types. check-in: e1141e3da7 user: jan tags: trunk
2025-07-28
23:53
Use rusqlite 0.37.0. check-in: ea24b44e08 user: jan tags: strval-0.3.0, trunk
2025-07-09
17:33
More ignore experimentation. check-in: d43ecc80f1 user: jan tags: trunk

Changes to Cargo.toml. 
1
2
3
4
5
6
7
8
9
10

[package]
name = "strval"
version = "0.3.0"
edition = "2024"
license = "0BSD"
# https://crates.io/category_slugs
categories = ["text-processing"]
keywords = ["parsing", "string", "rusqlite"]
repository = "https://repos.qrnch.tech/pub/strval"
description = "Parse strings into values"



|








1
2
3
4
5
6
7
8
9
10

[package]
name = "strval"
version = "0.3.1"
edition = "2024"
license = "0BSD"
# https://crates.io/category_slugs
categories = ["text-processing"]
keywords = ["parsing", "string", "rusqlite"]
repository = "https://repos.qrnch.tech/pub/strval"
description = "Parse strings into values"
︙︙
Changes to src/binu64count.rs. 
1
2
3
4
5
6
7
8

use std::{marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};


|








1
2
3
4
5
6
7
8

use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

}

impl<C> AsRef<str> for BinU64Count<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl<C> FromStr for BinU64Count<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()








>
>
>
>
>
>








64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

}

impl<C> AsRef<str> for BinU64Count<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for BinU64Count<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for BinU64Count<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()
︙︙
Changes to src/binu64size.rs. 
1
2
3
4
5
6
7
8

use std::{marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};


|








1
2
3
4
5
6
7
8

use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

}

impl<C> AsRef<str> for BinU64Size<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl<C> FromStr for BinU64Size<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()








>
>
>
>
>
>








64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

}

impl<C> AsRef<str> for BinU64Size<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for BinU64Size<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for BinU64Size<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()
︙︙
Changes to src/binusizecount.rs. 
1
2
3
4
5
6
7
8

use std::{marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};


|








1
2
3
4
5
6
7
8

use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

}

impl<C> AsRef<str> for BinUsizeCount<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl<C> FromStr for BinUsizeCount<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()








>
>
>
>
>
>








64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

}

impl<C> AsRef<str> for BinUsizeCount<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for BinUsizeCount<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for BinUsizeCount<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()
︙︙
Changes to src/binusizesize.rs. 
1
2
3
4
5
6
7
8

use std::{marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};


|








1
2
3
4
5
6
7
8

use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

}

impl<C> AsRef<str> for BinUsizeSize<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl<C> FromStr for BinUsizeSize<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()








>
>
>
>
>
>








64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

}

impl<C> AsRef<str> for BinUsizeSize<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for BinUsizeSize<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for BinUsizeSize<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()
︙︙
Changes to src/boolean.rs. 
1
2
3
4
5
6
7
8

use std::str::FromStr;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};


|








1
2
3
4
5
6
7
8

use std::{fmt, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙︙
56
57
58
59
60
61
62






63
64
65
66
67
68
69

}

impl AsRef<str> for Bool {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl FromStr for Bool {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = match s {
      "0" | "false" | "f" | "off" => false,








>
>
>
>
>
>








56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

}

impl AsRef<str> for Bool {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl fmt::Display for Bool {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl FromStr for Bool {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = match s {
      "0" | "false" | "f" | "off" => false,
︙︙
Changes to src/decu64count.rs. 
1
2
3
4
5
6
7
8

use std::{marker::PhantomData, str::FromStr};

use parse_size::ByteSuffix;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}

|








1
2
3
4
5
6
7
8

use std::{fmt, marker::PhantomData, str::FromStr};

use parse_size::ByteSuffix;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
︙︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

}

impl<C> AsRef<str> for DecU64Count<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl<C> FromStr for DecU64Count<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()








>
>
>
>
>
>








64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

}

impl<C> AsRef<str> for DecU64Count<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for DecU64Count<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for DecU64Count<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()
︙︙
Changes to src/decu64size.rs. 
1
2
3
4
5
6
7
8

use std::{marker::PhantomData, str::FromStr};

use parse_size::ByteSuffix;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}

|








1
2
3
4
5
6
7
8

use std::{fmt, marker::PhantomData, str::FromStr};

use parse_size::ByteSuffix;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
︙︙
63
64
65
66
67
68
69






70
71
72
73
74
75
76

}

impl<C> AsRef<str> for DecU64Size<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl<C> FromStr for DecU64Size<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()








>
>
>
>
>
>








63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

}

impl<C> AsRef<str> for DecU64Size<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for DecU64Size<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for DecU64Size<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()
︙︙
Changes to src/decusizecount.rs. 
1
2
3
4
5
6
7
8

use std::{marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};


|








1
2
3
4
5
6
7
8

use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

}

impl<C> AsRef<str> for DecUsizeCount<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl<C> FromStr for DecUsizeCount<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()








>
>
>
>
>
>








64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

}

impl<C> AsRef<str> for DecUsizeCount<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for DecUsizeCount<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for DecUsizeCount<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()
︙︙
Changes to src/decusizesize.rs. 
1
2
3
4
5
6
7
8

use std::{marker::PhantomData, str::FromStr};

use parse_size::ByteSuffix;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}

|








1
2
3
4
5
6
7
8

use std::{fmt, marker::PhantomData, str::FromStr};

use parse_size::ByteSuffix;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
︙︙
63
64
65
66
67
68
69






70
71
72
73
74
75
76

}

impl<C> AsRef<str> for DecUsizeSize<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl<C> FromStr for DecUsizeSize<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()








>
>
>
>
>
>








63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

}

impl<C> AsRef<str> for DecUsizeSize<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for DecUsizeSize<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for DecUsizeSize<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()
︙︙
Changes to src/dur.rs. 
1
2
3
4
5
6
7
8

use std::{marker::PhantomData, str::FromStr, time::Duration};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};


|








1
2
3
4
5
6
7
8

use std::{fmt, marker::PhantomData, str::FromStr, time::Duration};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙︙
69
70
71
72
73
74
75






76
77
78
79
80
81
82

}

impl<C> AsRef<str> for Dur<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl<C> FromStr for Dur<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let dur = s
      .parse::<jiff::SignedDuration>()








>
>
>
>
>
>








69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

}

impl<C> AsRef<str> for Dur<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for Dur<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for Dur<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let dur = s
      .parse::<jiff::SignedDuration>()
︙︙
Changes to src/percent.rs. 
1
2
3
4
5
6
7
8
9
10

//! Relative or absolute limit.

use std::str::FromStr;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};




|








1
2
3
4
5
6
7
8
9
10

//! Relative or absolute limit.

use std::{fmt, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙︙
52
53
54
55
56
57
58






59
60
61
62
63
64
65

}

impl AsRef<str> for Percent {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl FromStr for Percent {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    if let Some(s) = s.strip_suffix("%") {
      let val = s.parse::<f32>().unwrap();








>
>
>
>
>
>








52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

}

impl AsRef<str> for Percent {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl fmt::Display for Percent {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl FromStr for Percent {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    if let Some(s) = s.strip_suffix("%") {
      let val = s.parse::<f32>().unwrap();
︙︙
Changes to src/relabslim.rs. 
1
2
3
4
5
6
7
8
9
10

//! Relative or absolute limit.

use std::{marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};




|








1
2
3
4
5
6
7
8
9
10

//! Relative or absolute limit.

use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙︙
100
101
102
103
104
105
106






107
108
109
110
111
112
113

}

impl<C> AsRef<str> for RelAbsLim<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl<C> FromStr for RelAbsLim<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    if let Some(s) = s.strip_suffix("%") {
      let f = s.parse::<f32>().unwrap();








>
>
>
>
>
>








100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

}

impl<C> AsRef<str> for RelAbsLim<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for RelAbsLim<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for RelAbsLim<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    if let Some(s) = s.strip_suffix("%") {
      let f = s.parse::<f32>().unwrap();
︙︙
Changes to src/select.rs. 
1
2
3
4
5
6
7
8

use std::str::FromStr;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};


|








1
2
3
4
5
6
7
8

use std::{fmt, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙︙
54
55
56
57
58
59
60






61
62
63
64
65
66
67

}

impl<E> AsRef<str> for Select<E> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}







impl<E> FromStr for Select<E>
where
  E: FromStr
{
  type Err = Error;









>
>
>
>
>
>








54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

}

impl<E> AsRef<str> for Select<E> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<E> fmt::Display for Select<E> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<E> FromStr for Select<E>
where
  E: FromStr
{
  type Err = Error;
︙︙
Changes to src/str.rs. 
1
2
3
4
5
6
7
8

use std::{marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};


|








1
2
3
4
5
6
7
8

use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙︙
61
62
63
64
65
66
67






68
69
70
71
72
73
74

}

impl<C> AsRef<str> for Str<C> {
  fn as_ref(&self) -> &str {
    &self.val
  }
}







impl<C> FromStr for Str<C>
where
  C: Controller<Type = String>
{
  type Err = Error;









>
>
>
>
>
>








61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

}

impl<C> AsRef<str> for Str<C> {
  fn as_ref(&self) -> &str {
    &self.val
  }
}

impl<C> fmt::Display for Str<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.val)
  }
}

impl<C> FromStr for Str<C>
where
  C: Controller<Type = String>
{
  type Err = Error;
︙︙
Changes to www/changelog.md. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14










15
16
17
18
19
20
21

# Change Log

⚠️  indicates a breaking change.

## [Unreleased]

[Details](/vdiff?from=strval-0.3.0&to=trunk)

### Added

### Changed

### Removed











---

## [0.3.0] - 2025-07-29

[Details](/vdiff?from=strval-0.2.0&to=strval-0.3.0)

### Changed







|







>
>
>
>
>
>
>
>
>
>








1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# Change Log

⚠️  indicates a breaking change.

## [Unreleased]

[Details](/vdiff?from=strval-0.3.1&to=trunk)

### Added

### Changed

### Removed

---

## [0.3.1] - 2025-07-30

[Details](/vdiff?from=strval-0.3.0&to=strval-0.3.1)

### Added

- Implement `Display` for data types.  Returns the string representation.

---

## [0.3.0] - 2025-07-29

[Details](/vdiff?from=strval-0.2.0&to=strval-0.3.0)

### Changed
︙︙