I noticed that the list indexing function, (!!), is generalizable. I'm showing some instances:

{-# LANGUAGE MultiParamTypeClasses #-}

import Data.Complex
import Data.Functor.Compose
import Data.Functor.Product
import Data.Functor.Sum
import Data.List.NonEmpty
import Data.Maybe

infix 9 !?
infixl 9 !

class Indexable i a where
    (!?) :: i b -> a -> Maybe b

(!) :: Indexable i a => i b -> a -> b
x ! n = fromJust (x !? n)

instance Indexable [] Int where
    [] !? _ = Nothing
    (x:_) !? 0 = Just x
    (_:xs) !? n
        | n < 0 = Nothing
        | otherwise = xs !? (n-1)

instance Indexable ((->) a) (Identity a) where
    f !? Identity n = Just (f n)

instance Indexable ((,) a) () where
    (_,x) !? _ = Just x

instance Indexable Complex Bool where
    (x :+ _) !? False = Just x
    (_ :+ y) !? True = Just y

instance (Indexable f a, Indexable g b) => Indexable (Compose f g) (a,b) where
    Compose z !? (m,n) = do
        y <- z !? m
        y !? n

instance (Indexable f a, Indexable g b) => Indexable (Product f g) (Either a b) where
    Pair x _ !? Left m = x !? m
    Pair _ y !? Right n = y !? n

instance (Indexable f a, Indexable g a) => Indexable (Sum f g) (Identity a) where
    InL x !? Identity n = x !? n
    InR y !? Identity n = y !? n

instance Indexable NonEmpty Int where
    (x :| xs) !? n = (x : xs) !? n