[mlir][NFC] Replace mlir/Support/Functional.h with llvm equivalents.

[rriddle]

Summary

Functional.h contains many different methods that have a direct, and more efficient, equivalent in LLVM. This revision replaces all usages with the LLVM equivalent, and removes the header. This is part of larger cleanup, pr45513, merging MLIR support facilities into LLVM.

[rriddle]

Rebase

[lattner]

Awesome!

mlir/include/mlir/IR/OpBase.td

 // Predicate to verify that all the operands at the given `indices`
 // have the same element type.
 // Type Constraint operands' Element type are all Same At the given `indices`.
 // We query the operands' types into a list and check they are all the same.
 // Precondition:
 // 1) all operands involved are of shaped type and
 // 2) the indices are not out of range.
 class TCopVTEtAreSameAt<list<int> indices> : CPred<
-  "llvm::is_splat(mlir::functional::map("
-    "[this](unsigned i) { return getElementTypeOrSelf(this->getOperand(i)); }, "
-    "llvm::ArrayRef<unsigned>({" # StrJoinInt<indices>.result # "})))">;
+  "llvm::is_splat(llvm::map_range("
+    "llvm::ArrayRef<unsigned>({" # StrJoinInt<indices>.result # "}), "
+    "[this](unsigned i) { return getElementTypeOrSelf(this->getOperand(i)); "
+    "}))">;
 
 //===----------------------------------------------------------------------===//
 // Pattern definitions
 //===----------------------------------------------------------------------===//
 
 // Marker used to identify the delta value added to the default benefit value.
 def addBenefit;
 

mlir/include/mlir/Support/Functional.h

-//===- Functional.h - Helpers for functional-style Combinators --*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_SUPPORT_FUNCTIONAL_H_
-#define MLIR_SUPPORT_FUNCTIONAL_H_
-
-#include "mlir/Support/LLVM.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/Casting.h"
-
-/// This file provides some simple template functional-style sugar to operate
-/// on **value** types. Make sure when using that the stored type is cheap to
-/// copy!
-///
-/// TODO(ntv): add some static_assert but we need proper traits for this.
-
-namespace mlir {
-namespace functional {
-
-/// Map with iterators.
-template <typename Fn, typename IterType>
-auto map(Fn fun, IterType begin, IterType end)
-    -> SmallVector<typename std::result_of<Fn(decltype(*begin))>::type, 8> {
-  using R = typename std::result_of<Fn(decltype(*begin))>::type;
-  SmallVector<R, 8> res;
-  // auto i works with both pointer types and value types with an operator*.
-  // auto *i only works for pointer types.
-  for (auto i = begin; i != end; ++i) {
-    res.push_back(fun(*i));
-  }
-  return res;
-}
-
-/// Map with templated container.
-template <typename Fn, typename ContainerType>
-auto map(Fn fun, ContainerType input)
-    -> decltype(map(fun, std::begin(input), std::end(input))) {
-  return map(fun, std::begin(input), std::end(input));
-}
-
-/// Zip map with 2 templated container, iterates to the min of the sizes of
-/// the 2 containers.
-/// TODO(ntv): make variadic when needed.
-template <typename Fn, typename ContainerType1, typename ContainerType2>
-auto zipMap(Fn fun, ContainerType1 input1, ContainerType2 input2)
-    -> SmallVector<typename std::result_of<Fn(decltype(*input1.begin()),
-                                              decltype(*input2.begin()))>::type,
-                   8> {
-  using R = typename std::result_of<Fn(decltype(*input1.begin()),
-                                       decltype(*input2.begin()))>::type;
-  SmallVector<R, 8> res;
-  auto zipIter = llvm::zip(input1, input2);
-  for (auto it : zipIter) {
-    res.push_back(fun(std::get<0>(it), std::get<1>(it)));
-  }
-  return res;
-}
-
-/// Apply with iterators.
-template <typename Fn, typename IterType>
-void apply(Fn fun, IterType begin, IterType end) {
-  // auto i works with both pointer types and value types with an operator*.
-  // auto *i only works for pointer types.
-  for (auto i = begin; i != end; ++i) {
-    fun(*i);
-  }
-}
-
-/// Apply with templated container.
-template <typename Fn, typename ContainerType>
-void apply(Fn fun, ContainerType input) {
-  return apply(fun, std::begin(input), std::end(input));
-}
-
-/// Zip apply with 2 templated container, iterates to the min of the sizes of
-/// the 2 containers.
-/// TODO(ntv): make variadic when needed.
-template <typename Fn, typename ContainerType1, typename ContainerType2>
-void zipApply(Fn fun, ContainerType1 input1, ContainerType2 input2) {
-  auto zipIter = llvm::zip(input1, input2);
-  for (auto it : zipIter) {
-    fun(std::get<0>(it), std::get<1>(it));
-  }
-}
-
-/// Unwraps a pointer type to another type (possibly the same).
-/// Used in particular to allow easier compositions of
-///   Operation::operand_range types.
-template <typename T, typename ToType = T>
-inline std::function<ToType *(T *)> makePtrDynCaster() {
-  return [](T *val) { return dyn_cast<ToType>(val); };
-}
-
-/// Simple ScopeGuard.
-struct ScopeGuard {
-  explicit ScopeGuard(std::function<void(void)> destruct)
-      : destruct(destruct) {}
-  ~ScopeGuard() { destruct(); }
-
-private:
-  std::function<void(void)> destruct;
-};
-
-} // namespace functional
-} // namespace mlir
-
-#endif // MLIR_SUPPORT_FUNCTIONAL_H_

