标签: idioms

我有一个数组数组,如下所示:

fruits_and_calories = [
  ["apple", 100],
  ["banana", 200],
  ["kumquat", 225],
  ["orange", 90]
]

我还有一个我想在数组的每个元素上调用的方法:

fruits_and_calories.each do |f| eat(f[0], f[1])

我真的希望能说出类似的话:

fruits_and_calories.each do |f| eat(f[:name], f[:calories])

有没有办法可以在不必更改数组中的每个项目的情况下将其拉出来(例如,通过迭代它并以某种方式添加符号)？或者,如果这太难了,还有更好的选择吗？

我遇到了在C++中按值删除元素的问题的答案:

C++按值而不是按位置擦除向量元素？

基本上:

vec.erase(std::remove(vec.begin(), vec.end(), valueToRemove), vec.end());

答案是有道理的,但这不是坏风格吗？逻辑由双重否定组成......有更清洁的方法吗？

我有一个引用方法的变量,我用eval关键字调用该方法

a_test = "myvariable"
eval a_test


def myvariable
(...)
end

我想将一个变量传递给方法,例如

def myvariable(var1)
(...)
end

是否有人熟悉任何"成语"的方式来实现这一目标.做点什么

eval a_test "string_test" 

自然会失败,因为解释器将对名为"a_test"的函数进行查找

可能重复:
使用先前的非NA值在向量中填充NA？

是否有一种惯用的方法可以在R向量中"向下"复制单元格值？通过"复制",我的意思是用最接近的先前非NA值替换NA.

虽然我可以使用for循环非常简单地执行此操作,但它运行速度非常慢.关于如何矢量化的任何建议将不胜感激.

# Test code
# Set up test data
len <- 1000000
data <- rep(c(1, rep(NA, 9)), len %/% 10) * rep(1:(len %/% 10), each=10)
head(data, n=25)
tail(data, n=25)

# Time naive method
system.time({
  data.clean <- data;
  for (i in 2:length(data.clean)){
    if(is.na(data.clean[i])) data.clean[i] <- data.clean[i-1]
  }
})

# Print results
head(data.clean, n=25)
tail(data.clean, n=25)

试运行结果:

> # Set up test data
> len <- 1000000
> data <- rep(c(1, rep(NA, 9)), len %/% 10) * rep(1:(len %/% …

我的任务是处理zip文件中的文件.所以我写了一堆独立的函数并组合它们以获得所需的结果.这是一种做事方式.现在不是把它全部写成函数,而是将它们中的一些写成具有选择性接收和所有的过程,而且每件事都很酷.但是后来进一步思考这个问题,我想,我们是否需要功能呢？我不能将所有这些功能替换或转换为与自身和其他进程通信的进程吗？所以我怀疑.何时使用功能以及何时使用流程？从使用功能(如缓存)的性能角度来看,是否有任何优势？进程中的代码块是否同样缓存？

那么在我们的例子中,什么是标准的习惯用法？下面的当前伪代码.

start() ->
  FL = extract("..path"),
  FPids = lists:map(open_file, FL), %  get file Pids,
  lists:foreach(fun(FPid) ->
                  CPid = spawn_compute_process(),
                  rpc(CPid,{compute,FPid}) 
                end, FPids).

compute() ->
  receive
    {Pid,{..}} ->
      Line = read_line(..),
      TL = tidy_line(Line), % an independent function. But couldn't it be a guard within this process?
    ..
  end.

extract(FilePath) -> FilesList.

read_line(FPid) -> line.  

那么你如何编写代码呢？比如,首先编写较小的独立函数,然后将它们包装在进程中？
谢谢.

我在一个我正在研究的S​​cheme解释器中找到了下面的类型别名.在评估AST时,它将功能识别为本机支持的功能或用户定义的功能.我理解Enum定义的第二部分,但第一部分使我无法理解.

pub enum Function {
    Native(ValueOperation),
    Scheme(Vec<String>, Vec<Value>, Rc<RefCell<Environment>>),
}


type ValueOperation = fn(&[Value], Rc<RefCell<Environment>>) -> Result<Value, RuntimeError>;

这种类型的别名如何工作？这个定义是否说a ValueOperation只是函数签名的简写？我无法在官方文档/书籍中找到任何关于这个成语的提及.

为函数签名定义类型别名的目的是什么？你能用它"做什么"？它是某种函数指针吗？

我希望使用 Java 中经常使用的相当标准的 while 循环习惯用法来查找文本文件的最后一行。

我有一个不太紧凑的版本可以工作。但我想使用的语法在 Kotlin 中似乎不是有效的语法。我的首选方法包括在同一行中进行作业和Boolean对该作业的测试。

诚然，这是一个小问题，但我希望更好地实现我的 Kotlin 代码。

fun readLastLine(file:File):String {
    val bufferedReader = file.bufferedReader()
    var lastLine=""

    //valid
    var current = bufferedReader.readLine()
    while(current != null) {
        lastLine=current
        current = bufferedReader.readLine()
    }
    //return lastLine

    //not valid...
    //while((current=bufferedReader.readLine())!=null){
    //    lastLine=current
    //}

   //responding to comment below, 
   //preferred/terse answer using file.readLines
   //this reads all the lines into a list, then returns the last
   return file.readLines().last()
}

假设有一个模板类template <class T> myclass;。

是否有惯用的方法允许将非const T对象转换为的对象const T？

基本上，我希望以下转换隐式发生：

void f(myclass<const int> x);

myclass<int> a;
f(a); // should compile

重要编辑：

答案似乎很琐碎（问题很愚蠢），但是涉及到一些概念上的问题（至少对我而言）。

I was under the impression that I need to conditionally enable a conversion operator because a conversion operator from myclass<const T> to myclass<const T> doesn't make any sense, i.e. I need to declare the conversion operator if and only if T was const qualified. I was expecting the compiler to complain about a redundant conversion …

我正在查看一些反编译代码并看到.getClass();，即没有对其返回值进行任何处理。

  public String forLocale(Locale locale, String keyword) {
    Stream var10000 = getLocaleMappingList(locale, this.getSupportedLocales());
    Map var10001 = this.translations;
    var10001.getClass();
    Map<String, String> translation = (Map)var10000.map(var10001::get).filter((m) -> {
      return m.containsKey(keyword);
    }).findFirst().orElse(this.translations.get(FALLBACK));
    Preconditions.checkState(translation.containsKey(keyword), keyword + " is not a valid translation key");
    return (String)translation.get(keyword);
  }

那是做什么用的？原来的代码是这样的吗？（到目前为止，我还没有看到反编译代码的实例至少在行方面与源代码不匹配。）

这有点像一个断言，但是通过这样做而不是让事情出错，可以实现var10001::get什么？或者更多的是关于性能？

更新

这是字节码。很酷的事情来学习如何做！

 // access flags 0x1
  public forLocale(Ljava/util/Locale;Ljava/lang/String;)Ljava/lang/String;
   L0
    LINENUMBER 184 L0
    ALOAD 1
    ALOAD 0
    INVOKEVIRTUAL com/spotify/i18n/Translations.getSupportedLocales ()Ljava/util/Set;
    INVOKESTATIC com/spotify/i18n/Translations.getLocaleMappingList (Ljava/util/Locale;Ljava/util/Collection;)Ljava/util/stream/Stream;
    ALOAD 0
    GETFIELD com/spotify/i18n/Translations.translations : Ljava/util/Map;
    DUP …