[mlir][sparse] minor cleanup of sparse tensor dialect ops

[aartbik]

Summary

Removed some whitespace, improved some of the ops doc.

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

def SparseTensor_OutOp : SparseTensor_Op<"out", []>,
   string description = [{
     Outputs the contents of a sparse tensor to the destination defined by an
     opaque pointer provided by `dest`. For targets that have access to a file
     system, for example, this pointer may specify a filename (or file) for output.
     The form of the operation is kept deliberately very general to allow for
     alternative implementations in the future, such as sending the contents to
     a buffer defined by a pointer.
 
+    Note that this operation is "impure" in the sense that its behavior
+    is solely defined by side-effects and not SSA values. The semantics
+    may be refined over time as our sparse abstractions evolve.
+
     Example:
 
     ```mlir
     sparse_tensor.out %t, %dest : tensor<1024x1024xf64, #CSR>, !Dest
     ```
   }];
   let assemblyFormat = "$tensor `,` $dest attr-dict `:` type($tensor) `,` type($dest)";
 }
def SparseTensor_SelectOp : SparseTensor_Op<"select", [NoSideEffect, SameOperandsAndResultType]>,
   }];
   let hasVerifier = 1;
 }
 
 def SparseTensor_YieldOp : SparseTensor_Op<"yield", [NoSideEffect, Terminator]>,
     Arguments<(ins Optional<AnyType>:$result)> {
   let summary = "Yield from sparse_tensor set-like operations";
   let description = [{
-      Yields a value from within a `binary`, `unary`, `reduce`, 
+      Yields a value from within a `binary`, `unary`, `reduce`,
       `select` or `foreach` block.
 
       Example:
 
-      ```
+      ```mlir
       %0 = sparse_tensor.unary %a : i64 to i64 {
         ^bb0(%arg0: i64):
           %cst = arith.constant 1 : i64
           %ret = arith.addi %arg0, %cst : i64
           sparse_tensor.yield %ret : i64
       }
       ```
   }];
let description = [{
 
      For a input sparse tensor with rank n, the block must take n + 1 arguments. The
      first n arguments must be Index type, together indicating the current coordinates
      of the element being visited. The last argument must have the same type as the
      sparse tensor's element type, representing the actual value loaded from the input
      tensor at the given coordinates.
 
      Example:
-     
      ```mlir
      sparse_tensor.foreach in %0 : tensor<?x?xf64, #DCSR> do {
       ^bb0(%arg1: index, %arg2: index, %arg3: f64):
         do something...
      }
      ```
   }];
-  
   let regions = (region AnyRegion:$region);
   let assemblyFormat = "`in` $tensor attr-dict `:` type($tensor)  `do` $region";
   let hasVerifier = 1;
 }
 
 #endif // SPARSETENSOR_OPS