标签: function-composition

我想创建一个函数apply,它接受一个具有任意数量参数的函数以及一个整数列表,并返回函数的结果(其中列表中的每个整数按顺序是一个参数.

我想的是:

apply :: ([Int] -> Int) -> [Int] -> Int
apply f x:xs = apply (f x) xs
apply f [] = f

但我知道这不会起作用,因为类型签名是错误的 - 函数不会获取整数列表,它只需要一些int参数.

另外,当我到达基本情况时,apply的f参数实际上应该是一个整数,无论​​如何都违反了类型签名.

有谁知道如何处理这类问题？

我有一个元组列表,我需要通过添加两个元素来扩展它,每个元素来自一个列表.所以我有[(1, 2, 3)]两个迭代器it1 = (i for i in ['a1', 'a2'])和it2 = (i for i in in ['b1', 'b2']).结果应该是[(1, 2, 3, 'a1', 'b1'), (1, 2, 3, 'a1', 'b2'), (1, 2, 3, 'a2', 'b1'), (1, 2, 3, 'a2', 'b2')].

如果我使用上面显示的迭代器它不起作用.但是,如果我使用列表它是有效的.这是代码:

def get_iters():
    return ((i for i in ['a1', 'a2']), (i for i in ['b1', 'b2']))

def get_lists():
    return ([i for i in ['a1', 'a2']], [i for i in ['b1', 'b2']])

def compose(lst_of_tuples, iter=True):
    iters …

我可能会问一些非常愚蠢的事情,答案可能非常简单,因为"实施者选择了那种方式",但我在这里.

要添加两个数字,我们可以使用任何样式:(10+) 4或10 + 4或(10 + 4).

而如果我们有两个功能,说add10和multiply5 并撰写他们做出一个功能出来,说add10andMultiply5 则
add10.mul5 10似乎给了一个错误,而
add10.mul5 $ 5将工作,
(add10.mul5) 5将工作,
add10andMultiply5 5也可以工作.

任何评论为什么第一个不应该工作？请赐教.谢谢.

我正在尝试做的一个非常简单的例子:我知道可以写:

let myFunc = anotherFunc

代替

let myFunc = fun x -> anotherFunc x

我有两个函数fDate1,fDate2 - 都是DateTime - > bool.我需要构造一个函数,它接受一个日期并验证fDate1,fDate2是否返回true.现在我发明了以下表达式:

let myDateFunc = fun x -> (fDate1 x) || (fDate2 x)

有没有更好的方法来做这些(例如使用'>>'或高阶功能)？

也许这是一个经常被问到的问题,但我没有找到答案.

monad的绑定定义如下:

(>>=)  :: m a -> (a -> m b) -> m b

目前我正在这样做:

foo :: Int
foo = sum $ ((*11) . (+2)) `map` [1..4]

我想实现这样的语法,因为我认为它更具可读性:

[1..4] >>= (+2) >>= (*11) >>= sum

我不知道合适的运营商而不是>>=.

此外:foo是198.

这很有效

unique :: (a -> Bool) -> [a] -> Bool
unique p xs = 1 == length (filter p xs)

但现在我想要它的形式:

unique = (== 1) . length . filter

错误信息:

Couldn't match expected type `[a] -> Bool' with actual type `Bool'
Expected type: b0 -> [a] -> Bool
  Actual type: b0 -> Bool
In the first argument of `(.)', namely `(== 1)'
In the expression: (== 1) . length . filter

为什么这不起作用？

我正在为一个接受输入的对象编写测试,将一些函数组合在一起,通过组合函数运行输入,并返回结果.

这是一组极为简化的对象和函数,反映了我的设计:

type Result =
| Success of string

let internal add5 x = x + 5

let internal mapResult number =
    Success (number.ToString())

type public InteropGuy internal (add, map) = 
    member this.Add5AndMap number =
        number |> (add >> map)

type InteropGuyFactory() =
    member this.CreateInteropGuy () =
        new InteropGuy(add5, mapResult)

该类被设计用于C#interop,它解释了结构,但是这个问题仍然适用于组成函数参数的任何测试函数.

在测试编写功能时,我无法找到一种优雅的方法来保持内部函数的实现细节不会进入测试条件,或者换句话说,隔离链中的一个链接而不是在输入后检查输出完全通过管道输送.如果我只是检查输出,那么每个函数的测试将依赖于下游函数正常工作,如果链末端的函数停止工作,则所有测试都将失败.我能做的最好的事情是将函数存根以返回某个值,然后将其下游函数存根,存储下游函数的输入,然后断言存储的值等于存根函数的输出:

[<TestClass>]
type InteropGuyTests() = 

    [<TestMethod>]
    member this.``Add5AndMap passes add5 result into map function``() = 

        let add5 _ = 13

        let tempResult = ref 0
        let mapResult result = …

我在功能构成和类型方面遇到了一些麻烦.我想撰写filter(返回一个列表)len,其中列表作为参数(技术上是一个,Foldable但我在这里简化).查看类型一切都如预期:

> :t length
length :: Foldable t => t a -> Int

> :t filter
filter :: (a -> Bool) -> [a] -> [a]

所以现在我期待的类型(len . filter)是

(length . filter) :: (a -> Bool) -> [a] -> Int

而实际上是

> :t (length . filter)
(length . filter) :: Foldable ((->) [a]) => (a -> Bool) -> Int

所以我似乎失去了一些论点.是否Foldable以某种方式包含在要求中我不理解？

请注意,如果我进行部分应用,一切都按预期工作:

> let myFilter = filter odd
> :t myFilter
myFilter …

我想创建一个函数链,它将是一个管道/流/组合函数的输入.

如果没有将类型的字面扩展到选定的深度,这是否可能,这通常是处理？见lodash的流程.

我想实现链中数据流的类型检查. - 函数的参数是前一个的结果 - 第一个参数是模板参数 - 最后一个返回是模板参数

type Chain<In, Out, Tmp1 = any, Tmp2 = any> = [] | [(arg: In) => Out] | [(arg: In) => Tmp1, (i: Tmp1) => Tmp2, ...Chain<Tmp2, Out>];

这个想法在草案中.

然而,这会产生以下错误:

1. Type alias 'Chain' circularly references itself. (明白为什么,不知道怎么解决)
2. A rest element type must be an array type. (可能传播不适用于通用元组)
3. Type 'Chain' is not generic. (甚至不理解为什么这个错误甚至在这里)

这是ChainTypecript 中可能的定义吗？如果是这样,请附上一个片段.

(测试最新的tsc 3.1.6)

我正在尝试用于理解来构造对象调用，这是我的简单实现：

object FuncA extends (String => Int => String) {
    override def apply(str: String): Int => String = i => {
      s"${(str.toInt + i).toString}"
    }
  }

  object FuncB extends (String => Int) {
    override def apply(str: String): Int = {
      str.toInt
    }
  }

  for {
    funcAStr <- FuncA("1")(1)
    funcBStr <- FuncB(funcAStr) // Fails here
  } yield {
    println(s"Final String incremented as int is $funcBStr")
  }

但是奇怪的是，我有一个问题，其中funcAStr被解释为Char而不是String。任何理想的原因是什么？