我目前正在用Scala编程,但我想这适用于任何函数式编程语言,或者更确切地说,任何编程语言都推荐不变性并且可以与数据库交互.

当我从数据库中获取数据时,我将其映射到模型数据结构.在函数式编程中,数据结构往往是不可变的.但是数据库中的数据是可变的,所以我想知道我的模型是否也应该是可变的.一般来说,在这种情况下,什么是好的和广为接受的做法？

按照Martin Odersky在Coursera上的Scala课程,我记得他说过:

最好使用不可变数据结构,但是当你想与现实世界交互时,使用可变数据结构会很有用.

所以,我再次想知道该怎么做.截至目前,我的数据结构是不可变的,当我想更新数据库中的记录时,这会导致很多样板代码.使用可变模型有助于减少这种锅炉板吗？

(我已经问了一个类似于我使用的技术的类似问题,但我对实际答案并不满意,所以我在这里概括了一下.)

嘿,我尝试修剪groovy列表中的每个字符串项

list.each() { it = it.trim(); }

但这仅适用于闭包,在列表中字符串仍然是"foo","bar"和"groovy".

我怎样才能实现这一目标？

在Python中,如何重用现有的相等的不可变对象(就像这样做str)？这可以通过定义__hash__方法来完成,还是需要更复杂的措施？

我听说纯功能数据结构的一个好处就是你可以免费获得undo/redo操作.有人可以解释原因吗？我不明白为什么在函数式语言中添加undo/redo更容易.

例如,假设我有以下队列实现:

data Queue a = Queue [a] [a]

newQueue :: Queue a
newQueue = Queue [] []

empty :: Queue a -> Bool
empty (Queue [] []) = True
empty _ = False

enqueue :: Queue a -> a -> Queue a
enqueue (Queue xs ys) y = Queue xs (y:ys)

dequeue :: Queue a -> (a, Queue a)
dequeue (Queue [] []) = error "Queue is empty!"
dequeue (Queue [] ys) = dequeue (Queue (reverse ys) [])
dequeue …

我想确保给定的一组对象是不可变的.

我正在考虑以下方面的事情:

1. 检查每个字段是否为私人决赛
2. 检查课程是否是最终的
3. 检查可变成员

所以我想我的问题是:可能吗？

我可以递归地检查一个类的每个成员是否都有它的字段private final,但这还不够,因为一个类可以有一个名为e的方法getHaha(param),它将给定的param添加到一个数组中.

那么有一个很好的方法来检查一个对象是不可变的还是甚至可能？

谢谢,

我最近一直在潜入Scala,并且(可能是可以预见的)花了相当多的时间研究Scala标准库中的不可变集合API.

我正在编写一个应用程序,它必须在大型集合上执行许多+/-操作.出于这个原因,我想确保我选择的实现是一个所谓的"持久"数据结构,这样我就可以避免进行写时复制.我看到马丁奥德斯基的这个答案,但它并没有真正解决我的问题.

我编写了以下测试代码来比较ListSet和HashSet的性能以进行添加操作:

import scala.collection.immutable._

object TestListSet extends App {
  var set = new ListSet[Int]
  for(i <- 0 to 100000) {
    set += i
  }
}

object TestHashSet extends App {
  var set = new HashSet[Int]
  for(i <- 0 to 100000) {
    set += i
  }
}

这是HashSet的粗略运行时测量:

$ time scala TestHashSet

real    0m0.955s
user    0m1.192s
sys     0m0.147s

和ListSet:

$ time scala TestListSet

real    0m30.516s
user    0m30.612s
sys     0m0.168s

单链表上的缺点是恒定时间操作,但这种性能看起来线性或更差.这个性能是否与需要检查集合中的每个元素以确保对象相等以符合Set的无重复不变量有关？如果是这种情况,我意识到它与"持久性"无关.

至于官方文档,我所能找到的只是以下页面,但似乎不完整:Scala 2.8 Collections API - Performance Characteristics …

如何在Python中"锁定"对象？

说我有:

class Foo:
  def __init__(self):
    self.bar = []
    self.qnx = 10

我会尽可能多地修改foo:

foo = Foo()
foo.bar.append('blah')
foo.qnx = 20

但是,当我尝试时,我希望能够"锁定"它

lock(foo)
foo.bar.append('blah')  # raises some exception.
foo.qnx = 20            # raises some exception.

这可能在Python中吗？

关于不可变状态的优点已经写了很多,但是在Scala中是否存在通常情况下更喜欢可变类？(这是来自使用可变类的"经典"OOP设计背景的人的Scala新手问题.)

对于像三维Point类这样微不足道的东西,我获得了不变性的优点.但是像Motor类这样的东西会暴露出各种控制变量和/或传感器读数呢？经验丰富的Scala开发人员通常会编写这样一个类是不可变的吗？在这种情况下,'speed'会在内部表示为'val'而不是'var',而'setSpeed'方法会返回该类的新实例吗？同样,来自描述电机内部状态的传感器的每个新读数是否会导致新的Motor实例被实例化？

使用类封装可变状态在Java或C#中执行OOP的"旧方法"似乎非常适合Motor示例.所以我很想知道,一旦你获得了使用不可变状态范例的经验,你甚至会设计像Motor这样的类是不可变的.

我正在寻求对基于价值的类的定义的一些澄清.我无法想象,最后一个要点(6)应该如何与第一个一起工作

• (1)它们是final和immutable(尽管可能包含对可变对象的引用)
• (6)它们在相等时可自由替换,这意味着在任何计算或方法调用中根据equals()交换任意两个x和y实例应该不会产生明显的行为变化.

Optional 就是这样一堂课.

Optional a = Optional.of(new ArrayList<String>());
Optional b = Optional.of(new ArrayList<String>());
assertEquals(a, b); // passes as `equals` delegated to the lists

b.get().add("a");

// now bite the last bullet
assertTrue(a.get().isEmpty()); // passes
assertTrue(b.get().isEmpty()); // throws

我读错了,还是需要更准确？

更新

伊兰的答案是有道理的(他们不再平等),但让我移动目标:

...
assertEquals(a, b); // now, they are still equal
assertEquals(m(a, b), m(a, a)); // this will throw
assertEquals(a, b); // now, they are equal, too

让我们定义一个有趣的方法m,它会做一些变异并再次撤消它:

int …

我试图了解如何实现trie等不可变性,与JS中的不变性相关.我理解应该如何进行重要的结构共享.

我的问题是你有一个图形结构,如下所示:

a -- b
     |
     c
     |
     d -- h
          |
     e -- i -- l
          |
     f -- j -- m
          |
     g -- k -- n

那么你添加一个x系统.我将尝试两种不同的方式:

a -- b
     |
     c
     |
     d -- h -- x
          |
     e -- i -- l
          |
     f -- j -- m
          |
     g -- k -- n

那个只是作为叶子节点添加的.

a -- b
     |
     c
     |
     d -- h
          |
          x
          |
     e -- i -- …