template <typename T>
concept StringConcept = requires(T t) {
    typename T::iterator; // 1. 检查类型存在性
    t.data();             // 2. 检查表达式合法性

    // 3. 将表达式作为 concept 的第一个参数，要求 concept 成立（额外参数从第二个参数起放置）
    { t.c_str() } -> std::same_as<char const *>;

    // 4. 用 requires 语句引入子条件
    requires std::is_pointer_v<decltype(t.data())>;

    // 5. 除了 requires 体之外还能用其他编译期常量表达式做约束
} && (sizeof(T) > 8) && !std::is_aggregate_v<T>;

template<StringConcept Str>
void takeString(Str const &s) { }

int main() {
    takeString(std::string{"hello"});
}

template <typename T>
requires HasPlus<T>
int f(T p)
{}

template <typename T>
int g(T p)
requires HasPlus<T>
{}

// 注意 requires 约束的位置比较灵活

enum { ITEM_A1, ITEM_A2 };
enum B { ITEM_B1, ITEM_B2 };
// 从 C 沿用来的语法：
// 1. 底层类型默认为int，但也能手动指定
// 2. 枚举名裸露在外
// 区别：
// C 允许前向声明 enum
// C++ 允许枚举列表为空；允许在表示类型时省略 enum 关键字；虽然枚举名裸露但也能通过限定名访问

// C++ 新增 enum class
enum C { ITEM_C1, ITEM_C2 };
// 类型不再裸露，需要使用限定名访问
// 没有默认底层类型，但是可以手动指定

#include <type_traits>

enum A: int { ITEM_1 };
enum { ITEM_2 };
enum class B: int { ITEM_3 };

// 即便底层类型相同，实际类型也不同
static_assert(! std::is_same_v<int, A>);
static_assert(sizeof(int) == sizeof(A));
static_assert(sizeof(int) == sizeof(ITEM_2));
// 枚举不是聚合类
static_assert(! std::is_aggregate_v<A>);
static_assert(! std::is_aggregate_v<B>);

int main() {
    [](int){}(ITEM_1);
    [](int){}(ITEM_2);
    
    int b3 = (int)B::ITEM_3;
    // [](int){}(B::ITEM_3); // no conversion from B to int
    // [](B){}(b3);          // no conversion from int to B
    [](B){}(B {b3});
    // [](B){}( {b3} );      // 即便是花括号也不能推导，因为枚举不是类

    // 强类型整数还是用 aggregate 做比较好：
    // 虽然整数到枚举可以使用构造的方式描述，但枚举到整数只能强制转换
    // 作为对比，aggregate 直接访问成员即可
}

struct Foo { Foo(int, int) {} };
struct Bar { explicit Bar(int, int) {} };

Foo f1(1, 1); // ok
Foo f2 {1, 1}; // ok
Foo f3 = {1, 1}; // ok

Bar b1(1, 1); // ok
Bar b2 {1, 1}; // ok
Bar b3 = {1, 1}; // NOT OKAY

Bar many_bars[] = { {1, 1} };     // ERROR explicit阻止了 {1, 1} 被推导成 Bar{1, 1}
Bar many_bars2[] = { Bar{1, 1} }; // okay

std::map<std::string, int> intMap {
    { "Hello Super Long String", 1 },
    { "Another Longish String", 2 },
    { "This cannot fall into SSO buffer", 3 }
};

std::cout << "Lookup in intMap with by const char*:\\n";
std::cout << intMap.contains("Hello Super Long String") << '\\n';
//
std::map<std::string, int, std::less<>> trIntMap {
    { "Hello Super Long String", 1 },
    { "Another Longish String", 2 },
    {"This cannot fall into SSO buffer", 3 }
};

std::cout << "Lookup in trIntMap by const char*: \\n";
std::cout << trIntMap.contains("Hello Super Long String") << '\\n';

struct string_hash {
  using is_transparent = void;
  [[nodiscard]] size_t operator()(const char *txt) const {
    // 对指针的hash只考虑了地址，所以要选用string_view的hash
    return std::hash<std::string_view>{}(txt);
  }
  [[nodiscard]] size_t operator()(std::string_view txt) const {
    return std::hash<std::string_view>{}(txt);
  }
  [[nodiscard]] size_t operator()(const std::string &txt) const {
    // string和string_view的hash方式一样
    // 但用string的特化会减少一次从string到string_view的构造
    return std::hash<std::string>{}(txt);
  }
};

std::unordered_map<std::string, int, string_hash, std::equal_to<>>
      intMapTransparent {
    { "Hello Super Long String", 1 },
    { "Another Longish String", 2 },
    {"This cannot fall into SSO buffer", 3 }
};

bool found = intMapTransparent.contains("Hello Super Long String");
std::cout << "Found: " << std::boolalpha << found << '\\n';

bn.addEventListener("DOMNodeInserted", o, s)

var [adder, remover] = ((bn, o, s) => {
    var helper = { remove : () => {}, add : () => {} }
    var observer = new MutationObserver(function(mutations) {
      mutations.forEach(function(mutation) {
        var nodes = Array.prototype.slice.call(mutation.addedNodes);
        nodes.forEach((node_) => { o(); helper.remove() });
      });
    });
    helper.remove = () => observer.disconnect();
    helper.add = () => observer.observe(bn, { childList: true, subtree: true, };
    return [helper.add, helper.remove];
})(bn, o, s);
adder()

bn.removeEventListener("DOMNodeInserted", o, s)

auto f()         { return 42; } // #1
auto f() -> auto { return 42; } // #2，相当于 #1

$ cat Makefile
all:
        echo \'*\'
$ make
echo \'*\'
'*'
$ nvim Makefile
$ cat Makefile
all:
        echo '*'
$ make
echo '*'
Makefile