After ARROW-8792 we can observe that we are generating 312 take kernels

In [1]: import pyarrow.compute as pc                                                                      

In [2]: reg = pc.function_registry()                                                                      

In [3]: reg.get_function('take')                                                                          
Out[3]: 
arrow.compute.Function
kind: vector
num_kernels: 312

You can see them all here: https://gist.github.com/wesm/c3085bf40fa2ee5e555204f8c65b4ad5

It's probably going to be sufficient to only support int16, int32, and int64 index types for almost all types and insert implicit casts (once we implement implicit-cast-insertion into the execution code) for other index types. If we determine that there is some performance hot path where we need to specialize for other index types, then we can always do that.

Additionally, we should be able to collapse the date/time kernels since we're just moving memory.

Reporter: Wes McKinney / @wesm
Assignee: Wes McKinney / @wesm

Related issues:

• [C++] C++ array kernels framework and execution buildout (umbrella issue) (is a child of)
• [C++] Add "DispatchBest" APIs to compute::Function that selects a kernel that may require implicit casts to invoke (is related to)
• [C++] Reduce shared library / binary code size (umbrella issue) (is related to)

_{Note: This issue was originally created as ARROW-8901. Please see the migration documentation for further details.}