This article is rated C-class on Wikipedia's content assessment scale. It is of interest to the following WikiProjects: | ||||||||||||||||||
|
To-do list for First-class function:
|
The language support table is excellent and reasonably detailed. However, it's missing the following languages:
Please add a language to the list if it is missing from the table. Put higher priority languages higher on the list. Please remove a language if it has been added to the table. --Hierarchivist (talk) 21:51, 7 May 2014 (UTC)
"Most modern programming languages support functions defined statically at compile time. C additionally supports function pointers, which can be stored in data structures and passed as arguments to other functions. Nevertheless, C is not considered to support first class functions, since in general functions cannot be created dynamically during the execution of a program. The closest analog in C is that of a dynamically compiled function created by a just-in-time compiler, which is compiled as an array of machine language instructions in memory and then cast to a function pointer. However, this technique is specific to the underlying hardware architecture and is therefore neither general nor portable."
The languages mentioned, for the most part, do not have the explicit ability to create functions but to create closures. Functions consist of code, which is typically not dynamically generated or modified. Closures capture the (usually lexically) contectual environment existing at the time of the closure's creation, along with whatever function is associated with the closure. This is, unfortunately, more than a semantic issue - it is explicitely being confused with dynamic code generation, which is given as a comparative example. This technique has nothing in common whatsoever with first order functions.
Of course, removing this "requirement" from the list also means that C DOES have first class functions. If you don't agree with this, I'd recommend including closures as mentioned (which, IMO, are a somewhat different beast), and perhaps anonymous functions as well.
I'd make these changes myself but I don't want to so majorly overhaul this node without some further input. —The preceding unsigned comment was added by 74.128.168.38 (talk) 22:36, 18 January 2007 (UTC).
IMO a more serious problem here is the fact that AFAIK this statement is not supported by the references. The only reference I see for this article is Scott's Programming Language Pragmatics. I own a copy of that book and I was just reading it the other day. I'm pretty sure Scott says that C *does* have first-class functions. He gives a clear definition of first-class, second-class and third-class objects and none of the definitions makes any reference to whether you can "dynamically" create an object. It does require that in order to be a first-class object, the language must allow you to use it as the return value of a function (which C allows). If anyone objects to this analysis then I suggest they dig up another reference that supports their view. 216.165.132.252 (talk) —Preceding undated comment added 17:46, 24 December 2009 (UTC).
void EvalFuncOnGrid( float(^block)(float) ) {
int i;
for ( i = 0; i < 5 ; ++i ) {
float x = i * 0.1;
printf("%f %f", x, block(x));
}
}
void Caller(void) {
float forceConst = 3.445;
EvalFuncOnGrid(^float(float x){ return 0.5 * forceConst * x * x; });
}
void main(void) {
Caller();
}
I don`t see from this example Does Apple extension made first-class functions avialable or not. It just shows that you can pass anonymous function as parameter. To see that it fully supports first-class functions we also have to see that-
1. We can assign anonymous function to variable.
2. We can return anonymous function from other function.
Are these requirements met in Apple`s C extension ? If not,- then that C extension clearly does not introduced first-class functions. —Preceding unsigned comment added by 84.32.222.96 (talk) 08:19, 22 February 2010 (UTC)
So this is a classic "proof" of first class functions in php:
function makeDerivative($fn, $deltaX) {
return function($x) use ($fn, $deltaX) {
return ($fn($x + $deltaX) - $fn($x)) / $deltaX;
};
}
$cos = makeDerivative(sin, 0.00000001);
echo $cos(0); // 1
echo $cos(pi() / 2); // 0
But there are a few things wrong with it. First, this code actually throws a catchable fatal error. The label 'sin' doesn't refer to the builtin function but rather the constant sin. Since such a constant wasn't defined, php pretends you meant string 'sin'. What you should actually do is:
$cos = makeDerivative('sin', 0.00000001);
and for all intents and purposes, $fn in the closure is a string. When you use $fn($x), php resolves the value of the string to some function and calls it with the arguments $x, but in no situation can you actually store or pass in a reference to a function. The closure object is actually first class (you can pass it around, assign it to variables), but functions are not. 72.235.55.215 (talk) 09:36, 15 June 2012 (UTC)
It seems to me that if you have to wrap a function in a 'proc' object in order to assign it to a variable, then your functions are second-class citizens. Something else I would expect to be able to do in a language that supports first class functions:
def f(x)
x+4
end
g = f
g(2)
This doesn't work in ruby either. You can't assign a function using = (the normal assignment operator), you have to use def, or wrap the function in an object. That's not first-class.88.96.214.6 12:26, 20 March 2007 (UTC)
def f(x) # global functions are contained in the Kernel
x + 4
end
g = Kernel.method :f
g.call(2) #=> 6
g[2] #=> 6
g.(2) #=> 6 (only works in ruby 1.9, its a new syntax)
g.class #=> 'Method'
proc = g.to_proc # returns the method as a Proc
IMO Python has unlimited function literals; it is possible to create any function (not limited to an expression like lambda functions) by creating a string and executing it; example:
>>> code="""def myfunc(a):
... if isinstance(a, int):
... print a**2
... else:
... print a, 'is not an integer number'
... """
>>> exec(code)
>>> myfunc(3)
9
>>> myfunc(3.0)
3.0 is not an integer number
>>>
(just tested using Python 2.5.2) --Tobias (talk) 09:55, 19 August 2008 (UTC)
And what about this? ->
import math
def make_derivative(f, deltaX):
delta=[deltaX]
function=[f]
fnc=lambda x: (function[0](x+delta[0])-function[0](x))/delta[0]
return fnc
cos=make_derivative(math.sin, 0.0000000001)
# cos(0) ~> 1.0
# cos(math.pi/2) ~> 0.0
I just wanted to state agreement with the anonymous edit [1] removing the statement "A different set of difficulties arises when programs can create functions at runtime; if the program is compiled, this means that the runtime environment must itself include a compiler." Although it is possible for a program to generate another program in source or AST form and subsequently compile it at runtime, it is also possible for a program to directly generate machine code at runtime, and this is common in certain applications e.g. compiled bitmaps. Dcoetzee 12:30, 30 November 2008 (UTC)
Just because you can create a compiled bitmap from C, or embed a compiler in a C program, does not mean that the C language supports creating functions dynamically. Since it allows you to escape the type system through dangerous pointer casts and such, it does allow you to hack in such functionality, or perform any kind of machine-level black magic that you want, but that's quite different from providing language support. Many C compilers support inline assembly instructions but they're not part of the C language either. Contrast this with Common Lisp which does provide a compiler within the runtime environment and does allow you to generate and run Lisp code at runtime. Every Common Lisp implementation is required to have this functionality and it is fully integrated with other language features. 216.165.132.252 (talk) —Preceding undated comment added 17:54, 24 December 2009 (UTC).
That article wants to describe the same concept. An anonymous function per se is damn useless. What makes it useful is that it can be passed around. But that article fails to explain this, or pretty much anything, besides giving some examples that largely overlap with this article. Pcap ping 21:35, 20 August 2009 (UTC)
I am not exactly an expert, but I think having first class functions is neither stronger nor weaker than having anonymous functions:
Since the two concepts are closely related it may in fact be best to discuss them in a single article. But it would take a serious effort to get the details right, and we would need really good sources. It's probably easier to keep the articles separate but keep them synchronised. (Basically they should use the same languages as examples, unless a language has one of the properties but not the other, which should then be stated clearly.) Hans Adler 09:06, 21 August 2009 (UTC)
()
, to simulate first-class functions; you can even implement a fixed point combinator that way in C++ (there's a link on that page). In Java you only get anonymous inner classes, which give you closures, but you have to syntactically invoke a method thereof. Still you can implement a fixed point combinator in Java, with really awful syntax. But you don't need reflection, and if you have reflection but no inner classes to work as closures, you still can implement a fixed point combinator (try). Basically a fixed point combinator is an essential test of first-classness because it needs to return a function that's not "written" anywhere; well, it is defined implicitly. Since you mentioned Java, dynamic class loading is a different concept however, orthogonal to the idea of first-class functions; it's more like an eval as mentioned in this article.Having said all that, we're not lacking concrete examples here, but rather some non WP:OR definitions of these concepts. I'll try to find some authoritative references (as in not some text on language X, but more principles/theory kinda book). Pcap ping 10:42, 21 August 2009 (UTC)
I agree with Macrakis that first-class functions are a lot wider topic than anonymous functions. To show that I can simply mention the fact that function may return ordinary OR anonymous function. So in theory - language can support first-class functions by operating only with ordinary functions. This illustrates that in general first-class functions has nothing to do with anonymous functions. However in practice first-class functions are much more useful when used in conjuntion with anonymous functions. So at most - anonymous functions can be only sub-topic of first-class functions. (Albeit we can`t ignore possibility that mentioning anonymous functions here can obfuscate understanding of first-class functions) —Preceding unsigned comment added by 84.32.222.96 (talk) 09:04, 22 February 2010 (UTC)
I agree with 84.32.222.96, but I do feel that first-class function is an ill-defined concept. At present, the article lists four things a language must be able to do before it can be said to support first-order functions; many languages support the last three, but dynamic function code assembly by treating program code as just regular structured data (which I believe is the first property) is specific to interpreted languages (e.g. in the Lisp or Forth families) and therefore quite different from the other three. Someone who knows only Lisp, or only C#, or only C++, won't see this, of course. So while I'm opposed to this merge, I do think it's important to consider whether the present article describes a well-defined term in the first place. Rp (talk) 16:26, 25 August 2010 (UTC)
(see M.J. Dominus. Higher Order Perl, 2005. pp 325, 333)
$lambda = sub {$_[0] + 4};
print $lambda->(2), "\n"; # => 6
Psilva (talk) 09:35, 26 September 2009 (UTC)
There is also this. --Paddy (talk) 16:23, 26 September 2009 (UTC)
I disagree with various statements concerning whether or not this is generally available in C - or that it must somehow require specific hardware. Consider the following:
// imports first_class dll.
- include <first_class.h>
class dll_data;
class first_class;
main (char* args)
{
dll_data *dll_data = new dll_data (int N, args);
char *new_c_source;
bool quit = false;
while (!quit)
{
first_class::load_dll ();
quit = first_class::run (dll_data);
new_c_source = dll_data->new_source;
first_class::unload_dll ();
if (new_c_source!=NULL)
first_class::recomplie_dll (dll_data->new_source);
}
}
Windows actually has a "LoadModule" function (I think) that allows you to load dlls when you want them or need them, allowing you to do things like have one version of a program that can use different DLL's according to different OS, or whatever. These can then be loaded during execution rather then when the program first starts up (automatically) and thus avoiding the dreaded "required DLL not found error". The process can even be applied recursively, so that DLL's which have various complicated and interacting dependencies can be linked in and out, etc. In my simple example I am suggesting a kind of persistent data block type (which could also be modified if needed by using placement new, casting to a void pointer, and/or realloc as needed).
Then there is the issue of "Active X" and so on. I'm not sure how you would do this in Linux, although I am aware that Linux/Uxix variants to support some kind of _popen (char *filename -- etc) method which allows an application to create a new process and communicate with it via a named pipe and thus incur no more essential performance penalty other than whatever mighg be associated with named pipes. Lots of things could be dynamically modified this way -- such as MPEG encoders, database engines, etc. The pipes in such cases can be used for streaming the otherwise computationally intensive data -- even to the point that it becomes imaginable to create applications that could be run for months or even years (I have seen Linux boxes with uptime over 1 year) —Preceding unsigned comment added by 67.116.237.73 (talk) 08:40, 5 December 2009 (UTC)
Functional languages must support first-class functions BY DESIGN (in language semantics itself),- not recursively/dynamically invoking compiler as in your example or not by doing some other metaprogramming stuff. Otherwise by using your logic we can conclude that ANY compiled language supports functional programming (or any other programming idiom, just by invoking compiler dynamically). Which will sound crazy [and leave language designers unemployed :) ], don`t you think ? So let`s face it - C/C++ was not designed as modern functional language, and it will stay as it is, unless ... will be re-designed by it`s designers :-) —Preceding unsigned comment added by 84.32.222.96 (talk) 17:50, 22 February 2010 (UTC)
It is about what haskel can do with its functions rather than about first class functions. They are not the same thing. The former is a superset of the latter.
Integers would be first class in most languages and whilst you would be able to pass them into and out of functions, you cannot curry an integer or lazily evaluate it, or create a closure on it.
The things you can do with a first class integer include passing it to and from a function; creating new integers from other integers in expressions; and having integers of members of collection datatypes such as lists and sets. If a language has first class integers, and you can do what you can do with integers with its functions, then the functions are every bit as first class as the languages integers. Or would integers in the language be thought of as second class?
I think this new section should be trimmed. --Paddy (talk) 18:43, 13 July 2010 (UTC)
Or a member of a set for that matter? I'm just thinking what can you do with a string and an integer that you may not be able to do for a function in some languages, and so limit the first-classness of functions.
In Python:
>>> def a(): pass
>>> def b(): pass
>>> { a:1, b:2 }
{<function b at 0x00000000032669C8>: 2, <function a at 0x0000000003266A48>: 1}
>>> { a:1, b:2 }[a]
1
>>> {a, b}
{<function a at 0x0000000003266A48>, <function b at 0x00000000032669C8>}
>>> type({a, b})
<class 'set'>
>>> a = lambda : None
>>> b = lambda : None
>>> type(a)
<class 'function'>
>>> { a:1, b:2 }
{<function <lambda> at 0x000000000327D1C8>: 2, <function <lambda> at 0x0000000003276A48>: 1}
>>> { a:1, b:2 }[a]
1
>>> a == b
False
>>> a == a
True
>>> a is b
False
>>> a is a
True
--Paddy (talk) 08:36, 17 February 2011 (UTC)
It seems as if first classness of functions comes down to:
- Hardly rigourous but very human. --Paddy (talk) 08:54, 17 February 2011 (UTC)
>>> def main():
... a = 10
... b = 10
... f = (lambda ls: map(lambda x: a * x + b, ls))
... a = 3
... b = 1
... return f
...
>>> main()([1,2,3,4,5])
[4, 7, 10, 13, 16]
>>> (lambda x: x) == (lambda x: x)
False
>>> def main():
... x = 1
... def f():
... x = x + 1
... print x
... return f
...
>>> o = main()
>>> o()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in f
UnboundLocalError: local variable 'x' referenced before assignment
>>> def main():
... x = [1]
... def f():
... x[0] = x[0] + 1
... return x[0]
... return f
...
>>> o = main()
>>> o()
2
>>> o()
3
>>> o()
4
>>> o()
5
Hi Ruud, Python 3 addressed the access to outer variables issue with the nonlocal keyword:
Python 3.1 (r31:73572, Jun 28 2009, 18:34:47)
[GCC 3.3.4 (pre 3.3.5 20040809)] on linux2
Type "copyright", "credits" or "license()" for more information.
>>> def outer():
x = 1
def inner():
nonlocal x
x += 1
print(x)
return inner
>>> f = outer()
>>> f()
2
>>> f()
3
>>> f()
4
>>>
--Paddy (talk) 14:36, 17 February 2011 (UTC)
I don't understand why C++ isn't listed as supporting partial application of functions. This is exactly what the C++11 std::bind function does, and even in C++03 the std::bind1st and std::bind2nd functions provided for partial application, although in a limited way. I've found a number of web pages (such as one from the Dream in Code web site) that support this view, but I don't know if any of them would be considered definitive.
63.232.147.98 (talk) 01:14, 22 February 2012 (UTC)
Partial Application in JavaScript
Partial function application in the functional js library.
--Widged (talk) 21:12, 13 March 2012 (UTC)
Back in 2010 someone pointed out that Apple's C supports anonymous functions called "blocks". I don't know much about all the various versions of C, but Apple writes that "Blocks are available in GCC and Clang as shipped with the OS X v10.6 Xcode developer tools" (See iOS Developer Library:Blocks Programming Topics). So what version of C is this?
Blocks can assigned to variable, passed to functions, returned as values from functions. The block can refer to variables in the scope that they were defined and use persistent storage for the local variables if the function returns. In other words, I think they thought of everything as far as I can see. Thus this version of C has first class functions.
This info should be added to the table and the text, otherwise this article is in error. ---- CharlesGillingham (talk) 01:19, 1 November 2014 (UTC)
This language specific section does not have enough merit to be included as it only states the capabilities and limitations of one language and will only encourage a host of other language specific entries. It is better to delete it. --Paddy (talk) 21:45, 16 November 2014 (UTC)
Language support for first class functions should not present a table grouping languages by family. It is not relevant to the topic but it is vague and at best arguable. Furthermore the specific taxonomy used is neither accurate nor intuitive with respect to first class functions. For example, one category is C Family and another is Scripting, while another is Functional.
I suggest we remove the taxonomy from table and restructure the section. — Preceding unsigned comment added by Rahab rx (talk • contribs) 18:36, 3 September 2016 (UTC)
The source links to the functools library which includes functions common in functional programming. It does indeed have a partial application function, but what it does is just sort of provide a function that can be used in place of partial application. Python doesn't actually implement it on a syntax level. Have a function that takes an argument "x" and returns "x + 1" isn't partial application of "+1", it's just a function that is used instead of actual partial application. If Python has partial application, then every language which has closures also has partial application and you could probably argue that any language that has functions has partial application. 131.252.226.117 (talk) 19:23, 8 November 2016 (UTC)
Hello fellow Wikipedians,
I have just modified 2 external links on First-class function. Please take a moment to review my edit. If you have any questions, or need the bot to ignore the links, or the page altogether, please visit this simple FaQ for additional information. I made the following changes:
When you have finished reviewing my changes, you may follow the instructions on the template below to fix any issues with the URLs.
This message was posted before February 2018. After February 2018, "External links modified" talk page sections are no longer generated or monitored by InternetArchiveBot. No special action is required regarding these talk page notices, other than regular verification using the archive tool instructions below. Editors have permission to delete these "External links modified" talk page sections if they want to de-clutter talk pages, but see the RfC before doing mass systematic removals. This message is updated dynamically through the template ((source check))
(last update: 5 June 2024).
Cheers.—InternetArchiveBot (Report bug) 09:27, 1 October 2017 (UTC)
the first link in the first note leads to "page not found" — Preceding unsigned comment added by 2001:7c7:2051:195:e1ce:11c7:dd2e:fd8b (talk • contribs) 09:07, 27 September 2021 (UTC)