diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 73744888e57..43300789307 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -171,7 +171,7 @@ jobs:
         with:
           use-cross: true
           command: check
-          args: --features=merge_sort,io_ipc,io_csv,io_print,io_json,io_parquet --target ${{ matrix.target }}
+          args: --features=compute_merge_sort,io_ipc,io_csv,io_print,io_json,io_parquet --target ${{ matrix.target }}
 
   linux-simd-test:
     name: SIMD
diff --git a/Cargo.toml b/Cargo.toml
index a6dc602b0ec..16a8cfd5faa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -115,12 +115,10 @@ full = [
     "io_avro_compression",
     "io_avro_async",
     "regex",
-    "merge_sort",
     "compute",
     # parses timezones used in timestamp conversions
     "chrono-tz"
 ]
-merge_sort = ["itertools"]
 io_csv = ["io_csv_read", "io_csv_write"]
 io_csv_async = ["io_csv_read_async"]
 io_csv_read = ["csv", "lexical-core"]
@@ -149,7 +147,56 @@ io_avro_async = ["io_avro", "futures"]
 io_json_integration = ["io_json", "serde_derive", "hex"]
 io_print = ["comfy-table"]
 # the compute kernels. Disabling this significantly reduces compile time.
-compute = ["strength_reduce", "multiversion", "lexical-core", "ahash"]
+compute_aggregate = ["multiversion"]
+compute_arithmetics = ["strength_reduce"]
+compute_bitwise = []
+compute_boolean = []
+compute_boolean_kleene = []
+compute_cast = ["lexical-core"]
+compute_comparison = []
+compute_concatenate = []
+compute_contains = []
+compute_filter = []
+compute_hash = ["multiversion", "ahash"]
+compute_if_then_else = []
+compute_length = []
+compute_like = ["regex"]
+compute_limit = []
+compute_merge_sort = ["itertools", "compute_sort"]
+compute_nullif = ["compute_comparison"]
+compute_partition = ["compute_sort"]
+compute_regex_match = ["regex"]
+compute_sort = ["compute_take"]
+compute_substring = []
+compute_take = []
+compute_temporal = []
+compute_window = ["compute_concatenate"]
+compute = [
+    "compute_aggregate",
+    "compute_arithmetics",
+    "compute_bitwise",
+    "compute_boolean",
+    "compute_boolean_kleene",
+    "compute_cast",
+    "compute_comparison",
+    "compute_concatenate",
+    "compute_contains",
+    "compute_filter",
+    "compute_hash",
+    "compute_if_then_else",
+    "compute_length",
+    "compute_like",
+    "compute_limit",
+    "compute_merge_sort",
+    "compute_nullif",
+    "compute_partition",
+    "compute_regex_match",
+    "compute_sort",
+    "compute_substring",
+    "compute_take",
+    "compute_temporal",
+    "compute_window",
+]
 # base64 + io_ipc because arrow schemas are stored as base64-encoded ipc format.
 io_parquet = ["parquet2", "io_ipc", "base64", "futures"]
 benchmarks = ["rand"]
@@ -165,7 +212,7 @@ skip_feature_sets = [
     # very small scope with no API changes.
     ["ahash"],
     ["benchmarks"],
-    ["merge_sort"],
+    ["compute_merge_sort"],
     # io are additive APIs and do not interact
     ["io_csv"],
     ["io_csv_read"],
@@ -251,7 +298,7 @@ name = "bitmap"
 harness = false
 
 [[bench]]
-name = "concat"
+name = "concatenate"
 harness = false
 
 [[bench]]
diff --git a/benches/concat.rs b/benches/concatenate.rs
similarity index 82%
rename from benches/concat.rs
rename to benches/concatenate.rs
index 17273a2769f..7233a15a9d4 100644
--- a/benches/concat.rs
+++ b/benches/concatenate.rs
@@ -1,7 +1,7 @@
 extern crate arrow2;
 
 use arrow2::{
-    compute::concat,
+    compute::concatenate::concatenate,
     datatypes::DataType,
     util::bench_util::{create_boolean_array, create_primitive_array},
 };
@@ -17,7 +17,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         c.bench_function(&format!("int32 concat aligned 2^{}", log2_size), |b| {
             b.iter(|| {
-                let _ = concat::concatenate(&[&array1, &array2]);
+                let _ = concatenate(&[&array1, &array2]);
             })
         });
 
@@ -25,7 +25,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         c.bench_function(&format!("int32 concat unaligned 2^{}", log2_size), |b| {
             b.iter(|| {
-                let _ = concat::concatenate(&[&array1, &array2]);
+                let _ = concatenate(&[&array1, &array2]);
             })
         });
 
@@ -34,7 +34,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         c.bench_function(&format!("boolean concat aligned 2^{}", log2_size), |b| {
             b.iter(|| {
-                let _ = concat::concatenate(&[&array1, &array2]);
+                let _ = concatenate(&[&array1, &array2]);
             })
         });
 
@@ -42,7 +42,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         c.bench_function(&format!("boolean concat unaligned 2^{}", log2_size), |b| {
             b.iter(|| {
-                let _ = concat::concatenate(&[&array1, &array2]);
+                let _ = concatenate(&[&array1, &array2]);
             })
         });
     });
