Module `Capsule_prim.Data`Source

Pointers to data within a capsule.

Sourcetype ('a, 'k) t : (value mod everything) with 'a @@ contended portable

('a, 'k) t is the type of 'as within the capsule 'k. It can be passed between threads. Operations on ('a, 'k) t require a 'k Password.t associated with the capsule 'k.

Source

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

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

Source

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

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

Source

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

Like wrap, but for unique values.

Source

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

Like unwrap, but for unique values.

Source

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

Like wrap, but for once values.

Source

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

Like unwrap, but for once values.

Source

val wrap_once_unique : 
  access:'k Capsule_prim__.Prim.Access.t ->
  'a @ unique once ->
  ('a, 'k) t @ unique once @@ portable

Like wrap, but for once unique values.

Source

val unwrap_once_unique : 
  access:'k Capsule_prim__.Prim.Access.t ->
  ('a, 'k) t @ unique once ->
  'a @ unique once @@ portable

Like unwrap, but for once unique values.

Source

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

unwrap_shared ~access t returns the shared value of t, which lives in the capsule 'k. 'k is always the current capsule. Since 'a may have been shared with other threads, 'a must cross portability.

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

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

Source

val create_once : 
  (unit -> 'a @ once) @ local once portable ->
  ('a, 'k) t @ once @@ portable

Like create, but for once values.

Source

val create_unique : 
  (unit -> 'a @ unique) @ local once portable ->
  ('a, 'k) t @ unique @@ portable

create_unique f runs f within the capsule 'k and returns a pointer to the result of f.

Source

val aliased : 
  ('a, 'k) t ->
  ('a Basement.Stdlib_shim.Modes.Aliased.t, 'k) t @@ portable

aliased t wraps the value inside an aliased Data.t in Modes.Aliased.t, making it cross aliased.

This is useful for if you need a Capsule.Data.t @ unique, but want the value it points to to be aliased.

Source

val map : 
  password:'k Capsule_prim__.Prim.Password.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 capsule '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.

Source

val both_unique : 
  ('a, 'k) t @ unique ->
  ('b, 'k) t @ unique ->
  ('a * 'b, 'k) t @ unique @@ portable

Like both, but for unique values

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.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 capsule 'k and returns the result. The result is within '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 creates a pointer to a 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 is marked contended. The value is required to always be portable, so unlike extract, project does not require permission to access 'k. This is safe because all accesses to the value happen only after it's marked contended.

Source

val project_shared : 
  ('a : value mod portable) 'k. key:'k Capsule_prim__.Prim.Key.t ->
  ('a, 'k) t ->
  'a @ shared @@ portable

project_shared ~key t is like project t, but since t is a capsule associated with a key @ aliased global, the contents can be returned at shared.

Source

val project_shared_unique : 
  ('a : value mod portable) 'k. key:'k Capsule_prim__.Prim.Key.t ->
  ('a, 'k) t @ unique ->
  'a @ unique shared @@ portable

Source

val bind : 
  password:'k Capsule_prim__.Prim.Password.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.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_shared : 
  ('a : value mod portable) 'b 'k. password:
                                     'k Capsule_prim__.Prim.Password.Shared.t @ local ->
  f:('a @ shared -> 'b) @ local once portable ->
  ('a, 'k) t ->
  ('b, 'k) t @@ portable

map_shared ~password ~f t applies f to the shared parts of t within the capsule 'k and returns a pointer to the result. Since 'a may have been shared with other threads, 'a must cross portability.

Source

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

extract_shared ~password ~f t applies f to the shared parts of t within the capsule 'k and returns the result. The result is within 'k so must be portable and is marked contended. Since 'a may have been shared with other threads, 'a must cross portability.

Sourcemodule Shared : sig ... end

Sourcemodule Local : sig ... end

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

Sourcemodule Or_null : sig ... end

Source

val unwrap_or_null : 
  ('a Basement.Or_null_shim.Export.or_null, 'k) Or_null.t ->
  ('a, 'k) t Basement.Or_null_shim.Export.or_null @@ portable

Module Capsule_prim.DataSource

Module `Capsule_prim.Data`Source