Monads

import { Some, None, fromNullable } from 'kotlinify-ts/monads';

// Creating Options
const someValue = Some(42);
const noValue = None();
const fromNull = fromNullable(localStorage.getItem("token"));

// Transform and extract values
fromNullable(findUser(id))
  .map(user => user.email)
  .filter(email => email.includes("@"))
  .getOrElse("no-email@default.com");

// Chain operations safely
fromNullable(getUserInput())
  .flatMap(input => fromNullable(validateInput(input)))
  .map(valid => processInput(valid))
  .fold(
    () => showDefaultView(),
    result => showResultView(result)
  );

import { Some, None, fromNullable, sequence, traverse } from 'kotlinify-ts/monads';

// Working with multiple Options
const options = [Some(1), Some(2), Some(3)];
const allValues = sequence(options); // Some([1, 2, 3])

const maybeOptions = [Some(1), None(), Some(3)];
const partial = sequence(maybeOptions); // None()

// Transform arrays to Options
const userIds = ["u1", "u2", "u3"];
const users = traverse(userIds, id => fromNullable(findUser(id)));
// Some([user1, user2, user3]) or None() if any user not found

// Combine Options with zip
const name = fromNullable(getName());
const email = fromNullable(getEmail());
const combined = name.zip(email); // Option<[string, string]>

// Use scope functions for cleaner code
fromNullable(getConfig())
  .let(config => parseConfig(config))
  .also(parsed => console.log("Config loaded:", parsed))
  .apply(config => applyConfig(config))
  .takeIf(config => config.isValid)
  .getOrElse(defaultConfig);

// Working with Option monad
const maybeToken = fromNullable(null);
console.log('Empty option:', maybeToken.getOrElse('default-token'));

const user = Some({ name: 'Alice', age: 30 });
const greeting = user
  .map(u => `Hello, ${u.name}!`)
  .getOrElse('Hello, stranger!');

console.log(greeting);

// Chain transformations
const result = Some(10)
  .map(x => x * 2)
  .filter(x => x > 15)
  .map(x => `Value: ${x}`)
  .getOrElse('Too small');

console.log(result);

import { Left, Right } from 'kotlinify-ts/monads';

// Creating Either values
const success = Right<string, number>(42);
const failure = Left<string, number>("Error occurred");

// Validate and transform
function validateAge(input: string): Either<string, number> {
  const age = parseInt(input);
  return isNaN(age) ? Left("Invalid age") : Right(age);
}

validateAge("25")
  .map(age => age + 1)
  .flatMap(age => age >= 18 ? Right(age) : Left("Too young"))
  .fold(
    error => console.error(error),
    age => console.log("Valid age:", age)
  );

// Chain multiple operations
function parseEmail(input: string): Either<string, string> {
  return input.includes("@")
    ? Right(input.toLowerCase())
    : Left("Invalid email format");
}

function checkDomain(email: string): Either<string, string> {
  return email.endsWith("@company.com")
    ? Right(email)
    : Left("Must be company email");
}

parseEmail(userInput)
  .flatMap(checkDomain)
  .map(email => createUser(email))
  .fold(
    error => showError(error),
    user => redirectToDashboard(user)
  );

import { Left, Right } from 'kotlinify-ts/monads';

// Transform left values (errors)
validateInput(data)
  .mapLeft(error => ({
    message: error,
    timestamp: Date.now(),
    context: "validation"
  }))
  .fold(
    enrichedError => logError(enrichedError),
    result => processResult(result)
  );

// Filter with fallback
Right<string, number>(10)
  .filterOrElse(
    value => value > 5,
    () => "Value too small"
  )
  .getOrElse(0);

// Swap sides for different perspectives
const either = validatePermission(user);
const swapped = either.swap(); // Right becomes Left, Left becomes Right

// Use with scope functions
Right<string, UserData>(userData)
  .let(data => enrichUserData(data))
  .also(enriched => logUserActivity(enriched))
  .apply(data => cacheUserData(data))
  .takeIf(
    data => data.isActive,
    () => "User not active"
  );

// Convert to Option
validateUser(input)
  .toOption() // Some if Right, None if Left
  .map(user => user.id)
  .getOrNull();

