Module `Data.Shared`Source

Sourcetype ('a, 'k) data = ('a, 'k) t

Sourcetype ('a, 'k) t : value mod portable

('a, 'k) t is the type of 'as in a "sub-capsule" of 'k that has a shared view of 'k and uncontended access to the sub-capsule enclosing 'a.

Both read and write operations only require 'k Access.t @ shared. However, unlike ('a, 'k) Data.t, ('a, 'k) Data.Shared.t does not cross contention.

Source

val wrap : 
  access:'k Capsule_prim__.Prim.Access.t @ shared ->
  'a ->
  ('a, 'k) t @@ portable

wrap ~access v returns a pointer to the value v, which lives in the sub-capsule of 'k. 'k is always the current capsule.

Source

val unwrap : 
  access:'k Capsule_prim__.Prim.Access.t @ shared ->
  ('a, 'k) t ->
  'a @@ portable

unwrap ~access t returns the value of t, which lives in the sub-capsule of 'k. 'k is always the current capsule.

Sourceval expose : key:'k Capsule_prim__.Prim.Key.t -> ('a, 'k) t -> 'a @@ portable

A 'k Key.t @ global aliased indicates that all capsules have permanent read-only access to 'k. Therefore, ('a, 'k) t can be safely exposed.

Sourceval create : (unit -> 'a) @ local once portable -> ('a, 'k) t @@ portable

create f runs f within the sub-capsule of 'k and returns a pointer to the result.

Source

val map : 
  password:'k Capsule_prim__.Prim.Password.Shared.t @ local ->
  f:('a -> 'b) @ local once portable ->
  ('a, 'k) t ->
  ('b, 'k) t @@ portable

map ~password ~f t applies f to the value of p within the sub-capsule of 'k and returns a pointer to the result.

Sourceval both : ('a, 'k) t -> ('b, 'k) t -> ('a * 'b, 'k) t @@ portable

both t1 t2 is a pointer to a pair of the values of t1 and t2.

Sourceval fst : ('a * 'b, 'k) t -> ('a, 'k) t @@ portable

fst t gives a pointer to the first value inside t

Sourceval snd : ('a * 'b, 'k) t -> ('b, 'k) t @@ portable

snd t gives a pointer to the second value inside t

Sourceval idx : ('a, 'k) t -> ('a, 'b) idx_imm -> ('b, 'k) t @@ portable

idx t i is a pointer to the value at i in t.

Source

val extract : 
  password:'k Capsule_prim__.Prim.Password.Shared.t @ local ->
  f:('a -> 'b @ unique once portable contended) @ local once portable ->
  ('a, 'k) t ->
  'b @ unique once portable contended @@ portable

extract ~password ~f t applies f to the value of t within the sub-capsule of 'k and returns the result. The result has access to 'k so must be portable and is marked contended.

Source

val inject : 
  ('a : value mod contended) 'k. 'a @ portable ->
  ('a, 'k) t @@ portable

inject v is a pointer to an value v injected into the capsule 'k. It's a specialization of create to values that are always uncontended.

Source

val project : 
  ('a : value mod portable) 'k. ('a, 'k) t ->
  'a @ contended @@ portable

project t returns the value of t. The result is within 'k, so must be portable and is marked contended. Since it's always portable, unlike with extract, we don't need exclusive access to 'k: all accesses to the value happen only after it's marked contended.

Source

val bind : 
  password:'k Capsule_prim__.Prim.Password.Shared.t @ local ->
  f:('a -> ('b, 'j) t) @ local once portable ->
  ('a, 'k) t ->
  ('b, 'j) t @@ portable

bind ~password ~f t is project (map ~password ~f t).

Source

val iter : 
  password:'k Capsule_prim__.Prim.Password.Shared.t @ local ->
  f:('a -> unit) @ local once portable ->
  ('a, 'k) t ->
  unit @@ portable

iter is extract with result type specialized to unit.

Source

val map_into : 
  ('a : value mod portable) 'b 'k. password:
                                     'k Capsule_prim__.Prim.Password.Shared.t @ local ->
  f:('a @ shared -> 'b) @ local once portable ->
  ('a, 'k) data ->
  ('b, 'k) t @@ portable

map_into is like Capsule.map_shared but returns a Shared.t.

Sourcemodule Local : sig ... end

Functions to work with ('a, 'k) t @ local.

Module Data.SharedSource

Module `Data.Shared`Source