String 在Scala中将字符串转换为运算符

如何将Scala中的字符串转换为相应的运算符？

---

给定两个整数和字符串“+”，我想要这两个整数相加的结果。

最后一个问题非常简单：

def applyOperator(x: Int, y: Int, operator: String) = operator match {
  case "+" => x + y
  case "-" => x - y
  ...
}

您可以尝试使用Twitter的Eval库或反射，但考虑到更简单的解决方案，我不推荐使用它

对于第一个问题：运算符本身不是值，因此不能“将字符串转换为运算符”。但您可以接近：将字符串转换为一个函数，该函数将添加（或减去）其参数：

def stringToOperator(operator: String): (Int, Int) => Int = operator match {
  case "+" => _ + _
  case "-" => _ - _
  ...
}

您甚至可以对其进行一点推广，使其不仅适用于整数：

def stringToOperator[A: Numeric](operator: String): (A, A) => A = operator match { ... }

---

（这同样适用于第一个答案。）

最后一个问题非常简单：

def applyOperator(x: Int, y: Int, operator: String) = operator match {
  case "+" => x + y
  case "-" => x - y
  ...
}

您可以尝试使用Twitter的Eval库或反射，但考虑到更简单的解决方案，我不推荐使用它

对于第一个问题：运算符本身不是值，因此不能“将字符串转换为运算符”。但您可以接近：将字符串转换为一个函数，该函数将添加（或减去）其参数：

def stringToOperator(operator: String): (Int, Int) => Int = operator match {
  case "+" => _ + _
  case "-" => _ - _
  ...
}

您甚至可以对其进行一点推广，使其不仅适用于整数：

def stringToOperator[A: Numeric](operator: String): (A, A) => A = operator match { ... }

（显而易见，这也适用于第一个答案。）

这一个

case class Evaluatee(v1: Int, operator: String, v2: Int)

object Evaluator {
  def raw(s: String)(v1: Int, v2: Int) = s match {
      case "+" => (v1 + v2)
      case "-" => (v1 - v2)
      case "*" => (v1 * v2)
      case "/" => (v1 / v2)
  }

  def evaluate(evaluatee: Evaluatee) =
    raw(evaluatee.operator)(evaluatee.v1, evaluatee.v2)
}

完成以下测试：

  test("1+1=2"){
    assert(Evaluator.evaluate(Evaluatee(1, "+", 1)) == 2)
  }
  test("2-1=1"){
    assert(Evaluator.evaluate(Evaluatee(2, "-", 1)) == 1)
  }
  test("1+1=2 raw"){
    assert(Evaluator.raw("+")(1,1) == 2)
  }

这个

case class Evaluatee(v1: Int, operator: String, v2: Int)

object Evaluator {
  def raw(s: String)(v1: Int, v2: Int) = s match {
      case "+" => (v1 + v2)
      case "-" => (v1 - v2)
      case "*" => (v1 * v2)
      case "/" => (v1 / v2)
  }

  def evaluate(evaluatee: Evaluatee) =
    raw(evaluatee.operator)(evaluatee.v1, evaluatee.v2)
}

完成以下测试：

  test("1+1=2"){
    assert(Evaluator.evaluate(Evaluatee(1, "+", 1)) == 2)
  }
  test("2-1=1"){
    assert(Evaluator.evaluate(Evaluatee(2, "-", 1)) == 1)
  }
  test("1+1=2 raw"){
    assert(Evaluator.raw("+")(1,1) == 2)
  }

---

我们不能只做像

1“+”2

这样的事情，因为我认为scala能够创建自己的

DSL

的最大特点是

apply

方法，但我不能只调用它而不使用任何东西，我很确定我们总是需要使用

（）

或

{/code>例如
列表（1）
我们不能做
列表1
，但我们可以
列表{1}

但是试试这个也许对你有用

case class NumOp (num1:Int){
        def apply(op:String)(num2:Int):Int = {
                        op match {
                                case "+" => num1+num2
                                case "-" => num1-num2
                                case _ => 0
                        }
        }
}

object ConvertsNumOp{
        implicit def convert(a:Int):NumOp= NumOp(a)
}


import ConvertsNumOp._

scala> 2 ("-") (1)
res0: Int = 1

scala> 4 ("-") (2)
res1: Int = 2

scala> 4 ("+") (2)
res2: Int = 6
scala> 4 ("-") (2) ("+") (1) ("-") (8)
res0: Int = -5

你可以动态地做一些事情，这样也许可以工作

编辑：

这是另一个版本的
NumOp
可能是最干净的

case class NumOp(num1:Int) {
        def apply(op:String):Int => Int = {
                        op match {
                                case "+" => num1.+_
                                case "-" => num1.-_
                                case _ =>  throw new NotImplementedError("Operator not implemented")
                        }
        }
}

动态地使用它

val numList = List(1,2,3,4,5,6,7,8,9,10);
val optList = List("+","-");
var retVal = for{ a <- numList; op <- optList } 
                      yield (a)(op)(a)

val numList=List（1,2,3,4,5,6,7,8,9,10）；
val optList=List（“+”，“-”）；
var retVal=对于{a我们不能只做像
1“+”2
这样的事情，因为我认为scala能够创建自己的
DSL
的最大特点是
apply
方法，但我不能只调用它，我非常确定我们总是需要使用
（）
或
{/code>例如
列表（1）
我们不能做
列表1
，但我们可以
列表{1}

但是试试这个也许对你有用

case class NumOp (num1:Int){
        def apply(op:String)(num2:Int):Int = {
                        op match {
                                case "+" => num1+num2
                                case "-" => num1-num2
                                case _ => 0
                        }
        }
}

object ConvertsNumOp{
        implicit def convert(a:Int):NumOp= NumOp(a)
}


import ConvertsNumOp._

scala> 2 ("-") (1)
res0: Int = 1

scala> 4 ("-") (2)
res1: Int = 2

scala> 4 ("+") (2)
res2: Int = 6
scala> 4 ("-") (2) ("+") (1) ("-") (8)
res0: Int = -5

你可以动态地做一些事情，这样也许可以工作

编辑：

这是另一个版本的
NumOp
可能是最干净的

case class NumOp(num1:Int) {
        def apply(op:String):Int => Int = {
                        op match {
                                case "+" => num1.+_
                                case "-" => num1.-_
                                case _ =>  throw new NotImplementedError("Operator not implemented")
                        }
        }
}

动态地使用它

val numList = List(1,2,3,4,5,6,7,8,9,10);
val optList = List("+","-");
var retVal = for{ a <- numList; op <- optList } 
                      yield (a)(op)(a)

val numList=List（1,2,3,4,5,6,7,8,9,10）；
val optList=List（“+”，“-”）；
var retVal=对于{a，请你为第一个代码添加一些解释。孤独代码什么都没有说。我对答案进行了一点扩展。请你为第一个代码添加一些解释。孤独代码什么都没有说。我对答案进行了一点扩展。