I c++ I can do something like

#ifdef FOO_BAR
    doStuff();
#endif

Is there a similar way to do this sort of thing with toit? The primary usecase for me would be to entirely avoid building verbose log lines, which in their call might create long strings etc, when there is no expectaiton for that log line to every be used? The only alternative right now I guess would be commenting and un commenting lines continually?

If you use

if SOME-GLOBAL-CONSTANT:

then the compiler will remove the dead code if it can see that the constant is false.

thats quite neat,and could allow me to define my own log levels?

LEVEL-DEBUG ::= 4
LEVEL-TRACE ::= 5
LOG-LEVEL ::= LEVEL-DEBUG

do-log-debug [block]:
  if LOG-LEVEL >= LEVEL-DEBUG: print block.call

do-log-trace [block]:
  if LOG-LEVEL >= LEVEL-TRACE: print block.call

main:
  do-log-debug: "$(expensive) construction of some long debug string"
  do-log-trace: "$(expensive) construction of some long trace string"

Or would this not get optimized down during compilation?

Simple expressions are also optimized away.

So thats a yes? 😉

Yes 🙂

So, the answer is probably that I should go and try and run this bytecode snapshot tool myself 😄 But i wonder if sometihng like this would still work in terms of keeping things light at complication time? (Still a simple expression, but its only evaulated in a class instance)

import lite-logging

log ::= lite-logging.new-default lite-logging.DEBUG-LEVEL

main:
  log.debug: "Hello, world!"

and

import log
import .levels

new-default level/int -> Logger:
  return Logger log.default level

class Logger:
  
  logger /log.Logger
  level /int

  constructor .logger/log.Logger .level/int:
    logger = logger
    level = level

  debug [block]:
    if level >= DEBUG-LEVEL: print block.call

You mean at runtime?

I did try something like

import lite-logging

LITE-LOG-LEVEL ::= lite-logging.DEBUG-LEVEL
log ::= lite-logging.new-default

main:
  log.debug: "Hello, world!"

first, but

LITE-LOG-LEVEL

is not accessible in the class

That's not really possible.

ooo, different loggers, with a null logger approach might work quite nicely

You could also just pass the log-level as argument to the Logger and then dispatch (factory constructor) in the logger.

As a version one, this is a slightly nice wrapper for my first use

import lite-logging
log ::= lite-logging.new lite-logging.DEBUG-LEVEL

main:
  log.debug: "Hello, world!"

and

import log as toit-log
import .levels

new level/int --name/string?=null-> Logger:
  return Logger level --name=name

class Logger:
  
  logger /toit-log.Logger
  logger-level /int

  constructor .logger-level/int --name/string?=null:
    logger = toit-log.Logger (max toit-log.DEBUG-LEVEL logger-level) toit-log.DefaultTarget --name=name
    logger-level = logger-level

  log level/int [block] --tags/Map?=null -> none:
    if logger-level <= level: logger.log level block.call --tags=tags

  trace [block] --tags/Map?=null -> none:
    // Uses the debug level logger, as the toit logger has no trace level..
    if logger-level <= TRACE-LEVEL: logger.log DEBUG-LEVEL "TRACE: $(block.call)" --tags=tags

  debug [block] --tags/Map?=null -> none:
    if logger-level <= DEBUG-LEVEL: logger.log DEBUG-LEVEL block.call --tags=tags
  
  info [block] --tags/Map?=null -> none:
    if logger-level <= INFO-LEVEL: logger.log INFO-LEVEL block.call --tags=tags
  
  warn [block] --tags/Map?=null -> none:
    if logger-level <= WARN-LEVEL: logger.log WARN-LEVEL block.call --tags=tags
  
  error [block] --tags/Map?=null -> none:
    if logger-level <= ERROR-LEVEL: logger.log ERROR-LEVEL block.call --tags=tags

Which means I can use blocks to avoid possibly expansive strings for debug logging, and leave the logging in place when the app is run in different logging modes. It doesnt compile away the stuff that won't be used though. but solves my main pain, and doesnt look that bad at all

If the level of the logger can't be changed, you could have subclasses that don't have the

if

.

I'll try running with this for a bit, and see if I regret all of this in a few weeks 😉