First-class

#PL #First_Class
A first-class object (or first-class citizen) can be used as values or passed as arguments, or inputs, to yet more functions.

Supports all the operations generally available include:

Being passed as an argument to a function.
Being returned from a function.
Being assigned to a variable.
Being created and destroyed dynamically.
Being stored in data structures.

In many programming languages, functions are first-class objects. This means you can treat functions just like any other object. For instance, you can store them in variables, pass them as parameters to other functions, return them from functions, and store them in data structures like arrays or lists.

Application

Higher-order Functions:

Functions that take other functions as arguments or return them as results. This is common in functional programming paradigms. For example, in JavaScript:

function greet(name) {
  return function(message) {
    console.log(`${message}, ${name}!`);
  }
}

const greetJohn = greet('John');
greetJohn('Hello');  // Output: Hello, John!

Callback Functions:
- Functions passed as arguments to other functions that are intended to be called at a later time. This is widely used in asynchronous programming. For example, in Node.js:
```
const fs = require('fs');

fs.readFile('example.txt', 'utf8', function(err, data) {
  if (err) throw err;
  console.log(data);
});
```
Functional Programming:
- Languages like Haskell and Lisp heavily use first-class functions. This enables the use of functions like map, reduce, and filter which operate on collections of data.
Event Handling:
- In GUI applications, event handlers are often first-class functions. For example, in a browser environment:
```
document.getElementById('myButton').addEventListener('click', function() {
  alert('Button was clicked!');
});
```

Decorators:

In Python, decorators are functions that modify the behavior of other functions or methods. They are made possible by the fact that functions are first-class objects. For example:

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

Command Patterns:
- In object-oriented design, the command pattern can use functions or objects as first-class citizens to encapsulate a request as an object, thereby allowing for parameterization of clients with queues, requests, and operations.

Lambda Expressions:

Anonymous functions that can be used wherever function objects are required. For example, in Python:

numbers = [1, 2, 3, 4]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers)  # Output: [1, 4, 9, 16]