标签: first-class-functions

我正在使用python解决一个难题,根据我正在解决的难题,我将不得不使用一组特殊的规则.如何将函数传递给Python中的另一个函数？

例

def Game(listA, listB, rules):
   if rules == True:
      do...
   else:
      do...

def Rule1(v):
  if "variable_name1" in v:
      return False
  elif "variable_name2" in v:
      return False
  else:
      return True

def Rule2(v):
  if "variable_name3" and "variable_name4" in v:
      return False
  elif "variable_name4" and variable_name1 in v:
      return False
  else:
      return True

这只是一个伪代码,因此不具体,但我得到了编译的代码但我需要知道如何调用该函数Game以及它是否正确定义,因为规则将被切换为Rule1(v)或者Rule2(v).

什么是头等公民职能？

Java是否支持一流的公民功能？

编辑:
正如在Wikepedia上提到的那样

一级函数是函数式编程风格的必需品.

有没有其他使用头等功能？

在python中,引用函数非常简单:

>>> def foo():
...     print "foo called"
...     return 1
... 
>>> x = foo
>>> foo()
foo called
1
>>> x()
foo called
1
>>> x
<function foo at 0x1004ba5f0>
>>> foo
<function foo at 0x1004ba5f0>

但是,它似乎在Ruby中有所不同,因为裸体foo实际上调用了foo:

ruby-1.9.2-p0 > def foo
ruby-1.9.2-p0 ?>  print "foo called"
ruby-1.9.2-p0 ?>  1
ruby-1.9.2-p0 ?>  end
 => nil 
ruby-1.9.2-p0 > x = foo
foo called => 1 
ruby-1.9.2-p0 > foo
foo called => 1 
ruby-1.9.2-p0 > x
 => 1 

我如何实际将 …

更具体地说,代表具有作为F#中的第一类值的函数的特征(如果有的话)没有; 作为第一类值的特征有什么特征(如果有的话)在C#中委托没有？

我仍然对这是什么感到困惑first-class functions.如果我理解正确,first-class functions应该使用一个函数作为对象.它是否正确？

这是一个first-class function吗？

def this_is_example(myarg1):
    return myarg1

def this_is_another_ example(myarg):
     return this_is_example(myarg)+myarg

this_is_another_ example(1)

我查看了最新的Ruby版本,以便对最新的更改进行一些调整.我尝试做的第一件事是调用Ruby lambda/block/proc就像你使用Python可调用一样.

a = lambda {|x| puts x}
a.call(4) # works, and prints 4
a[4] # works and prints 4
a.(4) # same
a(4) # undefined method 'a' for main:Object

为什么最后一次通话不可能？它会永远吗？

第一类函数是否意味着它们表现为变量？显然,它们的行为与变量完全不同,因为:

console.log(foo);
var foo = 'bar';

......不起作用,而这个:

console.log(foo());
function foo() {
 return('bar');
}

...一样.

那说,这个:

console.log(foo());
var foo = function() { return 'bar'; };

不起作用,这更加一致.

是什么赋予了？

这是一个奇怪的oop问题.我想创建一组对象(在设计时已知),每个对象都具有与之关联的某些功能.我可以通过给出包含'delegates'的对象属性来做到这一点:

public class StateTransition {
    Func<bool> Condition { get; set; }
    Action ActionToTake { get; set; }
    Func<bool> VerifyActionWorked { get; set; }
}

StateTransition foo = new StateTransition {
    Condition = () => {//...}
    // etc
};

或者,我可以使用抽象类并为我想要创建的每个对象实现它:

public abstract class StateTransition {
    public abstract bool Condition();
    public abstract void ActionToTake();
    public abstract bool VerifyActionWorked();
}

class Foo : StateTransition {
    public override bool Condition() {//...}
    // etc
}

Foo f = new Foo();

我意识到这两种方法的实际后果(在设计时间与运行时间创建)是完全不同的.

如何选择适合我的应用的方法？

我已经使用ScriptBlocks在PowerShell中成功传递了无参数函数.但是,如果函数有参数,我无法使用它.有没有办法在PowerShell中执行此操作？(最好是v2)

Function Add([int] $x, [int] $y)  
{ 
  return $x + $y 
}
Function Apply([scriptblock] $s)    
{ 
    write-host ($s.Invoke(1,2)) 
}

然后

Apply { Add } 

将0写入控制台.Apply会调用Add,但不传递任何参数(即使用默认[int]值0和0)

在Swift文档中,Apple说:

闭包是自包含的功能块,可以在代码中传递和使用.Swift中的闭包类似于C和Objective-C中的块以及其他编程语言中的lambdas.

我认为是第一类功能的定义

他们也这样说:

闭包可以从定义它们的上下文中捕获和存储对任何常量和变量的引用.这被称为关闭那些常量和变量.Swift为您处理捕获的所有内存管理.

我认为这是封闭的定义,而另一种缺陷是一流的功能,但Apple似乎把它们放在一起并称之为封闭.

我误解了什么吗？或者是Apple调用闭包和一流的函数闭包？

我已经编写了这个示例代码,并且想知道我是否在撰写评论中是对的？

// 'a' takes a first class function, which makes 'a' a higher order function
func a(ch: () -> Void){
    print("Something")
    ch()                // 'ch' is a first class function
    print("Ended")
}

func closureFunc(){
    var num = 2
    a({
        // access to 'num' is possible by closures
        num = num*2
        print(num)
    })
}

closureFunc()