unique_lock & shared_lock

[samchon]

In C++ STL, unique_lock & shared_lock ensures safety locks using destruction pattern. However, unlike C++, JS does not support the destructor, thus TSTL should design alternative solutions for those safety locks.

My answer is to using closure function for the safety lock. However, I haven't determined the detailed solution yet. I've two candidate solutions. Which one would be better? I'm looking forward to your ideas and opinions.

1. Global Functions in Namespace

type Closure = () => void | Promise<void>;
interface Mutex
{
    lock(): Promise<void>;
    unlock(): Promise<void>;
    
    try_lock?(): Promise<boolean>;
    try_lock_for?(ms: number): Promise<boolean>;
    try_lock_until?(at: Date): Promise<boolean>;
}

namespace std.unique_lock
{
    export async function lock(mtx: Mutex, task: Closure): Promise<void>
    {
        await mtx.lock();
        await task();
        await mtx.unlock();
    }
    export function try_lock(mtx: Mutex, task: Closure): Promise<boolean>;
    export function try_lock_for(mtx: Mutex, ms: number, task: Closure): Promise<boolean>;
    export function try_lock_until(mtx: Mutex, ms: number, task: Closure): Promise<boolean>;
}

2. Class providing Lambda Methods

type Task = () => void | Promise<void>;
interface SharedMutex
{
    lock_shared(): Promise<void>;
    unlock_shared(): Promise<void>;
    
    try_lock_shared?(): Promise<boolean>;
    try_lock_shared_for?(ms: number): Promise<boolean>;
    try_lock_shared_until?(at: Date): Promise<boolean>;
}

class SharedLock
{
    private mtx_: SharedMutex;
    public constructor(mutex: SharedMutex);

    public lock(task: Closure): Promise<void>;
    public try_lock(task: Closure): Promise<boolean>;
    public try_lock_for?(ms: number, task: Closure): Promise<boolean>;
    public try_lock_until?(at: Date, task: Closure): Promise<boolean>
    {
        let ret: Boolean = await this.mtx_.try_lock_shared_until(at);
        if (ret)
        {
            await task();
            await this.mtx_.mtx_.unlock_shared();
        }
        return ret;
    }
}

[samchon]

I'm planning to adapt the 1st way. You've an another idea or opposite opinion, then please tell me.

[samchon]

I decided to adapt both of them all. Type restriction would be enhanced like such below:

export class SharedLock<Mutex extends IMutex>
{
    public constructor(mutex: Mutex);

    public lock(closure: Closure): Promise<void>;
    public try_lock(closure: Closure): Promise<boolean>;

    public try_lock_for: "try_lock_shared_for" extends keyof Mutex
        ? (ms: number, closure: Closure) => Promise<boolean>
        : undefined;
    
    public try_lock_until: "try_lock_shared_until" extends keyof Mutex
        ? (at: Date, closure: Closure) => Promise<boolean>
        : undefined;
}

export namespace SharedLock
{
    export function lock<Mutex extends Pick<_ISharedLockable, "lock_shared"|"unlock_shared">>
        (mutex: Mutex, closure: Closure): Promise<void>;

    export function try_lock<Mutex extends Pick<_ISharedLockable, "try_lock_shared"|"unlock_shared">>
        (mutex: Mutex, closure: Closure): Promise<boolean>;

    export function try_lock_for<Mutex extends Pick<_ISharedTimedLockable, "try_lock_shared_for"|"unlock_shared">>
        (mutex: Mutex, ms: number, closure: Closure): Promise<boolean>;

    export function try_lock_until<Mutex extends Pick<_ISharedTimedLockable, "try_lock_shared_until"|"unlock_shared">>
        (mutex: Mutex, at: Date, closure: Closure): Promise<boolean>;
}
export import shared_lock = SharedLock;

interface IMutex
{
    lock_shared(): Promise<void>;
    unlock_sharedO(): Promise<void>;

    try_lock_shared(): Promise<boolean>;
    try_lock_shared_for?(ms: number): Promise<boolean>;
    try_lock_shared_until?(at: Date): Promise<boolean>;
}
type Closure = () => void | Promise<void>;