Proposal: Add "Alternative" instance for ZipList, as well as Semigroup and Monoid

[Zemyla]

This paper on monoids and near-semirings gives an Alternative instance
for ZipList consistent with its Applicative instance:

https://lirias.kuleuven.be/bitstream/123456789/499951/1/main.pdf

The original definition of (<|>) leaves a lot to be desired, because
it iterates through the first list twice, preventing inlining of xs:

ZipList xs <|> ZipList ys = ZipList $ xs ++ drop (length xs) ys

Edited for efficiency, it winds up being:

instance Alternative ZipList where
empty = ZipList []

ZipList xs <|> ZipList ys = ZipList $ go xs ys where
go [] ys = ys
go xs [] = xs
go (x:xs) (_:ys) = x:go xs ys

A different formulation, using foldr/build, goes like this:

ZipList xs <|> ZipList ys = ZipList $ build $ \c z -> let
goX x xr !n = c x $ xr $ n + 1
goY y yr n
| n <= 0 = c y $ yr 0
| otherwise = yr $ n - 1
in foldr goX (foldr goY (const z) ys) ys (0 :: Int)

It is an idempotent monoid, and sconcat/mconcat can be written as follows:

zlconcat :: Foldable t => t (ZipList a) -> ZipList a
zlconcat xss = ZipList $ build $ \c z -> let
goO (ZipList xs) xr !n = foldr goI endI xs 0 where
goI x xk i
| i < n = xk $ i + 1
| otherwise = c x $ xk $ i + 1
endI i = if i < n then xr n else xr i
in foldr goO (const z) xss (0 :: Int)

So in the end, the Semigroup/Monoid instances look like:

instance Semigroup (ZipList a) where
(<>) = (<|>)

sconcat = zlconcat

stimes = stimesIdempotentMonoid

instance Monoid (ZipList a) where
mempty = empty

mappend = (<|>)

mconcat = zlconcat

Sadly, the paper doesn't prove that it's a valid left catch
Alternative, and sort of mentions it offhand, but tests suggest it is
associative, [] is obviously the identity for <|> and the zero for
<*>, and pure a <|> x = pure a.

Any ideas on which implementation to prefer, or different ideas for
implementing sconcat/mconcat?