Is there any way to view the reduction steps in haskell, i.e trace the recursive function calls made? For example, chez scheme provides us with trace-lambda. Is there an equivalent form in Haskell?
You could try inserting Debug.Trace.trace in places you want to trace, but this has the tendency of (a) producing wildly out-of-order output, as your trace statement may belong to a thunk that isn't evaluated until far far away from the original call, and (b) changing the runtime behavior of your program, if tracing requires evaluating things that wouldn't otherwise have been evaluated (yet).
Is this for debugging? If so...
Hat modifies your source code to output tracing which can be viewed after running. The output should be pretty close to what you want: the example on their homepage is
For example, the computation of the faulty program
main = let xs :: [Int]
xs = [4*2,5 `div` 0,5+6]
in print (head xs,last' xs)
last' (x:xs) = last' xs
last' [x] = x
gives the result
(8, No match in pattern.
and the Hat viewing tools can be used to explore its behaviour as follows:
Hat-stack
For aborted computations, that is computations that terminated with an error message or were interrupted, hat-stack shows in which function call the computation was aborted. It does so by showing a virtual stack of function calls (redexes). Thus, every function call shown on the stack caused the function call above it. The evaluation of the top stack element caused the error (or during its evaluation the computation was interrupted). The stack shown is virtual, because it does not correspond to the actual runtime stack. The actual runtime stack enables lazy evaluation whereas the virtual stack corresponds to a stack that would be used for eager (strict) evaluation.
Using the same example program as above, hat-stack shows
$ hat-stack Example
Program terminated with error:
No match in pattern.
Virtual stack trace:
(Last.hs:6) last' []
(Last.hs:6) last' [_]
(Last.hs:6) last' [_,_]
(Last.hs:4) last' [8,_,_]
(unknown) main
$
These days, GHCi (≥6.8.1) also comes with a debugger:
$ ghci -fbreak-on-exception
GHCi, version 6.10.1: http://www.haskell.org/ghc/ :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer ... linking ... done.
Loading package base ... linking ... done.
Prelude> :l Example.hs
[1 of 1] Compiling Main ( Example.hs, interpreted )
Example.hs:5:0:
Warning: Pattern match(es) are overlapped
In the definition of `last'': last' [x] = ...
Ok, modules loaded: Main.
*Main> :trace main
(8,Stopped at <exception thrown>
_exception :: e = _
[<exception thrown>] *Main> :back
Logged breakpoint at Example.hs:(5,0)-(6,12)
_result :: t
[-1: Example.hs:(5,0)-(6,12)] *Main> :hist
-1 : last' (Example.hs:(5,0)-(6,12))
-2 : last' (Example.hs:5:15-22)
-3 : last' (Example.hs:(5,0)-(6,12))
-4 : last' (Example.hs:5:15-22)
-5 : last' (Example.hs:(5,0)-(6,12))
-6 : last' (Example.hs:5:15-22)
-7 : last' (Example.hs:(5,0)-(6,12))
-8 : main (Example.hs:3:25-32)
-9 : main (Example.hs:2:17-19)
-10 : main (Example.hs:2:16-34)
-11 : main (Example.hs:3:17-23)
-12 : main (Example.hs:3:10-33)
<end of history>
[-1: Example.hs:(5,0)-(6,12)] *Main> :force _result
*** Exception: Example.hs:(5,0)-(6,12): Non-exhaustive patterns in function last'
[-1: Example.hs:(5,0)-(6,12)] *Main> :back
Logged breakpoint at Example.hs:5:15-22
_result :: t
xs :: [t]
[-2: Example.hs:5:15-22] *Main> :force xs
xs = []
While not as nice, it has the benefit of being easily available, and being usable without recompiling your code.
There's a reduction count in hugs, if that helps?
Alternatively, could you use something like the hugs hood to wrap your code, to get more detail around what it's doing at each step?
Nothing of the kind is built into the Haskell standard.
I would hope that the Helium graphical interpreter would offer something like this, but the web page is silent on the topic.
A partial solution is to use vacuum to visualize data structures.
I've seen some gif animations of fold, scan and others, but I can't find them at the moment. I think Cale Gibbard made the animations.
Related
Issue
Following is a minimal, contrived example:
read :: FilePath -> Aff String
read f = do
log ("File: " <> f) -- (1)
readTextFile UTF8 f -- (2)
I would like to do some debug logging in (1), before a potential error on (2) occurs. Executing following code in Spago REPL works for success cases so far:
$ spago repl
> launchAff_ $ read "test/data/tree/root.txt"
File: test/data/tree/root.txt
unit
Problem: If there is an error with (2) - file is directory here - , (1) seems to be not executed at all:
$ spago repl
> launchAff_ $ read "test/data/tree"
~/purescript-book/exercises/chapter9/.psci_modules/node_modules/Effect.Aff/foreign.js:532
throw util.fromLeft(step);
^
[Error: EISDIR: illegal operation on a directory, read] {
errno: -21,
code: 'EISDIR',
syscall: 'read'
}
The original problem is more complex including several layers of recursions (see E-Book exercise 3), where I need logging to debug above error.
Questions
How can I properly log regardless upcoming errors here?
(Optional) Is there a more sophisticated, well-established debugging alternative - purescript-debugger? A decicated VS Code debug extension/functionality would be the cherry on the cake.
First of all, the symptoms you observe do not mean that the first line doesn't execute. It does always execute, you're just not seeing output from it due to how console works in the PureScript REPL. The output gets swallowed. Not the only problem with REPL, sadly.
You can verify that the first line is always executed by replacing log with throwError and observing that the error always gets thrown. Or, alternatively, you can make the first line modify a mutable cell instead of writing to the console, and then examine the cell's contents.
Finally, this only happens in REPL. If you put that launchAff_ call inside main and run the program, you will always get the console output.
Now to the actual question at hand: how to debug trace.
Logging to console is fine if you can afford it, but there is a more elegant way: Debug.trace.
This function has a hidden effect - i.e. its type says it's pure, but it really produces an effect when called. This little lie lets you use trace in a pure setting and thus debug pure code. No need for Effect! This is ok as long as used for debugging only, but don't put it in production code.
The way it works is that it takes two parameters: the first one gets printed to console and the second one is a function to be called after printing, and the result of the whole thing is whatever that function returns. For example:
calculateSomething :: Int -> Int -> Int
calculateSomething x y =
trace ("x = " <> show x) \_ ->
x + y
main :: Effect Unit
main =
log $ show $ calculateSomething 37 5
> npx spago run
'x = 37'
42
The first parameter can be anything at all, not just a string. This lets you easily print a lot of stuff:
calculateSomething :: Int -> Int -> Int
calculateSomething x y =
trace { x, y } \_ ->
x + y
> npx spago run
{ x: 37, y: 5 }
42
Or, applying this to your code:
read :: FilePath -> Aff String
read f = trace ("File: " <> f) \_ -> do
readTextFile UTF8 f
But here's a subtle detail: this tracing happens as soon as you call read, even if the resulting Aff will never be actually executed. If you need tracing to happen on effectful execution, you'll need to make the trace call part of the action, and be careful not to make it the very first action in the sequence:
read :: FilePath -> Aff String
read f = do
pure unit
trace ("File: " <> f) \_ -> pure unit
readTextFile UTF8 f
It is, of course, a bit inconvenient to do this every time you need to trace in an effectful context, so there is a special function that does it for you - it's called traceM:
read :: FilePath -> Aff String
read f = do
traceM ("File: " <> f)
readTextFile UTF8 f
If you look at its source code, you'll see that it does exactly what I did in the example above.
The sad part is that trace won't help you in REPL when an exception happens, because it's still printing to console, so it'll still get swallowed for the same reasons.
But even when it doesn't get swallowed, the output is a bit garbled, because trace actually outputs in color (to help you make it out among other output), and PureScript REPL has a complicated relationship with color:
> calculateSomething 37 5
←[32m'x = 37'←[39m
42
In addition to Fyodor Soikin's great answer, I found a variant using VS Code debug view.
1.) Make sure to build with sourcemaps:
spago build --purs-args "-g sourcemaps"
2.) Add debug configuration to VS Code launch.json:
{
"version": "0.2.0",
"configurations": [
{
"type": "pwa-node",
"request": "launch",
"name": "Launch Program",
"skipFiles": ["<node_internals>/**"],
"runtimeArgs": ["-e", "require('./output/Main/index.js').main()"],
"smartStep": true // skips files without (valid) source map
}
]
}
Replace "./output/Main/index.js" / .main() with the compiled .js file / function to be debugged.
3.) Set break points and step through the .purs file via sourcemap support.
I noticed that the base package use errorWithoutStackTrace to implement lots of functions. Is there some performance different between the following two definition?
head :: [a] -> a
head (x:_) = x
head [] = errorWithoutStackTrace ("Prelude.head: empty list")
head :: [a] -> a
head (x:_) = x
head [] = withFrozenCallStack $ error ("Prelude.head: empty list")
error means something bad happened so for most, if not all purposes, it does not matter how fast it is, because it indicates a program that's not working.
That said, a quick glance at the code is enough to reasonably guess that error does strictly more work than errorWithoutStackTrace (and that is compounded by the addition of withFrozenCallStack to the error variant of your code). Confirming that with benchmarks is left as an exercise to the reader.
Here's the definition of error and errorWithoutStackTrace:
https://hackage.haskell.org/package/base-4.12.0.0/docs/src/GHC.Err.html#error
error s = raise# (errorCallWithCallStackException s ?callStack)
errorWithoutStackTrace s = raise# (errorCallException s)
Now those two internal functions are defined as follows:
errorCallException :: String -> SomeException
errorCallException s = toException (ErrorCall s)
errorCallWithCallStackException :: String -> CallStack -> SomeException
errorCallWithCallStackException s stk = unsafeDupablePerformIO $ do
...
return $ toException (ErrorCallWithLocation s stack)
Note that both essentially do toException (something s), but errorCallWithCallStackException also has a whole lot more code to handle the stack (in "...").
I would like to know how I can limit the maximum memory (heap) a process can use to allocate objects.
I looked into spawn_opt with max_heap_size as mentioned here but I keep getting a badarg error. Is this even possible now? I want to avoid using a gen server to kill the process when heapsize goes over a limit.
-module(maxMemCheck).
-export([fib/1,printfib/1]).
-export([main/0]).
printfib(N) ->
Res = maxMemCheck:fib(N),
io:fwrite("~w ~w~n", [N, Res]).
fib(0) -> 0 ;
fib(1) -> 1 ;
fib(N) when N > 0 -> fib(N-1) + fib(N-2) .
main () ->
spawn_opt(maxMemCheck,printfib,[10],[{max_heap_size,#{size => 300, kill => true, error_logger => true}}]).
This results in the error:
{"init terminating in do_boot",{badarg,[{erlang,spawn_opt,[maxMemCheck,fib,"\n",[{max_heap_size,#{error_logger=>true,kill=>true,size=>300}}]],[]},{init,start_it,1,[]},{init,start_em,1,[]}]}}
Crash dump is being written to: erl_crash.dump...done
init terminating in do_boot ()
The syntax is correct, maybe you are using an "old" erlang version. This syntax uses a map variable which was introduced in OTP18 or 19.
Looking at the description for traceIO, I feel that it does exactly what hPutStrLn stderr does. However when I looked into its source code:
traceIO :: String -> IO ()
traceIO msg = do
withCString "%s\n" $ \cfmt -> do
-- NB: debugBelch can't deal with null bytes, so filter them
-- out so we don't accidentally truncate the message. See Trac #9395
let (nulls, msg') = partition (=='\0') msg
withCString msg' $ \cmsg ->
debugBelch cfmt cmsg
when (not (null nulls)) $
withCString "WARNING: previous trace message had null bytes" $ \cmsg ->
debugBelch cfmt cmsg
It seems it uses a foreign routine called debugBelch, which I failed to find any documentation about. So what does traceIO do that can't be done by hPutStrLn stderr?
One thing I can think of is that it might ensure that the string is printed as a unit, without any other trace messages inside. Indeed an experiment seems to confirm this:
Prelude Debug.Trace System.IO> traceIO $ "1" ++ trace "2" "3"
2
13
Prelude Debug.Trace System.IO> hPutStrLn stderr $ "1" ++ trace "2" "3"
12
3
Another difference is that it seems to remove characters that cannot safely be printed to stderr:
Prelude Debug.Trace System.IO> hPutStrLn stderr "\9731"
*** Exception: <stderr>: hPutChar: invalid argument (invalid character)
Prelude Debug.Trace System.IO> traceIO "\9731"
Prelude Debug.Trace System.IO>
As #dfeuer reminds me of, none of these features would be impossible to write in Haskell. So the deciding factor is probably this: debugBelch is already a predefined C function, used all over the place in GHC's runtime system, which is written in C and C--, not Haskell.
Snippets of my code are shown below. After doing a lot of cumbersome tracing, I have reached a point where I think it's the external modules which are the source of my problem, as the findall in links_of_actor never gets called, but links_of_actor itself gets called. I would be very grateful to anyone who can help and can clarify/add more of my code to this question if needed.
find_identity(A) :-
all_actor_links(ALs),
find_identity(ALs,[],A).
find_identity([a(A,_)],_,A).
find_identity(ALs,Ms,A) :-
agent_ask_oracle(oscar,o(1),link,L),
( memberchk(L,Ms) -> find_identity(ALs,Ms,A)
; otherwise -> purge_actors(ALs,L,NewALs),
find_identity(NewALs,[L|Ms],A)
).
links_of_actor(A,Ls) :-
actor(A),
wp(A,WT),
findall(L,wt_link(WT,L),Ls1),
findall(L,link(L),Ls2),
intersection(Ls1,Ls2,Ls).
actor_links(A,a(A,Ls)) :-
links_of_actor(A,Ls).
all_actor_links(ALs) :-
findall(A,actor(A),As),
maplist(actor_links,As,ALs).
----------------------------------------------------- Support Functions ---------------------------------------------------
% wp(Q,WT) <- issue query Q to Wikipedia and return the page in wikitext format
wp(Q,WT):-
wp_cache(Q,WT),!.
wp(Q,WT):-
wp_query2URL(Q,URL),
http_get(URL,R,[]),
atom_json_term(R,RR,[]),
wt_get(RR,WT0),
( atomic_list_concat1(_L,'#REDIRECT',WT0) -> wt_link(WT0,QQ),wp(QQ,WT)
; otherwise -> WT=WT0
),
assert(wp_cache(Q,WT)).
------------------------------------------------------------ Edit ----------------------------------------------------------------
After using the guitracer that is available with prolog, I have found that the program fails at http_get(URL,R,[]) in the wp(Q,WT) predicate. However, I am still not sure as to why this isn't working - Could it be possibly because of my internet?
To clarify, the predicate actor is defined in my file: actor('Billy Bob Thornton'). etc. and so are the links : link('Barack Obama')..
Using these definitions, the error can be localized by adding a # in front of those goals that have to succeed.
...
wp(Q,WT):-
#wp_query2URL(Q,URL),
#http_get(URL,R,[]),
#atom_json_term(R,RR,[]),
#wt_get(RR,WT0),
...
Well, did you try to see if the URL you gave to http_open is actually valid? You can always test from the top-level if you can http_open an URL:
?- use_module(library(http/http_client)).
true.
?- http_open("stackoverflow.com", R, []).
R = % a lot of stuff