Adev-monads NPM

ADev Monads 🚀

ADev Monads is a lightweight functional utility library based on monads. It provides types and functions to work with structures such as Option, Maybe, Either, and others, making data flows safer and composable.

✨ Features

⚡ Lightweight and Modular: Designed for easy extension with new types.
🛠️ TypeScript Support: Fully typed for greater development safety.
🌟 Efficient: Optimized implementations with no external dependencies.
🔦 Focus on Simplicity: Easy-to-use utilities.

📦 Installation

Use npm or yarn to install the package:

npm install adev-monads

Or with yarn:

yarn add adev-monads

🚀 Quick Start

🧹 Working with `Option`

The Option type allows you to handle values that may be present (some) or absent (none).

import { Option } from 'adev-monads';

const value = Option.some(42);

// Check if a value is present
if (value.isSome()) {
  console.log('Value present:', value);
} else {
  console.log('No value');
}

// Transform the value if present
const transformed = value.map((x) => x * 2);
console.log('Transformed:', transformed.getOrElse(0));

📚 Full API

`Option`

🛠️ Constructor

Option.some<T>(value: T): Option<T>: Creates an Option instance with a present value.
Option.none<T>(): Option<T>: Creates an Option instance without a value (absent).

🚨 Main Methods

isNone(): boolean: Returns true if the value is none.
isSome(): boolean: Returns true if the value is some.
map(fn: (value: T) => U): Option: Applies a function to the value if present.
flatMap(fn: (value: T) => Option): Option: Similar to map, but avoids nested values.
getOrElse(defaultValue: T): T: Gets the value or returns a default value.
filter(predicate: (value: T) => boolean): Option<T>: Filters the value based on a predicate.
fold<U, V>(ifNone: () => U, fn: (value: T) => V): U | V: Handles both cases (some and none).

Full Example

const option = Option.some(10);
const result = option
  .filter((x) => x > 5)
  .map((x) => x * 2)
  .getOrElse(0);

console.log(result); // 20

📝 `Writer` Monad

The Writer monad represents a computation that produces a value along with a log. It's useful in scenarios where you need to track a sequence of messages or actions (e.g., logging, debugging) alongside the result of the computation.

Constructor

Writer.of<T, W>(value: T, log: W[] = []): Writer<T, W>: Creates an instance of Writer with a value and an optional log.
Writer.tell<W>(message: W): Writer<null, W>: Creates a Writer instance with a log message and no value.

Main Methods

map(fn: (value: T) => U): Writer<U, W>: Transforms the value inside the Writer using the provided function.
flatMap(fn: (value: T) => Writer<U, W>): Writer<U, W>: Similar to map, but the function returns a new Writer, combining logs.
fold(onValue: (value: T) => U, onLog: (log: W[]) => void): U: Processes both the value and the log with the provided functions.
getValue(): T: Retrieves the value inside the Writer.
getLog(): W[]: Retrieves the log associated with the Writer.

Example

import { Writer } from 'adev-monads';

const writer = Writer.of(42, ['initial log']);
const newWriter = writer.map(x => x * 2);
const finalWriter = newWriter.flatMap(x => Writer.of(x + 5, ['calculation complete']));

console.log(finalWriter.getValue()); // 89
console.log(finalWriter.getLog()); // ['initial log', 'calculation complete']