module Main where
 
main :: IO ()
main = putStrLn "Hello, World!"

-- This is a single-line comment.
 
{-
  This is a multi-line
  comment block.
-}
 
-- | Documentation comment for functions (Haddock style)
myFunc :: Int -> Int
myFunc x = x + 1

-- Variables in Haskell are immutable binds
x :: Int
x = 10 
 
-- Local bindings using 'let ... in' (Expression-level binding)
calculateArea :: Double -> Double -> Double
calculateArea width height =
  let area = width * height
  in area
 
-- Local bindings using 'where' (Declaration-level binding)
calculateVolume :: Double -> Double -> Double -> Double
calculateVolume w h d = area * d
  where area = w * h

-- Arithmetic
-- +, -, *, / (Fractional division), div (integer division), mod (modulo)
x = 5 / 2   -- 2.5 (Fractional)
y = 5 `div` 2 -- 2 (Integer division, backticks convert function to infix)
 
-- Relational & Equality
-- ==, /= (Not Equal), <, >, <=, >=
 
-- Logical
-- &&, ||, not
 
-- List Concatenation & Prepend
-- ++ (list concatenation), : (cons/prepend operator)
list1 = [1, 2] ++ [3, 4] -- [1, 2, 3, 4]
list2 = 1 : [2, 3]        -- [1, 2, 3]
 
-- Function Application & Composition
-- $ (Function application with low precedence, replaces parentheses)
-- . (Function composition)
printVal = print $ 2 + 2 -- same as: print (2 + 2)

-- in Haskell, 'if' is an expression that must always return a value
-- both the 'then' and 'else' branches are mandatory and must return the same type
checkAge :: Int -> String
checkAge age = if age >= 18
               then "Adult"
               else "Minor"

-- Pattern match values directly on expressions
describeList :: [a] -> String
describeList xs = case xs of
  []      -> "empty list"
  [x]     -> "singleton list"
  (x:y:_) -> "long list"

-- Guards provide a clean way to test conditional properties on arguments
bmiTell :: Double -> String
bmiTell bmi
  | bmi <= 18.5 = "Underweight"
  | bmi <= 25.0 = "Normal"
  | bmi <= 30.0 = "Overweight"
  | otherwise   = "Obese"

-- Since Haskell has no loops, recursion is used for iteration
factorial :: Integer -> Integer
factorial 0 = 1 -- Base case
factorial n = n * factorial (n - 1) -- Recursive case
 
-- Tail-recursive version with accumulator (helps compile to efficient loops)
factorialTail :: Integer -> Integer
factorialTail n = go n 1
  where
    go 0 acc = acc
    go k acc = go (k - 1) (acc * k)

-- Every function in Haskell takes exactly one argument and returns another function
-- This is called Currying.
add :: Int -> Int -> Int
add x y = x + y
 
-- Partial Application
addFive :: Int -> Int
addFive = add 5 -- returns a function expecting the second argument

-- Destructure patterns directly in parameter definitions
first :: (a, b, c) -> a
first (x, _, _) = x
 
head' :: [a] -> a
head' [] = error "Empty list!"
head' (x:_) = x -- extract head and discard tail

-- Syntax: \argument -> expression
addLambda = \x y -> x + y
 
doubleList = map (\x -> x * 2) [1, 2, 3] -- [2, 4, 6]

-- Functions that take functions as arguments or return functions
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)
 
-- applyTwice (+3) 10 -> 16

-- Function composition: (f . g) x = f (g x)
-- Function application: f $ x = f x
 
negateAndSum :: [Int] -> Int
negateAndSum = negate . sum -- clean, point-free style (no arguments declared)
 
-- $ avoids nested parentheses
val = putStrLn $ show $ sum [1..10]

-- Creates an alias for an existing type (no new type constructed)
type PhoneNumber = String
type Name = String
type PhoneBook = [(Name, PhoneNumber)]

-- 1. Sum Type (enumerations)
data Direction = North | South | East | West
 
-- 2. Product Type (records/structs)
data Point = Point Double Double -- constructor and arguments
 
-- 3. Sum of Products with Record Syntax (named fields)
data Person = Person {
  name :: String,
  age  :: Int
} deriving (Show, Eq)
 
-- Automatic getters generated:
-- name :: Person -> String
-- age  :: Person -> Int

-- Wraps exactly one type at compile-time for safety, erased at runtime
newtype CustomerId = CustomerId Int

-- Type classes define interfaces for types.
-- Eq      - Defines equality (==, /=)
-- Ord     - Defines ordering (<, >, <=, >=, compare)
-- Show    - Defines string formatting (show)
-- Read    - Defines parsing from string (read)
-- Num     - Mathematical operations (+, -, *, abs)
 
-- Deriving classes automatically
data Color = Red | Blue | Green
  deriving (Show, Eq, Ord)

class Printable a where
  printMe :: a -> String
  
-- Implement Type Class Instance
instance Printable Int where
  printMe x = "Integer: " ++ show x
  
instance Printable String where
  printMe s = "String: " ++ s

-- A Functor represents context that can be mapped over.
-- fmap :: (a -> b) -> f a -> f b
-- Infix operator: <$>
 
x :: Maybe Int
x = (+3) <$> Just 5 -- Just 8
 
y :: Maybe Int
y = (+3) <$> Nothing -- Nothing

