Haskell 101

main :: IO ()
main = putStrLn "Hello, World!"
$ ghc --make HelloWorld.hs
$ ./HelloWorld
main :: IO ()
main = putStrLn "Hello, World!"
$ ghc hello.hs
$ ./hello
add :: Int -> Int -> Int
add x y = x + y
data Person = Person { name :: String, age :: Int }
numbers :: [Int]
numbers = [1, 2, 3, 4, 5]
person :: (String, Int)
person = ("Alice", 30)
addOne :: Int -> Int
addOne x = x + 1

double :: Int -> Int
double x = x * 2

-- Compose addOne and double functions
addOneAndDouble :: Int -> Int
addOneAndDouble = double . addOne
if condition then expression1 else expression2
max a b = if a > b then a else b
factorial 0 = 1
factorial n = n * factorial (n - 1)
[1, 2, 3, 4, 5]        -- a list of integers
['a', 'b', 'c', 'd']   -- a list of characters
["hello", "world"]     -- a list of strings
(1, "hello")      -- a tuple of an integer and a string
('a', 3.14)       -- a tuple of a character and a floating-point number
(True, False)     -- a tuple of two booleans
head [1, 2, 3]     -- returns 1
tail [1, 2, 3]     -- returns [2, 3]
length [1, 2, 3]   -- returns 3
[1, 2] ++ [3, 4]   -- returns [1, 2, 3, 4]
fst (1, "hello")   -- returns 1
snd (1, "hello")   -- returns "hello"
zip [1, 2, 3] ["a", "b", "c"]  -- returns [(1, "a"), (2, "b"), (3, "c")]
-- Define a new data type
data Shape = Circle Float | Rectangle Float Float

-- Define functions that work with Shape
area :: Shape -> Float
area (Circle r) = pi * r * r
area (Rectangle w h) = w * h
data Person = Person { name :: String, age :: Int }

-- Define a function that works with Person
greet :: Person -> String
greet p = "Hello, " ++ name p ++ "!"
module MyModule (foo, bar) where

foo :: Int -> Int
foo x = x * 2

bar :: Int -> Int
bar x = x + 3
import MyModule

main = do
    print (foo 2) -- prints 4
    print (bar 2) -- prints 5
module MyModule (foo, bar) where

import OtherModule (baz)

foo :: Int -> Int
foo x = x * 2

bar :: Int -> Int
bar x = x + 3

qux :: Int -> Int
qux x = baz x + 1
readLine :: IO String
readLine = getLine
main :: IO ()
main = do
  line <- readLine
  putStrLn line
foo :: Int -> String
foo x = if x > 0
        then "positive"
        else "non-positive"
bar :: Int -> String
bar x
  | x > 0 = "positive"
  | x == 0 = "zero"
  | otherwise = "negative"
data Tree a = Empty | Node a (Tree a) (Tree a)
treeSum :: Tree Int -> Int
treeSum Empty = 0
treeSum (Node value left right) = value + treeSum left + treeSum right
factorial :: Int -> Int
factorial n
    | n == 0    = 1
    | otherwise = n * factorial (n - 1)
[ expression | pattern <- list, predicate ]
[ x | x <- [1..10], x `mod` 2 == 0 ]
map :: (a -> b) -> [a] -> [b]
(\arg1 arg2 ... argn -> body)
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)

-- Example usage:
> applyTwice (\x -> x * 2) 5
20
> filter (\x -> x `mod` 2 /= 0) [1, 2, 3, 4, 5]
[1,3,5]
data Color = Red | Green | Blue
describeColor :: Color -> String
describeColor c = case c of
  Red -> "This color is red."
  Green -> "This color is green."
  Blue -> "This color is blue."
data Person = Person String Int
showPerson :: Person -> String
showPerson (Person name age) = name ++ " is " ++ show age ++ " years old."
data Tree a = Empty | Node a (Tree a) (Tree a)
insert :: Ord a => a -> Tree a -> Tree a
insert x Empty = Node x Empty Empty
insert x (Node y left right)
  | x < y     = Node y (insert x left) right
  | otherwise = Node y left (insert x right)
type Vertex = Int
type Graph = [(Vertex, [Vertex])]

adjacent :: Vertex -> Graph -> [Vertex]
adjacent v g = case lookup v g of
                 Just vs -> vs
                 Nothing -> []

insertEdge :: Vertex -> Vertex -> Graph -> Graph
insertEdge u v g = case lookup u g of
                     Just vs -> (u, v:vs) : g
                     Nothing -> (u, [v]) : g

