jcalz

RECIPE FOR STUFFED ARTICHOKES

by Joseph Calzaretta

INTRODUCTION

This is my version of a recipe I got from my mother, Nancy Calzaretta, which is a version of a recipe she got from her mother, Mary Crema. Presumably some version of this recipe goes back further into Italy somewhere? My mom made this with every Thanksgiving and Christmas meal,

jcalz

// I claim that the following regular expression should match a string if and only if
// it is composed of only the character "x", and
// its length is an even number greater than two which cannot be expressed as the sum of two prime numbers
// that is, if the length of the string is a counterexample to Goldbach's conjecture.
const r = /^(?!^(x*(?<!^(?:x?|\2+(xx+))))((?!(?:x?|(xx+?)\4+)$)x*)$)xx(xx)+$/;

console.log("start");
for (let i = 0; i < 1000; i++) {    
    const s = "x".repeat(i);
        if (r.test(s)) console.log(i)

jcalz

var N = 30;
var a = Array(N).fill(undefined).map((_, i) => i);
var out = [];

out.push("type Add = [" + a.map(i =>
    "[" + a.filter(j => (i + j) < N).map(j =>
        "'" + (i + j) + "'"
    ).join(",") + "]"
).join(",") + "];");
out.push("type Sub = [" + a.map(i =>

jcalz

interface NullSigil {
    [k: string]: NullSigil;
}

// phantom property to recover T from NullSafe<T>
type OriginalTypeKey = "***originalType***"

type IsNullable<T, Y, N> = null extends T ? Y :
    undefined extends T ? Y : N;

jcalz

var format = x => ((x+.5)*100).toFixed(4)+'%';
var f = ([[a,b],[c,d]]) => format(a)+' '+format(b)+', '+format(c)+' '+format(d);
var r = 1.5 - 0.5*Math.sqrt(5);
var th = Math.PI/2;
var pn = 2*Math.PI/5;

var R = .5;
var result=[0,1,2,3,4].map(k => 
  [[R*Math.cos(th+pn*(k-.5)),R*Math.sin(th+pn*(k-.5))],[r*R*Math.cos(th+pn*(k+0)),r*R*Math.sin(th+pn*(k+0))]]).map(f).join(', ');
console.log(result);

jcalz

function arrayDestruct
  (obj: any): never[];
function arrayDestruct<T, K0 extends keyof T>
  (obj: T, k0: K0): [T[K0]];
function arrayDestruct<T, K0 extends keyof T, K1 extends keyof T>
  (obj: T, k0: K0, k1: K1): [T[K0], T[K1]];
function arrayDestruct<T, K0 extends keyof T, K1 extends keyof T, K2 extends keyof T>
  (obj: T, k0: K0, k1: K1, k2: K2): [T[K0], T[K1], T[K2]];
function arrayDestruct<T, K0 extends keyof T, K1 extends keyof T, K2 extends keyof T>
  (obj: T, k0: K0, k1: K1, k2: K2): [T[K0], T[K1], T[K2]];

jcalz

function defined<T>(x: T | undefined): x is T {
  return typeof x !== 'undefined';
}

function hasKey<K extends string>(key: K, obj: any): obj is {[P in K]: any} {
  return key in obj;
}

function mark<T>(): T {
  return null! as T;

jcalz

You can use the tuple() function in tuple.ts to infer tuple types in TypeScript and cut down on the need to repeat yourself. Without tuple(), declaring a constant of a tuple type looks like this:

const daysOfTheWeek: ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"] = 
  ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];

You can't do this:

const daysOfTheWeek = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"]; 

jcalz

type IBuilder<T> = {
  [k in keyof T]: (arg: T[k]) => IBuilder<T>
} & { build(): T }

function proxyBuilder<T>(): IBuilder<T> {
  var built: any = {};
  var builder = new Proxy({}, {
    get: function(target, prop, receiver) {
      if (prop === 'build') return () => built;
      return (x: any): any => {

jcalz

interface NumberConstructor {
  isNaN(x: any): boolean
}

namespace Collections {
  

  type Dictionary<T> = {
    [k: string]: T
  }