Formatting issues and changes between 1 and 2 #880

MilesCranmer · 2024-10-16T21:46:02Z

Just pasting the diffs of some of my packages to help identify new formatting issues. These overlap with #878 and #879. I’m using BlueStyle.

As you can see, many of these are superficial changes (though some be violating Blue, not sure). However, some of these formatting changes are semantic differences like #878.

Here's the diff for SymbolicRegression.jl

diff --git a/benchmark/benchmarks.jl b/benchmark/benchmarks.jl
index 9e486234..07ecd1c2 100644
--- a/benchmark/benchmarks.jl
+++ b/benchmark/benchmarks.jl
@@ -88,10 +88,10 @@ function create_utils_benchmark()
     suite["best_of_sample"] = @benchmarkable(
         best_of_sample(pop, rss, $options),
         setup = (
-            nfeatures = 1;
-            dataset = Dataset(randn(nfeatures, 32), randn(32));
-            pop = Population(dataset; npop=100, nlength=20, options=$options, nfeatures);
-            rss = RunningSearchStatistics(; options=$options)
+            nfeatures=1;
+            dataset=Dataset(randn(nfeatures, 32), randn(32));
+            pop=Population(dataset; npop=100, nlength=20, options=($options), nfeatures);
+            rss=RunningSearchStatistics(; options=($options))
         )
     )
 
