Learn Modern Haskell for Python and Javascript Developers

import System.Random (randomRIO)
import Text.Read (readMaybe)
import System.IO (hFlush, stdout)

-- In Haskell, side effects (like printing or random numbers) MUST be marked with the IO type.
main :: IO ()
main = do
    -- Generate a random number. `<-` extracts the pure value from the IO action.
    secretNumber <- randomRIO (1, 100)
    putStrLn "Guess the number between 1 and 100!"
    -- We use recursion instead of a `while` loop
    gameLoop secretNumber

-- Functions that take an Int and perform IO
gameLoop :: Int -> IO ()
gameLoop secret = do
    putStr "> "
    hFlush stdout -- Forces output to appear before user types
    guessStr <- getLine
    
    -- readMaybe safely attempts to parse the string into an Int, returning a `Maybe Int`
    case readMaybe guessStr of
        Nothing -> do
            putStrLn "Please type a valid number!"
            gameLoop secret -- Loop back
            
        Just guess -> case compare guess secret of
            LT -> do
                putStrLn "Higher!"
                gameLoop secret
            GT -> do
                putStrLn "Lower!"
                gameLoop secret
            EQ -> putStrLn "You win!"

import System.Random (randomRIO)
import Text.Read (readMaybe)
import System.IO (hFlush, stdout)

main :: IO ()
main = do
    putStrLn "Solve the addition problems! Type 'quit' to exit."
    playLoop

playLoop :: IO ()
playLoop = do
    a <- randomRIO (1, 10)
    b <- randomRIO (1, 10)
    
    putStr $ "What is " ++ show a ++ " + " ++ show b ++ "? "
    hFlush stdout
    
    input <- getLine
    if input == "quit"
        then putStrLn "Thanks for playing!"
        else do
            -- `let` is used inside `do` blocks to bind pure values (no IO)
            let correctAnswer = a + b
            case readMaybe input of
                Just ans | ans == correctAnswer -> putStrLn "Correct!"
                         | otherwise            -> putStrLn $ "Wrong! It was " ++ show correctAnswer
                Nothing -> putStrLn "Please enter a number or 'quit'."
            
            playLoop -- Recurse to play the next round

import System.Random (randomRIO)
import Text.Read (readMaybe)
import System.IO (hFlush, stdout)

-- Algebraic Data Types form the backbone of safe State Machines
data Operation = Add | Multiply deriving (Show, Eq)
data AppState = Menu | Playing | Quit deriving (Show, Eq)

-- Record syntax allows us to name fields in a complex structure
data Settings = Settings {
    minVal :: Int,
    maxVal :: Int,
    op     :: Operation
} deriving (Show)

defaultSettings :: Settings
defaultSettings = Settings { minVal = 1, maxVal = 10, op = Add }

main :: IO ()
main = runMachine Menu defaultSettings

-- We pass the State and Settings explicitly through recursion. No global mutable variables!
runMachine :: AppState -> Settings -> IO ()
runMachine Quit _ = return ()
runMachine Menu settings = do
    putStr "1. Play  2. Set Multiply  3. Quit\n> "
    hFlush stdout
    input <- getLine
    case input of
        "1" -> runMachine Playing settings
        -- We return a NEW settings object with the `op` changed
        "2" -> do
            putStrLn "Operation set to Multiplication."
            runMachine Menu (settings { op = Multiply })
        "3" -> runMachine Quit settings
        _   -> do
            putStrLn "Invalid option."
            runMachine Menu settings

runMachine Playing settings = do
    a <- randomRIO (minVal settings, maxVal settings)
    b <- randomRIO (minVal settings, maxVal settings)
    
    let (symbol, correct) = case op settings of
            Add      -> ("+", a + b)
            Multiply -> ("*", a * b)

    putStr $ "What is " ++ show a ++ " " ++ symbol ++ " " ++ show b ++ "? ('menu' to go back) "
    hFlush stdout
    
    input <- getLine
    if input == "menu"
        then runMachine Menu settings
        else do
            case readMaybe input of
                Just ans | ans == correct -> putStrLn "Correct!"
                         | otherwise      -> putStrLn $ "Wrong, it was " ++ show correct
                Nothing -> putStrLn "Not a number."
            runMachine Playing settings

import System.Random.Shuffle (shuffleM) -- Requires the 'random-shuffle' package
import System.IO (hFlush, stdout)

-- Data types with named records
data Flashcard = Flashcard {
    question :: String,
    answer   :: String
} deriving (Show)

main :: IO ()
main = do
    let deck = [ Flashcard "Capital of France?" "Paris"
               , Flashcard "2 ** 8?" "256"
               , Flashcard "Haskell build tool?" "Cabal" ]

    -- shuffleM shuffles the list within the IO monad
    shuffledDeck <- shuffleM deck

    -- Instead of `for` loops, we use `mapM_` to map an IO action over a list
    mapM_ askCard shuffledDeck
    
    putStrLn "Deck completed!"

askCard :: Flashcard -> IO ()
askCard card = do
    putStr $ "Q: " ++ question card ++ " (Press Enter)"
    hFlush stdout
    _ <- getLine
    putStrLn $ "A: " ++ answer card ++ "\n"

import System.Directory (listDirectory, doesFileExist, createDirectoryIfMissing, renameFile)
import System.FilePath ((), takeExtension)
import Control.Monad (forM_)
import Data.Char (toLower)

main :: IO ()
main = do
    let downloadsDir = "./downloads_test"
    createDirectoryIfMissing True downloadsDir
    
    -- listDirectory reads the contents of the folder
    entries <- listDirectory downloadsDir
    
    -- forM_ is similar to a for-loop, it executes an IO action for each item
    forM_ entries $ \fileName -> do
        let path = downloadsDir  fileName
        isFile <- doesFileExist path
        
        if isFile
            then do
                -- takeExtension safely pulls out the extension (e.g., ".pdf")
                let ext = drop 1 $ map toLower (takeExtension fileName)
                let folderName = getCategory ext
                let targetDir = downloadsDir  folderName
                
                createDirectoryIfMissing True targetDir
                let newPath = targetDir  fileName
                
                renameFile path newPath
                putStrLn $ "Moved " ++ fileName ++ " to " ++ targetDir
            else return ()

-- A perfectly pure function to categorize files!
getCategory :: String -> String
getCategory ext = case ext of
    "pdf"  -> "Documents"
    "docx" -> "Documents"
    "txt"  -> "Documents"
    "jpg"  -> "Media"
    "png"  -> "Media"
    "mp4"  -> "Media"
    "zip"  -> "Compressed"
    "tar"  -> "Compressed"
    _      -> "Others"