c0nst 0.2.1

proc-macro for sharing code between const and non-const traits
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

# c0nst

[![Crates.io](https://img.shields.io/crates/v/c0nst.svg)](https://crates.io/crates/c0nst)
[![Documentation](https://docs.rs/c0nst/badge.svg)](https://docs.rs/c0nst)
[![Build Status](https://github.com/npmccallum/c0nst/workflows/CI/badge.svg)](https://github.com/npmccallum/c0nst/actions)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Rust 1.63+](https://img.shields.io/badge/rust-1.63+-orange.svg)](https://www.rust-lang.org)

Write const trait code once, run on both nightly and stable Rust.

```rust
#![cfg_attr(feature = "nightly", feature(const_trait_impl))]

c0nst::c0nst! {
    pub c0nst trait Default {
        fn default() -> Self;
    }

    impl c0nst Default for () {
        fn default() -> Self {}
    }

    pub c0nst fn default<T: [c0nst] Default>() -> T {
        T::default()
    }
}
```

## Installation

```toml
[dependencies]
c0nst = "0.2"

[features]
nightly = ["c0nst/nightly"]
```

## How it works

Replace `const` with `c0nst` - the macro transforms your code based on feature
flags:

- **With `nightly` feature**: `c0nst` → `const` (modern const trait syntax)
- **Without `nightly` feature**: `c0nst` and `[c0nst]` are removed (stable
  compatibility)

Perfect for **library authors** - write once, let users choose between nightly
const traits or stable compatibility.

## Features

- **Zero-cost** - Simple keyword replacement, no runtime overhead
- **Forward compatible** - Easy migration when const traits stabilize
  (`s/c0nst/const/g`)
- **Lightweight** - Single proc-macro, minimal dependencies
- **Comprehensive** - Handles all syntax from the
  [RFC](https://github.com/rust-lang/rust/issues/143874)
- **Destruct support** - Automatically resolves `Destruct` trait references

## For Library Authors

Write const-optional traits that work for everyone! First, expose the choice to
your library users:

```toml
# Cargo.toml
[features]
nightly = ["c0nst/nightly"]
```

Then, define and implement const traits using the nightly syntax (with the
`c0nst` variation):

```rust
// src/lib.rs
#![cfg_attr(feature = "nightly", feature(const_trait_impl))]

c0nst::c0nst! {
    pub c0nst trait Compute {
        fn calculate(&self) -> u32;
    }

    impl c0nst Compute for u32 {
        fn calculate(&self) -> u32 { *self * 2 }
    }
}
```

## For Library Users

### Runtime (Stable)

If you want to run on stable rust, use the library like normal. First, add the
dependency:

```toml
# Cargo.toml
[dependencies]
my-lib = "1.0"
```

Then use the dependency.

```rust
// src/main.rs
let value: u32 = 42u32.calculate(); // ✅ Runtime
```

That's it. You can compile on stable rust and get runtime behavior.

### Compile-time (Nightly)

On the other hand, if you want compile-time behavior and are willing to accept
the requirement to compile only on nightly, then just use the `nightly` feature:

```toml
# Cargo.toml
[dependencies]
my-lib = { version = "1.0", features = ["nightly"] }
```

Then, you get compile-time behavior:

```rust
// src/main.rs
#![feature(const_trait_impl)]
const VALUE: u32 = 42u32.calculate(); // ✅ Compile-time
```