@@ -110,9 +110,9 @@ function create_utils_benchmark()
             end
         end,
         setup = (
-            nfeatures = 1;
-            dataset = Dataset(randn(nfeatures, 32), randn(32));
-            mutation_weights = MutationWeights(;
+            nfeatures=1;
+            dataset=Dataset(randn(nfeatures, 32), randn(32));
+            mutation_weights=MutationWeights(;
                 mutate_constant=1.0,
                 mutate_operator=1.0,
                 swap_operands=1.0,
@@ -125,21 +125,23 @@ function create_utils_benchmark()
                 form_connection=0.0,
                 break_connection=0.0,
             );
-            options = Options(;
-                unary_operators=[sin, cos], binary_operators=[+, -, *, /], mutation_weights
+            options=Options(;
+                unary_operators=[sin, cos],
+                binary_operators=[+, -, *, /],
+                mutation_weights,
             );
-            recorder = RecordType();
-            temperature = 1.0;
-            curmaxsize = 20;
-            rss = RunningSearchStatistics(; options);
-            trees = [
+            recorder=RecordType();
+            temperature=1.0;
+            curmaxsize=20;
+            rss=RunningSearchStatistics(; options);
+            trees=[
                 gen_random_tree_fixed_size(15, options, nfeatures, Float64) for _ in 1:100
             ];
-            expressions = [
+            expressions=[
                 Expression(tree; operators=options.operators, variable_names=["x1"]) for
                 tree in trees
             ];
-            members = [
+            members=[
                 PopMember(dataset, expression, options; deterministic=false) for
                 expression in expressions
             ]
@@ -149,18 +151,18 @@ function create_utils_benchmark()
     ntrees = 10
     suite["optimize_constants_x10"] = @benchmarkable(
         foreach(members) do member
-            optimize_constants(dataset, member, $options)
+            return optimize_constants(dataset, member, $options)
         end,
         seconds = 20,
         setup = (
-            nfeatures = 1;
-            T = Float64;
-            dataset = Dataset(randn(nfeatures, 512), randn(512));
-            ntrees = $ntrees;
-            trees = [
+            nfeatures=1;
+            T=Float64;
+            dataset=Dataset(randn(nfeatures, 512), randn(512));
+            ntrees=($ntrees);
+            trees=[
                 gen_random_tree_fixed_size(20, $options, nfeatures, T) for i in 1:ntrees
             ];
-            members = [
+            members=[
                 PopMember(dataset, tree, $options; deterministic=false) for tree in trees
             ]
         )
@@ -176,12 +178,12 @@ function create_utils_benchmark()
             )
             s[T] = @benchmarkable(
                 foreach(trees) do tree
-                    compute_complexity(tree, $options)
+                    return compute_complexity(tree, $options)
                 end,
                 setup = (
-                    T = Float64;
-                    nfeatures = 3;
-                    trees = [
+                    T=Float64;
+                    nfeatures=3;
+                    trees=[
                         gen_random_tree_fixed_size(20, $options, nfeatures, T) for
                         i in 1:($ntrees)
                     ]
@@ -194,12 +196,14 @@ function create_utils_benchmark()
     if isdefined(SymbolicRegression.MutationFunctionsModule, :randomly_rotate_tree!)
         suite["randomly_rotate_tree_x10"] = @benchmarkable(
             foreach(trees) do tree
-                SymbolicRegression.MutationFunctionsModule.randomly_rotate_tree!(tree)
+                return SymbolicRegression.MutationFunctionsModule.randomly_rotate_tree!(
+                    tree
+                )
             end,
             setup = (
-                T = Float64;
-                nfeatures = 3;
-                trees = [
+                T=Float64;
+                nfeatures=3;
+                trees=[
                     gen_random_tree_fixed_size(20, $options, nfeatures, T) for
                     i in 1:($ntrees)
                 ]
@@ -209,14 +213,14 @@ function create_utils_benchmark()
 
     suite["insert_random_op_x10"] = @benchmarkable(
         foreach(trees) do tree
-            SymbolicRegression.MutationFunctionsModule.insert_random_op(
+            return SymbolicRegression.MutationFunctionsModule.insert_random_op(
                 tree, $options, nfeatures
             )
         end,
         setup = (
-            T = Float64;
-            nfeatures = 3;
-            trees = [
+            T=Float64;
+            nfeatures=3;
+            trees=[
                 gen_random_tree_fixed_size(20, $options, nfeatures, T) for i in 1:($ntrees)
             ]
         )
@@ -237,12 +241,12 @@ function create_utils_benchmark()
     )
     suite["check_constraints_x10"] = @benchmarkable(
         foreach(trees) do tree
-            check_constraints(tree, $options, $options.maxsize)
+            return check_constraints(tree, $options, $options.maxsize)
         end,
         setup = (
-            T = Float64;
-            nfeatures = 3;
-            trees = [
+            T=Float64;
+            nfeatures=3;
+            trees=[
                 gen_random_tree_fixed_size(20, $options, nfeatures, T) for i in 1:($ntrees)
             ]
         )
diff --git a/ext/SymbolicRegressionEnzymeExt.jl b/ext/SymbolicRegressionEnzymeExt.jl
index b8b8be60..9929567f 100644
--- a/ext/SymbolicRegressionEnzymeExt.jl
+++ b/ext/SymbolicRegressionEnzymeExt.jl
@@ -39,7 +39,7 @@ function (g::GradEvaluator{<:Any,<:AutoEnzyme})(_, G, x::AbstractVector{T}) wher
     doutput = [one(T)]
 
     with_stacksize(32 * 1024 * 1024) do
-        autodiff(
+        return autodiff(
             Reverse,
             evaluator,
             Duplicated(g.f.tree, g.extra.storage_tree),
diff --git a/ext/SymbolicRegressionJSON3Ext.jl b/ext/SymbolicRegressionJSON3Ext.jl
index 1384f690..a78cd2f0 100644
--- a/ext/SymbolicRegressionJSON3Ext.jl
+++ b/ext/SymbolicRegressionJSON3Ext.jl
@@ -5,7 +5,7 @@ import SymbolicRegression.UtilsModule: json3_write
 
 function json3_write(record, recorder_file)
     open(recorder_file, "w") do io
-        JSON3.write(io, record; allow_inf=true)
+        return JSON3.write(io, record; allow_inf=true)
     end
 end
 
diff --git a/src/CheckConstraints.jl b/src/CheckConstraints.jl
index fb0bbb71..7c95ff7e 100644
--- a/src/CheckConstraints.jl
+++ b/src/CheckConstraints.jl
@@ -73,7 +73,7 @@ end
 function check_constraints(
     ex::AbstractExpression,
     options::AbstractOptions,
-    maxsize::Int,
+    maxsize::Int;
     cursize::Union{Int,Nothing}=nothing,
 )::Bool
     tree = get_tree(ex)
@@ -82,7 +82,7 @@ end
 function check_constraints(
     tree::AbstractExpressionNode,
     options::AbstractOptions,
-    maxsize::Int,
+    maxsize::Int;
     cursize::Union{Int,Nothing}=nothing,
 )::Bool
     ((cursize === nothing) ? compute_complexity(tree, options) : cursize) > maxsize &&
@@ -102,8 +102,8 @@ function check_constraints(
     return true
 end
 
-check_constraints(
-    ex::Union{AbstractExpression,AbstractExpressionNode}, options::AbstractOptions
-)::Bool = check_constraints(ex, options, options.maxsize)
+check_constraints(ex::Union{AbstractExpression,AbstractExpressionNode}, options::AbstractOptions)::Bool = check_constraints(
+    ex, options, options.maxsize
+)
 
 end
diff --git a/src/Configure.jl b/src/Configure.jl
index 2b184e5c..9207eee1 100644
--- a/src/Configure.jl
+++ b/src/Configure.jl
@@ -1,6 +1,6 @@
 const TEST_TYPE = Float32
 
-function test_operator(op::F, x::T, y=nothing) where {F,T}
+function test_operator(op::F, x::T; y=nothing) where {F,T}
     local output
     try
         output = y === nothing ? op(x) : op(x, y)
@@ -196,12 +196,10 @@ function activate_env_on_workers(
 )
     verbosity > 0 && @info "Activating environment on workers."
     @everywhere procs begin
-        Base.MainInclude.eval(
-            quote
-                using Pkg
-                Pkg.activate($$project_path)
-            end,
-        )
+        Base.MainInclude.eval(quote
+            using Pkg
+            Pkg.activate($$project_path)
+        end)
     end
 end
 
@@ -237,12 +235,9 @@ function import_module_on_workers(
     #             to JuliaLang.
 
     for ext in relevant_extensions
-        push!(
-            expr.args,
-            quote
-                using $ext: $ext
-            end,
-        )
+        push!(expr.args, quote
+            using $ext: $ext
+        end)
     end
 
     verbosity > 0 && if isempty(relevant_extensions)
diff --git a/src/ConstantOptimization.jl b/src/ConstantOptimization.jl
index 92b5d0c5..2cd1fa46 100644
--- a/src/ConstantOptimization.jl
+++ b/src/ConstantOptimization.jl
@@ -125,7 +125,7 @@ function (g::GradEvaluator{<:Any,AD})(_, G, x::AbstractVector) where {AD}
     AD isa AutoEnzyme && error("Please load the `Enzyme.jl` package.")
     set_scalar_constants!(g.f.tree, x, g.f.refs)
     (val, grad) = value_and_gradient(g.backend, g.f.tree) do tree
-        eval_loss(tree, g.f.dataset, g.f.options; regularization=false, idx=g.f.idx)
+        return eval_loss(tree, g.f.dataset, g.f.options; regularization=false, idx=g.f.idx)
     end
     if G !== nothing && grad !== nothing
         G .= extract_gradient(grad, g.f.tree)
diff --git a/src/Dataset.jl b/src/Dataset.jl
index f9e28bcc..64c2ad89 100644
--- a/src/Dataset.jl
+++ b/src/Dataset.jl
@@ -90,9 +90,9 @@ end
 Construct a dataset to pass between internal functions.
 """
 function Dataset(
-    X::AbstractMatrix{T},
+    X::AbstractMatrix{T};
     y::Union{AbstractVector,Nothing}=nothing,
-    loss_type::Type{L}=Nothing;
+    loss_type::Type{L}=Nothing,
     index::Int=1,
     weights::Union{AbstractVector,Nothing}=nothing,
     variable_names::Union{Array{String,1},Nothing}=nothing,
diff --git a/src/ExpressionBuilder.jl b/src/ExpressionBuilder.jl
index 709937ec..b3bbaaa2 100644
--- a/src/ExpressionBuilder.jl
+++ b/src/ExpressionBuilder.jl
@@ -27,7 +27,7 @@ import DynamicExpressions: get_operators
 import ..CoreModule: create_expression
 
 @unstable function create_expression(
-    t::T, options::AbstractOptions, dataset::Dataset{T,L}, ::Val{embed}=Val(false)
+    t::T, options::AbstractOptions, dataset::Dataset{T,L}, (::Val{embed})=Val(false)
 ) where {T,L,embed}
     return create_expression(
         t, options, dataset, options.node_type, options.expression_type, Val(embed)
@@ -37,7 +37,7 @@ end
     t::AbstractExpressionNode{T},
     options::AbstractOptions,
     dataset::Dataset{T,L},
-    ::Val{embed}=Val(false),
+    (::Val{embed})=Val(false),
 ) where {T,L,embed}
     return create_expression(
         t, options, dataset, options.node_type, options.expression_type, Val(embed)
@@ -46,8 +46,8 @@ end
 function create_expression(
     ex::AbstractExpression{T},
     options::AbstractOptions,
-    ::Dataset{T,L},
-    ::Val{embed}=Val(false),
+    ::Dataset{T,L};
+    (::Val{embed})=Val(false),
 ) where {T,L,embed}
     return ex::options.expression_type
 end
@@ -57,7 +57,7 @@ end
     dataset::Dataset{T,L},
     ::Type{N},
     ::Type{E},
-    ::Val{embed}=Val(false),
+    (::Val{embed})=Val(false),
 ) where {T,L,embed,N<:AbstractExpressionNode,E<:AbstractExpression}
     return create_expression(constructorof(N)(; val=t), options, dataset, N, E, Val(embed))
 end
@@ -67,7 +67,7 @@ end
     dataset::Dataset{T,L},
     ::Type{<:AbstractExpressionNode},
     ::Type{E},
-    ::Val{embed}=Val(false),
+    (::Val{embed})=Val(false),
 ) where {T,L,embed,E<:AbstractExpression}
     return constructorof(E)(t; init_params(options, dataset, nothing, Val(embed))...)
 end
diff --git a/src/HallOfFame.jl b/src/HallOfFame.jl
index a75b8293..91e27d80 100644
--- a/src/HallOfFame.jl
+++ b/src/HallOfFame.jl
@@ -102,7 +102,7 @@ function calculate_pareto_frontier(hallOfFame::HallOfFame{T,L,N}) where {T,L,N}
         # We check if this member is better than all members which are smaller than it and
         # also exist.
         betterThanAllSmaller = true
-        for i in 1:(size - 1)
+        for i in 1:(size-1)
             if !hallOfFame.exists[i]
                 continue
             end
diff --git a/src/LossFunctions.jl b/src/LossFunctions.jl
index 01dcca86..cfe47f47 100644
--- a/src/LossFunctions.jl
+++ b/src/LossFunctions.jl
@@ -162,7 +162,7 @@ function loss_to_score(
     use_baseline::Bool,
     baseline::L,
     member,
-    options::AbstractOptions,
+    options::AbstractOptions;
     complexity::Union{Int,Nothing}=nothing,
 )::L where {L<:LOSS_TYPE}
     # TODO: Come up with a more general normalization scheme.
diff --git a/src/MLJInterface.jl b/src/MLJInterface.jl
index 4d7a1d14..8400f6d4 100644
--- a/src/MLJInterface.jl
+++ b/src/MLJInterface.jl
@@ -217,7 +217,7 @@ function _update(m, verbosity, old_fitresult, old_cache, X, y, w, options, class
         variable_names=variable_names,
         y_variable_names=y_variable_names,
         y_is_table=MMI.istable(y),
-        has_classes=!isnothing(classes),
+        has_classes=(!isnothing(classes)),
         X_units=X_units_clean,
         y_units=y_units_clean,
         types=(
diff --git a/src/Mutate.jl b/src/Mutate.jl
index 7b828f6f..e61776fc 100644
--- a/src/Mutate.jl
+++ b/src/Mutate.jl
@@ -349,7 +349,7 @@ end
     kws...,
 ) where {W<:AbstractMutationWeights}
     mutation_choices = fieldnames(W)
-    quote
+    return quote
         Base.Cartesian.@nif(
             $(length(mutation_choices)),
             i -> mutation_choice == $(mutation_choices)[i],
diff --git a/src/MutationFunctions.jl b/src/MutationFunctions.jl
index 73e0367b..007b0738 100644
--- a/src/MutationFunctions.jl
+++ b/src/MutationFunctions.jl
@@ -47,7 +47,7 @@ Return a random node from the tree. You may optionally
 filter the nodes matching some condition before sampling.
 """
 function random_node(
-    tree::AbstractNode, rng::AbstractRNG=default_rng(); filter::F=Returns(true)
+    tree::AbstractNode; rng::AbstractRNG=default_rng(), filter::F=Returns(true)
 ) where {F<:Function}
     Base.depwarn(
         "Instead of `random_node(tree, filter)`, use `rand(NodeSampler(; tree, filter))`",
@@ -73,7 +73,7 @@ end
 
 """Randomly convert an operator into another one (binary->binary; unary->unary)"""
 function mutate_operator(
-    ex::AbstractExpression{T}, options::AbstractOptions, rng::AbstractRNG=default_rng()
+    ex::AbstractExpression{T}, options::AbstractOptions; rng::AbstractRNG=default_rng()
 ) where {T<:DATA_TYPE}
     tree, context = get_contents_for_mutation(ex, rng)
     ex = with_contents_for_mutation(ex, mutate_operator(tree, options, rng), context)
@@ -81,7 +81,7 @@ function mutate_operator(
 end
 function mutate_operator(
     tree::AbstractExpressionNode{T},
-    options::AbstractOptions,
+    options::AbstractOptions;
     rng::AbstractRNG=default_rng(),
 ) where {T}
     if !(has_operators(tree))
@@ -100,7 +100,7 @@ end
 function mutate_constant(
     ex::AbstractExpression{T},
     temperature,
-    options::AbstractOptions,
+    options::AbstractOptions;
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     tree, context = get_contents_for_mutation(ex, rng)
@@ -112,7 +112,7 @@ end
 function mutate_constant(
     tree::AbstractExpressionNode{T},
     temperature,
-    options::AbstractOptions,
+    options::AbstractOptions;
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     # T is between 0 and 1.
@@ -147,8 +147,8 @@ end
 function append_random_op(
     ex::AbstractExpression{T},
     options::AbstractOptions,
-    nfeatures::Int,
-    rng::AbstractRNG=default_rng();
+    nfeatures::Int;
+    rng::AbstractRNG=default_rng(),
     makeNewBinOp::Union{Bool,Nothing}=nothing,
 ) where {T<:DATA_TYPE}
     tree, context = get_contents_for_mutation(ex, rng)
@@ -160,8 +160,8 @@ end
 function append_random_op(
     tree::AbstractExpressionNode{T},
     options::AbstractOptions,
-    nfeatures::Int,
-    rng::AbstractRNG=default_rng();
+    nfeatures::Int;
+    rng::AbstractRNG=default_rng(),
     makeNewBinOp::Union{Bool,Nothing}=nothing,
 ) where {T<:DATA_TYPE}
     node = rand(rng, NodeSampler(; tree, filter=t -> t.degree == 0))
@@ -193,7 +193,7 @@ end
 function insert_random_op(
     ex::AbstractExpression{T},
     options::AbstractOptions,
-    nfeatures::Int,
+    nfeatures::Int;
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     tree, context = get_contents_for_mutation(ex, rng)
@@ -205,7 +205,7 @@ end
 function insert_random_op(
     tree::AbstractExpressionNode{T},
     options::AbstractOptions,
-    nfeatures::Int,
+    nfeatures::Int;
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     node = rand(rng, NodeSampler(; tree))
@@ -229,7 +229,7 @@ end
 function prepend_random_op(
     ex::AbstractExpression{T},
     options::AbstractOptions,
-    nfeatures::Int,
+    nfeatures::Int;
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     tree, context = get_contents_for_mutation(ex, rng)
@@ -241,7 +241,7 @@ end
 function prepend_random_op(
     tree::AbstractExpressionNode{T},
     options::AbstractOptions,
-    nfeatures::Int,
+    nfeatures::Int;
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     node = tree
@@ -264,9 +264,9 @@ end
 function make_random_leaf(
     nfeatures::Int,
     ::Type{T},
-    ::Type{N},
+    ::Type{N};
     rng::AbstractRNG=default_rng(),
-    ::Union{AbstractOptions,Nothing}=nothing,
+    (::Union{AbstractOptions,Nothing})=nothing,
 ) where {T<:DATA_TYPE,N<:AbstractExpressionNode}
     if rand(rng, Bool)
         return constructorof(N)(T; val=randn(rng, T))
@@ -292,7 +292,7 @@ end
 function delete_random_op!(
     ex::AbstractExpression{T},
     options::AbstractOptions,
-    nfeatures::Int,
+    nfeatures::Int;
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     tree, context = get_contents_for_mutation(ex, rng)
@@ -304,7 +304,7 @@ end
 function delete_random_op!(
     tree::AbstractExpressionNode{T},
     options::AbstractOptions,
-    nfeatures::Int,
+    nfeatures::Int;
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     node, parent, side = random_node_and_parent(tree, rng)
@@ -363,7 +363,7 @@ function randomize_tree(
     ::AbstractExpressionNode{T},
     curmaxsize::Int,
     options::AbstractOptions,
-    nfeatures::Int,
+    nfeatures::Int;
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     tree_size_to_generate = rand(rng, 1:curmaxsize)
@@ -375,7 +375,7 @@ function gen_random_tree(
     length::Int,
     options::AbstractOptions,
     nfeatures::Int,
-    ::Type{T},
+    ::Type{T};
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     # Note that this base tree is just a placeholder; it will be replaced.
@@ -391,7 +391,7 @@ function gen_random_tree_fixed_size(
     node_count::Int,
     options::AbstractOptions,
     nfeatures::Int,
-    ::Type{T},
+    ::Type{T};
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     tree = make_random_leaf(nfeatures, T, options.node_type, rng, options)
@@ -409,7 +409,7 @@ function gen_random_tree_fixed_size(
 end
 
 function crossover_trees(
-    ex1::E, ex2::E, rng::AbstractRNG=default_rng()
+    ex1::E, ex2::E; rng::AbstractRNG=default_rng()
 ) where {T,E<:AbstractExpression{T}}
     if ex1 === ex2
         error("Attempted to crossover the same expression!")
@@ -424,7 +424,7 @@ end
 
 """Crossover between two expressions"""
 function crossover_trees(
-    tree1::N, tree2::N, rng::AbstractRNG=default_rng()
+    tree1::N, tree2::N; rng::AbstractRNG=default_rng()
 ) where {T,N<:AbstractExpressionNode{T}}
     if tree1 === tree2
         error("Attempted to crossover the same tree!")
diff --git a/src/OptionsStruct.jl b/src/OptionsStruct.jl
index fa8a0035..c002a775 100644
--- a/src/OptionsStruct.jl
+++ b/src/OptionsStruct.jl
@@ -118,9 +118,11 @@ Controls level of specialization we compile into `Options`.
 
 Overload if needed for custom expression types.
 """
-operator_specialization(
+function operator_specialization(
     ::Type{O}, ::Type{<:AbstractExpression}
-) where {O<:AbstractOperatorEnum} = O
+) where {O<:AbstractOperatorEnum}
+    return O
+end
 @unstable operator_specialization(::Type{<:OperatorEnum}, ::Type{<:AbstractExpression}) =
     OperatorEnum
 
@@ -288,7 +290,7 @@ end
     # Return an options struct with concrete operators
     type_parameters = O.parameters
     fields = Any[:(getfield(options, $(QuoteNode(k)))) for k in fieldnames(O)]
-    quote
+    return quote
         operators = getfield(options, :operators)
         Options{$(type_parameters[1]),typeof(operators),$(type_parameters[3:end]...)}(
             $(fields...)
diff --git a/src/ParametricExpression.jl b/src/ParametricExpression.jl
index f98a1de0..5c9958ff 100644
--- a/src/ParametricExpression.jl
+++ b/src/ParametricExpression.jl
@@ -107,7 +107,7 @@ end
 function MF.make_random_leaf(
     nfeatures::Int,
     ::Type{T},
-    ::Type{N},
+    ::Type{N};
     rng::AbstractRNG=default_rng(),
     options::Union{AbstractOptions,Nothing}=nothing,
 ) where {T<:DATA_TYPE,N<:ParametricNode}
@@ -132,7 +132,7 @@ end
 
 function MF.crossover_trees(
     ex1::ParametricExpression{T},
-    ex2::ParametricExpression{T},
+    ex2::ParametricExpression{T};
     rng::AbstractRNG=default_rng(),
 ) where {T}
     tree1 = get_contents(ex1)
@@ -167,7 +167,7 @@ end
 function MF.mutate_constant(
     ex::ParametricExpression{T},
     temperature,
-    options::AbstractOptions,
+    options::AbstractOptions;
     rng::AbstractRNG=default_rng(),
 ) where {T<:DATA_TYPE}
     if rand(rng, Bool)
diff --git a/src/PopMember.jl b/src/PopMember.jl
index 63cfebfb..2f42ab48 100644
--- a/src/PopMember.jl
+++ b/src/PopMember.jl
@@ -60,9 +60,9 @@ and loss.
 function PopMember(
     t::AbstractExpression{T},
     score::L,
-    loss::L,
+    loss::L;
     options::Union{AbstractOptions,Nothing}=nothing,
-    complexity::Union{Int,Nothing}=nothing;
+    complexity::Union{Int,Nothing}=nothing,
     ref::Int=-1,
     parent::Int=-1,
     deterministic=nothing,
@@ -108,8 +108,8 @@ Automatically compute the score for this tree.
 function PopMember(
     dataset::Dataset{T,L},
     tree::Union{AbstractExpressionNode{T},AbstractExpression{T}},
-    options::AbstractOptions,
-    complexity::Union{Int,Nothing}=nothing;
+    options::AbstractOptions;
+    complexity::Union{Int,Nothing}=nothing,
     ref::Int=-1,
     parent::Int=-1,
     deterministic=nothing,
diff --git a/src/Population.jl b/src/Population.jl
index 54aabd36..b3c19baa 100644
--- a/src/Population.jl
+++ b/src/Population.jl
@@ -173,7 +173,7 @@ const CACHED_WEIGHTS =
     p = options.tournament_selection_p
     # Computing the weights for the tournament becomes quite expensive,
     return get!(CACHED_WEIGHTS, (n, p)) do
-        k = collect(0:(n - 1))
+        k = collect(0:(n-1))
         prob_each = p * ((1 - p) .^ k)
 
         return StatsBase.Weights(prob_each, sum(prob_each))
diff --git a/src/Recorder.jl b/src/Recorder.jl
index 171a1f46..2348af36 100644
--- a/src/Recorder.jl
+++ b/src/Recorder.jl
@@ -4,7 +4,7 @@ using ..CoreModule: RecordType
 
 "Assumes that `options` holds the user options::AbstractOptions"
 macro recorder(ex)
-    quote
+    return quote
         if $(esc(:options)).use_recorder
             $(esc(ex))
         end
diff --git a/src/SearchUtils.jl b/src/SearchUtils.jl
index 23358d9d..f3d5fdca 100644
--- a/src/SearchUtils.jl
+++ b/src/SearchUtils.jl
@@ -262,8 +262,8 @@ macro sr_spawner(expr, kws...)
     @assert all(ex -> ex.head == :(=), kws)
     @assert any(ex -> ex.args[1] == :parallelism, kws)
     @assert any(ex -> ex.args[1] == :worker_idx, kws)
-    parallelism = kws[findfirst(ex -> ex.args[1] == :parallelism, kws)::Int].args[2]
-    worker_idx = kws[findfirst(ex -> ex.args[1] == :worker_idx, kws)::Int].args[2]
+    parallelism = kws[findfirst(ex -> ex.args[1] == :parallelism, kws) :: Int].args[2]
+    worker_idx = kws[findfirst(ex -> ex.args[1] == :worker_idx, kws) :: Int].args[2]
     return quote
         if $(parallelism) == :serial
             $(expr)
@@ -363,7 +363,7 @@ end
 function _check_for_loss_threshold(halls_of_fame, f::F, options::AbstractOptions) where {F}
     return all(halls_of_fame) do hof
         any(hof.members[hof.exists]) do member
-            f(member.loss, compute_complexity(member, options))::Bool
+            return f(member.loss, compute_complexity(member, options))::Bool
         end
     end
 end
@@ -431,7 +431,7 @@ function update_progress_bar!(
     dataset::Dataset{T,L},
     options::AbstractOptions,
     equation_speed::Vector{Float32},
-    head_node_occupation::Float64,
+    head_node_occupation::Float64;
     parallelism=:serial,
 ) where {T,L}
     equation_strings = string_dominating_pareto_curve(
@@ -604,7 +604,7 @@ function save_to_file(
     # Write file twice in case exit in middle of filewrite
     for out_file in (output_file, output_file * ".bkup")
         open(out_file, "w") do io
-            write(io, s)
+            return write(io, s)
         end
     end
     return nothing
diff --git a/src/SymbolicRegression.jl b/src/SymbolicRegression.jl
index 0530dba4..a4911266 100644
--- a/src/SymbolicRegression.jl
+++ b/src/SymbolicRegression.jl
@@ -800,9 +800,9 @@ function _main_search_loop!(
     resource_monitor = ResourceMonitor(;
         # Storing n times as many monitoring intervals as populations seems like it will
         # help get accurate resource estimates:
-        max_recordings=options.populations * 100 * nout,
-        start_reporting_at=options.populations * 3 * nout,
-        window_size=options.populations * 2 * nout,
+        max_recordings=(options.populations * 100 * nout),
+        start_reporting_at=(options.populations * 3 * nout),
+        window_size=(options.populations * 2 * nout),
     )
     while sum(state.cycles_remaining) > 0
         kappa += 1
@@ -1093,7 +1093,7 @@ using ConstructionBase: ConstructionBase as _
 include("precompile.jl")
 redirect_stdout(devnull) do
     redirect_stderr(devnull) do
-        do_precompilation(Val(:precompile))
+        return do_precompilation(Val(:precompile))
     end
 end
 
diff --git a/src/TemplateExpression.jl b/src/TemplateExpression.jl
index dfc8b59c..fff6e79e 100644
--- a/src/TemplateExpression.jl
+++ b/src/TemplateExpression.jl
@@ -162,8 +162,8 @@ function EB.create_expression(
     options::AbstractOptions,
     dataset::Dataset{T,L},
     ::Type{<:AbstractExpressionNode},
-    ::Type{E},
-    ::Val{embed}=Val(false),
+    ::Type{E};
+    (::Val{embed})=Val(false),
 ) where {T,L,embed,E<:TemplateExpression}
     function_keys = keys(options.expression_options.variable_mapping)
 
@@ -219,8 +219,8 @@ function DE.string_tree(
 end
 function DE.eval_tree_array(
     tree::TemplateExpression{T},
-    cX::AbstractMatrix{T},
-    operators::Union{AbstractOperatorEnum,Nothing}=nothing;
+    cX::AbstractMatrix{T};
+    operators::Union{AbstractOperatorEnum,Nothing}=nothing,
     kws...,
 ) where {T}
     raw_contents = get_contents(tree)
@@ -294,7 +294,7 @@ end
 
 """We combine the operators of each inner expression."""
 function DE.combine_operators(
-    ex::TemplateExpression{T,N}, operators::Union{AbstractOperatorEnum,Nothing}=nothing
+    ex::TemplateExpression{T,N}; operators::Union{AbstractOperatorEnum,Nothing}=nothing
 ) where {T,N}
     raw_contents = get_contents(ex)
     function_keys = keys(raw_contents)
@@ -306,7 +306,7 @@ end
 
 """We simplify each inner expression."""
 function DE.simplify_tree!(
-    ex::TemplateExpression{T,N}, operators::Union{AbstractOperatorEnum,Nothing}=nothing
+    ex::TemplateExpression{T,N}; operators::Union{AbstractOperatorEnum,Nothing}=nothing
 ) where {T,N}
     raw_contents = get_contents(ex)
     function_keys = keys(raw_contents)
@@ -323,7 +323,7 @@ end
 function CC.check_constraints(
     ex::TemplateExpression,
     options::AbstractOptions,
-    maxsize::Int,
+    maxsize::Int;
     cursize::Union{Int,Nothing}=nothing,
 )::Bool
     raw_contents = get_contents(ex)
@@ -333,7 +333,7 @@ function CC.check_constraints(
     has_invalid_variables = any(keys(raw_contents)) do key
         tree = raw_contents[key]
         allowed_variables = variable_mapping[key]
-        contains_other_features_than(tree, allowed_variables)
+        return contains_other_features_than(tree, allowed_variables)
     end
     if has_invalid_variables
         return false
@@ -354,7 +354,7 @@ function contains_other_features_than(tree::AbstractExpression, features)
 end
 function contains_other_features_than(tree::AbstractExpressionNode, features)
     any(tree) do node
-        node.degree == 0 && !node.constant && node.feature ∉ features
+        return node.degree == 0 && !node.constant && node.feature ∉ features
     end
 end
 
diff --git a/src/Utils.jl b/src/Utils.jl
index da67bcf4..0f73a648 100644
--- a/src/Utils.jl
+++ b/src/Utils.jl
@@ -95,8 +95,9 @@ const max_ops = 8192
 const vals = ntuple(Val, max_ops)
 
 """Return the bottom k elements of x, and their indices."""
-bottomk_fast(x::AbstractVector{T}, k) where {T} =
-    _bottomk_dispatch(x, vals[k])::Tuple{Vector{T},Vector{Int}}
+function bottomk_fast(x::AbstractVector{T}, k) where {T}
+    return _bottomk_dispatch(x, vals[k])::Tuple{Vector{T},Vector{Int}}
+end
 
 function _bottomk_dispatch(x::AbstractVector{T}, ::Val{k}) where {T,k}
     if k == 1
@@ -113,7 +114,7 @@ function _bottomk!(x, minval, indmin)
         if new_min
             minval[end] = x[i]
             indmin[end] = i
-            for ki in lastindex(minval):-1:(firstindex(minval) + 1)
+            for ki in lastindex(minval):-1:(firstindex(minval)+1)
                 need_swap = minval[ki] < minval[ki - 1]
                 if need_swap
                     minval[ki], minval[ki - 1] = minval[ki - 1], minval[ki]
diff --git a/test/manual_distributed.jl b/test/manual_distributed.jl
index 0d6490c6..e9a9f4e9 100644
--- a/test/manual_distributed.jl
+++ b/test/manual_distributed.jl
@@ -5,12 +5,10 @@ procs = addprocs(2)
 using Test, Pkg
 project_path = splitdir(Pkg.project().path)[1]
 @everywhere procs begin
-    Base.MainInclude.eval(
-        quote
-            using Pkg
-            Pkg.activate($$project_path)
-        end,
-    )
+    Base.MainInclude.eval(quote
+        using Pkg
+        Pkg.activate($$project_path)
+    end)
 end
 @everywhere using SymbolicRegression
 @everywhere _inv(x::Float32)::Float32 = 1.0f0 / x
diff --git a/test/test_dataset.jl b/test/test_dataset.jl
index 50547197..20717f72 100644
--- a/test/test_dataset.jl
+++ b/test/test_dataset.jl
@@ -13,7 +13,7 @@ end
     using SymbolicRegression
     using DispatchDoctor: allow_unstable
     dataset = allow_unstable() do
-        Dataset(randn(ComplexF32, 3, 32), randn(ComplexF32, 32); loss_type=Float64)
+        return Dataset(randn(ComplexF32, 3, 32), randn(ComplexF32, 32); loss_type=Float64)
     end
     @test dataset isa Dataset{ComplexF32,Float64}
 end
diff --git a/test/test_derivatives.jl b/test/test_derivatives.jl
index 9615a927..cbc411d0 100644
--- a/test/test_derivatives.jl
+++ b/test/test_derivatives.jl
@@ -135,7 +135,7 @@ function check_tree(
     tree::AbstractExpressionNode, node_index::NodeIndex, constant_list::AbstractVector
 )
     if tree.degree == 0
-        (!tree.constant) || tree.val == constant_list[node_index.val::UInt16]
+        (!tree.constant) || tree.val == constant_list[node_index.val:: UInt16]
     elseif tree.degree == 1
         check_tree(tree.l, node_index.l, constant_list)
     else
diff --git a/test/test_expression_derivatives.jl b/test/test_expression_derivatives.jl
index c8cba75a..b8953d5e 100644
--- a/test/test_expression_derivatives.jl
+++ b/test/test_expression_derivatives.jl
@@ -17,7 +17,7 @@
         x = @view X[1, :]
         y = @view X[2, :]
 
-        sum(i -> x[i] * x[i] - cos(2.5 * y[i]), eachindex(x))
+        return sum(i -> x[i] * x[i] - cos(2.5 * y[i]), eachindex(x))
     end
     δy_hat = ex'(X)
 
@@ -28,7 +28,7 @@
         x = @view X[1, :]
         y = @view X[2, :]
 
-        sum(i -> (x[i] + x[i]) * sin(2.5 + y[i]), eachindex(x))
+        return sum(i -> (x[i] + x[i]) * sin(2.5 + y[i]), eachindex(x))
     end
     δy2_hat = ex'(X, options2)
 
@@ -98,7 +98,7 @@ end
                 X[1, i] * X[1, i] - cos(c[1] * X[2, i] + c[2]) + params[1, classes[i]] for
                 i in 1:32
             ]
-            sum(abs2, pred .- y) / length(y)
+            return sum(abs2, pred .- y) / length(y)
         end
 
     options = Options(;
diff --git a/test/test_mlj.jl b/test/test_mlj.jl
index d2677348..b489fd63 100644
--- a/test/test_mlj.jl
+++ b/test/test_mlj.jl
@@ -102,7 +102,7 @@ end
 
     rng = MersenneTwister(0)
     X = (b1=randn(rng, 32), b2=randn(rng, 32))
-    Y = (c1=X.b1 .* X.b2, c2=X.b1 .+ X.b2)
+    Y = (c1=(X.b1 .* X.b2), c2=(X.b1 .+ X.b2))
     w = ones(32)
     model = MultitargetSRRegressor(; niterations=10, stop_kws...)
     mach = machine(model, X, Y, w)
@@ -189,7 +189,7 @@ end
     # Ensure that the hall of fame is empty:
     _, hofs = mach.fitresult.state
     foreach(hofs) do hof
-        hof.exists .= false
+        return hof.exists .= false
     end
     mach.report[:fit] = SymbolicRegression.MLJInterfaceModule.full_report(
         model, mach.fitresult
diff --git a/test/test_params.jl b/test/test_params.jl
index b74b5801..f72386a0 100644
--- a/test/test_params.jl
+++ b/test/test_params.jl
@@ -77,7 +77,7 @@ test_info(f::F, ::Test.Fail) where {F} = f()
 macro quiet(ex)
     return quote
         redirect_stderr(devnull) do
-            $ex
+            return $ex
         end
     end |> esc
 end
diff --git a/test/test_recorder.jl b/test/test_recorder.jl
index 95d7b734..02db0e56 100644
--- a/test/test_recorder.jl
+++ b/test/test_recorder.jl
@@ -25,7 +25,7 @@ hall_of_fame = equation_search(
 )
 
 data = open(options.recorder_file, "r") do io
-    JSON3.read(io; allow_inf=true)
+    return JSON3.read(io; allow_inf=true)
 end
 
 @test haskey(data, :options)
diff --git a/test/test_template_expression.jl b/test/test_template_expression.jl
index 8f44d521..4cef4365 100644
--- a/test/test_template_expression.jl
+++ b/test/test_template_expression.jl
@@ -7,14 +7,14 @@
     options = Options(; binary_operators=(+, *, /, -), unary_operators=(sin, cos))
     operators = options.operators
     variable_names = (i -> "x$i").(1:3)
-    x1, x2, x3 =
-        (i -> Expression(Node(Float64; feature=i); operators, variable_names)).(1:3)
+    x1, x2, x3 = (i -> Expression(Node(Float64; feature=i); operators, variable_names)).(
+        1:3
+    )
 
     # For combining expressions to a single expression:
-    my_structure(nt::NamedTuple{<:Any,<:Tuple{Vararg{<:AbstractString}}}) =
-        "sin($(nt.f)) + $(nt.g)^2"
-    my_structure(nt::NamedTuple{<:Any,<:Tuple{Vararg{<:AbstractVector}}}) =
-        @. sin(nt.f) + nt.g^2
+    my_structure(nt::NamedTuple{<:Any,<:Tuple{Vararg{<:AbstractString}}}) = "sin($(nt.f)) + $(nt.g)^2"
+    my_structure(nt::NamedTuple{<:Any,<:Tuple{Vararg{<:AbstractVector}}}) = @. sin(nt.f) +
+        nt.g^2
     my_structure(nt::NamedTuple{<:Any,<:Tuple{Vararg{<:Expression}}}) =
         sin(nt.f) + nt.g * nt.g
 
@@ -64,14 +64,14 @@ end
 
     operators = OperatorEnum(; binary_operators=(+, *, /, -), unary_operators=(sin, cos))
     variable_names = (i -> "x$i").(1:3)
-    x1, x2, x3 =
-        (i -> Expression(Node(Float64; feature=i); operators, variable_names)).(1:3)
+    x1, x2, x3 = (i -> Expression(Node(Float64; feature=i); operators, variable_names)).(
+        1:3
+    )
 
     # For combining expressions to a single expression:
-    my_structure(nt::NamedTuple{<:Any,<:Tuple{Vararg{<:AbstractString}}}) =
-        "sin($(nt.f)) + $(nt.g)^2"
-    my_structure(nt::NamedTuple{<:Any,<:Tuple{Vararg{<:AbstractVector}}}) =
-        @. sin(nt.f) + nt.g^2
+    my_structure(nt::NamedTuple{<:Any,<:Tuple{Vararg{<:AbstractString}}}) = "sin($(nt.f)) + $(nt.g)^2"
+    my_structure(nt::NamedTuple{<:Any,<:Tuple{Vararg{<:AbstractVector}}}) = @. sin(nt.f) +
+        nt.g^2
     my_structure(nt::NamedTuple{<:Any,<:Tuple{Vararg{<:Expression}}}) =
         sin(nt.f) + nt.g * nt.g
 
@@ -101,8 +101,11 @@ end
     variable_names = (i -> "x$i").(1:3)
 
     # Create expressions
-    x1, x2, x3 =
-        (i -> Expression(Node(Float64; feature=i); options.operators, variable_names)).(1:3)
+    x1, x2, x3 = (
+        i -> Expression(Node(Float64; feature=i); options.operators, variable_names)
+    ).(
+        1:3
+    )
 
     # Test with vector inputs:
     nt_vector = NamedTuple{(:f, :g1, :g2, :g3)}((1:3, 4:6, 7:9, 10:12))
@@ -136,8 +139,9 @@ end
     operators =
         Options(; binary_operators=(+, *, /, -), unary_operators=(sin, cos)).operators
     variable_names = (i -> "x$i").(1:3)
-    x1, x2, x3 =
-        (i -> Expression(Node(Float64; feature=i); operators, variable_names)).(1:3)
+    x1, x2, x3 = (i -> Expression(Node(Float64; feature=i); operators, variable_names)).(
+        1:3
+    )
 
     my_structure(nt) = nt.f
 
diff --git a/test/test_units.jl b/test/test_units.jl
index a586f5e3..5dff9a40 100644
--- a/test/test_units.jl
+++ b/test/test_units.jl
@@ -131,15 +131,15 @@ end
     # Check that every cos(...) which contains x1 also has complexity
     has_cos(tree) =
         any(get_tree(tree)) do t
-            t.degree == 1 && options.operators.unaops[t.op] == cos
+            return t.degree == 1 && options.operators.unaops[t.op] == cos
         end
     valid_trees = [
         !has_cos(member.tree) || any(
             t ->
                 t.degree == 1 &&
-                    options.operators.unaops[t.op] == cos &&
-                    Node(Float64; feature=1) in t &&
-                    compute_complexity(t, options) > 1,
+                options.operators.unaops[t.op] == cos &&
+                Node(Float64; feature=1) in t &&
+                compute_complexity(t, options) > 1,
             get_tree(member.tree),
         ) for member in dominating
     ]
@@ -243,10 +243,10 @@ end
     best = first(filter(m::PopMember -> m.loss < 1e-7, dominating)).tree
     @test compute_complexity(best, options2) == 6
     @test any(get_tree(best)) do t
-        t.degree == 1 && options2.operators.unaops[t.op] == cbrt
+        return t.degree == 1 && options2.operators.unaops[t.op] == cbrt
     end
     @test any(get_tree(best)) do t
-        t.degree == 1 && options2.operators.unaops[t.op] == safe_sqrt
+        return t.degree == 1 && options2.operators.unaops[t.op] == safe_sqrt
     end
 
     @testset "With MLJ" begin
@@ -268,10 +268,10 @@ end
             best_idx = findfirst(report.losses .< 1e-7)::Int
             @test report.complexities[best_idx] <= 6
             @test any(get_tree(report.equations[best_idx])) do t
-                t.degree == 1 && t.op == 2  # cbrt
+                return t.degree == 1 && t.op == 2  # cbrt
             end
             @test any(get_tree(report.equations[best_idx])) do t
-                t.degree == 1 && t.op == 1  # safe_sqrt
+                return t.degree == 1 && t.op == 1  # safe_sqrt
             end
 
             # Prediction should have same units:
diff --git a/test/test_utils.jl b/test/test_utils.jl
index 67ceb0dc..2433476a 100644
--- a/test/test_utils.jl
+++ b/test/test_utils.jl
@@ -9,8 +9,8 @@ function simple_bottomk(x, k)
 end
 
 array_options = [
-    (n=n, seed=seed, T=T) for n in (1, 5, 20, 50, 100, 1000), seed in 1:10,
-    T in (Float32, Float64, Int)
+    (n=n, seed=seed, T=T) for
+    n in (1, 5, 20, 50, 100, 1000), seed in 1:10, T in (Float32, Float64, Int)
 ]
 
 @testset "argmin_fast" begin

MilesCranmer · 2024-10-16T21:53:13Z

Some changes seem like new quirks, though they don’t actually affect semantics, like

-        (!tree.constant) || tree.val == constant_list[node_index.val::UInt16]
+        (!tree.constant) || tree.val == constant_list[node_index.val:: UInt16]

domluna · 2024-10-16T23:39:14Z

Besides the ones mentioned in the other issues at the one in the comment above are there any other ones in the diff that are also quirks?

kenahoo · 2024-10-17T14:54:39Z

I'm seeing several new kinds:

     open(path, "w") do io
-        TOML.print(io, data)
+        return TOML.print(io, data)
     end

         node_sample_size =
-            rand(rng, 1:(nv(base_proposal.grid_graph) - length(base_proposal.rez_assets))) - 1
+            rand(rng, 1:(nv(base_proposal.grid_graph)-length(base_proposal.rez_assets))) - 1

-        known_nodes = known_nodes[.!to_purge, :]
+        known_nodes = known_nodes[.! to_purge, :]

             [:FrEnode, :ToEnode] =>
                 (FrEnode, ToEnode) ->
                     (FrEnode == from.id && ToEnode == to.id) ||
-                        (FrEnode == to.id && ToEnode == from.id),
+                    (FrEnode == to.id && ToEnode == from.id),
             branches,

-    branches.Foooooooo[to_impute] .=
-        get_foooooooo.(branches.Voltage[to_impute], branches.Distance[to_impute])
+    branches.Foooooooo[to_impute] .= get_foooooooo.(
+        branches.Voltage[to_impute], branches.Distance[to_impute]
+    )

domluna · 2024-10-19T20:04:53Z

this one is actually more correct now since the indentation should only be applied to shortcircuit boolean expressions. In the example above it's a regular boolean expression where a true of false is returned whereas in a shortcircuit expression something else (although it can also be a boolean) is returned or done once the initial calls up to the last one are completed, i.e. a && b && return c vs a && b && c

mtfishman mentioned this issue Oct 17, 2024

[ITensorMPS] Added option for MPO-MPS zipup ITensor/ITensors.jl#1536

Open

7 tasks

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Formatting issues and changes between 1 and 2 #880

Formatting issues and changes between 1 and 2 #880

MilesCranmer commented Oct 16, 2024 •

edited

Loading

MilesCranmer commented Oct 16, 2024

domluna commented Oct 16, 2024

kenahoo commented Oct 17, 2024

domluna commented Oct 19, 2024

Formatting issues and changes between 1 and 2 #880

Formatting issues and changes between 1 and 2 #880

Comments

MilesCranmer commented Oct 16, 2024 • edited Loading

MilesCranmer commented Oct 16, 2024

domluna commented Oct 16, 2024

kenahoo commented Oct 17, 2024

domluna commented Oct 19, 2024

MilesCranmer commented Oct 16, 2024 •

edited

Loading