# @theweirdscience/casey

> A javascript functional approach to switch and if-else statements

Latest version **1.0.1** (published 2018-07-20) · MIT license · 0 weekly downloads

## Install

```sh
npm install @theweirdscience/casey
pnpm add @theweirdscience/casey
yarn add @theweirdscience/casey
bun add @theweirdscience/casey
```

## Health

**Score 25/100 (F)** — status: abandoned.

Positive: has types; no vulnerabilities; high quality score.

Warnings: low downloads; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.0.1 |
| Published | 2018-07-20 |
| First published | 2018-06-11 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | CommonJS |
| Dependencies | 0 |
| Unpacked size | 11 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 1 |
| Author | Merten van Gerven |
| Maintainers | merten.vg, olivier.h, oscarlodriguez, satyams |
| Keywords | casey, case, switch, if, else |

## Links

- npm: https://www.npmjs.com/package/@theweirdscience/casey
- Repository: https://github.com/theweirdscience/casey
- Homepage: https://github.com/theweirdscience/casey#readme
- Issues: https://github.com/theweirdscience/casey/issues
- npm.io page: https://npm.io/package/@theweirdscience/casey

## Alternatives

- [@mce/gif](https://npm.io/package/@mce/gif.md) — 2.6K weekly downloads
- [cleanse](https://npm.io/package/cleanse.md) — 173 weekly downloads
- [str](https://npm.io/package/str.md) — 127 weekly downloads
- [naming](https://npm.io/package/naming.md) — 95 weekly downloads
- [tap-telco-api](https://npm.io/package/tap-telco-api.md) — 19 weekly downloads

## Recent versions

- 1.0.1 (latest) — 2018-07-20
- 1.0.0 — 2018-06-11

## README

[![Build Status](https://travis-ci.org/theweirdscience/casey.svg?branch=master)](https://travis-ci.org/theweirdscience/casey)
[![Coverage Status](https://coveralls.io/repos/github/theweirdscience/casey/badge.svg?branch=master)](https://coveralls.io/github/theweirdscience/casey?branch=master)

# casey

A javascript functional approach to switch and if-else statements


## Installation

```
npm install --save @theweirdscience/casey
# or
yarn add @theweirdscience/casey
```

## Usage

You can always start by importing the module

```js
import casey from "@theweirdscience/casey";
```

Simple usage allows you to provide direct mappings from a condition value to a desired resulting value. An optional `default` may be provided for when there is no explicit match using strict `===` comparison.

```js
casey
  .case(1, "one")
  .case(2, "two")
  .case(3, "three")
  .default("not found")
  .match(2); // "two"
```

A slightly more advanced approach is to provide the custom matching functions and corresponding value generating functions. This can be useful when the conditions require more than a simple strict comparison or the values are resource/processor intensive to create. When a function is provided for the value it will automatically be called and the resulting value returned by `match`. Comparison functions may return any value to be checked for truthiness but a `boolean` value is recommended for transparency.

```js
casey
  .case(v => v === 1, () => "one")
  .case(v => v === 2, () => "two")
  .case(v => v === 3, () => "three")
  .default(() => "not found")
  .match(3); // "three"
```

In some less frequent cases you may wish to predetermine the desired result by providing a boolean value for the condition. In this form the same result will always be returned by `match` essentially overriding the provided default.

```js
const a = 5;
casey
  .case(a === 1, "one")
  .case(a === 2, "two")
  .case(a === 3, "three")
  .case(true, "other number")
  .default("not found")
  .match(); // "other number"
```

You can also add your cases in batches using the `map` function. Casey looks for the first possible match so duplicate conditions, though possible, will always result in the first possible match. `map` may be called multiple times to add more cases in batches.

```js
casey.map([[1, "one"], [2, "two"], [3, "three"]]).match(3); // "three"
```

In all scenarios you can mix the types of the conditions and the value as you please. They do not need to all be the same though the resulting code may make your eyes bleed.

Another advantage to using `casey` is the ability to provide the match function directly to an `Array.map()` function.

```js
const translate = casey
  .case(1, "one")
  .case(2, "two")
  .case(3, "three")
  .default("other");
[1, 2, 3, 4].map(translate.match); // ["one","two","three","other"]
```

## Testing

```
npm test
```

## Rationale

With functional programming becoming more and more prevalent the traditional if, elseif, else way of development starts to feel clunky and unnecessary.

```js
const value = 3;
let result = "";
if (value === 1) {
  result = "one";
} else if (value === 2) {
  result = "two";
} else if (value === 3) {
  result = "three";
} else {
  result = "other";
}
result; // "three"
```

is the same as

```js
const value = 3;
casey
  .case(1, "one")
  .case(2, "two")
  .case(3, "three")
  .default("other")
  .match(value); // "three"
```

---
_Source: https://npm.io/package/@theweirdscience/casey · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._