AnthonyMikh

[package]
name = "fizzbuzz"
version = "0.1.0"
edition = "2021"

[features]
use_nightly = []
compare_with_previous_impl = []

AnthonyMikh

enum Expr {
    Lit(i32),
    Neg(Box<Self>),
    Add(Box<Self>, Box<Self>),
}

fn lit(x: i32) -> Expr {
    Expr::Lit(x)
}

AnthonyMikh

#![feature(generic_associated_types)]

pub struct Data {
    pub name: String,
    pub whatever: u32,
    pub bytes: Vec<u8>,
}

trait BorrowedKeyFamily {
    type Key<'a>: Ord + 'a;

AnthonyMikh

#[derive(Clone)]
struct Lexer<'a> {
    s: &'a str,
}

impl<'a> Lexer<'a> {
    fn of(s: &'a str) -> Self {
        Self { s }
    }

AnthonyMikh

macro_rules! make_literal_maker {
    ($name:ident : $ty:ident) => {
        macro_rules! $name {
            ($n:expr) => {{
                const fn digits_len(mut n: $ty) -> ::core::primitive::usize {
                    if n == 0 {
                        return 1;
                    }
                    let mut n_digits = 0;
                    #[allow(unused_comparisons)]

AnthonyMikh

#include <cstddef>
#include <cstring>
#include <cstdlib>

// #define TYPED_TIGHT_MALLOC

namespace typed {

template <typename T>
T* memset_n(T *dest, int ch, std::size_t count) {

AnthonyMikh

struct Z;
struct S<T>(T);

trait Add<Rhs> {
    type Sum;
}

type SumOf<N, M> = <N as Add<M>>::Sum;

impl<N> Add<N> for Z {

AnthonyMikh

#[derive(Clone, Copy)]
pub struct Bounds {
    rows: usize,
    cols: usize,
}

type Pos = (usize, usize);

impl Bounds {
    pub fn around_neumann(

AnthonyMikh

use std::cmp::Ordering;
use std::convert::Infallible as Never;
use std::fmt::{self, Debug};

struct Z;
struct S<T>(T);

#[derive(Clone)]
struct Node<T, Next> {
    value: T,

AnthonyMikh

struct Lexer<'a> {
    s: &'a str,
}

type Num = usize;

#[derive(Debug)]
enum Lexeme<'a> {
    String(&'a str),
    Num(Num),