Some languages (Javascript, Python) have the notion that a function is an object://Javascriptvar fn = console.log;This means that functions can be treated like any other object (first-class functions), e.g. passed in as an argument to another function:var invoker = function(toInvoke) {    toInvoke();};invoker(fn); //will call console.logOther languages (C++, C#, VB.NET) do not define functions as real objects://C#Type t = Console.WriteLine.GetType();//This code will not compile, because://'Console.WriteLine()' is a method, which is not valid in the given contextRather these languages may have objects which can point to a function (such as C++ function pointers) and can be passed around just like any other object. In the CLI, these wrapper objects are called delegates or delegate instances://C#void Invoker(Action toInvoke) {    toInvoke();}Action action = Console.WriteLine;Invoker(action);//also valid, and the toInvoke argument will now contain a delegate which points to Console.WriteLine//Invoker(Console.WriteLine);What differences in capability arise from these two mechanisms -- function object vs pointer-to-function as object?
Differences between first-class function mechanisms
functions;delegates
I see two areas of different behavior that arise from the two mechanisms:The pointer object is a separate object from the referenced function, and will have a separate identity from the function, and from other pointers to the functionThe pointer object can have behaviors beyond that of the original function. For example, in the CLI:Delegate instances know about the relevant this (and can bind it to the method)Delegate instances can contain pointers to multiple functions(Note: This is from my experience in C# / VB.NET and Javascript. Other languages may have different variants of either mechanism.)Object reference equalityIf a function is a real object then any variables pointing to the function are actually pointing to the same object://Javascriptvar fn = console.log;var fn1 = console.log;console.log(fn === fn1); //prints truePointer objects have their own identity, even when both point to the same function://C#Action action = Console.WriteLine;Action action2 = Console.WriteLine;Console.WriteLine(Object.ReferenceEquals(action, action2)); //prints FalseAdditional behaviors of the pointer objectTarget bindingFunction objects have no knowledge of the class to which they are attached://Javascriptvar a1 = {    data: 5,    writeData: function() {        'use strict'; //otherwise `this` would be the global object; `this.data` would probably return `undefined`        console.log(this.data);    }};var action = a1.writeData;action(); //Uncaught TypeError: Cannot read property 'data' of undefinedTherefore, part of calling the function as an instance method, is the implict binding of this within the function to the object:a1.writeData(); //prints 5We can also explicitly bind this with bind, apply, or call:action = a1.writeData.bind(a1);action(); //prints 5However (as @amon pointed out in this answer), the delegate instance retains that information://C#public class A {    public int Data;    public void WriteData() {        Console.WriteLine(this.Data);    }}var a1 = new A() {Data=4};Action action = a1.WriteData;because action contains knowledge of the target of methods:Console.WriteLine(action.Target == a1); //prints TrueMulticast delegateJavascript variables / properties that refer to a function object, work just like references to any other object, and therefore cannot refer to multiple function objects simultaneously.On the other hand, a delegate instance in .NET can point to multiple functions://C#public static class Writers {    public static void WriteOne() {        Console.WriteLine(1);    }    public static void WriteTwo() {        Console.WriteLine(2);    }}action = Writers.WriteOne;action += Writers.WriteTwo;action(); //prints 1, and then prints 2