The lambdas must flow.
If I break, you can:
  1. Restart:           M-x haskell-process-restart
  2. Configure logging: C-h v haskell-process-log (useful for debugging)
  3. General config:    M-x customize-mode
  4. Hide these tips:   C-h v haskell-process-show-debug-tips
Changed directory: /home/hugo/Academic/Teaching/2022.2/TCPF/Aulas/
λ> :i Applicative
type Applicative :: (* -> *) -> Constraint
class Functor f => Applicative f where
  pure :: a -> f a
  (<*>) :: f (a -> b) -> f a -> f b
  GHC.Base.liftA2 :: (a -> b -> c) -> f a -> f b -> f c
  (*>) :: f a -> f b -> f b
  (<*) :: f a -> f b -> f a
  {-# MINIMAL pure, ((<*>) | liftA2) #-}
  	-- Defined in ‘GHC.Base’
instance Applicative (Either e) -- Defined in ‘Data.Either’
instance Applicative [] -- Defined in ‘GHC.Base’
instance Applicative Maybe -- Defined in ‘GHC.Base’
instance Applicative IO -- Defined in ‘GHC.Base’
instance Applicative ((->) r) -- Defined in ‘GHC.Base’
instance (Monoid a, Monoid b, Monoid c) =>
         Applicative ((,,,) a b c)
  -- Defined in ‘GHC.Base’
instance (Monoid a, Monoid b) => Applicative ((,,) a b)
  -- Defined in ‘GHC.Base’
instance Monoid a => Applicative ((,) a) -- Defined in ‘GHC.Base’
λ> :i Alternative

<interactive>:1:1-11: error: Not in scope: ‘Alternative’
λ> import Control.Applicative
λ> :i Alternative
type Alternative :: (* -> *) -> Constraint
class Applicative f => Alternative f where
  empty :: f a
  (<|>) :: f a -> f a -> f a
  some :: f a -> f [a]
  many :: f a -> f [a]
  {-# MINIMAL empty, (<|>) #-}
  	-- Defined in ‘GHC.Base’
instance Alternative ZipList -- Defined in ‘Control.Applicative’
instance GHC.Base.MonadPlus m => Alternative (WrappedMonad m)
  -- Defined in ‘Control.Applicative’
instance (Control.Arrow.ArrowZero a, Control.Arrow.ArrowPlus a) =>
         Alternative (WrappedArrow a b)
  -- Defined in ‘Control.Applicative’
instance Alternative [] -- Defined in ‘GHC.Base’
instance Alternative Maybe -- Defined in ‘GHC.Base’
instance Alternative IO -- Defined in ‘GHC.Base’
λ> (Just 1) <|> (Just 2)

λ> 1 + 1
2
λ> (Just 1) <|> Nothing
Just 1
λ> (Just 1) <|> (Just 2)
Just 1
λ> [] <|> [1,2,3]
[1,2,3]
λ> [4,5, 6] <|> [1,2,3]
[4,5,6,1,2,3]
λ> :i Alternative
type Alternative :: (* -> *) -> Constraint
class Applicative f => Alternative f where
  empty :: f a
  (<|>) :: f a -> f a -> f a
  some :: f a -> f [a]
  many :: f a -> f [a]
  {-# MINIMAL empty, (<|>) #-}
  	-- Defined in ‘GHC.Base’
instance Alternative ZipList -- Defined in ‘Control.Applicative’
instance GHC.Base.MonadPlus m => Alternative (WrappedMonad m)
  -- Defined in ‘Control.Applicative’
instance (Control.Arrow.ArrowZero a, Control.Arrow.ArrowPlus a) =>
         Alternative (WrappedArrow a b)
  -- Defined in ‘Control.Applicative’
instance Alternative [] -- Defined in ‘GHC.Base’
instance Alternative Maybe -- Defined in ‘GHC.Base’
instance Alternative IO -- Defined in ‘GHC.Base’
λ> :t some
some :: Alternative f => f a -> f [a]
λ> some (Nothing)
Nothing
λ> some (Just 5)
Interrupted.
λ> some (Just 5)
Interrupted.
λ> x = Just 5 :: Maybe Integer
λ> some x
Interrupted.
λ> x
DeFato 5 :# (DeFato 10 :# (DeFato 44 :# Vazia))
λ> y
DeFato 0 :# (Nada :# Vazia)
λ> sequenceA x 

<interactive>:212:1-11: error:
    • No instance for (Applicative Talvez)
        arising from a use of ‘sequenceA’
    • In the expression: sequenceA x
      In an equation for ‘it’: it = sequenceA x
λ> sequenceA x 
DeFato (5 :# (10 :# (44 :# Vazia)))
λ> sequenceA y
Nada
λ> z
DeFato (5 :# (10 :# (44 :# Vazia)))
λ> w
Nada
λ> sequenceA z

<interactive>:226:1-11: error:
    • No instance for (Applicative Lista)
        arising from a use of ‘sequenceA’
    • In the expression: sequenceA z
      In an equation for ‘it’: it = sequenceA z
λ> z'
DeFato [5,10,44]
λ> sequenceA z'
[DeFato 5,DeFato 10,DeFato 44]
λ> x'
[DeFato 5,DeFato 10,DeFato 44]
λ> y'
[DeFato 0,Nada]
λ> w'
Nada
λ> sequenceA w'
[Nada]
λ> sequenceA . sequenceA . sequenceA $ y'
Nada
λ> sequenceA . sequenceA . sequenceA $ w'
[Nada]
λ> :i Traversable
type Traversable :: (* -> *) -> Constraint
class (Functor t, Foldable t) => Traversable t where
  traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
  sequenceA :: Applicative f => t (f a) -> f (t a)
  mapM :: Monad m => (a -> m b) -> t a -> m (t b)
  sequence :: Monad m => t (m a) -> m (t a)
  {-# MINIMAL traverse | sequenceA #-}
  	-- Defined in ‘Data.Traversable’
instance Traversable Talvez
  -- Defined at /home/hugo/Academic/Teaching/2022.2/TCPF/Aulas/Aula29.hs:36:10
instance Traversable Lista
  -- Defined at /home/hugo/Academic/Teaching/2022.2/TCPF/Aulas/Aula29.hs:19:10
instance Traversable [] -- Defined in ‘Data.Traversable’
instance Traversable ZipList -- Defined in ‘Data.Traversable’
instance Traversable Maybe -- Defined in ‘Data.Traversable’
instance Traversable (Either a) -- Defined in ‘Data.Traversable’
instance Traversable (Const m) -- Defined in ‘Data.Traversable’
instance Traversable ((,) a) -- Defined in ‘Data.Traversable’
λ> sequenceA sx'
[DeFato 5,DeFato 10,DeFato 44]
λ> sequenceA sx

<interactive>:266:1-12: error:
    • No instance for (Applicative Lista)
        arising from a use of ‘sequenceA’
    • In the expression: sequenceA sx
      In an equation for ‘it’: it = sequenceA sx
λ> ssx'
[DeFato 5,DeFato 10,DeFato 44]
λ> x'
[DeFato 5,DeFato 10,DeFato 44]
λ> ssy'
[Nada]
λ> y'
[DeFato 0,Nada]
λ>