[mlir][OpDSL] Rename `PrimFn` to `ArithFn`.

[gysit]

Summary

The revision renames PrimFn to ArithFn. The name resembles the newly introduced arith dialect that implements most of the arithmetic functions. An exception are log/exp that are part of the math dialect.

Depends On D115239

[gysit]

Fix formatting of templated code.

[gysit]

Improve doc.

[gysit]

Rebase.

mlir/docs/Dialects/Linalg/OpDSL.md

 The bulk of language consists of assignment expressions of the form above. The
 iteration dimension order is determined lexically based on the order encountered
 in the expression (following operator precedence if math operators are used).
 TODO: Introduce a directive to fix the dimension bindings.
 
 Reduction dimensions are inferred to be any dimensions on the RHS that are not
 on the LHS.
 
-A number of arithmetic primitive functions are supported:
+A number of arithmetic functions are supported:
 
-*   `PrimFn.add(a, b)` (also via overloading the binary `+` operator)
-*   `PrimFn.exp(a)`
-*   `PrimFn.log(a)`
-*   `PrimFn.mul(a, b)` (also via overloading the binary `*` operator)
-*   `PrimFn.max(a, b)`
-*   `PrimFn.sub(a, b)` (also via overloading the binary `-` operator)
+*   `ArithFn.add(a, b)` (also via overloading the binary `+` operator)
+*   `ArithFn.exp(a)`
+*   `ArithFn.log(a)`
+*   `ArithFn.mul(a, b)` (also via overloading the binary `*` operator)
+*   `ArithFn.max(a, b)`
+*   `ArithFn.min(a, b)`
+*   `ArithFn.sub(a, b)` (also via overloading the binary `-` operator)
+*   `ArithFn.max_unsigned(a, b)`
+*   `ArithFn.min_unsigned(a, b)`
 
 Reduction functions can appear as the outer-most function on the RHS:
 
 *   `ReduceFn.add` (also overloading the inplace `+=` on a LHS)
 *   `ReduceFn.mul`
 *   `ReduceFn.max`
 
 Type functions cast the `operand` to the target type `TypeVar` applying signed

mlir/include/mlir/Dialect/Linalg/IR/LinalgNamedStructuredOps.yaml

structured_op: !LinalgStructuredOpConfig
   iterator_types:
   - parallel
   - parallel
   - reduction
   assignments:
   - !ScalarAssign
     arg: C
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: C
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   iterator_types:
   - parallel
   - parallel
   - reduction
   assignments:
   - !ScalarAssign
     arg: C
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: C
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast_unsigned
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   iterator_types:
   - parallel
   - parallel
   - reduction
   assignments:
   - !ScalarAssign
     arg: C
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: C
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: sub
                 operands:
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
                       scalar_arg: A
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
                       scalar_arg: AZp
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: sub
                 operands:
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - reduction
   - parallel
   - parallel
   - reduction
   assignments:
   - !ScalarAssign
     arg: accum
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: accum
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: AccumType
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - parallel
   - parallel
   - reduction
   assignments:
   - !ScalarAssign
     arg: C
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: C
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - parallel
   - parallel
   - reduction
   assignments:
   - !ScalarAssign
     arg: C
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: C
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: sub
                 operands:
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
                       scalar_arg: A
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
                       scalar_arg: AZp
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: sub
                 operands:
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
indexing_maps: !LinalgIndexingMapsConfig
     - affine_map<(d0, d1)[s0, s1] -> (d0)>
   iterator_types:
   - parallel
   - reduction
   assignments:
   - !ScalarAssign
     arg: x
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: x
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
indexing_maps: !LinalgIndexingMapsConfig
     - affine_map<(d0, d1)[s0, s1] -> (d0)>
   iterator_types:
   - parallel
   - reduction
   assignments:
   - !ScalarAssign
     arg: x
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: x
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   iterator_types:
   - parallel
   - parallel
   - reduction
   assignments:
   - !ScalarAssign
     arg: C
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: C
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
indexing_maps: !LinalgIndexingMapsConfig
     - affine_map<(d0)[s0] -> (d0)>
     - affine_map<(d0)[s0] -> ()>
   iterator_types:
   - reduction
   assignments:
   - !ScalarAssign
     arg: C
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: C
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
indexing_maps: !LinalgIndexingMapsConfig
     - affine_map<(d0, d1)[s0, s1] -> (d0)>
   iterator_types:
   - parallel
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - parallel
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - reduction
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - parallel
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - reduction
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - reduction
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: sub
                 operands:
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
                       scalar_arg: I
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
                       scalar_arg: IZp
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: sub
                 operands:
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - reduction
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - reduction
   - reduction
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - parallel
   - parallel
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - parallel
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - parallel
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: sub
                 operands:
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
                       scalar_arg: I
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
                       scalar_arg: IZp
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: sub
                 operands:
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - parallel
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - parallel
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: mul
             operands:
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: sub
                 operands:
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
                       scalar_arg: I
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
                       scalar_arg: IZp
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: sub
                 operands:
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
structured_op: !LinalgStructuredOpConfig
   - parallel
   - reduction
   - reduction
   - parallel
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
           type_fn:
             fn_name: cast
             type_var: U
