module Aula29 where

import Aula10 (Lista (..))
import Aula7 (Talvez (..))
import Aula27 ()

import GHC.Base (liftA2)

instance Foldable Lista where
  foldr _ base Vazia     = base
  foldr f base (x :# xs) = f x (foldr f base xs)

fromList :: [a] -> Lista a
fromList = foldr (:#) Vazia

toList :: Lista a -> [a]
toList = foldr (:) []

instance Traversable Lista where
  -- sequenceA :: Applicative f => t (f a) -> f (t a)
  -- sequenceA Vazia     = pure Vazia
  -- sequenceA (x :# xs) = liftA2 (:#) x (sequenceA xs)
  sequenceA = foldr (liftA2 (:#)) (pure Vazia)
    -- x  :: f a
    -- xs :: Lista (f a)
    -- pure   :: b -> f b
    -- (<*>)  :: f (b -> c) -> f b -> f c
    -- liftA2 :: (b -> c -> d) -> f b -> f c -> f d
    -- parece que c = Lista a

instance Foldable Talvez where
  -- foldr :: (a -> b -> b) -> b -> Talvez a -> b
  foldr _ base Nada       = base
  foldr f base (DeFato x) = f x base

instance Traversable Talvez where
  -- sequenceA :: Applicative f => Talvez (f a) -> f (Talvez a)
  sequenceA Nada       = pure Nada
  sequenceA (DeFato x) = fmap DeFato x
  -- fica feio:
  -- sequenceA = foldr (const . fmap DeFato) (pure Nada)

x = (DeFato 5) :# (DeFato 10) :# (DeFato 44) :# Vazia
y = (DeFato 0) :# Nada :# Vazia

x' = toList x
y' = toList y
  
sx = sequenceA x
sy = sequenceA y

sx' = sequenceA x'
sy' = sequenceA y'

-- ssx = sequenceA x -- dá erro pois não declaramos Lista como Applicative
-- ssy = sequenceA y -- dá erro pois não declaramos Lista como Applicative

ssx' = sequenceA sx' -- igual a x'
ssy' = sequenceA sy' -- diferente de y'