template<typename T>
struct fmt::formatter<std::optional<T>>: formatter<T> {
  using formatter<T>::parse;
  auto format(const std::optional<T>& opt, format_context& ctx) const {
    if (opt.has_value()) {
      format_to(ctx.out(), "Some(");
      this->formatter<T>::format(opt value(), ctx);
      return format_to(ctx.out(), ")");
    } else {
      return format_to(ctx.out(), "None");
    }
  }
};

/* /* */
#include <fmt/core.h>
int main() {
  fmt::println("Hello C++!");
  auto _ = R"(*/
fn main() {
  println!("Hello Rust!");
  const _:&str = ")";
}

$ g++ -x c++ code.rspp -lfmt -o as-cxx && ./as-cxx
Hello C++!

$ rustc code.rspp -o as-rs && ./as-rs 
Hello Rust!

%: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