[BUG] loc-based indexing with slice ranges inconsistent with pandas

[wence-]

Describe the bug

When indexing a frame with .loc one can provide a slice range where the endpoints of the slice are not contained in the index. If the index is not sorted then both pandas and cudf agree that you receive an error.

import cudf

df = cudf.DataFrame({"a": [1, 2, 3]}, index=[7, 0, 4])

df.loc[1:5] # => ValueError
df.to_pandas().loc[1:5] # => KeyError

Probably we should fix the distinction in the exception that is raised.

However, when the index is sorted, behaviour starts to differ:

When the index is monotone increasing (repeated values are allowed), and the slice has a positive step, then things work

import cudf
df = cudf.DataFrame({"a": [1, 2, 3]}, index=[0, 4, 7])

df.loc[1:5] == df.to_pandas().loc[1:5]

If the slice has negative stride, then cudf produces the wrong answer:

df = cudf.DataFrame({"a": [1, 2, 3]}, index=[0, 4, 7])
df.loc[5:0:-1] 
#   a
# 7  3
df.to_pandas().loc[5:0:-1]
#    a
# 4  2
# 0  1

If the index is monotone decreasing, and the slice has positive step, then the behaviour matches if both slice endpoints are in the index, and the behaviour differs if at least one of the slice end points is not in the index, in these circumstances, pandas always returns an empty dataframe, and cudf always produces a ValueError.

df = cudf.DataFrame({"a": [1, 2, 3]}, index=[7, 4, 0])
df.loc[0:4] == df.to_pandas().loc[0:4] # empty dataframe
df.loc[1:4] # => ValueError
df.to_pandas().loc[1:4] # empty data frame

If the slice has negative step, then the behaviour also differs, but differently. If both slice endpoints are in the index, then cudf returns an empty dataframe, whereas pandas returns the (reordered) dataframe sliced by the endpoints

df = cudf.DataFrame({"a": [1, 2, 3]}, index=[7, 4, 0])
df.loc[0:4:-1] # empty dataframe
df.to_pandas().loc[0:4:-1]
#    a
# 0  3
# 4  2

If at least one of the slice endpoints is not in the index, then cudf produces a ValueError and pandas behaves as for the monotone increasing case.

df = cudf.DataFrame({"a": [1, 2, 3]}, index=[7, 4, 0])
df.loc[0:5:-1] # => ValueError
df.to_pandas().loc[0:5:-1]
#    a
# 0  3
# 4  2

The above issues apply, mutatis mutandis to almost all index types in almost all cases (although I have not exhaustively checked). Amusingly the monotone increasing case with positive step slice with endpoint not in the index works for FloatXXXIndex.

Expected behavior

We should be consistent, both internally, and probably matching pandas where possible (raising errors otherwise).