int x = 42;
  auto addX = [x](int y) { return x+y;}; // capture: lexical scope
  std::cout << "addX(10):" << addX(10) << std::endl;
  x = 1;
  std::cout << "addX(10):" << addX(10) << std::endl;
// 52 52

  int y = 42;
  auto addY = [&](int x) { return x+y;}; // reference: dynamic scope
  std::cout << "addY(10):" << addY(10) << std::endl;
  y = 1;
  std::cout << "addY(10):" << addY(10) << std::endl;
// 52 11

template<class T, class U, class F>
U foldl(F f, U acc, List<T> lst)
{
    static_assert(std::is_convertible<F, std::function<U(U, T)>>::value, 
                 "foldl requires a function type U(U, T)");
    if (lst.isEmpty())
        return acc;
    else
        return foldl(f, f(acc, lst.head()), lst.tail());
}

template<class T, class U, class F>
U foldr(F f, U acc, List<T> lst)
{
    static_assert(std::is_convertible<F, std::function<U(T, U)>>::value, 
                 "foldr requires a function type U(T, U)");
    if (lst.isEmpty())
        return acc;
    else
        return f(lst.head(), foldr(f, acc, lst.tail()));
}

	List<int> l;
  l = l.cons(0).cons(1).cons(2).cons(3).cons(4);
  int sum = foldl([](int a, int b) { return a+b;}, 0, l); // 10

  float sum_ = foldr([](int a, float b) { return a+b;}, 0.0f, l);
  printf("%f\n", sum_); //10.0

  int max = foldl([](int a, int b) { return a>b?a:b;}, 0, l); // 4

  int val = 3;
  bool anyLargerThanVal = foldl([=](bool acc, int x) { return x>**val**? true:acc;}, false, l);// 1

  
  std::cout << "sum:" << sum << ", max:" << max << std::endl;
  std::cout << "anyLargerThanVal:" << anyLargerThanVal << std::endl;

auto compose = [](auto f, auto g) { 
    return [=](auto&& ... x) { 
        return f(g(x...)); 
    }; 
};

auto h1 = compose([](int x){return x+1;}, [](){ return 42;}); // 43
std::cout << "h1()=" << h1() << std::endl;

auto h2 = compose([](pair<int,int> p){return p.first+p.second;}, [](int x, int y){ return pair(x, y);});
std::cout << "h2(1,2)=" << h2(1, 2) << std::endl; //3

auto add3(int a, int b, int c) {
return a+b+c;
}

auto curried_add3(int a) {
	return [=](int b){ // == [a,b] != [&] 여기를 &로 바꾸면 안됨. 
		return [=](int c){ //왜냐면 리턴해버리니까 a,b가 사라지기에 더미 데이터가 들어옴
					return a+b+c;
		};
	};
}

std::cout <<  add3(1,2,3) << " "; // 6 
std::cout << curried_add3(1)(2)(3) << std::endl; // 6
auto add2_one = curried_add3(1);
auto add1_three = add2_one(2);
add1_three(3); // 6
add1_three(4); // 7

template<class T, class U>
std::function<std::function<U(List<T>)>(U)>
cfoldl(std::function<U(U, T)> f) 
{
    std::function<std::function<U(List<T>)>(U)> captured1;
    captured1 = [=](U acc) {
      std::function<U(List<T>)> captured2;
      captured2 = [=](List<T> lst) {
        if (lst.isEmpty()) return acc;
        else return cfoldl(f) (f(acc, lst.head())) (lst.tail());
      };
      return captured2;
    };
    return captured1;
}

	std::function<int(int,int)> adder = [](int a, int b)->int { return a+b;};
  auto sumFold = cfoldl(adder);
  std::cout << "after sumFold \n";
  int sum2 = sumFold(100)(l); // l: 0 1 2 3 4
  std::cout << "sum2:" << sum2 << std::endl; // 110

#include <functional>
#include <iostream>
#include "List.h"

template<class T>
bool contains(List<T> lst, T v) {
	return !filter([&](T val){return v == val;}, lst).isEmpty();
}

struct set { //set struct을 만들어서 세개의 함수를 포함
	std::function<struct set(int)> insert;
	std::function<bool(int)> member;
	std::function<int()> size;
};

struct set make_set(List<int> xs) { // xs를 캡처
	struct set s = { // nstructor가 없지만 list constructor로 초기화함
	[=](int a){if (contains(xs, a)) {return make_set(xs);}
							else {return make_set(xs.cons(a));}
						},
	[=](int a){return contains(xs,a);},
	[=](){int size=0; forEach(xs, [&](auto x){size++;}); return size;}
	};
	return s;
}

int main(){
	auto s1 = make_set(List<int>{});
    std::cout << s1.size() << std::endl;
	auto s2 = s1.insert(42);
    std::cout << s2.size() << std::endl;
	auto s3 = s2.insert(40);
    std::cout << s3.size() << std::endl;
}