deleteEdge :: Vertex -> Vertex -> Graph -> Graph
deleteEdge u v g = case lookup u g of
                     Just vs -> (u, filter (/=v) vs) : g
                     Nothing -> g
quicksort :: Ord a => [a] -> [a]
quicksort []     = []
quicksort (x:xs) = quicksort smaller ++ [x] ++ quicksort larger
  where smaller = [y | y <- xs, y < x]
        larger  = [y | y <- xs, y >= x]
main :: IO ()
main = do
  line <- getLine
  putStrLn ("You said: " ++ line)
add :: Int -> Int -> Int
add x y = x + y
add5 :: Int -> Int
add5 = add 5
> add5 3
8
add :: Int -> (Int -> Int)
add x y = x + y
> add5 = add 5
> add5 3
8
import Control.Monad.State

-- Define a data type to represent the state of the counter
type CounterState = Int

-- Define a function that increments the counter and returns the new state
incrementCounter :: State CounterState ()
incrementCounter = do
  counter <- get
  put (counter + 1)

-- Define a function that retrieves the current value of the counter
getCounter :: State CounterState Int
getCounter = get

-- Define a function that runs a sequence of counter operations
runCounter :: State CounterState Int
runCounter = do
  incrementCounter
  incrementCounter
  incrementCounter
  getCounter
-- Execute the runCounter computation with an initial state of 0
result = evalState runCounter 0
import Control.Monad.Reader

-- Define a data type to represent the configuration
data Config = Config {
  port :: Int,
  debug :: Bool
}

-- Define a function that reads the port number from the configuration
getPort :: Reader Config Int
getPort = do
  config <- ask
  return (port config)

-- Define a function that reads the debug flag from the configuration
getDebug :: Reader Config Bool
getDebug = do
  config <- ask
  return (debug config)

-- Define a function that uses both getPort and getDebug
getInfo :: Reader Config String
getInfo = do
  port <- getPort
  debug <- getDebug
  return ("Port: " ++ show port ++ ", Debug: " ++ show debug)
fibs :: [Integer]
fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
take 10 fibs -- returns [0,1,1,2,3,5,8,13,21,34]
module MyModule (
    myFunction,
    myConstant
) where

myFunction :: Int -> Int
myFunction x = x + 1

myConstant :: Int
myConstant = 42
module Main where

import MyModule

main :: IO ()
main = do
    putStrLn ("The constant is " ++ show myConstant)
    putStrLn ("2 + 1 = " ++ show (myFunction 2))
import System.IO

main = do
  handle <- openFile "example.txt" ReadMode
  contents <- hGetContents handle
  putStrLn contents
  hClose handle
import System.IO

main = do
  handle <- openFile "example.txt" WriteMode
  hPutStrLn handle "Hello, world!"
  hClose handle
import System.Environment

main :: IO ()
main = do
    args <- getArgs
    putStrLn ("Arguments: " ++ show args)
$ runhaskell myprogram.hs arg1 arg2 arg3
import System.Environment (getArgs)

main :: IO ()
main = do
    [inputFile, outputFile] <- getArgs
    inputContents <- readFile inputFile
    let outputContents = process inputContents
    writeFile outputFile outputContents

process :: String -> String
process = unlines . map reverse . lines
module MyModule
    ( foo
    , bar
    ) where

foo :: Int -> Int
foo x = x * 2

bar :: String -> String
bar s = reverse s
import MyModule

main :: IO ()
main = do
    putStrLn (show (foo 42))
    putStrLn (bar "hello"))
import qualified Data.Set as Set
import qualified Data.Map as Map

