# Module Flags_intf

    module Flags_intf: sig .. end

`module Flags` implements Unix-style sets of flags that are represented as an `int` with various bits set, one bit for each flag. E.g. `Linux_ext.Epoll.Flag`.

`Flags` defines a module type `Flags.S`, the interface for a flags, and a functor `Flags.Make` for creating a flags implementation.

`module Flags` implements Unix-style sets of flags that are represented as an `int` with various bits set, one bit for each flag. E.g. `Linux_ext.Epoll.Flag`.

`Flags` defines a module type `Flags.S`, the interface for a flags, and a functor `Flags.Make` for creating a flags implementation.

    module Int63: Core_int63

    module type S = sig .. end

`module type S` is the interface for a set of flags.

    module type Make_arg = sig .. end

    module type Flags = sig .. end

`module Flags` implements Unix-style sets of flags that are represented as an `int` with various bits set, one bit for each flag. E.g. `Linux_ext.Epoll.Flag`.

`Flags` defines a module type `Flags.S`, the interface for a flags, and a functor `Flags.Make` for creating a flags implementation.
`module type S` is the interface for a set of flags. Values of `type t` are set of flags, and the various functions operate on sets of flags. There is a finite universe of flags (in particular 63 flags, one for each bit).

`sexp_of_t` and `t_of_sexp` use the flag names supplied to `Flags.Make`.
consistent with subset
set union, bitwise or
set difference
bitwise and
bitwise not
An entry `flag, name` in `known` means that the bit(s) in `flag` is (are) called `name`; i.e. if `bit_and flags flag = flag`, then the bit(s) is (are) set and `name` will appear in `sexp_of_t flags`. `known` is only used to make `sexp_of_t`'s output human readable.

The flags in the output of `sexp_of_t` will occur in the same order as they appear in `known`.

It is allowed to have a single flag with multiple bits set.

It is an error if different flags intersect, and `allow_intersecting = false`.
If `remove_zero_flags`, then all flags with value zero will be automatically removed from `known`. If `not remove_zero_flags`, then it is an error for `known` to contain any flags with value zero.

About this existence of this option: it seems better to make it an option here rather than do the filtering at the functor call site. It also makes clear to callers that they need to think about zero flags, and clear what they can do if they encounter them.
`allow_intersecting` says whether to allow intersecting `known` flags. It is common to do `allow_intersecting = false`, however in some situations, e.g. Unix open flags, the flags intersect.
`should_print_error` says whether to print an error message if there is an error in the known flags. It is typical to use `should_print_error = true` because `Flags.Make` is applied at the module level, where the exception raised isn't displayed nicely.
`create ~bit:n` creates a flag with the `n`th bit set. `n` must be between 0 and 62.

Typically a flag has one bit set; `create` is useful in exactly those cases. For flags with multiple bits one can either define the Int63.t directly or create it in terms of simpler flags, using `+` and `-`.
`Flags.Make` builds a new flags module. If there is an error in the `known` flags, it behaves as per `on_error`.

We expose `type t = int` in the result of `Flags.Make` so that one can easily use flag constants as values of the flag type without having to coerce them. It is typical to hide the `t = int` in another signature `S`.