Module `Blocks.BidirectionalLabeled`Source

Parameters

module V : Sig.COMPARABLE

module E : Sig.ORDERED_TYPE

module HM : HM with type key = V.t

Sourcemodule VE : sig ... end

Sourcemodule S : sig ... end

Sourcemodule E : sig ... end

Sourcetype edge = E.t

Sourceval mem_edge : ('a * S.t) HM.t -> HM.key -> V.t -> bool

Sourceval mem_edge_e : ('a * S.t) HM.t -> (HM.key * E.t * V.t) -> bool

Sourceexception Found of edge

Sourceval find_edge : ('a * S.t) HM.t -> E.vertex -> V.t -> edge

val find_all_edges : 
  ('a * S.t) HM.t ->
  HM.key ->
  V.t ->
  (HM.key * E.t * V.t) list

val unsafe_remove_edge : 
  (S.t * S.t) HM.t ->
  HM.key ->
  HM.key ->
  (S.t * S.t) HM.t

val unsafe_remove_edge_e : 
  (S.t * S.t) HM.t ->
  (HM.key * E.t * HM.key) ->
  (S.t * S.t) HM.t

Sourceval remove_edge : (S.t * S.t) HM.t -> HM.key -> HM.key -> (S.t * S.t) HM.t

val remove_edge_e : 
  (S.t * S.t) HM.t ->
  (HM.key * E.t * HM.key) ->
  (S.t * S.t) HM.t

Sourceval iter_succ : (V.t -> unit) -> ('a * S.t) HM.t -> HM.key -> unit

Sourceval fold_succ : (V.t -> 'a -> 'a) -> ('b * S.t) HM.t -> HM.key -> 'a -> 'a

val iter_succ_e : 
  ((HM.key * E.t * V.t) -> unit) ->
  ('a * S.t) HM.t ->
  HM.key ->
  unit

val fold_succ_e : 
  ((HM.key * E.t * V.t) -> 'a -> 'a) ->
  ('b * S.t) HM.t ->
  HM.key ->
  'a ->
  'a

Sourceval succ : ('a * S.t) HM.t -> HM.key -> V.t list

Sourceval succ_e : ('a * S.t) HM.t -> HM.key -> (HM.key * E.t * V.t) list

Sourceval map_vertex : (HM.key -> HM.key) -> (S.t * S.t) HM.t -> (S.t * S.t) HM.t

Sourcemodule I : sig ... end

include module type of struct include I end

Sourcetype t = (S.t * S.t) HM.t

Sourcemodule PV = I.PV

Sourcemodule PE = I.PE

Sourceval iter_edges : (HM.key -> V.t -> unit) -> ('a * S.t) HM.t -> unit

Sourceval fold_edges : (HM.key -> V.t -> 'a -> 'a) -> ('b * S.t) HM.t -> 'a -> 'a

Sourceval iter_edges_e : ((HM.key * E.t * V.t) -> unit) -> ('a * S.t) HM.t -> unit

val fold_edges_e : 
  ((HM.key * E.t * V.t) -> 'a -> 'a) ->
  ('b * S.t) HM.t ->
  'a ->
  'a

Sourceval iter_pred : (V.t -> unit) -> (S.t * 'a) HM.t -> HM.key -> unit

Sourceval fold_pred : (V.t -> 'a -> 'a) -> (S.t * 'b) HM.t -> HM.key -> 'a -> 'a

Sourceval in_degree : (S.t * 'a) HM.t -> HM.key -> int

val iter_pred_e : 
  ((V.t * E.t * HM.key) -> unit) ->
  (S.t * 'a) HM.t ->
  HM.key ->
  unit

val fold_pred_e : 
  ((V.t * E.t * HM.key) -> 'a -> 'a) ->
  (S.t * 'b) HM.t ->
  HM.key ->
  'a ->
  'a

Sourceval pred : (S.t * 'a) HM.t -> HM.key -> V.t list

Sourceval pred_e : (S.t * 'a) HM.t -> HM.key -> (V.t * E.t * HM.key) list