Lisoph

#![feature(i128_type)]

struct BitSet {
    offsets: u32,
    chunks: Vec<u128>,
}

impl BitSet {
    fn new() -> Self {
        Self {

Lisoph

#![feature(i128_type)]

struct BitSet {
    ints: [u128; 8],
}

impl BitSet {
    fn new() -> Self {
        Self {
            ints: [0; 8],

Lisoph

fn main() {
    let digits: Vec<_> = INPUT.chars().map(|c| char::to_digit(c, 10).unwrap()).collect();
    let step = digits.len() / 2;
    let mut acc = 0;
    
    for (i, d) in digits.iter().enumerate() {
        if let Some(x) = digits.iter().cycle().skip(i).nth(step) {
            if d == x {
                acc += d;
            }

Lisoph

fn main() {
    let input = r#"pphsv ojtou brvhsj cer ntfhlra udeh ccgtyzc zoyzmh jum lugbnk
vxjnf fzqitnj uyfck blnl impo kxoow nngd worcm bdesehw
caibh nfuk kfnu llfdbz uxjty yxjut jcea
qiho qif eupwww avyglnj nxzotsu hio lws
xjty usocjsh pivk qnknunc yjcgh bwya djw zpyr
ycfmfe mgq sjiomg nfzjul bjwkmgu yvsnvgj dcjupu wzz blmn
rdowgbt vpwfdoi blzl laghnk gsa vhnpo cztxzlb rtz hvwonhb eciju pfjtbo
bqs bqs dbutvgf mmzb izpyud rap izpyud xlzeb mnj hjncs
xpu vwp nujcos piu irindir tpmfd umtvlm gznu

Lisoph

#[derive(Debug, PartialEq, Copy, Clone)]
enum Dir {
    Up,
    Down,
    Left,
    Right,
}

#[derive(Clone, Copy, PartialEq)]
struct Point {

Lisoph

#![feature(conservative_impl_trait)]

use std::cmp::PartialEq;

type ParseResult<T, I: Iterator<Item = T>> = Result<ParseStatus<T, I>, ParseError>;

#[derive(Debug)]
enum ParseStatus<T, I: Iterator<Item = T>> {
    Ok(Vec<T>, I),
    NeedMoreData(usize), // # of units needed

Lisoph

use std::collections::HashSet;
use std::cell::RefCell;
use std::rc::Rc;

struct WidgetRef(Rc<RefCell<Box<Widget>>>);

impl WidgetRef {
    fn new(inner: Rc<RefCell<Box<Widget>>>) -> Self {
        WidgetRef(inner)
    }

Lisoph

struct Event<'a> {
    handlers: Vec<Box<FnMut() + 'a>>,
}

impl<'a> Event<'a> {
    fn new() -> Self {
        Self {
            handlers: Vec::new(),
        }
    }

Lisoph

enum MouseButton {
    Left,
    Middle,
    Right,
}

enum UiEvent {
    MouseMove(i32, i32),
    MouseClicked(i32, i32, MouseButton),
}

Lisoph

#![feature(conservative_impl_trait)]

fn take<'a>(take: &'a str) -> impl Fn(&'a str) -> (&'a str, &'a str) {
    move |input| {
        let len = input.chars().zip(take.chars()).take_while(|&(i, t)| i == t).count();
        (&input[0..len], &input[len..])
    }
}

fn chain<'a, F1, F2>(first: F1, second: F2) -> impl Fn(&'a str) -> ((&'a str, &'a str), &'a str)