%:define bitard bitand
%:define pidor bitor

if (a bitard a pidor b) <%
    auto greet = <:bitard:>(auto and n) <% 
    cout << n << a << endl; 
%>;
    greet("Anon");
%>

macro_rules! static_assert_eq_usize {
  ($lhs:expr, $rhs:expr) => {
    const _: [(); $lhs] = [(); $rhs];
  }
}

macro_rules! assert_layout {
  {
    $(
      $t:ident (size = $size:expr, align = $align:expr) {
        $($member:ident @ $offset:expr,)*
      }
    )*
  } => {
    $(
      static_assert_eq_usize!($size, std::mem::size_of::<$t>());
      static_assert_eq_usize!($align, std::mem::align_of::<$t>());
      $(static_assert_eq_usize!($offset, std::mem::offset_of!($t, $member));)*
    )*
  }
}

#[repr(C)]
struct LogHeader {
  magic: u64,
  version: u64,
  length: u64,
}

#[repr(C, packed(4))]
struct LogEntry {
  timestamp: u32,
  data: u64,
}

assert_layout! {
  LogHeader (size = 24, align = 8) {
    magic   @ 0,
    version @ 8,
    length  @ 16,
  }
  LogEntry (size = 12, align = 4) {
    timestamp @ 0,
    data      @ 4,
  }
}

struct foo {
    int baz[];
}

struct bar;

namespace baz {
    struct { void operator&=(auto&&) {} } foo;
}

int main() {
    baz::foo &= [](bar* foo) -> int { return 1; };
    { return 1; } int (foo::* bar)[] =& foo::baz;
}

cargo init --bin
cargo add serde
cargo add --features arbitrary_precision

use serde::Deserialize;

#[derive(Debug, Deserialize)]
#[serde(tag = "type")]
enum MyEnum {
    A { val: f64 },
}

fn main() {
    let json = r#"{ "type": "A", "val": 0.0, "v": 9999999999999999999999999999999 }"#;
    let my_enum: MyEnum = serde_json::from_str(json).unwrap();
    println!("{:?}", my_enum);
}

thread 'main' panicked at src/main.rs:10:54:
called `Result::unwrap()` on an `Err` value: Error("invalid type: map, expected f64", line: 0, column: 0)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

use serde::Deserialize;
use serde_json::Value;

#[derive(Debug, Deserialize)]
#[serde(tag = "type")]
enum MyEnum {
    A { val: f64 },
}

fn main() {
    let json = r#"{ "type": "A", "val": 0.0, "v": 9999999999999999999999999999999 }"#;
    let value: Value = serde_json::from_str(json).unwrap();
    let my_enum: MyEnum = serde_json::from_value(value).unwrap();
    println!("{:?}", my_enum);
}

thread 'main' panicked at src/main.rs:12:57:
called `Result::unwrap()` on an `Err` value: Error("invalid type: integer `9999999999999999999999999999999` as u128, expected any value", line: 0, column: 0)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

template<typename T = decltype([]{})>
using CreateNewType = T;

static_assert(not std::is_same_v<CreateNewType<>, CreateNewType<>>);

using SavedType = CreateNewType<>;
static_assert(std::is_same_v<SavedType, SavedType>);
static_assert(not std::is_same_v<SavedType, CreateNewType<>>);

// yob.hpp
template<auto F>
struct OnDestroy {
  ~OnDestroy() { F(); }
};

using LoudDestroy = OnDestroy<[] { std::cout << "Goodbye"; }>;
void consume(LoudDestroy);

// yob.cpp
#include "yob.hpp"
void consume(LoudDestroy) {}

// main.cpp
#include "yob.hpp"
int main() {
  consume({}); // linker error with clang
}

// yob.hpp
void foo(int) = delete;
void bar(int) = new;

// yob.cpp
#include "yob.hpp"
void bar(int) {}

// main.cpp
#include "yob.hpp"
int main() {
  foo(15); // compiler error
  bar(23); // linker error
}