Previous  Up  

Module type Blit_intf.Blit

module type Blit = sig .. end
include ??
include ??
include ??
include ??
module type S = Blit_intf.S
module type S1 = Blit_intf.S1
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.blit
end) -> 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.blit
end) -> S_distinct 
      with type src := Src.t 
      with type dst := Dst.t
Make_distinct is for blitting between values of disinct 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
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.




end) -> S1  with type 'a t := 'a Sequence.t
Make1 is for blitting between two values of the same polymorphic type.