mdwhatcott

package humanize

import (
	"fmt"
	"strings"
)

// Comma formats a number with commas separating each block of 3 numbers.
// Inspiration: https://pkg.go.dev/github.com/dustin/go-humanize#Comma
func Comma(n int) string {

mdwhatcott

func index[K comparable, V any](list []V, key func(V) K) map[K]V {
	result := make(map[K]V)
	for _, value := range list {
		result[key(value)] = value
	}
	return result
}

mdwhatcott

func GetOrSetDefault[K comparable, V any](m map[K]V, key K, new_ func() V) V {
	value, found := m[key]
	if !found {
		value = new_()
		m[key] = value
	}
	return value
}

/*

mdwhatcott

package should

import (
	"fmt"
	"log"
	"reflect"
	"runtime"
)

type assertion func(actual any, expected ...any) error

mdwhatcott

// Package should info: github.com/mdwhatcott/testing@v0.19.0 (a little copy-paste is better than a little dependency)
// AUTO-GENERATED: 2022-12-27 23:56:46.913568 -0700 MST m=+0.004900728
package should

import (
	"errors"
	"fmt"
	"log"
	"math"
	"reflect"

mdwhatcott

package assert

import (
	"reflect"
	"testing"
)

// That allows assertions as in: assert.That(t, actual).Equals(expected)

func That(t *testing.T, actual interface{}) *assertion {

mdwhatcott

#lang racket

(require rackunit)
(require "bowling.rkt")

(define (roll-many times roll)
  (for/list ([i times]) roll))

(test-equal? "Gutter Game" 0 (score (roll-many 20 0)))
(test-equal? "All Ones"    20 (score (roll-many 20 1)))

mdwhatcott

(ns kata.life)

(defn neighbors-of [[x y]]
  (for [Y (range (dec y) (+ 2 y))
        X (range (dec x) (+ 2 x))
        :when (not= [x y] [X Y])] [X Y]))

(defn count-active-neighbors [cell grid]
  (->> cell neighbors-of set (filter grid) count))

mdwhatcott

(ns hello-quil.grid
  (:require [quil.core :as q]
            [quil.middleware :as m]))

(defn hovering? [{:keys [x y width mark] :as cell}]
  (let [x2 (+ x width)
        y2 (+ y width)
        mx (q/mouse-x)
        my (q/mouse-y)]
    (and (nil? mark)

mdwhatcott

(ns factors.core-spec
  (:require [speclj.core :refer :all]
            [factors.core :refer :all]))

(defn factors-of [n]
  (loop [n n, d 2, fs []]
    (cond (= n 1) fs
          (zero? (mod n d)) (recur (/ n d) d (conj fs d))
          :else (recur n (inc d) fs))))