Lib.rs

› Rust 模式
#proc-macro #string-literal #prefix #string #attributes #formatted #proc-macro-attributes

nightly prefixes

类似属性的宏，模仿字面量前缀，例如 #[f]"Hello, {world}"

synek317 拥有。

1 个不稳定版本

0.1.0 2024 年 4 月 20 日

#2001 在 Rust 模式

自定义许可

17KB

prefixes

重要提示

此项目目前仅是一个实验。到目前为止，项目是否将继续或很快被放弃还不确定。有关字面量前缀的持续讨论请参见此处

描述

Prefixes 为字面量提供各种前缀样式的过程宏属性，以便轻松创建常见类型。

快速示例

#![feature(stmt_expr_attributes, proc_macro_hygiene)]

use prefixes::{f, ms, P, s};

fn _deep_thought2() -> String {
    let answer_path = #[P]"./answer.txt";
    let answer = if answer_path.exists() {
        std::fs::read_to_string(&answer_path).unwrap()
    } else {
        std::thread::sleep(#[s]6 + #[ms]9);
        #[f]"42"
    };

    #[f]"Answer to the Ultimate Question of Life, the Universe, and Everything = {answer}"
}

使用方法

要使用 prefixes，首先将其添加到您的项目中的 Cargo.toml

[dependencies]
prefixes = "0.1.0"

然后启用 stmt_expr_attributes 和 proc_macro_hygiene 功能（这只能在 nightly Rust 上实现）

#![feature(stmt_expr_attributes, proc_macro_hygiene)]

最后，使用您需要的 prefixes，例如。

#![feature(stmt_expr_attributes, proc_macro_hygiene)]
use prefixes::f;

fn greeting(name: &str) -> String {
    #[f]"Welcome, {name}!"
}

Prefixes

Prefix #[f]

使用 format! 宏从字符串字面量构建格式化的字符串。

#![feature(stmt_expr_attributes, proc_macro_hygiene)]
use prefixes::f;

let n = 2137;
let s1 = format!("n = {n}");
let s2 = #[f]"n = {n}";

assert_eq!(s1, s2);

也可能用于创建拥有字符串，例如

#![feature(stmt_expr_attributes, proc_macro_hygiene)]
use prefixes::f;

let s1 = #[f]"2137";
let s2 = "2137".to_string();

assert_eq!(s1, s2);

Prefixes #[ms], #[s]

使用 from_millis（#[ms]）或 from_secs[_f32|_f64] 方法（#[s]）从整数字面量构建 std::time::Duration。

#![feature(stmt_expr_attributes, proc_macro_hygiene)]
use std::time::Duration;
use prefixes::{ms, s};

let d1 = Duration::from_millis(1000);
let d2 = #[ms]1000;

assert_eq!(d1, d2);

let d3 = Duration::from_secs(2);
let d4 = #[s]2;

assert_eq!(d3, d4);

let d5 = Duration::from_secs_f32(3.0f32);
let d6 = #[s]3.0f32;

assert_eq!(d5, d6);

let d7 = Duration::from_secs_f64(4.0f64);
let d8 = #[s]4.0f64;

assert_eq!(d7, d8);

Prefixes #[os], #[OS]

从字符串字面量构建 OsStr（#[os]）或 OsString（#[OS]）。此外，#[OS] 支持类似于 #[f] 的字符串插值。

#![feature(stmt_expr_attributes, proc_macro_hygiene)]
use std::ffi::{OsStr, OsString};
use prefixes::{os, OS};

let os1 = OsStr::new("foo");
let os2 = #[os]"foo";

assert_eq!(os1, os2);

let n = 42;
let os3 = OsString::from(format!("n = 42"));
let os4 = #[OS]"n = 42";

assert_eq!(os3, os4);

Prefixes #[p], #[P]

从字符串字面量构建 Path (#[p]) 或 PathBuf (#[P])。此外，#[P] 支持字符串插值。

#![feature(stmt_expr_attributes, proc_macro_hygiene)]
use std::path::{Path, PathBuf};
use prefixes::{p, P};

let p1 = Path::new("/foo");
let p2 = #[p]"/foo";

assert_eq!(p1, p2);

let ext = "txt";
let p3 = PathBuf::from(format!("/foo.{ext}"));
let p4 = #[P]"/foo.{ext}";

assert_eq!(p3, p4);

前缀 #[re], #[RE]

从字符串字面量构建 Regex。此外，#[RE] 调用 .unwrap() 结果。仅在将 regex crate 包含在依赖项中时才有效。不需要显式使用 use regex::Regex。

#![feature(stmt_expr_attributes, proc_macro_hygiene)]
use regex::Regex;
use prefixes::{re, RE};

let re1 = Regex::new("1|2");
let re2 = #[re]"1|2";

assert_eq!(format!("{re1:?}"), format!("{re2:?}"));

let re3 = Regex::new("[A-Z]").unwrap();
let re4 = #[RE]"[A-Z]";

assert_eq!(format!("{re3:?}"), format!("{re4:?}"));

许可协议

本项目受 MIT 许可协议许可 - 有关详细信息，请参阅 LICENSE 文件。

依赖项

~255–700KB
~17K SLoC