https://github.com/kixunil/hex_lit

Rust hex literal without proc macros
https://github.com/kixunil/hex_lit

Last synced: 3 months ago
JSON representation

Rust hex literal without proc macros

• Host: GitHub
• URL: https://github.com/kixunil/hex_lit
• Owner: Kixunil
• Created: 2022-08-13T18:03:45.000Z (over 2 years ago)
• Default Branch: master
• Last Pushed: 2022-08-13T18:04:23.000Z (over 2 years ago)
• Last Synced: 2024-10-11T17:49:23.578Z (3 months ago)
• Language: Rust
• Size: 3.91 KB
• Stars: 2
• Watchers: 3
• Forks: 1
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# Hex literals without proc macros.

This crate implements minimalistic hex literal macros without use of proc macros.

The advantages are much faster compile times, ability to work with non-literal const values and

easier auditing.

However, because of the use of `const fn` the crate has some limitations depending on the Rust

version.

Either way, the resulting type is a byte array (`[u8; N]`) that doesn't force you to write down

its length. This is already very useful since the compiler can prove the length and you avoid

runtime allocations.

The crate is `no_std` and does **not** require an allocator.

## Usage

Just pass a `&str` *constant* (usually a literal) into the hex macro.

Example

```rust

use hex_lit::hex;

let array = hex!("2a15ff");

assert_eq!(&array, &[42, 21, 255]);

```

The input MUST NOT contain any spaces or other separators and it MUST have even length.

Note that you can still separate long strings into chunks using the concat macro:

```rust

use hex_lit::hex;

let array = hex!(concat!(

    "0000002a000000",

    "ffffffffffffff",

));

assert_eq!(&array, &[0, 0, 0, 42, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255]);

```

## Features depending on Rust version

* 1.41.1+ - the MSRV, use in const contexts is impossible, only the hex! macro is available.

* 1.46.0+ - usage in const contexts is available and (regardless of cargo features) correctness

            of input is checked at compile time. 

* 1.57+ - nicer error messages for bad inputs (regardless of cargo features)

## Cargo features

* `rust_v_1_46` - acknowledges bumping MSRV to 1.46+ and enables usage in const context.

Bumping MSRV is intentionally explicit.

Because of improved input checking it is recommended to use Rust 1.46+, prefereably 1.57+ in CI

even if your targeted MSRV is lower.

## License

MITNFA