import { Success, Failure, tryCatch, tryCatchAsync } from 'kotlinify-ts/monads';

// Creating Results
const success = Success<number, Error>(42);
const failure = Failure<number, Error>(new Error("Operation failed"));

// Safe execution with tryCatch
const result = tryCatch(
  () => JSON.parse(jsonString),
  error => new Error(`Parse error: ${error}`)
);

result
  .map(data => data.users)
  .filter(users => users.length > 0)
  .fold(
    error => console.error("Failed:", error),
    users => console.log("Users:", users)
  );

// Async operations with tryCatchAsync
const apiResult = await tryCatchAsync(
  async () => {
    const response = await fetch("/api/users");
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    return response.json();
  },
  error => ({
    message: error instanceof Error ? error.message : "Unknown error",
    timestamp: Date.now()
  })
);

apiResult
  .map(data => data.users)
  .onSuccess(users => updateUI(users))
  .onFailure(error => showError(error))
  .getOrElse([]);

import { Success, Failure, tryCatch, tryCatchAsync } from 'kotlinify-ts/monads';

// Error recovery strategies
tryCatch(() => loadFromCache())
  .recover(error => {
    console.warn("Cache miss:", error);
    return loadDefault();
  })
  .map(data => processData(data));

// Chain with recoverWith for complex recovery
tryCatchAsync(() => fetchPrimary())
  .recoverWith(async error => {
    console.warn("Primary failed:", error);
    return tryCatchAsync(() => fetchBackup());
  })
  .map(data => normalize(data))
  .getOrElse(cachedData);

// Transform errors
tryCatch(() => riskyOperation())
  .mapError(error => ({
    type: "OPERATION_ERROR",
    message: error.message,
    stack: error.stack,
    retry: true
  }))
  .fold(
    enrichedError => handleError(enrichedError),
    result => handleSuccess(result)
  );

// Combine with scope functions
await tryCatchAsync(() => fetchUserData(userId))
  .let(data => enrichUserData(data))
  .also(enriched => logAnalytics(enriched))
  .apply(data => cacheData(data))
  .onSuccess(data => notifySubscribers(data))
  .onFailure(error => alertOps(error));

import { NonEmptyList } from 'kotlinify-ts/monads';

// Create a list that's guaranteed to have at least one element
const errors = NonEmptyList.of(
  "Email is required",
  "Password too short",
  "Age must be 18+"
);

// Access head and tail
console.log(errors.head);  // "Email is required"
console.log(errors.tail);  // ["Password too short", "Age must be 18+"]

// Works with all array methods
const formatted = errors.map(err => `• ${err}`);

// Create from array (returns null if empty)
const maybeList = NonEmptyList.fromArray(someArray);
if (maybeList) {
  console.log("At least one item:", maybeList.head);
}

import { Left, Right, zipOrAccumulate, zipOrAccumulate3, zipOrAccumulate4 } from 'kotlinify-ts/monads';

// Validate multiple independent fields
const emailValidation = validateEmail(formData.email);
const passwordValidation = validatePassword(formData.password);

// Accumulate errors from both validations
const result = zipOrAccumulate(emailValidation, passwordValidation);

result.fold(
  errors => {
    // NonEmptyList<string> with ALL errors
    console.log("Validation failed with errors:", errors);
    errors.forEach(error => displayError(error));
  },
  ([email, password]) => {
    // Both validations passed!
    createAccount(email, password);
  }
);

// Validate 3 fields at once
const validated = zipOrAccumulate3(
  validateUsername(data.username),
  validateEmail(data.email),
  validateAge(data.age)
);

// Validate 4 fields at once
const apiValidation = zipOrAccumulate4(
  validateEndpoint(request.endpoint),
  validateMethod(request.method),
  validateHeaders(request.headers),
  validateBody(request.body)
);

import { Left, Right, mapOrAccumulate } from 'kotlinify-ts/monads';

// Validate an array of items, collecting ALL errors
const userInputs = [
  { name: "Alice", age: 25, email: "alice@example.com" },
  { name: "B", age: 30, email: "bob@example.com" },      // Name too short
  { name: "Charlie", age: 15, email: "charlie@example" }, // Age too young, invalid email
  { name: "David", age: 20, email: "david@example.com" }
];