set_size = Set.size someSet
map_size = Map.size someMap
{-# LANGUAGE PackageImports #-}

import "bytestring" Data.ByteString as BS

-- Use the BS alias to refer to the module's functions and types
bs_length = BS.length someByteString
main :: IO ()
main = do
    handle <- openFile "input.txt" ReadMode
    contents <- hGetContents handle
    putStr contents
    hClose handle
import System.IO

main :: IO ()
main = do
    let path = "output.txt"
    handle <- openFile path WriteMode
    hPutStrLn handle "Hello, world!"
    hClose handle
import System.Directory (createDirectory, removeDirectory, doesDirectoryExist)
import System.FilePath ((</>))
import System.Environment

main :: IO ()
main = do
    args <- getArgs
    let a = read (head args) :: Int
        b = read (args !! 1) :: Int
    print (a + b)
{-# LANGUAGE OverloadedStrings #-}

import qualified Data.ByteString.Lazy as BL
import qualified Data.Csv as Csv

data Person = Person
    { name :: !String
    , age :: !Int
    , email :: !String
    }

instance Csv.FromRecord Person where
    parseRecord v
        | length v == 3 = Person <$> Csv.parseField (v !! 0)
                                 <*> Csv.parseField (v !! 1)
                                 <*> Csv.parseField (v !! 2)
        | otherwise = fail "Invalid record"

main :: IO ()
main = do
    csvData <- BL.readFile "people.csv"
    case Csv.decode Csv.NoHeader csvData of
        Left err -> putStrLn err
        Right people -> mapM_ print people
import System.IO

main :: IO ()
main = do
  contents <- readFile "example.txt"
  putStrLn contents
import System.IO

main :: IO ()
main = do
  writeFile "example.txt" "Hello, world!"
import System.IO

main :: IO ()
main = do
  appendFile "example.txt" "More text!"
import Network.Socket

main :: IO ()
main = withSocketsDo $ do
  addr <- resolve "3000"
  sock <- open addr
  listen sock
  loop sock

resolve :: String -> IO AddrInfo
resolve port = do
  let hints = defaultHints { addrFlags = [AI_PASSIVE] }
  addr:_ <- getAddrInfo (Just hints) Nothing (Just port)
  return addr

open :: AddrInfo -> IO Socket
open addr = do
  sock <- socket (addrFamily addr) Stream defaultProtocol
  setSocketOption sock ReuseAddr 1
  bind sock (addrAddress addr)
  return sock

listen :: Socket -> IO ()
listen sock = do
  listen sock 5

loop :: Socket -> IO ()
loop sock = do
  (conn, addr) <- accept sock
  handleConnection conn
  loop sock

handleConnection :: Socket -> IO ()
handleConnection conn = do
  msg <- recv conn 1024
  sendAll conn msg
  close conn
import Control.Exception (bracket)

readFileSafe :: FilePath -> IO String
readFileSafe path = bracket (openFile path ReadMode)
                           hClose
                           (\h -> do contents <- hGetContents h
                                     return contents)
class Eq a where
    (==) :: a -> a -> Bool
    (/=) :: a -> a -> Bool
instance Eq Int where
    x == y = x `eqInt` y
    x /= y = not (x == y)
data Person = Person { name :: String, age :: Int }

instance Eq Person where
    p1 == p2 = (name p1 == name p2) && (age p1 == age p2)
    p1 /= p2 = not (p1 == p2)
positiveIntegers = [1..]
take 10 positiveIntegers
data Maybe a = Nothing | Just a
data Either a b = Left a | Right b
sqrtMaybe :: Double -> Maybe Double
sqrtMaybe x
  | x < 0     = Nothing
  | otherwise = Just (sqrt x)
sqrtEither :: Double -> Either String Double
sqrtEither x
  | x < 0     = Left "Cannot take square root of a negative number"
  | otherwise = Right (sqrt x)
type family ListOfN (n :: Nat) (a :: Type) :: Type where
  ListOfN 0 a = '[]
  ListOfN n a = a ': ListOfN (n - 1) a
data IntOrString a where
  IntVal    :: Int -> IntOrString Int
  StringVal :: String -> IntOrString String
type family AppendList (xs :: [k]) (ys :: [k]) :: [k] where
  AppendList '[] ys = ys
  AppendList (x ': xs) ys = x ': AppendList xs ys
class Container c where
    type Element c :: *
    empty :: c
    insert :: Element c -> c -> c
    delete :: Element c -> c -> c
instance Container [] where
    type Element [] = a
    empty = []
    insert x xs = x : xs
    delete x = filter (/= x)
data Point (coord :: Nat) = Point { x :: Vec coord Double, y :: Vec coord Double, z :: Vec coord Double }
point2d :: Point 2
point2d = Point (1 :& 2 :& Nil) (3 :& 4 :& Nil) (0 :& 0 :& Nil)

point3d :: Point 3
point3d = Point (1 :& 2 :& 3 :& Nil) (4 :& 5 :& 6 :& Nil) (7 :& 8 :& 9 :& Nil)
nats = 0 : map (+1) nats
take 10 nats -- [0,1,2,3,4,5,6,7,8,9]
const x _ = x
lookup :: Eq a => a -> [(a, b)] -> Maybe b
lookup key [] = Nothing
lookup key ((k,v):xs)
  | key == k  = Just v
  | otherwise = lookup key xs
divide :: Int -> Int -> Either String Int
divide x 0 = Left "Division by zero"
divide x y = Right (x `div` y)
case divide 4 2 of
  Left err -> putStrLn err
  Right result -> putStrLn ("Result: " ++ show result)
data Shape = Circle Double | Rectangle Double Double
data Person = Person { name :: String, age :: Int }
data Color = Red | Green | Blue
data Point = Point Double Double
data Tree a = Leaf | Node (Tree a) a (Tree a)
sumTree :: Tree Double -> Double
sumTree Leaf = 0
sumTree (Node left x right) = sumTree left + x + sumTree right
data BinaryTree a = Empty | Node a (BinaryTree a) (BinaryTree a)
data BSTree a = Empty | Node a (BSTree a) (BSTree a)
insert :: Ord a => a -> b -> BSTree (a,b) -> BSTree (a,b)
insert k v Empty = Node (k,v) Empty Empty
insert k v (Node (k',v') left right)
  | k < k'    = Node (k',v') (insert k v left) right
  | k > k'    = Node (k',v') left (insert k v right)
  | otherwise = Node (k,v) left right
data Tree a = Empty | Node a (Tree a) (Tree a)

insert :: Ord a => a -> Tree a -> Tree a
insert x Empty = Node x Empty Empty
insert x (Node y left right)
  | x < y     = Node y (insert x left) right
  | otherwise = Node y left (insert x right)
search :: Ord a => a -> Tree a -> Maybe a
search _ Empty = Nothing
search x (Node y left right)
  | x == y    = Just y
  | x < y     = search x left
  | otherwise = search x right
delete :: Ord a => a -> Tree a -> Tree a
delete _ Empty = Empty
delete x (Node y left right)
  | x < y     = Node y (delete x left) right
  | x > y     = Node y left (delete x right)
  | otherwise = case (left, right) of
                  (Empty, Empty) -> Empty
                  (Empty, _)     -> right
                  (_, Empty)     -> left
                  _              -> let successor = findSuccessor right
                                     in Node successor left (delete successor right)
    where findSuccessor (Node y Empty _) = y
          findSuccessor (Node _ left _)  = findSuccessor left
data Graph a = Graph [a] [(a, a)]
g :: Graph Int
g = Graph [1, 2, 3] [(1, 2), (2, 3), (3, 1)]
import Data.List (foldl')
import qualified Data.Set as Set

bfs :: Ord a => Graph a -> a -> [a]
bfs (Graph nodes edges) start =
  let neighbors node = [b | (a, b) <- edges, a == node || b == node]
      go visited queue =
        case queue of
          [] -> []
          (node:rest) ->
            let newNodes = filter (`Set.notMember` visited) (neighbors node)
                newVisited = foldl' (flip Set.insert) visited newNodes
            in node : go newVisited (rest ++ newNodes)
  in go (Set.singleton start) [start]
data BinaryTree a = Leaf | Node (BinaryTree a) a (BinaryTree a)
insert :: Ord a => a -> BinaryTree a -> BinaryTree a
insert x Leaf = Node Leaf x Leaf
insert x (Node left y right)
  | x < y     = Node (insert x left) y right
  | otherwise = Node left y (insert x right)
data Expr = Lit Int
          | Add Expr Expr
          | Sub Expr Expr
          | Mul Expr Expr
          | Div Expr Expr
eval :: Expr -> Int
eval (Lit x) = x
eval (Add e1 e2) = eval e1 + eval e2
eval (Sub e1 e2) = eval e1 - eval e2
eval (Mul e1 e2) = eval e1 * eval e2
eval (Div e1 e2) = eval e1 `div` eval e2
data Tree a = Leaf
            | Node (Tree a) a (Tree a)
data Tree a = Empty | Node a (Tree a) (Tree a) deriving (Show, Eq)
insert :: Ord a => a -> Tree a -> Tree a
insert x Empty = Node x Empty Empty
insert x (Node val left right)
    | x < val   = Node val (insert x left) right
    | x > val   = Node val left (insert x right)
    | otherwise = Node val left right -- x is already in the tree
inOrder :: Tree a -> [a]
inOrder Empty          = []
inOrder (Node val l r) = inOrder l ++ [val] ++ inOrder r
delete :: Ord a => a -> Tree a -> Tree a
delete x Empty = Empty
delete x (Node val left right)
    | x < val   = Node val (delete x left) right
    | x > val   = Node val left (delete x right)
    | otherwise = case (left, right) of
                      (Empty, Empty) -> Empty -- case 1: no children
                      (left, Empty)  -> left  -- case 2: one child
                      (Empty, right) -> right -- case 2: one child
                      (left, right)  -> Node (findMin right) left (delete (findMin right) right) -- case 3: two children
                      where
                          findMin (Node val Empty _) = val
                          findMin (Node val left _)  = findMin left
deleteNode :: Ord a => a -> Tree a -> Tree a
deleteNode _ Empty = Empty
deleteNode x (Node val left right)
  | x < val = Node val (deleteNode x left) right
  | x > val = Node val left (deleteNode x right)
  | otherwise = case (left, right) of
      (Empty, Empty) -> Empty
      (left, Empty) -> left
      (Empty, right) -> right
      (left, right) -> let minRight = findMin right
                        in Node minRight left (deleteNode minRight right)
  where findMin (Node val Empty _) = val
        findMin (Node _ left _) = findMin left
import Data.List (isInfixOf)

isSubstring :: String -> String -> Bool
isSubstring sub str = isInfixOf sub str
import Data.List.Split (splitOn)

splitString :: Char -> String -> [String]
splitString delim str = splitOn delim str
findMax :: [Int] -> Int
findMax nums = maximum nums

findMin :: [Int] -> Int
findMin nums = minimum nums
import Statistics.Sample (mean)

computeMean :: [Double] -> Double
computeMean nums = mean nums
import Control.Concurrent
import Control.Monad

main :: IO ()
main = do
  forkIO $ forever $ do
    putStrLn "Hello, world!"
    threadDelay 1000000
  threadDelay 5000000
import System.Process

main :: IO ()
main = do
  (_, _, _, h) <- createProcess (proc "ls" ["-l"])
  waitForProcess h
import Control.Concurrent.STM

main :: IO ()
main = do
  counter <- newTVarIO 0
  mapM_ (\_ -> forkIO $ do
            atomically $ modifyTVar' counter (+1)
        ) [1..10]
  readTVarIO counter >>= print
import Control.Parallel

parSum :: Num a => [a] -> a
parSum [] = 0
parSum (x:xs) = sum1 `par` (sum2 `pseq` (sum1 + sum2))
  where
    sum1 = x
    sum2 = parSum xs
import Control.Concurrent

main :: IO ()
main = do
  tid1 <- forkIO $ do
    putStrLn "Thread 1 running"
    threadDelay 1000000
    putStrLn "Thread 1 finished"
  tid2 <- forkIO $ do
    putStrLn "Thread 2 running"
    threadDelay 2000000
    putStrLn "Thread 2 finished"
  putStrLn "Waiting for threads to finish"
  mapM_ takeMVar [tid1, tid2]
  putStrLn "All threads finished"
import Control.Concurrent.STM

main :: IO ()
main = do
  counter <- newTVarIO 0
  atomically $ modifyTVar' counter (+1)
  currentValue <- atomically $ readTVar counter
  print currentValue
import Control.Concurrent.STM

data TQueue a = TQueue (TVar [a])

newTQueue :: STM (TQueue a)
newTQueue = TQueue <$> newTVar []

writeTQueue :: TQueue a -> a -> STM ()
writeTQueue (TQueue tvar) x = modifyTVar' tvar (\xs -> xs ++ [x])

readTQueue :: TQueue a -> STM a
readTQueue (TQueue tvar) = do
  xs <- readTVar tvar
  case xs of
    [] -> retry
    (x:xs') -> do
      writeTVar tvar xs'
      return x
import Control.Parallel.Strategies

parSum :: Num a => [a] -> a
parSum xs = sum (parMap rseq id xs)
import Test.HUnit

add :: Int -> Int -> Int
add x y = x + y

testAdd :: Test
testAdd = test [
  "add 2 3 should be 5" ~: add 2 3 ~?= 5,
  "add 0 0 should be 0" ~: add 0 0 ~?= 0
  ]

main :: IO ()
main = runTestTT testAdd
import Test.QuickCheck

prop_reverse :: [Int] -> Bool
prop_reverse xs = reverse (reverse xs) == xs

main :: IO ()
main = quickCheck prop_reverse
import Debug.Trace

add :: Int -> Int -> Int
add x y = trace ("adding " ++ show x ++ " and " ++ show y) $ x + y
safeDivide :: Double -> Double -> Either String Double
safeDivide _ 0 = Left "Cannot divide by zero"
safeDivide x y = Right (x / y)
import Control.Exception (catch, IOException)

readFileSafe :: FilePath -> IO (Either String String)
readFileSafe file = do
  result <- catch (Right <$> readFile file) handler
  return result
  where
    handler :: IOException -> IO (Either String String)
    handler ex = return $ Left $ show ex
import Test.HUnit

-- Define test cases
test1 = TestCase (assertEqual "1 + 1 should be 2" 2 (1 + 1))
test2 = TestCase (assertBool "True should be True" (True))

-- Group test cases into a test list
tests = TestList [test1, test2]

-- Run the tests
main = runTestTT tests
import Test.QuickCheck

prop_reverse :: [Int] -> Bool
prop_reverse xs = reverse (reverse xs) == xs

-- Run the tests
main = quickCheck prop_reverse
import Debug.Trace

factorial :: Int -> Int
factorial 0 = 1
factorial n = trace ("calculating factorial of " ++ show n) $ n * factorial (n - 1)
$ stack new my-web-app yesod-sqlite
$ cd my-web-app
$ stack build
{-# LANGUAGE OverloadedStrings #-}

module Handler where

import Import

getUsersR :: Handler Value
getUsersR = do
  users <- runDB $ selectList [] []
  returnJson users
GET /users UsersController getUsersR
User
  name Text
  age Int Maybe
  deriving Show
User
  name Text
  age (Maybe Int)
  deriving Show
$ stack exec -- yesod devel
$ stack exec -- yesod add-handler
$ stack exec -- yesod add-sqlite
$ stack exec -- yesod persist
$ stack exec -- yesod devel
getUsersR :: Handler Value
getUsersR = do
  users <- runDB $ selectList [] []
  returnJson users

postUsersR :: Handler Value
postUsersR = do
  user <- requireJsonBody :: Handler User
  userId <- runDB $ insert user
  returnJson $ object ["id" .= (toJSON $ fromSqlKey userId)]
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}

import Data.Text (Text)
import Database.Persist.TH

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
Post
    title Text
    content Text
    deriving Generic
|]
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "blog.db" $ do
    runMigration migrateAll
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "blog.db" $ do
    -- Insert a new post
    postId <- insert $ Post "My First Post" "Hello, world!"

    -- Get all posts
    posts <- selectList [] [Desc PostTitle]
    liftIO $ print posts
CREATE TABLE Users (
    id INT PRIMARY KEY,
    name VARCHAR(50),
    email VARCHAR(50)
);
INSERT INTO Users (id, name, email) VALUES (1, 'Alice', 'alice@example.com');
UPDATE Users SET email='bob@example.com' WHERE name='Bob';
DELETE FROM Users WHERE id=2;
SELECT * FROM Users WHERE name LIKE 'A%';
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}

import Data.Text (Text)
import Database.Persist.TH

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
Post
    title Text
    content Text
    deriving Generic
|]
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "blog.db" $ do
    runMigration migrateAll
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "blog.db" $ do
    -- Insert a new post
    postId <- insert $ Post "My First Post" "Hello, world!"
    liftIO $ print postId
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "blog.db" $ do
    -- Retrieve all posts
    posts <- selectList [] []
    liftIO $ print posts
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "blog.db" $ do
    -- Insert a new post
    postId <- insert $ Post "My First Post" "Hello, world!"
    liftIO $ print postId
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "blog.db" $ do
    -- Update a post
    updateWhere [PostTitle ==. "My First Post"] [PostContent =. "Updated content"]
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "blog.db" $ do
    -- Delete a post
    deleteWhere [PostTitle ==. "My First Post"]
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "blog.db" $ do
    -- Join posts and users
    postsAndUsers <- select $
        from $ \(p `InnerJoin` u) -> do
            on (p ^. PostAuthorId ==. u ^. UserId)
            return (p, u)
    liftIO $ print postsAndUsers
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "blog.db" $ do
    -- Count posts
    postCount <- select $ aggregate $ do
        p <- from $ table @Post
        return countRows
    liftIO $ print postCount
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "blog.db" $ do
    -- Subquery for posts with authors whose names start with "A"
    posts <- select $
        from $ \p -> do
            where_ $ exists $
                from $ \u -> do
                    where_ $ u ^. UserName `like` val "A%"
                    on (p ^. PostAuthorId ==. u ^. UserId)
            return p
    liftIO $ print posts
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}

import Database.Persist.TH (mkPersist, mkMigrate, persistLowerCase, share, sqlSettings)

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
Person
    name String
    age Int
    deriving Show Generic
|]
import Control.Monad.IO.Class (liftIO)
import Database.Persist.Sqlite