mlir/lib/Analysis/SliceAnalysis.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Operation.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 
 ///
 /// Implements Analysis functions specific to slicing in Function.
 ///
 

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/AffineExprVisitor.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Pass/Pass.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
 namespace {
 /// Visit affine expressions recursively and build the sequence of operations
 /// that correspond to it.  Visitation functions return an Value of the

 
 /// Create a sequence of operations that implement the `affineMap` applied to
 /// the given `operands` (as it it were an AffineApplyOp).
 Optional<SmallVector<Value, 8>> mlir::expandAffineMap(OpBuilder &builder,
                                                       Location loc,
                                                       AffineMap affineMap,
                                                       ValueRange operands) {
   auto numDims = affineMap.getNumDims();
-  auto expanded = functional::map(
+  auto expanded = llvm::to_vector<8>(
+      llvm::map_range(affineMap.getResults(),
                       [numDims, &builder, loc, operands](AffineExpr expr) {
                         return expandAffineExpr(builder, loc, expr,
                                                 operands.take_front(numDims),
                                                 operands.drop_front(numDims));
-      },
-      affineMap.getResults());
+                      }));
   if (llvm::all_of(expanded, [](Value v) { return v; }))
     return expanded;
   return None;
 }
 
 /// Given a range of values, emit the code that reduces them with "min" or "max"
 /// depending on the provided comparison predicate.  The predicate defines which
 /// comparison to perform, "lt" for "min", "gt" for "max" and is used for the

