package patdiff

You can search for identifiers within the package.

in-package search v0.2.0

package patdiff

patdiff
- Library patdiff
  - Patdiff
    
    Ansi_output
    
    Diff_input
    
    File_name
    
    Format
    
    Hunks
    
    Output
    
    Compare_core
    
    Configuration
    
    Fields
    
    Private
    
    On_disk
    
    V1
    
    V0
    
    Patdiff_core
    
    S
    
    Private
    
    Without_unix
    
    Private
    
    Is_binary
    
    Should_keep_whitespace
- Library patdiff.kernel
  - Patdiff_kernel
    
    Ansi_output
    
    Rule
    
    Ascii_output
    
    Rule
    
    Comparison_result
    
    Configuration
    
    Fields
    
    Direct
    
    Private
    
    Diff_input
    
    Fields
    
    Direct
    
    File_name
    
    Float_tolerance
    
    Format
    
    Color
    
    RGB6
    
    Gray24
    
    Replace_polymorphic_compare
    
    Map
    
    Key
    
    Tree
    
    Provide_of_sexp
    
    Provide_of_sexp
    
    Provide_bin_io
    
    Provide_hash
    
    Set
    
    Elt
    
    Tree
    
    Named
    
    Provide_of_sexp
    
    Named
    
    Provide_of_sexp
    
    Provide_bin_io
    
    Provide_hash
    
    Style
    
    Replace_polymorphic_compare
    
    Map
    
    Key
    
    Tree
    
    Provide_of_sexp
    
    Provide_of_sexp
    
    Provide_bin_io
    
    Provide_hash
    
    Set
    
    Elt
    
    Tree
    
    Named
    
    Provide_of_sexp
    
    Named
    
    Provide_of_sexp
    
    Provide_bin_io
    
    Provide_hash
    
    Rule
    
    Affix
    
    Rules
    
    Location_style
    
    Html_output
    
    Private
    
    Make
    
    Rule
    
    Without_mtime
    
    Rule
    
    Hunks
    
    Import
    
    Patience_diff
    
    Is_binary
    
    Output
    
    S
    
    Rule
    
    Patdiff_core
    
    S
    
    Private
    
    Make
    
    Without_unix
    
    Should_keep_whitespace
- Sources
  - patdiff
    
    compare_core.ml
    
    configuration.ml
    
    html_output.ml
    
    import.ml
    
    patdiff.ml
    
    patdiff__.ml
    
    patdiff_core.ml
  - patdiff.kernel
    
    ansi_output.ml
    
    ascii_output.ml
    
    comparison_result.ml
    
    configuration.ml
    
    diff_input.ml
    
    file_name.ml
    
    float_tolerance.ml
    
    format.ml
    
    html_output.ml
    
    html_output_intf.ml
    
    hunks.ml
    
    import.ml
    
    is_binary.ml
    
    output.ml
    
    output_intf.ml
    
    patdiff_core.ml
    
    patdiff_core_intf.ml
    
    patdiff_kernel.ml
    
    patdiff_kernel__.ml
    
    should_keep_whitespace.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Set.Tree`Source

include Core_kernel.Set_intf.Make_S_plain_tree(Elt).S

Sourcetype t = (Elt.t, Elt.comparator_witness) Base.Set.Using_comparator.Tree.t

Sourceval compare : t -> t -> Base.Int.t

Source

type named =
  (Elt.t, Elt.comparator_witness) Base.Set.Using_comparator.Tree.Named.t

include Core_kernel.Set_intf.Creators_and_accessors0
  with type ('a, 'b) set := ('a, 'b) Base.Set.Using_comparator.Tree.t
  with type t := t
  with type tree := t
  with type elt := Elt.t
  with type named := named
  with type comparator_witness := Elt.comparator_witness

include Core_kernel.Set_intf.Accessors0
  with type t := t
  with type tree := t
  with type elt := Elt.t
  with type named := named
  with type comparator_witness := Elt.comparator_witness

include Base.Set.Accessors0
  with type t := t
  with type tree := t
  with type elt := Elt.t
  with type named := named
  with type comparator_witness := Elt.comparator_witness

include Base.Container.S0 with type t := t with type elt := Elt.t

Sourceval length : t -> int

Sourceval is_empty : t -> bool

Sourceval iter : t -> f:(Elt.t -> unit) -> unit

iter must allow exceptions raised in f to escape, terminating the iteration cleanly. The same holds for all functions below taking an f.

Sourceval fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum

fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en are the elements of t.

Source

val fold_result : 
  t ->
  init:'accum ->
  f:('accum -> Elt.t -> ('accum, 'e) Base.Result.t) ->
  ('accum, 'e) Base.Result.t

fold_result t ~init ~f is a short-circuiting version of fold that runs in the Result monad. If f returns an Error _, that value is returned without any additional invocations of f.

Sourceval exists : t -> f:(Elt.t -> bool) -> bool

Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.

Sourceval for_all : t -> f:(Elt.t -> bool) -> bool

Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.

Sourceval count : t -> f:(Elt.t -> bool) -> int

Returns the number of elements for which the provided function evaluates to true.

Source

val sum : 
  (module Base__.Container_intf.Summable with type t = 'sum) ->
  t ->
  f:(Elt.t -> 'sum) ->
  'sum

Returns the sum of f i for all i in the container.

Sourceval find : t -> f:(Elt.t -> bool) -> Elt.t option

Returns as an option the first element for which f evaluates to true.

Sourceval find_map : t -> f:(Elt.t -> 'a option) -> 'a option

Returns the first evaluation of f that returns Some, and returns None if there is no such element.

Sourceval to_list : t -> Elt.t list

Sourceval to_array : t -> Elt.t array

Sourceval invariants : t -> bool

Sourceval mem : t -> Elt.t -> bool

Sourceval add : t -> Elt.t -> t

Sourceval remove : t -> Elt.t -> t

Sourceval union : t -> t -> t

Sourceval inter : t -> t -> t

Sourceval diff : t -> t -> t

Sourceval symmetric_diff : t -> t -> (Elt.t, Elt.t) Base.Either.t Base.Sequence.t

Sourceval compare_direct : t -> t -> int

Sourceval equal : t -> t -> bool

Sourceval is_subset : t -> of_:t -> bool

Sourceval are_disjoint : t -> t -> bool

Sourcemodule Named : sig ... end

Source

val fold_until : 
  t ->
  init:'b ->
  f:
    ('b ->
      Elt.t ->
      ('b, 'final) Base__.Container_intf.Export.Continue_or_stop.t) ->
  finish:('b -> 'final) ->
  'final

Sourceval fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b

Source

val iter2 : 
  t ->
  t ->
  f:([ `Left of Elt.t | `Right of Elt.t | `Both of Elt.t * Elt.t ] -> unit) ->
  unit

