Source Edit

This module provides basic primitives for creating parallel programs. A Task should be only owned by a single Thread, it cannot be shared by threads.

Example:

  1. import std/tasks
  2. block:
  3.   var num = 0
  4.   proc hello(a: int) = inc num, a
  6.   let b = toTask hello(13)
  7.   b.invoke()
  8.   assert num == 13
  9.   # A task can be invoked multiple times
  10.   b.invoke()
  11.   assert num == 26
  13. block:
  14.   type
  15.     Runnable = ref object
  16.       data: int
  18.   var data: int
  19.   proc hello(a: Runnable) {.nimcall.} =
  20.     a.data += 2
  21.     data = a.data
  24.   when false:
  25.     # the parameters of call must be isolated.
  26.     let x = Runnable(data: 12)
  27.     let b = toTask hello(x) # error ----> expression cannot be isolated: x
  28.     b.invoke()
  30.   let b = toTask(hello(Runnable(data: 12)))
  31.   b.invoke()
  32.   assert data == 14
  33.   b.invoke()
  34.   assert data == 16

Imports

macros, isolation, typetraits, effecttraits

Types

  1. Task = object

Task contains the callback and its arguments. Source Edit

Procs

  1. proc `=copy`(x: var Task; y: Task) {.error.}

Source Edit 

  1. proc `=destroy`(t: var Task) {.inline, ...gcsafe, raises: [], tags: [RootEffect],
  2.                                forbids: [].}

Frees the resources allocated for a Task. Source Edit 

  1. proc invoke(task: Task; res: pointer = nil) {.inline, ...gcsafe,
  2.     raises: [Exception], tags: [RootEffect], forbids: [].}

Invokes the task. Source Edit

Macros

  1. macro toTask(e: typed{nkCall | nkInfix | nkPrefix | nkPostfix | nkCommand |
  2.     nkCallStrLit}): Task

Converts the call and its arguments to Task.

Example:

  1. proc hello(a: int) = echo a
  3. let b = toTask hello(13)
  4. assert b is Task

Source Edit

Exports

unsafeIsolate, \=copy, \=sink, extract, \=destroy, Isolated, isolate