Module `CCIO`

IO Utils

Simple utilities to deal with basic Input/Output tasks in a resource-safe way. For advanced IO tasks, the user is advised to use something like Lwt or Async, that are far more comprehensive.

Examples:

obtain the list of lines of a file:

# let l = CCIO.(with_in "/tmp/some_file" read_lines_l);;

transfer one file into another:

# CCIO.(
    with_in "/tmp/input"
      (fun ic ->
         let chunks = read_chunks ic in
         with_out ~flags:[Open_binary] ~mode:0o644 "/tmp/output"
           (fun oc ->
              write_gen oc chunks
           )
      )
  ) ;;

since: 0.6

before 0.12: was in 'containers.io', now moved into 'containers'

type 'a or_error = ('a, string) Result.result
type 'a gen = unit -> 'a option: See Gen in the gen library.

Input

val with_in : ?⁠mode:int -> ?⁠flags:Stdlib.open_flag list -> string -> (Stdlib.in_channel -> 'a) -> 'a

Open an input file with the given optional flag list, calls the function on the input channel. When the function raises or returns, the channel is closed.

raises Sys_error: in case of error (same as open_in and close_in).

parameter flags: opening flags (default [Open_text]). Open_rdonly is used in any cases.

val read_chunks : ?⁠size:int -> Stdlib.in_channel -> string gen: Read the channel's content into chunks of size size.

val read_line : Stdlib.in_channel -> string option: Read a line from the channel. Returns None if the input is terminated. The "\n" is removed from the line.

val read_lines : Stdlib.in_channel -> string gen: Read all lines. The generator should be traversed only once.

val read_lines_l : Stdlib.in_channel -> string list: Read all lines into a list.

val read_all : ?⁠size:int -> Stdlib.in_channel -> string

Read the whole channel into a buffer, then converted into a string.

parameter size: the internal buffer size.

since: 0.7

val read_all_bytes : ?⁠size:int -> Stdlib.in_channel -> Stdlib.Bytes.t

Read the whole channel into a mutable byte array.

parameter size: the internal buffer size.

since: 0.12

Output

val with_out : ?⁠mode:int -> ?⁠flags:Stdlib.open_flag list -> string -> (Stdlib.out_channel -> 'a) -> 'a

Like with_in but for an output channel.

parameter flags: opening flags (default [Open_creat; Open_trunc; Open_text]).

raises Sys_error: in case of error (same as open_out and close_out). Open_wronly is used in any cases.

val with_out_a : ?⁠mode:int -> ?⁠flags:Stdlib.open_flag list -> string -> (Stdlib.out_channel -> 'a) -> 'a

Like with_out but with the [Open_append; Open_creat; Open_wronly] flags activated, to append to the file.

raises Sys_error: in case of error (same as open_out and close_out).

val write_line : Stdlib.out_channel -> string -> unit: Write the given string on the channel, followed by "\n".

val write_gen : ?⁠sep:string -> Stdlib.out_channel -> string gen -> unit: Write the given strings on the output. If provided, add sep between every two strings (but not at the end).

val write_lines : Stdlib.out_channel -> string gen -> unit: Write every string on the output, followed by "\n".

val write_lines_l : Stdlib.out_channel -> string list -> unit

Both

val with_in_out : ?⁠mode:int -> ?⁠flags:Stdlib.open_flag list -> string -> (Stdlib.in_channel -> Stdlib.out_channel -> 'a) -> 'a

Combines with_in and with_out.

parameter flags: opening flags (default [Open_creat]).

raises Sys_error: in case of error.

since: 0.12

Misc for Generators

val tee : ('a -> unit) list -> 'a gen -> 'a gen: tee funs gen behaves like gen, but each element is given to every function f in funs at the time the element is produced.

File and file names

How to list recursively files in a directory:

# let files = CCIO.File.read_dir ~recurse:true (CCIO.File.make "/tmp");;
# CCIO.write_lines stdout files;;

See File.walk if you also need to list directories:

# let content = CCIO.File.walk (CCIO.File.make "/tmp");;
# Gen.map CCIO.File.show_walk_item content |> CCIO.write_lines stdout;;

module File : sig ... end