const validation = mapOrAccumulate(userInputs, user => {
  const errors = [];

  if (user.name.length < 2) {
    return Left(`User ${user.name}: Name too short`);
  }
  if (user.age < 18) {
    return Left(`User ${user.name}: Must be 18+`);
  }
  if (!user.email.includes('@')) {
    return Left(`User ${user.name}: Invalid email`);
  }

  return Right({
    ...user,
    validated: true
  });
});

validation.fold(
  errors => {
    // NonEmptyList with all validation errors
    console.log(`Found ${errors.length} validation errors:`);
    errors.forEach(error => console.error(error));
  },
  validUsers => {
    // All users passed validation!
    console.log(`Successfully validated ${validUsers.length} users`);
    saveUsers(validUsers);
  }
);

import { Left, Right, zipOrAccumulate3, NonEmptyList, EitherNel } from 'kotlinify-ts/monads';

// Type alias for cleaner signatures
type ValidationError = string;
type Validated<T> = EitherNel<ValidationError, T>;

// Individual field validators
function validateUsername(input?: string): Validated<string> {
  if (!input || input.length < 3) {
    return Left(NonEmptyList.of("Username must be at least 3 characters"));
  }
  if (!/^[a-zA-Z0-9_]+$/.test(input)) {
    return Left(NonEmptyList.of("Username can only contain letters, numbers, and underscores"));
  }
  return Right(input);
}

function validateEmail(input?: string): Validated<string> {
  if (!input) {
    return Left(NonEmptyList.of("Email is required"));
  }
  if (!input.includes('@')) {
    return Left(NonEmptyList.of("Email must contain @"));
  }
  if (!input.match(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)) {
    return Left(NonEmptyList.of("Invalid email format"));
  }
  return Right(input.toLowerCase());
}

function validatePassword(input?: string): Validated<string> {
  const errors: string[] = [];

  if (!input) {
    errors.push("Password is required");
  } else {
    if (input.length < 8) errors.push("Password must be at least 8 characters");
    if (!/[A-Z]/.test(input)) errors.push("Password must contain uppercase letter");
    if (!/[a-z]/.test(input)) errors.push("Password must contain lowercase letter");
    if (!/[0-9]/.test(input)) errors.push("Password must contain number");
  }

  return errors.length > 0
    ? Left(NonEmptyList.of(errors[0], ...errors.slice(1)))
    : Right(input);
}

// Compose validators to validate entire form
function validateSignupForm(formData: FormData) {
  const username = formData.get('username')?.toString();
  const email = formData.get('email')?.toString();
  const password = formData.get('password')?.toString();

  return zipOrAccumulate3(
    validateUsername(username),
    validateEmail(email),
    validatePassword(password)
  ).map(([username, email, password]) => ({
    username,
    email,
    password,
    createdAt: new Date()
  }));
}

// Usage in a form handler
async function handleSignup(formData: FormData) {
  validateSignupForm(formData).fold(
    errors => {
      // Display ALL validation errors at once
      const errorList = errors.map(e => `<li>${e}</li>`).join('');
      showErrorMessage(`
        <p>Please fix the following errors:</p>
        <ul>${errorList}</ul>
      `);
    },
    async validData => {
      // All validations passed!
      const user = await createUser(validData);
      redirectToDashboard(user);
    }
  );
}

import { Some, None, Right, Left, Success, Failure } from 'kotlinify-ts/monads';

// Option to Either
const option = fromNullable(getValue());
const either = option.toEither("No value found");
// Some(5) -> Right(5)
// None() -> Left("No value found")

// Option to Result (through fold)
const result = option.fold(
  () => Failure(new Error("Missing value")),
  value => Success(value)
);

// Either to Option
const validated = validateInput(data);
const maybeValid = validated.toOption();
// Right(value) -> Some(value)
// Left(error) -> None()

// Result to Either
const operation = tryCatch(() => performOperation());
const eitherResult = operation.toEither();
// Success(value) -> Right(value)
// Failure(error) -> Left(error)

