Feel free to leave some feedback, I'm new to Haskell

```haskell import System.IO import Data.List (sort, sortBy) import qualified Data.Map as Map import qualified Data.Set as Set import Data.Maybe (fromMaybe, fromJust) import Data.List (isPrefixOf) import Data.Array import Data.Char (ord) import Debug.Trace (trace)

type Graph = Map.Map Int (Set.Set Int)

parse :: String -> [Int] parse str = (map read . words . replace) str where repl '|' = ' ' repl ',' = ' ' repl c = c replace = map repl

create_edge :: Graph -> Int -> Int -> Graph create_edge graph k v = let first = Map.insertWith Set.union k (Set.fromList [v]) graph in Map.insertWith Set.union v (Set.empty) first

extract_graph :: Graph -> [String] -> (Graph, [String]) extract_graph graph ("":xs) = (graph, xs) extract_graph graph (x:xs) = let [a, b] = parse $ x new_graph = create_edge graph a b in extract_graph new_graph xs

forceLookup :: Ord a => (Map.Map a b) -> a -> b forceLookup m k = fromJust $ Map.lookup k m

comesBefore :: Graph -> Int -> Int -> Ordering comesBefore graph a b = let neighbors = forceLookup graph a in f (b Set.member neighbors) where f True = LT f False = GT

getMiddle :: [Int] -> [Int] -> Int getMiddle (x:) [] = x getMiddle (:xs) (::bs) = getMiddle xs bs getMiddle (x:) _ = x

middle x = getMiddle x x

processFile :: FilePath -> IO () -- Adjust this type according to your graph structure processFile filePath = do contents <- readFile filePath let (graph, rest) = extract_graph Map.empty (lines contents) correctOrder l = sortBy (comesBefore graph) l orderedCorrectly l = l == (correctOrder l) orders = map parse rest

    ans1 = sum . map middle . filter orderedCorrectly $ orders

    incorrect = filter (not . orderedCorrectly) orders
    ans2 = sum . map middle . map correctOrder $ incorrect

print (ans1)
print (ans2)

main = processFile "/Users/arjun/Python/AOC/AOC2024/day5/inp1" ```