标签: mutable

我正在实现Ukkonen的算法,它要求树的所有叶子都包含对同一整数的引用,并且我在Haskell中这样做以了解有关该语言的更多信息.但是,我很难写出执行此操作的数据类型.

-- Node has children, indexes of info on the edge
-- to it, and an optional suffix link.

-- Leaf has a beginning index of the info, but the
-- end index is always an incrementing variable index.
data STree = Node [STree] (Int, Int) (Maybe STree)
           | Leaf (Int, ??? )

如何将引用放在Leaf类型声明中？

Rails 有一个名为的类扩展class_attribute，它允许继承类实例变量。这适用于不可变对象，例如String，但不适用于可变对象：

class Base
  class_attribute :options
  self.options = {}
end

class SubClass < Base
end

Base.options                   # {}
SubClass.options[:foo] = "bar" # { foo: "bar" }
Base.options                   # { foo: "bar" }

问题是如何让子类拥有自己的副本，options而不在其主体中显式初始化它：

class SubClass < Base
  self.options = {}
end

首先,我不是问&mut和ref mut本身有什么区别.

我在问,因为我想:

let ref mut a = MyStruct

是相同的

let a = &mut MyStruct

考虑从函数返回特征对象.你可以退还一个Box<Trait>或一个&Trait.如果您希望对其方法进行可变访问,是否可以返回&mut Trait？

鉴于这个例子:

trait Hello {
    fn hello(&mut self);
}

struct English;
struct Spanish;

impl Hello for English {
    fn hello(&mut self) {
        println!("Hello!");
    }
}

impl Hello for Spanish {
    fn hello(&mut self) {
        println!("Hola!");
    }
}

该方法接收可变参考用于演示目的.

这不会编译:

fn make_hello<'a>() -> &'a mut Hello {
    &mut English
}

也不是这样

fn make_hello<'a>() -> &'a …

假设我有一个inputshape张量100x1、另一个inplaceshape张量20x1和一个index_tensorshape 100x1。代表我想要插入值index_tensor的位置。只有20 个 True 值，其余值为 False。我尝试在下面解释所需的操作。 inputinplaceindex_tensor 使用tensorflow如何实现这个操作。

assign操作仅适用于tf.Variable我想将其应用于 的输出tf.nn.rnn。

我读到可以使用，tf.scatter_nd但它需要inplace和index_tensor具有相同的形状。

我想使用它的原因是我从 rnn 获得输出，然后我从中提取一些值并将它们输入到某个致密层，而来自致密层的输出，我想插入回从 rnn 获得的原始张量中手术。由于某些原因，我不想对 rnn 的整个输出应用密集层操作，如果我不将密集层的结果插入到 rnn 的输出中，那么密集层就没用了。

任何建议将不胜感激。

我一直在尝试使用文件中的属性名称动态加载的数据类，但无法找到创建“冻结”和“非冻结”属性的方法。我相信数据类只允许您将所有属性设置为冻结或非冻结。

截至目前，我创建了一个冻结数据类，并添加了一个可变类作为我可以随时更改的属性之一，但我对这种方法的可读性不太满意。

人们是否会推荐另一个Pythonic数据类，而不需要实现一个能够设置可变/不可变属性的类？

import dataclasses

class ModifiableConfig:
    """There is stuff in here but you get the picture."""
    ...

config_dataclass = dataclasses.make_dataclass(
    'c',
    [(x, type(x), v) for x, v in config.items()] + [('var', object, ModifiableConfig())],
    frozen=True
)

不过，我更喜欢能够选择哪些属性被冻结，哪些属性不被冻结。不再需要向数据类添加额外的类。它可能看起来像这样：

config_dataclass_modifiable = dataclasses.make_dataclass(
            'c', [(x, type(x), v, True if 'modifiable' in x else False) for x, v in config.items()])

请注意“如果 x else False 中‘可修改’则为 True”，我并不是说这就是我最终会做的事情，但希望这有助于更好地理解我的问题。

