Module Transform.Pipe

module Pipe: sig .. end

type ('a, 'b, 'c, 'd) t = private

`\|`	`Id : ('a0, 'a0, 'c0, 'c0) t`	`(*`	no transformation	`*)`
`\|`	`Fail : ('a1, 'b0, 'c1, 'd0) t`	`(*`	yields empty list	`*)`
`\|`	`Flatten : ('a2, 'b1 list, 'c2, 'd1) t -> ('a2, 'b1, 'c2, 'd1) t`
`\|`	`Close : ('b10 -> ('c10 -> 'd2) -> 'b2 * ('c20 -> 'd2)) * ('a3, 'b10, 'c10, 'd2) t -> ('a3, 'b2, 'c20, 'd2) t`
`\|`	`Comp : ('a4, 'b3, 'e, 'f) Transform.transformation * ('b3, 'c3, 'd3, 'e) t -> ('a4, 'c3, 'd3, 'f) t`
`\|`	`Fork : ('a5, 'b4, 'c4, 'd4) t * ('a5, 'b4, 'c4, 'd4) t -> ('a5, 'b4, 'c4, 'd4) t`

Composite transformation from 'a to 'b, with a reverse transformation from 'c to 'd

Every constructor from here is "smart":

val id : ('a, 'a, 'c, 'c) t

val fail : ('a, 'b, 'c, 'd) t

val flatten : ('a, 'b list, 'c, 'd) t -> ('a, 'b, 'c, 'd) t

val close : f:('b1 -> ('c1 -> 'd) -> 'b2 * ('c2 -> 'd)) ->
       ('a, 'b1, 'c1, 'd) t -> ('a, 'b2, 'c2, 'd) t

val compose : ('a, 'b, 'd1, 'e) Transform.transformation ->
       ('b, 'b2, 'c, 'd1) t -> ('a, 'b2, 'c, 'e) t

val (@@@) : ('a, 'b, 'd1, 'e) Transform.transformation ->
       ('b, 'b2, 'c, 'd1) t -> ('a, 'b2, 'c, 'e) t

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

val fork_l : ('a, 'b, 'c, 'd) t list -> ('a, 'b, 'c, 'd) t

val fork_comp : ('a, 'b, 'd1, 'e) Transform.transformation list ->
       ('b, 'b2, 'c, 'd1) t -> ('a, 'b2, 'c, 'e) t

val check : ('a, 'b, 'c, 'd) t -> unit

check pipe checks that the features of each component of the pipeline fit with their input. It is assumed we start with Transform.Features.full

val print : ('a, 'b, 'c, 'd) t Transform.printer