bon 3.9.1

Next-gen compile-time-checked builder generator, named function's arguments, and more!
Documentation 
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use crate::prelude::*;

struct IntoBool(bool);

impl From<IntoBool> for bool {
    fn from(value: IntoBool) -> Self {
        value.0
    }
}

struct IntoUnit;

impl From<IntoUnit> for () {
    fn from(IntoUnit: IntoUnit) {}
}

struct IntoStrRef<'a>(&'a str);

impl<'a> From<IntoStrRef<'a>> for &'a str {
    fn from(value: IntoStrRef<'a>) -> Self {
        value.0
    }
}

struct Generic<T>(T);
struct IntoGeneric<T>(T);

impl<T> From<IntoGeneric<T>> for Generic<T> {
    fn from(value: IntoGeneric<T>) -> Self {
        Self(value.0)
    }
}

#[test]
fn match_any() {
    #[builder(on(_, into))]
    fn sut<T>(_arg1: bool, _arg2: Option<()>, _arg3: T) {}

    sut::<&str>()
        .arg1(IntoBool(true))
        .arg2(IntoUnit)
        .arg3(IntoStrRef("foo"))
        .call();
}

#[test]
fn match_str_ref() {
    #[builder(on(&str, into))]
    fn sut(_arg1: bool, _arg2: Option<()>, _arg3: &str) {}

    sut().arg1(true).arg2(()).arg3(IntoStrRef("foo")).call();
}

#[test]
fn match_path() {
    #[builder(on(bool, into))]
    fn sut<T>(_arg1: bool, _arg2: Option<()>, _arg3: T) {}

    sut::<&str>()
        .arg1(IntoBool(true))
        .arg2(())
        .arg3("foo")
        .call();
}

#[test]
fn match_generic() {
    #[builder(on(Generic<_>, into))]
    fn sut<T>(_arg1: bool, _arg2: Option<()>, _arg3: Generic<T>) {}

    sut().arg1(true).arg2(()).arg3(IntoGeneric("foo")).call();
}