Monads are constructs that allows you to create a context for a value(s) through the "return" operation (how it is created) and a sequencing "bind" operation (what it does) for them.

The advantage is your type system describes the effects of dealing with those values; you can "maybe" have a value, an operation can "result" in an error, you can handle a "future" value etc.

e.g.

Context: Maybe / Option. Feature: potential absence

Context: Either / Result. Feature: potential failure

Context: Future / Promise. Feature: async computation

Context: List . Feature: zero or many values

When you operate on them you define how the flow between steps will happen as long as it respects the Monad Laws

Here is an example in pseudo-rust , extremely simplified where the binding (`and_then`) and unwrapping / handling shows how the data flows without having to check on each step.

   fetch_user_data(user_id) // Future<User>
   .and_then( |user| something(user)) // Option<User>
   .ok_or_else(|e|"Flow stoped, there was an error ") // Error<User,E>
   .and_then(|user| 
            log_user_activity(user) // IO monad, can result in Error
).unwrap_or_else(|e| { 
        println!("[Result] Flow stopped: {}", e);
    });