expressive-switch

Expressive Switch

Use switch statements with a custom comparison expression. Goodbye switch(true)!

Very small library with no dependencies.

const switchPair = require('expressive-switch');

// Set up the closure and return the helper functions
const [s, c] = switchPair();

const subject = "I love horses";

switch(s(testCase => subject.indexOf(testCase) > -1)) {
	case c('ducks'):
		// This one does't match
		console.log("Someone's talking about ducks");
		break;
	case c('horses'):
		// This one matches!
		console.log("Someone's talking about horses");
		break;
	default:
		// Fallback for no matches
		console.log("Who knows?");
}

Uses

Error checking

function handleError(error) {
	const [s, c] = switchPair();

	switch(s(cls => error instanceof cls)) {
		case c(NotFoundError):
			return 'Page not found!';
		case c(TypeError):
			return 'Provided the wrong type!'
		default:
			// Don't know what the problem is, throw it
			throw error;
	}
}

URL routing

function routeRequest(url) {
	const [s, c] = switchPair();
	let args;

	switch(s(regex => args = url.match(regex))) {
		case c(/^\/$/):
			return HomePageComponent();
		case c(/^\/photos\/([0-9]+)$/):
			return PhotographComponent({ photoId: args[1] });
		default:
			return PageNotFoundComponent();
	}
}

Shape checking

function castResponseObject(object) {
	// Alternative syntax - specify the subject and predicate separately
	const [shapeOf, hasKey] = switchPair((key, subject) => key in subject);

	switch(shapeOf(object)) {
		case hasKey('error'):
			return new Error(object.error);
		case hasKey('value'):
			return object.value;
		default:
			return object;
	}
}

How does it work?

s saves your predicate function in a closure and returns a symbol.

c calls the predicate function with the test case value and returns the same symbol if the predicate returns truthy.

As far as switch is concerned, it's dealing with a symbol. As far as case is concerned, it's dealing with that same symbol or null.

TC39 Proposal

What if this was more concise and part of the javascript core language?

function handleError(error) {
	switch(error instanceof case) {
		case NotFoundError:
			return 'Page not found!';
		case TypeError:
			return 'Provided the wrong type!'
		default:
			throw error;
	}
}

Maybe it could be!