我会实现一个简单的链表。这是我到目前为止的（工作）代码：

pub struct LinkedList<T> {
    start: Option<Box<Link<T>>>,
}

impl<T> LinkedList<T> {
    pub fn new() -> LinkedList<T> {
        return LinkedList { start: None };
    }
}

struct Link<T> {
    value: Box<T>,
    next: Option<Box<Link<T>>>,
}

impl<T> Link<T> {
    fn new_end(value: T) -> Link<T> {
        return Link::new(value, None);
    }

    fn new(value: T, next: Option<Box<Link<T>>>) -> Link<T> {
        return Link {
            value: Box::new(value),
            next,
        };
    }
}

列表中的下一个是附加到列表的方法；这就是我想出的：

pub fn append(&mut self, element: T) {
    // Create the link to append
    let new_link = …

如果我在如下结构中有数组，我无法比较结构的相等性，因为数组是可变的？有没有办法让等式传递给数组，以便我得到truefor a([1,2,3]) == a([1,2,3])？或者是这样做的唯一方法来扩展Base.==？

julia> struct a
       v
       end

julia> a([1,2,3]) == a([1,2,3])
false

julia> a(1) == a(1)
true

julia> [1,2,3] == [1,2,3] # want the equality to work like this for the struct
true

julia> [1,2,3] === [1,2,3]
false

我正在从书中学习 Rust，并且正在处理第 8 章末尾的练习，但是在将单词转换为 Pig Latin 的问题上我遇到了困难。我想具体看看我是否可以将 a 传递&mut String给一个接受 a （也接受切片）的函数&mut str并修改其中引用的字符串，以便将更改反射回外部而不需要 a return，就像在 C 中使用 a 一样char **。

我不太确定我只是搞乱了语法，还是由于 Rust 的严格规则而导致它比听起来更复杂，而我还没有完全掌握这些规则。对于里面的终身错误，to_pig_latin()我记得读过一些解释如何正确处理这种情况的东西，但现在我找不到它，所以如果你也能为我指出它，我将非常感激。

另外，您对我处理字符串内的字符和索引的方式有何看法？

use std::io::{self, Write};

fn main() {
    let v = vec![
        String::from("kaka"),
        String::from("Apple"),
        String::from("everett"),
        String::from("Robin"),
    ];

    for s in &v {
        // cannot borrow `s` as mutable, as it is not declared as mutable
        // cannot borrow data in a `&` reference as mutable
        to_pig_latin(&mut s);
    }

    for …

我目前正在使用一些 DataFrame，并希望使我的代码模块化。这需要将数据帧传递给函数。我知道 DataFrame 的可变性质以及将可变实例传递给函数时的一些“陷阱”。DataFrames 的功能是否有最佳实践？我应该在函数内复制一份然后将其传回吗？或者我应该在函数内对 df 进行更改并返回 None ？

选项 1 还是选项 2 更好？下面是传达这个想法的基本代码：

选项1：

def test(df):
    df['col1'] = df['col1']+1
    return None

test(df)

选项2：

def test(main_df):
    df = main_df.copy()
    df['col1'] = df['col1']+1
    return df 

main_df = test(main_df)

正如问题lambda capture by value mutable 中所见，它不适用于 const &? , 当const T&使用其名称或[=]可变 lambda捕获类型的值时，隐藏类中的字段获取类型const T。可以争论的是，这对于可变 lambda 来说是正确的做法。

但是为什么对非可变 lambda 也这样做呢？在非可变 lambda 表达式中，operator()(...)is 被声明const，因此无论如何它都不能修改捕获的值。

当我们移动 lambda 时，例如将它包装在std::function.

请参阅以下两个示例：

#include <cstdio>
#include <functional>

std::function<void()> f1, f2;

struct Test {
    Test() {puts("Construct");}
    Test(const Test& o) {puts("Copy");}
    Test(Test&& o) {puts("Move");}
    ~Test() {puts("Destruct");}
};

void set_f1(const Test& v) {
    f1 = [v] () {}; // field type in lambda object will be …