code: def overloaded_build(type_, add_name=None):
      
      typename = type_.__name__
      instrname = 'BUILD_' + typename.upper()
      dict_ = OrderedDict(
          __doc__=dedent(
              """
              A CodeTransformer for overloading {name} instructions.
              """.format(name=instrname)
          )
      )
  
      try:
          build_instr = getattr(instructions, instrname)
      except AttributeError:
          raise TypeError("type %s is not buildable" % typename)
  
      if add_name is not None:
          try:
              add_instr = getattr(
                  instructions,
                  '_'.join((typename, add_name)).upper(),
              )
          except AttributeError:
              TypeError("type %s is not addable" % typename)
  
          dict_['_start_comprehension'] = pattern(
              build_instr, matchany[var], add_instr,
          )(_start_comprehension)
          dict_['_return_value'] = pattern(
              instructions.RETURN_VALUE, startcodes=(IN_COMPREHENSION,),
          )(_return_value)
      else:
          add_instr = None
  
      dict_['_build'] = pattern(build_instr)(_build)
  
      if not typename.endswith('s'):
          typename = typename + 's'
  
      return type(
          'overloaded_' + typename,
          (overloaded_constants(type_),),
          dict_,
      )
docs: Factory for constant transformers that apply to a given
      build instruction.
  
      Parameters
      ----------
      type_ : type
          The object type to overload the construction of. This must be one of
          "buildable" types, or types with a "BUILD_*" instruction.
      add_name : str, optional
          The suffix of the instruction tha adds elements to the collection.
          For example: 'add' or 'append'
  
      Returns
      -------
      transformer : subclass of CodeTransformer
          A new code transformer class that will overload the provided
          literal types.