Great question! Let's break down how to get the exact behavior you're looking for—combining an absolute base path with a relative path to produce a resolved absolute path, just like C#'s Path.GetFullPath(Path.Combine(abs, rel)).

The Problem with Standard Library Functions #

You're spot-on about the limitations of Haskell's standard tools: functions like makeAbsolute and canonicalizePath in System.FilePath use the current working directory as their base, not a specified absolute path. That doesn't fit your use case where you want to resolve relative paths against a given absolute base.

A Custom Solution Using System.FilePath #

Luckily, the System.FilePath module has all the building blocks we need to implement this ourselves. We can write a pure function (no IO required, since we're just doing logical path resolution, not accessing the filesystem) that handles path segments, resolves .. and ., and returns an Either type for clean error handling.

Code Implementation #

import System.FilePath (splitDirectories, joinPath, isAbsolute, normalise)
import Control.Monad (foldM)

-- Combines an absolute base path with a relative path, returning a resolved absolute path
-- Returns Left on errors (non-absolute base, navigating above root)
combineAndMakeAbsolute :: FilePath -> FilePath -> Either String FilePath
combineAndMakeAbsolute base rel
  | not (isAbsolute base) = Left "Base path must be an absolute path"
  | otherwise = Right . normalise . joinPath =<< foldM resolveSegment (splitDirectories base) (splitDirectories rel)
  where
    resolveSegment dirs "." = Right dirs  -- Ignore current directory segments
    resolveSegment [] ".." = Left "Cannot navigate above the root directory"
    resolveSegment dirs ".." = Right (init dirs)  -- Pop the last directory for parent references
    resolveSegment dirs segment = Right (dirs ++ [segment])  -- Append normal directory segments

How It Works with Your Example #

Let's walk through your test case step by step:

• Inputs: base = "X:/A/B/Q", rel = "../../B/W"

1. First, we validate that base is absolute (which it is here).
2. Split both paths into directory segments:
   • Base segments: ["X:", "A", "B", "Q"]
   • Relative segments: ["..", "..", "B", "W"]
3. Use foldM to process each relative segment:
   • First ..: removes "Q" → ["X:", "A", "B"]
   • Second ..: removes "B" → ["X:", "A"]
   • "B": appends → ["X:", "A", "B"]
   • "W": appends → ["X:", "A", "B", "W"]
4. Join the segments back into a path and normalise it (handles cross-platform path separators and cleans up redundant slashes) → "X:/A/B/W"

Testing the Function #

Try running this with your example:

combineAndMakeAbsolute "X:/A/B/Q" "../../B/W"
-- Returns: Right "X:/A/B/W"

Adding IO (If Needed) #

If you want an IO-wrapped version (for consistency with other filesystem functions, or if you later want to add filesystem checks), you can wrap it easily:

combineAndMakeAbsoluteIO :: FilePath -> FilePath -> IO (Either String FilePath)
combineAndMakeAbsoluteIO base rel = return $ combineAndMakeAbsolute base rel

Key Notes #

• This function is cross-platform: it handles both Windows-style paths (like X:/A/B) and Unix-style paths (like /home/user/docs).
• It returns Either String FilePath so you can gracefully handle errors (e.g., if someone passes a relative base path, or tries to go above the root).
• Unlike canonicalizePath, this doesn't access the filesystem—it just does logical path resolution, matching C#'s Path.GetFullPath behavior exactly.

内容的提问来源于stack exchange，提问作者John Walker