C

#include <stdio.h>
 
int sum(int x, int y)
{
    return x + y;
}
int subtract(int x, int y)
{
    return x - y;
}
int multiply(int x, int y)
{
    return x * y;
}
 
//  int choice - выбранный пункт
int (*select(int choice))(int, int)
{
    // возвращаем нужную функцию
    switch (choice)
    {
        case 2:
            return subtract;
        case 3:
            return multiply;
        default:
            return sum;
    }
}
int main(void)
{
    int (*operation)(int, int) = select(1);
    printf("%d \n", operation(8, 5)); // 13
 
    operation = select(2);
    printf("%d \n", operation(8, 5)); // 3

    operation = select(3);
    printf("%d \n", operation(8, 5)); // 40

    return 0;
}

С помощью псевдонимов:

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

int sum(int x, int y) { return x+y; }
int subtract(int x, int y) { return x-y;}
int multiply(int x, int y) { return x * y;}
 
//  int choice - выбранный пункт
binary_op* select(int choice)
{
    // возвращаем нужную функцию
    switch (choice)
    {
        case 2:
            return &subtract;
        case 3:
            return &multiply;
        default:
            return ∑
    }
}
int main(void)
{
    binary_op* operation  = select(1);
    printf("%d \n", operation(8, 5)); // 13
 
    operation = select(2);
    printf("%d \n", operation(8, 5)); // 3

    operation = select(3);
    printf("%d \n", operation(8, 5)); // 40

    return 0;
}

C++

#include <iostream>
 
int sum(int, int);
int subtract(int, int);
int multiply(int, int);
int(*select(int))(int, int);
 
int main()
{
    int(*action)(int, int) {select(1)};  // получаем указатель на функцию sum
    std::cout << action(8, 5) << std::endl; // 13

    action = select(2);  // получаем указатель на функцию subtract
    std::cout << action(8, 5) << std::endl; // 3

    action = select(3);  // получаем указатель на функцию multiply
    std::cout << action(8, 5) << std::endl; // 40
}
 
int(*select(int choice))(int, int)
{
    // возвращаем нужную функцию в зависимости от choice
    switch (choice)
    {
        case 2:
            return subtract;
        case 3:
            return multiply;
        default:
            return sum;
    }
}
int sum(int x, int y)
{
    return x + y;
}
int subtract(int x, int y)
{
    return x - y;
}
int multiply(int x, int y)
{
    return x * y;
}

C#

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

Func<int, int, int> action= Select(1);  // получаем ссылку на функцию Sum
Console.WriteLine(action(8, 5)); // 13

action = Select(2);  // получаем ссылку на функцию Subtract
Console.WriteLine(action(8, 5)); // 3

action = Select(3);  // получаем ссылку на функцию Multiply
Console.WriteLine(action(8, 5)); // 40

Func<int, int, int> Select(int choice)
{
    // возвращаем нужную функцию в зависимости от choice
    switch (choice)
    {
        case 2:
            return Subtract;
        case 3:
            return Multiply;
        default:
            return Sum;
    }
}
int Sum(int a, int b) => a+ b;
int Subtract(int a, int b) => a - b;
int Multiply(int a, int b) => a * b;

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

BinaryOp action= Select(1);  // получаем ссылку на функцию Sum
Console.WriteLine(action(8, 5)); // 13

action = Select(2);  // получаем ссылку на функцию Subtract
Console.WriteLine(action(8, 5)); // 3

action = Select(3);  // получаем ссылку на функцию Multiply
Console.WriteLine(action(8, 5)); // 40

BinaryOp Select(int choice)
{
    // возвращаем нужную функцию в зависимости от choice
    switch (choice)
    {
        case 2:
            return Subtract;
        case 3:
            return Multiply;
        default:
            return Sum;
    }
}
int Sum(int a, int b) => a+ b;
int Subtract(int a, int b) => a - b;
int Multiply(int a, int b) => a * b;
// BinaryOp представляет метод, который принимает два числа int и возвращает int
delegate int BinaryOp (int a, int b);