mlir/lib/Conversion/LoopToStandard/LoopToStandard.cpp

 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/PatternMatch.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/Utils.h"
 
 using namespace mlir;
 using namespace mlir::loop;
 
 namespace {

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/Utils.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/CommandLine.h"

mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp

 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/Dialect/Vector/VectorUtils.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/Types.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/FoldUtils.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"

 /// }
 /// ```
 ///
 /// Of course, much more intricate n-D imperfectly-nested patterns can be
 /// vectorized too and specified in a fully declarative fashion.
 
 #define DEBUG_TYPE "early-vect"
 
-using functional::makePtrDynCaster;
-using functional::map;
 using llvm::dbgs;
 using llvm::SetVector;
 
 /// Forward declaration.
 static FilterFunctionType
 isVectorizableLoopPtrFactory(const DenseSet<Operation *> &parallelLoops,
                              int fastestVaryingMemRefDimension);
 
static LogicalResult vectorizeRootOrTerminal(Value iv,
   return success();
 }
 /// end TODO(ntv): Hoist to a VectorizationMaterialize.cpp when appropriate. ///
 
 /// Coarsens the loops bounds and transforms all remaining load and store
 /// operations into the appropriate vector.transfer.
 static LogicalResult vectorizeAffineForOp(AffineForOp loop, int64_t step,
                                           VectorizationState *state) {
-  using namespace functional;
   loop.setStep(step);
 
   FilterFunctionType notVectorizedThisPattern = [state](Operation &op) {
     if (!matcher::isLoadOrStore(op)) {
       return false;
     }
     return state->vectorizationMap.count(&op) == 0 &&
            state->vectorizedSet.count(&op) == 0 &&

mlir/lib/Dialect/GPU/Transforms/MemoryPromotion.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/GPU/MemoryPromotion.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/LoopOps/EDSC/Builders.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Pass/Pass.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Transforms/LoopUtils.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::gpu;
 
 /// Returns the textual name of a GPU dimension.

mlir/lib/Dialect/Linalg/EDSC/Builders.cpp

 //===- Builders.cpp - MLIR Declarative Linalg Builders --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Builders.h"
 #include "mlir/Dialect/Affine/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
 #include "mlir/Dialect/LoopOps/EDSC/Builders.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/IR/AffineExpr.h"
-#include "mlir/Support/Functional.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 using namespace mlir::loop;
 
 mlir::edsc::LoopRangeBuilder::LoopRangeBuilder(ValueHandle *iv,
Operation *mlir::edsc::makeGenericLinalgOp(
   values.reserve(nViews);
   values.append(inputs.begin(), inputs.end());
   std::copy_if(outputs.begin(), outputs.end(), std::back_inserter(values),
                [](StructuredIndexed s) { return s.hasValue(); });
   SmallVector<Type, 4> types;
   std::copy_if(outputs.begin(), outputs.end(), std::back_inserter(types),
                [](StructuredIndexed s) { return !s.hasValue(); });
 
-  auto iteratorStrTypes = functional::map(toString, iteratorTypes);
+  auto iteratorStrTypes =
+      llvm::to_vector<8>(llvm::map_range(iteratorTypes, toString));
   // clang-format off
   auto *op =
       edsc::ScopedContext::getBuilder()
           .create<linalg::GenericOp>(
               edsc::ScopedContext::getLocation(),
               types,
               values,
               IntegerAttr::get(IntegerType::get(64, ctx), nInputs),

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

 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/StandardTypes.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/STLExtras.h"
 
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
return canonicalizeStridedLayout(
       MemRefType::Builder(type).setShape(newSizes).setAffineMaps({layout}));
 }
 
 /// Helper functions assert Attribute of the proper type in attr and returns the
 /// corresponding vector.
 /// TODO(rridle,ntv) this should be evolved into a generic
 /// `getRangeOfType<AffineMap>(ArrayAttr attrs)` that does not copy.
 static SmallVector<AffineMap, 4> getAffineMaps(ArrayAttr attrs) {
-  return functional::map(
-      [](Attribute a) { return a.cast<AffineMapAttr>().getValue(); }, attrs);
+  return llvm::to_vector<8>(llvm::map_range(
+      attrs, [](Attribute a) { return a.cast<AffineMapAttr>().getValue(); }));
 }
 
 template <typename AffineExprTy>
 unsigned getMaxPosOfType(ArrayRef<ArrayRef<AffineExpr>> exprArrays) {
   unsigned pos = 0;
   for (auto exprs : exprArrays) {
     for (auto expr : exprs) {
       expr.walk([&pos](AffineExpr e) {

mlir/lib/Dialect/Linalg/Transforms/LinalgToLoops.cpp

 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/LinalgTransforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/LoopOps/EDSC/Builders.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BlockAndValueMapping.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/STLExtras.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/FoldUtils.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;

 // Returns a pair that contains input indices and output indices of a
 // SingleInputPoolingOp `op`.
 template <typename SingleInputPoolingOp>
 static std::pair<SmallVector<ValueHandle, 8>, SmallVector<ValueHandle, 8>>
 getInputAndOutputIndices(ArrayRef<Value> allIvs, SingleInputPoolingOp op) {
   auto &b = ScopedContext::getBuilder();
   auto loc = ScopedContext::getLocation();
   auto mapsRange = op.indexing_maps().template getAsRange<AffineMapAttr>();
-  auto maps =
-      functional::map([](AffineMapAttr a) { return a.getValue(); }, mapsRange);
+  auto maps = llvm::to_vector<8>(
+      llvm::map_range(mapsRange, [](AffineMapAttr a) { return a.getValue(); }));
   SmallVector<ValueHandle, 8> iIdx(
       makeCanonicalAffineApplies(b, loc, maps[0], allIvs));
   SmallVector<ValueHandle, 8> oIdx(
       makeCanonicalAffineApplies(b, loc, maps[2], allIvs));
   return {iIdx, oIdx};
 }
 
 namespace {
public:
   }
 
   static void emitScalarImplementation(ArrayRef<Value> allIvs, ConvOp convOp) {
     assert(convOp.hasBufferSemantics() &&
            "expected linalg op with buffer semantics");
     auto b = ScopedContext::getBuilder();
     auto loc = ScopedContext::getLocation();
     auto mapsRange = convOp.indexing_maps().getAsRange<AffineMapAttr>();
-    auto maps = functional::map([](AffineMapAttr a) { return a.getValue(); },
-                                mapsRange);
+    auto maps = llvm::to_vector<8>(llvm::map_range(
+        mapsRange, [](AffineMapAttr a) { return a.getValue(); }));
     SmallVector<ValueHandle, 8> fIdx(
         makeCanonicalAffineApplies(b, loc, maps[0], allIvs));
     SmallVector<ValueHandle, 8> imIdx(
         makeCanonicalAffineApplies(b, loc, maps[1], allIvs));
     SmallVector<ValueHandle, 8> oIdx(
         makeCanonicalAffineApplies(b, loc, maps[2], allIvs));
     IndexedValueType F(convOp.filter()), I(convOp.input()), O(convOp.output());
 
LinalgOpToLoopsImpl<LoopTy, ConcreteOpTy>::doit(Operation *op,
   assert(linalgOp.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
   auto nPar = linalgOp.getNumParallelLoops();
   auto nRed = linalgOp.getNumReductionLoops();
   auto nWin = linalgOp.getNumWindowLoops();
   auto nLoops = nPar + nRed + nWin;
   auto mapsRange =
       linalgOp.indexing_maps().template getAsRange<AffineMapAttr>();
-  auto maps =
-      functional::map([](AffineMapAttr a) { return a.getValue(); }, mapsRange);
+  auto maps = llvm::to_vector<8>(
+      llvm::map_range(mapsRange, [](AffineMapAttr a) { return a.getValue(); }));
   AffineMap invertedMap = inversePermutation(concatAffineMaps(maps));
   if (invertedMap.isEmpty()) {
     LinalgScopedEmitter<IndexedValueTy, ConcreteOpTy>::emitScalarImplementation(
         {}, linalgOp);
     return LinalgLoops();
   }
 
   SmallVector<ValueHandle, 4> allIvs(nLoops,

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/LoopOps/EDSC/Builders.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineExprVisitor.h"
 #include "mlir/IR/AffineMap.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/STLExtras.h"
 #include "mlir/Transforms/FoldUtils.h"
 
 #include "llvm/Support/CommandLine.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
Optional<TiledLinalgOp> static tileLinalgOpImpl(OpBuilder &b, LinalgOp op,
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(op);
   ScopedContext scope(b, op.getLoc());
   // 2. Build the tiled loop ranges.
   auto viewSizes = getViewSizes(b, op);
   // The flattened loopToOperandRangesMaps is expected to be an invertible
   // permutation map (asserted in the inverse calculation).
   auto mapsRange = op.indexing_maps().getAsRange<AffineMapAttr>();
-  auto maps =
-      functional::map([](AffineMapAttr a) { return a.getValue(); }, mapsRange);
+  auto maps = llvm::to_vector<8>(
+      llvm::map_range(mapsRange, [](AffineMapAttr a) { return a.getValue(); }));
   auto viewSizesToLoopsMap = inversePermutation(concatAffineMaps(maps));
   assert(viewSizesToLoopsMap && "expected invertible map");
 
   SmallVector<SubViewOp::Range, 4> loopRanges;
   LoopIndexToRangeIndexMap loopIndexToRangeIndex;
   std::tie(loopRanges, loopIndexToRangeIndex) =
       makeTiledLoopRanges(b, scope.getLocation(), viewSizesToLoopsMap,
                           viewSizes, tileSizes, folder);

mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.cpp

 
 #include "mlir/Dialect/SPIRV/SPIRVOps.h"
 
 #include "mlir/Dialect/CommonFolders.h"
 #include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
-#include "mlir/Support/Functional.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Common utility functions
 //===----------------------------------------------------------------------===//
 
 /// Returns the boolean value under the hood if the given `boolAttr` is a scalar

 }
 
 //===----------------------------------------------------------------------===//
 // spv.CompositeExtractOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult spirv::CompositeExtractOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 1 && "spv.CompositeExtract expects one operand");
-  auto indexVector = functional::map(
-      [](Attribute attr) {
+  auto indexVector =
+      llvm::to_vector<8>(llvm::map_range(indices(), [](Attribute attr) {
         return static_cast<unsigned>(attr.cast<IntegerAttr>().getInt());
-      },
-      indices());
+      }));
   return extractCompositeElement(operands[0], indexVector);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.constant
 //===----------------------------------------------------------------------===//
 
 OpFoldResult spirv::ConstantOp::fold(ArrayRef<Attribute> operands) {

mlir/lib/Dialect/Vector/EDSC/Builders.cpp

 //===- Builders.cpp - MLIR Declarative Linalg Builders --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Vector/EDSC/Builders.h"
 #include "mlir/Dialect/Vector/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/EDSC/Builders.h"
 #include "mlir/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Builders.h"
-#include "mlir/Support/Functional.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::edsc::ops;
 
 Value mlir::edsc::ops::vector_contraction(
     StructuredIndexed A, StructuredIndexed B, StructuredIndexed C,
     ArrayRef<IteratorType> iteratorTypes) {
   using IndexingExprs = ArrayRef<ArrayRef<AffineExpr>>;
   return vector_contract(
       A.getValue(), B.getValue(), C.getValue(),
       IndexingExprs{A.getExprs(), B.getExprs(), C.getExprs()},
-      ArrayRef<StringRef>{functional::map(toString, iteratorTypes)});
+      ArrayRef<StringRef>{
+          llvm::to_vector<8>(llvm::map_range(iteratorTypes, toString))});
 }
 
 Value mlir::edsc::ops::vector_contraction_matmul(Value A, Value B, Value C) {
   AffineExpr m, n, k;
   bindDims(ScopedContext::getContext(), m, n, k);
   return vector_contraction(StructuredIndexed(A, {m, k}),
                             StructuredIndexed(B, {k, n}),
                             StructuredIndexed(C, {m, n}),
                             {IteratorType::Parallel, IteratorType::Parallel,
                              IteratorType::Reduction});
 }

mlir/lib/Dialect/Vector/VectorOps.cpp

 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/Dialect/Vector/VectorUtils.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/MathExtras.h"
 #include "mlir/Support/STLExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include <numeric>
 
 using namespace mlir;
 using namespace mlir::vector;
if (val1 + val2 < 0 || val1 + val2 >= max)
              << " to be confined to [" << min << ", " << max << ")";
     ++index;
   }
   return success();
 }
 
 static ArrayAttr makeI64ArrayAttr(ArrayRef<int64_t> values,
                                   MLIRContext *context) {
-  auto attrs = functional::map(
-      [context](int64_t v) -> Attribute {
-        return IntegerAttr::get(IntegerType::get(64, context), APInt(64, v));
-      },
-      values);
-  return ArrayAttr::get(attrs, context);
+  auto attrs = llvm::map_range(values, [context](int64_t v) -> Attribute {
+  });
+  return ArrayAttr::get(llvm::to_vector<8>(attrs), context);
 }
 
 static LogicalResult verify(InsertStridedSliceOp op) {
   auto sourceVectorType = op.getSourceVectorType();
   auto destVectorType = op.getDestVectorType();
   auto offsets = op.offsets();
   auto strides = op.strides();
   if (offsets.size() != static_cast<unsigned>(destVectorType.getRank()))

mlir/lib/Dialect/Vector/VectorTransforms.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/OperationSupport.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/Types.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Support/STLExtras.h"
 
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "vector-to-vector"
 
 using namespace mlir;
 using llvm::dbgs;
-using mlir::functional::zipMap;
 
 /// Given a shape with sizes greater than 0 along all dimensions,
 /// returns the distance, in number of elements, between a slice in a dimension
 /// and the next slice in the same dimension.
 ///   e.g. shape[3, 4, 5] -> linearization_basis[20, 5, 1]
 static SmallVector<int64_t, 8> computeStrides(ArrayRef<int64_t> shape) {
   if (shape.empty())
     return {};
if (auto tupleGetOp = dyn_cast<vector::TupleGetOp>(op)) {
       unsigned sourceVectorRank = sourceVectorType.getRank();
       auto resultVectorType = shapeCastOp.getResultVectorType();
       auto resultVectorShape = resultVectorType.getShape();
       unsigned resultVectorRank = resultVectorType.getRank();
 
       int i = sourceVectorRank - 1;
       int j = resultVectorRank - 1;
 
-      // Check that source/result vector shape prefixes match while
-      // updating 'newOffsets'.
-      bool canShapeCastFold = true;
+      // Check that source/result vector shape prefixes match while updating
+      // 'newOffsets'.
       SmallVector<int64_t, 4> newOffsets(sourceVectorRank, 0);
-
-      auto apply = [&](int64_t sourceSize, int64_t resultSize) {
-        canShapeCastFold = sourceSize == resultSize;
-        newOffsets[i--] = offsets[j--];
-      };
-      functional::zipApply(apply, llvm::reverse(sourceVectorShape),
-                           llvm::reverse(resultVectorShape));
-      if (!canShapeCastFold)
+      for (auto it : llvm::zip(llvm::reverse(sourceVectorShape),
+                               llvm::reverse(resultVectorShape))) {
+        if (std::get<0>(it) != std::get<1>(it))
           return nullptr;
+        newOffsets[i--] = offsets[j--];
+      }
 
       // Check that remaining prefix of source/result vector shapes are all 1s.
       // Currently we only support producer/consumer tracking through trivial
       // shape cast ops. Examples:
       //   %1 = vector.shape_cast %0 : vector<1x1x2x4xf32> to vector<2x4xf32>
       //   %3 = vector.shape_cast %2 : vector<16x8xf32> to vector<1x16x8xf32>
       assert(i == -1 || j == -1);
       if (i >= 0 &&

mlir/lib/Dialect/Vector/VectorUtils.cpp

 #include "mlir/Dialect/Vector/VectorUtils.h"
 #include "mlir/Analysis/LoopAnalysis.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Operation.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/MathExtras.h"
 #include "mlir/Support/STLExtras.h"
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
 
 using llvm::SetVector;
for (int64_t r = 0; r < rank; ++r) {
     vectorOffsets[r] = index / sliceStrides[r];
     index %= sliceStrides[r];
   }
   return vectorOffsets;
 }
 
 SmallVector<int64_t, 4> mlir::computeElementOffsetsFromVectorSliceOffsets(
     ArrayRef<int64_t> sizes, ArrayRef<int64_t> vectorOffsets) {
-  return functional::zipMap([](int64_t v1, int64_t v2) { return v1 * v2; },
-                            vectorOffsets, sizes);
+  SmallVector<int64_t, 4> result;
+  for (auto it : llvm::zip(vectorOffsets, sizes))
+    result.push_back(std::get<0>(it) * std::get<1>(it));
+  return result;
 }
 
 SmallVector<int64_t, 4>
 mlir::computeSliceSizes(ArrayRef<int64_t> shape, ArrayRef<int64_t> sizes,
                         ArrayRef<int64_t> elementOffsets) {
   int64_t rank = shape.size();
   SmallVector<int64_t, 4> sliceSizes(rank);
   for (unsigned r = 0; r < rank; ++r)
     sliceSizes[r] = std::min(sizes[r], shape[r] - elementOffsets[r]);
   return sliceSizes;
 }
 
 Optional<SmallVector<int64_t, 4>> mlir::shapeRatio(ArrayRef<int64_t> superShape,
                                                    ArrayRef<int64_t> subShape) {
   if (superShape.size() < subShape.size()) {
     return Optional<SmallVector<int64_t, 4>>();
   }
 
   // Starting from the end, compute the integer divisors.
-  // Set the boolean `divides` if integral division is not possible.
   std::vector<int64_t> result;
   result.reserve(superShape.size());
-  bool divides = true;
-  auto divide = [&divides, &result](int superSize, int subSize) {
+  int64_t superSize = 0, subSize = 0;
+  for (auto it :
+       llvm::zip(llvm::reverse(superShape), llvm::reverse(subShape))) {
+    std::tie(superSize, subSize) = it;
     assert(superSize > 0 && "superSize must be > 0");
     assert(subSize > 0 && "subSize must be > 0");
-    divides &= (superSize % subSize == 0);
-    result.push_back(superSize / subSize);
-  };
-  functional::zipApply(
-      divide, SmallVector<int64_t, 8>{superShape.rbegin(), superShape.rend()},
-      SmallVector<int64_t, 8>{subShape.rbegin(), subShape.rend()});
 
     // If integral division does not occur, return and let the caller decide.
-  if (!divides) {
+    if (superSize % subSize != 0)
       return None;
+    result.push_back(superSize / subSize);
   }
 
   // At this point we computed the ratio (in reverse) for the common
   // size. Fill with the remaining entries from the super-vector shape (still in
   // reverse).
   int commonSize = subShape.size();
   std::copy(superShape.rbegin() + commonSize, superShape.rend(),
             std::back_inserter(result));

 /// header file.
 static AffineMap makePermutationMap(
     ArrayRef<Value> indices,
     const DenseMap<Operation *, unsigned> &enclosingLoopToVectorDim) {
   if (enclosingLoopToVectorDim.empty())
     return AffineMap();
   MLIRContext *context =
       enclosingLoopToVectorDim.begin()->getFirst()->getContext();
-  using functional::makePtrDynCaster;
-  using functional::map;
   SmallVector<AffineExpr, 4> perm(enclosingLoopToVectorDim.size(),
                                   getAffineConstantExpr(0, context));
 
   for (auto kvp : enclosingLoopToVectorDim) {
     assert(kvp.second < perm.size());
     auto invariants = getInvariantAccesses(
         cast<AffineForOp>(kvp.first).getInductionVar(), indices);
     unsigned numIndices = indices.size();

mlir/lib/IR/AffineMap.cpp

 //===- AffineMap.cpp - MLIR Affine Map Classes ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/AffineMap.h"
 #include "AffineMapDetail.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/StandardTypes.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Support/MathExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 
 namespace {

mlir/lib/IR/Builders.cpp

 //===- Builders.cpp - Helpers for constructing MLIR Classes ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
-#include "mlir/Support/Functional.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace mlir;
 
 Builder::Builder(ModuleOp module) : context(module.getContext()) {}
 
 Identifier Builder::getIdentifier(StringRef str) {
   return Identifier::get(str, context);
 }

 }
 SymbolRefAttr
 Builder::getSymbolRefAttr(StringRef value,
                           ArrayRef<FlatSymbolRefAttr> nestedReferences) {
   return SymbolRefAttr::get(value, nestedReferences, getContext());
 }
 
 ArrayAttr Builder::getI32ArrayAttr(ArrayRef<int32_t> values) {
-  auto attrs = functional::map(
-      [this](int32_t v) -> Attribute { return getI32IntegerAttr(v); }, values);
+  auto attrs = llvm::to_vector<8>(llvm::map_range(
+      values, [this](int32_t v) -> Attribute { return getI32IntegerAttr(v); }));
   return getArrayAttr(attrs);
 }
 
 ArrayAttr Builder::getI64ArrayAttr(ArrayRef<int64_t> values) {
-  auto attrs = functional::map(
-      [this](int64_t v) -> Attribute { return getI64IntegerAttr(v); }, values);
+  auto attrs = llvm::to_vector<8>(llvm::map_range(
+      values, [this](int64_t v) -> Attribute { return getI64IntegerAttr(v); }));
   return getArrayAttr(attrs);
 }
 
 ArrayAttr Builder::getIndexArrayAttr(ArrayRef<int64_t> values) {
-  auto attrs = functional::map(
-      [this](int64_t v) -> Attribute {
+  auto attrs = llvm::to_vector<8>(
+      llvm::map_range(values, [this](int64_t v) -> Attribute {
         return getIntegerAttr(IndexType::get(getContext()), v);
-      },
-      values);
+      }));
   return getArrayAttr(attrs);
 }
 
 ArrayAttr Builder::getF32ArrayAttr(ArrayRef<float> values) {
-  auto attrs = functional::map(
-      [this](float v) -> Attribute { return getF32FloatAttr(v); }, values);
+  auto attrs = llvm::to_vector<8>(llvm::map_range(
+      values, [this](float v) -> Attribute { return getF32FloatAttr(v); }));
   return getArrayAttr(attrs);
 }
 
 ArrayAttr Builder::getF64ArrayAttr(ArrayRef<double> values) {
-  auto attrs = functional::map(
-      [this](double v) -> Attribute { return getF64FloatAttr(v); }, values);
+  auto attrs = llvm::to_vector<8>(llvm::map_range(
+      values, [this](double v) -> Attribute { return getF64FloatAttr(v); }));
   return getArrayAttr(attrs);
 }
 
 ArrayAttr Builder::getStrArrayAttr(ArrayRef<StringRef> values) {
-  auto attrs = functional::map(
-      [this](StringRef v) -> Attribute { return getStringAttr(v); }, values);
+  auto attrs = llvm::to_vector<8>(llvm::map_range(
+      values, [this](StringRef v) -> Attribute { return getStringAttr(v); }));
   return getArrayAttr(attrs);
 }
 
 ArrayAttr Builder::getAffineMapArrayAttr(ArrayRef<AffineMap> values) {
-  auto attrs = functional::map(
-      [](AffineMap v) -> Attribute { return AffineMapAttr::get(v); }, values);
+  auto attrs = llvm::to_vector<8>(llvm::map_range(
+      values, [](AffineMap v) -> Attribute { return AffineMapAttr::get(v); }));
   return getArrayAttr(attrs);
 }
 
 Attribute Builder::getZeroAttr(Type type) {
   switch (type.getKind()) {
   case StandardTypes::BF16:
   case StandardTypes::F16:
   case StandardTypes::F32:

mlir/test/EDSC/builder-api-test.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Transforms/LoopUtils.h"
 #include "mlir/Transforms/Passes.h"
 
 #include "APITest.h"
 
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;

mlir/test/lib/Dialect/Affine/TestVectorizationUtils.cpp

 #include "mlir/Analysis/NestedMatcher.h"
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Vector/VectorUtils.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Pass/Pass.h"
-#include "mlir/Support/Functional.h"
 #include "mlir/Support/STLExtras.h"
 #include "mlir/Transforms/Passes.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "affine-super-vectorizer-test"
 
 using namespace mlir;
 
 using llvm::SetVector;
 
-using functional::map;
-
 static llvm::cl::OptionCategory clOptionsCategory(DEBUG_TYPE " options");
 
 static llvm::cl::list<int> clTestVectorShapeRatio(
     "vector-shape-ratio",
     llvm::cl::desc("Specify the HW vector size for vectorization"),
     llvm::cl::ZeroOrMore, llvm::cl::cat(clOptionsCategory));
 static llvm::cl::opt<bool> clTestForwardSlicingAnalysis(
     "forward-slicing",
for (auto m : matches) {
     } else {
       outs << "\nmatched: " << *opInst << " with shape ratio: ";
       interleaveComma(MutableArrayRef<int64_t>(*ratio), outs);
     }
   }
 }
 
 static NestedPattern patternTestSlicingOps() {
-  using functional::map;
   using matcher::Op;
   // Match all operations with the kTestSlicingOpName name.
   auto filter = [](Operation &op) {
     // Just use a custom op name for this test, it makes life easier.
     return op.getName().getStringRef() == "slicing-test-op";
   };
   return Op(filter);
 }

mlir/test/mlir-tblgen/predicate.td

let arguments = (ins
     AnyTensor:$b,
     AnyTensor:$c,
     AnyTensor:$d,
     AnyTensor:$e
   );
 }
 
 // CHECK-LABEL: OpJ::verify()
-// CHECK:      llvm::is_splat(mlir::functional::map(
-// CHECK-SAME:   [this](unsigned i) { return getElementTypeOrSelf(this->getOperand(i)); },
-// CHECK-SAME:   llvm::ArrayRef<unsigned>({0, 2, 3})))
+// CHECK:      llvm::is_splat(llvm::map_range(
+// CHECK-SAME:   llvm::ArrayRef<unsigned>({0, 2, 3}),
+// CHECK-SAME:   [this](unsigned i) { return getElementTypeOrSelf(this->getOperand(i)); }))
 // CHECK:   return emitOpError("failed to verify that operands indexed at 0, 2, 3 should all have the same type");
 
 def OpK : NS_Op<"op_for_AnyTensorOf", []> {
   let arguments = (ins TensorOf<[F32, I32]>:$x);
 }
 
 // CHECK-LABEL: OpK::verify
 // CHECK: auto valueGroup0 = getODSOperands(0);
 // CHECK: for (Value v : valueGroup0) {
 // CHECK: if (!(((v.getType().isa<TensorType>())) && (((v.getType().cast<ShapedType>().getElementType().isF32())) || ((v.getType().cast<ShapedType>().getElementType().isSignlessInteger(32))))))