DevWurm/Problems.md

## example.ts
// import match.ts

// weired types
class Nums {
    a: number = 2
    b(): number {
        return 7;
    }
}

type numeric = number | number[] | Nums

// function for extracting a basic number from a numeric type
function extract(n: numeric): number {
    // matching by type constructor
    if (match(n, Array)) {
        return n[0];
    }
    // matching by type compliant literal (possible, but not reccomended in favot of readability)
    else if (match(n, 7)) {
        return n;
    }
    // matching by type complienat object literal
    else if (match(n, { a: 1, b: () => 7 })) {
        return n.a + n.b();
    }
    else {
        return NaN;
    }
}

alert(`Expecting 7.123: ${extract(7.123)}`);
alert(`Expecting 4: ${extract([4, 3, 2, 1])}`);
alert(`Expecting 9: ${extract(new Nums())}`);
alert(`Expecting 3: ${extract({ a: 0, b: () => 3 })}`);

## match.ts
function match<T>(o: any, ref: {new(...args : any[]): T} | T): o is T  {
    let oObject: Object;
    switch (typeof o) {
        case 'boolean': oObject = new Boolean(o); break;
        case 'number': oObject = new Number(o); break;
        case 'string': oObject = new String(o); break;
        case 'undefined': return ref === undefined;
        default: oObject = o;
    }

    if (isConstructor(ref)) {
        return (
            oObject instanceof ref
            ||
            Object.getOwnPropertyNames(ref.prototype)
                .reduce((acc, curr) => (curr in oObject) && acc, true)
        )
    } else {
        return (
            Object.getOwnPropertyNames(Object.getPrototypeOf(ref))
                .reduce((acc, curr) => (curr in oObject) && acc, true)
        )
    }

}

function isConstructor<T>(x: { new (...args : any[]): T } | T): x is { new (): T } {
    return Boolean((<{ new (): T }> x).prototype);
}

## Problems.md

      
    Raw
  

              Problems.md
            
          
    Problems


can't decide between different array types (solution idea: if the reference array is not empty, test the first element against the first element of the test element)
	// import match.ts

	// weired types
	class Nums {
	a: number = 2
	b(): number {
	return 7;
	}
	}

	type numeric = number \| number[] \| Nums

	// function for extracting a basic number from a numeric type
	function extract(n: numeric): number {
	// matching by type constructor
	if (match(n, Array)) {
	return n[0];
	}
	// matching by type compliant literal (possible, but not reccomended in favot of readability)
	else if (match(n, 7)) {
	return n;
	}
	// matching by type complienat object literal
	else if (match(n, { a: 1, b: () => 7 })) {
	return n.a + n.b();
	}
	else {
	return NaN;
	}
	}

	alert(`Expecting 7.123: ${extract(7.123)}`);
	alert(`Expecting 4: ${extract([4, 3, 2, 1])}`);
	alert(`Expecting 9: ${extract(new Nums())}`);
	alert(`Expecting 3: ${extract({ a: 0, b: () => 3 })}`);
	function match<T>(o: any, ref: {new(...args : any[]): T} \| T): o is T {
	let oObject: Object;
	switch (typeof o) {
	case 'boolean': oObject = new Boolean(o); break;
	case 'number': oObject = new Number(o); break;
	case 'string': oObject = new String(o); break;
	case 'undefined': return ref === undefined;
	default: oObject = o;
	}

	if (isConstructor(ref)) {
	return (
	oObject instanceof ref
	\|\|
	Object.getOwnPropertyNames(ref.prototype)
	.reduce((acc, curr) => (curr in oObject) && acc, true)
	)
	} else {
	return (
	Object.getOwnPropertyNames(Object.getPrototypeOf(ref))
	.reduce((acc, curr) => (curr in oObject) && acc, true)
	)
	}

	}

	function isConstructor<T>(x: { new (...args : any[]): T } \| T): x is { new (): T } {
	return Boolean((<{ new (): T }> x).prototype);
	}