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 foldl
type Foldable :: (* -> *) -> Constraint
class Foldable t where
  ...
  foldl :: (b -> a -> b) -> b -> t a -> b
  ...
  	-- Defined in ‘Data.Foldable’
λ> :i foldr
type Foldable :: (* -> *) -> Constraint
class Foldable t where
  ...
  foldr :: (a -> b -> b) -> b -> t a -> b
  ...
  	-- Defined in ‘Data.Foldable’
λ> meufoldr (^) 1 [2,3,4]
2417851639229258349412352
λ> meufoldl (^) 1 [2,3,4]
1
λ> foldr (^) 1 [2,3,4]
2417851639229258349412352
λ> foldl (^) 1 [2,3,4]
1
λ> :t foldr
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
λ> :t foldl
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
λ> :i []

type [] :: * -> *
data [] a = [] | a : [a]
  	-- Defined in ‘GHC.Types’
instance Applicative [] -- Defined in ‘GHC.Base’
instance Eq a => Eq [a] -- Defined in ‘GHC.Classes’
instance Functor [] -- Defined in ‘GHC.Base’
instance Monad [] -- Defined in ‘GHC.Base’
instance Monoid [a] -- Defined in ‘GHC.Base’
instance Ord a => Ord [a] -- Defined in ‘GHC.Classes’
instance Semigroup [a] -- Defined in ‘GHC.Base’
instance Show a => Show [a] -- Defined in ‘GHC.Show’
instance MonadFail [] -- Defined in ‘Control.Monad.Fail’
instance Read a => Read [a] -- Defined in ‘GHC.Read’
instance Foldable [] -- Defined in ‘Data.Foldable’
instance Traversable [] -- Defined in ‘Data.Traversable’
λ> idr [1,2,3,4]
[1,2,3,4]
λ> idl [1,2,3,4]
[1,2,3,4]
λ> :t flip
flip :: (a -> b -> c) -> b -> a -> c
λ> take 10 naturais 
[0,1,2,3,4,5,6,7,8,9]
λ> take 10 naturaisr
[0,1,2,3,4,5,6,7,8,9]
λ> take 10 naturaisl
Interrupted.
λ> :i Foldable
type Foldable :: (* -> *) -> Constraint
class Foldable t where
  Data.Foldable.fold :: Monoid m => t m -> m
  foldMap :: Monoid m => (a -> m) -> t a -> m
  Data.Foldable.foldMap' :: Monoid m => (a -> m) -> t a -> m
  foldr :: (a -> b -> b) -> b -> t a -> b
  Data.Foldable.foldr' :: (a -> b -> b) -> b -> t a -> b
  foldl :: (b -> a -> b) -> b -> t a -> b
  Data.Foldable.foldl' :: (b -> a -> b) -> b -> t a -> b
  foldr1 :: (a -> a -> a) -> t a -> a
  foldl1 :: (a -> a -> a) -> t a -> a
  Data.Foldable.toList :: t a -> [a]
  null :: t a -> Bool
  length :: t a -> Int
  elem :: Eq a => a -> t a -> Bool
  maximum :: Ord a => t a -> a
  minimum :: Ord a => t a -> a
  sum :: Num a => t a -> a
  product :: Num a => t a -> a
  {-# MINIMAL foldMap | foldr #-}
  	-- Defined in ‘Data.Foldable’
instance Foldable [] -- Defined in ‘Data.Foldable’
instance Foldable Maybe -- Defined in ‘Data.Foldable’
instance Foldable (Either a) -- Defined in ‘Data.Foldable’
instance Foldable ((,) a) -- Defined in ‘Data.Foldable’
λ> product [2,3,4]
24
λ> maximum [1,2,3,4]
4
λ> length [1,2,3,4]
4
λ> :i maximum
type Foldable :: (* -> *) -> Constraint
class Foldable t where
  ...
  maximum :: Ord a => t a -> a
  ...
  	-- Defined in ‘Data.Foldable’
λ> :i product
type Foldable :: (* -> *) -> Constraint
class Foldable t where
  ...
  product :: Num a => t a -> a
  	-- Defined in ‘Data.Foldable’
λ>