[NFC] Fix syntax of ranked memrefs in the MLIR Language Reference.

[jurahul]

Summary

• Eliminate incorrect |
• Eliminate memspace0 as the memory spaces currently are integer literals and memory space 0 is not explicitly printed.

mlir/docs/LangRef.md

 #### Memref Type
 
 Syntax:
 
 ```
 memref-type ::= ranked-memref-type | unranked-memref-type
 
 ranked-memref-type ::= `memref` `<` dimension-list-ranked tensor-memref-element-type
-                      (`,` layout-specification)? |
-                      (`,` memory-space)? `>`
+                      (`,` layout-specification)? (`,` memory-space)? `>`
 
 unranked-memref-type ::= `memref` `<*x` tensor-memref-element-type
                          (`,` memory-space)? `>`
 
 stride-list ::= `[` (dimension (`,` dimension)*)? `]`
 strided-layout ::= `offset:` dimension `,` `strides: ` stride-list
 layout-specification ::= semi-affine-map | strided-layout
 memory-space ::= integer-literal /* | TODO: address-space-id */

 // A layout that yields a padding on two at either end of the minor dimension.
 #padded = affine_map<(d0, d1) -> (d0, (d1 + 2) floordiv 2, (d1 + 2) mod 2)>
 
 
 // The dimension list "16x32" defines the following 2D index space:
 //
 //   { (i, j) : 0 <= i < 16, 0 <= j < 32 }
 //
-memref<16x32xf32, #identity, memspace0>
+memref<16x32xf32, #identity>
 
 // The dimension list "16x4x?" defines the following 3D index space:
 //
 //   { (i, j, k) : 0 <= i < 16, 0 <= j < 4, 0 <= k < N }
 //
 // where N is a symbol which represents the runtime value of the size of
 // the third dimension.
 //
 // %N here binds to the size of the third dimension.
-%A = alloc(%N) : memref<16x4x?xf32, #col_major, memspace0>
+%A = alloc(%N) : memref<16x4x?xf32, #col_major>
 
 // A 2-d dynamic shaped memref that also has a dynamically sized tiled layout.
 // The memref index space is of size %M x %N, while %B1 and %B2 bind to the
 // symbols s0, s1 respectively of the layout map #tiled_dynamic. Data tiles of
 // size %B1 x %B2 in the logical space will be stored contiguously in memory.
 // The allocation size will be (%M ceildiv %B1) * %B1 * (%N ceildiv %B2) * %B2
 // f32 elements.
 %T = alloc(%M, %N) [%B1, %B2] : memref<?x?xf32, #tiled_dynamic>

 Data is accessed through a memref type using a multidimensional index into the
 multidimensional index space defined by the memref's dimension list.
 
 Examples
 
 ```mlir
 // Allocates a memref with 2D index space:
 //   { (i, j) : 0 <= i < 16, 0 <= j < 32 }
-%A = alloc() : memref<16x32xf32, #imapA, memspace0>
+%A = alloc() : memref<16x32xf32, #imapA>
 
 // Loads data from memref '%A' using a 2D index: (%i, %j)
-%v = load %A[%i, %j] : memref<16x32xf32, #imapA, memspace0>
+%v = load %A[%i, %j] : memref<16x32xf32, #imapA>
 ```
 
 ##### Index Map
 
 An index map is a one-to-one
 [semi-affine map](Dialects/Affine.md#semi-affine-maps) that transforms a
 multidimensional index from one index space to another. For example, the
 following figure shows an index map which maps a 2-dimensional index from a 2x2