diff --git a/src/compute/arithmetics/basic/common.rs b/src/compute/arithmetics/basic/common.rs
deleted file mode 100644
index ed99efe7fbd..00000000000
--- a/src/compute/arithmetics/basic/common.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use crate::array::{Array, PrimitiveArray};
-use crate::error::{ArrowError, Result};
-use crate::types::NativeType;
-
-// Checking if both arrays have the same type
-#[inline]
-pub fn check_same_type<L: NativeType, R: NativeType>(
-    lhs: &PrimitiveArray<L>,
-    rhs: &PrimitiveArray<R>,
-) -> Result<()> {
-    if lhs.data_type() != rhs.data_type() {
-        return Err(ArrowError::InvalidArgumentError(
-            "Arrays must have the same logical type".to_string(),
-        ));
-    }
-    Ok(())
-}
-
-// Checking if both arrays have the same length
-#[inline]
-pub fn check_same_len<L: NativeType, R: NativeType>(
-    lhs: &PrimitiveArray<L>,
-    rhs: &PrimitiveArray<R>,
-) -> Result<()> {
-    if lhs.len() != rhs.len() {
-        return Err(ArrowError::InvalidArgumentError(
-            "Arrays must have the same length".to_string(),
-        ));
-    }
-    Ok(())
-}
diff --git a/src/compute/arithmetics/basic/div.rs b/src/compute/arithmetics/basic/div.rs
index aa41b6b42c0..2491cc5aaaf 100644
--- a/src/compute/arithmetics/basic/div.rs
+++ b/src/compute/arithmetics/basic/div.rs
@@ -3,13 +3,13 @@ use std::ops::Div;
 
 use num_traits::{CheckedDiv, NumCast, Zero};
 
-use crate::compute::arithmetics::basic::check_same_len;
 use crate::datatypes::DataType;
 use crate::{
     array::{Array, PrimitiveArray},
     compute::{
         arithmetics::{ArrayCheckedDiv, ArrayDiv, NativeArithmetics},
         arity::{binary, binary_checked, unary, unary_checked},
+        utils::check_same_len,
     },
     types::NativeType,
 };
diff --git a/src/compute/arithmetics/basic/mod.rs b/src/compute/arithmetics/basic/mod.rs
index d9126e3a7f4..53456f03ab0 100644
--- a/src/compute/arithmetics/basic/mod.rs
+++ b/src/compute/arithmetics/basic/mod.rs
@@ -18,9 +18,6 @@ pub use rem::*;
 mod sub;
 pub use sub::*;
 
-mod common;
-pub(crate) use common::*;
-
 use std::ops::Neg;
 
 use num_traits::{CheckedNeg, WrappingNeg};
diff --git a/src/compute/arithmetics/decimal/add.rs b/src/compute/arithmetics/decimal/add.rs
index e6a33ff4490..bbb71101e52 100644
--- a/src/compute/arithmetics/decimal/add.rs
+++ b/src/compute/arithmetics/decimal/add.rs
@@ -1,12 +1,11 @@
 //! Defines the addition arithmetic kernels for [`PrimitiveArray`] representing decimals.