Sourceval filter : t -> f:(Elt.t -> bool) -> t

Sourceval partition_tf : t -> f:(Elt.t -> bool) -> t * t

Sourceval elements : t -> Elt.t list

Sourceval min_elt : t -> Elt.t option

Sourceval min_elt_exn : t -> Elt.t

Sourceval max_elt : t -> Elt.t option

Sourceval max_elt_exn : t -> Elt.t

Sourceval choose : t -> Elt.t option

Sourceval choose_exn : t -> Elt.t

Sourceval split : t -> Elt.t -> t * Elt.t option * t

Sourceval group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list

Sourceval find_exn : t -> f:(Elt.t -> bool) -> Elt.t

Sourceval nth : t -> int -> Elt.t option

Sourceval remove_index : t -> int -> t

Sourceval to_tree : t -> t

Source

val to_sequence : 
  ?order:[ `Increasing | `Decreasing ] ->
  ?greater_or_equal_to:Elt.t ->
  ?less_or_equal_to:Elt.t ->
  t ->
  Elt.t Base.Sequence.t

Source

val binary_search : 
  t ->
  compare:(Elt.t -> 'key -> int) ->
  [ `Last_strictly_less_than
  | `Last_less_than_or_equal_to
  | `Last_equal_to
  | `First_equal_to
  | `First_greater_than_or_equal_to
  | `First_strictly_greater_than ] ->
  'key ->
  Elt.t option

Source

val binary_search_segmented : 
  t ->
  segment_of:(Elt.t -> [ `Left | `Right ]) ->
  [ `Last_on_left | `First_on_right ] ->
  Elt.t option

Source

val merge_to_sequence : 
  ?order:[ `Increasing | `Decreasing ] ->
  ?greater_or_equal_to:Elt.t ->
  ?less_or_equal_to:Elt.t ->
  t ->
  t ->
  (Elt.t, Elt.t) Base.Sequence.Merge_with_duplicates_element.t Base.Sequence.t

Source

val to_map : 
  t ->
  f:(Elt.t -> 'data) ->
  (Elt.t, 'data, Elt.comparator_witness) Base.Map.t

Source

val quickcheck_observer : 
  Elt.t Core_kernel.Quickcheck.Observer.t ->
  t Core_kernel.Quickcheck.Observer.t

Source

val quickcheck_shrinker : 
  Elt.t Core_kernel.Quickcheck.Shrinker.t ->
  t Core_kernel.Quickcheck.Shrinker.t

include Core_kernel.Set_intf.Creators0
  with type t := t
  with type tree := t
  with type elt := Elt.t
  with type comparator_witness := Elt.comparator_witness
  with type ('a, 'b) set := ('a, 'b) Base.Set.Using_comparator.Tree.t

include Base.Set.Creators0
  with type t := t
  with type tree := t
  with type elt := Elt.t
  with type comparator_witness := Elt.comparator_witness
  with type ('a, 'b) set := ('a, 'b) Base.Set.Using_comparator.Tree.t

Sourceval empty : t

Sourceval singleton : Elt.t -> t

Sourceval union_list : t list -> t

Sourceval of_list : Elt.t list -> t

Sourceval of_array : Elt.t array -> t

Sourceval of_sorted_array : Elt.t array -> t Base.Or_error.t

Sourceval of_sorted_array_unchecked : Elt.t array -> t

Sourceval of_increasing_iterator_unchecked : len:int -> f:(int -> Elt.t) -> t

Sourceval stable_dedup_list : Elt.t list -> Elt.t list

Sourceval map : ('a, _) Base.Set.Using_comparator.Tree.t -> f:('a -> Elt.t) -> t

Source

val filter_map : 
  ('a, _) Base.Set.Using_comparator.Tree.t ->
  f:('a -> Elt.t option) ->
  t

Sourceval of_tree : t -> t

Sourceval of_hash_set : Elt.t Core_kernel.Hash_set.t -> t

Sourceval of_hashtbl_keys : (Elt.t, _) Core_kernel.Hashtbl.t -> t

Sourceval of_map_keys : (Elt.t, _, Elt.comparator_witness) Base.Map.t -> t

Source

val quickcheck_generator : 
  Elt.t Core_kernel.Quickcheck.Generator.t ->
  t Core_kernel.Quickcheck.Generator.t

Sourcemodule Provide_of_sexp (Elt : sig ... end) : sig ... end

include Base.Sexpable.S with type t := t

Sourceval t_of_sexp : Sexplib0__.Sexp.t -> t

Sourceval sexp_of_t : t -> Sexplib0__.Sexp.t

package patdiff

Module Set.TreeSource

Module `Set.Tree`Source