Scala使用'byname'参数和非''name'参数进行curry
Scala是一种多范式编程语言，它结合了面向对象编程和函数式编程的特性。在Scala中，可以使用'byname'参数和非'byname'参数进行curry（柯里化）。
柯里化是一种函数转换技术，它将接受多个参数的函数转换为一系列只接受一个参数的函数。在Scala中，可以使用'byname'参数和非'byname'参数来实现柯里化。
'byname'参数是一种延迟求值的参数，它会在每次调用时重新计算。它的语法形式是将参数类型用'=> T'表示，其中T是参数的类型。通过使用'byname'参数，可以实现在每次调用时都重新计算参数的效果。
非'byname'参数是一种普通的参数，它在函数调用时会立即求值。非'byname'参数的语法形式是将参数类型直接写在参数列表中。
使用'byname'参数和非'byname'参数进行curry可以提供更大的灵活性和可复用性。通过柯里化，可以将一个接受多个参数的函数转换为一系列只接受一个参数的函数，这样可以更方便地进行函数组合和重用。
Scala中的柯里化示例代码如下：
def add(x: Int)(y: => Int): Int = x + y
val add2 = add(2) _ // 部分应用，返回一个只接受一个参数的函数
val result = add2(3) // 调用柯里化后的函数
println(result) // 输出结果为5在上面的示例中，函数add接受一个非'byname'参数x和一个'byname'参数y。通过将add函数部分应用，我们得到了一个只接受一个参数的函数add2。最后，我们调用add2函数并输出结果。
Scala中的柯里化可以应用于各种场景，例如函数组合、参数复用和代码重用等。它可以提高代码的可读性和可维护性。
腾讯云提供了一系列与Scala开发相关的产品和服务，例如云服务器、云数据库、云存储等。您可以通过访问腾讯云官方网站（https://cloud.tencent.com/）了解更多关于这些产品的详细信息和使用指南。
相关·内容
我可以：
scala> def foo( f: => String) = println(f)
foo: (f: => String)Unit
我可以：
scala> def foo( f: String*) = f.map(println)
foo: (f: String*)Seq[Unit]
但我不能：
scala> def foo( f: =>String* ) = f.map(println)
<console>:1: error: ')' expected but identifier found.
def
浏览 6提问于2013-05-01得票数 2
回答已采纳
考虑以下函数：
import java.util.concurrent.Callable;
def callable[T]( operation: =>T) : Callable[T] = {
new Callable[T] {
def call : T = operation
}
}
在REPL中，此代码执行我想要的操作：
scala> val myCallable = callable {
| println("Side effect!");
| "Hi!"
| }
myCallable: java
浏览 0提问于2013-03-26得票数 2
我是一个Scala程序员，学习Haskell和"Haskell编程从首要原则“，使我在Scala中使用的功能概念更加一致。
我非常理解赛跑的概念。在Scala中很好地实现了它。
然而，我不理解提交人所提供的仓促和取消仓促的实施：
curry f a b = f (a, b)
:t curry
-- curry :: ((t1, t2) -> t) -> t1 -> t2 -> t
:t fst
-- fst :: (a, b) -> a
:t curry fst
-- curry fst :: t -> b -> t
uncurr
浏览 5提问于2021-01-03得票数 9
回答已采纳
我正在尝试模拟一个接受按名称调用参数的方法调用：
import org.scalatest.WordSpec
import org.scalatest.mock.MockitoSugar
import org.mockito.Mockito._
import org.junit.runner.RunWith
import org.scalatest.junit.JUnitRunner
trait Collaborator {
def doSomething(t: => Thing)
}
trait Thing
@RunWith(classOf[JUnitRunner])
cl
浏览 87提问于2010-01-28得票数 23
回答已采纳
1回答
我在Scala中使用JRebel，我经常遇到需要重启服务器的情况，因为如果超类发生了变化，JRebel将无法加载类。这主要是在我更改匿名函数时完成的，因为我可以从JRebel错误描述中推断出来：
Class 'mypackage.NewBook$$anonfun$2' superclass was changed from 'scala.runtime.AbstractFunction1' to 'scala.runtime.AbstractFunction2' and could not be reloaded。
有没有办法，我如何设计我的代码
浏览 0提问于2010-12-29得票数 1
回答已采纳
2回答
Scala 函数编程的作者在scala中定义了curry：
def curry[A,B,C](f: (A, B) => C): A => (B => C) =
a => b => f(a, b)
但是，如果我们将其应用于参数类型的函数，例如：
def isSorted[A](as: Array[A], ordered:(A,A)=>Boolean) =
if(as.size < 2)
true else
as.zip(as.drop(1)).map(ordered.tupled).reduce(_
浏览 4提问于2016-03-19得票数 0
回答已采纳
所有人:我是scala的新手。我不太理解"functional programming in scala“一书中关于curry的一个例子。为什么像a，b这样没有变量的函数可以顺利编译和运行？
def curry[A,B,C](f: (A, B) => C): A => (B => C) =
a => b => f(a, b)
浏览 7提问于2017-02-06得票数 0
回答已采纳
我试图进行研究，但仍然没有弄清楚Scala的术语是什么，与下面的代码中的小写a，b有关。
def curry[A, B, C](f: (A, B) => C): A => (B => C) = a => b => f(a, b)
为什么a，b出现在右手边？
我知道它是代数数据类型的一部分，但仍然找不到匹配的定义。
更新基于的答案，"Scala从返回类型A => (B => C)中知道a和b的类型。a是A类型，b是B类型。“
我想问一下Scala如何知道a和b的类型，即:背后的机制？这是什么术语？
我想这是一种语言特征。当阅读这些复杂的代码时，请
浏览 8提问于2021-07-16得票数 1
回答已采纳
2回答
在Scala中，你可以在应用或正常顺序评估之间进行选择，参见“”中的示例。
def byName(a: => Unit) = {
for (i <- 0 until 10) {println(a)}
}
def byValue(a: Unit) = {
for (i <- 0 until 10) {println(a)}
}
var i = 1;
byValue(i = i + 1)
println(i); // 2
byName(i = i + 1)
println(i) // 12
这在F#中也是可能的吗？
浏览 0提问于2013-03-28得票数 4
1回答
作为Scala中函数编程的一个练习，我们必须创建一个currifies函数。我无法创建这个，所以我寻找了解决方案：
def curry[A,B,C](f: (A, B) => C): A => (B => C) =
a => b => f(a, b)
我看了它，已经可以玩一点，但我不完全理解它。
你能给我详细解释一下吗？小变量a和b从何而来？=>在a => b中的含义是什么？
浏览 3提问于2016-07-01得票数 1
回答已采纳
4回答
我正在阅读Scala中的函数式编程，并经历了不同的练习。我遇到了赛跑。
有人能给我解释一下这个急促的功能以及它是如何工作的吗？我似乎能理解这段代码。与我在不同博客上看到的关于在Scala中运行的内容相比。
def curry[A,B,C](f: (A, B) => C): A => (B => C) = a => b => f(a,b)
a来自=> b => f(a，b)是一个函数吗?如果是的话，它的参数是什么？
另外，更新这是什么意思？a in a => b => f(a,b)意味着什么？函数是否将返回接受单个参数并返回函数的名为b的函
浏览 4提问于2014-12-10得票数 1
回答已采纳
我的作为一个副本关闭了，所以我再试一次。我也读过，我的要求是不同的。我感兴趣的是学习Call-by-Name: => Type与() => Type的不同之处的内部实现。
我的困惑来自于查看javap和反汇编，这在这两种情况下没有区别。
例如ParamTest.scala
object ParamTest {
def bar(x: Int, y: => Int) : Int = if (x > 0) y else 10
def baz(x: Int, f: () => Int) : Int = if (x > 0) f() else 20
}
jav
浏览 3提问于2016-10-25得票数 11
回答已采纳
1回答
我明白如何在实践中使用匆匆的功能。
def plainSum(a: Int)(b: Int) = a + b
val plusOne = plainSum(1) _
其中plusOne是一个(Int) => Int类型的匆匆函数，可以应用于Int
plusOne(10)
res0: Int = 11
独立地阅读由Chiusano和Bjarnason编写的用Scala编写的函数式编程(第2章)时，它演示了将两个参数的函数f转换为一个参数的函数的实现可以用以下方式编写：
def curry[A, B, C](f: (A, B) => C): A => (B => C) =
浏览 0提问于2018-08-12得票数 0
回答已采纳
3回答
以下Scala代码适用于我：
def curry(s1: String)(s2: String): String = (s1 + " " + s2).toUpperCase
val uncurry = Function.uncurried(curry _)
println(uncurry("short", "pants"))
但是，以下代码没有：
def cat(s1: String, s2: String): String = (s1 + " " + s2).toUpperCase
def curry = Functio
浏览 3提问于2014-10-16得票数 0
回答已采纳
与它的表亲Haskell不同，它允许您为一个函数提供多个值：
foo 1 2 = 3
foo 1 2 = 4
它还做了 (或其他一些搜索)来探索这种非决定论的含义。
这使得它类似于Prolog (特别是由于类型系统和语法而导致的 )，在那里您将声明
foo 1 2 3.
foo 1 2 4.
语义上，N元Curry函数和N+1元Prolog关系有什么区别吗？
浏览 3提问于2020-12-17得票数 2
回答已采纳
1回答
我正在试图找出如何排序一个向量的城市对象。每个对象都有一个cityName成员和一个cityCode成员。我希望访问器函数自动对向量进行排序，然后以正确的排序顺序在屏幕上显示它。我想我已经接近了，但是谁能告诉我我做错了什么？非常感谢。
//specification file for the City class
#ifndef CITY_H
#define CITY_H
#include <string>
using namespace std;
class City
{
protected:
string cityName;
string cityCode
浏览 0提问于2014-04-08得票数 0
回答已采纳
1回答
我是Scala的新手，我刚开始学习它，现在尝试一些练习。尤其是这个，我很难理解。
我理解(f: (A, B) => C)部分，但其他部分我不太明白。有人能解释一下在匿名功能部分之后发生了什么吗？
谢谢!
这是一项功能：
def curry[A, B, C](f: (A, B) => C): A => (B => C) = a => b => f(a, b)
浏览 0提问于2019-07-18得票数 1
回答已采纳
在Scala (2.9.2)中，我尝试创建一个函数，该函数在访问时提供一些其他值
() => Any
我认为我已经成功地通过一个按名称/ currying的解决方案做到了这一点：
def byName(theValue : => Any)() : Any = theValue
val myHolder = byName(myValue)_
所以我的夹子是正确的类型。但是，我发现在创建这个curried函数的过程中，会计算by name参数。如果我执行以下操作，它将按预期工作：
def byName(theValue : => Any) : Any = () => the
浏览 0提问于2012-11-06得票数 11
回答已采纳
这个问题可能类似于，但我的问题是有更多的特性。
我有以下表格的清单
let studentsList = [{
name:'A',
rollNo:1,
mark:10
},
{
name:'B',
rollNo:2,
mark:30
},
{
name:'C',
rollNo:3,
mark:40
},
{
name:'A&#
浏览 0提问于2019-03-14得票数 0
回答已采纳
1回答
我一直在努力处理以下Scala代码
def curry[A,B,C,U](m: Map[(A,B,C),U], a: A): Map[(B,C),U] = m.collect { case ((aa,b,c),v) if aa == a => (b,c) -> v }
def curry[A,B,C,U](m: Map[(A,B,C),U], b: B): Map[(A,C),U] = m.collect { case ((a,bb,c),v) if bb == b => (a,c) -> v }
我无法编译这一点，因为在Erasure之后，这两个函数都是相同的，而且我
浏览 1提问于2020-02-17得票数 0
回答已采纳
2回答
实现功能运行的最惯用的方法是什么？
例如：在Haskell：
times a b = a * b
-- This can then be used uncurried:
times 2 3 -- Result is 6
-- But there is also auto-currying:
(times 2) 3 -- This works too
在朱莉娅，一些内置支持这一点：
<(8, 7) # Result is false
<(8)(7) # Same
7 |> <(8) # Same
但是，用户定义的函数并不会自动具有以下功能：
ti
浏览 10提问于2022-10-28得票数 2
回答已采纳
2回答
我编写了一个类，它使用Dapper在两个数据库之间同步一个表。类中的公共和私有方法是泛型的，泛型参数是正在同步的POCO类。
var Sync = new syncClass(localConn, remoteConn);
await Sync.SyncTable();
我觉得一个小故事会有帮助：
为了简单起见，我想将所有的同步都封装在一个可序列化的事务中(推拉)，这样如果有什么问题，我可以回滚。
接下来，我希望同步多个表，并试图找到一种适当的方法来管理多个表。使用者可以写多行：
await Sync.StartTransaction();
await Sync.SyncTable();
..
浏览 0提问于2021-02-16得票数 4
在创建了名为ScalaIDE的test.WsTemp工作表之后，我编写了下面的代码，并收到了特性Enum中一行的三个错误
scala.math.Ordering[U]类型的发散隐式展开--从性状LowPriorityOrderingImplicits中有序的方法开始
没有为Ordering定义隐式U
方法排序的参数不足：(implicit ord: scala.math.Ordering[U])List[U]，未指定的值参数ord。
为什么这不能工作，因为很明显，Val扩展了Ordered[Val]
object WsTemp {
trait Val extends O
浏览 2提问于2013-02-24得票数 3
回答已采纳
1回答
所以我做了一个关于Haskell的测试，其中一个问题是：
让函数成为
lolo g x = ys
where ys = [x] ++ filter (curry g x) ys
然后确定名为lolo的函数的类型。选项包括：
a) (a,b) -> Bool -> b -> [(a,b)]
b) (b -> b -> b) -> Bool -> [b]
c) ((b,b) -> Bool) -> b -> [b]
d) (a -> b -> Bool) -> b -> [c]
有人能解释一下是哪一个吗
浏览 3提问于2014-04-28得票数 1
我有一个似乎是错误的假设。我过去的“主要”语言是C++，而在C++中，我可以像这样用伪语言进行函数参数绑定：
// declaration
void f(int param1, int param2);
// usage
func<void, int> boundfunc = bind(f, 1, _1)
func(2) // equivalent to f(1, 2)
有趣的一点是，如果我用函数调用替换boundfunc定义中的boundfunc，那么该函数调用将在绑定站点调用，而不是对func的调用。
因此，当我试图巩固在我的头脑中运行的概念时，我将它与C++中的绑定进行比较
浏览 4提问于2011-03-14得票数 1
回答已采纳
给定以下Scala代码：
object test {
def byval(a: Int) = println("Int")
def byval(a: Long) = println("Long")
def byname(a: => Int) = println("=> Int")
def byname(a: => Long) = println("=> Long")
def main(args: Array[String]) {
byval(5)
bynam
浏览 6提问于2010-12-01得票数 9
回答已采纳
2回答
我们正在使用.NET核心来构建Web。我们需要支持"GetBy“功能，例如GetByName、GetByType等，但是我们遇到的问题是如何以Restful的方式通过路由来描述这个问题，以及方法重载，而我们认为这些路由应该如何正确地工作。我们使用的是MongoDB，所以我们的ID是字符串。
我想我们的路线应该是这样的：
/api/templates?id=1
/api/templates?name=ScienceProject
/api/templates?type=Project
问题是控制器中的所有方法都有一个字符串参数，并且没有正确地映射。我的路线应该有所不同吗?还是有办法将这些
浏览 5提问于2017-10-11得票数 2
回答已采纳
在发现之后，我正在尝试获得一个部分应用的函数，它需要隐式参数。
这样做似乎是不可能的。如果没有，你能给我解释一下为什么吗？
scala> def sum(a: Int)(implicit b: Int): Int = { a+b }
sum: (a: Int)(implicit b: Int)Int
scala> sum(3)(4)
res12: Int = 7
scala> val partFunc2 = sum _
<console>:8: error: could not find implicit value for parameter b: Int
浏览 0提问于2012-06-04得票数 7
回答已采纳
3回答
为了记录这一点，我发现Scala中的函数没有被自动修改，这是非常恼人的。我正在尝试编写一个工厂，它接受任何函数并返回一个咖喱版本：
def curry(fn:(_ => _)) = (fn _).curried
基本上，我在这里定义的是一个函数curry，它以一个函数fn作为参数，它的类型是_ => _，并返回函数fn的匆匆版本。很明显，这不起作用是因为Java。
这就是我所犯的错误：
error: _ must follow method; cannot follow fn.type
def curry(fn:(_ => _)) = (fn _).currie
浏览 3提问于2016-06-24得票数 3
这可能属于“你不能，而且无论如何也没有理由这样做”，但我很好奇这是否可能。至少，这可能会是一个有趣的R字谜。
我一直在考虑让cat总是附加\n。但是，编写cat的目的是(通过...)粘贴与给定的参数一样多的参数。
令人惊讶的是，这是可行的：
> library(functional)
> catnip <- Curry( cat, "\n" )
> catnip("hi")
hi
但是，\n会在用户输入文本之前结束。有没有办法对函数进行curry，使您指定curried参数始终结束...参数？
浏览 1提问于2012-06-28得票数 8
回答已采纳
2回答
我有以下两个函数，用scala编写：
def f: (Int,Int) => Int = (x,y) => x+y
def g: Int=>Int=>Int=x=>y=>x+y
现在我想写一个函数，把函数f，取一个参数，变成一个函数g，带两个参数。
除了定义之外，我找不到解决这个问题的办法
curry: ((Int, Int) => Int) => (Int => Int => Int):
有什么建议吗？
浏览 3提问于2014-07-16得票数 1
回答已采纳
我正在记录一个公共API，它有一个名为/findGuild的方法，该方法接受强制的key参数和以下参数之一：
byPlayer
byName
它必须有byPlayer或byName；我的问题是:如何表明byPlayer和是相互排斥的，但其中一个是强制性的？
现在，这个资源的.apib中有以下内容：
### GET /findGuild{?byName,byPlayer,key}
+ Parameters
+ byName: `YourGuild` (string, optional) - Search for the Guild by its name.
+ byP
浏览 1提问于2016-01-31得票数 1
回答已采纳
我在思考如何使用varargs编写一个方法，我意识到我甚至没有直觉来判断如何去做。理想情况下，它可以让您在任何时候开始使用它，然后以iterable结束它。
def concat(strs: String*) = strs.mkString
val curriedConcat = concat.curry
curriedConcat("OK")("hello", "world")("welcome")(Seq(): _*)
在scala中支持这一点吗？除了将它绑定到一个长度为N的函数，然后再进行curry，我不知道如何做更多的
浏览 0提问于2012-12-08得票数 5
回答已采纳
我可以按照XML配置中的类型和名称以下列方式自动生成
<bean name="employee1" class="com.Class1" autowire="byName">
<bean name="employee2" class="com.Class2" autowire="byType">
但是，我如何在Java配置中完成同样的任务呢？我的意思是，Java等同于autowire="byName“和autowire="byType”属性吗？
@Config
浏览 0提问于2018-11-20得票数 0
在Ruby 的Proc.curry方法的文档中，它说：
咖喱-> a_proc
咖喱(原味) -> a_proc
返回一个咖喱过程。如果给出了可选性参数，它将确定参数的数量。仓促的程序会收到一些争论。如果提供了足够数量的参数，则将提供的参数传递给原始proc并返回结果。否则，返回另一个获取其余参数的匆匆过程。
我知道arity是指函数的参数数。但是，我不太清楚它是如何工作的。有人能帮我解释一下吗？我读过关于这个文档的例子，但仍然很困惑。
浏览 1提问于2018-12-04得票数 4
回答已采纳
1回答
引言
我有个密码：
import React, { Component } from 'react';
import { View, Button } from 'react-native';
export default function App() {
const myMethod = (name) => {
console.log(`Hello ${name}!`);
};
return (
<View>
<Button onPress={() => myMethod("Vi
浏览 9提问于2022-03-08得票数 2
回答已采纳
我是个新手，只是为了熟悉它而玩弄它。我正在尝试执行一个翻转的函数，但我得到了一个TypeError。 使用相同的“unflipped”函数可以按预期工作。 const curriedMap = _.curry(_.map);
const squares1 = curriedMap([ 1, 2, 3, 4 ]);
console.log(squares1(x => x * x)); // [ 1, 4, 9, 16 ]
const flippedMap = _.flip(_.map);
console.log(flippedMap(x => x * x, [1, 2, 3
浏览 23提问于2019-05-05得票数 2
1回答
(如何)你能写一元函数吗？
、、、、
我的职能如下：
f: a -> m[b]
g: (b,c) -> m[d]
h: (a,c) -> m[d]
如何将h表示为f和g的组合
使用do/for符号，我们可以很容易地实现h，如下所示：
h: (a,c) => {
for {
b <- f(a)
d <- g(b,c)
} yield (d)
}
但是，我很好奇我们是否可以这样表达它：h = f andThen g，其中andThen被用作一元合成运算符。例如：
f: a -> m[b]
g: b -> m[c]
h: a -> m[c] = f andThen g
我
浏览 8提问于2021-05-14得票数 7
回答已采纳
如何使用自由类型变量为表达式赋值，就像我将其他函数f赋值为val =f：?？
我有过
fun curry f x y = f (x,y);
val dummy = fn (x,y) => {a=x,b=y} (* or anything with free type *)
val dummCd = fn x=> fn y=> {a=x,b=y}
我以为‘咖喱假人’会像‘假镉’一样工作，但是，
dummCd
val it = fn: 'a -> 'b -> {a: 'a, b: 'b}
和
curry dummy:
浏览 5提问于2020-03-07得票数 1
回答已采纳
1回答
我有一个dataframe，其中一列包含公司名称( dataframe大约有50列)。例如 Name
byname_tt
standing_re
mystandying_tz
mouse_x
mousepad_db 我正在尝试创建另一个列，其中包含与选中的名称相似的名称列表。来比较我用的名字fuzzywuzzy。 def check_name(name):
check = df.apply(lambda row: ((fuzz.partial_ratio(row['Name'], name)) >= 50), axis=1)
return [df.Nam
浏览 39提问于2021-08-20得票数 0
回答已采纳
我一直在Haskell中学习跑步，现在我尝试用currying形式编写函数的Haskell类型签名，它的未缓存形式有一个参数对类型(x，y)，其结果是x类型的值。我认为正确的方法是f :: (y,x) -> x，但我不确定。这是正确的，如果不是，为什么？
浏览 2提问于2021-09-22得票数 3
回答已采纳
function reduceAncestors(person, f, defaultValue) {
function valueFor(person) {
if (person == null)
return defaultValue;
else
return f(person, valueFor(byName[person.mother]),
valueFor(byName[person.father]));
}
return valueFor(person);
浏览 0提问于2014-08-05得票数 4
Spring3.0为兼容java 5添加了很多特性。现在很多方法都是参数化的。例如，HibernateTemplate.executeXXX()、HibernateTemplate.getXXX()、HibernateTemplate.mergeXXX()返回T，HibernateTemplate.loadAll()返回List<T>。
但是findXXX()方法返回普通的List，所以我必须将其转换为类似List<MyEntity>的类型。
有人知道原因是什么吗？为什么find方法不是参数化的？或者可能还有其他参数化的API？
这就是我正在做的事情。
这是spring
浏览 2提问于2010-11-17得票数 3
回答已采纳
1回答
我试图为以下函数编写类型：
const curry = (
f, arr = []
) => (...args) => (
a => a.length >= f.length ?
f(...a) :
curry(f, a)
)([...arr, ...args]);
我发现为curry创建了一个类型，如下所示：
type Head<T extends any[]> =
T extends [any, ...any[]]
? T[0]
: never;
type Tail<T extends any[]> =
浏览 2提问于2020-02-18得票数 1
回答已采纳
作为Haskell的初学者，我对最佳实践很好奇。特别是，在没有其他要求的情况下，使用元组关联相关的函数参数还是保持它们“裸”更好？
例如。
vector :: Float -> Float -> Float -> Vector
与
vector :: (Float, Float, Float) -> Vector
我问的原因是，有时参数的某些方面(例如2D或3D点或矢量中的x坐标)通常与其他参数(例如y&z坐标)绑定在一起。我可以看到如何在这两种情况下使用模式匹配，但我很想知道使用元组或不同参数是否会有严重的影响。
当涉及到其他参数时，元组的使用似乎清楚地表明，
浏览 1提问于2020-05-25得票数 2
2回答
问:你将如何使这一工作？
加(2)(5)；// 7
加(2，5)；// 7
我正试图解决上述问题:我知道第一种解决方案使用的是赛跑，将按以下方式实现：
var add = functoin(x){
return function (y){
return x+y;
};
};
第二个是jsut您的正常功能：
var add = functoin(x,y){
return x+y;
};
有办法使两者同时工作吗？
浏览 2提问于2017-02-05得票数 4
回答已采纳
1回答
我正在学习Scala，并有以下玩具代码：
object M {
def isSorted[X](xs: Array[X], compare: (X, X) => Boolean): Boolean =
xs.dropRight(1).zip(xs.drop(1)).forall(Function.tupled(compare))
def curry[A,B,C](f: (A, B) => C) : A => (B => C) =
(a) => (b) => f(a, b)
}
我的目标是把它叫做：
M.curry(M.isSorte
浏览 2提问于2015-02-08得票数 2
回答已采纳
我在和“伟大的.”作斗争示例来自于雄辩的JS中的高阶函数一章。我不明白其中一个函数是如何从仅包含祖先数据的对象创建值的。以下是功能：
function reduceAncestors(person, f, defaultValue) {
function valueFor(person) {
if (person == null)
return defaultValue;
else
return f(person, valueFor(byName[person.mother]),
value
浏览 2提问于2014-12-08得票数 2
回答已采纳
我想在PHP中使用：
$x = function ($a, $b) {
echo $a . ' ' . $b;
};
for ($i= 0;$i< 10;$i++) {
$y = bind($x, $i)// how?
$y($i);
}
浏览 2提问于2011-11-04得票数 1
回答已采纳
Groovy有一个概念，它称之为“currying”。下面是他们的wiki的一个例子：
def divide = { a, b -> a / b }
def halver = divide.rcurry(2)
assert halver(8) == 4
我对这里所发生的事情的理解是，divide的右参数被绑定到值2，这似乎是一种部分应用的形式。
术语currying通常用于将接受一系列参数的函数转换为只接受一个参数并返回另一个函数的函数。例如，下面是Haskell中curry函数的类型：
curry :: ((a, b) -> c) -> (a -> (b ->
浏览 0提问于2012-06-14得票数 15
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
