How does Haskell handle error handling and monadic effects? Explain with examples.

In Haskell, error handling and monadic effects are managed through a powerful construct called the "Maybe" type and the use of monads. Haskell's approach to error handling is based on the concept of immutability and pure functions, which promotes safe and reliable programming practices. Let's explore how Haskell handles error handling and monadic effects in more detail.

Error Handling with Maybe:
The Maybe type in Haskell is used to represent computations that may or may not produce a result. It provides a safe way to handle errors and express optional values. The Maybe type is defined as follows:

```
haskell`data Maybe a = Nothing | Just a`
```
The "Nothing" value represents the absence of a value or an error, while "Just a" wraps a value of type 'a'. This allows functions to return a Maybe type instead of throwing exceptions or returning null values.

Here's an example that demonstrates the usage of Maybe for error handling:

```
haskell`safeDivide :: Int -> Int -> Maybe Int
safeDivide _ 0 = Nothing
safeDivide x y = Just (x `div` y)

main :: IO ()
main = do
putStrLn "Enter two numbers:"
input1 <- getLine
input2 <- getLine
let x = read input1 :: Int
y = read input2 :: Int
case safeDivide x y of
Just result -> putStrLn ("Result: " ++ show result)
Nothing -> putStrLn "Error: Division by zero"`
```
In this example, the function safeDivide takes two integers as input and returns a Maybe Int. It checks if the second argument is zero and returns Nothing to indicate an error in case of division by zero. Otherwise, it returns Just (x `div` y) to represent the result of the division.

In the main function, we read two numbers from the user and use the case statement to handle the Maybe result. If the result is Just result, we print the result. If it is Nothing, we print an error message.

Monadic Effects in Haskell:
Haskell uses monads to manage side effects and impure computations in a controlled manner. Monads provide a way to sequence and combine computations while maintaining purity. The IO monad is commonly used for performing I/O operations, such as reading from files or interacting with the console.

Here's an example that demonstrates the usage of the IO monad for file I/O:

```
haskell`import System.IO

readFileContents :: FilePath -> IO (Maybe String)
readFileContents path = do
handle <- openFile path ReadMode
contents <- hGetContents handle
hClose handle
if null contents
then return Nothing
else return (Just contents)

main :: IO ()
main = do
putStrLn "Enter a file path:"
path <- getLine
result <- readFileContents path
case result of
Just contents -> putStrLn ("File contents:\n" ++ contents)
Nothing -> putStrLn "Error: Empty file or file not found"`
```
In this example, the function readFileContents takes a file path as input and returns the contents of the file as a Maybe String using the IO monad. It uses functions from the System.IO module to open the file, read its contents, and close the file handle. If the file is empty or not found, it returns Nothing; otherwise, it returns Just contents.

In the main function, we prompt the user for a file path and use the case statement to handle the Maybe result. If the result is Just contents, we print the file contents. If it is Nothing, we print an error message.

By utilizing the Maybe type and monads like IO, Haskell provides a robust and type