trvswgnr

// --- Type-level Utilities for Testing --- //
type Expect<T extends true> = T;
type Equal<X, Y> =
  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;

const discard = <T>(x: T): void => void x;

const getRandomValue = (): string | number | bigint | boolean | symbol | undefined => {
  const choices = ["foo", 1, 2n, true, Symbol("bar"), undefined];
  const index = Math.floor(Math.random() * choices.length);

trvswgnr

//! Higher-kinded types in Rust
//!
//! Functor, Applicative, and Monad traits
//!
//! Example implementations for custom Maybe type

// -- Trait Definitions -- //

/// A constructor for a type of a higher kind with one type parameter
pub trait TypeClass {

trvswgnr

#include <iostream>
#include <string>
#include <string_view>
#include <tuple>
#include <typeinfo>
#include <cstdio>
#include <vector>

std::vector<size_t> find_placeholders(const std::string_view& fmt) {
    std::vector<size_t> positions;

trvswgnr

#[derive(Debug)]
struct Pipe<T>(T);

impl<T> std::ops::Deref for Pipe<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

trvswgnr

// --- examples --- //

// happy path
const Priority = Enum("Low", "Normal", "High");
//    ^?
type Priority = Enum<typeof Priority>;
//   ^?

// invalid key starting with number
const InvalidPriority1 = Enum("1Low", "Normal", "High");

trvswgnr

# train_grpo.py
import re
import torch
from datasets import load_dataset, Dataset
from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import LoraConfig
from trl import GRPOConfig, GRPOTrainer

# Load and prep dataset

trvswgnr

/*
[dependencies]

*/

mod sealed {
    pub trait IsType<T: ?Sized> {}
    impl<T: ?Sized> IsType<T> for T {}
}

trvswgnr

type Op = '<<' | '&' | '|';

const Gift = {
  Coal: '0',
  Train: '1 << 0',
  Bicycle: '1 << 1',
  SuccessorToTheNintendoSwitch: '1 << 2',
  TikTokPremium: '1 << 3',
  Vape: '1 << 4',
  Traditional: 'Train | Bicycle',

trvswgnr

import type { Expect, Equal, IsAny, IsUnknown } from "type-testing";
import { Solution } from "./solution";

// biome-ignore lint/suspicious/noExplicitAny: <explanation>
type AnyArray = any[];

type PartialApplicationHelper<T extends AnyArray, R> = <A extends Partial<T>>(
  ...args: A
) => A extends AnyArray
  ? A["length"] extends T["length"]

trvswgnr

interface Service {
  ratio: number;
  name: string;
}

function assignNumWorkers(services: Service[], maxTotalWorkers: number): Map<string, number> {
  // sub 1 for the orchestrator
  const availableWorkers = maxTotalWorkers - 1;

  // calc total ratio sum