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
  }

jcalz

acceptors
accumulate
acknowledge
acolytes
acquitted
activates
addressing
adiabatically
adulthood
aerofoils