-- Applicatives allow applying functions wrapped in contexts to values wrapped in contexts.
-- pure :: a -> f a
-- (<*>) :: f (a -> b) -> f a -> f b
 
res = Just (+) <*> Just 5 <*> Just 3 -- Just 8

-- Monads sequence operations, handling side effects (errors, I/O, state).
-- (>>=) :: m a -> (a -> m b) -> m b -- Bind Operator
-- return :: a -> m a
 
-- Standard bind syntax
half :: Int -> Maybe Int
half x = if even x then Just (x `div` 2) else Nothing
 
val = Just 20 >>= half >>= half -- Just 5
 
-- Do-notation (Syntactic sugar for Monad bind operations)
getUserInfo :: Maybe (String, Int)
getUserInfo = do
  name <- Just "Alice"
  age  <- Just 30
  return (name, age)

-- Infinite list definition (safe under lazy evaluation)
infiniteOnes = 1 : infiniteOnes
 
-- Take first 5 elements (evaluates only what is needed)
firstFive = take 5 infiniteOnes -- [1, 1, 1, 1, 1]

-- 1. seq function (forces evaluation of first arg before returning second)
sumStrict :: Int -> [Int] -> Int
sumStrict acc []     = acc
sumStrict acc (x:xs) = let nextAcc = acc + x
                       in nextAcc `seq` sumStrict nextAcc xs
                       
-- 2. strict application operator ($!)
result = f $! x -- forces x before applying f
 
-- 3. Bang Patterns (Requires GHC Extension BangPatterns)
sumBang :: Int -> [Int] -> Int
sumBang !acc []     = acc -- forces evaluation of acc
sumBang !acc (x:xs) = sumBang (acc + x) xs

-- throwing pure errors (dangerous, causes crash on evaluation)
divide :: Int -> Int -> Int
divide _ 0 = error "Division by zero!"
divide x y = x `div` y

import Control.Exception
 
readAndHandle :: IO ()
readAndHandle = do
  result <- try (readFile "non_existent.txt") :: IO (Either IOException String)
  case result of
    Left  ex       -> putStrLn $ "Caught file error: " ++ show ex
    Right contents -> putStrLn contents

import Control.Concurrent
 
main :: IO ()
main = do
  mvar <- newEmptyMVar -- Synced communication variable (like a blocking box)
  
  -- Fork lightweight thread
  forkIO $ do
    threadDelay 1000000 -- microseconds (1s)
    putMVar mvar "Worker finished"
    
  print "Waiting for worker..."
  val <- takeMVar mvar -- Blocks until variable populated
  print val

import Control.Concurrent.STM
 
-- STM guarantees atomic transaction blocks, preventing deadlocks & race conditions
transfer :: TVar Int -> TVar Int -> Int -> STM ()
transfer fromAcc toAcc amount = do
  fromBal <- readTVar fromAcc
  if fromBal < amount
    then retry -- Aborts transaction and waits for TVar change to retry
    else do
      writeTVar fromAcc (fromBal - amount)
      toBal <- readTVar toAcc
      writeTVar toAcc (toBal + amount)
      
executeTransfer :: TVar Int -> TVar Int -> Int -> IO ()
executeTransfer from to amt = atomically $ transfer from to amt

import System.IO
import qualified Data.Text.IO as TIO
 
main :: IO ()
main = do
  -- Standard lazy write/read
  writeFile "output.txt" "First line\nSecond line\n"
  
  contents <- readFile "output.txt"
  -- file handles stay open lazily until string evaluated
  putStr contents
  
  -- Strict Text I/O (recommended to avoid file lock leaks)
  strictText <- TIO.readFile "output.txt"
  TIO.putStr strictText

-- Geometry.hs
module Geometry (
  sphereVolume,
  sphereArea
) where
 
sphereVolume :: Double -> Double
sphereVolume radius = (4.0 / 3.0) * pi * (radius ^ 3)
 
sphereArea :: Double -> Double
sphereArea radius = 4 * pi * (radius ^ 2)

import Data.List -- Import all functions
import Data.Map (lookup, insert) -- Selective import
import Data.Set hiding (null) -- Hide specific name collisions
import qualified Data.Text as T -- Namespace alias

{-# LANGUAGE OverloadedStrings #-} -- Allows String literals to match Text/ByteString types
{-# LANGUAGE BangPatterns #-} -- Allows bang (!) patterns for strictness
{-# LANGUAGE MultiParamTypeClasses #-} -- Type classes with multiple parameters
{-# LANGUAGE GeneralizedNewtypeDeriving #-} -- Automatic deriving of underlying types for newtypes

{-# LANGUAGE ForeignFunctionInterface #-}
module Main where
 
import Foreign.C.Types
 
-- Call external C function
foreign import ccall "sin" c_sin :: CDouble -> CDouble
 
main :: IO ()
main = print $ c_sin 1.0

# Run GHCi shell
ghci
 
# Compile file to native executable
ghc Main.hs -o main
 
# Create new Stack project
stack new my-project
stack build
stack run

-- Extract values using pattern matching
let (x, y) = (1, 2) -- x=1, y=2
let (h:t)  = [1, 2, 3] -- h=1, t=[2, 3]
 
-- as-patterns (captures both the split parts and the overall structure)
firstLetter :: String -> String
firstLetter allVal@(c:_) = "First letter of " ++ allVal ++ " is " ++ [c]