编写`（\\ x - > traceShow xx）`的简单方法是什么？

Question

Printing the value of an expression is a common practice in debugging. For example, if I have a piece of code like this

my . super . cool . fUnCtIoN . chain $ value

and I am trying to see the output of fUnCtIoN . chain fUnCtIoN . chain , I would add

my . super . cool . (\ x -> traceShow x x ) . fUnCtIoN . chain $ value

which is mouthful for a simple task like this, not to mention if I want to print many intermediate results:

(\ x -> traceShow x x )
    . my
    . (\ x -> traceShow x x )
    . super
    . (\ x -> traceShow x x )
    . cool
    . (\ x -> traceShow x x )
    . fUnCtIoN
    . (\ x -> traceShow x x )
    . chain
    $ value

It would just look awful. Is there a better way to do this?

Answer 1

Just use traceShowId ! It does exactly what you're asking for.

my . super . cool . traceShowId . fUnCtIoN . chain $ value

Answer 2

Yes. join traceShow .

λ>  import Control.Monad
λ> :t join
join :: Monad m => m (m a) -> m a
λ> :t join (+)
join (+) :: Num a => a -> a

In the case of the function monad, join fx = fxx , so join traceShow is equivalent to \\x -> traceShow xx .

Or make a where clause that provides a new definition of (.) :

--...your code without the nasty bits...
    where
       (.) f g a = f ( join traceShow (g a))

Which may just help, though there will be one more traceShow call than previously.

Answer 3

How about a helper function for adding a trace call to a function:

dbg :: Show a => String -> a -> a
dbg name x = trace (name ++ ": " ++ show x) x

main = do
  let x = dbg "my"    . my
        . dbg "super" . super
        . dbg "cool"  . cool
        . dbg "func"  . fUnCtIoN
        . dbg "chain" . chain
        $ value
  print x

my       = (+1)
super    = (+2)
cool     = (+3)
fUnCtIoN = (+4)
chain    = (+5)
value = 3

Output:

chain: 3
func: 8
cool: 12
super: 15
my: 17
18

Answer 4

You could write a higher-order function which takes a function of two arguments and uses the same value for both arguments.

applyBoth :: (a -> a -> b) -> a -> b
applyBoth f x = f x x

(Aside: this is join for the "reader" monad (->) a .)

Then you can use that combinator in curried form:

applyBoth traceShow
    . my
    . applyBoth traceShow
    . super
    . applyBoth traceShow
    . cool
    . applyBoth traceShow
    . fUnCtIoN
    . applyBoth traceShow
    . chain
    $ value

Or define an alias for applyBoth traceShow .

traceS = applyBoth traceShow

traceS
    . my
    . traceS
    . super
    . traceS
    . cool
    . traceS
    . fUnCtIoN
    . traceS
    . chain
    $ value

For maximum terseness points, you can automatically interleave traceS into a list of functions by folding it up:

showSteps :: Show a => [a -> a] -> a -> a
showSteps = foldr (\f g -> f . traceS . g) id

showSteps [my, super, cool, fUnCtIoN, chain] value

---

Edit Eh, what the hell... It's not entirely relevant, but here's how to make showSteps work when you want to pipeline your data through a number of types. It's an example of a program we wouldn't be able to write without GHC's advanced type system features ( GADTs and RankNTypes in this instance).

Path is a GADT which explains how to walk through a directed graph of types, starting at the source type x and ending at the destination type y . It's parameterised by a category c :: * -> * -> * .

infixr 6 :->
data Path c x y where
    End :: Path c z z
    (:->) :: c x y -> Path c y z -> Path c x z

:-> reminds us that a journey of a thousand miles begins with a single step: if the category you're working in lets you go from x to y , and you can take a path from y to z , you can go from x to z . End is for when you have reached your destination - it's pretty easy to walk from z to z by not walking at all.

So Path has the same recursive structure as a linked list, but with a more flexible approach to the things inside it. Rather than requiring all of its elements to have the same type, it gives you a way to join up arrows like dominos, as long as the return type of one arrow matches the input type of the next. (To use the mathematical jargon: if you view the underlying category c as a logical relation, then End augments c with reflexivity and :-> augments c with transitivity . Path c thus constructs the reflexive transitive closure of c . Another way of looking at this is that Path is the free category , much like [] is the free monoid ; you can define instance Category (Path c) without any constraint on c .)

You can fold up a Path with exactly the same code as you use to fold up a list, but the type is more precise: the folding function can't know anything a priori about the types of the arrows inside the path.

foldr :: (forall x y. c x y -> r y z -> r x z) -> r z z -> Path c x z -> r x z
foldr f z End = z
foldr f z (x :-> xs) = f x $ foldr f z xs

At this point, I could define type-aligned sequences of functions ( type TAS = Path (->) ) and show you how f :-> g :-> h :-> End can be folded up into h . g . f h . g . f h . g . f , but since our goal is to print out all the intermediate values, we have to use a category with a tiny bit more structure than plain old -> . (Thanks to @dfeuer in the comments for the suggestion - I've adjusted the name he gave to better reflect the attention-seeking nature of my behaviour.)

data Showoff x y where
    Showoff :: Show y => (x -> y) -> Showoff x y

Showoff is just like a regular function, except it assures you that the return value y will be Show able. We can use this extra bit of knowledge to write showSteps for paths in which each step is a Showoff .

type ShowTAS = Path Showoff

showSteps :: ShowTAS a b -> a -> b
showSteps path = foldr combine id path . traceS
    where combine (Showoff f) g = g . traceS . f

It strikes me as a bit of a shame to use the impure traceS right in the midst of all this strongly typed fun. In real life I'd probably return a String along with the answer.

To prove that it does actually work, here is a chain of functions with varying types. We take in a String , read it into an Int , add one to it, convert it to a Float , then divide it by 2.

chain :: ShowTAS String Float
chain = Showoff read :-> plusOne :-> toFloat :-> divideTwo :-> End

    where plusOne :: Showoff Int Int
          plusOne = Showoff (+1)

          toFloat :: Showoff Int Float
          toFloat = Showoff fromIntegral

          divideTwo :: Showoff Float Float
          divideTwo = Showoff (/2)

ghci> showSteps chain "4"
"4"
4
5
5.0
2.5
2.5  -- this last one is not from a traceShow call, it's just ghci printing the result

Fun!