All Projects → phenax → Enum Fp

phenax / Enum Fp

Licence: mit
Functional Enum type / Sum type for javascript with simple pattern matching

Programming Languages

javascript
184084 projects - #8 most used programming language
js
455 projects
enum
40 projects

Projects that are alternatives of or similar to Enum Fp

Functionaljava
Functional programming in Java
Stars: ✭ 1,472 (+5351.85%)
Mutual labels:  algebraic-data-types, functional-programming
Remote Data Ts
RemoteData type
Stars: ✭ 185 (+585.19%)
Mutual labels:  algebraic-data-types, functional-programming
Cl Algebraic Data Type
Algebraic data types in Common Lisp
Stars: ✭ 86 (+218.52%)
Mutual labels:  algebraic-data-types, functional-programming
Imtools
Fast and memory-efficient immutable collections and helper data structures
Stars: ✭ 85 (+214.81%)
Mutual labels:  algebraic-data-types, functional-programming
Derive4j
Java 8 annotation processor and framework for deriving algebraic data types constructors, pattern-matching, folds, optics and typeclasses.
Stars: ✭ 511 (+1792.59%)
Mutual labels:  algebraic-data-types, functional-programming
Poica
🧮 A research programming language on top of C macros
Stars: ✭ 231 (+755.56%)
Mutual labels:  algebraic-data-types, functional-programming
Fluture
🦋 Fantasy Land compliant (monadic) alternative to Promises
Stars: ✭ 2,249 (+8229.63%)
Mutual labels:  algebraic-data-types, functional-programming
Lambda
Functional patterns for Java
Stars: ✭ 737 (+2629.63%)
Mutual labels:  algebraic-data-types, functional-programming
Whyhaskellmatters
In this article I try to explain why Haskell keeps being such an important language by presenting some of its most important and distinguishing features and detailing them with working code examples. The presentation aims to be self-contained and does not require any previous knowledge of the language.
Stars: ✭ 418 (+1448.15%)
Mutual labels:  algebraic-data-types, functional-programming
Scriptum
A fool's scriptum on functional programming
Stars: ✭ 346 (+1181.48%)
Mutual labels:  algebraic-data-types, functional-programming
Static Land
Specification for common algebraic structures in JavaScript based on Fantasy Land
Stars: ✭ 699 (+2488.89%)
Mutual labels:  algebraic-data-types, functional-programming
Purify
Functional programming library for TypeScript - https://gigobyte.github.io/purify/
Stars: ✭ 843 (+3022.22%)
Mutual labels:  algebraic-data-types, functional-programming
Puddles
Tiny vdom app framework. Pure Redux. No boilerplate.
Stars: ✭ 24 (-11.11%)
Mutual labels:  functional-programming
Mappy
A functional programming language. Like LISP but focused around maps rather than lists.
Stars: ✭ 10 (-62.96%)
Mutual labels:  functional-programming
Union Js
🏷️ Tagged unions for vanilla JavaScript!
Stars: ✭ 24 (-11.11%)
Mutual labels:  functional-programming
J8plus
Library containing useful tools for Java 8
Stars: ✭ 23 (-14.81%)
Mutual labels:  functional-programming
Bugz
🐛 Composable User Agent Detection using Ramda
Stars: ✭ 15 (-44.44%)
Mutual labels:  functional-programming
Goderive
Code Generation for Functional Programming, Concurrency and Generics in Golang
Stars: ✭ 848 (+3040.74%)
Mutual labels:  functional-programming
Proppy
Functional props composition for UI components (React.js & Vue.js)
Stars: ✭ 921 (+3311.11%)
Mutual labels:  functional-programming
Txmonad
A toy xmonad
Stars: ✭ 22 (-18.52%)
Mutual labels:  functional-programming

Enum-FP

Functional Enum type / Sum type for javascript with simple pattern matching

CircleCI npm bundle size (minified + gzip) Codecov

Checkout the docs for more information

Medium article on SumTypes using EnumFP

Install

To add the project to your project

yarn add enum-fp

Usage

Import it to your file

import Enum from 'enum-fp';

Create an enum type

const Action = Enum([ 'Add', 'Edit', 'Delete', 'Get' ]);

// Or with a fixed number of arguments
const Maybe = Enum({
    Just: [ 'value' ],
    Nothing: [],
});

Create an instance of the type using one of the contructors

const action = Action.Edit(2, 'Hello world and India');

Pattern matching

const Action = Enum([ 'Add', 'Edit', 'Delete', 'DeleteAll', 'Get' ]);

const logMessage = action => console.log('>>', 
  Action.match(action, {
    Edit: (id, message) => `Editing [${id}] to "${message}"`,
    Add: message => `Adding "${message}"`,
    Delete: id => `Deleting [${id}]`,
    DeleteAll: () => 'Deleting all entries',
    _: () => 'Unknown action', // To handle default cases, use _
  })
);

logMessage(Action.Add('Earth'));      // >> Adding "Earth"
logMessage(Action.Add('Earth 2'));    // >> Adding "Earth 2"
logMessage(Action.Add('Pluto'));
logMessage(Action.Add('Pluto'));       // >> Adding "Pluto1"
logMessage(Action.Edit(1, 'Mars'));   // >> Editing [2] to "Mars"
logMessage(Action.Delete(2));         // >> Deleting [3]
logMessage(Action.Add('Pluto'));      // >> Adding "Pluto"
logMessage(Action.DeleteAll());       // >> Deleting all entries

// As Get action is not handled in the pattern, it will execute the default
logMessage(Action.Get());             // >> Unknown action

Type validation

You can add strict type validation instead of argument descriptions. You can read more about types module here

import T from 'enum-fp/types';

const TodoAction = Enum({
  Add: [ T.String('message') ],
  SetChecked: [ T.Number('id'), T.Bool('isChecked') ],
  Delete: [ T.Number('id') ],
  Edit: [ T.Number('id'), T.String('message') ],
  DeleteAll: [],
});

NOTE: The string passed to the functions are just for documentation purposes and are optional. It won't affect the behavior of the type in any way.

Enum use cases

In the react world

You can use it to manage react component state! Checkout the documentation

Safely work with empty/invalid states

  • Working with invalid values
// Just an example. You should use `Maybe` functor in cases like these
const Value = Enum({ Invalid: [], Valid: ['value'] });

const extractName = user => user && user.name
  ? Value.Valid(user.name)
  : Value.Invalid();

const splitBySpace = Value.cata({
  Valid: name => name.split(' '),
  Invalid: () => [],
});

const getNameSplit = compose(splitBySpace, extractName);

const [ firstName, lastName ] = getNameSplit({ name: 'Akshay Nair' }); // >> returns ['Akshay','Nair']

In the functional world

If you are unfamiliar with functors, you can read Functors in JS blog post.

  • Maybe

Maybe functor is used to handle null.

const Maybe = Enum({ Just: ['value'], Nothing: [] });

const fmap = fn => Maybe.cata({
  Just: compose(Maybe.Just, fn),
  Nothing: Maybe.Nothing,
});
  • Either

Either functor is used for handling exceptions

const Either = Enum({ Left: ['error'], Right: ['value'] });

const fmap = fn => Either.cata({
  Left: Either.Left,
  Right: compose(Either.Right, fn),
});
const fmapFail = fn => Either.cata({
  Left: compose(Either.Left, fn),
  Right: Either.Right,
});
Note that the project description data, including the texts, logos, images, and/or trademarks, for each open source project belongs to its rightful owner. If you wish to add or remove any projects, please contact us at [email protected].