// Result to Option
const maybeResult = operation.toOption();
// Success(value) -> Some(value)
// Failure(error) -> None()

// Chain across different monads
fromNullable(getUserInput())
  .fold(
    () => Failure(new Error("No input")),
    input => tryCatch(() => processInput(input))
  )
  .toEither()
  .map(processed => formatOutput(processed))
  .fold(
    error => displayError(error),
    output => displaySuccess(output)
  );

import { flowOf } from 'kotlinify-ts/flow';
import { Some, None, Success, Failure, Right, Left } from 'kotlinify-ts/monads';

// Filter flow items using Option
flowOf([1, 2, null, 3, undefined, 4])
  .mapNotNull(x => x)  // Removes null/undefined
  .collect(values => console.log(values)); // [1, 2, 3, 4]

// Transform with Option, keeping only Some values
flowOf(["user1", "user2", "user3"])
  .mapToOption(id => fromNullable(findUser(id)))
  .collect(users => console.log("Found users:", users));
  // Only emits users that were found

// Process with Result, keeping only successes
flowOf(["/api/user/1", "/api/user/2", "/api/user/3"])
  .mapToResult(url => tryCatch(() => fetchData(url)))
  .map(data => data.profile)
  .collect(profiles => updateUI(profiles));
  // Only successful fetches are processed

// Validate with Either, keeping only Right values
flowOf(["email1", "email2", "invalid", "email3"])
  .mapToEither(email =>
    email.includes("@")
      ? Right(email)
      : Left("Invalid email")
  )
  .map(email => email.toLowerCase())
  .collect(validEmails => sendNewsletter(validEmails));
  // Only valid emails are collected

// Complex flow pipeline with monads
flowOf(rawDataStream)
  .mapToResult(data => tryCatch(() => parseData(data)))
  .mapToOption(parsed => fromNullable(validate(parsed)))
  .map(valid => transform(valid))
  .filterNotNull()
  .collect(results => saveResults(results));

import { tryCatchAsync, fromNullable, Right, Left } from 'kotlinify-ts/monads';

// Replace traditional try-catch with Result
async function fetchUserProfile(userId: string) {
  return tryCatchAsync(async () => {
    const response = await fetch(`/api/users/${userId}`);
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    return response.json();
  })
  .flatMap(data =>
    fromNullable(data.profile)
      .fold(
        () => Failure(new Error("Profile not found")),
        profile => Success(profile)
      )
  )
  .map(profile => ({
    ...profile,
    lastAccessed: Date.now()
  }))
  .also(profile => updateCache(userId, profile))
  .onFailure(error => {
    console.error(`Failed to fetch user ${userId}:`, error);
    trackError(error);
  });
}

// Form validation with Either
function validateForm(formData: FormData) {
  const validateField = (name: string, validator: (value: string) => boolean, error: string) =>
    fromNullable(formData.get(name)?.toString())
      .filter(validator)
      .fold(
        () => Left(error),
        value => Right(value)
      );

  const email = validateField(
    "email",
    email => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email),
    "Invalid email format"
  );

  const password = validateField(
    "password",
    pwd => pwd.length >= 8,
    "Password must be at least 8 characters"
  );

  return email
    .flatMap(() => password)
    .map(() => ({
      email: formData.get("email") as string,
      password: formData.get("password") as string
    }));
}

// Database operation with error handling
async function saveUserPreferences(userId: string, preferences: Preferences) {
  return tryCatchAsync(
    async () => {
      const user = await db.users.findById(userId);
      if (!user) throw new Error("User not found");

      await db.preferences.upsert({
        userId,
        ...preferences,
        updatedAt: new Date()
      });

      return { success: true, userId };
    },
    error => ({
      type: "DB_ERROR",
      message: error instanceof Error ? error.message : "Database operation failed",
      userId,
      timestamp: Date.now()
    })
  )
  .recover(error => {
    // Fallback to cache if DB fails
    localStorage.setItem(`prefs_${userId}`, JSON.stringify(preferences));
    return { success: true, userId, cached: true };
  })
  .also(result => {
    if (result.cached) {
      scheduleRetry(userId, preferences);
    }
  });
}