modules.md

aceink / Exports

aceink

Table of contents

Classes

• Deferred
• Queue
• Semaphore

Type Aliases

• ErrorValue
• Func

Functions

• createDeferred
• createLock
• delay
• each
• gowait
• identity
• map
• noop
• once
• q

Type Aliases

ErrorValue

Ƭ ErrorValue<T, E>: [E, undefined] | [null, T]

Type parameters

Name
T
E

Defined in

gowait.ts:28

---

Func

Ƭ Func<Result, Args>: (...args: Args) => Result

Type parameters

Name	Type
Result	ExplicitAny
Args	extends ExplicitAny[] = ExplicitAny[]

Type declaration

▸ (...args): Result

Anonymous Function definition

Parameters

Name	Type
...args	Args

Returns

Result

Defined in

lang.ts:16

Functions

createDeferred

▸ createDeferred<T>(value?): Deferred<T>

Create a new Deferred instance

Type parameters

Name
T

Parameters

Name	Type
value?	T

Returns

Deferred<T>

Defined in

deferred.ts:9

---

createLock

▸ createLock<RefType>(count?, bound?): Semaphore<RefType>

Basic counting semaphore/lock factory

Type parameters

Name	Type
RefType	number

Parameters

Name	Type	Default value
count?	number	undefined
bound	boolean	true

Returns

Semaphore<RefType>

Defined in

semaphore.ts:6

---

delay

▸ delay<T>(ms?, arg?): Promise<T>

delay a certain number of milliseconds returning a promise that resolves an argument

Type parameters

Name	Type
T	undefined

Parameters

Name	Type
ms?	number
arg?	T

Returns

Promise<T>

Defined in

lang.ts:24

---

each

▸ each<T, K>(this, list, iterator, «destructured»?): Promise<void>

Iterate a list with optional concurrency

Type parameters

Name	Type
T	T
K	any

Parameters

Name	Type
this	void | K
list	Iterable<T>
iterator	IteratorFunc<T, any>
«destructured»	Object
› concurrency?	number
› context?	void | K
› onError?	"settle" | "bail"

Returns

Promise<void>

Defined in

each.ts:15

---

gowait

▸ gowait<T, E>(promised): Promise<ErrorValue<T, E>>

Kind of like nodes ErrBacks, but with the ease (and overhead) of promises. It will only reject promises for native errors. Syncronous errors are caught.

Example

const [err, value] = await gowait(doWorkThatMightErrorAsync())
if (err) {
  panic(err)
} else {
  success(value)
}

Type parameters

Name	Type
T	T
E	Error

Parameters

Name	Type
promised	Promise<T> | Func<Promise<T>>

Returns

Promise<ErrorValue<T, E>>

Defined in

gowait.ts:45

---

identity

▸ identity<T>(x): T

Basic identity function

Type parameters

Name
T

Parameters

Name	Type
x	T

Returns

T

Defined in

lang.ts:10

---

map

▸ map<T, R, K>(this, list, iterator, «destructured»?): Promise<R[]>

Map over a list with optional concurrency

Type parameters

Name	Type
T	T
R	R
K	any

Parameters

Name	Type
this	K
list	Iterable<T>
iterator	IteratorFunc<T, R>
«destructured»	Object
› concurrency?	number
› context?	K

Returns

Promise<R[]>

Defined in

map.ts:8

---

noop

▸ noop(): void

Basic noop function

Returns

void

Defined in

lang.ts:5

---

once

▸ once<T>(fn, after?): T

Execute fn one time and [after=noop] for every subsequent invocation

Type parameters

Name	Type
T	extends Func<any, any[]>

Parameters

Name	Type	Default value
fn	T	undefined
after	Func<any, any[]>	noop

Returns

T

Defined in

lang.ts:31

---

q

▸ q(size, bound?): Queue

Create Queue with a specified size

Parameters

Name	Type	Default value
size	number	undefined
bound	boolean	true

Returns

Queue

Defined in

queue.ts:8