-use crate::compute::arithmetics::basic::check_same_len;
 use crate::{
     array::{Array, PrimitiveArray},
     buffer::Buffer,
     compute::{
         arithmetics::{ArrayAdd, ArrayCheckedAdd, ArraySaturatingAdd},
         arity::{binary, binary_checked},
-        utils::combine_validities,
+        utils::{check_same_len, combine_validities},
     },
 };
 use crate::{
diff --git a/src/compute/arithmetics/decimal/div.rs b/src/compute/arithmetics/decimal/div.rs
index b83e057f632..754c90a79e5 100644
--- a/src/compute/arithmetics/decimal/div.rs
+++ b/src/compute/arithmetics/decimal/div.rs
@@ -1,14 +1,13 @@
 //! Defines the division arithmetic kernels for Decimal
 //! `PrimitiveArrays`.
 
-use crate::compute::arithmetics::basic::check_same_len;
 use crate::{
     array::{Array, PrimitiveArray},
     buffer::Buffer,
     compute::{
         arithmetics::{ArrayCheckedDiv, ArrayDiv},
         arity::{binary, binary_checked},
-        utils::combine_validities,
+        utils::{check_same_len, combine_validities},
     },
     datatypes::DataType,
     error::{ArrowError, Result},
diff --git a/src/compute/arithmetics/decimal/mul.rs b/src/compute/arithmetics/decimal/mul.rs
index b3858aa8e13..6b8289f418d 100644
--- a/src/compute/arithmetics/decimal/mul.rs
+++ b/src/compute/arithmetics/decimal/mul.rs
@@ -1,14 +1,13 @@
 //! Defines the multiplication arithmetic kernels for Decimal
 //! `PrimitiveArrays`.
 
-use crate::compute::arithmetics::basic::check_same_len;
 use crate::{
     array::{Array, PrimitiveArray},
     buffer::Buffer,
     compute::{
         arithmetics::{ArrayCheckedMul, ArrayMul, ArraySaturatingMul},
         arity::{binary, binary_checked},
-        utils::combine_validities,
+        utils::{check_same_len, combine_validities},
     },
     datatypes::DataType,
     error::{ArrowError, Result},
diff --git a/src/compute/arithmetics/decimal/sub.rs b/src/compute/arithmetics/decimal/sub.rs
index d7870401a3f..6cedf2fe74b 100644
--- a/src/compute/arithmetics/decimal/sub.rs
+++ b/src/compute/arithmetics/decimal/sub.rs
@@ -1,13 +1,12 @@
 //! Defines the subtract arithmetic kernels for Decimal `PrimitiveArrays`.
 
-use crate::compute::arithmetics::basic::check_same_len;
 use crate::{
     array::{Array, PrimitiveArray},
     buffer::Buffer,
     compute::{
         arithmetics::{ArrayCheckedSub, ArraySaturatingSub, ArraySub},
         arity::{binary, binary_checked},
-        utils::combine_validities,
+        utils::{check_same_len, combine_validities},
     },
     datatypes::DataType,
     error::{ArrowError, Result},
diff --git a/src/compute/arity.rs b/src/compute/arity.rs
index fec79e9d4cd..a7c359bf337 100644
--- a/src/compute/arity.rs
+++ b/src/compute/arity.rs
@@ -1,7 +1,6 @@
 //! Defines kernels suitable to perform operations to primitive arrays.
 
-use super::utils::combine_validities;
-use crate::compute::arithmetics::basic::check_same_len;
+use super::utils::{check_same_len, combine_validities};
 use crate::{
     array::PrimitiveArray,
     bitmap::{Bitmap, MutableBitmap},
diff --git a/src/compute/concat.rs b/src/compute/concatenate.rs
similarity index 54%
rename from src/compute/concat.rs
rename to src/compute/concatenate.rs
index b6c410c04e6..45cc21ccd92 100644
--- a/src/compute/concat.rs
+++ b/src/compute/concatenate.rs
@@ -1,31 +1,14 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
 //! Contains the concatenate kernel
 //!
 //! Example:
 //!
 //! ```
 //! use arrow2::array::Utf8Array;
-//! use arrow2::compute::concat::concatenate;
+//! use arrow2::compute::concatenate::concatenate;
 //!
 //! let arr = concatenate(&[
-//!     &Utf8Array::<i32>::from_slice(vec!["hello", "world"]),
-//!     &Utf8Array::<i32>::from_slice(vec!["!"]),
+//!     &Utf8Array::<i32>::from_slice(["hello", "world"]),
+//!     &Utf8Array::<i32>::from_slice(["!"]),
 //! ]).unwrap();
 //! assert_eq!(arr.len(), 3);
 //! ```
diff --git a/src/compute/contains.rs b/src/compute/contains.rs
index b1385924cb0..7e7c07721a0 100644
--- a/src/compute/contains.rs
+++ b/src/compute/contains.rs
@@ -1,13 +1,11 @@
 //! Declares the [`contains`] operator
 
-use crate::types::NativeType;
 use crate::{
     array::{Array, BinaryArray, BooleanArray, ListArray, Offset, PrimitiveArray, Utf8Array},
     bitmap::Bitmap,
-};
-use crate::{
     datatypes::DataType,
     error::{ArrowError, Result},
+    types::NativeType,
 };
 
 use super::utils::combine_validities;
diff --git a/src/compute/if_then_else.rs b/src/compute/if_then_else.rs
index 36261e5ac1e..4b44b9f7cf6 100644
--- a/src/compute/if_then_else.rs
+++ b/src/compute/if_then_else.rs
@@ -1,7 +1,7 @@
 //! Contains the operator [`if_then_else`].
-use crate::array::growable;
+use crate::array::{growable, Array, BooleanArray};
+use crate::bitmap::utils::SlicesIterator;
 use crate::error::{ArrowError, Result};
-use crate::{array::*, bitmap::utils::SlicesIterator};
 
 /// Returns the values from `lhs` if the predicate is `true` or from the `lhs` if the predicate is false
 /// Returns `None` if the predicate is `None`.
diff --git a/src/compute/like.rs b/src/compute/like.rs
index d36643f5afa..334c1fe74ca 100644
--- a/src/compute/like.rs
+++ b/src/compute/like.rs
@@ -4,10 +4,11 @@ use std::collections::HashMap;
 use regex::bytes::Regex as BytesRegex;
 use regex::Regex;
 
-use crate::datatypes::DataType;
-use crate::{array::*, bitmap::Bitmap};
 use crate::{
+    array::{BinaryArray, BooleanArray, Offset, Utf8Array},
+    bitmap::Bitmap,
     compute::utils::combine_validities,
+    datatypes::DataType,
     error::{ArrowError, Result},
 };
 
diff --git a/src/compute/mod.rs b/src/compute/mod.rs
index ab20499b5ff..b44433b9ef7 100644
--- a/src/compute/mod.rs
+++ b/src/compute/mod.rs
@@ -12,37 +12,77 @@
 //! Some dynamically-typed operators have an auxiliary function, `can_*`, that returns
 //! true if the operator can be applied to the particular `DataType`.
 
+#[cfg(feature = "compute_aggregate")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_aggregate")))]
 pub mod aggregate;
+#[cfg(feature = "compute_arithmetics")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_arithmetics")))]
 pub mod arithmetics;
 pub mod arity;
+#[cfg(feature = "compute_bitwise")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_bitwise")))]
 pub mod bitwise;
+#[cfg(feature = "compute_boolean")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_boolean")))]
 pub mod boolean;
+#[cfg(feature = "compute_boolean_kleene")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_boolean_kleene")))]
 pub mod boolean_kleene;
+#[cfg(feature = "compute_cast")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_cast")))]
 pub mod cast;
+#[cfg(feature = "compute_comparison")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_comparison")))]
 pub mod comparison;
-pub mod concat;
+#[cfg(feature = "compute_concatenate")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_concatenate")))]
+pub mod concatenate;
+#[cfg(feature = "compute_contains")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_contains")))]
 pub mod contains;
+#[cfg(feature = "compute_filter")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_filter")))]
 pub mod filter;
+#[cfg(feature = "compute_hash")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_hash")))]
 pub mod hash;
+#[cfg(feature = "compute_if_then_else")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_if_then_else")))]
 pub mod if_then_else;
+#[cfg(feature = "compute_length")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_length")))]
 pub mod length;
+#[cfg(feature = "compute_like")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_like")))]
+pub mod like;
+#[cfg(feature = "compute_limit")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_limit")))]
 pub mod limit;
+#[cfg(feature = "compute_merge_sort")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_merge_sort")))]
+pub mod merge_sort;
+#[cfg(feature = "compute_nullif")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_nullif")))]
 pub mod nullif;
+#[cfg(feature = "compute_partition")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_partition")))]
 pub mod partition;
+#[cfg(feature = "compute_regex_match")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_regex_match")))]
+pub mod regex_match;
+#[cfg(feature = "compute_sort")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_sort")))]
 pub mod sort;
+#[cfg(feature = "compute_substring")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_substring")))]
 pub mod substring;
+#[cfg(feature = "compute_take")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_take")))]
 pub mod take;
+#[cfg(feature = "compute_temporal")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_temporal")))]
 pub mod temporal;
 mod utils;
+#[cfg(feature = "compute_window")]
+#[cfg_attr(docsrs, doc(cfg(feature = "compute_window")))]
 pub mod window;
-
-#[cfg(feature = "regex")]
-#[cfg_attr(docsrs, doc(cfg(feature = "regex")))]
-pub mod like;
-#[cfg(feature = "regex")]
-#[cfg_attr(docsrs, doc(cfg(feature = "regex")))]
-pub mod regex_match;
-
-#[cfg(feature = "merge_sort")]
-#[cfg_attr(docsrs, doc(cfg(feature = "merge_sort")))]
-pub mod merge_sort;
diff --git a/src/compute/nullif.rs b/src/compute/nullif.rs
index 185ac948774..891ace88053 100644
--- a/src/compute/nullif.rs
+++ b/src/compute/nullif.rs
@@ -1,8 +1,8 @@
 //! Contains the operator [`nullif`].
 use crate::array::PrimitiveArray;
 use crate::bitmap::Bitmap;
-use crate::compute::arithmetics::basic::check_same_type;
 use crate::compute::comparison::{primitive_compare_values_op, Simd8, Simd8Lanes};
+use crate::compute::utils::check_same_type;
 use crate::datatypes::DataType;
 use crate::error::{ArrowError, Result};
 use crate::{array::Array, types::NativeType};
diff --git a/src/compute/utils.rs b/src/compute/utils.rs
index 87f1372aeb7..864eb27d40d 100644
--- a/src/compute/utils.rs
+++ b/src/compute/utils.rs
@@ -1,24 +1,8 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
 use crate::{
-    array::{BooleanArray, Offset, Utf8Array},
+    array::{Array, BooleanArray, Offset, Utf8Array},
     bitmap::Bitmap,
     datatypes::DataType,
+    error::{ArrowError, Result},
 };
 
 pub fn combine_validities(lhs: Option<&Bitmap>, rhs: Option<&Bitmap>) -> Option<Bitmap> {
@@ -45,3 +29,25 @@ pub fn unary_utf8_boolean<O: Offset, F: Fn(&str) -> bool>(
     let values = Bitmap::from_trusted_len_iter(iterator);
     BooleanArray::from_data(DataType::Boolean, values, validity)
 }
+
+// Errors iff the two arrays have a different length.
+#[inline]
+pub fn check_same_len(lhs: &dyn Array, rhs: &dyn Array) -> Result<()> {
+    if lhs.len() != rhs.len() {
+        return Err(ArrowError::InvalidArgumentError(
+            "Arrays must have the same length".to_string(),
+        ));
+    }
+    Ok(())
+}
+
+// Errors iff the two arrays have a different data_type.
+#[inline]
+pub fn check_same_type(lhs: &dyn Array, rhs: &dyn Array) -> Result<()> {
+    if lhs.data_type() != rhs.data_type() {
+        return Err(ArrowError::InvalidArgumentError(
+            "Arrays must have the same logical type".to_string(),
+        ));
+    }
+    Ok(())
+}
diff --git a/src/compute/window.rs b/src/compute/window.rs
index 8ccced766e3..37f4d403a46 100644
--- a/src/compute/window.rs
+++ b/src/compute/window.rs
@@ -17,7 +17,7 @@
 
 //! Defines windowing functions, like `shift`ing
 
-use crate::compute::concat;
+use crate::compute::concatenate::concatenate;
 use num_traits::{abs, clamp};
 
 use crate::{
@@ -58,8 +58,8 @@ pub fn shift(array: &dyn Array, offset: i64) -> Result<Box<dyn Array>> {
 
     // Concatenate both arrays, add nulls after if shift > 0 else before
     if offset > 0 {
-        concat::concatenate(&[null_array.as_ref(), slice.as_ref()])
+        concatenate(&[null_array.as_ref(), slice.as_ref()])
     } else {
-        concat::concatenate(&[slice.as_ref(), null_array.as_ref()])
+        concatenate(&[slice.as_ref(), null_array.as_ref()])
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 4cb9b06a164..4b71b9991e1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -18,8 +18,6 @@ pub mod types;
 #[cfg(feature = "cache_aligned")]
 mod vec;
 
-#[cfg(feature = "compute")]
-#[cfg_attr(docsrs, doc(cfg(feature = "compute")))]
 pub mod compute;
 pub mod io;
 pub mod record_batch;
diff --git a/tests/it/compute/concat.rs b/tests/it/compute/concatenate.rs
similarity index 98%
rename from tests/it/compute/concat.rs
rename to tests/it/compute/concatenate.rs
index 80b3fa7c100..7e4ea3d4322 100644
--- a/tests/it/compute/concat.rs
+++ b/tests/it/compute/concatenate.rs
@@ -1,5 +1,5 @@
 use arrow2::array::*;
-use arrow2::compute::concat::concatenate;
+use arrow2::compute::concatenate::concatenate;
 use arrow2::error::Result;
 
 #[test]
diff --git a/tests/it/compute/mod.rs b/tests/it/compute/mod.rs
index 732f1319303..ff55ab74d7b 100644
--- a/tests/it/compute/mod.rs
+++ b/tests/it/compute/mod.rs
@@ -1,26 +1,46 @@
+#[cfg(feature = "compute_aggregate")]
 mod aggregate;
+#[cfg(feature = "compute_arithmetics")]
 mod arithmetics;
+#[cfg(feature = "compute_bitwise")]
 mod bitwise;
+#[cfg(feature = "compute_boolean")]
 mod boolean;
+#[cfg(feature = "compute_boolean_kleene")]
 mod boolean_kleene;
+#[cfg(feature = "compute_cast")]
 mod cast;
+#[cfg(feature = "compute_comparison")]
 mod comparison;
-mod concat;
+#[cfg(feature = "compute_concatenate")]
+mod concatenate;
+#[cfg(feature = "compute_contains")]
 mod contains;
+#[cfg(feature = "compute_filter")]
 mod filter;
+#[cfg(feature = "compute_hash")]
 mod hash;
+#[cfg(feature = "compute_if_then_else")]
 mod if_then_else;
+#[cfg(feature = "compute_length")]
 mod length;
-#[cfg(feature = "regex")]
+#[cfg(feature = "compute_like")]
 mod like;
+#[cfg(feature = "compute_limit")]
 mod limit;
-#[cfg(feature = "merge_sort")]
+#[cfg(feature = "compute_merge_sort")]
 mod merge_sort;
+#[cfg(feature = "compute_partition")]
 mod partition;
-#[cfg(feature = "regex")]
+#[cfg(feature = "compute_regex_match")]
 mod regex_match;
+#[cfg(feature = "compute_sort")]
 mod sort;
+#[cfg(feature = "compute_substring")]
 mod substring;
+#[cfg(feature = "compute_take")]
 mod take;
+#[cfg(feature = "compute_temporal")]
 mod temporal;
+#[cfg(feature = "compute_window")]
 mod window;
diff --git a/tests/it/main.rs b/tests/it/main.rs
index e83b6e88ede..96515ebaf66 100644
--- a/tests/it/main.rs
+++ b/tests/it/main.rs
@@ -8,5 +8,4 @@ mod temporal_conversions;
 mod io;
 mod test_util;
 
-#[cfg(feature = "compute")]
 mod compute;