Fun with Lambdas: C++14 Style (part 2)

Look at some interesting examples of C++11/14 lambdas and how they interact with other language features and libraries. I hope to find some time to add some explanations. See part 1 if you missed it.

• Associative containers and lambdas

  std::set<int, std::function<bool(int, int)>> 
    numbers([](int i, int j) { return i < j; });
  

• Recursive Lambdas (see Creating recursive lambdas and returning them too!)

  auto make_fibo() 
  {
    return [](int n) {
      std::function<int(int)> recurse;
      recurse = [&](int n){ 
         return (n<=2)? 1 : recurse(n-1) + recurse(n-2); 
      }; 
      return recurse(n);
    };
  }
  

• Composable list manipulation (e.g., cpplinq, narl, LEESA)

  Box boxes[] = { ... };
  int sum_of_weights = 
       cpplinq::from_array(boxes)
    >> where([](const Box & box) { 
         return box.color == Color.RED;
       })
    >> select([](const Box & box) {
         return box.get_weight();
       })
    >> sum();
  
  

• Overloaded Lambdas

  template <class... F>
  struct overload : F... {
    overload(F... f) : F(f)... {}  
  };
  
  template <class... F>
  auto make_overload(F... f) {
    return overload<F...>(f...);   
  }
  
  auto f = 
      make_overload([](int i) { /* print */ },
                    [](double d) { /* print */ });
  f(10); // int 
  f(9.99); // double
  

• Type Switch (simple pattern matching) (see type_switch.cpp and this paper)

  struct Base { 
    virtual ~Base() {} 
  };
  struct Derived : Base {};
  
  template <class Poly>
  void test(Poly& p) {  
    match(p)(
      [](int i)             { cout << "int";       },
      [](std::string &)     { cout << "string";    },
      [](Derived &)         { cout << "Derived";   },     
      [](Base &)            { cout << "Base";      },    
      otherwise([](auto x)  { cout << "Otherwise"; })
    );  
  }
  Derived d;
  Base &b = d;
  std::string cpptruths = "C++ Truths";
  boost::any something = cpptruths;
  
  test(10);        // int
  test(cpptruths); // string
  test(something); // string
  test(b);         // Derived
  test(9.99);      // Otherwise
  

• Converting shared_ptr between boost and std (see StackOverflow)

  template <typename T>
  boost::shared_ptr<T> 
  make_shared_ptr(std::shared_ptr<T> ptr) 
  {      
    return boost::shared_ptr<T>(ptr.get(), 
      [ptr](T*) mutable { ptr.reset(); });
  }
  
  template <typename T>
  std::shared_ptr<T> 
  make_shared_ptr(boost::shared_ptr<T> ptr)
  {      
    return std::shared_ptr<T>(ptr.get(), 
      [ptr](T*) mutable { ptr.reset(); });
  }
  

• In-place parameter pack expansion 

  template <class... T>
  void foreach(T... args) 
  {  
    bool b[] = { [=](){ 
      std::cout << args << "\n"; 
      return true; 
    }()... }; 
  }
  
  foreach(10, 20.2, true);
  

• Memoization (see original)

  template <typename ReturnType, 
            typename... Args>
  auto memoize(ReturnType (*func)(Args...))
  {
      std::map<std::tuple<Args...>, ReturnType> cache;
  
      return ([=](Args... args) mutable  
      {
          std::tuple<Args...> t(args...);
          if (cache.find(t) == cache.end())                
          {
            std::cout << "not found\n";
            cache[t] = func(args...);
          }
          return cache[t];
      });
  }
  

• Finally, slides
  
  
  
  Fun with Lambdas: C++14 Style (part 2) from Sumant Tambe