在haxe类型的iterables或等效函数构造中使用Lambda.filter（）

如何使haxe Lambda.filter与类型化的iterable一起工作？由于类型错误，下一个代码拒绝编译：

迭代器应该是可编辑的
{next:Void->Int，hasNext:Void->Bool}应该是可编辑的

代码示例：

import Lambda;
import openfl.events.KeyboardEvent;

class KeyBoard {
    private var keys:Map<Int,Bool>;
    public function new() keys = new Map();
    public function key_handler(key:KeyboardEvent) {
        if (key.type == KeyboardEvent.KEY_DOWN) keys.set(key.keyCode, true);
        if (key.type == KeyboardEvent.KEY_UP) keys.remove(key.keyCode);
    }
    public function keys_down() {
        return Lambda.filter(keys.keys(), function(k:Int) { return keys.exists(k);});
        // The comprehension working alternative:
        //return [for (k in keys.keys()) if (keys.exists(k)) k];

    }
}

---

问题在于Haxe中Iterable和Iterator之间的区别，Lambda在默认情况下不能与Iterator一起工作（社区的官方社区实用程序中报告了Lambda缺乏对Iterator的支持）

可以认为该主题是重复的：

---

在当前状态下，Lambda实用程序只是过时了，没有足够的可用性。

问题在于Haxe中Iterable和Iterator之间的区别，Lambda默认情况下不能与Iterator一起工作（社区的官方社区实用程序中报告了Lambda缺乏对Iterator的支持）

可以认为该主题是重复的：

---

在当前状态下，Lambda实用程序只是过时了，没有足够的可用性。

您可以尝试编写Lambda类的惰性版本

（我已经在中这样做了，但我不再使用它，因为它使用表达式和保留标识符，而不是函数/短lambda，我现在认为这很愚蠢）

或者，您可以使用类似以下内容：

using Test.IteratorTools;

class IteratorTools {
    public static function toIterable<T>(f:Void->Iterator<T>):Iterable<T>
    {
        return {
            iterator : f
        };
    }
}

class Test {
    static function main() {
        var map = ["a" => "abc", "b" => "bcd", "c" => "cde"];
        var fkeys = Lambda.filter(map.keys.toIterable(), function(k) return k != "c");
        trace(fkeys);
    }
}

使用Test.iterator工具；
类迭代器工具{
公共静态函数toIterable（f:Void->Iterator）：Iterable
{
返回{
迭代器：f
};
}
}
课堂测试{
静态函数main（）{
var map=[“a”=>“abc”、“b”=>“bcd”、“c”=>“cde”]；
var fkeys=Lambda.filter（map.keys.toIterable（），函数（k）返回k！=“c”）；
微量元素（fkeys）；
}
}

---

请注意，要使其工作，您需要haxe的开发版本，至少需要提交。否则，将出现“无法在抽象成员内联方法上创建闭包”错误。

您可以尝试编写Lambda类的惰性版本

（我已经在中这样做了，但我不再使用它，因为它使用表达式和保留标识符，而不是函数/短lambda，我现在认为这很愚蠢）

或者，您可以使用类似以下内容：

using Test.IteratorTools;

class IteratorTools {
    public static function toIterable<T>(f:Void->Iterator<T>):Iterable<T>
    {
        return {
            iterator : f
        };
    }
}

class Test {
    static function main() {
        var map = ["a" => "abc", "b" => "bcd", "c" => "cde"];
        var fkeys = Lambda.filter(map.keys.toIterable(), function(k) return k != "c");
        trace(fkeys);
    }
}

使用Test.iterator工具；
类迭代器工具{
公共静态函数toIterable（f:Void->Iterator）：Iterable
{
返回{
迭代器：f
};
}
}
课堂测试{
静态函数main（）{
var map=[“a”=>“abc”、“b”=>“bcd”、“c”=>“cde”]；
var fkeys=Lambda.filter（map.keys.toIterable（），函数（k）返回k！=“c”）；
微量元素（fkeys）；
}
}

---

请注意，要使其工作，您需要haxe的开发版本，至少需要提交。否则，您将出现“无法在抽象成员内联方法上创建闭包”错误。

当前的Lambda实用程序有时仍然有用，但是是的，我们缺少主要在迭代器上工作的惰性版本，而不是Iterables。构建这样的东西很容易（甚至可能有一些语法糖，比如短lambda），最终甚至有一天会进入标准库。是的，你说得对，它仍然有用，然而，我发现它并不适用于当前std库数据结构方法的所有可能输出，这使得它不是适用于所有情况的通用可靠工具。。。正如你所说的，一个新的库应该在将来的某个时候取而代之，从其他语言中汲取最新和最伟大的经验教训。当前的Lambda实用程序有时仍然有用，但是是的，我们缺少主要在迭代器上而不是Iterables上工作的懒惰版本。构建这样的东西很容易（甚至可能有一些语法糖，比如短lambda），最终甚至有一天会进入标准库。是的，你说得对，它仍然有用，然而，我发现它并不适用于当前std库数据结构方法的所有可能输出，这使得它不是适用于所有情况的通用可靠工具。。。正如你所说，一个新的图书馆应该在将来的某个时候取而代之，从其他语言中汲取最新和最伟大的经验教训。嗨，我想知道懒散的缺点是什么，它对我来说很不错。为什么函数会更好？也许这不是“愚蠢”，只是我不认为短lambda的方向（即使以后它们总是内联的）会更好。虽然性能有所提高，但我选择的行为并没有真正解决冗长的问题。当然，lambda调用变短了，但是通过使用固定标识符（例如

$x

），用户代码的可读性也降低了，字符串插值旁边的用法变得非常混乱。假设这样：目前我必须编写

vertices.map（$x.x+，'+$x.y）

，而不是更可读的

vertices.map（v=>'${v.x}，{v，y}'）

@MarkKnol，我很想听到更多关于这个主题的想法。请随时打开一个问题或通过电子邮件直接联系我。嗨，我想知道懒散的缺点是什么，它看起来对我很好。为什么函数会更好？也许这不是“愚蠢”，只是我不认为短lambda的方向（即使以后它们总是内联的）会更好。虽然性能有所提高，但我选择的行为并没有真正解决冗长的问题。当然，lambda调用变短了，但是通过使用固定标识符（例如

$x

），用户代码的可读性也降低了，字符串插值旁边的用法变得非常混乱。假设这样：目前我必须编写

vertices.map（$x.x+，'+$x.y）

，而不是更可读的

vertices.map（v=>'${v.x}，{v，y}'）

@MarkKnol，我很想听到更多关于这个主题的想法。请随时打开一个问题