IO | funfix-effect

IO | funfix-effect

Methods

ap

ap<B>(ff: IO<function>): IO<B>

Type parameters
- B
Parameters
- ff: IO<function>
Returns IO<B>

asyncBoundary

asyncBoundary(ec?: Scheduler): IO<A>

Parameters
- Optional ec: Scheduler
Returns IO<A>

attempt

attempt(): IO<Either<Throwable, A>>

Returns IO<Either<Throwable, A>>

chain

chain<B>(f: function): IO<B>

Type parameters
- B
Parameters
- f: function
  - - (a: A): IO<B>
    - Parameters
      - a: A
      Returns IO<B>
Returns IO<B>

delayExecution

delayExecution(delay: number | Duration): IO<A>

Parameters
- delay: number | Duration
Returns IO<A>

delayResult

delayResult(delay: number | Duration): IO<A>

Parameters
- delay: number | Duration
Returns IO<A>

doOnCancel

doOnCancel(callback: IO<void>): IO<A>

Parameters
- callback: IO<void>
Returns IO<A>

doOnFinish

doOnFinish(f: function): IO<A>

Parameters
- f: function
  - - (e: Option<Throwable>): IO<void>
    - Parameters
      - e: Option<Throwable>
      Returns IO<void>
Returns IO<A>

executeForked

executeForked(ec?: Scheduler): IO<A>

Parameters
- Optional ec: Scheduler
Returns IO<A>

executeWithModel

executeWithModel(em: ExecutionModel): IO<A>

Parameters
- em: ExecutionModel
Returns IO<A>

executeWithOptions

executeWithOptions(set: IOOptions): IO<A>

Parameters
- set: IOOptions
Returns IO<A>

flatMap

flatMap<B>(f: function): IO<B>

Type parameters
- B
Parameters
- f: function
  - - (a: A): IO<B>
    - Parameters
      - a: A
      Returns IO<B>
Returns IO<B>

followedBy

followedBy<B>(fb: IO<B>): IO<B>

Type parameters
- B
Parameters
- fb: IO<B>
Returns IO<B>

forEach

forEach(cb: function): IO<void>

Parameters
- cb: function
  - - (a: A): void
    - Parameters
      - a: A
      Returns void
Returns IO<void>

forEffect

forEffect<B>(fb: IO<B>): IO<A>

Type parameters
- B
Parameters
- fb: IO<B>
Returns IO<A>

map

map<B>(f: function): IO<B>

Type parameters
- B
Parameters
- f: function
  - - (a: A): B
    - Parameters
      - a: A
      Returns B
Returns IO<B>

memoize

memoize(): IO<A>

Returns IO<A>

memoizeOnSuccess

memoizeOnSuccess(): IO<A>

Returns IO<A>

recover

recover<AA>(f: function): IO<A | AA>

Type parameters
- AA
Parameters
- f: function
  - - (e: Throwable): AA
    - Parameters
      - e: Throwable
      Returns AA
Returns IO<A | AA>

recoverWith

recoverWith<AA>(f: function): IO<A | AA>

Type parameters
- AA
Parameters
- f: function
  - - (e: Throwable): IO<AA>
    - Parameters
      - e: Throwable
      Returns IO<AA>
Returns IO<A | AA>

run

run(ec?: Scheduler): Future<A>

Parameters
- Default value ec: Scheduler = Scheduler.global.get()
Returns Future<A>

a Future that will eventually complete with the result produced by this IO on evaluation

runOnComplete

runOnComplete(cb: function, ec?: Scheduler): ICancelable

Parameters
- cb: function
  - - (result: Try<A>): void
    - Parameters
      - result: Try<A>
      Returns void
- Default value ec: Scheduler = Scheduler.global.get()
Returns ICancelable

a cancelable action that can be triggered to cancel the running computation, assuming that the implementation of the source IO can be cancelled

timeout

timeout(after: number | Duration): IO<A>

