class_docstr: Represents the type of a TensorFlow function.
  
  FunctionType is the canonical way to represent the input/output contract of
  all kinds of functions within the tf.function domain, including:
    - Polymorphic Function
    - Concrete Function
    - Atomic Function
  
  It provides consistent, centralized and layered logic for:
    - Canonicalization of Python input arguments
    - Type-based dispatch to monomorphic functions
    - Packing/unpacking structured python values to Tensors
    - Generation of structured placeholder values for tracing
  
  Additionaly, it also provides:
    - Lossless serialization
    - Native integration with Python function signature representation
    - Seamless migration from older representation formats
docstr: Returns a common subtype (if exists).
docstr_tok: ["Returns","a","common","subtype","(","if","exists",")","."]
code: def most_specific_common_subtype(
      self, others: Sequence["FunctionType"]
  ) -> Optional["FunctionType"]:
      """Returns a common subtype (if exists)."""
      subtyped_parameters = []
  
      for i, parameter in enumerate(self.parameters.values()):
          # Functions are contravariant on their parameter types.
          subtyped_parameter = parameter.most_specific_common_supertype(
              [list(other.parameters.values())[i] for other in others]
          )
          if subtyped_parameter is None:
              return None
          subtyped_parameters.append(subtyped_parameter)
  
      if not all(subtyped_parameters):
          return None
  
      # Common subtype has superset of all captures.
      capture_names = set(self.captures.keys())
      for other in others:
          capture_names = capture_names.union(other.captures.keys())
  
      subtyped_captures = collections.OrderedDict()
      for name in capture_names:
          containing = [
              t for t in [self, *others] if name in t.captures
          ]
          # Pick the first type that has the capture as the base.
          base = containing[0]
          relevant_others = containing[1:]
  
          # Functions are contravariant upon the capture types.
          common_type = base.captures[
              name
          ].most_specific_common_supertype(
              [other.captures[name] for other in relevant_others]
          )
          if common_type is None:
              return None
          else:
              subtyped_captures[name] = common_type
  
      return FunctionType(subtyped_parameters, subtyped_captures)
  
imports: import collections
  import inspect
  from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Tuple
  from absl import logging
  from tensorflow.core.function import trace_type
  from tensorflow.core.function.polymorphism import function_type_pb2
  from tensorflow.core.function.trace_type import serialization
  from tensorflow.python.types import core
  from tensorflow.python.types import trace
label_desc: Use image node_id 11 for calling the FunctionType obj's underlying member method code with example usage: obj.most_specific_common_subtype(others) and returns: FunctionType, None, None, None