Data structures 创建命名结构的静态iterable集合的惯用方法？

创建命名结构的静态iterable集合的惯用方法是什么？我有一个结构的

n

实例，其中

n

在编译时已知，并且小于20。我希望能够遍历所有条目，并且能够通过名称而不是索引引用每个条目。所有数据在编译时都是已知的

我可以使用数组或枚举，以及将标签映射到索引的手写常量；但这似乎很挑剔

fn common_behaviour(x: f64) {
   print!("{}", x);
}

const ADD: usize = 0;
const SUBTRACT: usize = 1;

fn main () {
    let mut foos: [f64; 2] = [0.0; 2];
    foos[ADD] = 4.0;
    foos[SUBTRACT] = 2.0;

    for foo in &foos {
       common_behaviour(*foo);
    }
    foos[ADD] += 1.0;
    foos[SUBTRACT] -= 1.0;
}

或者，我可以只支付性能成本并使用HashMap，因为散列开销实际上可能并不重要，但这似乎也不太理想

也许，我可以重构代码，使用函数指针，而不是对不同的特殊情况进行特殊的封装

fn common_behaviour(x: f64) {
   print!("{}", x);
}

fn add(x: f64) -> f64 {
    x + 1.0
}

fn subtract(x: f64) -> f64 {
    x - 1.0
}

struct Foo {
   data: f64,
   special: fn(f64) -> f64
}

impl Foo {
    fn new(data: f64, special: fn(f64) -> f64) -> Foo {
        Foo { data, special }
    }
}

fn main() {
    let mut foos = [Foo::new(4.0, add), Foo::new(2.0, subtract)];

    for foo in &mut foos {
       common_behaviour(foo.data);
       foo.data = (foo.special)(foo.data);
    }
}

处理这种情况最惯用的方法是什么？

看看：

fn main() {
    let mut foos = [Foo::new(4.0, add), Foo::new(2.0, subtract)];

    for foo in &mut foos {
       common_behaviour(foo.data);
       foo.data = (foo.special)(foo.data);
    }
}

我看到了一个正在努力涌现的模式，Rust非常擅长表达这种模式，这要归功于

enum

：

enum Foo {
    Add(f64),
    Sub(f64),
}

impl Foo {
    fn apply(&mut self) {
        match self {
            Foo::Add(x) => {
                Self::common(*x);
                *x += 1.0;
            },
            Foo::Sub(x) => {
                Self::common(*x);
                *x -= 1.0;
            },
        }
    }

    fn common(x: f64) {
        print!("{}", x);
    }
}

你的例子是：

fn main() {
    let mut foos = [Foo::Add(4.0), Foo::Sub(2.0)];

    for foo in &mut foos {
       foo.apply();
    }
}

---

查看编译时生成的映射。这个问题可以从一个代码示例中受益，该示例展示了您拥有的以及如何使用它；我不知道如何理解“函数指针”注释，它似乎与问题无关。。。这让我觉得我一开始就不理解这个问题。@MatthieuM。添加了代码示例。如果你需要更多的澄清，我很乐意补充。