Rust 最短路径、Tide、Partial、Yew、Leptos、数独实践案例

基于Rust的Meta和pyrefly相关实例

以下是一些基于Rust的Meta和pyrefly相关实例的示例代码和用法。这些示例涵盖了常见的使用场景，包括元编程、代码生成、Python交互等。

基本元编程示例

使用Rust的宏和元编程功能生成代码。

macro_rules! greet {
    ($name:expr) => {
        println!("Hello, {}!", $name);
    };
}

fn main() {
    greet!("World");
}

动态代码生成

使用quote库生成Rust代码。

use quote::quote;

fn generate_struct(name: &str) -> proc_macro2::TokenStream {
    quote! {
        struct #name {
            field: i32,
        }
    }
}

fn main() {
    let generated = generate_struct("MyStruct");
    println!("{}", generated);
}

使用pyrefly与Python交互

通过pyrefly调用Python函数。

use pyrefly::Python;

fn main() {
    let python = Python::acquire_gil();
    let result = python.eval("2 + 2", None, None).unwrap();
    println!("2 + 2 = {}", result);
}

生成Python绑定

使用pyo3生成Python模块。

use pyo3::prelude::*;

#[pyfunction]
fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[pymodule]
fn my_module(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(add, m)?)?;
    Ok(())
}

宏生成测试用例

使用宏生成多个测试用例。

macro_rules! generate_tests {
    ($($name:ident: $value:expr,)*) => {
        $(
            #[test]
            fn $name() {
                assert_eq!($value, true);
            }
        )*
    }
}

generate_tests! {
    test_case_1: 1 == 1,
    test_case_2: 2 == 2,
}

动态类型检查

使用anyhow进行动态类型处理。

use anyhow::Result;

fn process_value(value: &dyn std::any::Any) -> Result<()> {
    if let Some(num) = value.downcast_ref::<i32>() {
        println!("Got an i32: {}", num);
    } else if let Some(s) = value.downcast_ref::<String>() {
        println!("Got a String: {}", s);
    } else {
        anyhow::bail!("Unsupported type");
    }
    Ok(())
}

使用syn解析Rust语法

解析Rust代码并生成AST。

use syn::{parse_str, ItemFn};

fn main() {
    let code = "fn hello() { println!(\"Hello\"); }";
    let ast: ItemFn = parse_str(code).unwrap();
    println!("{:#?}", ast);
}

生成枚举变体

使用宏生成枚举变体。

macro_rules! gen_enum {
    ($name:ident { $($variant:ident),* }) => {
        enum $name {
            $($variant),*
        }
    };
}

gen_enum! { Color { Red, Green, Blue } }

使用pyrefly调用Python脚本

通过pyrefly执行Python脚本。

use pyrefly::{Python, PyResult};

fn main() -> PyResult<()> {
    let python = Python::acquire_gil();
    python.run("print('Hello from Python')", None, None)?;
    Ok(())
}

生成文档注释

使用宏生成文档注释。

macro_rules! doc {
    ($text:expr) => {
        #[doc = $text]
    };
}

doc!("This is a documented function.");
fn my_func() {}

动态分发Traits

使用Box<dyn Trait>实现动态分发。

trait Greet {
    fn greet(&self);
}

struct English;
impl Greet for English {
    fn greet(&self) {
        println!("Hello!");
    }
}

struct Spanish;
impl Greet for Spanish {
    fn greet(&self) {
        println!("Hola!");
    }
}

fn greet_all(greeters: Vec<Box<dyn Greet>>) {
    for greeter in greeters {
        greeter.greet();
    }
}

使用pyrefly传递数据

在Rust和Python之间传递数据。

use pyrefly::{Python, PyResult};

fn main() -> PyResult<()> {
    let python = Python::acquire_gil();
    let list = python.eval("[1, 2, 3]", None, None)?;
    println!("Python list: {:?}", list);
    Ok(())
}

生成Getter/Setter

使用宏生成Getter和Setter。

macro_rules! generate_accessors {
    ($field:ident: $type:ty) => {
        pub fn $field(&self) -> $type {
            self.$field
        }

        pub fn set_$field(&mut self, value: $type) {
            self.$field = value;
        }
    };
}

struct Person {
    age: i32,
}

impl Person {
    generate_accessors!(age: i32);
}

使用pyrefly调用带参数的Python函数

调用Python函数并传递参数。

use pyrefly::{Python, PyResult};

fn main() -> PyResult<()> {
    let python = Python::acquire_gil();
    let result = python.eval("lambda x: x * 2", None, None)?;
    let doubled = result.call1((42,))?;
    println!("Result: {}", doubled);
    Ok(())
}

生成模式匹配

使用宏生成模式匹配代码。

macro_rules! match_values {
    ($value:expr, { $($pat:pat => $expr:expr),* }) => {
        match $value {
            $($pat => $expr),*
        }
    };
}

fn main() {
    let x = 42;
    match_values!(x, {
        0 => println!("Zero"),
        42 => println!("The answer"),
        _ => println!("Other")
    });
}

使用pyrefly导入Python模块

导入Python模块并调用其函数。

use pyrefly::{Python, PyResult};