main :: IO ()
main = runSqlite "test.db" $ do
    -- Insert a new person into the database
    personId <- insert $ Person "John Doe" 30
    liftIO $ print personId

    -- Query the database for all people with age 30
    people <- selectList [PersonAge ==. 30] []
    liftIO $ print people
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}

import Database.Persist.TH (mkPersist, mkMigrate, persistLowerCase, share, sqlSettings)

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
Person
    name String
    age Int
    deriving Show Generic
|]

main :: IO ()
main = runSqlite "test.db" $ do
    -- Insert a new person into the database
    personId <- insert $ Person "John Doe" 30
    liftIO $ print personId

    -- Query the database for all people with age 30
    people <- selectList [PersonAge ==. 30] []
    liftIO $ print people
{-# LANGUAGE OverloadedStrings #-}

import Database.Selda
import Database.Selda.SQLite

data Person = Person { name :: Text, age :: Int }

peopleTable :: Table Person
peopleTable = table "people" [name :- primary]

main :: IO ()
main = withSQLite "test.db" $ do
    -- Create a table for people
    createTable peopleTable

    -- Insert a new person into the database
    insert_ peopleTable [Person "John Doe" 30]

    -- Query the database for all people with age 30
    people <- query $ select peopleTable `suchThat` (\p -> p ! age .== 30)
    liftIO $ print people
import Database.MongoDB

main :: IO ()
main = do
    pipe <- connect (host "localhost")
    e <- access pipe master "test" runCommand
    close pipe
import Database.Redis

main :: IO ()
main = do
    conn <- connect defaultConnectInfo
    runRedis conn $ set "mykey" "myvalue"
    value <- runRedis conn $ get "mykey"
    print value
    close conn
import Database.CQL.IO

main :: IO ()
main = do
    pool <- newPool [("127.0.0.1", 9042)] "test" Nothing
    r <- withConn pool $ execute "SELECT * FROM users WHERE id = ?" [Int 1]
    print r
    release pool
FROM haskell:latest

WORKDIR /app

COPY . /app

RUN stack build

CMD ["stack", "exec", "myapp"]
docker build -t myapp .
docker run -p 8080:8080 myapp
import Options.Applicative

data Options = Options
  { name :: String
  , age :: Int
  }

optionsParser :: Parser Options
optionsParser = Options
  <$> strOption (long "name" <> help "The name of the person")
  <*> option auto (long "age" <> help "The age of the person")

main :: IO ()
main = do
  options <- execParser $ info (optionsParser <**> helper) fullDesc
  putStrLn $ "Hello, " ++ name options ++ "! You are " ++ show (age options) ++ " years old."
import System.Environment

main :: IO ()
main = do
    args <- getArgs
    putStrLn ("Arguments: " ++ show args)
import Options.Applicative

data MyOptions = MyOptions
    { optVerbose :: Bool
    , optInput   :: FilePath
    }

parseOptions :: Parser MyOptions
parseOptions = MyOptions
    <$> switch
        ( long "verbose"
        <> short 'v'
        <> help "Enable verbose output" )
    <*> strOption
        ( long "input"
        <> short 'i'
        <> metavar "FILE"
        <> help "Input file" )

main :: IO ()
main = do
    options <- execParser (info parseOptions mempty)
    putStrLn ("Verbose: " ++ show (optVerbose options))
    putStrLn ("Input: " ++ optInput options)
stack new my-cli-tool
dependencies:
- base >= 4.7 && < 5
- optparse-applicative
{-# LANGUAGE OverloadedStrings #-}

import Options.Applicative

data Opts = Opts
    { optInput :: String
    }

optsParser :: Parser Opts
optsParser = Opts
    <$> strOption
        ( long "input"
        <> short 'i'
        <> metavar "STRING"
        <> help "Input string to be transformed"
        )

main :: IO ()
main = do
    Opts{..} <- execParser $ info (optsParser <**> helper)
        ( fullDesc
        <> progDesc "Transform input string to uppercase"
        )
    putStrLn $ map toUpper optInput
stack build
stack exec my-cli-tool -- -i "hello world"
import Graphics.UI.Gtk

main :: IO ()
main = do
  initGUI
  window <- windowNew
  label <- labelNew (Just "Hello, world!")
  containerAdd window label
  widgetShowAll window
  mainGUI
$ ghc --make MyApp.hs
$ ./MyApp
stack install gtk
import Graphics.UI.Gtk

main :: IO ()
main = do
  initGUI
  window <- windowNew
  set window [ windowTitle := "Hello World"
             , windowDefaultWidth := 250
             , windowDefaultHeight := 250 ]
  button <- buttonNewWithLabel "Click me!"
  onClicked button (putStrLn "Hello World")
  containerAdd window button
  widgetShowAll window
  mainGUI
stack runhaskell Main.hs

Haskell 101

Chapter 1: Introduction to Functional Programming

What is functional programming?

Why is functional programming important?

The benefits and drawbacks of functional programming

Introduction to Haskell

The history of functional programming and its evolution over time

Understanding the differences between functional and imperative programming paradigms

The fundamental concepts of functional programming: pure functions, immutability, recursion, and higher-order functions

The role of types in functional programming and the benefits of type safety

An overview of Haskell’s syntax and features, including pattern matching, lazy evaluation, and type inference

Setting up the Haskell development environment and writing your first program

Common functional programming patterns and idioms in Haskell, including function composition, currying, and monads

Practical applications of functional programming, including parallel and distributed computing, machine learning, and web development with frameworks like Yesod and Scotty

Best practices for designing and writing functional code in Haskell, including testing, documentation, and code organization

Tips and tricks for becoming a more effective Haskell developer and getting involved in the Haskell community

Common pitfalls and challenges in functional programming, and strategies for overcoming them

Future directions for functional programming and the role of Haskell in the evolving landscape of programming languages and paradigms

Chapter 2: Getting Started with Haskell

Setting up the Haskell environment

Basic syntax and data types in Haskell

Functions and function composition

Understanding types and type inference

Control structures in Haskell, including conditionals and loops

Understanding and working with lists, tuples, and other data structures in Haskell

Understanding type classes and their role in Haskell’s type system

Defining and working with custom data types, including algebraic data types and records

Using modules in Haskell to organize code and dependencies

Understanding and working with monads and monad transformers, including the IO monad for interacting with the outside world

An introduction to the standard library and common third-party packages for Haskell

Best practices for writing efficient and idiomatic Haskell code, including avoiding common mistakes and pitfalls

Advanced topics in Haskell, including type-level programming, generic programming, and concurrency

Resources for learning more about Haskell, including online tutorials, books, and the Haskell community

Chapter 3: Control Structures in Haskell

Conditional statements and guards

Recursion and pattern matching

Lists and list comprehension

Higher-order functions and lambda expressions

Understanding and working with algebraic data types and pattern matching on them

Implementing algorithms and data structures in Haskell, including trees, graphs, and sorting algorithms

Trees

Graphs

Sorting algorithms

Understanding and using monads for control flow and error handling

Advanced techniques for working with higher-order functions, including partial application and currying

Implementing stateful computations in Haskell using monads, including the State and Reader monads

Working with lazy evaluation and infinite data structures in Haskell

Understanding and using type-level programming, including type families and GADTs

Best practices for designing and writing functional code with control structures in Haskell, including testing and documentation

Common mistakes and pitfalls to avoid when working with control structures in Haskell

Additional resources for learning more about control structures and functional programming in Haskell

Chapter 4: Modules and IO Operations

Understanding modules and import statements

File input/output operations in Haskell

Command-line arguments in Haskell

Working with the standard IO library

Organizing code with modules and packages, including creating and publishing your own packages

Advanced topics in modules and imports, including qualified imports and module aliases

Understanding and working with the Handle and FilePath types in the IO library

Working with directories and files in Haskell, including file and directory manipulation and permissions

An introduction to parsing and serialization in Haskell, including parsing command-line arguments and working with common data formats like JSON and CSV

Interacting with the outside world using the IO monad, including reading and writing to files and network sockets

Advanced techniques for working with the IO monad, including lazy IO and resource management

Best practices for designing and writing functional code that interacts with the outside world, including error handling and testing

Common mistakes and pitfalls to avoid when working with modules and IO operations in Haskell

Additional resources for learning more about modules, IO operations, and functional programming in Haskell

Chapter 5: Advanced Concepts in Haskell

Type classes and instances

Monads and their uses

Lazy evaluation and infinite lists

Understanding the Maybe and Either monads

Understanding advanced type system features in Haskell, including type families, GADTs, and type-level programming

Advanced topics in type classes and instances, including multi-parameter type classes and type class hierarchies

Working with type families and associated types to enable more flexible and powerful type-level programming

Advanced topics in monads and their uses, including monad transformers, stateful computations, and the Cont monad for control flow

Understanding and working with lazy evaluation, including infinite lists and the concept of thunks in Haskell

Working with advanced monads and monad stacks, including the Writer, Reader, and State monads

Understanding and using the Maybe and Either monads for error handling and control flow

Best practices for designing and writing functional code with advanced concepts in Haskell, including testing and documentation

Common mistakes and pitfalls to avoid when working with advanced concepts in Haskell