structured_op: !LinalgStructuredOpConfig
   - parallel
   - reduction
   - reduction
   - parallel
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: max
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
           type_fn:
             fn_name: cast
             type_var: U
structured_op: !LinalgStructuredOpConfig
   - parallel
   - reduction
   - reduction
   - parallel
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: max_unsigned
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
           type_fn:
             fn_name: cast_unsigned
             type_var: U
structured_op: !LinalgStructuredOpConfig
   - parallel
   - parallel
   - reduction
   - reduction
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: max
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
           type_fn:
             fn_name: cast
             type_var: U
structured_op: !LinalgStructuredOpConfig
   - parallel
   - reduction
   - reduction
   - parallel
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: min
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
           type_fn:
             fn_name: cast
             type_var: U
structured_op: !LinalgStructuredOpConfig
   - parallel
   - reduction
   - reduction
   - parallel
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: min_unsigned
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
           type_fn:
             fn_name: cast_unsigned
             type_var: U
structured_op: !LinalgStructuredOpConfig
   - reduction
   - reduction
   - reduction
   - parallel
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
           type_fn:
             fn_name: cast
             type_var: U
structured_op: !LinalgStructuredOpConfig
   - reduction
   - reduction
   - reduction
   - parallel
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: max
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
           type_fn:
             fn_name: cast
             type_var: U
structured_op: !LinalgStructuredOpConfig
   - reduction
   - reduction
   - reduction
   - parallel
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: min
         operands:
         - !ScalarExpression
           scalar_arg: O
         - !ScalarExpression
           type_fn:
             fn_name: cast
             type_var: U
structured_op: !LinalgStructuredOpConfig
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
       type_fn:
         fn_name: cast
         type_var: T
         operands:
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: add
             operands:
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: mul
                 operands:
                 - !ScalarExpression
-                  scalar_apply:
+                  arith_fn:
                     fn_name: add
                     operands:
                     - !ScalarExpression
                       type_fn:
                         fn_name: cast
                         type_var: F64
                         operands:
                         - !ScalarExpression
                           scalar_const: '2147483647 : i64'
                     - !ScalarExpression
                       type_fn:
                         fn_name: cast
                         type_var: F64
                         operands:
                         - !ScalarExpression
-                          scalar_apply:
+                          arith_fn:
                             fn_name: add
                             operands:
                             - !ScalarExpression
-                              scalar_apply:
+                              arith_fn:
                                 fn_name: mul
                                 operands:
                                 - !ScalarExpression
-                                  scalar_apply:
+                                  arith_fn:
                                     fn_name: add
                                     operands:
                                     - !ScalarExpression
                                       type_fn:
                                         fn_name: cast
                                         type_var: I32
                                         operands:
                                         - !ScalarExpression
                                           scalar_index: 1
                                     - !ScalarExpression
-                                      scalar_apply:
+                                      arith_fn:
                                         fn_name: add
                                         operands:
                                         - !ScalarExpression
-                                          scalar_apply:
+                                          arith_fn:
                                             fn_name: mul
                                             operands:
                                             - !ScalarExpression
-                                              scalar_apply:
+                                              arith_fn:
                                                 fn_name: add
                                                 operands:
                                                 - !ScalarExpression
                                                   type_fn:
                                                     fn_name: cast
                                                     type_var: I32
                                                     operands:
                                                     - !ScalarExpression
value: !ScalarExpression
                             - !ScalarExpression
                               type_fn:
                                 fn_name: cast
                                 type_var: I32
                                 operands:
                                 - !ScalarExpression
                                   scalar_const: '12345 : i64'
                 - !ScalarExpression
-                  scalar_apply:
+                  arith_fn:
                     fn_name: mul
                     operands:
                     - !ScalarExpression
-                      scalar_apply:
+                      arith_fn:
                         fn_name: sub
                         operands:
                         - !ScalarExpression
                           scalar_arg: max
                         - !ScalarExpression
                           scalar_arg: min
                     - !ScalarExpression
                       type_fn:
indexing_maps: !LinalgIndexingMapsConfig
     - affine_map<(d0, d1)[s0, s1] -> (d0, d1)>
   iterator_types:
   - parallel
   - parallel
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: log
         operands:
         - !ScalarExpression
-          scalar_apply:
+          arith_fn:
             fn_name: add
             operands:
             - !ScalarExpression
               type_fn:
                 fn_name: cast
                 type_var: U
                 operands:
                 - !ScalarExpression
                   scalar_const: '1.000000e+00 : f64'
             - !ScalarExpression
-              scalar_apply:
+              arith_fn:
                 fn_name: exp
                 operands:
                 - !ScalarExpression
                   type_fn:
                     fn_name: cast
                     type_var: U
                     operands:
                     - !ScalarExpression
                       scalar_arg: I

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

