标签: partial-application

在为部分函数创建String映射时,我遇到了意外行为.当我创建一个部分函数作为地图元素时,它工作正常.当我分配给val时,它会调用.尝试调用检查会生成错误.这是预期的吗？我在做一些蠢事吗？注释掉check()以查看调用.我正在使用scala 2.7.7

def PartialFunctionProblem() = {
    def dream()() = {
        println("~Dream~");
        new Exception().printStackTrace()
    }
    val map = scala.collection.mutable.HashMap[String,()=>Unit]()
    map("dream") = dream()      // partial function
    map("dream")()              // invokes as expected
    val check = dream()         // unexpected invocation
    check()                     // error: check of type Unit does not take parameters 
}

当我map (1+) list在Haskell中编写类似内容时,内部表示是(1+)什么？由于它是部分应用(+),争论1必须在某处保存,但我无法理解这一点.有人可以给我一个简短的解释,如何实现currying和部分应用程序？

是否可以在Haskell中为部分应用类型创建数据构造函数？

ghci会话:

Prelude> data Vector a b = Vector {x::a, y::b}
Prelude> :t Vector
Vector :: a -> b -> Vector a b
Prelude> type T1 = Vector Int
Prelude> :t T1
<interactive>:1:1: Not in scope: data constructor `T1'
Prelude> let x = Vector
Prelude> let y = T1
<interactive>:46:9: Not in scope: data constructor `T1'

我想为T1类型创建数据构造函数 - 它甚至可能吗？或者我是否必须使用newtypes,因为无法手动定义此类函数？

John Resig有一篇关于部分应用的热门博客文章:http://ejohn.org/blog/partial-functions-in-javascript/它在很多地方都有提及,并且有

但是,博客文章中的代码不起作用.这里是:

Function.prototype.partial = function(){
  var fn = this, args = Array.prototype.slice.call(arguments);
  return function(){
    var arg = 0;
    for ( var i = 0; i < args.length && arg < arguments.length; i++ )
      if ( args[i] === undefined )
        args[i] = arguments[arg++];
    return fn.apply(this, args);
  };
};

var delay = setTimeout.partial(undefined, 10);

delay(function(){
  alert( "A call to this function will be temporarily delayed." );
});

现在,如果您尝试在控制台中运行它,它将正常工作.但是,如果您尝试再次使用延迟功能,它将无法正常工作.运行第一个段后,尝试在控制台中运行此命令:

delay(function(){
  alert( "This is a test" );
});

请注意,第二条消息不会出现 …

好吧,这是漫长的一天,我的大脑可能无法在Haskell级别上运行,但我无法理解"了解你一个Haskell"中的一个例子.

该部分称为带有$的函数应用程序,并且有一个如何$定义的示例:

($) :: (a -> b) -> a -> b
f $ x = f x

到目前为止一切都很清楚.我理解本节中的所有示例,除了最后一个:

ghci> map ($ 3) [(4+), (10*), (^2), sqrt]
[7.0,30.0,9.0,1.7320508075688772]

这里我们映射($ 3)函数列表并获得这些函数的应用结果3.但这怎么可能呢？

从第一个代码片段可以看出,第一个参数是一个函数,我们甚至可以写:

*Main> ($) sqrt 4
2.0

现在($ 3)是功能的部分应用$,但3继续功能的位置!所以3应该是一个功能还是什么？

还有另一个谜团:到底是(4+)什么？我知道这(+4)是部分应用功能+,所以(4+)应该部分应用功能4吗？废话.什么样的伎俩在这里有效？

我_用作占位符来创建匿名函数,问题是我无法预测Scala将如何转换我的代码.更确切地说,它错误地确定了我想要的"大"匿名函数的大小.

 List(1,2,3) foreach println(_:Int)   //error !
 List(1,2,3) foreach (println(_:Int)) //work
 List(1,2,3) foreach(println(_:Int))  //work

使用-Xprint:typer我可以看到Scala将第一个转换为"一个大的匿名函数":

x$1 => List(1,2,3) foreach(println(x$1:Int))

工作的第2个3号是正确的转变成我想要的.

... foreach (x$1 => println(x$1:Int)) 

为什么这个？规则是什么？

我希望有一个函数BindFirst绑定函数的第一个参数,而不必通过使用std :: placeholders显式地知道/声明函数的arity.我希望客户端代码看起来像那样.

#include <functional>
#include <iostream>

void print2(int a, int b)
{
    std::cout << a << std::endl;
    std::cout << b << std::endl;
}

void print3(int a, int b, int c)
{
    std::cout << a << std::endl;
    std::cout << b << std::endl;
    std::cout << c << std::endl;
}

int main()
{ 
    auto f = BindFirst(print2, 1); // std::bind(print2, 1, std::placeholders::_1);
    auto g = BindFirst(print3, 1); // std::bind(print3, 1, std::placeholders::_1, std::placeholders::_2);
    f(2);
    g(2,3);
}

任何想法如何BindFirst实施？

我在这里看一看:Scala currying与部分应用的函数,但那里的答案更多地回答了Scala中currying,partial application和normal函数之间的功能和语义差异.

我有兴趣了解这些可用于功能的不同技术之间是否有任何性能考虑因素,即......

如果我们使用普通函数的性能作为基础:

def add3(a: Int, b: Int, c: Int) = a + b + c
add3(1, 2, 3)

然后比较:

// First
(add3 _).curried(1)(2)(3)

// Second
val add2 = add3(1, _: Int, _: Int)
val add1 = add2(2, _: Int)
add1(3)

// Third
def add3(a: Int)(b: Int)(c: Int) = a + b + c
add3(1)(2)(3)

如果我发现一些性能不佳的代码(无论是在速度还是内存使用方面),我可能想要注意的是什么？我看到在所述代码段中发生了很多currying或部分应用程序？

例如,在Haskell中,我会查看正在生成多少个thunk并在其中闲逛.我认为Scala使用类似的方法来传递部分应用和curried函数,而Scala如何处理这些事情的细节将是很有价值的.

由于Kotlin支持函数式编程的许多概念,我想知道是否有办法在Kotlin中部分应用函数？

部分应用程序可能有用的一个这样的例子是:

// In one class
fun doSomething(cb: (a, b) -> Unit) {
    <some logic here to compute someField>
    doSomethingElse(cb.applyPartially(someField))
}

// In another class
fun doSomethingElse(cb: (b) -> Unit) {
    <some logic here to compute someOtherField>
    cb(someOtherField)
}

我试图了解有关 Haskell 函数的一些内容。

首先，这是一个以典型的“慢”方式定义的斐波那契函数（即没有记忆的递归，也没有无限列表技巧）

slowfib :: Int -> Integer
slowfib 0 = 0
slowfib 1 = 1
slowfib n = slowfib (n-2) + slowfib (n-1)

接下来，相同的规范记忆版本。（仅与教程/书籍/等中的典型示例略有不同，因为我更喜欢!!运算符的前缀版本。）

memfib = (!!) (map fib [0..])
  where
    fib 0 = 0
    fib 1 = 1
    fib k = memfib(k-2) + memfib(k-1)

上面的解决方案使用了!!运算符的部分应用，这是有道理的：我们希望memfib最终成为一个带参数的函数，并且我们正在定义它而不在定义中包含参数。

到现在为止还挺好。现在，我想我可以编写一个等效的记忆函数，在定义中包含一个参数，所以我这样做了：

memfib_wparam n = ((!!) (map fib [0..])) n
  where
    fib 0 = 0
    fib 1 = 1
    fib k = memfib_wparam(k-2) + memfib_wparam(k-1) …