# Module Std.Typename

    module Typename: Typename

    type 'a t

    type 'a typename = 'a t

    val create : ?name:string -> unit -> 'a t

    val static : unit t

    val same : 'a t -> 'b t -> bool

nominal type equality test

    val same_witness : 'a t -> 'b t -> ('a, 'b) Type_equal.t option

    val same_witness_exn : 'a t -> 'b t -> ('a, 'b) Type_equal.t

    module Key: sig .. end

a runtime representation of fully applied type `'a`

    val key : 'a t -> Key.t

    module Uid: sig .. end

an untyped runtime representation of non applied type

    val uid : 'a t -> Uid.t

    val name : 'a t -> string

    module type S0 = sig .. end

    module type S1 = sig .. end

    module type S2 = sig .. end

    module type S3 = sig .. end

    module type S4 = sig .. end

    module type S5 = sig .. end

    module Make0: functor (X : Named_intf.S0) -> S0
      with type t := X.t

    module Make1: functor (X : Named_intf.S1) -> S1
      with type 'a t := 'a X.t

    module Make2: functor (X : Named_intf.S2) -> S2
      with type ('a, 'b) t := ('a, 'b) X.t

    module Make3: functor (X : Named_intf.S3) -> S3
      with type ('a, 'b, 'c) t := ('a, 'b, 'c) X.t

    module Make4: functor (X : Named_intf.S4) -> S4
      with type ('a, 'b, 'c, 'd) t := ('a, 'b, 'c, 'd) X.t

    module Make5: functor (X : Named_intf.S5) -> S5
      with type ('a, 'b, 'c, 'd, 'e) t := ('a, 'b, 'c, 'd, 'e) X.t

    module Table: functor (X : sig

    type 'a t

    end) -> sig .. end

    module Same_witness_exn_1: functor (A : S1) -> functor (B : S1) -> sig .. end

    module Same_witness_exn_2: functor (A : S2) -> functor (B : S2) -> sig .. end

    module Same_witness_exn_3: functor (A : S3) -> functor (B : S3) -> sig .. end

    module Same_witness_exn_4: functor (A : S4) -> functor (B : S4) -> sig .. end

    module Same_witness_exn_5: functor (A : S5) -> functor (B : S5) -> sig .. end