标签: function-composition

1. 有谁可以举出功能组成的例子？

2. 这是函数组合运算符的定义？

   (.) :: (b -> c) -> (a -> b) -> a -> c
   f . g = \x -> f (g x)
   

   Run Code Online (Sandbox Code Playgroud)

这表明它需要两个函数并返回一个函数,但我记得有人用英语表达了逻辑

男孩是人 - >阿里是男孩 - >阿里是人

1. 这个逻辑与功能组成有什么关系？
2. 功能应用和组合的强绑定是什么意思,哪一个比另一个更强大的绑定？

请帮忙.

谢谢.

我试图用类型(Floating a) => a -> a -> a的函数组成一个类型的函数(Floating a) => a -> a来获得类型的函数(Floating a) => a -> a -> a.我有以下代码:

test1 :: (Floating a) => a -> a -> a
test1 x y = x

test2 :: (Floating a) => a -> a
test2 x = x

testBoth :: (Floating a) => a -> a -> a
testBoth = test2 . test1
--testBoth x y = test2 (test1 x y)

但是,当我在GHCI中编译它时,我收到以下错误:

/path/test.hs:8:11:
    Could not …

我在这里阅读,我注意到,例如,如果我有以下函数定义:

a :: Integer->Integer->Integer
b :: Integer->Bool

以下表达式无效:

(b . a) 2 3

组合的功能必须只有一个参数,这很奇怪.

这个限制是因为在Haskell中定义最通用的一个问题还是有其他原因？

我是Haskell的新手,所以我问的也许是无用的问题.

是否有更好的方式来表达(\(a, b) -> a < b)功能组合？我觉得我错过了一些东西,curry只是试着让我更加困惑.

作为Haskell的新手,我无法理解为什么表达式 head . words “one two three four”抛出异常并且函数组合head . words必须与$运算符一起应用- 右侧的表达式不需要进一步评估,因为它只是一个单独的String.编译它的另一种方法是放入head . words括号但是(head . words) :: String -> String具有相同的类型,head . words :: String -> String为什么将它放在括号中使表达式编译？

我想写一个Haskell函数,它返回一个附加到自身计数次数的列表(比如lst * count在Python中).

我的第一次尝试是:

self_append_n :: Int -> [a] -> [a]
self_append_n = concat . replicate

我的理由是replicate接受一个计数和一个值,并产生一个值列表.当值本身就是一个列表时,剩下的就是将列表连接在一起.但是,这给出了一个令人困惑的错误:

Couldn't match type `[a0]' with `[a] -> [a]'
Expected type: [[a0]] -> [a] -> [a]
  Actual type: [[a0]] -> [a0]
In the first argument of `(.)', namely `concat'
In the expression: concat . replicate
In an equation for `self_append_n':
    self_append_n = concat . replicate

然后我写了一个有点版本:

self_append_n a b = concat $ replicate a b

它的工作原理!

为什么无点编译无法编译,但添加点可以使它工作？

在Edward Kmett的演讲中,Lenses,Folds和Traversals,在幻灯片"The Power is the Dot"中,他展示的(.) . (.) . (.)是

(a -> b) -> (c -> d -> e -> a) -> c -> d -> e -> b

我可以通过在GHCI中显示它的类型来看到它.但我也想知道原因.我想了解的另一件事是为什么有在从参数中经常换着花样(.)来(.) . (.)和(.) . (.) . (.):

(.)             :: (a -> b) -> (c ->           a) -> c ->           b
(.) . (.)       :: (a -> b) -> (c -> d ->      a) -> c -> d ->      b
(.) . …

注意:这是作者删除的另一个问题的重新发布.这是原始问题:

我comp在Javascript中有这个polyvariadic 函数,并且想知道Haskell中是否有类似的实现是可能的.我最感兴趣comp的是:

const comp = f => Object.assign(
  g => comp([g].concat(f)),
  {run: x => f.reduce((acc, h) => h(acc), x)}
);

const inc = n => n + 1;
const sqr = n => n * n;
const repeatStr = s => n => Array(n + 1).join(s);

comp(repeatStr("*")) (inc) (sqr).run(2); // "*****"

comp(repeatStr("*"))
  (inc)
  (inc)
  (inc)
  (inc)
  (inc).run(0); // "*****"

comp构建一个异构数组,通常在Haskell中没有类型.我想这样的可变函数在其返回类型中必须是多态的.但是,到目前为止,这项任务超出了我的Haskell知识.任何线索都会有所帮助.

上下文

我使用Javascript运行时类型检查器,以便我可以comp以类型安全的方式在内部构建数组.它需要显式类型注释,并且仅支持参数和秩-2多态.

有一个默认的方法andThen()在BiFunction接口(java.util.function包).

default <V> BiFunction<T,U,V> andThen(Function<? super R,? extends V> after)

文件说:

返回首先将此函数应用于其输入的组合函数,然后将after函数应用于结果.如果对任一函数的求值抛出异常,则将其转发给组合函数的调用者.

理解解释的含义并不容易让人困惑.根据我的理解,andThen()调用默认方法时会返回一个组合函数.在类型上调用此组合函数,T并U返回该类型V.最后,有after关于类型R和调用的函数和函数V.

这种方法有什么需要？它如何真正适合图片？

Python 的标准库非常庞大，我的直觉告诉我其中一定有一种方法可以实现这一点，但我就是想不出来。这纯粹是出于好奇和学习目的：

我有两个简单的功能：

def increment(x):
    return x + 1

def double(x):
    return x * 2

我想将它们组合成一个新函数double_and_increment。我当然可以简单地这样做：

double_and_increment = lambda x: increment(double(x))

但我也可以用更复杂但也许更“符合人体工程学可扩展”的方式来做到这一点：

import functools

double_and_increment = functools.partial(functools.reduce, lambda acc, f: f(acc), [double, increment])

上面两个都工作得很好：

double_and_increment = lambda x: increment(double(x))

现在的问题是，标准库中是否有工具可以在没有任何用户定义的 lambda、常规函数或类的情况下实现组合。

第一个直觉是将调用lambda acc, f: f(acc)中的定义替换为，但不幸的是，这会以相反的顺序获取参数：functools.reduceoperator.call

>>> (lambda acc, f: f(acc))(1, str)  # What we want to replace.
>>> '1'
>>> import operator
>>> operator.call(str, 1)  # Incorrect argument order.
>>> '1'

我有一种预感，使用functools.reduce …