purify-ts

To use this starter, you must first have the Gatsby CLI installed globally. You can then create a new site using the gatsby new command.

npm install --global gatsby-cli

gatsby new gatsby-example-site

Purify is available as an npm package. You can install it using your preferred package manager to start using functional programming patterns in your TypeScript project.

$ npm install purify-ts

$ yarn add purify-ts

After creating your site, navigate into the project directory and use npm run develop to start the local development server.

cd gatsby-example-site
npm run develop

The Maybe<T> type is a container used to represent an optional value that may or may not exist. It has two states:

• Just(value): Represents a present value of type T.
• Nothing: Represents the absence of a value.

This type provides a functional way to handle nullability and optionality without explicit null checks, using methods like map, chain, and orDefault to transform or recover values safely.

The Either<L, R> type represents a value that can be one of two types: Left (conventionally used for errors or failures) or Right (conventionally used for successful values). It provides a functional way to chain computations and handle errors without using try/catch blocks everywhere.

Key methods for transforming values:

• map(f): Transforms the Right value if present.
• mapLeft(f): Transforms the Left value if present.
• bimap(f, g): Transforms both Left and Right values using different functions.
• chain(f): Chains computations that return another Either (monadic bind).
• caseOf(patterns): Performs structural pattern matching.

To create an Either, use the Left and Right constructors.

Purify provides combinators to build complex validation logic from simple codecs:

• oneOf(...codecs): Returns a codec that succeeds if any of the provided codecs succeed. If all fail, it returns a combined error message.
• nullable<T>(codec): A codec that accepts either the provided codec or null.
• optional<T>(codec): A codec that accepts either the provided codec or undefined. This is specifically designed for use within Codec.interface to mark properties as optional.
• intersect(codecA, codecB): Creates an intersection. For objects, it merges the results of both codecs.

You can test the contents of a tuple using every and some:

• every(pred): Returns true if the predicate pred returns true for both elements.
• some(pred): Returns true if the predicate pred returns true for at least one element.

The fanout method allows you to derive a tuple from a single input value using two different transformation functions. It supports three different usage patterns:

1. Immediate execution: Pass two functions and a value to get a Tuple immediately.
2. Function composition: Pass two functions to get a new function that accepts a value and returns a Tuple.
3. Curried composition: Pass one function to get a higher-order function for building complex pipelines.

Use Codec.interface to define a codec for a structured object by providing a mapping of property names to their respective codecs. This automatically handles required/optional properties and generates a corresponding JSON Schema.

Note: To make a property optional in an interface, wrap its codec in optional().

Tuples provide several methods to transform their contents without mutating the original instance:

• mapFirst(f): Applies function f to the first element, returning a new Tuple<F2, S>.
• map(f): Applies function f to the second element, returning a new Tuple<F, S2>.
• bimap(f, g): Applies f to the first element and g to the second, returning a new Tuple<F2, S2>.
• swap(): Returns a new tuple with the elements in reverse order.