Kotlin编写函数列表

目前我正在使用一个名为arrow的库中的compose，它是这样定义的

inline infix fun <IP, R, P1> ((IP) -> R).compose(crossinline f: (P1) -> IP): (P1) -> R = { p1: P1 -> this(f(p1)) }

---

我只是想得到同样的结果，我应该有一个函数列表而不是这样写。

我发现很难想象一个简单的组合应该如何与具有如此不同签名的方法一起工作。所以首先我们必须调整函数的类型。如果第一个函数的返回类型与第二个函数的参数匹配，则可以使用Arrow编写函数

inline infix fun <IP, R, P1> ((IP) -> R).compose(crossinline f: (P1) -> IP): (P1) -> R = { p1: P1 -> this(f(p1)) }

另一个问题是

isOdd

是一个

谓词。它不是在转换一个值

如果变压器具有兼容的签名，您可以使用例如
和

下面是一个将类型与函数组合在一起的版本。请注意，
filter
和
map
是arrow的
选项
中的特殊函数，允许您传递转换器函数/谓词

import arrow.core.Option
import arrow.core.andThen
import org.hamcrest.Matchers.`is`
import org.junit.Assert.assertThat
import org.junit.Test

class ComposeTest {

    @Test
    fun shouldCompose() {
        val add5 = { i: Int -> i + 5 }
        val multiplyBy2 = { i: Int -> i * 2 }
        val isOdd = { x: Int -> x % 2 != 0 }

        val composed: (Int) -> Option<Int> = { i: Int -> Option.just(i)
          .filter(isOdd)
          .map(add5.andThen(multiplyBy2))
        }

        assertThat(composed(3), `is`(Option.just(16)))
        assertThat(composed(4), `is`(Option.empty()))
    }
}

导入arrow.core.Option
导入arrow.core.and然后
导入org.hamcrest.Matchers.`is`
导入org.junit.Assert.assertThat
导入org.junit.Test
类组件测试{
@试验
有趣的应该写作{
val add5={i:Int->i+5}
val multiplyBy2={i:Int->i*2}
val isOdd={x:Int->x%2！=0}
val组合：（Int）->Option={i:Int->Option.just（i）
.过滤器（isOdd）
.map（添加5.第1个（倍数y2））
}
资产（由（3）组成，`is`（Option.just（16）））
assertThat（由（4）组成，`is`（Option.empty（））
}
}
我发现很难想象一个简单的组合应该如何与具有如此不同签名的方法一起工作。所以首先我们必须调整函数的类型。如果第一个函数的返回类型与第二个函数的参数匹配，则可以使用Arrow编写函数

另一个问题是
isOdd
是一个
谓词。它不是在转换一个值

如果变压器具有兼容的签名，您可以使用例如
和

下面是一个将类型与函数组合在一起的版本。请注意，
filter
和
map
是arrow的
选项
中的特殊函数，允许您传递转换器函数/谓词

import arrow.core.Option
import arrow.core.andThen
import org.hamcrest.Matchers.`is`
import org.junit.Assert.assertThat
import org.junit.Test

class ComposeTest {

    @Test
    fun shouldCompose() {
        val add5 = { i: Int -> i + 5 }
        val multiplyBy2 = { i: Int -> i * 2 }
        val isOdd = { x: Int -> x % 2 != 0 }

        val composed: (Int) -> Option<Int> = { i: Int -> Option.just(i)
          .filter(isOdd)
          .map(add5.andThen(multiplyBy2))
        }

        assertThat(composed(3), `is`(Option.just(16)))
        assertThat(composed(4), `is`(Option.empty()))
    }
}

导入arrow.core.Option
导入arrow.core.and然后
导入org.hamcrest.Matchers.`is`
导入org.junit.Assert.assertThat
导入org.junit.Test
类组件测试{
@试验
有趣的应该写作{
val add5={i:Int->i+5}
val multiplyBy2={i:Int->i*2}
val isOdd={x:Int->x%2！=0}
val组合：（Int）->Option={i:Int->Option.just（i）
.过滤器（isOdd）
.map（添加5.第1个（倍数y2））
}
资产（由（3）组成，`is`（Option.just（16）））
assertThat（由（4）组成，`is`（Option.empty（））
}
}
换句话说，您认为不可能在kotlin中组合具有不同签名的函数列表？我无法想象这应该如何工作-至少在没有关于如何将一种类型转换为另一种类型的逻辑的情况下是这样。谓词是完全不同的-它们过滤而不是转换-因此它们需要不同的组合（过滤与映射）谓词正在从值转换为布尔值，对吗？你是对的-我的论证至少部分错误。我的观点是，在编写函数时，签名需要兼容。对于
和
，第一个函数的输出需要是第二个函数的输入。但当然，compose是以另一种方式工作的，因此，
val composite=isOdd compose add5 compose multiplyy2
实际上可以工作。我也弄错了-我以为@Bads只想计算奇数-但实际上，他想知道结果是否是奇数…换句话说，你不认为在kotlin中用不同的签名组合函数列表是可能的吗？我无法想象这应该如何工作——至少在没有关于如何将一种类型转换为另一种类型的逻辑的情况下是如此。谓词是完全不同的-它们过滤而不是转换-因此它们需要不同的组合（过滤与映射）谓词正在从值转换为布尔值，对吗？你是对的-我的论证至少部分错误。我的观点是，在编写函数时，签名需要兼容。对于
和
，第一个函数的输出需要是第二个函数的输入。但当然，compose是以另一种方式工作的，因此，
val composite=isOdd compose add5 compose multiplyy2
实际上可以工作。我也弄错了-我以为@Bads只想计算奇数-但实际上，他想知道结果是否是奇数。。。
import arrow.core.Option
import arrow.core.andThen
import org.hamcrest.Matchers.`is`
import org.junit.Assert.assertThat
import org.junit.Test

class ComposeTest {

    @Test
    fun shouldCompose() {
        val add5 = { i: Int -> i + 5 }
        val multiplyBy2 = { i: Int -> i * 2 }
        val isOdd = { x: Int -> x % 2 != 0 }

        val composed: (Int) -> Option<Int> = { i: Int -> Option.just(i)
          .filter(isOdd)
          .map(add5.andThen(multiplyBy2))
        }

        assertThat(composed(3), `is`(Option.just(16)))
        assertThat(composed(4), `is`(Option.empty()))
    }
}