commit 2758e5bfac0d3d99612c3c73d63f43d1801bdb8f · anil.recoil.org/slop

+1 -1

stack/cacheio/bin/cache_cli.ml

···

       17
       17
        
           `P "This tool provides subcommands for listing, clearing, and managing cached files.";

     

       18
       18
        
         ] in

     

       19
       19
        
         let info = Cmd.info "cache" ~doc ~man in

     

       20
       20
       -
         let cmd = Cmd.group info (Cacheio_cmd.make_commands ~app_name fs) in

     

       20
       20
       +
         let cmd = Cmd.group info (Cacheio_cmd.Cmd.make_commands ~app_name fs) in

     

       21
       21
        
       

     

       22
       22
        
         exit (Cmd.eval cmd)

     

       23
       23

+1 -1

stack/cacheio/bin/dune

···

       6
       6
        
       (executable

     

       7
       7
        
        (public_name cache-cli)

     

       8
       8
        
        (name cache_cli)

     

       9
       9
       -
        (libraries cacheio.cmd cmdliner))
     

       9
       9
       +
        (libraries cacheio.cmd cmdliner eio_main))

+5 -1

stack/cacheio/bin/example.ml

···

       4
       4
        
       

     

       5
       5
        
       let setup_logs () =

     

       6
       6
        
         Logs.set_level (Some Logs.Info);

     

       7
       7
       -
         Logs.set_reporter (Logs_fmt.reporter ())

     

       7
       7
       +
         let reporter = Logs.format_reporter

     

       8
       8
       +
           ~pp_header:Logs.pp_header

     

       9
       9
       +
           ~app:Format.std_formatter

     

       10
       10
       +
           ~dst:Format.err_formatter () in

     

       11
       11
       +
         Logs.set_reporter reporter

     

       8
       12
        
       

     

       9
       13
        
       (** Example: Using CacheIO for caching data *)

     

       10
       14
        
       let cache_example env sw =

+5 -5

stack/cacheio/lib/cacheio.ml

···

       3
       3
        
       open Eio

     

       4
       4
        
       

     

       5
       5
        
       (** Module aliases *)

     

       6
       6
       -
       module Flags = Cacheio_flags

     

       7
       7
       -
       module Entry = Cacheio_entry

     

       8
       8
       -
       module Stats = Cacheio_stats

     

       6
       6
       +
       module Flags = Flags

     

       7
       7
       +
       module Entry = Entry

     

       8
       8
       +
       module Stats = Stats

     

       9
       9
        
       

     

       10
       10
        
       (** {1 Internal Key Management} *)

     

       11
       11
        
       

     
···

       383
       383
        
       

     

       384
       384
        
       (** {1 Chunk Support} *)

     

       385
       385
        
       

     

       386
       386
       -
       module Range = Cacheio_range

     

       387
       387
       -
       module Chunk = Cacheio_chunk

     

       386
       386
       +
       module Range = Range

     

       387
       387
       +
       module Chunk = Chunk

     

       388
       388
        
       

     

       389
       389
        
       let put_chunk t ~key ~range ~source ?(ttl=None) ?(flags=Flags.empty) () =

     

       390
       390
        
         (* Add Chunk flag *)

+37 -12

stack/cacheio/lib/cacheio.mli

···

       1
       1
       -
       (** File-backed cache with streaming API and TTL support

     

       1
       1
       +
       (** File-backed persistent cache with streaming API and TTL support

     

       2
       2
       +
       

     

       3
       3
       +
           Cacheio provides a robust file-backed caching system designed for high-performance

     

       4
       4
       +
           applications that need persistent storage with automatic expiry management.

     

       5
       5
       +
       

     

       6
       6
       +
           {2 Key Features}

     

       7
       7
       +
       

     

       8
       8
       +
           - {b SHA256-based key hashing}: Uniform distribution across subdirectories

     

       9
       9
       +
           - {b Maildir++-style naming}: Atomic operations with flag and TTL encoding

     

       10
       10
       +
           - {b Streaming API}: Built on Eio.Flow for efficient, non-blocking I/O

     

       11
       11
       +
           - {b Automatic expiry}: TTL-based cache expiration with manual control

     

       12
       12
       +
           - {b Thread-safe}: All operations are safe for concurrent access

     

       13
       13
       +
           - {b Chunk support}: Resume partial downloads with range-based chunks

     

       14
       14
       +
           - {b XDG integration}: Automatic directory management via XDG Base Directory spec

     

       15
       15
       +
       

     

       16
       16
       +
           {2 Usage Example}

     

       17
       17
       +
       

     

       18
       18
       +
           {[

     

       19
       19
       +
           let cache = Cacheio.create ~base_dir:cache_dir in

     

       20
       20
       +
       

     

       21
       21
       +
           (* Store data with 1 hour TTL *)

     

       22
       22
       +
           Eio.Switch.run @@ fun sw ->

     

       23
       23
       +
             let source = Eio.Flow.string_source "Hello, World!" in

     

       24
       24
       +
             Cacheio.put cache ~key:"greeting" ~source ~ttl:(Some 3600.0) ();

     

       2
       25
        
       

     

       3
       3
       -
           This module provides a file-backed cache implementation with:

     

       4
       4
       -
           - SHA256-based key hashing for uniform distribution

     

       5
       5
       -
           - Maildir++-style filename encoding with TTL and flags

     

       6
       6
       -
           - Streaming API using Eio.Flow for efficient I/O

     

       7
       7
       -
           - Automatic expiry management

     

       8
       8
       -
           - Thread-safe operations *)

     

       26
       26
       +
           (* Retrieve data *)

     

       27
       27
       +
           Eio.Switch.run @@ fun sw ->

     

       28
       28
       +
             match Cacheio.get cache ~key:"greeting" ~sw with

     

       29
       29
       +
             | Some source ->

     

       30
       30
       +
                 let content = Eio.Buf_read.(parse_exn take_all) source ~max_size:Int.max_int in

     

       31
       31
       +
                 print_endline content

     

       32
       32
       +
             | None -> print_endline "Not found"

     

       33
       33
       +
           ]}*)

     

       9
       34
        
       

     

       10
       35
        
       (** {1 Core Operations} *)

     

       11
       36
        
       

     
···

       26
       51
        
       val get : t -> key:string -> sw:Eio.Switch.t -> Eio.Flow.source_ty Eio.Resource.t option

     

       27
       52
        
       

     

       28
       53
        
       (** Cache flags management *)

     

       29
       29
       -
       module Flags = Cacheio_flags

     

       54
       54
       +
       module Flags = Flags

     

       30
       55
        
       

     

       31
       56
        
       (** Store data from a stream source with optional TTL and flags *)

     

       32
       57
        
       val put : t -> key:string -> source:Eio.Flow.source_ty Eio.Resource.t ->

     
···

       58
       83
        
       (** {1 Cache Management} *)

     

       59
       84
        
       

     

       60
       85
        
       (** Cache entry information *)

     

       61
       61
       -
       module Entry = Cacheio_entry

     

       86
       86
       +
       module Entry = Entry

     

       62
       87
        
       

     

       63
       88
        
       (** Cache statistics *)

     

       64
       64
       -
       module Stats = Cacheio_stats

     

       89
       89
       +
       module Stats = Stats

     

       65
       90
        
       

     

       66
       91
        
       (** Scan the cache and return all entries *)

     

       67
       92
        
       val scan : t -> Entry.t list

     
···

       81
       106
        
       (** {1 Chunk Support for Partial Downloads} *)

     

       82
       107
        
       

     

       83
       108
        
       (** Range management for partial downloads *)

     

       84
       84
       -
       module Range = Cacheio_range

     

       109
       109
       +
       module Range = Range

     

       85
       110
        
       

     

       86
       111
        
       (** Chunk file management *)

     

       87
       87
       -
       module Chunk = Cacheio_chunk

     

       112
       112
       +
       module Chunk = Chunk

     

       88
       113
        
       

     

       89
       114
        
       (** Store a chunk of data with a specific byte range *)

     

       90
       115
        
       val put_chunk : t -> key:string -> range:Range.t ->

+2 -2

stack/cacheio/lib/cacheio_chunk.ml stack/cacheio/lib/chunk.ml

···

       2
       2
        
       

     

       3
       3
        
       open Eio

     

       4
       4
        
       

     

       5
       5
       -
       module Range = Cacheio_range

     

       6
       6
       -
       module Flags = Cacheio_flags

     

       5
       5
       +
       module Range = Range

     

       6
       6
       +
       module Flags = Flags

     

       7
       7
        
       

     

       8
       8
        
       type t = {

     

       9
       9
        
         key : string;

-45

stack/cacheio/lib/cacheio_chunk.mli

···

       1
       1
       -
       (** Chunk file management for partial downloads *)

     

       2
       2
       -
       

     

       3
       3
       -
       (** Information about a chunk file *)

     

       4
       4
       -
       type t

     

       5
       5
       -
       

     

       6
       6
       -
       (** Get the key *)

     

       7
       7
       -
       val key : t -> string

     

       8
       8
       -
       

     

       9
       9
       -
       (** Get the hash *)

     

       10
       10
       -
       val hash : t -> string

     

       11
       11
       -
       

     

       12
       12
       -
       (** Get the range *)

     

       13
       13
       -
       val range : t -> Cacheio_range.t

     

       14
       14
       -
       

     

       15
       15
       -
       (** Get the path *)

     

       16
       16
       -
       val path : t -> Eio.Fs.dir_ty Eio.Path.t

     

       17
       17
       -
       

     

       18
       18
       -
       (** Get the flags *)

     

       19
       19
       -
       val flags : t -> Cacheio_flags.t

     

       20
       20
       -
       

     

       21
       21
       -
       (** Get the TTL *)

     

       22
       22
       -
       val ttl : t -> float option

     

       23
       23
       -
       

     

       24
       24
       -
       (** Parse a chunk from a filename and path *)

     

       25
       25
       -
       val parse : path:Eio.Fs.dir_ty Eio.Path.t -> filename:string -> t option

     

       26
       26
       -
       

     

       27
       27
       -
       (** Generate a chunk filename *)

     

       28
       28
       -
       val make_filename : hash:string -> range:Cacheio_range.t ->

     

       29
       29
       -
                          ?ttl:float -> ?flags:Cacheio_flags.t -> unit -> string

     

       30
       30
       -
       

     

       31
       31
       -
       (** Find all chunks for a key in a directory structure *)

     

       32
       32
       -
       val find_chunks : base_dir:Eio.Fs.dir_ty Eio.Path.t ->

     

       33
       33
       -
                        key:string -> t list

     

       34
       34
       -
       

     

       35
       35
       -
       (** Check if chunks form a complete sequence *)

     

       36
       36
       -
       val is_complete_sequence : t list -> total_size:int64 -> bool

     

       37
       37
       -
       

     

       38
       38
       -
       (** Get missing ranges from a list of chunks *)

     

       39
       39
       -
       val missing_ranges : t list -> total_size:int64 -> Cacheio_range.t list

     

       40
       40
       -
       

     

       41
       41
       -
       (** Sort chunks by range start position *)

     

       42
       42
       -
       val sort_by_range : t list -> t list

     

       43
       43
       -
       

     

       44
       44
       -
       (** Pretty printer *)

     

       45
       45
       -
       val pp : Format.formatter -> t -> unit

stack/cacheio/lib/cacheio_cmd.ml stack/cacheio/lib/cmd.ml

stack/cacheio/lib/cacheio_cmd.mli stack/cacheio/lib/cmd.mli

+5 -5

stack/cacheio/lib/cacheio_entry.ml stack/cacheio/lib/entry.ml

···

       5
       5
        
         size : int64;

     

       6
       6
        
         mtime : float;

     

       7
       7
        
         ttl : float option;

     

       8
       8
       -
         flags : Cacheio_flags.t;

     

       8
       8
       +
         flags : Flags.t;

     

       9
       9
        
       }

     

       10
       10
        
       

     

       11
       11
        
       let create ~key ~size ~mtime ~ttl ~flags =

     
···

       23
       23
        
         | Some expiry -> Unix.time () > expiry

     

       24
       24
        
       

     

       25
       25
        
       let is_pinned t =

     

       26
       26
       -
         Cacheio_flags.is_pinned t.flags

     

       26
       26
       +
         Flags.is_pinned t.flags

     

       27
       27
        
       

     

       28
       28
        
       let is_stale t =

     

       29
       29
       -
         Cacheio_flags.is_stale t.flags

     

       29
       29
       +
         Flags.is_stale t.flags

     

       30
       30
        
       

     

       31
       31
        
       let is_temporary t =

     

       32
       32
       -
         Cacheio_flags.is_temporary t.flags

     

       32
       32
       +
         Flags.is_temporary t.flags

     

       33
       33
        
       

     

       34
       34
        
       let compare_by_mtime a b =

     

       35
       35
        
         Float.compare a.mtime b.mtime

     
···

       45
       45
        
           (match t.ttl with

     

       46
       46
        
            | None -> "never"

     

       47
       47
        
            | Some exp -> Printf.sprintf "%.1f" exp)

     

       48
       48
       -
           Cacheio_flags.pp t.flags
     

       48
       48
       +
           Flags.pp t.flags

+2 -2

stack/cacheio/lib/cacheio_entry.mli stack/cacheio/lib/entry.mli

···

       9
       9
        
       

     

       10
       10
        
       (** Create an entry from components *)

     

       11
       11
        
       val create : key:string -> size:int64 -> mtime:float -> ttl:float option ->

     

       12
       12
       -
                    flags:Cacheio_flags.t -> t

     

       12
       12
       +
                    flags:Flags.t -> t

     

       13
       13
        
       

     

       14
       14
        
       (** {1 Accessors} *)

     

       15
       15
        
       

     
···

       26
       26
        
       val ttl : t -> float option

     

       27
       27
        
       

     

       28
       28
        
       (** Get the flags *)

     

       29
       29
       -
       val flags : t -> Cacheio_flags.t

     

       29
       29
       +
       val flags : t -> Flags.t

     

       30
       30
        
       

     

       31
       31
        
       (** {1 Predicates} *)

     

       32
       32

stack/cacheio/lib/cacheio_flags.ml stack/cacheio/lib/flags.ml

+10 -6

stack/cacheio/lib/cacheio_flags.mli stack/cacheio/lib/flags.mli

···

       1
       1
        
       (** Cache entry flags management

     

       2
       2
        
       

     

       3
       3
       -
           This module handles flags that can be attached to cache entries

     

       4
       4
       -
           to control their behavior and lifecycle. *)

     

       3
       3
       +
           This module provides a type-safe interface for managing cache entry flags.

     

       4
       4
       +
           Flags control entry behavior such as pinning (preventing eviction),

     

       5
       5
       +
           marking entries as stale (needing revalidation), or temporary.

     

       6
       6
       +
       

     

       7
       7
       +
           Flags are encoded in the filesystem using Maildir++-style conventions,

     

       8
       8
       +
           making them persistent across program restarts and visible to external tools. *)

     

       5
       9
        
       

     

       6
       10
        
       (** Abstract type representing a set of flags *)

     

       7
       11
        
       type t

     

       8
       12
        
       

     

       9
       13
        
       (** Individual flag types *)

     

       10
       14
        
       type flag = [

     

       11
       11
       -
         | `Pinned     (** Entry is pinned and won't be evicted *)

     

       12
       12
       -
         | `Stale      (** Entry needs revalidation *)

     

       13
       13
       -
         | `Temporary  (** Entry is temporary and can be cleared *)

     

       14
       14
       -
         | `Chunk      (** Entry is a partial chunk of a file *)

     

       15
       15
       +
         | `Pinned     (** Entry is pinned and won't be automatically evicted during cleanup *)

     

       16
       16
       +
         | `Stale      (** Entry needs revalidation before use *)

     

       17
       17
       +
         | `Temporary  (** Entry is temporary and will be removed on cache clear *)

     

       18
       18
       +
         | `Chunk      (** Entry is a partial chunk of a larger file (used for resume support) *)

     

       15
       19
        
       ]

     

       16
       20
        
       

     

       17
       21
        
       (** {1 Construction} *)

stack/cacheio/lib/cacheio_range.ml stack/cacheio/lib/range.ml

-40

stack/cacheio/lib/cacheio_range.mli

···

       1
       1
       -
       (** Byte range management for partial downloads *)

     

       2
       2
       -
       

     

       3
       3
       -
       (** A byte range with inclusive start and end positions *)

     

       4
       4
       -
       type t

     

       5
       5
       -
       

     

       6
       6
       -
       (** Create a range from start to end (inclusive) *)

     

       7
       7
       -
       val create : start:int64 -> end_:int64 -> t

     

       8
       8
       -
       

     

       9
       9
       -
       (** Get the start position *)

     

       10
       10
       -
       val start : t -> int64

     

       11
       11
       -
       

     

       12
       12
       -
       (** Get the end position (inclusive) *)

     

       13
       13
       -
       val end_ : t -> int64

     

       14
       14
       -
       

     

       15
       15
       -
       (** Calculate the length of a range *)

     

       16
       16
       -
       val length : t -> int64

     

       17
       17
       -
       

     

       18
       18
       -
       (** Check if two ranges are adjacent (no gap between them) *)

     

       19
       19
       -
       val adjacent : t -> t -> bool

     

       20
       20
       -
       

     

       21
       21
       -
       (** Check if two ranges overlap *)

     

       22
       22
       -
       val overlaps : t -> t -> bool

     

       23
       23
       -
       

     

       24
       24
       -
       (** Check if a range contains a position *)

     

       25
       25
       -
       val contains : t -> int64 -> bool

     

       26
       26
       -
       

     

       27
       27
       -
       (** Merge two ranges if they overlap or are adjacent *)

     

       28
       28
       -
       val merge : t -> t -> t option

     

       29
       29
       -
       

     

       30
       30
       -
       (** Compare ranges by start position *)

     

       31
       31
       -
       val compare : t -> t -> int

     

       32
       32
       -
       

     

       33
       33
       -
       (** Convert to string format "start-end" *)

     

       34
       34
       -
       val to_string : t -> string

     

       35
       35
       -
       

     

       36
       36
       -
       (** Parse from string format "start-end" *)

     

       37
       37
       -
       val of_string : string -> t option

     

       38
       38
       -
       

     

       39
       39
       -
       (** Pretty printer *)

     

       40
       40
       -
       val pp : Format.formatter -> t -> unit

+1 -1

stack/cacheio/lib/cacheio_stats.ml stack/cacheio/lib/stats.ml

···

       23
       23
        
       

     

       24
       24
        
       let of_entries entries =

     

       25
       25
        
         List.fold_left (fun acc entry ->

     

       26
       26
       -
           let open Cacheio_entry in

     

       26
       26
       +
           let open Entry in

     

       27
       27
        
           { total_size = Int64.add acc.total_size (size entry);

     

       28
       28
        
             entry_count = acc.entry_count + 1;

     

       29
       29
        
             expired_count = acc.expired_count + (if is_expired entry then 1 else 0);

+1 -1

stack/cacheio/lib/cacheio_stats.mli stack/cacheio/lib/stats.mli

···

       15
       15
        
                    pinned_count:int -> stale_count:int -> temporary_count:int -> t

     

       16
       16
        
       

     

       17
       17
        
       (** Compute statistics from a list of entries *)

     

       18
       18
       -
       val of_entries : Cacheio_entry.t list -> t

     

       18
       18
       +
       val of_entries : Entry.t list -> t

     

       19
       19
        
       

     

       20
       20
        
       (** {1 Accessors} *)

     

       21
       21

+53

stack/cacheio/lib/chunk.mli

···

       1
       1
       +
       (** Chunk file management for partial downloads and resumable transfers

     

       2
       2
       +
       

     

       3
       3
       +
           This module manages partial cache entries (chunks) that can be combined

     

       4
       4
       +
           to form complete files. Chunks enable resumable downloads and efficient

     

       5
       5
       +
           caching of large files by storing byte ranges independently.

     

       6
       6
       +
       

     

       7
       7
       +
           Each chunk is stored as a separate file with range information encoded

     

       8
       8
       +
           in its filename, allowing the cache to resume interrupted downloads

     

       9
       9
       +
           and serve partial content requests efficiently. *)

     

       10
       10
       +
       

     

       11
       11
       +
       (** Information about a chunk file *)

     

       12
       12
       +
       type t

     

       13
       13
       +
       

     

       14
       14
       +
       (** Get the key *)

     

       15
       15
       +
       val key : t -> string

     

       16
       16
       +
       

     

       17
       17
       +
       (** Get the hash *)

     

       18
       18
       +
       val hash : t -> string

     

       19
       19
       +
       

     

       20
       20
       +
       (** Get the range *)

     

       21
       21
       +
       val range : t -> Range.t

     

       22
       22
       +
       

     

       23
       23
       +
       (** Get the path *)

     

       24
       24
       +
       val path : t -> Eio.Fs.dir_ty Eio.Path.t

     

       25
       25
       +
       

     

       26
       26
       +
       (** Get the flags *)

     

       27
       27
       +
       val flags : t -> Flags.t

     

       28
       28
       +
       

     

       29
       29
       +
       (** Get the TTL *)

     

       30
       30
       +
       val ttl : t -> float option

     

       31
       31
       +
       

     

       32
       32
       +
       (** Parse a chunk from a filename and path *)

     

       33
       33
       +
       val parse : path:Eio.Fs.dir_ty Eio.Path.t -> filename:string -> t option

     

       34
       34
       +
       

     

       35
       35
       +
       (** Generate a chunk filename *)

     

       36
       36
       +
       val make_filename : hash:string -> range:Range.t ->

     

       37
       37
       +
                          ?ttl:float -> ?flags:Flags.t -> unit -> string

     

       38
       38
       +
       

     

       39
       39
       +
       (** Find all chunks for a key in a directory structure *)

     

       40
       40
       +
       val find_chunks : base_dir:Eio.Fs.dir_ty Eio.Path.t ->

     

       41
       41
       +
                        key:string -> t list

     

       42
       42
       +
       

     

       43
       43
       +
       (** Check if chunks form a complete sequence *)

     

       44
       44
       +
       val is_complete_sequence : t list -> total_size:int64 -> bool

     

       45
       45
       +
       

     

       46
       46
       +
       (** Get missing ranges from a list of chunks *)

     

       47
       47
       +
       val missing_ranges : t list -> total_size:int64 -> Range.t list

     

       48
       48
       +
       

     

       49
       49
       +
       (** Sort chunks by range start position *)

     

       50
       50
       +
       val sort_by_range : t list -> t list

     

       51
       51
       +
       

     

       52
       52
       +
       (** Pretty printer *)

     

       53
       53
       +
       val pp : Format.formatter -> t -> unit

+2 -2

stack/cacheio/lib/dune

···

       1
       1
        
       (library

     

       2
       2
        
        (public_name cacheio)

     

       3
       3
        
        (name cacheio)

     

       4
       4
       -
        (modules cacheio cacheio_flags cacheio_entry cacheio_stats cacheio_range cacheio_chunk)

     

       4
       4
       +
        (modules cacheio flags entry stats range chunk)

     

       5
       5
        
        (libraries eio eio_main digestif yojson ptime ptime.clock.os logs fmt xdge mirage-crypto-rng cstruct))

     

       6
       6
        
       

     

       7
       7
        
       (library

     

       8
       8
        
        (public_name cacheio.cmd)

     

       9
       9
        
        (name cacheio_cmd)

     

       10
       10
       -
        (modules cacheio_cmd)

     

       10
       10
       +
        (modules cmd)

     

       11
       11
        
        (libraries cacheio cmdliner eio eio_main xdge))

+57

stack/cacheio/lib/range.mli

···

       1
       1
       +
       (** Byte range management for partial downloads and chunked caching

     

       2
       2
       +
       

     

       3
       3
       +
           This module provides utilities for working with byte ranges,

     

       4
       4
       +
           primarily used for HTTP Range requests and partial file caching.

     

       5
       5
       +
           Ranges are inclusive on both ends (e.g., bytes 0-99 includes 100 bytes).

     

       6
       6
       +
       

     

       7
       7
       +
           {2 Example}

     

       8
       8
       +
       

     

       9
       9
       +
           {[

     

       10
       10
       +
           let r1 = Range.create ~start:0L ~end_:999L in

     

       11
       11
       +
           let r2 = Range.create ~start:1000L ~end_:1999L in

     

       12
       12
       +
           assert (Range.adjacent r1 r2 = true);

     

       13
       13
       +
           assert (Range.length r1 = 1000L);

     

       14
       14
       +
           match Range.merge r1 r2 with

     

       15
       15
       +
           | Some merged -> assert (Range.length merged = 2000L)

     

       16
       16
       +
           | None -> failwith "Should merge"

     

       17
       17
       +
           ]}*)

     

       18
       18
       +
       

     

       19
       19
       +
       (** A byte range with inclusive start and end positions.

     

       20
       20
       +
           For example, range [0,99] includes bytes 0 through 99 (100 bytes total). *)

     

       21
       21
       +
       type t

     

       22
       22
       +
       

     

       23
       23
       +
       (** Create a range from start to end (inclusive) *)

     

       24
       24
       +
       val create : start:int64 -> end_:int64 -> t

     

       25
       25
       +
       

     

       26
       26
       +
       (** Get the start position *)

     

       27
       27
       +
       val start : t -> int64

     

       28
       28
       +
       

     

       29
       29
       +
       (** Get the end position (inclusive) *)

     

       30
       30
       +
       val end_ : t -> int64

     

       31
       31
       +
       

     

       32
       32
       +
       (** Calculate the length of a range *)

     

       33
       33
       +
       val length : t -> int64

     

       34
       34
       +
       

     

       35
       35
       +
       (** Check if two ranges are adjacent (no gap between them) *)

     

       36
       36
       +
       val adjacent : t -> t -> bool

     

       37
       37
       +
       

     

       38
       38
       +
       (** Check if two ranges overlap *)

     

       39
       39
       +
       val overlaps : t -> t -> bool

     

       40
       40
       +
       

     

       41
       41
       +
       (** Check if a range contains a position *)

     

       42
       42
       +
       val contains : t -> int64 -> bool

     

       43
       43
       +
       

     

       44
       44
       +
       (** Merge two ranges if they overlap or are adjacent *)

     

       45
       45
       +
       val merge : t -> t -> t option

     

       46
       46
       +
       

     

       47
       47
       +
       (** Compare ranges by start position *)

     

       48
       48
       +
       val compare : t -> t -> int

     

       49
       49
       +
       

     

       50
       50
       +
       (** Convert to string format "start-end" *)

     

       51
       51
       +
       val to_string : t -> string

     

       52
       52
       +
       

     

       53
       53
       +
       (** Parse from string format "start-end" *)

     

       54
       54
       +
       val of_string : string -> t option

     

       55
       55
       +
       

     

       56
       56
       +
       (** Pretty printer *)

     

       57
       57
       +
       val pp : Format.formatter -> t -> unit