Parameters
- after: number | Duration
Returns IO<A>

timeoutTo

timeoutTo<AA>(after: number | Duration, fallback: IO<AA>): IO<A | AA>

Type parameters
- AA
Parameters
- after: number | Duration
- fallback: IO<AA>
Returns IO<A | AA>

transform

transform<R>(failure: function, success: function): IO<R>

Type parameters
- R
Parameters
- failure: function
  - - (e: Throwable): R
    - Parameters
      - e: Throwable
      Returns R
- success: function
  - - (a: A): R
    - Parameters
      - a: A
      Returns R
Returns IO<R>

transformWith

transformWith<R>(failure: function, success: function): IO<R>

Type parameters
- R
Parameters
- failure: function
  - - (e: Throwable): IO<R>
    - Parameters
      - e: Throwable
      Returns IO<R>
- success: function
  - - (a: A): IO<R>
    - Parameters
      - a: A
      Returns IO<R>
Returns IO<R>

Static always

always<A>(thunk: function): IO<A>

Type parameters
- A
Parameters
- thunk: function
  - - (): A
    - Returns A
Returns IO<A>

Static async

async<A>(register: function): IO<A>

Type parameters
- A
Parameters
- register: function
  - - (ec: Scheduler, cb: function): ICancelable | void
    - Parameters
      - ec: Scheduler
      - cb: function
        
        (a: Try<A>): void
        
        Parameters
        
        a: Try<A>
        
        Returns void
      Returns ICancelable | void
Returns IO<A>

Static asyncUnsafe

asyncUnsafe<A>(register: IORegister<A>): IO<A>

Type parameters
- A
Parameters
- register: IORegister<A>
Returns IO<A>

Static defer

defer<A>(thunk: function): IO<A>

Type parameters
- A
Parameters
- thunk: function
  - - (): IO<A>
    - Returns IO<A>
Returns IO<A>

Static deferAction

deferAction<A>(f: function): IO<A>

Type parameters
- A
Parameters
- f: function
  - - (ec: Scheduler): IO<A>
    - Parameters
      - ec: Scheduler
      Returns IO<A>
Returns IO<A>

Static deferFuture

deferFuture<A>(thunk: function): IO<A>

Type parameters
- A
Parameters
- thunk: function
  - - (): Future<A>
    - Returns Future<A>
Returns IO<A>

Static deferFutureAction

deferFutureAction<A>(f: function): IO<A>

Type parameters
- A
Parameters
- f: function
  - - (ec: Scheduler): Future<A>
    - Parameters
      - ec: Scheduler
      Returns Future<A>
Returns IO<A>

Static delayedTick

delayedTick<A>(delay: number | Duration): IO<void>

Type parameters
- A
Parameters
- delay: number | Duration
Returns IO<void>

Static firstCompletedOf

firstCompletedOf<A>(list: IO<A>[] | Iterable<IO<A>>): IO<A>

Type parameters
- A
Parameters
- list: IO<A>[] | Iterable<IO<A>>
Returns IO<A>

a new IO that will evaluate to the result of the first in the list to complete, the rest being cancelled

Static fork

fork<A>(fa: IO<A>, ec?: Scheduler): IO<A>

Type parameters
- A
Parameters
- fa: IO<A>
- Optional ec: Scheduler
Returns IO<A>

Static fromFuture

fromFuture<A>(fa: Future<A>): IO<A>

Type parameters
- A
Parameters
- fa: Future<A>
Returns IO<A>

Static fromTry

fromTry<A>(a: Try<A>): IO<A>

Type parameters
- A
Parameters
- a: Try<A>
Returns IO<A>

Static gather

gather<A>(list: IO<A>[] | Iterable<IO<A>>): IO<A[]>

Type parameters
- A
Parameters
- list: IO<A>[] | Iterable<IO<A>>
Returns IO<A[]>

Static map2

