trvswgnr

export const ARGS = Symbol("args");
export type ARGS = typeof ARGS;

export const TYPE = Symbol("type");
export type TYPE = typeof TYPE;

export const _F = Symbol("F");
export type _F = typeof _F;

interface Parameterized<Args extends readonly unknown[]> {

trvswgnr

const pipe = <T>(value: T) => {
    let fns: Array<(x: any) => unknown> = [];
    let cached: { v: T } | undefined = undefined;
    const self = {
        to: <U>(f: (v: T) => U) => {
            fns.push((x: T) => f(x));
            return self as unknown as ReturnType<typeof pipe<U>>;
        },
        run: (): T => {
            if (cached) return cached.v;

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',