timruffles

timruffles

export type Operation<T, E> =
    typeof NotStarted |
    typeof Waiting |
    Complete<T> |
    Failed<E>

export enum OperationState {
    NotStartedState = 'NotStarted',
    WaitingState = 'Waiting',
    CompleteState = 'Complete',

timruffles

#!/bin/bash
#
# Usage: bash count_functions_loc.sh some/directory

set -euo pipefail

main() {
  for f in $(find $1 -name '*.go' -not -name 'test_*.go'); do
    count_funcs < "$f" | awk "{ print \"$f\", \$1, \$2 }"
  done

timruffles

# Gets an int between min max inclusive very inefficiently, but
# only using bash built-ins. More inefficient the smaller the gap
#
# usage: n=$( bad_random_int 1000 2000 )
bad_random_int() {
    local min=$1
    local max=$2

    local n=0
    while [[ "$n" -lt "$min" ]] || [[ "$n" -gt "$max" ]]; do

timruffles

package main

import "fmt"

func main() {
    type person struct {
        nickname string
    }

    ppl := []person{

timruffles

// Let's define a type with a method that needs a fair few arguments
type Thing struct {}

func (c *Thing) Verb(a A,b B,c C,d D) {}

// We have things that depend on Thing and we want to test them, so to mock it we'll need to 
// define an interface and generate a mock
type Thinger interface {
  Verb(a A,b B,c C,d D)
}

timruffles

SOURCE="github.com/you/thing"
FORK="github.com/other/thing"
PACKAGE="some-package"
CONSTRAINT="aabbcc"
dep ensure -add ${SOURCE}/${PACKAGE}:${FORK}.git@${CONSTRAINT}

timruffles

How Next.js responds to a page request with HTML

We create the next request handler function via app.getRequestHandler(). This returns a standard express handler, so we use it like expressApp.get('*', middlewareA(), middlewareB(), nextApp.getRequestHandler()).

When the handler is invoked:

• Server#handleRequest (next-server/server/lib/next-server.js)
  • Parses URL + query string if not already done
• Server#run
• Searches for matching route

timruffles

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdint.h>
#include <string.h>

/**
 * So, plan is to store the values for the JS compiler
 * in a union, nicking Lua's idea. That way immediate
 * values like numbers live inside the JSValue wrapper,

timruffles

// cast the strings as any
enum StringEnum {
	a = 'a' as any,
	b = 'b' as any,
}

const a = StringEnum.a;
const x = 'a';
const y = 1;