What is the haskell way to copy a directory

Question

I find myself doing more and more scripting in haskell. But there are some cases where I'm really not sure of how to do it "right".
e.g. copy a directory recursively (a la unix cp -r).

Since I mostly use linux and Mac Os I usually cheat:

import System.Cmd
import System.Exit

copyDir ::  FilePath -> FilePath -> IO ExitCode
copyDir src dest = system $ "cp -r " ++ src ++ " " ++ dest

But what is the recommended way to copy a directory in a platform independent fashion?
I didn't find anything suitable on hackage.

This is my rather naiv implementation I use so far:

import System.Directory
import System.FilePath((</>))
import Control.Applicative((<$>))
import Control.Exception(throw)
import Control.Monad(when,forM_)

copyDir ::  FilePath -> FilePath -> IO ()
copyDir src dst = do
  whenM (not <$> doesDirectoryExist src) $
    throw (userError "source does not exist")
  whenM (doesFileOrDirectoryExist dst) $
    throw (userError "destination already exists")

  createDirectory dst
  content <- getDirectoryContents src
  let xs = filter (`notElem` [".", ".."]) content
  forM_ xs $ \name -> do
    let srcPath = src </> name
    let dstPath = dst </> name
    isDirectory <- doesDirectoryExist srcPath
    if isDirectory
      then copyDir srcPath dstPath
      else copyFile srcPath dstPath

  where
    doesFileOrDirectoryExist x = orM [doesDirectoryExist x, doesFileExist x]
    orM xs = or <$> sequence xs
    whenM s r = s >>= flip when r

Any suggestions of what really is the way to do it?

---

I updated this with the suggestions of hammar and FUZxxl.
...but still it feels kind of clumsy to me for such a common task!

Answer 1

It's possible to use the Shelly library in order to do this, see cp_r:

cp_r "sourcedir" "targetdir"

Shelly first tries to use native cp -r if available. If not, it falls back to a native Haskell IO implementation.

For further details on type semantics of cp_r, see this post written by me to described how to use cp_r with String and or Text.

Shelly is not platform independent, since it relies on the Unix package, which is not supported under Windows.

Answer 2

I couldn't find anything that does this on Hackage.

Your code looks pretty good to me. Some comments:

1. dstExists <- doesDirectoryExist dst
   

   This does not take into account that a file with the destination name might exist.

2. if or [not srcExists, dstExists] then print "cannot copy"
   

   You might want to throw an exception or return a status instead of printing directly from this function.

3. paths <- forM xs $ \name -> do
       [...]
     return ()
   

   Since you're not using paths for anything, you can change this to

   forM_ xs $ \name -> do
     [...]
   

Answer 3

The filesystem-trees package provides the means for a very simple implementation:

import System.File.Tree (getDirectory, copyTo_)

copyDirectory :: FilePath -> FilePath -> IO ()
copyDirectory source target = getDirectory source >>= copyTo_ target

Answer 4

I assume that the function in Path.IO copyDirRecur with variants to include/exclude symlinks may be a newer and maintained solution. It requires to convert the filepath to Path x Dir which is achieved with parseRelDir respective parseAbsDir, but I think to have a more precise date type than FilePath is worthwile to avoid hard to track errors at run-time.

Answer 5

The MissingH package provides recursive directory traversals, which you might be able to use to simplify your code.

Answer 6

There are also some functions for copying files and directories in the core Haskell library Cabal modules, specifically Distribution.Simple.Utils in package Cabal. copyDirectoryRecursive is one, and there are other functions near this one in that module.