[mlir][sparse] Moved the ElementConsumer typedef to a "type alias"

[wrengr]

Summary

I tried to do this originally but didn't realize I needed the using syntax instead of the typedef syntax for templated type aliases. This change is broken out from D122060 just in case it's considered objectionable style.

Depends On D122060

[wrengr]

rebase

[wrengr]

rebase

[wrengr]

No local changes, but rebasing over newest version of parent D122060 for the sake of child D122061

[wrengr]

Rolled into D122060

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

for (uint64_t r = 0; r < rank; r++) {
       if (e1.indices[r] == e2.indices[r])
         continue;
       return e1.indices[r] < e2.indices[r];
     }
     return false;
   }
 };
 
+/// The type of callback functions which receive an element.  We avoid
+/// packaging the coordinates and value together as an `Element` object
+/// because this helps keep code somewhat cleaner.
+template <typename V>
+using ElementConsumer =
+    const std::function<void(const std::vector<uint64_t> &, V)> &;
+
 /// A memory-resident sparse tensor in coordinate scheme (collection of
 /// elements). This data structure is used to read a sparse tensor from
 /// any external format into memory and sort the elements lexicographically
 /// by indices before passing it back to the client (most packed storage
 /// formats require the elements to appear in lexicographic index order).
 template <typename V>
 struct SparseTensorCOO {
 public:
public:
   /// target-rank are always equal since we only support permutations.
   /// Though once we add support for other dimension mappings, this
   /// method will have to be split in two.)
   inline uint64_t getRank() const { return permsz.size(); }
 
   /// Returns the target tensor's dimension sizes.
   inline const std::vector<uint64_t> &permutedSizes() const { return permsz; }
 
-  /// The type of callback functions which receive an element (in target
-  /// order).  We avoid packaging the coordinates and value together
-  /// as an `Element` object because this helps keep code somewhat cleaner.
-  typedef const std::function<void(const std::vector<uint64_t> &, V)>
-      &ElementConsumer;
-
   /// Enumerates all elements of the source tensor, permutes their
   /// indices, and passes the permuted element to the callback.
   /// The callback must not store the cursor reference directly, since
   /// this function reuses the storage.  Instead, the callback must copy
   /// it if they want to keep it.
-  inline void forallElements(ElementConsumer yield) {
+  inline void forallElements(ElementConsumer<V> yield) {
     forallElements(yield, 0, 0);
   }
 
 private:
   /// The recursive component of the public `forallElements`.
-  void forallElements(ElementConsumer yield, uint64_t parentPos, uint64_t d) {
+  void forallElements(ElementConsumer<V> yield, uint64_t parentPos,
+                      uint64_t d) {
     if (d == getRank()) {
       // TODO: <https://github.com/llvm/llvm-project/issues/54179>
       yield(cursor, src.getValue(parentPos));
     } else if (src.isCompressedDim(d)) {
       const uint64_t pstart = src.getPointer(d, parentPos);
       const uint64_t pstop = src.getPointer(d, parentPos + 1);
       for (uint64_t pos = pstart; pos < pstop; pos++) {
         cursor[reord[d]] = src.getIndex(d, pos);