fn main() -> PyResult<()> {
    let python = Python::acquire_gil();
    let math = python.import("math")?;
    let sqrt = math.getattr("sqrt")?.call1((16.0,))?;
    println!("sqrt(16) = {}", sqrt);
    Ok(())
}

生成Builder模式

使用宏生成Builder模式代码。

macro_rules! generate_builder {
    ($name:ident { $($field:ident: $type:ty),* }) => {
        struct $name {
            $($field: $type),*
        }

        struct Builder {
            $($field: Option<$type>),*
        }

        impl Builder {
            $(
                fn $field(mut self, value: $type) -> Self {
                    self.$field = Some(value);
                    self
                }
            )*

            fn build(self) -> $name {
                $name {
                    $($field: self.$field.unwrap()),*
                }
            }
        }
    };
}

generate_builder!(Person {
    name: String,
    age: i32,
});

使用pyrefly处理异常

捕获Python异常并处理。

use pyrefly::{Python, PyResult};

fn main() -> PyResult<()> {
    let python = Python::acquire_gil();
    let result = python.eval("1 / 0", None, None);
    if let Err(e) = result {
        println!("Error: {}", e);
    }
    Ok(())
}

生成泛型函数

使用宏生成泛型函数。

macro_rules! gen_fn {
    ($name:ident<$T:ident>($arg:ident: $T) -> $ret:ty $body:block) => {
        fn $name<$T>($arg: $T) -> $ret $body
    };
}

gen_fn!(identity<T>(x: T) -> T { x });

使用pyrefly序列化数据

将Rust数据序列化为Python对象。

use pyrefly::{Python, PyResult, ToPyObject};

fn main() -> PyResult<()> {
    let python = Python::acquire_gil();
    let dict = python.eval("{}", None, None)?;
    dict.set_item("key", "value")?;
    println!("Dict: {:?}", dict);
    Ok(())
}

生成测试模块

使用宏生成测试模块。

macro_rules! test_module {
    ($name:ident { $($test:ident: $body:block),* }) => {
        mod $name {
            $(
                #[test]
                fn $test() $body
            )*
        }
    };
}

test_module!(tests {
    test1: { assert_eq!(1, 1); },
    test2: { assert_eq!(2, 2); },
});

使用pyrefly调用类方法

调用Python类的实例方法。

use pyrefly::{Python, PyResult};

fn main() -> PyResult<()> {
    let python = Python::acquire_gil();
    let class = python.eval(
        "class MyClass:
            def method(self):
                return 42",
        None, None,
    )?;
    let instance = class.call0()?;
    let result = instance.call_method0("method")?;
    println!("Result: {}", result);
    Ok(())
}

生成常量

使用宏生成常量。

macro_rules! gen_consts {
    ($($name:ident = $value:expr),*) => {
        $(
            const $name: i32 = $value;
        )*
    };
}

gen_consts!(ONE = 1, TWO = 2);

使用pyrefly多线程交互

在多线程环境中使用Python。

use pyrefly::{Python, PyResult};
use std::thread;

fn main() -> PyResult<()> {
    let python = Python::acquire_gil();
    let handle = thread::spawn(move || {
        let python = Python::acquire_gil();
        python.eval("print('Hello from thread')", None, None).unwrap();
    });
    handle.join().unwrap();
    Ok(())
}

生成标记联合体

使用宏生成标记联合体。

macro_rules! gen_enum {
    ($name:ident { $($variant:ident($type:ty)),* }) => {
        enum $name {
            $($variant($type)),*
        }
    };
}

gen_enum!(Value {
    Int(i32),
    Float(f64),
    Text(String),
});

使用pyrefly调用NumPy

调用NumPy函数进行计算。

use pyrefly::{Python, PyResult};

fn main() -> PyResult<()> {
    let python = Python::acquire_gil();
    let np = python.import("numpy")?;
    let array = np.getattr("array")?.call1((vec![1, 2, 3],))?;
    let sum = np.getattr("sum")?.call1((array,))?;
    println!("Sum: {}", sum);
    Ok(())
}

生成迭代器适配器

使用宏生成迭代器适配器。

macro_rules! gen_iterator {
    ($name:ident($iter:expr) $body:block) => {
        struct $name<I> {
            iter: I,
        }

        impl<I: Iterator> Iterator for $name<I> {
            type Item = I::Item;

            fn next(&mut self) -> Option<Self::Item> {
                $body
            }
        }

        fn $name<I: Iterator>(iter: I) -> $name<I> {
            $name { iter }
        }
    };
}

gen_iterator!(double(iter) {
    self.iter.next().map(|x| x * 2)
});

使用pyrefly回调Rust函数

从Python回调Rust函数。

use pyrefly::{Python, PyResult};

fn callback(arg: i32) -> i32 {
    arg * 2
}

fn main() -> PyResult<()> {
    let python = Python::acquire_gil();
    let callback = python.into_py(callback);
    let result = python.eval(
        "lambda f, x: f(x)",
        None, None,
    )?.call1((callback, 21))?;
    println!("Result: {}", result);
    Ok(())
}

生成DSL

使用宏生成领域特定语言。