class_docstr: This is the type for argmax and argmin in Sempre. The type signature is <d,<d,<#1,<<d,#1>,#1>>>>.
  Example: (argmax (number 1) (number 1) (fb:row.row.league fb:cell.usl_a_league) fb:row.row.index)
  meaning, of the subset of rows where league == usl_a_league, find the row with the maximum index.
docstr: See ``PlaceholderType.resolve``
docstr_tok: ["See","``","PlaceholderType.resolve","``"]
code: def resolve(self, other):
      """See ``PlaceholderType.resolve``"""
      if not isinstance(other, NltkComplexType):
          return None
      expected_second = ComplexType(
          NUMBER_TYPE,
          ComplexType(
              ANY_TYPE,
              ComplexType(ComplexType(ANY_TYPE, ANY_TYPE), ANY_TYPE),
          ),
      )
      resolved_second = other.second.resolve(expected_second)
      if resolved_second is None:
          return None
  
      # The lambda function that we use inside the argmax  must take either a number or a date as
      # an argument.
      lambda_arg_type = other.second.second.second.first.first
      if (
          lambda_arg_type.resolve(NUMBER_TYPE) is None
          and lambda_arg_type.resolve(DATE_TYPE) is None
      ):
          return None
  
      try:
          # This is the first #1 in the type signature above.
          selector_function_type = resolved_second.second.first
          # This is the second #1 in the type signature above.
          quant_function_argument_type = (
              resolved_second.second.second.first.second
          )
          # This is the third #1 in the type signature above.
          return_type = resolved_second.second.second.second
  
          # All three placeholder (ph) types above should resolve against each other.
          resolved_first_ph = selector_function_type.resolve(
              quant_function_argument_type
          )
          resolved_first_ph.resolve(return_type)
  
          resolved_second_ph = quant_function_argument_type.resolve(
              resolved_first_ph
          )
          resolved_second_ph.resolve(return_type)
  
          resolved_third_ph = return_type.resolve(resolved_first_ph)
          resolved_third_ph = return_type.resolve(resolved_second_ph)
  
          if (
              not resolved_first_ph
              or not resolved_second_ph
              or not resolved_third_ph
          ):
              return None
  
          return ArgExtremeType(resolved_first_ph, lambda_arg_type)
      except AttributeError:
          return None
  
imports: from __future__ import absolute_import
  from nltk.sem.logic import Type, BasicType, ANY_TYPE, ComplexType
  from allennlp.semparse.type_declarations.type_declaration import ComplexType, HigherOrderType
  from allennlp.semparse.type_declarations.type_declaration import PlaceholderType, NamedBasicType
  from allennlp.semparse.type_declarations.type_declaration import UnaryOpType, BinaryOpType
label_desc: Use image node_id 2 for calling the ArgExtremeType obj's underlying member method code with example usage: obj.resolve(other) and returns: None, None, None, ArgExtremeType, None, None