jjhiggz

// Define individual animal types
type Dog = {
  type: "dog";
  name: string;
  sound: "bark";
};

type Cat = {
  type: "cat";
  name: string;

jjhiggz

import { uniqueBy } from "remeda";
import { SuperMap } from "./SuperMap.ts";

export class Graph<T> {
  adjacencyList: SuperMap<T, T[]>;
  private serialize: (input: T) => string;
  private deserialize: (input: string) => T;
  private printVal: (input: T) => any;

  constructor(

jjhiggz

import { piped } from "remeda";
import z from "zod";

const getBlocks = piped(
    (a: string) => a.split(""),
    (a) =>
        a.map((char, index) => {
            const isEven = index % 2 === 0;

            const charValue = z.number().parse(+char);

jjhiggz

import { buildMatrix } from "./build-matrix";

describe("Build Matrix", () => {
  it("Should turn my shit into matrix of rows", () => {
    expect(
      buildMatrix({
        // prettier-ignore
        elements: [
                1/1,
                1/3, 2/3,

jjhiggz

function reduce<T, U>(
  arr: T[], 
  reducer: (acc: U, currentValue: T, index: number, array: T[]) => U, 
  initialValue: U, 
  index: number = 0
): U {
  // Base case: if the index is out of bounds, return the accumulated value
  if (index >= arr.length) {
    return initialValue;
  }

jjhiggz

const at = <T,>(arr: T[], index: number) => index < 0 
    ? arr[arr.length + index] 
    : arr[index];

let recursiveFibCount = 0
const rFibonnaci = (num = 1, prevSeq: number[] = [0]): number => {
    if(prevSeq.length === num) {
       return at(prevSeq, -1)
    } 
    if(prevSeq.length === 1) return rFibonnaci(num, [0, 1])

jjhiggz

function moveAllInstancesToEnd<T extends any[] | string>(
    input: T, 
    shouldMoveCb: (input: T[number]) => unknown
): T {
   if(Array.isArray(input)){
    let notMoved: any = [] 
    let moved: any = []
    for(let el of input){
        if(shouldMoveCb(el)){
              moved.push(el)

jjhiggz

const getCounts = <T,>(
    input: Iterable<T>,
    shouldCountCb: (input: T) => unknown,
    serializeKey: (input: T) => any = input => input,
) => {
     let counts = {} as Record<any, number>
     for(let val of input){
        if(shouldCountCb(val)){
         counts[serializeKey(val)] = (counts[serializeKey(val)] ?? 0) + 1
        }

jjhiggz

export const Accordion = (
  {
     children, 
     show
  } : {
     children: ReactNode, 
     show: boolean
  }
) => {
return show ? 

jjhiggz

const result = <T,E extends Error>(cb: () => T): [null, E] | [T, null] => {
    try {
        return [cb(), null]
    } catch(e){
       return [null,e as E]
    }
}
const failsSometimes = () => {
    if(Math.random() > .5){
        throw new Error("Failed")