module Make:functor (
Shtream
:
AnyShtream.S
) ->
FittingSig.S
with type initial = Shtream.initial and type 'a elem = 'a Shtream.elem and type 'a shtream = 'a Shtream.t and type 'a coshtream = 'a Shtream.co_t
Shtream
parameter specifies the
underlying shtream implementation to use.Parameters: |
|
type ('b -> 'c)
t
'a
and produces
values of type 'b
.type 'a
elem
type
initial
FittingSig.S.elem
for specifying
the type of elements that fittings know how to read from
external processes. That is, fittings constructed from external
processes produce values of type initial elem
.type 'a
shtream
type 'a
coshtream
typeprocref =
Channel.procref
Channel.procref
typetext =
initial elem
val (-|) : ('a -> 'b) t ->
('b -> 'c) t -> ('a -> 'c) t
val pipe : ('i -> 'm) t ->
('m -> 'o) t -> ('i -> 'o) t
FittingSig.S.(-|)
Producers are useful for starting off pipelines.
val from_file : string -> ('i -> text) t
from_file file -| fitting
is like % fitting < file
val from_null : ('i -> text) t
from_null -| fitting
is like % fitting < /dev/null
val from_gen : Channel.dup_in_source -> ('i -> text) t
Channel.dup_in_source
.val from_shtream : 'o shtream -> ('i -> 'o) t
Consumers are useful for ending pipelines.
val to_file : ?clobber:Channel.clobber_spec ->
string -> ('i elem -> 'o) t
Channel.clobber_spec
for open modes.
fitting -| to_file file
is like % fitting > file
val to_null : ('i elem -> 'o) t
fitting -| to_null
is like % fitting > /dev/null
val to_stderr : ('i elem -> 'o) t
fitting -| to_stderr
is like % fitting >&2
val to_gen : Channel.dup_out_source -> ('i elem -> 'o) t
Channel.dup_out_source
.val to_coshtream : 'i coshtream -> ('i -> 'o) t
val command : string -> ('i elem -> text) t
Channel.open_command
.val program : ?path:bool ->
string ->
?argv0:string ->
string list -> ('i elem -> text) t
Channel.open_program
.val thunk : (unit -> unit) -> ('i elem -> text) t
val sed : ('i -> 'o) -> ('i -> 'o) t
val grep : ('i -> bool) -> ('i -> 'i) t
val trans : ('i shtream -> 'o shtream) ->
('i -> 'o) t
val sed_string : (string -> 'o) -> ('i elem -> 'o) t
FittingSig.S.sed
with a lift from strings.val grep_string : (string -> bool) ->
('i elem -> 'i elem) t
val (/</) : (text -> 'o) t ->
Channel.dup_spec -> (text -> 'o) t
fitting /</ dups
performs the redirections specifed by dups
for the extent
of fitting
. For example,
fitting /</ [ 4 %<& 0; 0 %< "file" ]
is like
% fitting 4<&0 <file
val redirect_in : Channel.dup_spec ->
(text -> 'o) t ->
(text -> 'o) t
FittingSig.S.(/</)
val (/>/) : ('i -> 'o elem) t ->
Channel.dup_spec -> ('i -> 'o elem) t
fitting />/ dups
performs the redirections specifed by dups
for the extent
of fitting
. For example,
fitting />/ [ 2 %>& 1 ]
is like
% fitting 2>&1
val redirect_out : Channel.dup_spec ->
('i -> 'o elem) t ->
('i -> 'o elem) t
FittingSig.S.(/>/)
val (^>>=) : ('i -> 'o) t ->
(Proc.status -> ('i -> 'o) t) -> ('i -> 'o) t
The exit code of external processes is the actual exit code as
reported by Proc.wait
. The exit code of a shtream is 0 unless
the shtream terminates by calling Shtream.fail_with n
, in which
case the code in n
. Or, FittingSig.S.yield
can return an exit code
directly.
val seq : ('i -> 'o) t ->
(Proc.status -> ('i -> 'o) t) -> ('i -> 'o) t
FittingSig.S.(^>>=)
val (^>>) : ('i -> 'o) t ->
('i -> 'o) t -> ('i -> 'o) t
a ^>> b
is exactly a ^>>= fun _ -> b
.
This is like ;
in the shell.val (&&^) : ('i -> 'o) t ->
('i -> 'o) t -> ('i -> 'o) t
&&
in the shell.val (||^) : ('i -> 'o) t ->
('i -> 'o) t -> ('i -> 'o) t
||
in the shell.val (~>>) : ('i -> 'o) t list -> ('i -> 'o) t
FittingSig.S.(^>>)
.val (~&&) : ('i -> 'o) t list -> ('i -> 'o) t
FittingSig.S.(&&^)
.
Terminates the sequence when any component fails.val (~||) : ('i -> 'o) t list -> ('i -> 'o) t
FittingSig.S.(||^)
.
Terminates the sequence when any component succeeds.val commands : string list -> (text -> text) t
val yield : Proc.status -> ('i -> 'o) t
val caml : (unit -> ('i -> 'o) t) -> ('i -> 'o) t
FittingSig.S.caml
constructs a new fitting that,
when run, forces the thunk and runs the resulting fitting.
This allows for OCaml side-effects at arbitrary points during a
fitting.val (^&=) : (text -> 'b elem) t ->
(Proc.t -> ('i -> 'o) t) -> ('i -> 'o) t
bg ^&= fg
runs bg
in the background, passed its Proc.t
to fg
, and runs
the fitting returned by fg
(in the foreground).
Notice that the bg
must have input type FittingSig.S.text
; it will
construct its own input shtream from the standard input.
val par : (text -> 'b elem) t ->
(Proc.t -> ('i -> 'o) t) -> ('i -> 'o) t
FittingSig.S.(^&=)
val (^&) : (text -> 'b elem) t ->
('i -> 'o) t -> ('i -> 'o) t
Proc.t
. This
backgrounds its first argument and then continues with its second
argument in the foreground.val run_source : (text -> 'o) t -> 'o shtream
val run_sink : ('i -> 'o elem) t -> 'i coshtream
val run_list : (text -> 'o) t -> 'o list
val run_shtream : ('i -> 'o) t ->
'i shtream -> 'o shtream
val run_in : ?procref:procref ->
(text -> 'o elem) t ->
Pervasives.in_channel
in_channel
. The fitting
will take its input from the standard input. If ?procref
is
provided, the Proc.t
of the child process will be stashed.val run_out : ?procref:procref ->
(text -> 'o elem) t ->
Pervasives.out_channel
out_channel
. The fitting
will send its output from the standard output. If ?procref
is
provided, the Proc.t
of the child process will be stashed.val run_backquote : ?procref:procref ->
(text -> 'o elem) t -> string
?procref
.val run_bg : (text -> 'o elem) t -> Proc.t
Proc.t
.
The fitting will take its input from the standard input and send
its output to the standard output.val run : (text -> 'o elem) t -> Proc.status
These conversions use the FittingSig.S.elem
conversions provided to the
Fitting.Make
functor by AnyShtream.ELEM
. The conversion
AnyShtream.ELEM.string_of
or AnyShtream.ELEM.of_string
is completely applied for each of these conversions, so no state
(should there be any) is retained in between calls.
val string_of_elem : 'a elem -> string
val elem_of_string : string -> text
val int_of_elem : 'a elem -> int
val elem_of_int : int -> text
val char_of_elem : 'a elem -> char
val elem_of_char : char -> text
val float_of_elem : 'a elem -> float
val elem_of_float : float -> text
val bool_of_elem : 'a elem -> bool
val elem_of_bool : bool -> text