Add debug utility function

The `debug` function is a utility designed to aid in debugging
specifications by allowing the spec developer to print out a
contextual message while executing a specification, whether in
a run or in a test, along with a formatted representation of a value.

This can be useful when trying to understand the state of
variables at specific points during the spec execution or
while tracking down issues.

The `debug` function has the following signature:

```
def debug(header: str, value: a) -> a
```

The `debug` function prints both header and the value on the same line,
preceded by a `>` character, and then returns the given value,
which makes it easy to debug nested expressions without
having the extract them into a variable first.

Example usage in the REPL:

```
>>> debug("a number:", 42)
> a number: 42
42

>>> debug("a record:", { foo: 32, bar: true })
> a record: { bar: true, foo: 32 }
{ bar: true, foo: 32 }

>>> debug("large record:", largeRecord)
> large record: {
  hello:
    {
      world:
        { foo: { bar: { baz: 42 }, toto: { tata: { tutu: "Hello, World" } } } }
    }
}
{
  hello:
    {
      world:
        { foo: { bar: { baz: 42 }, toto: { tata: { tutu: "Hello, World" } } } }
    }
}

>>> if (a * debug("nested", a + b) == 10) true else false
> nested 5
true
```

quint/src/effects/builtinSignatures.ts

@@ -223,6 +223,7 @@ const otherOperators = [
   { name: 'reps', effect: parseAndQuantify('(Pure, (Read[r1]) => Read[r2] & Update[u]) => Read[r1, r2] & Update[u]') },
   { name: 'fail', effect: propagateComponents(['read', 'update'])(1) },
   { name: 'assert', effect: propagateComponents(['read'])(1) },
+  { name: 'debug', effect: propagateComponents(['read'])(2) },
   {
     name: 'ite',
     effect: parseAndQuantify('(Read[r1], Read[r2] & Update[u], Read[r3] & Update[u]) => Read[r1, r2, r3] & Update[u]'),

quint/src/ir/quintIr.ts

@@ -140,6 +140,7 @@ export const builtinOpCodes = [
   'chooseSome',
   'concat',
   'contains',
+  'debug',
   'enabled',
   'eq',
   'eventually',

quint/src/names/base.ts

@@ -196,6 +196,7 @@ export const builtinNames = [
   'reps',
   'fail',
   'assert',
+  'debug',
   'orKeep',
   'mustChange',
   'enabled',

quint/src/runtime/impl/compilerImpl.ts

@@ -36,7 +36,10 @@ import { RuntimeValue, RuntimeValueLambda, RuntimeValueVariant, rv } from './run
 import { ErrorCode, QuintError } from '../../quintError'
 
 import { inputDefName, lastTraceName } from '../compile'
+import { prettyQuintEx, terminalWidth } from '../../graphics'
+import { format } from '../../prettierimp'
 import { unreachable } from '../../util'
+import { zerog } from '../../idGenerator'
 import { chunk } from 'lodash'
 
 // Internal names in the compiler, which have special treatment.
@@ -914,6 +917,15 @@ export class CompilerVisitor implements IRVisitor {
           this.translateAllOrThen(app)
           break
 
+        case 'debug':
+          this.applyFun(app.id, 2, (header, value) => {
+            let columns = terminalWidth()
+            let valuePretty = format(columns, 0, prettyQuintEx(value.toQuintEx(zerog)))
+            console.log('>', header.toStr(), valuePretty.toString())
+            return just(value)
+          })
+          break
+
         case 'fail':
           this.applyFun(app.id, 1, result => {
             return just(rv.mkBool(!result.toBool()))

quint/src/types/builtinSignatures.ts

@@ -125,6 +125,7 @@ const otherOperators = [
   { name: 'reps', type: '(int, int => bool) => bool' },
   { name: 'fail', type: '(bool) => bool' },
   { name: 'assert', type: '(bool) => bool' },
+  { name: 'debug', type: '(str, a) => a' },
 ]
 
 function uniformArgsWithResult(argsType: string, resultType: string): Signature {

quint/test/runtime/compile.test.ts

@@ -978,6 +978,17 @@ describe('compiling specs to runtime values', () => {
       evalVarAfterCall('n', 'run1', input).mapRight(m => assert.fail(`Expected an error, found: ${m}`))
     })
 
+    it('debug', () => {
+      // `debug(s, a)` returns `a`
+      const input = dedent(
+        `var n: int
+        |run run1 = (n' = 1).then(n' = debug("n plus one", n + 1))
+        `
+      )
+
+      assertVarAfterCall('n', '2', 'run1', input)
+    })
+
     it('unsupported operators', () => {
       assertResultAsString('allLists(1.to(3))', undefined)