optionally_const 0.1.0

Optional constness on stable Rust.
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

# Optional const

[![Crates.io](https://img.shields.io/crates/v/optionally_const)](https://crates.io/crates/optionally_const)
[![Downloads](https://img.shields.io/crates/d/optionally_const.svg)](https://crates.io/crates/optionally_const)
[![Documentation](https://docs.rs/optionally_const/badge.svg)](https://docs.rs/optionally_const)
[![License](https://img.shields.io/crates/l/optionally_const)](https://crates.io/crates/optionally_const)
[![Dependency Status](https://deps.rs/repo/github/JohnScience/optionally_const/status.svg)](https://deps.rs/repo/github/JohnScience/optionally_const)

Optional constness on stable Rust.

This crate should be superseded by [keyword genericity](#read-more-about-keyword-genericity) in the future.

## Usage


```rust
use optionally_const::{const_type_instance, OptionallyConst};

fn print_flag<T: OptionallyConst<bool>>(flag: T) {
    if let Some(flag) = T::MAYBE_CONST {
        println!("flag is const: {flag}");
    } else {
        let flag: bool = flag.into_value();
        println!("flag is not const: {flag}");
    };
}

fn main() {
    print_flag(true);
    print_flag(false);
    print_flag(const_type_instance!(true));
    print_flag(const_type_instance!(false));
}
```

## Limitations


* Rust currently doesn't allow defining a type like `struct ConstType<T, const VAL: T>;` because the type of const parameters must not depend on other generic parameters [\[E770\]]. Consequently, one can't provide a canonical "const type" for any const value.
* The `const_type_instance!` macro currently supports only `bool` type. However, it can be extended to support other types in the future.
* Due to lack of support for [negative trait bounds] and [\[E770\]], it's impossible to implement `OptionallyConst<T>` for all types that implement `Const<T>`. The current implementation only supports `bool` type. However, you can implement both `OptionallyConst<T>` and `Const<T>` for your own types.

## Optional constness for user-defined types


### Enums


```rust
use optionally_const::Const;

enum MyEnum {
    A,
    B,
    C,
}

impl std::fmt::Display for MyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            MyEnum::A => write!(f, "A"),
            MyEnum::B => write!(f, "B"),
            MyEnum::C => write!(f, "C"),
        }
    }
}

struct MyEnumAConstType;
struct MyEnumBConstType;
struct MyEnumCConstType;

// Ideally, OptionallyConst<T> should be implemented for
// all types that implement Const<T>.
//
// However, impl of OptionallyConst<T> for all `T` conflicts with the
// impl of OptionallyConst<T> for all `U: Const<T>` in the absence of
// negative trait bounds.

impl Const<MyEnum> for MyEnumAConstType {
    const VALUE: MyEnum = MyEnum::A;
}

impl OptionallyConst<MyEnum> for MyEnumAConstType {
    const MAYBE_CONST: Option<MyEnum> = Some(MyEnum::A);

    fn into_value(self) -> MyEnum {
        MyEnum::A
    }
}

impl Const<MyEnum> for MyEnumBConstType {
    const VALUE: MyEnum = MyEnum::B;
}

impl OptionallyConst<MyEnum> for MyEnumBConstType {
    const MAYBE_CONST: Option<MyEnum> = Some(MyEnum::B);

    fn into_value(self) -> MyEnum {
        MyEnum::B
    }
}

impl Const<MyEnum> for MyEnumCConstType {
    const VALUE: MyEnum = MyEnum::C;
}

impl OptionallyConst<MyEnum> for MyEnumCConstType {
    const MAYBE_CONST: Option<MyEnum> = Some(MyEnum::C);

    fn into_value(self) -> MyEnum {
        MyEnum::C
    }
}

fn print_my_enum<T: OptionallyConst<MyEnum>>(value: T) {
    if let Some(value) = T::MAYBE_CONST {
        println!("value is const: {value}");
    } else {
        let value: MyEnum = value.into_value();
        println!("value is not const: {value}");
    };
}

fn main() {
    print_my_enum(MyEnum::A);
    print_my_enum(MyEnum::B);
    print_my_enum(MyEnum::C);
    print_my_enum(MyEnumAConstType);
    print_my_enum(MyEnumBConstType);
    print_my_enum(MyEnumCConstType);
}
```

*Note: to migitate this problem, this crate should ideally provide a derive macro
that should be applied to enums. However, there's no such derive macro at the time of writing.*

## Read more about keyword genericity


* <https://blog.rust-lang.org/inside-rust/2022/07/27/keyword-generics/>

[\[E770\]]: https://doc.rust-lang.org/stable/error_codes/E0770.html
[negative trait bounds]: https://doc.rust-lang.org/beta/unstable-book/language-features/negative-bounds.html