Debugging with trace-show

[chtenb]

If you want to debug something by printing to the console, the function trace-show can be quite helpful.
However, I find that it often does not have the show function in scope (because it's not used in the actual logic, so it's not passed as implicit argument). So that requires you to temporarily modify a whole bunch of function signatures to include the show function, which is not very ergonomic for debugging.

Is there some dirty way to not have to do that or make it more ergonomic somehow?

EDIT: let me clarify with an example

pub alias label<a> = vector<a>

pub fun minimal-uniq-prefix-length(label : label<a>, neighbors : list<label<a>>, ?(==) : (a,a) -> bool) : _ int
  trace-show(label)
  trace-show(neighbors)
  val diff-indices = neighbors.map fn(neighbor)
    range/list(0, label.length - 1).index-of(fn(i) !(neighbor[i] == label[i]))
  diff-indices.maximum + 1

Invoking an explicit show implementation doesn't work either, because the data is polymorphic

[TimWhiting]

There is a generic show that shows a byte like / low level representation of any value. Not sure if it needs updating or what it looks like since I've never used it. Probably would look the best in JavaScript if you are only using functions that are also supported there.

koka/lib/std/core/debug.kk

Line 67 in 4a3a197

pub fip fun trace-any( message : string, x : a ) : ()

[osa1]

This issue exists in other languages with typeclasses (aka. traits) and you just deal with it basically (i.e. pass the function around, or add the typeclass constraint to all the callers and the function).

There's no solution that's convenient.

I suspect this may also be one of the reasons why OOP langs have toString built into the top type, instead of in a ToStringable. It's such a common thing to print things, you don't want to not be able to do it, ever, and you don't want to refactor your code (or plan ahead of time) to be able to do it.

One hacky solution that comes to mind is: if the language supports runtime type tests and casts, and you know the concrete types in the polymorphic code, you can do the type cast and use the concrete type's show (or in a typeclass system you would get it implicitly). I don't know if this is possible in Koka.

[TimWhiting]

Yeah, currently Koka erases all types at runtime since the functions are all statically known. (There is no dynamic-dispatching / vtables). Even with runtime type information, you wouldn't get something like vtables in Koka due to the fact that functions are resolved statically and overloaded on the types of all parameters.

I'd love to support a mode (e.g. --debug) where runtime type information is given by default (via adding implicits to every function with a polymorphic type) and dynamic multiple dispatch applied (with some syntax to opt into resolving a function at runtime, based on type information - and maybe only in that mode - otherwise being a no-op). I think this would be the best of both worlds - performance via type omission by default, but debugability and flexibility via runtime type info. I'd also like to also be able to opt into runtime type information in other modes as well (via an explicit implicit parameter though).

In other words, I'd like to have the hacky solution be an actual language feature that is nicely designed.

You can also currently work around the issue sometimes by incorporating some debug functionality into an effect if you already have one with those type parameters.