simple-functional-style-helper v2.0.0

simple-functional-style-helper

Zero-dependency functional programming toolkit for building robust JavaScript applications.

Features

Maybe Monad

Handle null-safe operations elegantly:

• Maybe.just(value): Wrap a value
• Maybe.nothing(): Represent absence of value
• map/flatMap: Transform values safely
• Pattern matching with just and nothing cases

Either Monad

Elegant error handling with left/right cases:

• Either.right(value): Success case
• Either.left(error): Error case
• map/flatMap: Transform success cases
• mapLeft: Transform error cases
• Built-in try/catch wrapper

Result Monad

Predictable error management:

• Result.success(value): Success state
• Result.failure(error): Failure state
• Error propagation with map/flatMap
• Safe error handling with mapError
• Automatic try/catch wrapping

SafeWrapper

Secure object property access:

• Deep nested property access
• Null-safe operations
• Path existence checking
• Schema validation
• Pattern matching

ModuleLoader

Dynamic module loading with parameter passing:

• Load all modules from a directory
• Pass parameters to module initializers
• Safe module loading with error handling
• Clean functional interface

Installation

npm install simple-functional-style-helper

Usage

import { Maybe, Either, Result, SafeWrapper } from 'simple-functional-style-helper'

// Maybe example
const maybeValue = Maybe.from(someNullableValue)
  .map(x => x * 2)
  .getOrElse(0)

// Either example
const result = Either.try(() => riskyOperation())
  .map(value => process(value))
  .getOrElse(defaultValue)

// Result example
const computation = Result.try(() => compute())
  .map(value => transform(value))
  .mapError(err => handleError(err))

// SafeWrapper example
const wrapper = SafeWrapper.of(complexObject)
const value = wrapper.get('deeply.nested.property')
  .map(val => transform(val))
  .getOrElse(defaultValue)

API Documentation

Maybe

• just(value): Create a Maybe with a value
• nothing(): Create an empty Maybe
• from(value): Create Maybe from nullable value
• map(fn): Transform value if present
• flatMap(fn): Chain transformations
• getOrElse(default): Get value or default
• match({ just, nothing }): Pattern matching

Either

• right(value): Create right (success) case
• left(error): Create left (error) case
• try(fn): Wrap function in try/catch
• map(fn): Transform right value
• mapLeft(fn): Transform left value
• flatMap(fn): Chain operations
• fold(leftFn, rightFn): Handle both cases

Result

• success(value): Create success state
• failure(error): Create failure state
• try(fn): Auto try/catch wrapper
• map(fn): Transform success value
• mapError(fn): Transform error
• flatMap(fn): Chain operations
• getOrThrow(): Get value or throw

SafeWrapper

• of(object): Create wrapper
• get(path): Safe property access
• has(path): Check path existence
• hasAll(paths): Check multiple paths
• hasAny(paths): Check any path exists
• validate(schema): Validate object structure

License

GPL-3.0