Dart

void main() {
     
    Function action = select(1);  // получаем функцию sum
    print(action(8, 5)); // 13

    action = select(2);  // получаем функцию subtract
     print(action(8, 5)); // 3

    action = select(3);  // получаем функцию multiply
     print(action(8, 5)); // 40
}
Function select(int choice)
{
    // возвращаем нужную функцию в зависимости от choice
    switch (choice)
    {
        case 2:
            return subtract;
        case 3:
            return multiply;
        default:
            return sum;
    }
}
int sum(int a, int b) => a+ b;
int subtract(int a, int b) => a - b;
int multiply(int a, int b) => a * b;

F#

let sum a b  = a + b
let subtract a b = a - b
let multiply a b = a * b;

let select choice = 
    match choice with
        | 2 -> subtract
        | 3 -> multiply
        | _ -> sum

let mutable action = select 1  // получаем функцию sum
printfn "%d" (action 8 5)      // 13

action <- select 2  // получаем функцию subtract
printfn "%d" (action 8 5)  // 3

action <- select 3  // получаем функцию multiply
printfn "%d" (action 8 5)  // 40

JavaScript

function select(choice)
{
    // возвращаем нужную функцию в зависимости от choice
    switch (choice)
    {
        case 2:
            return subtract;
        case 3:
            return multiply;
        default:
            return sum;
    }
}
function sum(a, b) { return a + b};
function subtract(a, b) { return a - b};
function multiply(a, b) { return a * b};

let action = select(1);  // получаем функцию sum
console.log(action(8, 5)); // 13

action = select(2);  // получаем функцию subtract
console.log(action(8, 5)); // 3

action = select(3);  // получаем функцию multiply
console.log(action(8, 5)); // 40

Kotlin

fun main() {
    var action: (Int, Int) ->Int = select(1) // получаем функцию sum
    println(action(8, 5)) // 13

    action = select(2) // получаем функцию subtract
    println(action(8, 5)) // 3

    action = select(3) // получаем функцию multiply
    println(action(8, 5)) // 40
}
fun select(choice: Int): (Int, Int)->Int {
    // возвращаем нужную функцию в зависимости от choice
    return when (choice) {
        2 -> ::subtract
        3 -> ::multiply
        else -> ::sum
    }
}
fun sum(a: Int, b: Int) = a + b
fun subtract(a: Int, b: Int) = a - b
fun multiply(a: Int, b: Int) = a * b

Python

def select(choice):
    # возвращаем нужную функцию в зависимости от choice
    match choice:
        case 2:
            return subtract
        case 3:
            return multiply
        case _:
            return sum

def sum(a, b): return a + b
def subtract(a, b): return a - b
def multiply(a, b): return a * b

action = select(1)  # получаем функцию sum
print(action(8, 5)) # 13

action = select(2)  # получаем функцию subtract
print(action(8, 5)) # 3

action = select(3)  # получаем функцию multiply
print(action(8, 5)) # 40

Rust

fn select(choice: i32)-> fn(i32, i32)->i32 {
    // возвращаем нужную функцию в зависимости от choice
    return match choice {
        2 => subtract,
        3 => multiply,
        _ => sum
    };
}
fn sum(a: i32, b: i32) -> i32 {a + b}
fn subtract(a: i32, b: i32) -> i32 {a - b}
fn multiply(a: i32, b: i32) -> i32 {a * b}

fn main(){
  
    let mut action: fn(i32, i32) ->i32 = select(1); // получаем функцию sum
    println!("{}",action(8, 5)); // 13

    action = select(2); // получаем функцию subtract
    println!("{}",action(8, 5)); // 3

    action = select(3); // получаем функцию multiply
    println!("{}",action(8, 5)); // 40
}