C

С помощью указателей на функции:

#include <stdio.h>
 
void hello()
{
    printf("Hello, World \n");
}
int sum(int x, int y)
{
    return x + y;
}
int main(void)
{
    // определяем указатель на функцию hello
    void (*message) (void) = hello;
    message();  // вызов функции через указатель

    // определяем указатель на функцию sum
    int (*operation)(int, int) = sum;
    int result = operation(5, 6);   // вызов функции через указатель
    printf("result = %d \n", result); 

    return 0;
}

С использованием псевдонимов:

#include <stdio.h>
 
typedef void (message)(void);
typedef int (binary_op)(int, int);

void hello() { printf("Hello, World \n");}
int sum(int x, int y) { return x + y; }

int main(void)
{
    // определяем указатель на функцию hello
    message* mes = &hello;
    mes();  // вызов функции через указатель

    // определяем указатель на функцию sum
    binary_op* op = &sum;
    int result = op(5, 6);   // вызов функции через указатель
    printf("result = %d \n", result); 

    return 0;
}

C++

#include <iostream>

void hello();
int sum(int, int);
 
int main()
{
    // указатель типа  void (*)() указывает на функцию hello
    void (*message)() {hello};
    message();

    // указатель operation указывает на функцию sum
    int (*operation)(int, int) {sum};
    int result = operation(5, 6);
    std::cout << "result = " << result << std::endl;

    // автовыведение типа указателя
    auto action {sum};
    int result2 = action(5, 6);
    std::cout << "result2 = " << result2 << std::endl;
}
void hello()
{
    std::cout << "Hello, World" << std::endl;
}
int sum(int x, int y)
{
    return x+y;
}

С использованием псевдонимов

#include <iostream>
 
// BinaryOp представляет указатель на функцию типа int (*)(int, int)
using BinaryOp = int (*)(int, int);

int sum(int, int);
int subtract(int, int);

int main()
{
    BinaryOp operation {sum};
    std::cout << operation(8, 5) << std::endl;	// 13
	operation = subtract;
    std::cout << operation(8, 5) << std::endl;	// 3
}
int sum(int x, int y){  return x + y;}
int subtract(int x, int y){  return x - y;}

C#

В C# для представления методов/функций в общем случае применяются делегаты. Можно использовать встроенные делегаты:

// переменная делегата Action указывает на функцию hello
Action message = Hello;
message();

// переменная делегата Func указывает на функцию sum
Func<int, int, int> operation = Sum;
int result = operation(5, 6);
Console.WriteLine($"result = {result}");

// автовыведение типа делегата
var action = Sum;
int result2 = action(5, 6);
Console.WriteLine($"result2 = {result2}");

void Hello()
{
    Console.WriteLine("Hello, World");
}
int Sum(int x, int y)
{
    return x+y;
}

С определением своих делегатов

BinaryOp operation = Sum;
Console.WriteLine(operation(8, 5));	// 13
operation = Subtract;
Console.WriteLine(operation(8, 5));	// 3

int Sum(int x, int y){  return x + y;}
int Subtract(int x, int y){  return x - y;}
// BinaryOp представляет метод типа int (int, int)
delegate int BinaryOp(int a, int b);

Dart

void main() {
     
    Function  message = hello;
    message();  // вызов функции

    Function operation = sum;
    int result = operation(5, 6);   // вызов функции
    print("result = $result"); 
}
void hello()
{
    print("Hello, World");
}
int sum(int x, int y)
{
    return x + y;
}

F#

let hello() = printfn "Hello, World"
let sum x y =  x + y

let message = hello   // функция типа unit -> unit
message()  // вызов функции

let operation = sum     // функция типа int -> int-> int
let result = operation 5 6   // вызов функции
printfn $"result = {result}" 

Kotlin

fun main() {
    val message: () -> Unit = ::hello
    message()   // вызов функции

    val operation: (Int, Int) -> Int = ::sum
    val result = operation(5, 6)    // вызов функции
    println("result = $result")
}

fun hello() {
    println("Hello, World")
}

fun sum(x: Int, y: Int): Int {
    return x + y
}

Python

def hello(): print("Hello, World")
def sum(x, y): return x + y

message = hello
message()           # вызов функции

operation = sum
result = operation(5, 6)    # вызов функции
print(f"result = {result}") 

Rust

fn hello() {
    println!("Hello, World");
}

fn sum(x: i32, y: i32) -> i32 {
    return x + y;
}

fn main(){
  
    let message: fn() = hello;
    message();   // вызов функции

    let operation: fn(i32, i32) -> i32 = sum;
    let result = operation(5, 6);    // вызов функции
    println!("result = {}", result);
    
}