通过部分单调函数在ADT上创建折叠/同构

Question

I'm a bit unsure as what the actual name is for what I am trying, creating a fold or catamorphism seems the be the name for it.

I've got the following data structures with a fold:

type Order = [Int]
data Orders = Orders FilePath Order Order

type FoldOrders m o os = FilePath -> o -> o -> m os
type FoldOrder m o i = [i] -> m o
type FoldInt m i = Int -> m i

type Fold m os o i = (FoldOrders m o os, FoldOrder m o i, FoldInt m i)

foldOrders :: (Monad m) => Fold m os o i -> Orders -> m os
foldOrders (fos, fo, fi) (Orders orders1 orders2) = do o1 <- foldOrder orders1
                                                       o2 <- foldOrder orders2
                                                       fos o1 o2
    where foldOrder order = do o <- mapM foldInt order
                               fo o
          foldInt int     = fi int

This fold works fine with for example this 'implementation':

simpleWrite :: Fold IO () () ()
simpleWrite = (fos, fo, fi)
where fos _ _ = return ()
      fo  _   = return ()
      fi  i   = putStrLn $ show i

Using this command

foldOrders simpleWrite (Orders [1,2] [3,4])

it prints out 1 2 3 4 like you would expect.

So far so good, but..

When I want to 'push' down some information (a filepath in this case) while walking over the datastructure like so:

write :: Fold IO a b c
write = (fos, fo, fi)
     where fos path fo1 fo2 = do _ <- fo1 path
                                 _ <- fo2 path
                                 return ()
           fo fis path = do ios <- mapM (\x -> x path) fis
                            return ()           
           fi int path = appendFile path $ show int

I can't get it to compile. It gives back this error:

Couldn't match type `FilePath -> IO ()' with `IO c'
Expected type: FoldInt IO c
  Actual type: Int -> FilePath -> IO ()
In the expression: fi

It seems like you cannot return a partial monadic function like this, but why is that? And how can I get this to work?

Answer 1

If you want to write to some specific file, then that file should just be a parameter to the write function, ie write :: FilePath -> Fold IO abc . But as I understand, you want to compute the file path from the actual data. In this case, the filepath depends on the size of the data, so this is what you need to compute. You also need to compute a continuation of type FilePath -> IO () - you have the latter, but you are missing the former.

write :: Fold IO () (Int, FilePath -> IO ()) (FilePath -> IO ())
write = (fos, fo, fi) where 

 fos :: (Int, FilePath -> IO ()) -> (Int, FilePath -> IO ()) -> IO () 
 fos (sz1, fo1) (sz2, fo2) = do 
   let fp = show (sz1 + sz2) ++ ".txt" 
   sequence_ [fo1 fp, fo2 fp] 

 fo :: [ FilePath -> IO () ] -> IO (Int, FilePath -> IO ())
 fo fis = return (length fis, \fp -> mapM_ ($ fp) fis)

 fi :: Int -> IO (FilePath -> IO ())
 fi int = return $ \fp -> appendFile fp (show int)

As you can see, the principle is quite simple. If you need to compute two things at once, just compute two things at once! Sizes are simply added while functions of type FilePath -> IO () are simply lifted pointwise and then sequenced.

And a test (in ghci):

>:! cat 4.txt
cat: 4.txt: No such file or directory
>foldOrders write  (Orders [1,2] [3,4])
>:! cat 4.txt
1234>foldOrders write  (Orders [1,2] [3,4])
>:! cat 4.txt
12341234>