module Data.List.Lazy
    ( intersperse_
    , intercalate_
    , tails_
    ) where

import Control.Monad (guard)
import Data.Foldable (fold)
import Data.Function (fix)

type MList a = Maybe [a]

toMList :: [a] -> MList a
toMList = return

fromMList :: MList a -> [a]
fromMList = fold

inMList :: ([a] -> [a]) -> MList a -> MList a
inMList f = toMList . f . fromMList

(<:>) :: a -> MList a -> MList a
(<:>) = inMList . (:)

-- | Lazier version of intersperse
intersperse_ :: a -> [a] -> [a]
intersperse_ sep = fromMList . fix (\me xs -> do
  (h:t) <- return xs
  h <:> (guard (not $ null t) >> sep <:> me t))

-- | Lazier version of intercalate
intercalate_ :: [a] -> [[a]] -> [a]
intercalate_ sep xs = concat $ intersperse_ sep xs

-- | Lazier version of tails
tails_ :: [a] -> [[a]]
tails_ xs = xs : fromMList (do
              (_:t) <- return xs
              return $ tails_ t)