map2<A1, A2, R>(fa1: IO<A1>, fa2: IO<A2>, f: function): IO<R>

Type parameters
- A1
- A2
- R
Parameters
- fa1: IO<A1>
- fa2: IO<A2>
- f: function
  - - (a1: A1, a2: A2): R
    - Parameters
      - a1: A1
      - a2: A2
      Returns R
Returns IO<R>

Static map3

map3<A1, A2, A3, R>(fa1: IO<A1>, fa2: IO<A2>, fa3: IO<A3>, f: function): IO<R>

Type parameters
- A1
- A2
- A3
- R
Parameters
- fa1: IO<A1>
- fa2: IO<A2>
- fa3: IO<A3>
- f: function
  - - (a1: A1, a2: A2, a3: A3): R
    - Parameters
      - a1: A1
      - a2: A2
      - a3: A3
      Returns R
Returns IO<R>

Static map4

map4<A1, A2, A3, A4, R>(fa1: IO<A1>, fa2: IO<A2>, fa3: IO<A3>, fa4: IO<A4>, f: function): IO<R>

Type parameters
- A1
- A2
- A3
- A4
- R
Parameters
- fa1: IO<A1>
- fa2: IO<A2>
- fa3: IO<A3>
- fa4: IO<A4>
- f: function
  - - (a1: A1, a2: A2, a3: A3, a4: A4): R
    - Parameters
      - a1: A1
      - a2: A2
      - a3: A3
      - a4: A4
      Returns R
Returns IO<R>

Static map5

map5<A1, A2, A3, A4, A5, R>(fa1: IO<A1>, fa2: IO<A2>, fa3: IO<A3>, fa4: IO<A4>, fa5: IO<A5>, f: function): IO<R>

Type parameters
- A1
- A2
- A3
- A4
- A5
- R
Parameters
- fa1: IO<A1>
- fa2: IO<A2>
- fa3: IO<A3>
- fa4: IO<A4>
- fa5: IO<A5>
- f: function
  - - (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): R
    - Parameters
      - a1: A1
      - a2: A2
      - a3: A3
      - a4: A4
      - a5: A5
      Returns R
Returns IO<R>

Static map6

map6<A1, A2, A3, A4, A5, A6, R>(fa1: IO<A1>, fa2: IO<A2>, fa3: IO<A3>, fa4: IO<A4>, fa5: IO<A5>, fa6: IO<A6>, f: function): IO<R>

Type parameters
- A1
- A2
- A3
- A4
- A5
- A6
- R
Parameters
- fa1: IO<A1>
- fa2: IO<A2>
- fa3: IO<A3>
- fa4: IO<A4>
- fa5: IO<A5>
- fa6: IO<A6>
- f: function
  - - (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6): R
    - Parameters
      - a1: A1
      - a2: A2
      - a3: A3
      - a4: A4
      - a5: A5
      - a6: A6
      Returns R
Returns IO<R>

Static now

now<A>(value: A): IO<A>

Type parameters
- A
Parameters
- value: A
Returns IO<A>

Static of

of<A>(thunk: function): IO<A>

Type parameters
- A
Parameters
- thunk: function
  - - (): A
    - Returns A
Returns IO<A>

Static once

once<A>(thunk: function): IO<A>

Type parameters
- A
Parameters
- thunk: function
  - - (): A
    - Returns A
Returns IO<A>

Static parMap2

parMap2<A1, A2, R>(fa1: IO<A1>, fa2: IO<A2>, f: function): IO<R>

Type parameters
- A1
- A2
- R
Parameters
- fa1: IO<A1>
- fa2: IO<A2>
- f: function
  - - (a1: A1, a2: A2): R
    - Parameters
      - a1: A1
      - a2: A2
      Returns R
Returns IO<R>

Static parMap3

parMap3<A1, A2, A3, R>(fa1: IO<A1>, fa2: IO<A2>, fa3: IO<A3>, f: function): IO<R>

