srele96

struct foo {
  std::string type;
  std::string value;
  void process(const std::string&, const std::string&);
};

srele96

struct foo {
  template <typename T>
  foo(T p_object) {
    p_object.process("hello");
  }
};

struct bar {
  void process(const std::string& p_value) { std::cout << p_value << "\n"; }
};

srele96

7
helloworld
5.25

srele96

6
Add int 5
Add string hello
Add float 3.5
Process int 2
Process string world
Process float 1.5

srele96

#include <iostream>
#include <memory>
#include <vector>

class object_ {
 private:
  struct concept_ {
    virtual void process(const std::string& p_value) = 0;
    virtual void out(std::ostream& p_ostream) const = 0;

srele96

#include <algorithm>
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <vector>

// Problem: Stock Price Alert System
//
// Description:

srele96

namespace share_config {

/**
 * Do not try to understand the WHY this is the way it is. It just is.
 *
 * I am using CRTP and Attorney pattern because I want to use them lol.
 */

struct config {
  std::function<void(const std::string&, std::ostream&)> callback_one;

srele96

namespace deduce_type {

namespace use_decltype {

struct result {
  int value;

  result() : value{1} {}
  explicit result(int p_value) : value{p_value} {}

srele96

#include <iostream>
#include <string>

namespace curiously_recurring_template_pattern {

namespace a {

template <class T>
class base {
 public:

srele96

const { useState } = React;

// Which patterns do we use?
// React children can be utilized as a function, experiment with it
function F(props) {
  console.log(props.children);
  console.log(props.children(0));
  console.log(props.children(0, 1));
  console.log(props.children([]));
  return props.children();