Data.Graph 中的路径 function 在 Haskell 中如何工作？

Question

I have read the documentation that I can find on the path function ( for a directed graph ). There isn't much coming up in the search engine.

All I found basically boils down to this link .

All it really says is what the path function does (which I already knew), and and example of output. What I am trying to figure out, is how the path function works or how it could be implemented manually. So far I have gotten this far but am now stuck (or may be on the wrong path altogether, I can't be certain):

member _ [] = False
member n (x:xs)
    | x == n = True
    | otherwise = membre n xs
    
getX :: (a, b) -> a
getX (x,_) = x

getY :: (a, b) -> b
getY (_,y) = y

getAllY :: [(a , b)] -> [b]
getAllY [] = [] 
getAllY (x:xs) = (getY x):(getAllY xs)

fltrX [] _ = []
fltrX (x:xs) n 
    | (getX x) == n = x:(fltrX xs n)
    | otherwise = fltrX xs n
    
fltrY [] _ = []
fltrY (x:xs) n 
    | (getY x) == n = x:(fltrY xs n)
    | otherwise = fltrY xs n

path' :: [(a , a)] -> a -> a -> Bool
path' [] _ _ = False
path' (xs) n m 
    | (member m (getAllY (fltrX xs n))) = True
    | otherwise = *recursive statement giving me a headache*

but I am having trouble seeing how to get the recursion right. I think I have just been staring at it too long and can't see the whole problem clearly anymore. Logic should be something like:

• it takes the y values from the tuples with x = n
• it finds all tuples where x in the list of Y values above
• if no Y values = m, do path function on new list of tuples with n = (each of the X values) and m = m
• if m is found in the Y values, return true

Can anyone point me in the right direction (pun intended) preferably without typing out the code for me?

Thanks!

Answer 1

Thanks to commenters for providing resources that helped me write the following solution:

member _ [] = False
member n (x:xs)
    | x == n = True
    | otherwise = member n xs
    
unique [] = []
unique (x:xs)
    | member x xs == True = unique xs
    | otherwise = x:(unique xs)


findAllEndsForX :: [(Int , Int)] -> Int -> [Int]
findAllEndsForX [] _ = []
findAllEndsForX ((a,b):xs) y
  | xs == [] = a:[b]
  | a == y = a:(findAllEndsForX xs b)
  | otherwise = (findAllEndsForX xs b)

accessible :: [(Int , Int)] -> Int -> [Int]
accessible [] _ = []
accessible xs n = unique (findAllEndsForX xs n)

path' :: [(Int , Int)] -> Int -> Int -> Bool
path' [] _ _ = False
path' xs v w = member w (accessible xs v)

My ultimate goal was to mimic the functionality of the path feature, not necessarily the implementation. I wanted to do the work without using any predefined functions.