# Module type Flags_intf.Make_arg

    module type Make_arg = sig .. end

    val known : (Int63.t * string) list

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`.

    val remove_zero_flags : bool

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.

    val allow_intersecting : bool

`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.

    val should_print_error : bool

`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.