Option Operations

/**
 * Create a Some instance containing a value
 * @param a - The value to wrap
 * @returns Option containing the value
 */
function some<A>(a: A): Option<A>;

/**
 * The None instance representing absence of value
 */
const none: Option<never>;

/**
 * Convert nullable value to Option
 * @param a - Value that may be null or undefined
 * @returns Some if value exists, None otherwise
 */
function fromNullable<A>(a: A | null | undefined): Option<A>;

/**
 * Create Option from predicate
 * @param predicate - Function to test the value
 * @returns Function that creates Option based on predicate result
 */
function fromPredicate<A>(predicate: Predicate<A>): (a: A) => Option<A>;
function fromPredicate<A, B extends A>(predicate: Refinement<A, B>): (a: A) => Option<B>;

import { some, none, fromNullable, fromPredicate } from "fp-ts/lib/Option";

// Direct construction
const value = some(42);
const empty = none;

// From nullable
const maybeString = fromNullable("hello"); // Some("hello")
const maybeNull = fromNullable(null);      // None

// From predicate
const isPositive = fromPredicate((n: number) => n > 0);
const positiveNumber = isPositive(5);  // Some(5)
const negativeNumber = isPositive(-1); // None

/**
 * Type guard to check if Option is Some
 * @param fa - Option to check
 * @returns true if Option is Some
 */
function isSome<A>(fa: Option<A>): fa is Some<A>;

/**
 * Type guard to check if Option is None
 * @param fa - Option to check
 * @returns true if Option is None
 */
function isNone<A>(fa: Option<A>): fa is None<A>;

/**
 * Pattern match on Option with handlers for both cases
 * @param onNone - Function to call if Option is None
 * @param onSome - Function to call if Option is Some
 * @returns Function that takes Option and returns result
 */
function fold<A, R>(onNone: () => R, onSome: (a: A) => R): (ma: Option<A>) => R;

/**
 * Extract value with default fallback
 * @param f - Function providing default value
 * @returns Function that extracts value or returns default
 */
function getOrElse<A>(f: () => A): (ma: Option<A>) => A;

/**
 * Convert Option to nullable value
 * @param ma - Option to convert
 * @returns Value or null
 */
function toNullable<A>(ma: Option<A>): A | null;

/**
 * Convert Option to value or undefined
 * @param ma - Option to convert
 * @returns Value or undefined
 */
function toUndefined<A>(ma: Option<A>): A | undefined;

import { some, none, fold, getOrElse, toNullable } from "fp-ts/lib/Option";

const value = some(42);
const empty = none;

// Pattern matching
const result1 = fold(
  () => "No value",
  (n: number) => `Value: ${n}`
)(value); // "Value: 42"

// Default values
const result2 = getOrElse(() => 0)(empty); // 0

// Convert to nullable
const nullable = toNullable(value); // 42

/**
 * Check if Option contains specific value
 * @param E - Equality instance for comparison
 * @returns Function that checks if Option contains value
 */
function elem<A>(E: Eq<A>): (a: A) => (ma: Option<A>) => boolean;

/**
 * Check if Option satisfies predicate
 * @param predicate - Predicate to test
 * @returns Function that tests Option against predicate
 */
function exists<A>(predicate: Predicate<A>): (ma: Option<A>) => boolean;

/**
 * Map with nullable result
 * @param f - Function that may return null/undefined
 * @returns Function that maps Option and handles nullable results
 */
function mapNullable<A, B>(f: (a: A) => B | null | undefined): (ma: Option<A>) => Option<B>;

/**
 * Convert Either to Option (discards left value)
 * @param fa - Either to convert
 * @returns Option containing right value or None
 */
function fromEither<L, A>(fa: Either<L, A>): Option<A>;

/**
 * Safely execute function that may throw
 * @param f - Lazy computation that may throw
 * @returns Some with result or None if exception thrown
 */
function tryCatch<A>(f: Lazy<A>): Option<A>;

/**
 * Convert refinement to Option function
 * @param refinement - Type refinement predicate
 * @returns Function that returns Option based on refinement
 */
function fromRefinement<A, B extends A>(refinement: Refinement<A, B>): (a: A) => Option<B>;

/**
 * Convert Option getter to refinement
 * @param getOption - Function returning Option
 * @returns Type refinement predicate
 */
function getRefinement<A, B extends A>(getOption: (a: A) => Option<B>): Refinement<A, B>;

/**
 * Main Option type class instances
 */
const option: Monad1<URI> & 
              Foldable2v1<URI> & 
              Plus1<URI> & 
              Traversable2v1<URI> & 
              Alternative1<URI> & 
              Extend1<URI> & 
              Compactable1<URI> & 
              Filterable1<URI> & 
              Witherable1<URI>;

/**
 * Show instance for Option
 * @param S - Show instance for contained type
 * @returns Show instance for Option
 */
function getShow<A>(S: Show<A>): Show<Option<A>>;

/**
 * Equality instance for Option
 * @param E - Equality instance for contained type
 * @returns Equality instance for Option
 */
function getEq<A>(E: Eq<A>): Eq<Option<A>>;

/**
 * Deprecated alias for getEq
 * @deprecated Use getEq instead
 */
const getSetoid: <A>(E: Eq<A>) => Eq<Option<A>>;

/**
 * Ordering instance for Option
 * @param O - Ordering instance for contained type
 * @returns Ordering instance for Option
 */
function getOrd<A>(O: Ord<A>): Ord<Option<A>>;

/**
 * Apply semigroup - combines Some values, returns None if either is None
 * @param S - Semigroup for contained type
 * @returns Semigroup for Option
 */
function getApplySemigroup<A>(S: Semigroup<A>): Semigroup<Option<A>>;

/**
 * Apply monoid - extends apply semigroup with None as identity
 * @param M - Monoid for contained type
 * @returns Monoid for Option
 */
function getApplyMonoid<A>(M: Monoid<A>): Monoid<Option<A>>;

/**
 * First monoid - returns first Some value encountered
 * @returns Monoid that prefers first Some value
 */
function getFirstMonoid<A>(): Monoid<Option<A>>;

/**
 * Last monoid - returns last Some value encountered
 * @returns Monoid that prefers last Some value
 */
function getLastMonoid<A>(): Monoid<Option<A>>;

/**
 * Option monoid using semigroup for contained values
 * @param S - Semigroup for contained type
 * @returns Monoid for Option
 */
function getMonoid<A>(S: Semigroup<A>): Monoid<Option<A>>;

// Core Option type
type Option<A> = Some<A> | None<A>;

// Option variants
class Some<A> {
  readonly _tag: 'Some' = 'Some';
  readonly _A!: A;
  readonly _URI!: URI;
  constructor(readonly value: A) {}
}

class None<A> {
  readonly _tag: 'None' = 'None';
  readonly _A!: A;
  readonly _URI!: URI;
}

// URI for type-level programming
const URI = 'Option';
type URI = typeof URI;