# Module type Blit_intf.Blit

    module type Blit = sig .. end

    include ??

    include ??

    include ??

    include ??

    module type S = Blit_intf.S

    module type S_permissions = Blit_intf.S_permissions

    module type S1 = Blit_intf.S1

    module type S1_permissions = Blit_intf.S1_permissions

    module type S_distinct = Blit_intf.S_distinct

There are various `Make*` functors that turn an `unsafe_blit` function into a `blit` function. The functors differ in whether the sequence type is monomorphic or polymorphic, and whether the src and dst types are distinct or are the same.

The blit functions make sure the slices are valid and then call `unsafe_blit`. They guarantee at a call `unsafe_blit ~src ~src_pos ~dst ~dst_pos ~len` that:

            len > 0
            && src_pos >= 0
            && src_pos + len <= get_src_len src
            && dst_pos >= 0
            && dst_pos + len <= get_dst_len dst

The `Make*` functors also automatically create unit tests.

    module Make: functor (Elt : Blit_intf.Elt) -> functor (Sequence : sig
    include Blit_intf.Sequence

    val unsafe_blit : (t, t) Blit_intf.blitend) -> S  with type t := Sequence.t

`Make` is for blitting between two values of the same monomorphic type.

    module Make_distinct: functor (Elt : Blit_intf.Elt) -> functor (Src : Blit_intf.Sequence  with type elt := Elt.t) -> functor (Dst : sig
    include Blit_intf.Sequence

    val unsafe_blit : (Src.t, t) Blit_intf.blitend) -> S_distinct
          with type src := Src.t
          with type dst := Dst.t

`Make_distinct` is for blitting between values of distinct monomorphic types.

    module Make1: functor (Sequence : sig
    type 'a t

    Make1 guarantees to only call create_like ~len t with len > 0 if
                 length t > 0.

    val create_like : len:int -> 'a t -> 'a t
    val length : 'a t -> int
    val unsafe_blit : ('a t, 'a t) Blit_intf.blit
    create, get, and set are just used for unit tests.  z is needed for
                 Flat_tuple_array.

    type 'a z

    val create_bool : len:int -> bool z t
    val get : 'a z t -> int -> 'a
    val set : 'a z t -> int -> 'a -> unit
    val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
    Make1 guarantees to only call create_like ~len t with len > 0 if
                 length t > 0.

    create, get, and set are just used for unit tests.  z is needed for
                 Flat_tuple_array.

    end) -> S1  with type 'a t := 'a Sequence.t

`Make1` is for blitting between two values of the same polymorphic type.