Type parameters
- A1
- A2
- A3
- R
Parameters
- fa1: IO<A1>
- fa2: IO<A2>
- fa3: IO<A3>
- f: function
  - - (a1: A1, a2: A2, a3: A3): R
    - Parameters
      - a1: A1
      - a2: A2
      - a3: A3
      Returns R
Returns IO<R>

Static parMap4

parMap4<A1, A2, A3, A4, R>(fa1: IO<A1>, fa2: IO<A2>, fa3: IO<A3>, fa4: IO<A4>, f: function): IO<R>

Type parameters
- A1
- A2
- A3
- A4
- R
Parameters
- fa1: IO<A1>
- fa2: IO<A2>
- fa3: IO<A3>
- fa4: IO<A4>
- f: function
  - - (a1: A1, a2: A2, a3: A3, a4: A4): R
    - Parameters
      - a1: A1
      - a2: A2
      - a3: A3
      - a4: A4
      Returns R
Returns IO<R>

Static parMap5

parMap5<A1, A2, A3, A4, A5, R>(fa1: IO<A1>, fa2: IO<A2>, fa3: IO<A3>, fa4: IO<A4>, fa5: IO<A5>, f: function): IO<R>

Type parameters
- A1
- A2
- A3
- A4
- A5
- R
Parameters
- fa1: IO<A1>
- fa2: IO<A2>
- fa3: IO<A3>
- fa4: IO<A4>
- fa5: IO<A5>
- f: function
  - - (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): R
    - Parameters
      - a1: A1
      - a2: A2
      - a3: A3
      - a4: A4
      - a5: A5
      Returns R
Returns IO<R>

Static parMap6

parMap6<A1, A2, A3, A4, A5, A6, R>(fa1: IO<A1>, fa2: IO<A2>, fa3: IO<A3>, fa4: IO<A4>, fa5: IO<A5>, fa6: IO<A6>, f: function): IO<R>

Type parameters
- A1
- A2
- A3
- A4
- A5
- A6
- R
Parameters
- fa1: IO<A1>
- fa2: IO<A2>
- fa3: IO<A3>
- fa4: IO<A4>
- fa5: IO<A5>
- fa6: IO<A6>
- f: function
  - - (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6): R
    - Parameters
      - a1: A1
      - a2: A2
      - a3: A3
      - a4: A4
      - a5: A5
      - a6: A6
      Returns R
Returns IO<R>

Static pure

pure<A>(value: A): IO<A>

Type parameters
- A
Parameters
- value: A
Returns IO<A>

Static raise

raise<A>(e: Throwable): IO<A>

Type parameters
- A
Parameters
- e: Throwable
Returns IO<A>

Static sequence

sequence<A>(list: IO<A>[] | Iterable<IO<A>>): IO<A[]>

Type parameters
- A
Parameters
- list: IO<A>[] | Iterable<IO<A>>
Returns IO<A[]>

Static shift

shift(ec?: Scheduler): IO<void>

Parameters
- Optional ec: Scheduler
Returns IO<void>

Static suspend

suspend<A>(thunk: function): IO<A>

Type parameters
- A
Parameters
- thunk: function
  - - (): IO<A>
    - Returns IO<A>
Returns IO<A>

Static tailRecM

tailRecM<A, B>(a: A, f: function): IO<B>

Type parameters
- A
- B
Parameters
- a: A
- f: function
  - - (a: A): IO<Either<A, B>>
    - Parameters
      - a: A
      Returns IO<Either<A, B>>
Returns IO<B>

Static unit

unit(): IO<void>

Returns IO<void>

Static unsafeStart

unsafeStart<A>(source: IO<A>, context: IOContext, cb: function): void | ICancelable

Type parameters
- A
Parameters
- source: IO<A>
- context: IOContext
- cb: function
  - - (r: Try<A>): void
    - Parameters
      - r: Try<A>
      Returns void
Returns void | ICancelable