=======================funcptr===============================
#include <iostream> 
using namespace std;

int f() { cout << "This is function f." << endl; }
int g() { cout << "This is function g." << endl; }

void doTwice(int (*a_function)()) {
	a_function();
	a_function();
}

int main () {
	doTwice(f);
	doTwice(g);
	return 0;
}
==========================divides=================================
#include <iostream>
#include <functional>
using namespace std;

class Divides {
  private:
    int divisor;

  public:
    Divides(int n) { divisor = n; }
    bool operator() (int number) {return (number % divisor == 0);}
};

int main () {
  Divides div3 = Divides(3);
  int input;
  bool result;

  cout << "Please enter a number: ";
  cin >> input;

  result = div3(input);

  cout << "Number " << input << " is " << (result?"":"not ") << "divisible by 3.\n";

  return 0;
}
========================divides2================================
#include <iostream>
#include <functional>
using namespace std;

int main () {
  std::function<bool(int)> div3 = [](int x) { return x % 3 == 0; };

  int input;
  bool result;

  cout << "Please enter a number: ";
  cin >> input;

  result = div3(input);

  cout << "Number " << input << " is " << (result?"":"not ") << "divisible by 3.\n";

  return 0;
}
=============================lambda==============================
#include <iostream>

using namespace std;

int main()
{
    auto func = [] () { cout << "Hello world"; };
    func(); // now call the function
}
=============================divides3==============================
#include <iostream>
#include <functional>
using namespace std;

std::function<bool(int)> makeDivider(int divisor) {
  return [=] (int x) { return x % divisor == 0; };
}

int main () {

  int divisor, number;
  bool result;

  cout << "Please enter a divisor and number to divide: ";
  cin >> divisor >> number;

  std::function<bool(int)> div_func = makeDivider(divisor); 

  if (div_func(number)) {
    cout << "it divides!" << endl;
  } else {
    cout << "it doesn't divide!" << endl;
  }

  if (makeDivider(divisor)(number)) {
    cout << "it divides!" << endl;
  } else {
    cout << "it doesn't divide!" << endl;
  }

  return 0;
}
=============================capture1==============================
#include <iostream>
#include <functional>
using namespace std;

std::function<int()> makeCounter() {
  int c = 0;
  return [=] () { c++; return c; };
}

std::function<int()> makeCounter2() {
  int c = 0;
  return [&] () { c++; return c; };
}

int main () {
  auto count1 = makeCounter();
  auto count2 = makeCounter2();

  return 0;
}
=============================capture2==============================
#include <iostream>
#include <functional>
using namespace std;

std::function<int()> makeCounter2() {
  int c = 0;
  return [&] () { c++; return c; };
}

int main () {
  auto count2 = makeCounter2();

  cout << count2() << endl;
  cout << count2() << endl;
  cout << count2() << endl;

  return 0;
}
=============================capture3==============================
#include <iostream>
#include <functional>
using namespace std;

std::function<int()> makeCounter2() {
  int c = 0;
  return [=] () mutable { c++; return c; };
}

int main () {
  auto count2 = makeCounter2();

  cout << count2() << endl;
  cout << count2() << endl;
  cout << count2() << endl;

  return 0;
}
=============================map==============================
#include <string>
#include <cctype>
#include <algorithm>
#include <iostream>
 
int main()
{
    std::string s("hello");
    std::transform(s.begin(), s.end(), s.begin(), (int (*)(int))std::toupper);
    std::cout << s << std::endl;
}
=============================map2==============================
#include <algorithm>
#include <iostream>
#include <functional>
#include <vector>
using namespace std;

std::function<int(int)> makeAdder(int x) {
  return [=] (int y) { return x + y; };
}

int main () {
  vector<int> v = {1, 2, 3, 4, 5};
  vector<int> v2;

  cout << "BEFORE\n";
  for (auto i : v) { cout << i << endl; }
  for (auto i : v2) { cout << i << endl; }

  std::transform(v.begin(), v.end(), std::back_inserter(v2), makeAdder(1));

  cout << "AFTER\n";
  for (auto i : v) { cout << i << endl; }
  for (auto i : v2) { cout << i << endl; }

  return 0;
}
=============================filter==============================
#include <algorithm>
#include <vector>
#include <iostream>
#include <functional>
using namespace std;

std::function<bool(int)> makeDivider(int divisor) {
  return [=] (int x) { return x % divisor == 0; };
}

int main () {
  vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  vector<int> v2;
  
  cout << "BEFORE\n";
  for (auto i : v) { cout << i << endl; }
  for (auto i : v2) { cout << i << endl; }

  std::copy_if(v.begin(), v.end(), std::back_inserter(v2), makeDivider(3));

  cout << "AFTER\n";
  for (auto i : v) { cout << i << endl; }
  for (auto i : v2) { cout << i << endl; }

}
============================python============================
def generate_power_func(n):
    def nth_power(x):
        return x**n
    return nth_power

raised_to_4 = generate_power_func(4)

def make_adder(x):
    return lambda y: x+y

def make_counter():
    count = 0

    def increment():
        nonlocal count
        count = count + 1
        return count

    return increment