Develop more comprehensive API

[milesfrain]

Moving discussion from JordanMartinez/purescript-cookbook#161 (comment)

Should this debug API be expanded? I was thinking of something like:

-- Uses JS console.log to print contents
spy :: a -> a
-- Uses Show instance to convert contents to string
spyShow :: Show a => a -> a
-- Prepends a tag (current spy behavior)
spyTag :: String -> a -> a
spyTagShow :: Show a => String -> a -> a

-- Wait to evaluate expression
-- Not sure if this only makes sense with `Tag`
spyThunk :: (Unit -> a) -> a
-- ... other combinations with Tag and Show

-- Monodic version
-- Wondering if this could be relaxed to Applicative (like haskell's traceM).
spyM :: Monad m => a -> m Unit
-- ... other combinations with Thunk, Tag, and Show

-- Stack dump
-- Uses JS console.trace() to log stack
-- Similar to Haskell's traceStack
spyStack :: a -> a
-- ... other combinations with M, Thunk, Tag, and Show

-- Reflecting version
-- Uses reflected expression as tag
-- Not sure if this is possible
spyReflect :: a -> a
-- ... other combinations with Stack, M, Thunk, Tag, and Show

-- This would be great to include
todo :: a

Additional details on spyReflect

Imagine writing:

fact :: Int -> Int -> Int
fact 0 acc = spyReflect acc 
fact n acc = fact (spyReflect $ n - 1) (spyReflect $ acc * n)

To get this behavior:

fact :: Int -> Int -> Int
fact 0 acc = spy "acc" acc 
fact n acc = fact (spy "n - 1" $ n - 1) (spy "acc * n" $ acc * n)

This is really convenient for debugging in other languages:

julia> x = 5
5

julia> @show (x + 3)
x + 3 = 8
8

julia> @info "tag" (x + 3)
┌ Info: tag
└   x + 3 = 8

Other questions:

• Thoughts on spy vs trace naming?
• Is reflect behavior possible?
• Are there other ways to gain all these behaviors without writing 2^n functions? Looks like 64 would be needed.
• Monad vs Applicative for traceM/spyM?
• Any other inspiration to gain from Haskell or Elm debug logging?
• Which todo implementation to use? This PR or this snippet?

[garyb]

Just a quick comment for now: spy vs trace is because they have different purposes. spy logs a value and emits the same value, so you can insert it into an expression without having to split values out from it, etc. trace is more like a console.log.

[garyb]

I've added two functions in the latest version which go some way to helping with some of the above use cases.

• spyWith allows you to pass in a function when spying now, so you can spyWith "thing" show for the spyWithShow case, and I don't feel like it's necessary to have a traceShow, etc. variant since you can just call show easily enough there.
• There's a debugger now which will fire up any available debugging functionality in the current runtime, so that probably takes care of the stack case?
• reflect functionality would need serious compiler magic

So I'm going to close this. If there are specific things that are still missing we can open separate issues for those to discuss perhaps, but really this library isn't really meant to be (nor is it able to be) a comprehensive debugging suite. It's more for quick and dirty investigation of things. If I need more insight into a problem than can be provided by logging some things I usually start writing tests instead.