只是想知道是否有一个语法快捷方式,用于获取两个proc并加入它们,以便将一个的输出传递给另一个,相当于:
a = ->(x) { x + 1 }
b = ->(x) { x * 10 }
c = ->(x) { b.( a.( x ) ) }
有喜欢的东西时,这会派上用场method(:abc).to_proc,并:xyz.to_proc
假设我想要Text.pack与之合作Text.strip.
:t (.) 生产: (b -> c) -> (a -> b) -> a -> c
:t (Text.pack) 生产: String -> Text
:t (Text.strip) 生产: Text -> Text
因此取代strip为(b -> c)给:
b = Text
c = Text
替换pack为(a -> b)得出:
a = String
b = Text
让我们验证::t strip . pack产生:
strip . pack :: String -> Text
好吧,太棒了试试看:
strip.pack " example "
生产:
Couldn't match expected type …我有以下功能：
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 gwhereandThen像一元组合运算符一样使用。例如：
f: a -> m[b]
g: b -> m[c]
h: a -> m[c] = f andThen g
我假设andThen在像 Haskell（例如 Kliesli >=>）这样的语言中创建这样的函数是可能的。在 Scala 中，我们可以这样写：（Scala 命名中的示例，andThenE因为 …
几个月前,我读到了一个有效的方法,通过用函数组合表示它们来添加和预先将列表添加到O(1)中的其他列表,这些函数组合一旦被评估,就在O(n)中生成结果列表.
不幸的是,我不记得这篇文章的来源或(如果存在的话)这种技术/方法的名称.你有关于它的参考吗？
只是寻找解释以下组成如何工作:
(=<<) . return
哪里
(=<<) :: (a -> m b) -> m a -> m b
return :: a -> m a
(.) :: (b -> c) -> (a -> b) -> a -> c
最终类型:
GHCi> :t (=<<) . return
(=<<) . return :: Monad m => m b -> m a -> m b
我上无法掌握如何能比得上马用(A - > MB) ,即.如何将一个简单类型的返回结果应用到期望函数类型的(= <<)的第一个参数？
monads haskell type-inference function-composition reader-monad
我正在阅读Joshua Suereth写的"Scala in Depth",这本书是我为作者明确建立的能力而购买的.我在第3页,经过一堆拼写错误和不连贯的格式化(好吧,我已经容忍了这些错误)我偶然发现了以下关于解决一个非常简单的场景的功能方法的例子.
trait Cat
trait Bird
trait Catch
trait FullTummy
def catch(hunter: Cat, prey: Bird): Cat with Catch
def eat(consumer: Cat with Catch): Cat with FullTummy
val story = (catch _) andThen (eat _)
story(new Cat, new Bird)
我谨慎地举了这个例子,前提是它显然是一个蓝图(没有具体的方法被定义......)......«catch»显然是另一个错字,前提是它是一个保留字...... Cat并且Bird不可实例化......
......但是,尽管这个例子的质量很差,但我不能认为根据功能构成定义的«故事»val(andThen是"反向关联" compose)是另一个意外的错误,前提是它是这个例子的核心.
实际上,该示例不会在我的本地版本的Scala(2.10.1)上编译,并且在最新版本(2.10.2)上也没有记录.
毫无疑问它的用处和实现很容易实现(如下):
trait Function2ex[-T1, -T2, +R] extends Function2[T1, T2, R] {
def andThen[A](g: R => A): (T1, T2) => A = { (x, y) => g(apply(x, y)) } …如果我们有两个功能,f并且g,然后在Haskell h = f . g相当于h x = f(g x).即功能从右到左应用于输入.有什么根本原因可以从右到左,而不是从左到右？也就是说他们为什么不h = f . g相同h x = g(f x)呢？
编辑:正如其他人指出我的等效功能错误的方式,所以我修复了那些.
我试图通过Haskell理解函数式编程,并且我在处理函数组合时遇到了很多麻烦.
其实我有这两个功能:
add:: Integer -> Integer -> Integer
add x y = x + y
sub:: Integer -> Integer -> Integer
sub x y = x - y
我希望能够撰写它们.它没有任何意义,但这是一个学习目标.
我尝试过的:
foo:: (Integer -> Integer) -> (Integer -> Integer) -> Integer
foo = add . sub
我明白了:
Haskell使用只有一个args的函数,因此我们返回一个新函数,在每次执行函数后执行.
所以第一个Integer是param类型,而第二个是生成函数的返回类型,必须添加第二个数字.
这将返回另一个函数(sub),它将产生相同的流程(返回带有参数等的函数...)
我对吗 ？
这是我的实际错误代码:
src\Main.hs:23:7:
Couldn't match type `Integer' with `Integer -> Integer'
Expected type: Integer -> (Integer -> Integer) -> Integer
Actual type: Integer -> Integer -> …在这个问题中，我询问了Python中的函数组合运算符。@Philip Tzou提供了以下代码，它可以完成这项工作。
import functools
class Composable:
def __init__(self, func):
self.func = func
functools.update_wrapper(self, func)
def __matmul__(self, other):
return lambda *args, **kw: self.func(other.func(*args, **kw))
def __call__(self, *args, **kw):
return self.func(*args, **kw)
我添加了以下功能。
def __mul__(self, other):
return lambda *args, **kw: self.func(other.func(*args, **kw))
def __gt__(self, other):
return lambda *args, **kw: self.func(other.func(*args, **kw))
通过这些添加，我们可以使用@、*和>as 运算符来组成函数。例如，我们可以编写print((add1 @ add2)(5), (add1 * add2)(5), (add1 > add2)(5))并获取# 8 8 8. （PyCharm 抱怨布尔值不可调用(add1 > …
我想要实现的是将 2 个函数（其中一个是没有 arg 函数）合二为一。
这是一个示例，可以让您了解我在做什么：
object Test extends App {
val zeroArgFunc = () => 10
val intArgFunc = (i: Int) => s"hello $i"
val stringArgFunc = (s: String) => println(s)
// This line works perfectly fine.
val intAndThenString: Int => Unit = stringArgFunc compose intArgFunc
// But this line fails with 'type mismatch' compilation error.
val zeroAndThenInt: () => String = intArgFunc compose zeroArgFunc
}
编译错误：
[error] found : () => Int
[error] required: ? => Int
[error] …