标签: higher-order-functions

我有许多高阶实用程序函数,它们接受代码引用并将该代码应用于某些数据.其中一些函数需要在执行子例程期间本地化变量.开始时,我正在使用caller以与此示例reduce函数中所示类似的方式确定要本地化的包:

sub reduce (&@) {
    my $code      = shift;
    my $caller    = caller;
    my ($ca, $cb) = do {
        no strict 'refs';
        map \*{$caller.'::'.$_} => qw(a b)
    };
    local (*a, *b) = local (*$ca, *$cb);
    $a = shift;
    while (@_) {
        $b = shift;
        $a = $code->()
    }
    $a
}

最初这种技术运行良好,但是当我尝试围绕高阶函数编写包装函数时,找出正确的调用者变得复杂.

sub reduce_ref (&$) {&reduce($_[0], @{$_[1]})}

现在为了reduce工作,我需要这样的东西:

    my ($ca, $cb) = do {
        my $caller = 0;
        $caller++ while caller($caller) =~ /^This::Package/;
        no strict …

我有以下高阶函数:

public static Func<T, bool> Not<T>(Func<T, bool> otherFunc)
{
    return arg => !otherFunc(arg);
}

并尝试这样称呼它:

var isValidStr = LinqUtils.Not(string.IsNullOrWhiteSpace);

编译器给我"类型参数不能从使用中推断"错误.但以下工作:

var isValidStr = LinqUtils.Not((string s) => string.IsNullOrWhiteSpace(s));

我想知道有什么区别？ string.IsNullOrWhiteSpace已经是一个具有完全相同签名的非重载函数.

如评论中所述,以下内容也有效,但仍无法解释为什么在这种情况下类型推断失败:

var isValidStr = LinqUtils.Not<string>(string.IsNullOrWhiteSpace);

filter在Emacs Lisp中是否有相当于高阶函数的东西？喜欢python或Javascript的功能.

(filter-equivalent (lambda (n) (= (% n 2) 0)) '(1 2 3 4 5 6 7 8))

==> (2 4 6 8)

Java 方法类和Java 7的MethodHandle类都引用与方法关联的对象,但它们很少使用,当函数需要传递给另一个时,最好使用实现包含一个的接口的匿名类方法.

(注意:MethodHandles应该比旧方法更快.)

为什么这些结构不经常用于将函数传递给函数？是因为它们仍然冗长吗？

代码示例:

public final class HigherOrder {

public static final List<?> map(final List<?> list, final MethodHandle mh) throws Throwable {
    if (list == null) return null;
    List<Object> ret = new ArrayList<>(list.size());
    for (Object element : list) {
        ret.add(mh.invoke(element));
    }
    return ret;
}

public static final Object reduce(final List<?> list, final MethodHandle mh) throws Throwable {
    if (list == null) return null;
    Object tmp = list.get(0);
    for (int i = 1; i < list.size(); …

我创建了一个在Elisp中返回函数的函数:

(defun singleton-set (elem)
  (defun f (n) (= n elem))
  f)

我尝试在IELM中运行它,它失败了:

ELISP> (singleton-set 5)
*** Eval error ***  Symbol's value as variable is void: f
ELISP> ((singleton-set 5) 5)
*** Eval error ***  Invalid function: (singleton-set 5)

由于Lisp-1和Lisp-2有什么区别？我将代码更改为

(defun singleton-set (elem)
  (defun f (n) (= n elem))
  #'f)

并调用(funcall (singleton-set 5) 5),但现在错误是

*** Eval error *** Symbol's value as variable is void: elem

我从elisp了解到:从内部函数捕获变量,这是由于Emacs Lisp的动态绑定.

如何在Emacs Lisp中使函数返回函数？这种机制与Python,Scala或Clojure等其他语言有什么不同？

相关问题:

• elisp用作参数和返回值
• Elisp交互式函数名称
• 如何在Emacs …

作为练习,我重写了一些Swift的高阶函数,一个是.filter.我决定.filter使用乐器测量我对抗Swift的版本,我对结果感到困惑.

这是我的过滤器版本,我承认可能不正确.

extension Array {
    func myFilter(predicate: Element -> Bool) -> [Element] {
        var filteredArray = [Element]()
        for x in self where predicate(x) {
            filteredArray.append(x)
        }

        return filteredArray
    }
}

发生了什么

我的过滤器

• 整体CPU消耗:85.7%
• 我的过滤器的消耗量:67.9%

斯威夫特的过滤器

• 整体CPU消耗:57.7%
• 我的过滤器的消耗量:70.9%

我的期望

我期待类似的表现.我很困惑为什么我的过滤器函数调用本身会消耗更少的CPU,但我的整体应用程序CPU高出近30%.

我的问题

如果我filter写错了,请帮助我理解我的错误.否则请指出为什么Swift的filterCPU负载比我的减少了30%.

采用以下F#示例:

let parse mapDate mapLevel mapMessge (groups : string list) = 
    {
        DateTime = 
            mapDate(
                groups.[2] |> Int32.Parse, 
                groups.[0] |> Int32.Parse, 
                groups.[1] |> Int32.Parse)
        Level = mapLevel groups.[3]
        Message = mapMessge  groups.[4]
    }

我可以单独单独测试map函数,但是我如何单元测试这个函数正确调用作为参数传入的函数？

在C#中,我会使用模拟并验证对它们的调用.我最近观看了一个复杂的视频,讨论了函数式语言如何使用存根而不是模拟.在这里我可以传入一个抛出的函数,如果它没有得到预期的参数,但我并没有真正卖掉这种方法.

我只是想知道函数式编程中是否有任何模式用于单元测试这样的高阶函数？

假设我想使用期望元组f(x,y)的函数运行折叠.这可以通过以下方式完成

List.fold (fun x y -> f (x, y)) x xs

我觉得应该有一个高阶函数来抽象出该模式,采用一个期望元组的函数并将其转换为需要两个独立参数的函数.

F#标准库中有这样的功能吗？如果没有,很容易写,但它应该被称为什么？untuple？

最近，我试图在我的一些实际案例制作系统中使用Haskell。Haskell类型系统确实为我提供了很大的帮助。例如，当我意识到我需要某种类型的功能时

f :: (Foldable t, Monad m) => ( a-> b -> m b) -> b -> t a -> m b

实际上有类似的功能foldM，foldlM和foldrM。

但是，真正令我震惊的是这些功能的定义，例如：

foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
foldlM f z0 xs = foldr f' return xs z0
  where f' x k z = f z x >>= k

因此函数f'必须为以下类型：

f' :: a -> b …

我有两个这样的对象：

let obj1 = { slotIDs: ["5e0301f353ee2a0546298f15"] }
let obj2 = { slotIDs: ["5e0301f353ee2a0546298f15", "5e03050453ee2a0546298f1c"] }

我需要像这样将它们合并到一个数组中

let newObj = ["5e0301f353ee2a0546298f15", "5e03050453ee2a0546298f1c"]

我试过使用 lodash union 和 map 但没有运气。