package mopsa

  1. Overview
  2. Docs
MOPSA: A Modular and Open Platform for Static Analysis using Abstract Interpretation

Install

Dune Dependency

gitlab.com Readme Changelog Edit opam file Versions (2)

Authors

  1. A
    Antoine Miné
  2. A
    Abdelraouf Ouadjaout
  3. M
    Matthieu Journault
  4. A
    Aymeric Fromherz
  5. R
    Raphaël Monat
  6. F
    Francesco Parolini
  7. M
    Marco Milanese
  8. J
    Jérôme Boillot

Maintainers

  1. A
    Antoine Miné <antoine.mine@lip6.fr>
  2. A
    Abdelraouf Ouadjaout <ouadjaout@gmail.com>
  3. R
    Raphaël Monat <raphael.monat@inria.fr>

Sources

mopsa-analyzer-v1.0.tar.gz
md5=9f673f79708b44a7effb3b6bb3618d2c
sha512=cb91cb428e43a22f1abbcb8219710d0c10a5b3756d0da392d4084b3b3a6157350776c596983e63def344f617d39964e91f244f60c07958695ee5c8c809a9f0f4

doc/mopsa.mopsa_py_parser/Mopsa_py_parser/Ast/VarSetMap/index.html

Module Ast.VarSetMap

type key = VarSet.t
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val remove_min_binding : 'a t -> 'a t
val merge : (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val is_singleton : 'a t -> bool
val of_list : (key * 'a) list -> 'a t
val map2 : (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val iter2 : (key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val fold2 : (key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
val for_all2 : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val exists2 : (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val map2z : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val iter2z : (key -> 'a -> 'a -> unit) -> 'a t -> 'a t -> unit
val fold2z : (key -> 'a -> 'a -> 'b -> 'b) -> 'a t -> 'a t -> 'b -> 'b
val for_all2z : (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
val exists2z : (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
val map2o : (key -> 'a -> 'c) -> (key -> 'b -> 'c) -> (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val iter2o : (key -> 'a -> unit) -> (key -> 'b -> unit) -> (key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
val fold2o : (key -> 'a -> 'c -> 'c) -> (key -> 'b -> 'c -> 'c) -> (key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
val for_all2o : (key -> 'a -> bool) -> (key -> 'b -> bool) -> (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val exists2o : (key -> 'a -> bool) -> (key -> 'b -> bool) -> (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val map2zo : (key -> 'a -> 'a) -> (key -> 'a -> 'a) -> (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val iter2zo : (key -> 'a -> unit) -> (key -> 'a -> unit) -> (key -> 'a -> 'a -> unit) -> 'a t -> 'a t -> unit
val fold2zo : (key -> 'a -> 'b -> 'b) -> (key -> 'a -> 'b -> 'b) -> (key -> 'a -> 'a -> 'b -> 'b) -> 'a t -> 'a t -> 'b -> 'b
val for_all2zo : (key -> 'a -> bool) -> (key -> 'a -> bool) -> (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
val exists2zo : (key -> 'a -> bool) -> (key -> 'a -> bool) -> (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
val map_slice : (key -> 'a -> 'a) -> 'a t -> key -> key -> 'a t
val iter_slice : (key -> 'a -> unit) -> 'a t -> key -> key -> unit
val fold_slice : (key -> 'a -> 'b -> 'b) -> 'a t -> key -> key -> 'b -> 'b
val for_all_slice : (key -> 'a -> bool) -> 'a t -> key -> key -> bool
val exists_slice : (key -> 'a -> bool) -> 'a t -> key -> key -> bool
val key_equal : 'a t -> 'a t -> bool
val key_subset : 'a t -> 'a t -> bool
val find_greater : key -> 'a t -> key * 'a
val find_less : key -> 'a t -> key * 'a
val find_greater_equal : key -> 'a t -> key * 'a
val find_less_equal : key -> 'a t -> key * 'a
val to_string : Containers__MapExtSig.map_printer -> (key -> string) -> ('a -> string) -> 'a t -> string
val print : Containers__MapExtSig.map_printer -> (out_channel -> key -> unit) -> (out_channel -> 'a -> unit) -> out_channel -> 'a t -> unit
val fprint : Containers__MapExtSig.map_printer -> (Format.formatter -> key -> unit) -> (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a t -> unit
val bprint : Containers__MapExtSig.map_printer -> (Buffer.t -> key -> unit) -> (Buffer.t -> 'a -> unit) -> Buffer.t -> 'a t -> unit
val to_poly_map : 'a t -> (key, 'a) Containers.MapExtPoly.t
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct