TypeScriptの正規表現にマシな型をつける ref: http://qiita.com/mod_poppo/items/4549dcfa16ae99ebf126

file0.txt

let m = str.match(/(a)(b)?/);
if (m) {
    let a: string = m[1];
    let b: string = m[2]; // 本当は string | undefined
}

file1.txt

let str = "x\\yz";
let t = str.replace(/\\(.)/, (m, s) => s.toUpperCase());
// s は any 型なので、仮に s.toUpper() と書いてもエラーにならない

file10.txt

interface String {
    match<captures extends SList>(regexp: TypedRegExp<captures>): TypedRegExpMatchArray<captures> | null;
    replace<a0, a1, a2>(searchValue: TypedRegExp<SCons<a0, SCons<a1, SCons<a2, SNil>>>>, replacer: (match: string, a0: a0, a1: a1, a2: a2, offset: number, string: string) => string): string;
    replace<a0, a1>(searchValue: TypedRegExp<SCons<a0, SCons<a1, SNil>>>, replacer: (match: string, a0: a0, a1: a1, offset: number, string: string) => string): string;
    replace<a0>(searchValue: TypedRegExp<SCons<a0, SNil>>, replacer: (match: string, a0: a0, offset: number, string: string) => string): string;
    replace(searchValue: TypedRegExp<SNil>, replacer: (match: string, offset: number, string: string) => string): string;
}

file2.txt

type SNil = {
    "tag": "Nil";
};
type SCons<a, b extends SList> = {
    "tag": "Cons";
    "head": a;
    "tail": b;
};
type SList = SNil | {
    "tag": "Cons";
    "head": any;
    "tail": SList;
};
// type SList = SNil | SCons<any, SList>; とは書けないが、上のようには書ける

// リストの連結
type Concat<a extends SList, b extends SList> = {
    "Nil": b;
    "Cons": SCons<a["head"], Concat<a["tail"], b>>;
}[a["tag"]];

// リストの要素を全て undefined で置き換える
type FillUndefined<a extends SList> = {
    "Nil": SNil;
    "Cons": SCons<undefined, FillUndefined<a["tail"]>>;
}[a["tag"]];

// リストの要素に対して | undefined を行う
type MaybeUndefined<a extends SList> = {
    "Nil": SNil;
    "Cons": SCons<a["head"] | undefined, MaybeUndefined<a["tail"]>>;
}[a["tag"]];

file3.txt

// error TS2322: Type '0' is not assignable to type 'SCons<"a", SCons<"b", SCons<"c", SCons<"d", SNil>>>>'.
let x : Concat<SCons<"a", SCons<"b", SNil>>, SCons<"c", SCons<"d", SNil>>> = 0; 

// error TS2322: Type '0' is not assignable to type 'SCons<undefined, SCons<undefined, SCons<undefined, SNil>>>'.
let y : FillUndefined<SCons<string, SCons<number, SCons<null, SNil>>>> = 0;

// error TS2322: Type '0' is not assignable to type 'SCons<string | undefined, SCons<number | undefined, SCons<null | undefined, SNil>>>'.
let z : MaybeUndefined<SCons<string, SCons<number, SCons<null, SNil>>>> = 0;

file4.txt

type ToTuple5<a0, a1, a2, a3, a4, a extends SList> = {
    "Nil": [a0, a1, a2, a3, a4];
    "Cons": [a0, a1, a2, a3, a4, a["head"]]; // a["tail"] is dropped...
}[a["tag"]];
type ToTuple4<a0, a1, a2, a3, a extends SList> = {
    "Nil": [a0, a1, a2, a3];
    "Cons": ToTuple5<a0, a1, a2, a3, a["head"], a["tail"]>;
}[a["tag"]];
type ToTuple3<a0, a1, a2, a extends SList> = {
    "Nil": [a0, a1, a2];
    "Cons": ToTuple4<a0, a1, a2, a["head"], a["tail"]>;
}[a["tag"]];
type ToTuple2<a0, a1, a extends SList> = {
    "Nil": [a0, a1];
    "Cons": ToTuple3<a0, a1, a["head"], a["tail"]>;
}[a["tag"]];
type ToTuple1<a0, a extends SList> = {
    "Nil": [a0];
    "Cons": ToTuple2<a0, a["head"], a["tail"]>;
}[a["tag"]];
type ToTuple<a extends SList> = {
    "Nil": [];
    "Cons": ToTuple1<a["head"], a["tail"]>;
}[a["tag"]];

file5.txt

type TypedRegExpExecArray<captures extends SList> = ToTuple<SCons<string, captures>> & {index: number; input: string};
type TypedRegExpMatchArray<captures extends SList> = ToTuple<SCons<string, captures>> & {index?: number; input?: string};

file6.txt

type ToFunction5<r, a0, a1, a2, a3, a4, a extends SList> = {
    "Nil": (a0: a0, a1: a1, a2: a2, a3: a3, a4: a4) => r;
    "Cons": (a0: a0, a1: a1, a2: a2, a3: a3, a4: a4, a5: a["head"]) => r; // a["tail"] is dropped...
}[a["tag"]];
type ToFunction4<r, a0, a1, a2, a3, a extends SList> = {
    "Nil": (a0: a0, a1: a1, a2: a2, a3: a3) => r;
    "Cons": ToFunction5<r, a0, a1, a2, a3, a["head"], a["tail"]>;
}[a["tag"]];
type ToFunction3<r, a0, a1, a2, a extends SList> = {
    "Nil": (a0: a0, a1: a1, a2: a2) => r;
    "Cons": ToFunction4<r, a0, a1, a2, a["head"], a["tail"]>;
}[a["tag"]];
type ToFunction2<r, a0, a1, a extends SList> = {
    "Nil": (a0: a0, a1: a1) => r;
    "Cons": ToFunction3<r, a0, a1, a["head"], a["tail"]>;
}[a["tag"]];
type ToFunction1<r, a0, a extends SList> = {
    "Nil": (a0: a0) => r;
    "Cons": ToFunction2<r, a0, a["head"], a["tail"]>;
}[a["tag"]];
type ToFunction<r, a extends SList> = {
    "Nil": () => r;
    "Cons": ToFunction1<r, a["head"], a["tail"]>;
}[a["tag"]];

file7.txt

// interface TypedRegExp<> extends RegExp では 'exec' の型が違うと言われて怒られた、ので交差型を使う
type TypedRegExp<captures extends SList> = {
    exec(string: string): TypedRegExpExecArray<captures> | null;
} & RegExp; /* RegExp が & の後でないとメソッドの型を上書きできないようなので注意 */

interface String {
    match<captures extends SList>(regexp: TypedRegExp<captures>): TypedRegExpMatchArray<captures> | null;
    replace<captures extends SList>(searchValue: TypedRegExp<captures>, replacer: ToFunction<string, SCons<string, Concat<captures, SCons<number, SCons<string, SNil>>>>>): string;
}

file8.txt

let str = "abc"
let m = str.match(/(a)(b)?/ as TypedRegExp<SCons<string, SCons<string | undefined, SNil>>>);
if (m) {
    let a: string = m[1];
    let b: string = m[2]; // --strictNullChecks でエラー
}

file9.txt

let str = "x\\yz";
let t = str.replace(/\\(.)/ as TypedRegExp<SCons<string, SNil>>, (m, s) => s.toUpper()); // エラーにならない！
console.log(t);