import { TRef } from "@effect/core/stm/TRef/definition";
import { Maybe } from "@tsplus/stdlib/data/Maybe/definition";
import { Effect } from "@effect/core/io/Effect/definition";
import { identity } from "@tsplus/stdlib/data/Function";
import { STM } from "@effect/core/stm/STM/definition/base";
export declare const MVarSym: unique symbol;
export type MVarSym = typeof MVarSym;
/**
 * An `MVar<A>` is a mutable location that is either empty or contains a value
 * of type `A`. It has two fundamental operations: `put` which fills an `MVar`
 * if it is empty and blocks otherwise, and `take` which empties an `MVar` if it
 * is full and blocks otherwise. They can be used in multiple different ways:
 *
 *   - As synchronized mutable variables,
 *   - As channels, with `take` and `put` as `receive` and `send`, and
 *   - As a binary semaphore `MVar<void>`, with `take` and `put` as `wait` and
 *     `signal`.
 *
 * They were introduced in the paper "Concurrent Haskell" by Simon Peyton Jones,
 * Andrew Gordon and Sigbjorn Finne.
 *
 * @tsplus type effect/core/concurrent/MVar
 */
export interface MVar<A> extends MVarInternal<A> {
}
/**
 * @tsplus type effect/core/concurrent/MVar.Ops
 */
export interface MVarOps {
    readonly $: MVarAspects;
}
export declare const MVar: MVarOps;
/**
 * @tsplus type effect/core/concurrent/MVar.Aspects
 */
export interface MVarAspects {
}
export declare class MVarInternal<A> {
    readonly [MVarSym]: MVarSym;
    private _content;
    constructor(content: TRef<Maybe<A>>);
    /**
     * Check whether the `MVar` is empty.
     *
     * Notice that the boolean value returned is just a snapshot of the state of
     * the `MVar`. By the time you get to react on its result, the `MVar` may have
     * been filled (or emptied) - so be extremely careful when using this
     * operation. Use `tryTake` instead if possible.
     */
    get isEmpty(): Effect<never, never, boolean>;
    /**
     * A slight variation on `update` that allows a value to be returned (`b`) in
     * addition to the modified value of the `MVar`.
     */
    modify<B>(f: (a: A) => readonly [B, A]): Effect<never, never, B>;
    /**
     * Put a `value` into an `MVar`. If the `MVar` is currently full, `put` will
     * wait until it becomes empty.
     */
    put(value: A): Effect<never, never, void>;
    /**
     * Atomically read the contents of an `MVar`. If the `MVar` is currently
     * empty, `read` will wait until it is full. `read` is guaranteed to receive
     * the next `put`.
     */
    get read(): Effect<never, never, A>;
    /**
     * Take a value from an `MVar`, put a new value into the `MVar` and return the
     * value taken.
     */
    swap(value: A): Effect<never, never, A>;
    /**
     * Return the contents of the `MVar`. If the `MVar` is currently empty, `take`
     * will wait until it is full. After a `take`, the `MVar` is left empty.
     */
    get take(): Effect<never, never, A>;
    /**
     * A non-blocking version of `put`. The `tryPut` function attempts to put the
     * `value` into the `MVar`, returning `true` if it was successful, or
     * `false` otherwise.
     */
    tryPut(value: A): Effect<never, never, boolean>;
    /**
     * A non-blocking version of `read`. The `tryRead` function returns
     * immediately, with `None` if the `MVar` was empty, or `Some(x)` if the
     * `MVar` was full with contents.
     */
    get tryRead(): Effect<never, never, Maybe<A>>;
    /**
     * A non-blocking version of `take`. The `tryTake` action returns immediately,
     * with `None` if the `MVar` was empty, or `Some(x)` if the `MVar` was full
     * with contents. After `tryTake`, the `MVar` is left empty.
     */
    get tryTake(): Effect<never, never, Maybe<A>>;
    /**
     * Replaces the contents of an `MVar` with the result of `f(a)`.
     */
    update(f: (a: A) => A): Effect<never, never, void>;
}
//# sourceMappingURL=definition.d.ts.map