In Haskell, functors, applicative functors, and monads are abstractions that provide a way to perform computations and manipulate values within a specific context. These abstractions allow for powerful composition and sequencing of computations while maintaining purity and control over side effects. Let's explore each concept:

1. Functors :
   * Functors represent a computational context or container that can hold values and define an operation to transform those values.
   * The `Functor` type class in Haskell defines the `fmap` function, which allows applying a function to the values inside the functor.
   * The `fmap` function has the type signature `fmap :: (a -> b) -> f a -> f b`, where `f` is the functor type constructor.
   * Examples of functors in Haskell include lists, Maybe, and IO.

2. Applicative Functors :
   * Applicative functors build upon functors and provide a mechanism to combine computations within a functor context.
   * The `Applicative` type class in Haskell extends the `Functor` type class and introduces the `pure` function to lift a value into an applicative functor.
   * Applicative functors also define the `(<*>)` function, called "apply," which allows applying a function inside an applicative functor to a value inside another applicative functor.
   * The `(<*>)` function has the type signature `(<*>) :: f (a -> b) -> f a -> f b`.
   * Applicative functors enable applying functions of multiple arguments to values inside a functor, facilitating composition and sequencing of computations. 3. Monads :
   * Monads are a more powerful abstraction that extends the capabilities of applicative functors.
   * The `Monad` type class in Haskell defines the `return` function (equivalent to `pure`) and the `(>>=)` function (pronounced "bind"), which allows sequencing computations within a monadic context.
   * `(>>=)` has the type signature `(>>=) :: m a -> (a -> m b) -> m b`, where `m` is the monad type constructor.
   * Monads provide a way to chain computations, passing the result of one computation as input to the next computation, while maintaining control over side effects and handling exceptional cases.
   * Monads also introduce the `do` notation, which provides a more readable syntax for composing monadic computations.

These abstractions (functors, applicative functors, and monads) provide different levels of computational context and allow for composition, sequencing, and manipulation of values within those contexts. They form the foundation of many libraries and idioms in Haskell, enabling concise and expressive code for handling side effects, error handling, parsing, I/O, and more.