static LogicalResult foldMemRefCastInTiledLoopOp(TiledLoopOp op) {
   return success(folded);
 }
 
 //===----------------------------------------------------------------------===//
 // Region builder helper.
 // TODO: Move this to a utility library.
 // The public methods on this class are referenced directly from generated code
 // and bind by name to math and type conversion functions in the DSL as:
-//   `applyfn__{fnName}`
+//   `arithfn__{fnName}`
 //   `typefn__{fnName}`
 // Examples:
-//   `applyfn__add`
-//   `applyfn__mul`
+//   `arithfn__add`
+//   `arithfn__mul`
 //   `typefn__cast`
 // The naming convention is intentional in order to match snake-cased DSL names.
 // See mlir-linalg-ods-yaml-gen.cpp for the code that mates to this class.
 //
 // Implementations of the math functions must be polymorphic over numeric types,
 // internally performing necessary casts. If the function application makes no
 // sense, then the only recourse is to assert and return nullptr. This can be
 // extended later if it becomes possible to fail construction of the region. The
public:
   Value typefn__cast(Type toType, Value operand) {
     return cast(toType, operand, false);
   }
 
   Value typefn__cast_unsigned(Type toType, Value operand) {
     return cast(toType, operand, true);
   }
 
-  Value applyfn__add(Value lhs, Value rhs) {
+  Value arithfn__add(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::AddFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::AddIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
-  Value applyfn__exp(Value x) {
+  Value arithfn__exp(Value x) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(x))
       return builder.create<math::ExpOp>(x.getLoc(), x);
     llvm_unreachable("unsupported non numeric type");
   }
 
-  Value applyfn__log(Value x) {
+  Value arithfn__log(Value x) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(x))
       return builder.create<math::LogOp>(x.getLoc(), x);
     llvm_unreachable("unsupported non numeric type");
   }
 
