reu

export type Rational = {
  numerator: number;
  denominator: number;
  simplify: () => Rational;
  add: (other: Rational) => Rational;
  sub: (other: Rational) => Rational;
  mul: (other: Rational) => Rational;
  div: (other: Rational) => Rational;
  valueOf: () => number;
  toString: () => string;

reu

use std::{
    borrow::Borrow,
    collections::{BTreeSet, HashMap},
    hash::Hash,
};

pub struct LFUCache(Lfu<i32, i32>);

// This is the Leetcode API we have to implement
impl LFUCache {

reu

use std::{
    io::{self, Read, Write},
    net::{TcpListener, TcpStream},
    os::fd::{AsRawFd, RawFd},
    thread,
};

const READ: libc::c_short = libc::POLLRDNORM;
const WRITE: libc::c_short = libc::POLLWRNORM;

reu

set -g default-terminal "screen-256color"
set -g terminal-overrides 'xterm*:smcup@:rmcup@'
set-option -sa terminal-overrides ",xterm*:Tc"

set -s escape-time 10
setw -g xterm-keys on
set -g mouse on
setw -g mode-keys vi
unbind -n -Tcopy-mode-vi MouseDragEnd1Pane
set -g base-index 1

reu

import {
  any,
  char,
  delimited,
  int,
  many0,
  map,
  multispace0,
  nat,
  parse,

reu

require "set"

class Sig
  def initialize(&computation)
    @observers = Set.new
    @dependencies = Set.new
    @computation = computation || proc { nil }
    compute if block_given?
  end

reu

use std::ops::{Div, Sub};

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Month {
    Jan = 1,
    Feb = 2,
    Mar = 3,
    Apr = 4,
    Mai = 5,
    Jun = 6,

reu

use std::any::{Any, TypeId};
use std::collections::HashMap;

#[derive(Default)]
pub struct AnyMap {
    map: HashMap<TypeId, Box<dyn Any>>,
}

impl AnyMap {
    pub fn insert<T: 'static>(&mut self, t: T) {

reu

use std::mem;

#[derive(Debug, PartialEq)]
pub enum List<T> {
    Empty,
    Cons(T, Box<List<T>>),
}

impl<T> List<T> {
    pub fn new() -> Self {

reu

async function* promisesIter(promises) {
  promises = [...promises];
  const buffer = [];
  for (promise of promises) {
    promise.then(result => {
      promises.splice(promises.indexOf(promise), 1);
      buffer.push(result);
    });
  }
  while (promises.length === 0 || await Promise.race(promises).then(() => true)) {