I'm a fan of whatis.

I like whatis but the fact that it's not what_is would be painful to me!
I vote peek.

One annoyance is that the anything-to-string code is in the standard library, not in core. Perhaps it could gracefully degrade if stdlib isn't available.

What behavior would it degrade to?

Big fan of whatis as well

One annoyance is that the anything-to-string code is in the standard library, not in core. Perhaps it could gracefully degrade if stdlib isn't available.

What behavior would it degrade to?

Printing in the syntax of the native target. JS or Erlang

I'd like both what_is or peek, even whatis (but I prefer the snake case version)

Where could it be used? Would it work like debug returning its rhs?

peek peek foo
// print foo twice?

bar(peek foo)
// print foo?

foo
|> peek bar
// print bar?

Having it return the value sounds good. We'd need to decide if it has any special pipes support as I suspect folks will want to pipe into it.

Just call it glimpse and be done with it 😉

👀 value

No seriously though I would prefer it just be called debug or dbg or debug_print or something to that effect.
I wouldn’t mind a naming conflict and deprecating io.debug.

I think the ideal syntax would be for it to work in a pipe and for keyword value to be how it’s called

Edit: I no longer think this syntax is a good idea, I would much prefer something like a global function.

We're not breaking the stdlib, and there's lots of other contexts in which the word debug is more appropriate and already taken, such as logging libraries.

I don't think debug is as good a name for printing as it would be for use in a debugger too.

pry is the only one not previously said that comes to mind for me

spy because it makes me feel cool

• i like peek and dump both are single syllable and have no underscores and are short enough.
• i don't like whatis because I would want to type what_is but that's slow to type.
• should def be an expression that returns the value so that it can be piped or just any call/value wrapped anywhere really
• I also like ? exp:

? foo
|> ? bar
|> ? quux(? batz)

I like it :)

pry is the only one not previously said that comes to mind for me

but are we really prying... into the vm runtime value?

My personal favorites are dump and ? expr. whatis and what_is are both slower to type and to say (even mentally), so I'm not as big a fan of them.

I'm just a silent reader on discord, but I'll chime in for bike shedding 😆

What about trace?

Apparently that even has some precedent in ActionScript: https://open-flash.github.io/mirrors/as2-language-reference/global_functions.html#trace()

What about trace?

Seems like we don't want to do anything that would overlap w/proper logging (trace, debug, info, warn, error).

? has a lot of potential power as a single character operator, I would hate to see it wasted on this.
What about echo as the name?

Does it have to be a keyword? Something that worked more like a global function would be a lot more composable w/gleam syntax in my opinion, and you wouldn't have to adopt a whole new style of control flow for a single keyword. Tbh this feels so clearly like a function I think it would be extremely strange to have it be a keyword as described above.

echo is actually a really good suggestion! I like that a lot.

Does it have to be a keyword? Something that worked more like a global function would be a lot more composable w/gleam syntax in my opinion, and you wouldn't have to adopt a whole new style of control flow for a single keyword. Tbh this feels so clearly like a function I think it would be extremely strange to have it be a keyword as described above.

It is to do things that a function cannot do. I'm not sure making it look a bit like a function would be beneficial given it couldn't be one.

echo is actually a really good suggestion! I like that a lot.

Does it have to be a keyword? Something that worked more like a global function would be a lot more composable w/gleam syntax in my opinion, and you wouldn't have to adopt a whole new style of control flow for a single keyword. Tbh this feels so clearly like a function I think it would be extremely strange to have it be a keyword as described above.

It is to do things that a function cannot do. I'm not sure making it look a bit like a function would be beneficial given it couldn't be one.

that's the reason I like ? as it cannot be confused...
What would the semantic explanation be for echo versus peek or pry or dump?

What would the semantic explanation be for echo versus peek or pry or dump?

No semantic difference here, just about how they feel, look, and any connotations from other languages.

hm, echo would write a string to the output buffer in php.
which other languages use echo?

echo foo
|> echo bar
|> echo quux(echo batz)

I think the question mark with a space is a good thing, ... a word kind of pollutes the screen/attention and makes it harder to follow the code with the debug printing included.

Ah yeah "looks like a function but isn't a function" is actually a bad outcome I suppose 🤔

If I hadn’t been poisoned by previous language experience I would think value? would be a quick easy common sense way to have a built in debugging feature, but having seen all the powerful ? syntax in other languages it would feel like such a demotion for the ?.
I wonder if we'd regret using ? here down the line when we have an idea for a cool new feature that ? Would be perfect for.

I doubt we'll ever use ? for anything. It's very easy to miss, not very Gleamy.

I would like thing? but ? thing seems too weird to me. I don't see how it fits in Gleam! I really feel like it breaks the flow somehow!
But I should add that a keyword seems more Gleamy. I think pry or peek are great.

Could gleam publish fail if there are debug commands in the code?

Yes! That's one of the things covered above

Goals:

1. Prints location so the programmer knows where the logging is coming from
2. Prints optional extra context, like a tag
3. Does not require an import
4. Warns so you don't forget it by mistake
5. Blocks gleam publish so you can't publish code that uses it

Let's keep in mind goal 2. Including a "tag" in the output in order to label the thing being printed can be extremely helpful in aiding debugging.

I don't think any of the syntax proposals so far include such tagging.

How about something like the following?

value
|> process
|> :tee "my tag"
|> more_processing

This potentially does the following:

• supports piping
• uses a : prefix to distinguish as not a function (since it's not a valid function name) -- see alternative suggestions below
• is relatable to the *nix tee command, which passes its input through unchanged to its output, while also spitting it out to a file (in this case, spitting it out to either stdout or stderr, which is perhaps another question to consider)
• would write "my tag: x" (where x is the value returned from process) to either stdout or stderr

I think the question of where to write the output (stdout or stderr) is perhaps another consideration. I would lean towards stderr so that injecting :tee doesn't potentially interfere with the program itself, which might be intended to be used in command pipeline (like the tee command itself). If it were to write to stdout, it might interfere with proper operation of the program that we might be trying to debug.

Alternative syntaxes for the :tee shown above:

|> :tee "my tag"
|# "my tag"
|> #"my tag"
|> ("my tag")
|> #my tag#

We could also reuse the "as" used by todo and panic:

foo
|> bar
|> echo as "tag"
|> baz

It would be a bit more awkward when used as a function though:

// maybe? I have no idea how it should look
echo foo as "tag"

I think it should print to stderr. If required later gleam.toml could make this behaviour configurable.

For words, short 1-word-1-syllable dump, pry, peek, show are those I'd prefer.

If we need tagging for the question mark, if we do prefixing, it could look like this:

// Regular
? var as "tag1"

// Piped
? foo as "tag2"
|> ? bar as "tag3"
|> ? quux(? batz as "tag4") as "tag5"

...or if it is suffixed like this:

// Regular
var ? "tag1"

// Piped
foo ? "tag2"
|> bar ? "tag3"
|> quux(batz ? "tag4") ? "tag5"

inspect foo

Inspect is not an option, it is already taken. We have gone with echo, the discussion is the design now.

echo thing as "thing" seems reasonable to me.

@lpil, as mentioned above, I'd suggest output go to stderr, not stdout, to avoid potential interference with intentional program output. Does that make sense?

Definitely. This is also what io.debug does today.

If this doesn't make it into 1.0 would it be sensible to reserve echo?

If this doesn't make it into 1.0 would it be sensible to reserve echo?

It was reserved in v0.34.0

What about dbg to align with Elixir?

We can't use dbg as it's not a reserved keyword in Gleam and reserving it now would be a breaking change