标签: lambda

在带有lambda b93的JDK 8中,b93中有一个类java.util.stream.Streams.zip可用于压缩流(这在教程Exploring Java8 Lambdas中说明.Dhananjay Nene的第1部分).这个功能:

创建一个惰性和顺序组合Stream,其元素是组合两个流的元素的结果.

然而在b98中,这已经消失了.事实上,在b98Streams中的java.util.stream中甚至无法访问该类.

是否已移动此功能,如果是这样,我如何使用b98简洁地压缩流？

我想到的应用程序是在Shen的这个java实现中,我在其中替换了zip中的zip功能

• static <T> boolean every(Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred)
• static <T> T find(Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred)

具有相当冗长代码的函数(不使用b98中的功能).

在Java中,是否可以让lambda接受多种不同的类型？

即:单变量工作:

    Function <Integer, Integer> adder = i -> i + 1;
    System.out.println (adder.apply (10));

Varargs也有效:

    Function <Integer [], Integer> multiAdder = ints -> {
        int sum = 0;
        for (Integer i : ints) {
            sum += i;
        }
        return sum;
    };

    //.... 
    System.out.println ((multiAdder.apply (new Integer [] { 1, 2, 3, 4 })));

但是我想要一些可以接受许多不同类型参数的东西,例如:

    Function <String, Integer, Double, Person, String> myLambda = a , b, c, d->  {
    [DO STUFF]
    return "done stuff"
    };

主要用途是在函数内部使用小内联函数以方便使用.

我查看了谷歌并检查了Java的功能包,但找不到.这可能吗？

我不太明白这个sorted()论点背后的语法:

key=lambda variable: variable[0]

不是lambda随意的吗？为什么variable在看起来像是两次dict？

我有以下代码:

Func<string, bool> comparer = delegate(string value) {
    return value != "0";
};

但是,以下内容无法编译:

var comparer = delegate(string value) {
    return value != "0";
};

为什么编译器无法弄清楚它是Func<string, bool>什么？它需要一个字符串参数,并返回一个布尔值.相反,它给了我错误:

无法将匿名方法分配给隐式类型的局部变量.

我有一个猜测,那就是如果编译var版本,如果我有以下内容,它将缺乏一致性:

var comparer = delegate(string arg1, string arg2, string arg3, string arg4, string arg5) {
    return false;
};

上面没有意义,因为Func <>只允许最多4个参数(在.NET 3.5中,这就是我正在使用的).也许有人可以澄清这个问题.谢谢.

当我在C#编译器遇到一些非常奇怪的代码时,我正在回答关于闭包(合法地)延长对象生命周期的可能性的问题(如果重要的话,那就是4.0).

我能找到的最短的repro如下:

1. 在调用包含类型的静态方法时创建一个捕获局部的lambda .
2. 将生成的委托引用分配给包含对象的实例字段.

结果:编译器创建一个闭包对象,该对象引用创建lambda的对象,当它没有理由时 - 委托的"内部"目标是静态方法,并且lambda-creation-object的实例成员不需要在委托执行时被(并且没有)触摸.实际上,编译器的行为就像程序员this无缘无故地捕获的那样.

class Foo
{
    private Action _field;

    public void InstanceMethod()
    {
        var capturedVariable = Math.Pow(42, 1);

        _field = () => StaticMethod(capturedVariable);
    }

    private static void StaticMethod(double arg) { }
}

发布版本生成的代码(反编译为'simpler'C#)如下所示:

public void InstanceMethod()
{

    <>c__DisplayClass1 CS$<>8__locals2 = new <>c__DisplayClass1();

    CS$<>8__locals2.<>4__this = this; // What's this doing here?

    CS$<>8__locals2.capturedVariable = Math.Pow(42.0, 1.0);
    this._field = new Action(CS$<>8__locals2.<InstanceMethod>b__0);
}

[CompilerGenerated]
private sealed class …

如何通过C++ 11 lambda中的move(也称为右值引用)捕获？

我想写这样的东西:

std::unique_ptr<int> myPointer(new int);

std::function<void(void)> example = [std::move(myPointer)]{
   *myPointer = 4;
};

我无法理解StreamJava 8中的接口,特别是它Spliterator与Collector接口有关的地方.我的问题是我根本就没有理解Spliterator和Collector接口,并因此在Stream界面依然有些模糊了我.

究竟什么是a Spliterator和a Collector,我该如何使用它们？如果我愿意自己编写Spliterator或Collector(也可能是我自己的编写Stream过程),我应该做什么而不是做什么？

我阅读了一些散布在网络上的例子,但由于这里的所有内容都是新的并且可能会有变化,因此示例和教程仍然非常稀少.

给定一个lambda,是否可以找出它的参数类型和返回类型？如果有,怎么样？

基本上,我想要lambda_traits哪些可以用于以下方式:

auto lambda = [](int i) { return long(i*10); };

lambda_traits<decltype(lambda)>::param_type  i; //i should be int
lambda_traits<decltype(lambda)>::return_type l; //l should be long

背后的动机是我想lambda_traits在一个接受lambda作为参数的函数模板中使用,我需要知道它的参数类型和函数内部的返回类型:

template<typename TLambda>
void f(TLambda lambda)
{
   typedef typename lambda_traits<TLambda>::param_type  P;
   typedef typename lambda_traits<TLambda>::return_type R;

   std::function<R(P)> fun = lambda; //I want to do this!
   //...
}

目前,我们可以假设lambda只接受一个参数.

最初,我尝试使用std::function:

template<typename T>
A<T> f(std::function<bool(T)> fun)
{
   return A<T>(fun);
}

f([](int){return true;}); //error

但它显然会给出错误.所以我将其更改TLambda为函数模板的版本,并希望在函数std::function内部构造对象(如上所示).

我正在与C#中的Action Delegates合作,希望能够更多地了解它们并思考它们可能有用的地方.

有没有人使用过Action Delegate,如果有的话为什么？或者你能举出一些可能有用的例子吗？

这三种方法之间的性能差异(如果有的话)是什么,都用于将数组转换为另一个数组？

1. 运用 foreach
2. 使用array_maplambda/closure函数
3. 使用array_map'静态'功能/方法
4. 还有其他方法吗？

为了使自己清楚,让我们看看这些例子,都做同样的事情 - 将数字数组乘以10:

$numbers = range(0, 1000);

的foreach

$result = array();
foreach ($numbers as $number) {
    $result[] = $number * 10;
}
return $result;

用lambda映射

return array_map(function($number) {
    return $number * 10;
}, $numbers);

使用'static'函数映射,作为字符串引用传递

function tenTimes($number) {
    return $number * 10;
}
return array_map('tenTimes', $numbers);

还有其他方法吗？我将很高兴听到上述案例之间的所有差异,以及为什么应该使用其他人而不是其他人的任何输入.