Re: walking a directory tree efficiently
Manlio Perillo wrote:
> By the way, I have managed to have a working program:
> http://hpaste.org/13919
>
> I would like to receive some advices:
> 1) I have avoided the do notation,
As Paolo Losi says, there's nothing wrong with do-notation. You should
use whichever style makes your code the easiest to understand.
In order to increase your understanding it's a helpful exercise to write
monadic code in applicative style instead of do-notation, just as it can
be helpful to use points-free style instead of lambda abstractions. But
these are just exercises to help you become more familiar with doing the
transformations in your mind. At the end of the day, you should use
whichever of these styles makes your code easiest to read. Sometimes
that even means switching between them and using different styles in
different places. There's no performance difference between them because
the compiler does various transformations to normalize things before
doing real work.
> using functions like liftM.
> Is this a good practice?
> Is this as efficient as using do notation?
I prefer using (liftM f m) instead of (m >>= return . f) which is more
verbose and obfuscates the purity of f. Though personally liftM doesn't
strike me as an infix operator and so I think it's clearer to use it in
prefix form. The name doesn't support infixation as well as `elem`,
`asTypeOf`, `isPrefixOf`, etc.
If all of your Monads define instances for Functor as well ---and they
should!--- then you can use (<$>) from Control.Applicative as a good
infix name. The functions liftM and fmap are equal. The Monad class
should have Functor as a superclass since all monads are functors, but
brokenly it doesn't. The only difference between using liftM and using
fmap is which dictionaries get passed around for polymorphic functions
(assuming they're not all compiled away). Sometimes there might be a
small difference in clarity too, since not everyone realizes all monads
are functors.
> 2) I have written some support functions: mapM' and filterM'
> Are they well written and generic?
> Are they already available in some package?
> Can you suggest better names?
Your mapM' can be written as (fmap . fmap) which is more generic.
Assuming your Monads are Functors, of course.
Your filterM' can be rewritten as ((=<<) . filterM) or as the somewhat
more verbose (\f m -> m >>= filterM f)
Since these functions are so short and are used only once, I would
suggest just writing the definitions inline instead of breaking them out
and giving them names. Giving them names makes them seem more important
than they are.
> 3) I find
> (,) node `liftM` walkTree' path
> not very readable.
> Is it possible to express it in a more (not too much) verbose way?
liftM (\x -> (node,x)) (walkTree' path)
Don't be afraid of verbosity if you think it makes the code clearer to read.
--
--
Live well,
~wren
RSS Feed