Kotlin：传递并使用一个2参数函数？

我试图学习Kotlin中的函数式编程，但很难使此代码正常工作：

import java.util.*

fun caseName(br: String, c: Int): String {
  if (c == 0) {
    return br.toLowerCase()
    } else {
    return br.toUpperCase()
    }
}
fun mapIt(ns: ArrayList<String>, f: (String, Int) -> String): List<String> {
  val coll: List<String> = ns.map {it -> f(it, _)}
  return coll
}

fun main(args: Array<String>) {
  val names = arrayListOf("Joe", "Bill", "Murrary")
  val cased = mapIt(names, (::caseName)(_, 0))
  println(cased.first())
}

---

这里有几个问题：

您的目标在这里是矛盾的-您希望

mapIt

采用2-arg函数，但看起来您还试图执行

caseName

的部分应用程序，这当然会产生1-arg函数

下划线不符合您在Kotlin中的想法（看起来您可能来自Scala背景？）

看起来你想要这样的东西：

// f is a *single*-arg function
fun mapIt(ns: ArrayList<String>, f: (String) -> String): List<String> {
    return ns.map(f)
}

fun main(args: Array<String>) {
    val names = arrayListOf("Joe", "Bill", "Murrary")
    val cased = mapIt(names, { caseName(it, 0) })  // Partial application
    println(cased.first())
}

// f is a two-arg function
fun mapIt(ns: ArrayList<String>, f: (String, Int) -> String): List<String> {
    return ns.map { f(it, 0) }
}

fun main(args: Array<String>) {
    val names = arrayListOf("Joe", "Bill", "Murrary")
    val cased = mapIt(names, ::caseName)
    println(cased.first())
}

//f是一个*single*-arg函数
funmapit（ns:ArrayList，f：（String）->String）：列表{
返回ns.map（f）
}
趣味主线（args:Array）{
val names=arrayListOf（“乔”、“比尔”、“默里”）
val cased=mapIt（名称，{caseName（it，0）}）//部分应用程序
println（cased.first（））
}

或者像这样：

// f is a *single*-arg function
fun mapIt(ns: ArrayList<String>, f: (String) -> String): List<String> {
    return ns.map(f)
}

fun main(args: Array<String>) {
    val names = arrayListOf("Joe", "Bill", "Murrary")
    val cased = mapIt(names, { caseName(it, 0) })  // Partial application
    println(cased.first())
}

// f is a two-arg function
fun mapIt(ns: ArrayList<String>, f: (String, Int) -> String): List<String> {
    return ns.map { f(it, 0) }
}

fun main(args: Array<String>) {
    val names = arrayListOf("Joe", "Bill", "Murrary")
    val cased = mapIt(names, ::caseName)
    println(cased.first())
}

//f是一个双参数函数
funmapit（ns:ArrayList，f:（String，Int）->String）：列表{
返回ns.map{f（it，0）}
}
趣味主线（args:Array）{
val names=arrayListOf（“乔”、“比尔”、“默里”）
val cased=mapIt（名称：：：caseName）
println（cased.first（））
}

这里有几个问题：

您的目标在这里是矛盾的-您希望

mapIt

采用2-arg函数，但看起来您还试图执行

caseName

的部分应用程序，这当然会产生1-arg函数

下划线不符合您在Kotlin中的想法（看起来您可能来自Scala背景？）

看起来你想要这样的东西：

// f is a *single*-arg function
fun mapIt(ns: ArrayList<String>, f: (String) -> String): List<String> {
    return ns.map(f)
}

fun main(args: Array<String>) {
    val names = arrayListOf("Joe", "Bill", "Murrary")
    val cased = mapIt(names, { caseName(it, 0) })  // Partial application
    println(cased.first())
}

// f is a two-arg function
fun mapIt(ns: ArrayList<String>, f: (String, Int) -> String): List<String> {
    return ns.map { f(it, 0) }
}

fun main(args: Array<String>) {
    val names = arrayListOf("Joe", "Bill", "Murrary")
    val cased = mapIt(names, ::caseName)
    println(cased.first())
}

//f是一个*single*-arg函数
funmapit（ns:ArrayList，f：（String）->String）：列表{
返回ns.map（f）
}
趣味主线（args:Array）{
val names=arrayListOf（“乔”、“比尔”、“默里”）
val cased=mapIt（名称，{caseName（it，0）}）//部分应用程序
println（cased.first（））
}

或者像这样：

// f is a *single*-arg function
fun mapIt(ns: ArrayList<String>, f: (String) -> String): List<String> {
    return ns.map(f)
}

fun main(args: Array<String>) {
    val names = arrayListOf("Joe", "Bill", "Murrary")
    val cased = mapIt(names, { caseName(it, 0) })  // Partial application
    println(cased.first())
}

// f is a two-arg function
fun mapIt(ns: ArrayList<String>, f: (String, Int) -> String): List<String> {
    return ns.map { f(it, 0) }
}

fun main(args: Array<String>) {
    val names = arrayListOf("Joe", "Bill", "Murrary")
    val cased = mapIt(names, ::caseName)
    println(cased.first())
}

//f是一个双参数函数
funmapit（ns:ArrayList，f:（String，Int）->String）：列表{
返回ns.map{f（it，0）}
}
趣味主线（args:Array）{
val names=arrayListOf（“乔”、“比尔”、“默里”）
val cased=mapIt（名称：：：caseName）
println（cased.first（））
}

您的原始代码（借款人代码）实际上非常接近成功，因此我将忽略您的werid简化版本。你只错了一句话：

val c = Borrower.findBorrower("borrower3", brs1, {Borrower.Companion::getName(it, 0)})
                                                                    ^^
                                                        Why you are using double colon?

最后一个参数是lambda表达式，在lambda中使用函数引用毫无意义，即使在scala中也是如此。只要用普通点就可以了

val c = Borrower.findBorrower("borrower3", brs1, {Borrower.Companion.getName(it, 0)})

由于可以仅使用主要类型的名称来调用伴随对象的成员，因此可以将其进一步简化为

val c = Borrower.findBorrower("borrower3", brs1, {Borrower.getName(it, 0)})

您的原始代码（借用者one）实际上非常接近成功，因此我将忽略您的werid简化版本。你只错了一句话：

val c = Borrower.findBorrower("borrower3", brs1, {Borrower.Companion::getName(it, 0)})
                                                                    ^^
                                                        Why you are using double colon?

最后一个参数是lambda表达式，在lambda中使用函数引用毫无意义，即使在scala中也是如此。只要用普通点就可以了

val c = Borrower.findBorrower("borrower3", brs1, {Borrower.Companion.getName(it, 0)})

由于可以仅使用主要类型的名称来调用伴随对象的成员，因此可以将其进一步简化为

val c = Borrower.findBorrower("borrower3", brs1, {Borrower.getName(it, 0)})

---

谢谢你的帮助。是的，我确实有一些Scala的经验，但在这里用下划线来描述我知识中的漏洞！我在寻找单个arg函数，并看到了我思维中的错误——错过了部分应用程序。你介意看看我的编辑吗？它启发了我开始时的简化示例？我相信有一个伴生物体的问题？谢谢你，谢谢你的帮助。是的，我确实有一些Scala的经验，但在这里用下划线来描述我知识中的漏洞！我在寻找单个arg函数，并看到了我思维中的错误——错过了部分应用程序。你介意看看我的编辑吗？它启发了我开始时的简化示例？我相信有一个伴生物体的问题？谢谢。我用了“：”因为我想我得打个电话。谢谢你们两位的帮助。我在用“：”因为我想我得打个电话。谢谢你们两位的帮助。