rev: tip feather/feather.mli -rw-r--r-- 3.5 KiB View raw Log this file
e0f98837d3d1Charles Chamberlain Update readme 3 months ago
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
open Core

type cmd

val process : string -> string list -> cmd
(** [process] constructs a new command *)

(* === Basic commands === *)

val cat : string -> cmd

val echo : string -> cmd

val ls : string -> cmd

val sh : string -> cmd

val rg : ?in_:string -> string -> cmd
(** [in_] is the directory that should be rg'd: rg <search> <in>. Without it, it'll filter
    stdin, just rg <search> *)

val rg_v : ?in_:string -> string -> cmd

val find :
  ?include_starting_dir:bool ->
    (** [include_starting_dir]: whether to include the starting directory
        passed into [find]. Defaults to [false], notably different than the unix
        find utility.  *)
  ?ignore_hidden:bool ->
  ?kind:[ `Files | `Directories ] ->
  ?name:string ->
  ?depth:int ->
    (** [depth]: The maximum search depth *)
  string ->
  cmd

val tr : string -> string -> cmd

val tr_d : string -> cmd

val grep : ?in_:string -> string -> cmd

val mkdir : string -> cmd

val mkdir_p : string -> cmd

val pwd : cmd

val less : cmd

val sort : cmd

val uniq : cmd

val shuf : cmd

val head : ?file:string -> int -> cmd

val tail : ?file:string -> int -> cmd

val tail_f : string -> cmd

val cp : string -> string -> cmd

val cp_r : string -> string -> cmd

val mv : string -> string -> cmd

val sed :
  ?g:bool (** defaults to TRUE *) ->
  string (** pattern *) ->
  string (** replacement *) ->
  cmd

val cut : ?d:char (** defaults to a space *) -> int -> cmd

val cut' : ?complement:unit -> ?d:char -> int list -> cmd


(* === Using [cmd]'s in OCaml === *)

val ( |. ) : cmd -> cmd -> cmd
(** [ |. ] is feather's version of a "|" in bash. *)

val collect_lines :
  ?cwd:string -> ?env:(string * string) list -> cmd -> string list

val collect_stdout : ?cwd:string -> ?env:(string * string) list -> cmd -> string

val map_lines : f:(string -> string) -> cmd

val filter_lines : f:(string -> bool) -> cmd
(** [map] within a series of pipes will be run in a thread.  *)

val run : ?cwd:string -> ?env:(string * string) list -> cmd -> unit

val run_bg : ?cwd:string -> ?env:(string * string) list -> cmd -> unit
(** Run the process in a thread. Use [wait] to ensure that the parent
 won't exit, subsequently killing the background process. *)

(* Redirection *)

val write_stdout_to : string -> cmd -> cmd

val append_stdout_to : string -> cmd -> cmd

val write_stderr_to : string -> cmd -> cmd

val append_stderr_to : string -> cmd -> cmd

module File_redirection_infix : sig
  (* Stdout *)
  val ( > ) : cmd -> string -> cmd

  val ( >> ) : cmd -> string -> cmd

  (* Stderr *)
  val ( >! ) : cmd -> string -> cmd

  val ( >>! ) : cmd -> string -> cmd

  val ( < ) : cmd -> string -> cmd
end

val stdout_to_stderr : cmd -> cmd

val stderr_to_stdout : cmd -> cmd
(** [stdout_to_stderr] and [stderr_to_stdout] are NOT composable!
    Think of these functions as each creating a new command with the given redirection.

    Applying both will result in no output to either stdout or stderr.
    [flip_stdout_and_stderr] should be easy to write if anyone should need it. *)

(* === Misc === *)

val devnull : string
(** [devnull] is easier to type than "/dev/null" *)

val last_exit : unit -> int
(** [last_exit] returns the exit status of the last child process to have exited *)

val fzf : ?cwd:string -> ?env:(string * string) list -> cmd -> string option
(** [fzf] runs the command, and fuzzy finds the stdout.
   Returns [None] if no item was chosen, [Some str] otherwise

   Note that [fzf] is a way to to run a [cmd] and does not in itself return a
   [cmd]. *)

val debug : bool ref