DutchGhost

//https://www.youtube.com/watch?v=BdXWlQsd7RI&t=8s
use core::marker::PhantomData;

trait Nat {}

struct Zero {}

struct Succ<N: Nat> {
    number: PhantomData<N>,
}

DutchGhost

const std = @import("std");

pub fn ArrayList(comptime T: type) type {
    return struct {
        const Self = @This();

        items: []T,
        length: usize = 0,

        pub fn init(comptime SIZE: usize) Self {

DutchGhost

#![allow(incomplete_features)]
#![feature(
    const_trait_impl,
    const_fn_trait_bound,
    const_generics,
    const_evaluatable_checked,
    specialization
)]

use core::mem::ManuallyDrop;

DutchGhost

#![allow(incomplete_features)]
#![feature(
    const_trait_impl,
    const_fn_trait_bound,
    const_generics,
    const_evaluatable_checked,
    specialization
)]

trait RemoveRef {

DutchGhost

mod std {
  use std::ops::Shl;
  use std::fmt::Display;

  pub struct cout;
  impl<T: Display> Shl<T> for cout {
    type Output = cout;
    fn shl(self, data: T) -> cout {
      print!("{}", data); 
      self

DutchGhost

extern crate alloc;
use {
    alloc::alloc::dealloc,
    core::{
        alloc::Layout,
        cell::Cell,
        marker::PhantomData,
        ops::{Add, Sub},
        ptr::{self, NonNull},

DutchGhost

const std = @import("std");

const Node = struct {
    next: ?*Node = null,
    frame: anyframe = undefined,
};

const List = struct {
    const Self = @This();

DutchGhost

macro_rules! monadic {
    (
        [$($e:tt)*] | [$head:ident : $tail:ident <- tails $origin:ident,
        $($heads:ident : $tails:ident <- tails $origins:ident),*], $condition:expr
    ) => {{
        let mut f = move || {
            monadic![@INNER [$($e)*] | [$head : $tail <- tails $origin $(,$heads : $tails <- tails $origins)*], $condition ];
            None
        };
        f()

DutchGhost

const input = @embedFile("../../../Inputs/day01.txt");

const std = @import("std");
const mem = std.mem;
const fmt = std.fmt;
const ArrayList = std.ArrayList;

const TARGET = @as(usize, 2020);

pub fn parseInput(slice: []const u8, allocator: *mem.Allocator) !ArrayList(usize) {

DutchGhost

usingnamespace closure: {
  var hashes: []const usize = &[0]usize{};

  break :closure struct {
    pub fn ctStrHash(comptime str: []const u8) usize {
      const hash = yourAlgo(str);
      comptime {
        for (hashes) |existing| {
          if (existing == hash) @compileError("collision");
        }