# Module Type_generic.S.Computation

    module Computation: Type_generic.Computation  with type 'a t = 'a t

exported to build a computation on top of a previous one

    type 'a t

    include Type_generic.Variant_and_record_intf.S

    val int : int t

    val int32 : int32 t

    val int64 : int64 t

    val nativeint : nativeint t

    val char : char t

    val float : float t

    val string : string t

    val bool : bool t

    val unit : unit t

    val option : 'a t -> 'a option t

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

    val array : 'a t -> 'a array t

    val lazy_t : 'a t -> 'a lazy_t t

    val ref_ : 'a t -> 'a Pervasives.ref t

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

    val tuple2 : 'a t ->
           'b t -> ('a * 'b) t

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

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

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

    val record : 'a Record.t -> 'a t

    val variant : 'a Variant.t -> 'a t

    module Named: Type_generic.Named  with type 'a computation := 'a t