bistro 0.6.0 (latest) · OCaml Package

type path =

val cd : path -> string list -> path

module Docker_image : sig ... end

module Singularity_image : sig ... end

type container_image =

val docker_image : 
  ?tag:string ->
  ?registry:string ->
  account:string ->
  name:string ->
  unit ->
  container_image

type _ t =

| Pure : {
1. id : string;
2. value : 'a;
} -> 'a t
| App : {
1. id : string;
2. f : ('a -> 'b) t;
3. x : 'a t;
} -> 'b t
| Both : {
1. id : string;
2. fst : 'a t;
3. snd : 'b t;
} -> ('a * 'b) t
| List : {
1. id : string;
2. elts : 'a t list;
} -> 'a list t
| Eval_path : {
1. id : string;
2. workflow : path t;
} -> string t
| Spawn : {
1. id : string;
2. elts : 'a list t;
3. f : 'a t -> 'b t;
4. deps : any list;
} -> 'b list t
| List_nth : {
1. id : string;
2. elts : 'a list t;
3. index : int;
} -> 'a t
| Input : {
1. id : string;
2. path : string;
3. version : int option;
} -> path t
| Select : {
1. id : string;
2. dir : path t;
3. sel : string list;
} -> path t
| Plugin : ('a plugin, any) step -> 'a t
| Shell : (shell_command, any) step -> path t
| Glob : {
1. id : string;
2. pattern : string option;
3. type_selection : [ `File | `Directory ] option;
4. dir : path t;
} -> path list t
| Trywith : {
1. id : string;
2. w : 'a t;
3. failsafe : 'a t;
} -> 'a t
| Ifelse : {
1. id : string;
2. cond : bool t;
3. _then_ : 'a t;
4. _else_ : 'a t;
} -> 'a t

and ('a, 'b) step = {

}

and 'a plugin =

and shell_command = {

}

and token =

| Path_token of path t
| Path_list_token of {
1. elts : path list t;
2. sep : string;
3. quote : char option;
}
| String_token of string t

and any =

val digest : 'a -> string

val id : 's. 's t -> string

val any : 'a t -> any

val compare_token : token -> token -> int

module Any : sig ... end

val input : ?version:int -> string -> path t

val select : path t -> string list -> path t

val pure : id:string -> 'a -> 'b t

val data : 'a -> 'b t

val int : 'a -> 'a t

val string : 'a -> 'a t

val app : ('a -> 'b) t -> 'c t -> 'd t

val ($) : ('a -> 'b) t -> 'a t -> 'b t

val both : 'a t -> 'b t -> ('c * 'd) t

val add_mem_dep : 'a t option -> any list -> any list

val plugin : 
  ?descr:string ->
  ?np:int ->
  ?mem:int t ->
  ?version:int ->
  (unit -> 'a) t ->
  'b t

val path_plugin : 
  ?descr:string ->
  ?np:int ->
  ?mem:int t ->
  ?version:int ->
  (string -> unit) t ->
  path t

val path : path t -> string t

val digestible_cmd : token Command.t -> string Command.t

val shell : 
  ?descr:string ->
  ?mem:int t ->
  ?np:int ->
  ?version:int ->
  ?img:container_image list ->
  token Command.t list ->
  path t

val list : 'a t list -> 'b list t

val independent_workflows_aux : 
  (bool * Any.Set.t) Any.Map.t ->
  Any.Map.key ->
  from:any ->
  (bool * Any.Set.t) Any.Map.t

val independent_workflows : Any.Map.key -> from:any -> Any.Set.elt list

val spawn : 'a list t -> f:('b t -> 'c t) -> 'd list t

val list_nth : 'a list t -> int -> 'b t

val glob : 
  ?pattern:string ->
  ?type_selection:[ `Directory | `File ] ->
  path t ->
  path list t

val trywith : 'a t -> 'b t -> 'c t

val ifelse : bool t -> 'a t -> 'b t -> 'c t

package bistro