What are monads and functors in Haskell? How are they used for handling side effects?

In Haskell, monads and functors are powerful abstractions that play a crucial role in functional programming, particularly for handling side effects in a pure and composable manner. Let's explore the concepts of monads and functors and how they are used for handling side effects in Haskell.

Functors:
Functors are a fundamental concept in Haskell that allow you to apply a function to a value within a context. In other words, a functor applies a pure function to a wrapped value, preserving the context. Functors provide a way to map over values that are encapsulated in some sort of container or context.

In Haskell, the `Functor` type class captures the essence of a functor. Any type that implements the `Functor` type class can be considered a functor. The key function of the `Functor` type class is `fmap`, which allows you to apply a function to the encapsulated value.

```
haskell`class Functor f where
fmap :: (a -> b) -> f a -> f b`
```
For example, the `Maybe` type is a functor in Haskell. It represents a computation that can either return a value or fail. The `fmap` function for `Maybe` allows you to apply a function to the encapsulated value only if it exists.

```
haskell`instance Functor Maybe where
fmap f (Just x) = Just (f x)
fmap _ Nothing = Nothing`
```
Monads:
Monads are an extension of functors that provide a way to sequence computations that involve side effects. They encapsulate computations and allow for the composition of computations in a controlled manner while maintaining purity.

In Haskell, the `Monad` type class captures the concept of a monad. The key function of the `Monad` type class is `bind`, often represented by the `>>=` operator, which allows you to chain computations that produce monadic values.

```
haskell`class Monad m where
(>>=) :: m a -> (a -> m b) -> m b
return :: a -> m a`
```
The `return` function lifts a pure value into the monadic context, and the `>>=` operator allows you to combine monadic values, extracting values from one computation and passing them as inputs to the next computation.

Monads are used to handle side effects in Haskell in a controlled and explicit manner. They ensure that side effects are encapsulated within the monadic context, enabling composition and maintaining referential transparency.

For example, the `IO` type is a monad in Haskell that represents computations that interact with the outside world. Using the `>>=` operator, you can sequence multiple `IO` actions, ensuring that their order of execution is maintained.

```
haskell`main :: IO ()
main = do
putStrLn "Enter your name: "
name <- getLine
putStrLn ("Hello, " ++ name ++ "!")`
```
In this example, the `getLine` function returns an `IO String`, representing the action of reading a line from the console. The `>>=` operator allows you to bind the result of `getLine` to the `name` variable and then perform further actions, such as printing a message using `putStrLn`.

By using monads, you can sequence side-effecting computations, handle errors, manage state, and perform various other effects in a controlled and composable manner.

In summary, functors and monads are essential abstractions in Haskell that enable the functional handling of side effects. Functors provide a way to map over values within a context, while monads allow for sequencing and composition of computations with side effects, ensuring referential transparency and control over effects.