listToMaybe doesn't participate in foldr/build fusion

I noticed that Data.OldList.findIndex seems to use more memory than necessary, and that changing the definition of listToMaybe to be in terms of foldr fixed the situation.

Consider the following module:

{-# LANGUAGE MagicHash #-}
{-# OPTIONS_GHC -ddump-to-file -ddump-prep -O #-}

module FindIndex where

import GHC.Base (Int(I#), build)
import GHC.Prim

-- | The definitions of listToMaybe, findIndices and findIndex are taken from base
listToMaybe           :: [a] -> Maybe a
listToMaybe []        =  Nothing
listToMaybe (a:_)     =  Just a

findIndices :: (a -> Bool) -> [a] -> [Int]
findIndices p ls = build $ \c n ->
  let go x r k | p x       = I# k `c` r (k +# 1#)
               | otherwise = r (k +# 1#)
  in foldr go (\_ -> n) ls 0#
{-# inline findIndices #-}

findIndex       :: (a -> Bool) -> [a] -> Maybe Int
findIndex p     = listToMaybe . findIndices p

-- This is the definition of findIndices when USE_REPORT_PRELUDE is defined
findIndices' :: (a -> Bool) -> [a] -> [Int]
findIndices' p xs = [ i | (x,i) <- zip xs [0..], p x]
{-# inline findIndices' #-}

listToMaybe' :: [a] -> Maybe a
listToMaybe' = foldr (const . Just) Nothing

-- | using listToMaybe', we get a join point
findIndex2       :: (a -> Bool) -> [a] -> Maybe Int
findIndex2 p     = listToMaybe' . findIndices p

-- | a "manual" implementaiton, we get a join point
findIndex3 :: (a -> Bool) -> [a] -> Maybe Int
findIndex3 p = go . zip [0..]
  where
    go [] = Nothing
    go ((i, x) : xs)
      | p x = Just i
      | otherwise = go xs

-- | alternate version of findIndices, stock listToMaybe, no join point
findIndex4 :: (a -> Bool) -> [a] -> Maybe Int
findIndex4 p = listToMaybe . findIndices' p

-- | alternate version of findIndices, foldr listToMaybe, we get a join point
findIndex5 :: (a -> Bool) -> [a] -> Maybe Int
findIndex5 p = listToMaybe' . findIndices' p

Find attached .dump-prep files with ghc-8.2.1 and ghc-head at commit 8843a39b.

My interpretation of this is: with both ghc-8.2.1 and ghc-head, findIndex{2,4,5} get join points and findIndex{"",3} don't. Having a join point means constant stack space, not having a join point means linear stack space.

I don't understand the simplifier well enough to know whether ghc could do better here, but it seems that changing the definition of listToMaybe to

listToMaybe :: [a] -> Maybe a
listToMaybe = foldr (const . Just) Nothing

would be a win. Are there any downsides?