-  Value applyfn__sub(Value lhs, Value rhs) {
+  Value arithfn__sub(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::SubFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::SubIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
-  Value applyfn__mul(Value lhs, Value rhs) {
+  Value arithfn__mul(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::MulFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::MulIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
-  Value applyfn__max(Value lhs, Value rhs) {
+  Value arithfn__max(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::MaxFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::MaxSIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
-  Value applyfn__max_unsigned(Value lhs, Value rhs) {
+  Value arithfn__max_unsigned(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::MaxFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::MaxUIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
-  Value applyfn__min(Value lhs, Value rhs) {
+  Value arithfn__min(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::MinFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::MinSIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
-  Value applyfn__min_unsigned(Value lhs, Value rhs) {
+  Value arithfn__min_unsigned(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::MinFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::MinUIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 

mlir/python/mlir/dialects/linalg/opdsl/lang/comprehension.py

def collect_scalar_uses(self, uses: Set["ScalarDef"]):
 
     def visit_scalar_def(expr):
       if isinstance(expr, ScalarDef):
         uses.add(expr)
 
     self.visit_tensor_exprs(visit_scalar_def)
 
   def __add__(self, rhs: "TensorExpression") -> "TensorExpression":
-    return PrimFn.add(self, rhs)
+    return ArithFn.add(self, rhs)
 
   def __mul__(self, rhs) -> "TensorExpression":
-    return PrimFn.mul(self, rhs)
+    return ArithFn.mul(self, rhs)
 
   def __sub__(self, rhs) -> "TensorExpression":
-    return PrimFn.sub(self, rhs)
+    return ArithFn.sub(self, rhs)
 
   def __hash__(self):
     return hash(id(self))
 
 
 class TensorUse(TensorExpression):
   """A used tensor represented by its (tensor_name, indices).
 
def __repr__(self):
     return f"{self.fn_name}"
 
 
 class TypeFn:
   cast = TypeFnType("cast")
   cast_unsigned = TypeFnType("cast_unsigned")
 
 
-class PrimFnType:
-  """Primitive operations."""
+class ArithFnType:
+  """Arithmetic operations."""
 
-  def __init__(self, prim_name: str):
-    self.prim_name = prim_name
+  def __init__(self, fn_name: str):
+    self.fn_name = fn_name
 
-  def __call__(self, *args):
-    return PrimApply(self, args)
+  def __call__(self, *args) -> "TensorArithFn":
+    return TensorArithFn(self, args)
 
   def reduce(self, *reduce_dims: DimDef):
-    """Shortcut to create a Reduce operation from this primitive."""
+    """Shortcut to create a Reduce operation from this function."""
     return ReduceFnType(self, *reduce_dims)
 
   def __repr__(self):
-    return f"{self.prim_name}"
+    return f"{self.fn_name}"
 
 
-class PrimFn:
-  add = PrimFnType("add")
-  exp = PrimFnType("exp")
-  log = PrimFnType("log")
-  mul = PrimFnType("mul")
-  max = PrimFnType("max")
-  min = PrimFnType("min")
-  sub = PrimFnType("sub")
-  max_unsigned = PrimFnType("max_unsigned")
-  min_unsigned = PrimFnType("min_unsigned")
+class ArithFn:
+  add = ArithFnType("add")
+  exp = ArithFnType("exp")
+  log = ArithFnType("log")
+  mul = ArithFnType("mul")
+  max = ArithFnType("max")
+  min = ArithFnType("min")
+  sub = ArithFnType("sub")
+  max_unsigned = ArithFnType("max_unsigned")
+  min_unsigned = ArithFnType("min_unsigned")
 
 
 class ReduceFnType:
   """A reduction operator that reduces into its LHS from its RHS."""
 
-  def __init__(self, operator: PrimFnType, *reduce_dims: DimDef):
-    """Initializes the ReduceFn with a primitive function and dims."""
-    if not isinstance(operator, PrimFnType):
-      raise ValueError(f"Reduce expected a Prim operator but got {operator}")
+  def __init__(self, operator: ArithFnType, *reduce_dims: DimDef):
+    """Initializes the ReduceFn with an airthmetic function and dims."""
+    if not isinstance(operator, ArithFnType):
+      raise ValueError(f"Reduce expected a ArithFnType but got {operator}")
     self.operator = operator
     self.reduce_dims = tuple(reduce_dims)
 
   def __call__(self, *args: TensorExpression):
     return ReduceApply(self, args)
 
   def __repr__(self):
-    return (f"reduce_{self.operator.prim_name}"
+    return (f"reduce_{self.operator.fn_name}"
             f"({', '.join(repr(d) for d in self.reduce_dims)})")
 
 
 class ReduceFn:
-  add = PrimFn.add.reduce
-  mul = PrimFn.mul.reduce
-  max = PrimFn.max.reduce
-  min = PrimFn.min.reduce
-  max_unsigned = PrimFn.max_unsigned.reduce
-  min_unsigned = PrimFn.min_unsigned.reduce
+  add = ArithFn.add.reduce
+  mul = ArithFn.mul.reduce
+  max = ArithFn.max.reduce
+  min = ArithFn.min.reduce
+  max_unsigned = ArithFn.max_unsigned.reduce
+  min_unsigned = ArithFn.min_unsigned.reduce
 
 
-class PrimApply(TensorExpression):
-  """Application of a primitive."""
+class TensorArithFn(TensorExpression):
+  """Application of an arithmetic function."""
 
-  def __init__(self, prim: PrimFnType, args: Sequence[TensorExpression]):
-    self.prim = prim
+  def __init__(self, arith_fn: ArithFnType, args: Sequence[TensorExpression]):
+    self.arith_fn = arith_fn
     self.args = tuple(args)
 
   def to_scalar_expression(self) -> ScalarExpression:
-    return ScalarApplyFn(self.prim.prim_name,
+    return ScalarArithFn(self.arith_fn.fn_name,
                          *[arg.to_scalar_expression() for arg in self.args
                           ]).expr()
 
   def visit_tensor_exprs(self, callback):
     super().visit_tensor_exprs(callback)
     for arg in self.args:
       arg.visit_tensor_exprs(callback)
 
   def __repr__(self):
-    return f"{repr(self.prim)}({', '.join(repr(a) for a in self.args)})"
+    return f"{repr(self.arith_fn)}({', '.join(repr(a) for a in self.args)})"
 
 
 class TensorTypeFn(TensorExpression):
   """Application of a type conversion operation."""
 
   def __init__(self, type_fn: TypeFn, type_var: TypeVar, arg: TensorExpression):
     self.type_fn = type_fn
     self.type_var = type_var
def __init__(self, reduce: ReduceFnType, args: Sequence[TensorExpression]):
     self.args = tuple(args)
 
   def to_scalar_expression(self) -> ScalarExpression:
     if self.lhs is None:
       raise ValueError(f"Cannot scalarize a ReduceApply that has not been "
                        f"bound to its lhs: {self}")
     full_args = [self.lhs.to_scalar_expression()
                 ] + [arg.to_scalar_expression() for arg in self.args]
-    return ScalarApplyFn(self.reduce.operator.prim_name, *full_args).expr()
+    return ScalarArithFn(self.reduce.operator.fn_name, *full_args).expr()
 
   def visit_tensor_exprs(self, callback):
     for arg in self.args:
       arg.visit_tensor_exprs(callback)
 
   def __repr__(self):
     return f"{repr(self.reduce)}({', '.join(repr(a) for a in self.args)})"
 

mlir/python/mlir/dialects/linalg/opdsl/lang/emitter.py

if expr.scalar_arg:
                          f"this structured op.")
     elif expr.scalar_const:
       value_attr = Attribute.parse(expr.scalar_const.value)
       return arith.ConstantOp(value_attr.type, value_attr).result
     elif expr.scalar_index:
       dim_attr = IntegerAttr.get(
           IntegerType.get_signless(64), expr.scalar_index.dim)
       return linalg.IndexOp(dim_attr).result
-    elif expr.scalar_apply:
-      fn = self._get_function(f"_eval_{expr.scalar_apply.fn_name}")
+    elif expr.arith_fn:
+      fn = self._get_function(f"_arithfn_{expr.arith_fn.fn_name}")
       operand_values = [
-          self.expression(operand) for operand in expr.scalar_apply.operands
+          self.expression(operand) for operand in expr.arith_fn.operands
       ]
       return fn(*operand_values)
     elif expr.type_fn:
       fn = self._get_function(f"_typefn_{expr.type_fn.fn_name}")
       operand = self.expression(expr.type_fn.operand)
       return fn(expr.type_fn.type_var.name, operand)
     raise NotImplementedError(f"Unimplemented scalar body expression: {expr}")
 
raise ValueError(f"Unable to cast body expression from {operand_type} to "
                      f"{to_type}")
 
   def _typefn_cast(self, type_var_name: str, operand: Value) -> Value:
     return self._cast(type_var_name, operand, False)
 
   def _typefn_cast_unsigned(self, type_var_name: str, operand: Value) -> Value:
     return self._cast(type_var_name, operand, True)
 
-  def _eval_add(self, lhs: Value, rhs: Value) -> Value:
+  def _arithfn_add(self, lhs: Value, rhs: Value) -> Value:
     if _is_floating_point_type(lhs.type):
       return arith.AddFOp(lhs, rhs).result
     if _is_integer_type(lhs.type) or _is_index_type(lhs.type):
       return arith.AddIOp(lhs, rhs).result
     raise NotImplementedError("Unsupported 'add' operand: {lhs}")
 
-  def _eval_exp(self, x: Value) -> Value:
+  def _arithfn_exp(self, x: Value) -> Value:
     if _is_floating_point_type(x.type):
       return math.ExpOp(x).result
     raise NotImplementedError("Unsupported 'exp' operand: {x}")
 
-  def _eval_log(self, x: Value) -> Value:
+  def _arithfn_log(self, x: Value) -> Value:
     if _is_floating_point_type(x.type):
       return math.LogOp(x).result
     raise NotImplementedError("Unsupported 'log' operand: {x}")
 
-  def _eval_sub(self, lhs: Value, rhs: Value) -> Value:
+  def _arithfn_sub(self, lhs: Value, rhs: Value) -> Value:
     if _is_floating_point_type(lhs.type):
       return arith.SubFOp(lhs, rhs).result
     if _is_integer_type(lhs.type) or _is_index_type(lhs.type):
       return arith.SubIOp(lhs, rhs).result
     raise NotImplementedError("Unsupported 'sub' operand: {lhs}")
 
-  def _eval_mul(self, lhs: Value, rhs: Value) -> Value:
+  def _arithfn_mul(self, lhs: Value, rhs: Value) -> Value:
     if _is_floating_point_type(lhs.type):
       return arith.MulFOp(lhs, rhs).result
     if _is_integer_type(lhs.type) or _is_index_type(lhs.type):
       return arith.MulIOp(lhs, rhs).result
     raise NotImplementedError("Unsupported 'mul' operand: {lhs}")
 
-  def _eval_max(self, lhs: Value, rhs: Value) -> Value:
+  def _arithfn_max(self, lhs: Value, rhs: Value) -> Value:
     if _is_floating_point_type(lhs.type):
       return arith.MaxFOp(lhs, rhs).result
     if _is_integer_type(lhs.type) or _is_index_type(lhs.type):
       return arith.MaxSIOp(lhs, rhs).result
     raise NotImplementedError("Unsupported 'max' operand: {lhs}")
 
-  def _eval_max_unsigned(self, lhs: Value, rhs: Value) -> Value:
+  def _arithfn_max_unsigned(self, lhs: Value, rhs: Value) -> Value:
     if _is_floating_point_type(lhs.type):
       return arith.MaxFOp(lhs, rhs).result
     if _is_integer_type(lhs.type) or _is_index_type(lhs.type):
       return arith.MaxUIOp(lhs, rhs).result
     raise NotImplementedError("Unsupported 'max_unsigned' operand: {lhs}")
 
-  def _eval_min(self, lhs: Value, rhs: Value) -> Value:
+  def _arithfn_min(self, lhs: Value, rhs: Value) -> Value:
     if _is_floating_point_type(lhs.type):
       return arith.MinFOp(lhs, rhs).result
     if _is_integer_type(lhs.type) or _is_index_type(lhs.type):
       return arith.MinSIOp(lhs, rhs).result
     raise NotImplementedError("Unsupported 'min' operand: {lhs}")
 
-  def _eval_min_unsigned(self, lhs: Value, rhs: Value) -> Value:
+  def _arithfn_min_unsigned(self, lhs: Value, rhs: Value) -> Value:
     if _is_floating_point_type(lhs.type):
       return arith.MinFOp(lhs, rhs).result
     if _is_integer_type(lhs.type) or _is_index_type(lhs.type):
       return arith.MinUIOp(lhs, rhs).result
     raise NotImplementedError("Unsupported 'min_unsigned' operand: {lhs}")
 
 
 def _infer_structured_outs(

mlir/python/mlir/dialects/linalg/opdsl/lang/scalar_expr.py

 
 from typing import Optional, Sequence
 
 from .yaml_helper import *
 from .types import *
 
 __all__ = [
     "ScalarAssign",
-    "ScalarApplyFn",
+    "ScalarArithFn",
     "ScalarTypeFn",
     "ScalarArg",
     "ScalarConst",
     "ScalarIndex",
     "ScalarExpression",
 ]
 
 
-class ScalarApplyFn:
-  """A type of ScalarExpression that applies a named function to operands."""
+class ScalarArithFn:
+  """A type of ScalarExpression that applies an arithmetic function."""
 
   def __init__(self, fn_name: str, *operands: "ScalarExpression"):
     self.fn_name = fn_name
     self.operands = operands
 
   def expr(self) -> "ScalarExpression":
-    return ScalarExpression(scalar_apply=self)
+    return ScalarExpression(arith_fn=self)
 
   def __repr__(self):
-    return f"ScalarApplyFn<{self.fn_name}>({', '.join(self.operands)})"
+    return f"ScalarArithFn<{self.fn_name}>({', '.join(self.operands)})"
 
 
 class ScalarTypeFn:
   """A type of ScalarExpression that applies a type conversion function."""
 
   def __init__(self, fn_name: str, type_var: TypeVar,
                operand: "ScalarExpression"):
     self.fn_name = fn_name
class ScalarIndex:
   def __repr__(self):
     return f"(ScalarIndex({self.dim})"
 
 
 class ScalarExpression(YAMLObject):
   """An expression on scalar values.
 
   Can be one of:
-    - ScalarApplyFn
+    - ScalarArithFn
     - ScalarTypeFn
     - ScalarArg
     - ScalarConst
     - ScalarIndex
     - ScalarSymbolicCast
   """
   yaml_tag = "!ScalarExpression"
 
   def __init__(self,
-               scalar_apply: Optional[ScalarApplyFn] = None,
+               arith_fn: Optional[ScalarArithFn] = None,
                type_fn: Optional[ScalarTypeFn] = None,
                scalar_arg: Optional[ScalarArg] = None,
                scalar_const: Optional[ScalarConst] = None,
                scalar_index: Optional[ScalarIndex] = None):
-    if (bool(scalar_apply) + bool(type_fn) + bool(scalar_arg) +
-        bool(scalar_const) + bool(scalar_index)) != 1:
-      raise ValueError("One of 'scalar_apply', 'type_fn', 'scalar_arg', "
+    if (bool(arith_fn) + bool(type_fn) + bool(scalar_arg) + bool(scalar_const) +
+        bool(scalar_index)) != 1:
+      raise ValueError("One of 'arith_fn', 'type_fn', 'scalar_arg', "
                        "'scalar_const', 'scalar_index', must be specified")
-    self.scalar_apply = scalar_apply
+    self.arith_fn = arith_fn
     self.type_fn = type_fn
     self.scalar_arg = scalar_arg
     self.scalar_const = scalar_const
     self.scalar_index = scalar_index
 
   def to_yaml_custom_dict(self):
-    if self.scalar_apply:
+    if self.arith_fn:
       return dict(
-          scalar_apply=dict(
-              fn_name=self.scalar_apply.fn_name,
-              operands=list(self.scalar_apply.operands),
+          arith_fn=dict(
+              fn_name=self.arith_fn.fn_name,
+              operands=list(self.arith_fn.operands),
           ))
     if self.type_fn:
       # Note that even though operands must be arity 1, we write it the
       # same way as for apply because it allows handling code to be more
       # generic vs having a special form.
       return dict(
           type_fn=dict(
               fn_name=self.type_fn.fn_name,

mlir/python/mlir/dialects/linalg/opdsl/ops/core_named_ops.py

def soft_plus_2d(
     I=TensorDef(T, S.M, S.N), O=TensorDef(U, S.M, S.N, output=True)):
   """Implements the soft plus operator.
 
   Numeric casting is performed on the input operand, promoting it to the same
   data type as the accumulator/output.
   """
   domain(D.m, D.n)
   O[D.m, D.n] = \
-      PrimFn.log(TypeFn.cast(U, const(1.0)) + PrimFn.exp(TypeFn.cast(U, I[D.m, D.n])))
+      ArithFn.log(TypeFn.cast(U, const(1.0)) + ArithFn.exp(TypeFn.cast(U, I[D.m, D.n])))

mlir/test/mlir-linalg-ods-gen/test-linalg-ods-yaml-gen.yaml

indexing_maps: !LinalgIndexingMapsConfig
     - affine_map<(d0, d1)[s0, s1] -> (d0, d1)>
   iterator_types:
   - parallel
   - parallel
   assignments:
   - !ScalarAssign
     arg: O
     value: !ScalarExpression
-      scalar_apply:
+      arith_fn:
         fn_name: add
         operands:
         - !ScalarExpression
           type_fn:
             fn_name: cast
             type_var: T
             operands:
             - !ScalarExpression

 #  ODS-NEXT:      TypeRange(outputs)
 
 # IMPL-LABEL:  void Test1Op::regionBuilder(
 #       IMPL:    ImplicitLocOpBuilder &b, Block &block)
 #       IMPL:  Value [[VAL0:[a-z0-9]+]] = helper.constant("42 : i64");
 #   IMPL-DAG:  Value [[VAL1:[a-z0-9]+]] = helper.typefn__cast(block.getArgument(0).getType(), [[VAL0]]);
 #   IMPL-DAG:  Value [[VAL2:[a-z0-9]+]] = helper.index(1);
 #   IMPL-DAG:  Value [[VAL3:[a-z0-9]+]] = helper.typefn__cast_unsigned(block.getArgument(0).getType(), [[VAL2]]);
-#   IMPL-DAG:  Value [[VAL4:[a-z0-9]+]] = helper.applyfn__add([[VAL1]], [[VAL3]]);
+#   IMPL-DAG:  Value [[VAL4:[a-z0-9]+]] = helper.arithfn__add([[VAL1]], [[VAL3]]);
 
 
 # @linalg_structured_op
 # def test2(I=TensorDef(T, S.M, S.N),
 #           O=TensorDef(T, S.M, S.N, output=True),
 #           strides=IndexAttrDef(S.SM, S.SN)):
 #   """Title.
 

mlir/test/python/dialects/linalg/opdsl/assignments.py

 # RUN: %PYTHON -m mlir.dialects.linalg.opdsl.dump_oplib --file %s | FileCheck %s
 
 from mlir.dialects.linalg.opdsl.lang import *
 
 
 # CHECK: ---
 # CHECK-LABEL: matmul
 # CHECK: assignments:
 # CHECK:  -
 # CHECK:    arg: C
 # CHECK:    value:
-# CHECK:      scalar_apply:
+# CHECK:      arith_fn:
 # CHECK:        fn_name: add
 # CHECK:        operands:
-# CHECK:          scalar_apply:
+# CHECK:          arith_fn:
 # CHECK:            fn_name: mul
 # CHECK:            operands:
 # CHECK:              type_fn:
 # CHECK:                type_var: U
 # CHECK:                operands:
 # CHECK:                  scalar_arg: A
 # CHECK:              type_fn:
 # CHECK:                type_var: U
 # CHECK:                operands:
 # CHECK:                  scalar_arg: B
 @linalg_structured_op
 def matmul(
     A=TensorDef(T, S.M, S.K),
     B=TensorDef(T, S.K, S.N),
     C=TensorDef(U, S.M, S.N, output=True)):
   C[D.m, D.n] += TypeFn.cast(U, A[D.m, D.k]) * TypeFn.cast(U, B[D.k, D.n])
 
 
 # CHECK: ---
 # CHECK-LABEL: constants
 # CHECK: assignments:
 # CHECK:  -
 # CHECK:    arg: O
-# CHECK:      scalar_apply:
+# CHECK:      arith_fn:
 # CHECK:        fn_name: sub
 # CHECK:        operands:
-# CHECK:          scalar_apply:
+# CHECK:          arith_fn:
 # CHECK:            fn_name: add
 # CHECK:            operands:
 # CHECK:              type_fn:
 # CHECK:                type_var: T
 # CHECK:                operands:
 # CHECK:                  scalar_const: '3.1415926535897931 : f64'
 # CHECK:              type_fn:
 # CHECK:                type_var: T
def constants(O=TensorDef(T, S.M, S.K, output=True)):
   O[D.m, D.n] = pi + cst42 - cst1000
 
 
 # CHECK: ---
 # CHECK-LABEL: indices
 # CHECK: assignments:
 # CHECK:  -
 # CHECK:    arg: O
-# CHECK:      scalar_apply:
+# CHECK:      arith_fn:
 # CHECK:        fn_name: add
 # CHECK:        operands:
 # CHECK:          scalar_index: 1
 # CHECK:          scalar_index: 0
 @linalg_structured_op
 def indices(O=TensorDef(T, S.M, S.K, output=True)):
   O[D.m, D.n] = index(D.n) + index(D.m)
 

mlir/test/python/dialects/linalg/opdsl/emit_misc.py

def fill_rng_poly(
   scaling = (max - min) * inv_range
   O[D.m, D.n] = TypeFn.cast(T,
                             (offset + TypeFn.cast(F64, rand2)) * scaling + min)
 
 
 @linalg_structured_op
 def soft_plus_poly(
     I=TensorDef(T, S.M, S.N), O=TensorDef(U, S.M, S.N, output=True)):
-  O[D.m, D.n] = PrimFn.log(
-      TypeFn.cast(U, const(1.0)) + TypeFn.cast(U, PrimFn.exp(I[D.m, D.n])))
+  O[D.m, D.n] = ArithFn.log(
+      TypeFn.cast(U, const(1.0)) + TypeFn.cast(U, ArithFn.exp(I[D.m, D.n])))
 
 
 @linalg_structured_op(op_name="custom_op_name")
 def non_default_op_name(I=TensorDef(T, S.N), O=TensorDef(T, S.N, output=True)):
   O[D.n] = I[D.n]
 
 
 with Context() as ctx, Location.unknown():

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

 };
 
 struct LinalgIndexingMapsConfig {
   Optional<SmallVector<SerializedAffineMap>> staticIndexingMaps;
 };
 
 struct ScalarExpression;
 
-struct ScalarApply {
+struct ScalarArithFn {
   std::string fnName;
   // NOTE: Must be pure heap allocated container (not SmallVector)
   // due to recursive data type.
   std::vector<ScalarExpression> operands;
 };
 
 struct ScalarTypeFn {
   std::string fnName;
   std::string typeVar;
   // NOTE: This must be of arity 1, but to break the self-referential cycle,
   // we use a heap allocated vector.
   std::vector<ScalarExpression> operands;
 };
 
 struct ScalarExpression {
   Optional<std::string> arg;
   Optional<std::string> constant;
   Optional<int64_t> index;
-  Optional<ScalarApply> apply;
+  Optional<ScalarArithFn> arithFn;
   Optional<ScalarTypeFn> typeFn;
 };
 
 struct ScalarAssign {
   std::string arg;
   ScalarExpression value;
 };
 

 template <> struct MappingTraits<ScalarAssign> {
   static void mapping(IO &io, ScalarAssign &info) {
     io.mapRequired("arg", info.arg);
     io.mapRequired("value", info.value);
   }
 };
 
 /// A scalar expression (RHS of an assignment). Must be one of:
-///   - `scalar_arg`: Name of an argument to the op.
-///   - `scalar_apply`: Result of evaluating a named function (see
-///      `ScalarApply`).
+///   - `scalar_arg`: An operation argument.
+///   - `scalar_const`: A constant definition.
+///   - `scalar_index`: An iteration index.
+///   - `arith_fn`: A named arithmetic function (see `ScalarArithFn`).
 ///   - `type_fn`: A named type conversion function (see `ScalarTypeFn`).
 template <> struct MappingTraits<ScalarExpression> {
   static void mapping(IO &io, ScalarExpression &info) {
     io.mapOptional("scalar_arg", info.arg);
     io.mapOptional("scalar_const", info.constant);
     io.mapOptional("scalar_index", info.index);
-    io.mapOptional("scalar_apply", info.apply);
+    io.mapOptional("arith_fn", info.arithFn);
     io.mapOptional("type_fn", info.typeFn);
   }
 };
 
 /// A scalar expression that evaluates a named function.
 /// Functions are generally "math" level and type polymorphic. Builtin
 /// functions include:
 ///   - `add(lhs, rhs)`
 ///   - `mul(lhs, rhs)`
-template <> struct MappingTraits<ScalarApply> {
-  static void mapping(IO &io, ScalarApply &info) {
+template <>
+struct MappingTraits<ScalarArithFn> {
+  static void mapping(IO &io, ScalarArithFn &info) {
     io.mapRequired("fn_name", info.fnName);
     io.mapRequired("operands", info.operands);
   }
 };
 
 template <>
 struct MappingTraits<ScalarTypeFn> {
   static void mapping(IO &io, ScalarTypeFn &info) {
for (LinalgOperandDef &arg : args) {
         }
         if (expression.index) {
           // Access an iteration index.
           std::string cppIdent = llvm::formatv("value{0}", ++localCounter);
           stmts.push_back(llvm::formatv("Value {0} = helper.index({1});",
                                         cppIdent, *expression.index));
           return cppIdent;
         }
-        if (expression.apply) {
+        if (expression.arithFn) {
           // Apply function.
           // Recursively generate operands.
           SmallVector<std::string> operandCppValues;
-          for (ScalarExpression &operand : expression.apply->operands) {
+          for (ScalarExpression &operand : expression.arithFn->operands) {
             auto operandCppValue = generateExpression(operand);
             if (!operandCppValue)
               return None;
             operandCppValues.push_back(*operandCppValue);
           }
           std::string cppIdent = llvm::formatv("value{0}", ++localCounter);
           stmts.push_back(
-              llvm::formatv("Value {0} = helper.applyfn__{1}({2});", cppIdent,
-                            expression.apply->fnName,
+              llvm::formatv("Value {0} = helper.arithfn__{1}({2});", cppIdent,
+                            expression.arithFn->fnName,
                             interleaveToString(operandCppValues, ", ")));
           return cppIdent;
         }
         if (expression.typeFn) {
           // Symbolic cast.
           // Operands must be arity 1.
           if (expression.typeFn->operands.size() != 1) {
             emitError(genContext.getLoc())