标签: mutable

这会产生一个不可变的字符串对象:

NSString* myStringA = @"A";  //CORRECTED FROM: NSMutableString* myStringA = @"A";

这会产生一个可变的字符串对象:

NSMutableString* myStringB = [NSMutableString stringWithString:@"B"];

但是这两个对象都被报告为同一种对象,"NSCFString":

NSLog(@"myStringA is type: %@, myStringB is type: %@", 
[myStringA class], [myStringB class]);

那么什么是在内部区分这些对象,以及如何测试它,以便我可以轻松地确定一个神秘的字符串变量是不可变的还是可变的,然后再做一些邪恶的事情呢？

这个问题是关于Data.Vector包裹的.

鉴于一旦更新单元格,我将永远不会使用某个单元格的旧值.更新操作是否总是创建一个新的向量,反映更新,还是作为就地更新完成？

注意:我知道 Data.Vector.Mutable

我正在努力解决如何在Haskell中进行有状态计算的一般问题.例如,下面的简单算法可以在Python的生成器工具的帮助下表示为有状态但"懒惰"的计算,只执行到达下一个yield语句所需的步骤,然后将控制流返回给调用者,直到请求下一个元素为止:

def solveLP(vmax0, elems):
    elem_true_ixs = [ [ ei for ei, b in enumerate(row) if b ] for row in elems ]

    return go(vmax0, elem_true_ixs)

def go(vmax, mms):
    if not mms:
        yield []

    else:
        for ei in mms[0]:
            maxcnt = vmax[ei]

            if not maxcnt > 0:
                continue

            vmax[ei] = maxcnt-1 # modify vmax vector in-place
            for es in go(vmax, mms[1:]):
                # note: inefficient vector-concat operation
                # but not relevant for this question
                yield [ei]+es
            vmax[ei] = maxcnt   # …

我一直在研究如何组合一个数据,这些数据将由多个线程访问,同时为线程安全提供锁定.我想我已经达到了这样一个程度,即我认为不可能在保持常态的同时做到这一点.

以下面的类为例:

template <typename TType, typename TMutex>
class basic_lockable_type
{

public:
    typedef TMutex lock_type;

public:
    template <typename... TArgs>
    explicit basic_lockable_type(TArgs&&... args)
        : TType(std::forward<TArgs...>(args)...) {}

    TType& data() { return data_; }
    const TType& data() const { return data_; }

    void lock() { mutex_.lock(); }
    void unlock() { mutex_.unlock(); }

private:
    TType           data_;
    mutable TMutex  mutex_;

};

typedef basic_lockable_type<std::vector<int>, std::mutex> vector_with_lock;

在这里我尝试将数据和锁定结合起来,标记mutex_为mutable.不幸的是,这是我看不到的,因为在使用时,vector_with_lock必须将其标记为mutable从一个const不完全正确的函数(data_应该mutable来自const)执行读操作.

void print_values() const
{
    std::lock_guard<vector_with_lock> lock(values_); …

我有一个递归函数,我试图@tailrec通过内部递归part(countR3)向队列添加元素(agenda是a scala.collections.mutable.Queue).我的想法是将功能的外部部分放在议程上并总结结果.

注意:这是一个家庭作业问题,因此我不想发布整个代码; 然而,使实现尾递归不是功课的一部分.

以下是与我的问题相关的代码部分:

import scala.collection.mutable.Queue

val agenda: Queue[Tuple2[Int, List[Int]]] = Queue()

@tailrec
def countR3(y: Int, x: List[Int]): Int = {
  if (y == 0) 1
  else if (x.isEmpty) 0
  else if …
  else {
    agenda.enqueue((y - x.head, x))
    countR3(y, x.tail)
  }
}
?
agenda.enqueue((4, List(1, 2)))
val count = agenda.foldLeft(0) {
  (count, pair) => {
    val mohr = countR3(pair._1, pair._2)
    println("count=" + count + " countR3=" + …

我想知道Java中的String数组是否可变？我知道字符串是不可变的,但字符串数组怎么样？

如果我有一个字符串数组,并更改内容,是否会创建一个新的字符串对象？或者实际值是否会改变？

提前致谢

我正在实现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类型声明中？

我试图在Spark中定义UserDefinedAggregateFunction(UDAF),它计算组的列中每个唯一值的出现次数.

这是一个例子:假设我有一个df这样的数据帧,

+----+----+
|col1|col2|
+----+----+
|   a|  a1|
|   a|  a1|
|   a|  a2|
|   b|  b1|
|   b|  b2|
|   b|  b3|
|   b|  b1|
|   b|  b1|
+----+----+

我将有一个UDAF DistinctValues

val func = new DistinctValues

然后我将它应用于数据帧df

val agg_value = df.groupBy("col1").agg(func(col("col2")).as("DV"))

我期待有这样的事情:

+----+--------------------------+
|col1|DV                        |
+----+--------------------------+
|   a|  Map(a1->2, a2->1)       |
|   b|  Map(b1->3, b2->1, b3->1)|
+----+--------------------------+

所以我推出了像这样的UDAF,

import org.apache.spark.sql.expressions.MutableAggregationBuffer
import org.apache.spark.sql.expressions.UserDefinedAggregateFunction
import org.apache.spark.sql.Row
import org.apache.spark.sql.types.StructType
import org.apache.spark.sql.types.StructField
import org.apache.spark.sql.types.DataType
import org.apache.spark.sql.types.ArrayType
import org.apache.spark.sql.types.StringType
import org.apache.spark.sql.types.MapType
import …

这编译:

[]{};

这也是:

[]() mutable {};

但是使用这段代码,编译器会向我抛出错误消息:

[] mutable {};
   ^~~~~~~
error: lambda requires '()' before 'mutable'

有什么特别的理由吗？

当我遇到这个有趣的场景时,我正在玩Rust关闭:

fn main() {
    let mut y = 10;

    let f = || &mut y;

    f();
}

这给出了一个错误:

error[E0495]: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
 --> src/main.rs:4:16
  |
4 |     let f = || &mut y;
  |                ^^^^^^
  |
note: first, the lifetime cannot outlive the lifetime  as defined on the body at 4:13...
 --> src/main.rs:4:13
  |
4 |     let f = || &mut y;
  |             ^^^^^^^^^
note: ...so that closure can access `y` …