# Monadisk
Une bibliothèque TypeScript pour la gestion de monades avec des
transformations et des vérifications de types.
## Installation
```bash
pnpm add monadisk
```
## Caractéristiques
- Création de monades avec vérifications de types
- Transformations de données typées
- Combinaison de monades (AND/OR)
- Fonctions de vérification personnalisables
- Support TypeScript complet
## API
### `createMonad`
Crée une nouvelle monade avec des vérificateurs.
```typescript
const monad = createMonad(
['string', createCheck(data => typeof data === 'string')],
['number', createCheck(data => typeof data === 'number')],
);
```
### `createCheck`
Crée une fonction de vérification pour la monade.
```typescript
const stringCheck = createCheck(
data => typeof data === 'string',
);
```
### `transform`
Transforme les données selon les règles définies.
```typescript
const transform1 = transform(monad, {
string: data => `String: ${data}`,
number: data => `Number: ${data}`,
else: () => 'Unknown type',
});
```
### Méthodes d'un Monad
#### `add`
Ajoute un nouveau vérificateur à la monade.
```typescript
const newMonad = monad.add(
45,
createCheck(data => data === 45),
);
```
#### `and`
Combine deux monades avec une opération AND.
```typescript
const combinedMonad = monad1.and(monad2);
```
#### `or`
Combine deux monades avec une opération OR.
```typescript
const combinedMonad = monad1.or(monad2);
```
#### `mergeAnd`
Fusionne deux monades avec des clés combinées (AND).
```typescript
const mergedMonad = monad1.mergeAnd(monad2);
```
#### `mergeOr`
Fusionne deux monades avec des clés combinées (OR).
```typescript
const mergedMonad = monad1.mergeOr(monad2);
```
#### `parse`
Analyse une valeur et retourne la clé correspondante.
```typescript
const result = monad.parse(value);
```
## Exemple d'utilisation
```typescript
import { createMonad, createCheck, transform } from 'monadisk';
// Création d'une monade
const monad = createMonad(
['string', createCheck(data => typeof data === 'string')],
['number', createCheck(data => typeof data === 'number')],
[45, createCheck(data => data === 45)],
);
// Création d'un transformateur
const transformer = transform(monad, {
string: data => `Texte: ${data}`,
number: data => `Nombre: ${data}`,
45: data => `Nombre spécial: ${data}`,
else: () => 'Type inconnu',
});
// Utilisation
console.log(transform('hello')); // "Texte: hello"
console.log(transform(42)); // "Nombre: 42"
console.log(transform(45)); // "Nombre spécial: 45"
console.log(transform(true)); // "Type inconnu"
```
### Concat (very powerfull)
Concatène deux monades en combinant leurs vérificateurs avec le séparateur
`::`. Cette méthode crée une nouvelle monade où l'on combine les
vérificateurs des deux monades.
```typescript
// Exemple d'utilisation de concat
const monad1 = createMonad(
['string', createCheck(data => typeof data === 'string')],
['number', createCheck(data => typeof data === 'number')],
);
const monad2 = createMonad(
[45, createCheck(data => data === 45)],
['bool', createCheck(data => typeof data === 'boolean')],
);
// Crée une nouvelle monade avec les clés combinées:
// 'string::45', 'string::bool', 'number::45', 'number::bool'
const concatenated = monad1.concat(monad2);
// Utilisation avec transform
const transformer = transform(concatenated, {
// Ici, on a deux arguments
'string::45': (str, num) => `String ${str} avec nombre ${num}`,
'number::bool': (num, bool) => `Nombre ${num} avec booléen ${bool}`,
else: () => 'Combinaison non gérée',
});
// Cette méthode est utile quand vous voulez créer une monade qui vérifie plusieurs conditions indépendantes sur différents arguments.
```
### NB: transform retourne une erreur si le cas n'est pas pris en charge
```typescript
import { createMonad, createCheck, transform } from 'monadisk';
// Création d'une monade
const monad = createMonad(
['string', createCheck(data => typeof data === 'string')],
['number', createCheck(data => typeof data === 'number')],
[45, createCheck(data => data === 45)],
);
// Création d'un transformateur
const transformer = transform(monad, {
string: data => `Texte: ${data}`,
number: data => `Nombre: ${data}`,
45: data => `Nombre spécial: ${data}`,
// no else case
});
// Utilisation
console.log(transform('hello')); // "Texte: hello"
console.log(transform(42)); // "Nombre: 42"
console.log(transform(45)); // "Nombre spécial: 45"
console.log(transform(true)); // Will throws error `Case for "true" is not handled`
```
## Licence
MIT
## CHANGE_LOG
...
### Version [0.1.1] --> _2025/03/10 12:30_
- Upgrade deps
### Version [0.1.0] --> _2025/02/15 21:00_
- Release for better performance
### Version [0.0.7] --> _2025/02/01 21:00_
- Add helpers to simplify usage
### Version [0.0.6] --> _2025/01/30 16/00_
- Add option to concat monad
### Version [0.0.5] --> _2025/01/28 13:10_
- Upgrade deps
- Better testing (100% coverage)
### Version [0.0.4] --> _2025/01/28 11:10_
- La fonction `transform` génère une erreur si le cas n'est pas pris en
charge
### Version [0.0.3] --> _2025/01/28 11:10_
- 🐛 Correction des fautes de frappe dans les exemples
- Correction de `tarnsform` en `transform` dans les exemples de code
- Amélioration de la lisibilité des exemples
- 📝 Restructuration du CHANGELOG
- Ajout des dates de version
- Utilisation de balises `` pour le contenu
- Better testing : 100% coverage
### Version [0.0.1] --> _2025/01/28 02:02_
- ✨ Première version de la bibliothèque
- 🎉 Implémentation des fonctionnalités de base :
- Création de monades avec `createMonad`
- Création de vérificateurs avec `createCheck`
- Transformations avec `transform`
- Méthodes de combinaison (`and`, `or`, `mergeAnd`, `mergeOr`)
- Support complet de TypeScript
- 📝 Documentation initiale
- ⚡️ Tests unitaires de base
- 🔄 Ajout des méthodes de fusion avancées pour une meilleure gestion des
monades complexes
- Amélioration de la documentation des méthodes `mergeAnd` et `mergeOr`
- Optimisation des performances pour les opérations de fusion