小编use*_*285的帖子

我听说R是一种功能编程语言，因此我决定尝试将其用于统计计算。我熟悉Scala和F＃中的函数式编程范例，在每种语言中，都有一个名为“模式匹配”的简洁功能，您可以在其中执行以下操作：

object Matcher extends App {

  class A
  class B extends A
  class C extends A

  class D(one: A, two: A) {

    def work {
      (one, two) match {
        case (o: B, t: B) => println("B")
        case (o: B, t: C) => println("C")
        case _ =>
      }
    }
  }

  val d1 = new D(new B, new B)
  val d2 = new D(new B, new C)

  d1.work
  //B
  d2.work
  //C
}

我想知道R是否具有这样的功能。Scala和F＃中的模式匹配会变得更加复杂，并进行类型检查，元组检查，条件检查等等。但是，每当我搜索“ R中的模式匹配”时，我得到的都是正则表达式类型的结果。R是一种功能语言，没有此功能，还是我只是不知道它的名字？

抱歉，这是个愚蠢的问题，但我不得不问这个。我有一个运行数十亿次计算的程序，我正在努力让它运行得更快。在我的程序中，我声明了很多用于中间计算的变量。例如，在伪代码中：

public bool FunctionThatGetsCalledInMain(manyparameters)
{
    for (int i = 0; i < 10000000; i++)
    {
        int x = bigFunctionThatReturnsAnInt(i,manyparameters)
        double y = bigFunctionThatReturnsADouble(i,manyparameters)
        string z = bigFunctionThatReturnsAString(i,manyparameters)

        bool b = someFunctionOfXYZ(x,y,z)
    }
}

我想知道是否可以通过执行以下操作来提高性能：

public bool FunctionThatGetsCalledInMain(manyparameters)
{
    for (int i = 0; i < 10000000; i++)
    {
        bool b = someFunctionOfXYZ(bigFunctionThatReturnsAnInt(i,manyparameters),bigFunctionThatReturnsADouble(i,manyparameters),bigFunctionThatReturnsAString(i,manyparameters))
    }
}

我知道这看起来很可怕，我的直觉告诉我这并不重要，但我只是想看看其他人是否同意。

我有一个带掩码的错误代码的枚举,带有字符串表示和二进制int表示:

type ErrorCodes = 
    | NoError = 0
    | InvalidInputError = 1
    | AuthenticationFailedError = 2
    | InvalidArgumentError = 4
    | ItemNotFoundError = 8
    | UnknownError = 16

当我浏览程序时,我使用按位OR运算符(|||)收集所有错误.所以现在我有一些看起来像01100的东西.如何打印到控制台:"InvalidArgumentError"和"ItemNotFoundError？"

我只想使用:

for i = 0 to 32 do
    if ((err.GetHashCode() % 2) = 1) then
        Console.WriteLine("ErrorCode: {0}",err.GetHashCode())

但现在我仍然坚持如何打印实际的字符串

F#元组和结构之间有什么根本区别.它们都可以容纳多个变量,但我只想知道何时使用另一个变量.

更具体地说,我试图通过一堆函数传递一堆参数,每次都会累积一个新变量.例如,我从param1开始并将其传递给返回的func1(param1,param2).然后将这个元组(或结构)传递给func2,它返回(param1,param2,param3),依此类推.

我目前的想法是这样的:有一个元组,我总是可以持有适量的参数,但是我放弃了数据的统一格式,最后,我必须打包并重新打包一个大约10个元素的元组.使用结构,我有参数一致性的优点,但问题是,我必须在开头指定参数null.

有没有一种简单的方法将char []转换为F#中的字符串而不显式循环数组？我试过了:

let char_arr = [|'a','b','c'|]
let str = new String(char_arr)

但这不起作用.建议？

我希望有一个类型A,它有一个属性是类型B的实例.类型B有一个类型为A的实例的属性.问题是,F#按顺序读取源文件.因此,如果我首先定义类型A,那么它将无法识别类型B.如果我首先定义类型B,我不能使它具有A的实例.有没有解决方法,或者这只是糟糕的设计对我而言？

我在C#中要求一个项目,但我认为这个问题也适用于其他语言.我听说大量的对象创建和破坏会导致大量的开销和性能问题.我想知道我是否可以通过简单地使用结构而不是对象来解决这个问题.

我有两个data.table像这样:

tests

id | test | score
=================
 1 |    1 |    90
 1 |    2 |   100
 2 |    1 |    70
 2 |    2 |    80
 3 |    1 |   100
 3 |    2 |    95

cheaters

id | test | score
=================
 1 |    2 |   100
 3 |    1 |   100
 3 |    2 |    95

假设我现在想在all_scores中包含一个布尔列来判断该特定测试是否被欺骗,因此输出将如下所示:

tests

id | test | score | cheat
=========================
 1 |    1 |    90 | FALSE
 1 …

说我有这样的地图:

val m: Map[Int, String] = Map(1 -> "a", 2 -> "b", 3 -> "c", 4 -> "d", ...)

假设我有一个功能:def f(i: Int): String我想要应用于这张地图的按键.然后,我希望按结果f(键)进行分组,并连接属于同一f(键)组的所有字符串(值).

在普通scala(无火花)中映射键时,是否有一种有效的方法来"groupByKey".

说我有以下代码:

val a: List[(Int, String)] = List((1,"A"),(2,"B"),(3,"C"))
val b: List[String] = List("A","C","E")

我可以:

a.map{case (fst,snd) => (fst,snd + "a")}
a.filter{case (_,snd) => b.contains(snd)}

但为什么我不能这样做:

a.map((_._1,_._2 + "a"))
a.filter(b.contains(_._2))

有没有办法用下划线表示法完成此操作,还是我被迫在这里？