code: def create(cls, rule_entries, union_rules=None):
      
      serializable_rules = OrderedDict()
      serializable_roots = OrderedSet()
      union_rules = OrderedDict(union_rules or ())
  
      def add_task(product_type, rule):
        # TODO(#7311): make a defaultdict-like wrapper for OrderedDict if more widely used.
        if product_type not in serializable_rules:
          serializable_rules[product_type] = OrderedSet()
        serializable_rules[product_type].add(rule)
  
      def add_root_rule(root_rule):
        serializable_roots.add(root_rule)
  
      def add_rule(rule):
        if isinstance(rule, RootRule):
          add_root_rule(rule)
        else:
          add_task(rule.output_type, rule)
        for dep_rule in rule.dependency_rules:
          add_rule(dep_rule)
  
      def add_type_transition_rule(union_rule):
        # NB: This does not require that union bases be supplied to `def rules():`, as the union type
        # is never instantiated!
        union_base = union_rule.union_base
        assert union_base._is_union
        union_member = union_rule.union_member
        if union_base not in union_rules:
          union_rules[union_base] = OrderedSet()
        union_rules[union_base].add(union_member)
  
      for entry in rule_entries:
        if isinstance(entry, Rule):
          add_rule(entry)
        elif isinstance(entry, UnionRule):
          add_type_transition_rule(entry)
        elif hasattr(entry, '__call__'):
          rule = getattr(entry, 'rule', None)
          if rule is None:
            raise TypeError("Expected callable {} to be decorated with @rule.".format(entry))
          add_rule(rule)
        else:
          raise TypeError("""\
  Rule entry {} had an unexpected type: {}. Rules either extend Rule or UnionRule, or are static \
  functions decorated with @rule.""".format(entry, type(entry)))
  
      return cls(serializable_rules, serializable_roots, union_rules)
docs: Creates a RuleIndex with tasks indexed by their output type.