Comment désactiver @assert dans Julia

Il n'y a pas d'option / indicateur de ligne de commande @assert pour désactiver globalement les @assert (!).

Pour l'instant, vous pouvez définir une macro @myassert qui, selon un commutateur global, est un no-op ou un @assert normal:

asserting() = false # when set to true, this will enable all `@myassert`s

macro mayassert(test)
  esc(:(if $(@__MODULE__).asserting()
    @assert($test)
   end))
end

f(x) = @mayassert x < 2 

(extrait de https://discourse.julialang.org/t/assert-alternatives/24775/14 )

Bien qu'il serait bien d'avoir cette fonctionnalité, le besoin de @assert dans votre code peut être réduit en définissant et en distribuant vos propres types. Par exemple, supposons que vous ayez une fonction foo(t::TimeType) = t , mais que vous ne souhaitiez accepter que des heures qui sont un multiple de cinq minutes. Vous pouvez créer un nouveau type avec cette exigence:

julia> t = FiveMinuteMultiple(2016, 7, 15, 4, 23)
ERROR: DomainError with 7:
the minute argument must be a multiple of 5
Stacktrace:
 [1] FiveMinuteMultiple(::Int64, ::Int64, ::Int64, ::Int64, ::Int64) at ./REPL[2]:5
 [2] top-level scope at none:0

julia> t = FiveMinuteMultiple(2016, 7, 15, 4, 25)
FiveMinuteMultiple(2016-07-15T04:25:00)

Maintenant, vous ne pouvez littéralement pas créer un FiveMinuteMultiple qui n'est pas un multiple de cinq minutes:

using Dates

struct FiveMinuteMultiple
    t::DateTime

    function FiveMinuteMultiple(y, m, d, h, mi)
        if mi%5 != 0
            throw(DomainError(m, "the minute argument must be a multiple of 5"))
        end
        new(DateTime(y, m, d, h, mi))
    end
end

Donc, si vous définissez maintenant foo(t::FiveMinuteMultiple) = t , vous n'avez plus besoin d'un @assert pour vérifier que l'argument est un temps qui est un multiple de cinq minutes. Bien sûr, vous devez toujours payer le coût de la vérification des arguments lorsque vous construisez le FiveMinuteMultiple , mais à moins qu'il ne s'agisse d'une boucle interne chaude, vous souhaiterez probablement cette validation de données supplémentaire de toute façon.

Avantages:

• La répartition de la méthode garantit que les arguments de vos fonctions sont du type correct.
• Vous pouvez éviter de dupliquer la même assertion sur plusieurs fonctions foo(t::FiveMinuteMultiple) , bar(t::FiveMinuteMultiple) et baz(t::FiveMinuteMultiple) .
• L'annotation d'argument plus spécifique avertit les utilisateurs et les développeurs que la fonction attend un type de données plus spécifique.

Désavantages:

• En fonction de votre cas d'utilisation, vous devrez peut-être transférer diverses méthodes vers le champ de données de votre structure. Par exemple, pour FiveMinuteMultiple vous devrez peut-être transférer des méthodes telles que day , hour , etc., vers le champ t de la structure.
• L'ajout d'un nouveau concept (type) pour représenter des assertions sur vos données peut introduire une couche d'abstraction inutile.

Vous pouvez placer vos instructions @assert dans un bloc @debug . Ensuite, l'appel @assert est désactivé, sauf si vous activez le débogage soit globalement ( ENV["JULIA_DEBUG"] = "all" ) soit juste pour votre module ( ENV["JULIA_DEBUG"] = "NameOfYourModule" )

julia> @debug begin
          @assert 1==2
       end
       #or 
       @debug @assert 1==2 # assert is not called

julia> ENV["JULIA_DEBUG"] = "all" # enable debugging
"all"

julia> @debug begin
          @assert 1==2
       end
┌ Error: Exception while generating log record in module Main at REPL[4]:1
│   exception =
│    AssertionError: 1 == 2
│    Stacktrace:
│     [1] top-level scope at REPL[4]:2
│     [2] top-level scope at logging.jl:319
|     ...
â”” @ Main REPL[4]:1