diff --git a/benchmark/agents.jl b/benchmark/agents.jl
index 9c8d96a56c..bb5fb15cd5 100644
--- a/benchmark/agents.jl
+++ b/benchmark/agents.jl
@@ -83,4 +83,3 @@ mutable struct ContinuousAgentFive <: AbstractAgent
     pos::NTuple{3,Float64}
     vel::NTuple{3,Float64}
 end
-
diff --git a/benchmark/benchmarks.jl b/benchmark/benchmarks.jl
index 2fcde2fad7..ad8965744c 100644
--- a/benchmark/benchmarks.jl
+++ b/benchmark/benchmarks.jl
@@ -64,30 +64,37 @@ graph_model = ABM(GraphAgent, GraphSpace(complete_digraph(200)))
 graph_agent = GraphAgent(1, 82, 6.5, false)
 graph_union_model = ABM(
     Union{GraphAgent,GraphAgentTwo,GraphAgentThree,GraphAgentFour,GraphAgentFive},
-    GraphSpace(complete_digraph(200)),
-    warn = false,
+    GraphSpace(complete_digraph(200));
+    warn=false,
 )
 
 # Limit samples here so space does not saturate with agents
-SUITE["graph"]["add"]["agent"] =
-    @benchmarkable add_agent!($graph_agent, $graph_model) samples = 100
-SUITE["graph"]["add"]["agent_pos"] =
-    @benchmarkable add_agent_pos!($graph_agent, $graph_model) samples = 100
-SUITE["graph"]["add"]["agent_single"] =
-    @benchmarkable add_agent_single!($graph_agent, $graph_model) samples = 100
-SUITE["graph"]["add"]["create_pos"] =
-    @benchmarkable add_agent!(26, $graph_model, 6.5, false) samples = 100
-SUITE["graph"]["add"]["create_single"] =
-    @benchmarkable add_agent_single!($graph_model, 6.5, false) samples = 100
-SUITE["graph"]["add"]["create"] =
-    @benchmarkable add_agent!($graph_model, 6.5, false) samples = 100
-
-SUITE["graph"]["add_union"]["agent"] =
-    @benchmarkable add_agent!($graph_agent, $graph_union_model) samples = 100
-SUITE["graph"]["add_union"]["agent_pos"] =
-    @benchmarkable add_agent_pos!($graph_agent, $graph_union_model) samples = 100
-SUITE["graph"]["add_union"]["agent_single"] =
-    @benchmarkable add_agent_single!($graph_agent, $graph_union_model) samples = 100
+SUITE["graph"]["add"]["agent"] = @benchmarkable add_agent!($graph_agent, $graph_model) samples =
+    100
+SUITE["graph"]["add"]["agent_pos"] = @benchmarkable add_agent_pos!(
+    $graph_agent, $graph_model
+) samples = 100
+SUITE["graph"]["add"]["agent_single"] = @benchmarkable add_agent_single!(
+    $graph_agent, $graph_model
+) samples = 100
+SUITE["graph"]["add"]["create_pos"] = @benchmarkable add_agent!(
+    26, $graph_model, 6.5, false
+) samples = 100
+SUITE["graph"]["add"]["create_single"] = @benchmarkable add_agent_single!(
+    $graph_model, 6.5, false
+) samples = 100
+SUITE["graph"]["add"]["create"] = @benchmarkable add_agent!($graph_model, 6.5, false) samples =
+    100
+
+SUITE["graph"]["add_union"]["agent"] = @benchmarkable add_agent!(
+    $graph_agent, $graph_union_model
+) samples = 100
+SUITE["graph"]["add_union"]["agent_pos"] = @benchmarkable add_agent_pos!(
+    $graph_agent, $graph_union_model
+) samples = 100
+SUITE["graph"]["add_union"]["agent_single"] = @benchmarkable add_agent_single!(
+    $graph_agent, $graph_union_model
+) samples = 100
 
 graph_model = ABM(GraphAgent, GraphSpace(complete_digraph(100)))
 for position in 1:100
@@ -102,20 +109,24 @@ SUITE["graph"]["move"]["pos"] = @benchmarkable move_agent!($a, 68, $graph_model)
 SUITE["graph"]["move"]["single"] = @benchmarkable move_agent_single!($a, $graph_model)
 
 # We use a digraph, so all agents are neighbors of each other
-SUITE["graph"]["neighbors"]["nearby_ids"] =
-    @benchmarkable nearby_ids($pos, $graph_model) setup = (nearby_ids($pos, $graph_model))
-SUITE["graph"]["neighbors"]["nearby_agents"] =
-    @benchmarkable nearby_ids($a, $graph_model) setup = (nearby_ids($a, $graph_model))
-SUITE["graph"]["neighbors"]["nearby_ids_iterate"] =
-    @benchmarkable iterate_over_neighbors($pos, $graph_model, 1) setup =
-        (nearby_ids($pos, $graph_model))
-SUITE["graph"]["neighbors"]["nearby_agents_iterate"] =
-    @benchmarkable iterate_over_neighbors($a, $graph_model, 1) setup =
-        (nearby_ids($a, $graph_model))
-SUITE["graph"]["neighbors"]["position_pos"] =
-    @benchmarkable nearby_positions($pos, $graph_model)
-SUITE["graph"]["neighbors"]["position_agent"] =
-    @benchmarkable nearby_positions($a, $graph_model)
+SUITE["graph"]["neighbors"]["nearby_ids"] = @benchmarkable nearby_ids($pos, $graph_model) setup = (nearby_ids(
+    $pos, $graph_model
+))
+SUITE["graph"]["neighbors"]["nearby_agents"] = @benchmarkable nearby_ids($a, $graph_model) setup = (nearby_ids(
+    $a, $graph_model
+))
+SUITE["graph"]["neighbors"]["nearby_ids_iterate"] = @benchmarkable iterate_over_neighbors(
+    $pos, $graph_model, 1
+) setup = (nearby_ids($pos, $graph_model))
+SUITE["graph"]["neighbors"]["nearby_agents_iterate"] = @benchmarkable iterate_over_neighbors(
+    $a, $graph_model, 1
+) setup = (nearby_ids($a, $graph_model))
+SUITE["graph"]["neighbors"]["position_pos"] = @benchmarkable nearby_positions(
+    $pos, $graph_model
+)
+SUITE["graph"]["neighbors"]["position_agent"] = @benchmarkable nearby_positions(
+    $a, $graph_model
+)
 
 SUITE["graph"]["position"]["contents"] = @benchmarkable ids_in_position($pos, $graph_model)
 SUITE["graph"]["position"]["positions"] = @benchmarkable positions($graph_model)
@@ -127,18 +138,20 @@ grid_agent = GridAgent(1, (2, 3), 6.5, false)
 grid_union_model = ABM(
     Union{GridAgent,GridAgentTwo,GridAgentThree,GridAgentFour,GridAgentFive},
     GridSpace((15, 15));
-    warn = false,
+    warn=false,
 )
 
-SUITE["grid"]["add"]["agent_pos"] =
-    @benchmarkable add_agent_pos!($grid_agent, $grid_model) samples = 100
-SUITE["grid"]["add"]["create_fill"] =
-    @benchmarkable fill_space!($grid_model, 6.5, false) samples = 100
+SUITE["grid"]["add"]["agent_pos"] = @benchmarkable add_agent_pos!($grid_agent, $grid_model) samples =
+    100
+SUITE["grid"]["add"]["create_fill"] = @benchmarkable fill_space!($grid_model, 6.5, false) samples =
+    100
 
-SUITE["grid"]["add_union"]["agent_pos"] =
-    @benchmarkable add_agent_pos!($grid_agent, $grid_union_model) samples = 100
-SUITE["grid"]["add_union"]["agent_fill"] =
-    @benchmarkable fill_space!(GridAgent, $grid_union_model, 6.5, false) samples = 100
+SUITE["grid"]["add_union"]["agent_pos"] = @benchmarkable add_agent_pos!(
+    $grid_agent, $grid_union_model
+) samples = 100
+SUITE["grid"]["add_union"]["agent_fill"] = @benchmarkable fill_space!(
+    GridAgent, $grid_union_model, 6.5, false
+) samples = 100
 
 grid_model = ABM(GridAgent, GridSpace((50, 50)))
 for x in 1:50
@@ -154,58 +167,62 @@ SUITE["grid"]["move"]["random"] = @benchmarkable move_agent!($a, $grid_model)
 SUITE["grid"]["move"]["pos"] = @benchmarkable move_agent!($a, (14, 35), $grid_model)
 SUITE["grid"]["move"]["single"] = @benchmarkable move_agent_single!($a, $grid_model)
 
-SUITE["grid"]["neighbors"]["nearby_ids"] =
-    @benchmarkable nearby_ids($pos, $grid_model, 5) setup =
-        (nearby_ids($pos, $grid_model, 5))
-SUITE["grid"]["neighbors"]["nearby_agents"] =
-    @benchmarkable nearby_ids($a, $grid_model, 5) setup = (nearby_ids($a, $grid_model, 5))
+SUITE["grid"]["neighbors"]["nearby_ids"] = @benchmarkable nearby_ids($pos, $grid_model, 5) setup = (nearby_ids(
+    $pos, $grid_model, 5
+))
+SUITE["grid"]["neighbors"]["nearby_agents"] = @benchmarkable nearby_ids($a, $grid_model, 5) setup = (nearby_ids(
+    $a, $grid_model, 5
+))
 
-SUITE["grid"]["neighbors"]["nearby_ids_iterate"] =
-    @benchmarkable iterate_over_neighbors($pos, $grid_model, 30) setup =
-        (nearby_ids($pos, $grid_model, 30))
+SUITE["grid"]["neighbors"]["nearby_ids_iterate"] = @benchmarkable iterate_over_neighbors(
+    $pos, $grid_model, 30
+) setup = (nearby_ids($pos, $grid_model, 30))
 
-SUITE["grid"]["neighbors"]["nearby_agents_iterate"] =
-    @benchmarkable iterate_over_neighbors($a, $grid_model, 30) setup =
-        (nearby_ids($a, $grid_model, 30))
+SUITE["grid"]["neighbors"]["nearby_agents_iterate"] = @benchmarkable iterate_over_neighbors(
+    $a, $grid_model, 30
+) setup = (nearby_ids($a, $grid_model, 30))
 
-SUITE["grid"]["neighbors"]["position_pos"] =
-    @benchmarkable nearby_positions($a, $grid_model)
-SUITE["grid"]["neighbors"]["position_agent"] =
-    @benchmarkable nearby_positions($a, $grid_model)
+SUITE["grid"]["neighbors"]["position_pos"] = @benchmarkable nearby_positions(
+    $a, $grid_model
+)
+SUITE["grid"]["neighbors"]["position_agent"] = @benchmarkable nearby_positions(
+    $a, $grid_model
+)
 
 SUITE["grid"]["position"]["contents"] = @benchmarkable ids_in_position($pos, $grid_model)
 SUITE["graph"]["position"]["positions"] = @benchmarkable positions($graph_model)
 
 #### API -> CONTINUOUS ####
 
-continuous_model = ABM(ContinuousAgent, ContinuousSpace((10.0, 10.0, 10.0); spacing = 0.5))
+continuous_model = ABM(ContinuousAgent, ContinuousSpace((10.0, 10.0, 10.0); spacing=0.5))
 continuous_agent = ContinuousAgent(1, (2.2, 1.9, 7.5), (0.5, 1.0, 0.01), 6.5, false)
 
 # We must use setup create the model inside some benchmarks here, otherwise we hit the issue from #226.
 # For tuning, this is actually impossible. So until ContinuousSpace is implemented, we drop these tests.
-SUITE["continuous"]["add"]["agent_pos"] =
-    @benchmarkable add_agent_pos!($continuous_agent, cmodel) setup =
-        (cmodel = ABM(ContinuousAgent, ContinuousSpace((10.0, 10.0, 10.0); spacing = 0.5))) samples =
-        100
-
-SUITE["continuous"]["add_union"]["agent_pos"] =
-    @benchmarkable add_agent_pos!($continuous_agent, cmodel) setup = (
-        cmodel = ABM(
-            Union{
-                ContinuousAgent,
-                ContinuousAgentTwo,
-                ContinuousAgentThree,
-                ContinuousAgentFour,
-                ContinuousAgentFive,
-            },
-            ContinuousSpace((10.0, 10.0, 10.0), spacing = 0.5);
-            warn = false,
-        )
-    ) samples = 100
-
-for x in range(0, stop = 9.99, length = 7)
-    for y in range(0, stop = 9.99, length = 7)
-        for z in range(0, stop = 9.99, length = 7)
+SUITE["continuous"]["add"]["agent_pos"] = @benchmarkable add_agent_pos!(
+    $continuous_agent, cmodel
+) setup = (cmodel = ABM(ContinuousAgent, ContinuousSpace((10.0, 10.0, 10.0); spacing=0.5))) samples =
+    100
+
+SUITE["continuous"]["add_union"]["agent_pos"] = @benchmarkable add_agent_pos!(
+    $continuous_agent, cmodel
+) setup = (
+    cmodel = ABM(
+        Union{
+            ContinuousAgent,
+            ContinuousAgentTwo,
+            ContinuousAgentThree,
+            ContinuousAgentFour,
+            ContinuousAgentFive,
+        },
+        ContinuousSpace((10.0, 10.0, 10.0); spacing=0.5);
+        warn=false,
+    )
+) samples = 100
+
+for x in range(0; stop=9.99, length=7)
+    for y in range(0; stop=9.99, length=7)
+        for z in range(0; stop=9.99, length=7)
             add_agent!((x, y, z), continuous_model, (0.8, 0.7, 1.3), 6.5, false)
         end
     end
@@ -214,22 +231,23 @@ a = continuous_model[139]
 pos = (7.07, 8.10, 6.58)
 SUITE["continuous"]["move"]["update"] = @benchmarkable move_agent!($a, $continuous_model)
 
-SUITE["continuous"]["neighbors"]["nearby_ids"] =
-    @benchmarkable nearby_ids($pos, $continuous_model, 5) setup =
-        (nearby_ids($pos, $continuous_model, 5))
-
-SUITE["continuous"]["neighbors"]["nearby_agents"] =
-    @benchmarkable nearby_ids($a, $continuous_model, 5) setup =
-        (nearby_ids($a, $continuous_model, 5))
-
-SUITE["continuous"]["neighbors"]["nearby_ids_iterate"] =
-    @benchmarkable iterate_over_neighbors($pos, $continuous_model, 10) setup =
-        (nearby_ids($pos, $continuous_model, 10))
-SUITE["continuous"]["neighbors"]["nearby_agents_iterate"] =
-    @benchmarkable iterate_over_neighbors($a, $continuous_model, 10) setup =
-        (nearby_ids($a, $continuous_model, 10))
-SUITE["continuous"]["neighbors"]["nearest"] =
-    @benchmarkable nearest_neighbor($a, $continuous_model, 5)
+SUITE["continuous"]["neighbors"]["nearby_ids"] = @benchmarkable nearby_ids(
+    $pos, $continuous_model, 5
+) setup = (nearby_ids($pos, $continuous_model, 5))
+
+SUITE["continuous"]["neighbors"]["nearby_agents"] = @benchmarkable nearby_ids(
+    $a, $continuous_model, 5
+) setup = (nearby_ids($a, $continuous_model, 5))
+
+SUITE["continuous"]["neighbors"]["nearby_ids_iterate"] = @benchmarkable iterate_over_neighbors(
+    $pos, $continuous_model, 10
+) setup = (nearby_ids($pos, $continuous_model, 10))
+SUITE["continuous"]["neighbors"]["nearby_agents_iterate"] = @benchmarkable iterate_over_neighbors(
+    $a, $continuous_model, 10
+) setup = (nearby_ids($a, $continuous_model, 10))
+SUITE["continuous"]["neighbors"]["nearest"] = @benchmarkable nearest_neighbor(
+    $a, $continuous_model, 5
+)
 
 # Benchmark takes too long to be reasonable, even with a small sample.
 # This needs to be looked at in the future, but it's being ignored for the moment
@@ -245,12 +263,15 @@ graph_df = init_agent_dataframe(graph_model, adata)
 grid_df = init_agent_dataframe(grid_model, adata)
 continuous_df = init_agent_dataframe(continuous_model, adata)
 
-SUITE["graph"]["collect"]["store_agent"] =
-    @benchmarkable collect_agent_data!($graph_df, $graph_model, $adata, 0)
-SUITE["grid"]["collect"]["store_agent"] =
-    @benchmarkable collect_agent_data!($grid_df, $grid_model, $adata, 0)
-SUITE["continuous"]["collect"]["store_agent"] =
-    @benchmarkable collect_agent_data!($continuous_df, $continuous_model, $adata, 0)
+SUITE["graph"]["collect"]["store_agent"] = @benchmarkable collect_agent_data!(
+    $graph_df, $graph_model, $adata, 0
+)
+SUITE["grid"]["collect"]["store_agent"] = @benchmarkable collect_agent_data!(
+    $grid_df, $grid_model, $adata, 0
+)
+SUITE["continuous"]["collect"]["store_agent"] = @benchmarkable collect_agent_data!(
+    $continuous_df, $continuous_model, $adata, 0
+)
 
 #### SCHEDULERS ###
 include("schedulers.jl")
diff --git a/benchmark/ensembles.jl b/benchmark/ensembles.jl
index 80ecc55469..84c0898568 100644
--- a/benchmark/ensembles.jl
+++ b/benchmark/ensembles.jl
@@ -15,31 +15,39 @@ function ensemble_benchmark(f, parallel, nreplicates)
     whensteps = 50
 
     function genmodels(nreplicates)
-        basemodels = [Models.schelling(; numagents)[1]
-                      for numagents in collect(numagents_low:numagents_high)]
+        basemodels = [
+            Models.schelling(; numagents)[1] for
+            numagents in collect(numagents_low:numagents_high)
+        ]
 
         return repeat(basemodels, nreplicates)
     end
 
     if f == ensemblerun!
         models = genmodels(nreplicates)
-        adf, mdf, _ = ensemblerun!(models, schelling_agent_step!, dummystep, nsteps;
-                                   parallel, adata = [:pos, :mood, :group],
-                                   showprogress = true,
-                                   when = (model, step) ->
-                                    ( (step) % whensteps == 0  ||  step == 0 ),
-                                   mdata = [:min_to_be_happy])
+        adf, mdf, _ = ensemblerun!(
+            models,
+            schelling_agent_step!,
+            dummystep,
+            nsteps;
+            parallel,
+            adata=[:pos, :mood, :group],
+            showprogress=true,
+            when=(model, step) -> ((step) % whensteps == 0 || step == 0),
+            mdata=[:min_to_be_happy],
+        )
     else
         # TODO: Why do we need `replicate_idx` here?
         # Can't we just use the `Models.schelling`?
         function initialize(;
-            replicate_idx = 1, numagents = 320, griddims = (20, 20), min_to_be_happy = 3
+            replicate_idx=1, numagents=320, griddims=(20, 20), min_to_be_happy=3
         )
-            space = GridSpace(griddims, periodic = false)
+            space = GridSpace(griddims; periodic=false)
             properties = Dict(:min_to_be_happy => min_to_be_happy)
 
-            model = ABM(SchellingAgent, space;
-                        properties = properties, scheduler = Schedulers.randomly)
+            model = ABM(
+                SchellingAgent, space; properties=properties, scheduler=Schedulers.randomly
+            )
 
             for n in 1:numagents
                 agent = SchellingAgent(n, (1, 1), false, n < numagents / 2 ? 1 : 2)
@@ -54,13 +62,17 @@ function ensemble_benchmark(f, parallel, nreplicates)
             :replicate_idx => collect(1:nreplicates),
             :griddims => (20, 20),
         )
-        paramscan(parameters, initialize;
-                  parallel, adata = [:pos, :mood, :group],
-                  mdata = [:min_to_be_happy], showprogress = true,
-                  agent_step! = schelling_agent_step!,
-                  when = (model, step) ->
-                   ( (step) % whensteps == 0  ||  step == 0 ),
-                  n = nsteps)
+        paramscan(
+            parameters,
+            initialize;
+            parallel,
+            adata=[:pos, :mood, :group],
+            mdata=[:min_to_be_happy],
+            showprogress=true,
+            (agent_step!)=schelling_agent_step!,
+            when=(model, step) -> ((step) % whensteps == 0 || step == 0),
+            n=nsteps,
+        )
     end
 end
 
@@ -72,7 +84,8 @@ for (f, parallel, nreplicates, name) in [
     (paramscan, false, 10, "paramscan serial 10 reps"),
     (paramscan, true, 10, "paramscan parallel 10 reps"),
     (paramscan, false, 20, "paramscan serial 20 reps"),
-    (paramscan, true, 20, "paramscan parallel 20 reps")
+    (paramscan, true, 20, "paramscan parallel 20 reps"),
 ]
-    ENSEMBLES_SUITE[name] = @benchmarkable ensemble_benchmark($f, $parallel, $nreplicates) samples = 1
+    ENSEMBLES_SUITE[name] = @benchmarkable ensemble_benchmark($f, $parallel, $nreplicates) samples =
+        1
 end
diff --git a/benchmark/schedulers.jl b/benchmark/schedulers.jl
index 92168cf5f2..5e3af7ee09 100644
--- a/benchmark/schedulers.jl
+++ b/benchmark/schedulers.jl
@@ -19,11 +19,11 @@ function fake_model(; nagents, scheduler)
     for i in 1:nagents
         add_agent!(model, i % 2, 0)
     end
-    model
+    return model
 end
 
 function fake_model_multi(; nagents, scheduler)
-    model = ABM(Union{FakeAgent,OtherFakeAgent}; scheduler, warn = false)
+    model = ABM(Union{FakeAgent,OtherFakeAgent}; scheduler, warn=false)
     for i in 1:nagents
         if i % 2 == 0
             add_agent!(FakeAgent(i, 0, 0), model)
@@ -31,7 +31,7 @@ function fake_model_multi(; nagents, scheduler)
             add_agent!(OtherFakeAgent(i, 1, 0), model)
         end
     end
-    model
+    return model
 end
 
 agent_step(agent, model) = agent.incr += 1
@@ -39,17 +39,26 @@ agent_step(agent, model) = agent.incr += 1
 SUITE["large_model"] = BenchmarkGroup()
 
 for (model, name) in [
-    (fake_model(; nagents = 800000, scheduler = Schedulers.fastest), "fastest"),
-    (fake_model(; nagents = 800000, scheduler = Schedulers.by_id), "by_id"),
-    (fake_model(; nagents = 800000, scheduler = Schedulers.ByID()), "ByID"),
-    (fake_model(; nagents = 800000, scheduler = Schedulers.randomly), "randomly"),
-    (fake_model(; nagents = 800000, scheduler = Schedulers.Randomly()), "Randomly"),
-    (fake_model(; nagents = 800000, scheduler = Schedulers.by_property(:group)), "by_property"),
-    (fake_model(; nagents = 800000, scheduler = Schedulers.ByProperty(:group)), "ByProperty"),
-    (fake_model(; nagents = 800000, scheduler = Schedulers.partially(0.7)), "partially"),
-    (fake_model(; nagents = 800000, scheduler = Schedulers.Partially(0.7)), "Partially"),
-    (fake_model_multi(; nagents = 800000, scheduler = Schedulers.by_type(true, true)), "by_type"),
-    (fake_model_multi(; nagents = 800000, scheduler = Schedulers.ByType(true, true, Union{FakeAgent,OtherFakeAgent})), "ByType")
+    (fake_model(; nagents=800000, scheduler=Schedulers.fastest), "fastest"),
+    (fake_model(; nagents=800000, scheduler=Schedulers.by_id), "by_id"),
+    (fake_model(; nagents=800000, scheduler=Schedulers.ByID()), "ByID"),
+    (fake_model(; nagents=800000, scheduler=Schedulers.randomly), "randomly"),
+    (fake_model(; nagents=800000, scheduler=Schedulers.Randomly()), "Randomly"),
+    (fake_model(; nagents=800000, scheduler=Schedulers.by_property(:group)), "by_property"),
+    (fake_model(; nagents=800000, scheduler=Schedulers.ByProperty(:group)), "ByProperty"),
+    (fake_model(; nagents=800000, scheduler=Schedulers.partially(0.7)), "partially"),
+    (fake_model(; nagents=800000, scheduler=Schedulers.Partially(0.7)), "Partially"),
+    (
+        fake_model_multi(; nagents=800000, scheduler=Schedulers.by_type(true, true)),
+        "by_type",
+    ),
+    (
+        fake_model_multi(;
+            nagents=800000,
+            scheduler=Schedulers.ByType(true, true, Union{FakeAgent,OtherFakeAgent}),
+        ),
+        "ByType",
+    ),
 ]
     SUITE["large_model"][name] = @benchmarkable step!($model, agent_step, dummystep)
 end
@@ -57,17 +66,23 @@ end
 SUITE["medium_model"] = BenchmarkGroup()
 
 for (model, name) in [
-    (fake_model(; nagents = 2000, scheduler = Schedulers.fastest), "fastest"),
-    (fake_model(; nagents = 2000, scheduler = Schedulers.by_id), "by_id"),
-    (fake_model(; nagents = 2000, scheduler = Schedulers.ByID()), "ByID"),
-    (fake_model(; nagents = 2000, scheduler = Schedulers.randomly), "randomly"),
-    (fake_model(; nagents = 2000, scheduler = Schedulers.Randomly()), "Randomly"),
-    (fake_model(; nagents = 2000, scheduler = Schedulers.by_property(:group)), "by_property"),
-    (fake_model(; nagents = 2000, scheduler = Schedulers.ByProperty(:group)), "ByProperty"),
-    (fake_model(; nagents = 2000, scheduler = Schedulers.partially(0.7)), "partially"),
-    (fake_model(; nagents = 2000, scheduler = Schedulers.Partially(0.7)), "Partially"),
-    (fake_model_multi(; nagents = 2000, scheduler = Schedulers.by_type(true, true)), "by_type"),
-    (fake_model_multi(; nagents = 2000, scheduler = Schedulers.ByType(true, true, Union{FakeAgent,OtherFakeAgent})), "ByType")
+    (fake_model(; nagents=2000, scheduler=Schedulers.fastest), "fastest"),
+    (fake_model(; nagents=2000, scheduler=Schedulers.by_id), "by_id"),
+    (fake_model(; nagents=2000, scheduler=Schedulers.ByID()), "ByID"),
+    (fake_model(; nagents=2000, scheduler=Schedulers.randomly), "randomly"),
+    (fake_model(; nagents=2000, scheduler=Schedulers.Randomly()), "Randomly"),
+    (fake_model(; nagents=2000, scheduler=Schedulers.by_property(:group)), "by_property"),
+    (fake_model(; nagents=2000, scheduler=Schedulers.ByProperty(:group)), "ByProperty"),
+    (fake_model(; nagents=2000, scheduler=Schedulers.partially(0.7)), "partially"),
+    (fake_model(; nagents=2000, scheduler=Schedulers.Partially(0.7)), "Partially"),
+    (fake_model_multi(; nagents=2000, scheduler=Schedulers.by_type(true, true)), "by_type"),
+    (
+        fake_model_multi(;
+            nagents=2000,
+            scheduler=Schedulers.ByType(true, true, Union{FakeAgent,OtherFakeAgent}),
+        ),
+        "ByType",
+    ),
 ]
     SUITE["medium_model"][name] = @benchmarkable step!($model, agent_step, dummystep)
 end
@@ -75,19 +90,25 @@ end
 SUITE["small_model"] = BenchmarkGroup()
 
 for (model, name) in [
-    (fake_model(; nagents = 50, scheduler = Schedulers.fastest), "fastest"),
-    (fake_model(; nagents = 50, scheduler = Schedulers.by_id), "by_id"),
-    (fake_model(; nagents = 50, scheduler = Schedulers.ByID()), "ByID"),
-    (fake_model(; nagents = 50, scheduler = Schedulers.randomly), "randomly"),
-    (fake_model(; nagents = 50, scheduler = Schedulers.Randomly()), "Randomly"),
-    (fake_model(; nagents = 50, scheduler = Schedulers.by_property(:group)), "by_property"),
-    (fake_model(; nagents = 50, scheduler = Schedulers.ByProperty(:group)), "ByProperty"),
-    (fake_model(; nagents = 50, scheduler = Schedulers.partially(0.7)), "partially"),
-    (fake_model(; nagents = 50, scheduler = Schedulers.Partially(0.7)), "Partially"),
-    (fake_model_multi(; nagents = 50, scheduler = Schedulers.by_type(true, true)), "by_type"),
-    (fake_model_multi(; nagents = 50, scheduler = Schedulers.ByType(true, true, Union{FakeAgent,OtherFakeAgent})), "ByType")
+    (fake_model(; nagents=50, scheduler=Schedulers.fastest), "fastest"),
+    (fake_model(; nagents=50, scheduler=Schedulers.by_id), "by_id"),
+    (fake_model(; nagents=50, scheduler=Schedulers.ByID()), "ByID"),
+    (fake_model(; nagents=50, scheduler=Schedulers.randomly), "randomly"),
+    (fake_model(; nagents=50, scheduler=Schedulers.Randomly()), "Randomly"),
+    (fake_model(; nagents=50, scheduler=Schedulers.by_property(:group)), "by_property"),
+    (fake_model(; nagents=50, scheduler=Schedulers.ByProperty(:group)), "ByProperty"),
+    (fake_model(; nagents=50, scheduler=Schedulers.partially(0.7)), "partially"),
+    (fake_model(; nagents=50, scheduler=Schedulers.Partially(0.7)), "Partially"),
+    (fake_model_multi(; nagents=50, scheduler=Schedulers.by_type(true, true)), "by_type"),
+    (
+        fake_model_multi(;
+            nagents=50,
+            scheduler=Schedulers.ByType(true, true, Union{FakeAgent,OtherFakeAgent}),
+        ),
+        "ByType",
+    ),
 ]
     SUITE["small_model"][name] = @benchmarkable step!($model, agent_step, dummystep)
 end
 
-results = run(SUITE, verbose = true, seconds = 5)
+results = run(SUITE; verbose=true, seconds=5)
diff --git a/benchmark/simple_grid/abusive_unkillable.jl b/benchmark/simple_grid/abusive_unkillable.jl
index bdf9a597ee..67b245817e 100644
--- a/benchmark/simple_grid/abusive_unkillable.jl
+++ b/benchmark/simple_grid/abusive_unkillable.jl
@@ -19,7 +19,7 @@ function initialize_abusiveunkillable()
     model = AbusiveUnkillableModel(AbusiveUnkillableAgent[], fill(0, grid_size...))
     N = floor(Int, grid_size[1] * grid_size[2] * grid_occupation * 0.5)
 
-    for i in 1:2N
+    for i in 1:(2N)
         grp = i <= N ? 1 : 2
         pos = (rand(1:grid_size[1]), rand(1:grid_size[2]))
         while model.space[pos...] > 0
@@ -67,7 +67,11 @@ end
 
 model_abusiveunkillable = initialize_abusiveunkillable()
 println("Benchmarking abusive unkillable version")
-@btime simulate_abusiveunkillable!($model_abusiveunkillable) setup = (model_abusiveunkillable = initialize_abusiveunkillable())
+@btime simulate_abusiveunkillable!($model_abusiveunkillable) setup = (
+    model_abusiveunkillable = initialize_abusiveunkillable()
+)
 println("Benchmarking abusive unkillable version: count nearby same")
 model_abusiveunkillable = initialize_abusiveunkillable()
-@btime count_nearby_same_abusiveunkillable(agent, model_abusiveunkillable) setup = (agent = rand(model_abusiveunkillable.agents))
+@btime count_nearby_same_abusiveunkillable(agent, model_abusiveunkillable) setup = (
+    agent = rand(model_abusiveunkillable.agents)
+)
diff --git a/benchmark/simple_grid/continuous_space_impact.jl b/benchmark/simple_grid/continuous_space_impact.jl
index d3f84cafce..7843633bf3 100644
--- a/benchmark/simple_grid/continuous_space_impact.jl
+++ b/benchmark/simple_grid/continuous_space_impact.jl
@@ -7,7 +7,7 @@ spacing = 0.1
 r = 0.1
 space = ContinuousSpace(extent, spacing)
 @agent Agent ContinuousAgent{2} begin end
-model = ABM(Agent, space; rng = StableRNG(42))
+model = ABM(Agent, space; rng=StableRNG(42))
 
 # fill with random agents
 N = 1000
@@ -47,7 +47,6 @@ Continuous space count nearby ids, spacing=0.05, r=0.1, exact
 Continuous space count nearby ids, spacing=0.1, r=0.1, exact
   4.843 μs (58 allocations: 5.22 KiB)
 
-
 # master
 Continuous space count nearby ids, spacing=0.05, r=0.1, inexact
   3.612 μs (71 allocations: 4.91 KiB)
@@ -58,4 +57,4 @@ Continuous space count nearby ids, spacing=0.1, r=0.1, inexact
   5.900 μs (118 allocations: 8.05 KiB)
 Continuous space count nearby ids, spacing=0.1, r=0.1, exact
   10.300 μs (218 allocations: 32.88 KiB)
-  =#
\ No newline at end of file
+  =#
diff --git a/benchmark/simple_grid/dict_based.jl b/benchmark/simple_grid/dict_based.jl
index 2d73d3cd6f..83e419c8f0 100644
--- a/benchmark/simple_grid/dict_based.jl
+++ b/benchmark/simple_grid/dict_based.jl
@@ -4,8 +4,8 @@ mutable struct DictAgent
 end
 
 function initialize_dict()
-    model = Dict{NTuple{2, Int}, DictAgent}()
-    N = grid_size[1]*grid_size[2]*grid_occupation
+    model = Dict{NTuple{2,Int},DictAgent}()
+    N = grid_size[1] * grid_size[2] * grid_occupation
     for n in 1:N
         group = n < N / 2 ? 1 : 2
         pos = (rand(1:grid_size[1]), rand(1:grid_size[2]))
@@ -49,4 +49,4 @@ end
 
 model_dict = initialize_dict()
 println("benchmarking dict-based step")
-@btime simulation_step!($model_dict) setup = (model_dict = initialize_dict())
\ No newline at end of file
+@btime simulation_step!($model_dict) setup = (model_dict = initialize_dict())
diff --git a/benchmark/simple_grid/gridspace_based.jl b/benchmark/simple_grid/gridspace_based.jl
index c0246bacf0..a1d0c519b1 100644
--- a/benchmark/simple_grid/gridspace_based.jl
+++ b/benchmark/simple_grid/gridspace_based.jl
@@ -1,16 +1,16 @@
 mutable struct GridSpaceAgent <: AbstractAgent
     id::Int
-    pos::NTuple{2, Int} # Notice that position type depends on space-to-be-used
+    pos::NTuple{2,Int} # Notice that position type depends on space-to-be-used
     group::Int
     happy::Bool
 end
 
 function initialize_gridspace()
-    space = GridSpace(grid_size; periodic = false)
+    space = GridSpace(grid_size; periodic=false)
     properties = Dict(:min_to_be_happy => min_to_be_happy)
     rng = Random.Xoshiro(rand(UInt))
     model = ABM(GridSpaceAgent, space; properties, rng)
-    N = grid_size[1]*grid_size[2]*grid_occupation
+    N = grid_size[1] * grid_size[2] * grid_occupation
     for n in 1:N
         group = n < N / 2 ? 1 : 2
         agent = GridSpaceAgent(n, (1, 1), group, false)
@@ -26,7 +26,7 @@ function agent_step_gridspace!(agent, model)
     else
         move_agent_single!(agent, model)
     end
-    return
+    return nothing
 end
 function count_nearby_same(agent, model)
     nearby_same = 0
@@ -47,12 +47,12 @@ println("Benchmarking GridSpace version: count nearby same")
 model = initialize_gridspace()
 @btime count_nearby_same(agent, model) setup = (agent = random_agent(model))
 
-function profile_nearby_same(model, agent = random_agent(model))
+function profile_nearby_same(model, agent=random_agent(model))
     x = 0
     N = 1000000
     for i in 1:N
         x += count_nearby_same(agent, model)
     end
-    return x/N
+    return x / N
 end
-# Then use @profview in VSCode
\ No newline at end of file
+# Then use @profview in VSCode
diff --git a/benchmark/simple_grid/run_comparison.jl b/benchmark/simple_grid/run_comparison.jl
index 55c30f6c32..0bcf74a1bf 100644
--- a/benchmark/simple_grid/run_comparison.jl
+++ b/benchmark/simple_grid/run_comparison.jl
@@ -4,13 +4,9 @@ Random.seed!(1234)
 const min_to_be_happy = 3 # how many nearby agents you need of same group
 const grid_occupation = 0.8 # percentage of space occupied by agents
 const grid_size = (30, 30)
-const moore = [
-    (1,0),  (1,1),  (1,-1),
-    (0,1),          (0,-1),
-    (-1,0), (-1,1), (-1,-1),
-]
+const moore = [(1, 0), (1, 1), (1, -1), (0, 1), (0, -1), (-1, 0), (-1, 1), (-1, -1)]
 
 include("dict_based.jl")
 include("gridspace_based.jl")
 include("simple_grid_space.jl")
-include("abusive_unkillable.jl")
\ No newline at end of file
+include("abusive_unkillable.jl")
diff --git a/benchmark/simple_grid/simple_grid_space.jl b/benchmark/simple_grid/simple_grid_space.jl
index 05b2a2120d..943a10a151 100644
--- a/benchmark/simple_grid/simple_grid_space.jl
+++ b/benchmark/simple_grid/simple_grid_space.jl
@@ -1,17 +1,17 @@
 mutable struct SoloGridSpaceAgent <: AbstractAgent
     id::Int
-    pos::NTuple{2, Int} # Notice that position type depends on space-to-be-used
+    pos::NTuple{2,Int} # Notice that position type depends on space-to-be-used
     group::Int
     happy::Bool
 end
 
 # Notice that these functions are fully identical with the GridSpace version.
 function initialize_sologridspace()
-    space = GridSpaceSingle(grid_size; periodic = false)
+    space = GridSpaceSingle(grid_size; periodic=false)
     properties = Dict(:min_to_be_happy => min_to_be_happy)
     rng = Random.Xoshiro(rand(UInt))
     model = ABM(SoloGridSpaceAgent, space; properties, rng)
-    N = grid_size[1]*grid_size[2]*grid_occupation
+    N = grid_size[1] * grid_size[2] * grid_occupation
     for n in 1:N
         group = n < N / 2 ? 1 : 2
         agent = SoloGridSpaceAgent(n, (1, 1), group, false)
@@ -27,7 +27,7 @@ function agent_step_sologridspace!(agent, model)
     else
         move_agent_single!(agent, model)
     end
-    return
+    return nothing
 end
 function count_nearby_same(agent, model)
     nearby_same = 0
@@ -41,7 +41,9 @@ end
 
 model_sologridspace = initialize_sologridspace()
 println("Benchmarking GridSpaceSingle version")
-@btime step!($model_sologridspace, agent_step_sologridspace!) setup = (model_sologridspace = initialize_sologridspace())
+@btime step!($model_sologridspace, agent_step_sologridspace!) setup = (
+    model_sologridspace = initialize_sologridspace()
+)
 
 println("Benchmarking GridSpaceSingle version: count nearby same")
 model = initialize_sologridspace()
diff --git a/docs/logo/logo.jl b/docs/logo/logo.jl
index 75fd96c404..457b947651 100644
--- a/docs/logo/logo.jl
+++ b/docs/logo/logo.jl
@@ -7,7 +7,7 @@ using InteractiveDynamics
 
 # Some nice colors:
 pink_green = Dict(:S => "#2b2b33", :I => "#a533d6", :R => "#338c54")
-pink_green_dark = Dict(:S => "#d068fc", :I =>  "#72cc94", :R => "#f0f0f0")
+pink_green_dark = Dict(:S => "#d068fc", :I => "#72cc94", :R => "#f0f0f0")
 juliadynamics = Dict(
     :S => JULIADYNAMICS_COLORS[3],
     :I => JULIADYNAMICS_COLORS[1],
@@ -30,11 +30,10 @@ Makie.renderstring!(
     font_matrix,
     "Agents.jl",
     font,
-    round(Int, logo_dims[2]/2),
-    round(Int, y/2 + logo_dims[2]/6) ,
-    round(Int, x/2),
-    halign = :hcenter,
-
+    round(Int, logo_dims[2] / 2),
+    round(Int, y / 2 + logo_dims[2] / 6),
+    round(Int, x / 2);
+    halign=:hcenter,
 )
 
 # Use this to test how the font looks like:
@@ -47,10 +46,10 @@ include("logo_model_def.jl")
 
 static_preplot!(ax, model) = hidedecorations!(ax)
 ax_kwargs = (;
-    leftspinecolor = BLACK,
-    rightspinecolor = BLACK,
-    topspinecolor = BLACK,
-    bottomspinecolor = BLACK,
+    leftspinecolor=BLACK,
+    rightspinecolor=BLACK,
+    topspinecolor=BLACK,
+    bottomspinecolor=BLACK,
     backgroundcolor,
     # ax.leftspinevisible = false,
     # ax.rightspinevisible = false,
@@ -59,33 +58,50 @@ ax_kwargs = (;
 )
 
 # Test:
-sir = sir_logo_initiation(; N = 400, interaction_radius = 0.035)
-fig, ax = abmplot(sir;
+sir = sir_logo_initiation(; N=400, interaction_radius=0.035)
+fig, ax = abmplot(
+    sir;
     # agent_step! = sir_agent_step!, model_step! = sir_model_step!,
-    enable_inspection = false,
-    ac = sir_colors, as = 9, static_preplot!,
-    figure = (resolution = logo_dims, ), axis = ax_kwargs,
+    enable_inspection=false,
+    ac=sir_colors,
+    as=9,
+    static_preplot!,
+    figure=(resolution=logo_dims,),
+    axis=ax_kwargs,
 )
 display(fig)
 
 # %% actually make the video
 using CairoMakie
 CairoMakie.activate!()
-sir = sir_logo_initiation(; N = 600, interaction_radius = 0.035)
-abmvideo("agents4_logo.gif", sir, sir_agent_step!, sir_model_step!;
-    ac = sir_colors, as = 9, static_preplot!,
-    figure = (resolution = logo_dims, backgroundcolor),
-    axis = ax_kwargs, showstep = false,
+sir = sir_logo_initiation(; N=600, interaction_radius=0.035)
+abmvideo(
+    "agents4_logo.gif",
+    sir,
+    sir_agent_step!,
+    sir_model_step!;
+    ac=sir_colors,
+    as=9,
+    static_preplot!,
+    figure=(resolution=logo_dims, backgroundcolor),
+    axis=ax_kwargs,
+    showstep=false,
     # For gif:
-    spf = 4, framerate = 30, frames = 450,
+    spf=4,
+    framerate=30,
+    frames=450,
     # For mp4:
     # spf = 2, framerate = 60, frames = 900,
 )
 
 # %% Save final figure for making the icon
-fig, ax = abmplot(sir;
-    enable_inspection = false,
-    ac = sir_colors, as = 9, static_preplot!,
-    figure = (resolution = logo_dims, backgroundcolor), axis = ax_kwargs,
+fig, ax = abmplot(
+    sir;
+    enable_inspection=false,
+    ac=sir_colors,
+    as=9,
+    static_preplot!,
+    figure=(resolution=logo_dims, backgroundcolor),
+    axis=ax_kwargs,
 )
 CairoMakie.save("agents_for_icon.png", fig)
diff --git a/docs/logo/logo_model_def.jl b/docs/logo/logo_model_def.jl
index b6a4625dd2..4d081927db 100644
--- a/docs/logo/logo_model_def.jl
+++ b/docs/logo/logo_model_def.jl
@@ -23,15 +23,15 @@ end
 
 function transmit!(a1, a2, rp, rng)
     ## for transmission, only 1 can have the disease (otherwise nothing happens)
-    count(a.status == :I for a in (a1, a2)) ≠ 1 && return
+    count(a.status == :I for a in (a1, a2)) ≠ 1 && return nothing
     infected, healthy = a1.status == :I ? (a1, a2) : (a2, a1)
 
-    rand(rng) > infected.β && return
+    rand(rng) > infected.β && return nothing
 
     if healthy.status == :R
-        rand(rng) > rp && return
+        rand(rng) > rp && return nothing
     end
-    healthy.status = :I
+    return healthy.status = :I
 end
 
 function sir_model_step!(model)
@@ -45,7 +45,7 @@ end
 function sir_agent_step!(agent, model)
     move_agent!(agent, model, model.dt)
     update!(agent)
-    recover_or_die!(agent, model)
+    return recover_or_die!(agent, model)
 end
 
 update!(agent) = agent.status == :I && (agent.days_infected += 1)
@@ -65,33 +65,25 @@ function recover_or_die!(agent, model)
 end
 
 function sir_logo_initiation(;
-        recovery_period = RECOVERY_PERIOD * steps_per_day,
-        reinfection_probability = REINFECT,
-        isolated = 0.0, # in percentage
-        interaction_radius = 0.014,
-        dt = 1.0,
-        speed = SPEED,
-        death_rate = 0.044, # from website of WHO
-        N = 1000, # Agents outside text
-        initial_infected = INITINFECT,
-        seed = SEED,
-        β = BETA,
-    )
+    recovery_period=RECOVERY_PERIOD * steps_per_day,
+    reinfection_probability=REINFECT,
+    isolated=0.0, # in percentage
+    interaction_radius=0.014,
+    dt=1.0,
+    speed=SPEED,
+    death_rate=0.044, # from website of WHO
+    N=1000, # Agents outside text
+    initial_infected=INITINFECT,
+    seed=SEED,
+    β=BETA,
+)
 
     # Sample agents inside text
     points = sample(findall(p -> p > 0.0, font_matrix), AGENTS_IN_TEXT)
     # Convert those into points that make sense within our continuous space (image coords must be y-inverted)
-    init_static = map(
-        p -> (p.I[2]/100, (logo_dims[2] - p.I[1])/100),
-        points,
-    )
+    init_static = map(p -> (p.I[2] / 100, (logo_dims[2] - p.I[1]) / 100), points)
 
-    properties = (;
-        reinfection_probability,
-        death_rate,
-        interaction_radius,
-        dt,
-    )
+    properties = (; reinfection_probability, death_rate, interaction_radius, dt)
     rng = Random.Xoshiro(seed)
     space = ContinuousSpace(logo_dims ./ 100)
     model = ABM(PoorSoul, space; rng, properties)
@@ -103,17 +95,17 @@ function sir_logo_initiation(;
         status = :S
         mass = Inf
         vel = (0.0, 0.0)
-        p = round(Int, recovery_period*(rand(rng)*0.4 + 0.8))
+        p = round(Int, recovery_period * (rand(rng) * 0.4 + 0.8))
         add_agent!(pos, model, vel, mass, 0, status, β, p)
     end
     #--------------------------------------
     ## Add initial individuals
     for ind in 1:N
-        status = ind ≤ N - initial_infected*N ? :S : :I
+        status = ind ≤ N - initial_infected * N ? :S : :I
         isisolated = ind ≤ isolated * N
         mass = isisolated ? Inf : 1.0
         vel = isisolated ? (0.0, 0.0) : sincos(2π * rand(rng)) .* speed
-        p = round(Int, recovery_period*(rand(rng)*0.4 + 0.8))
+        p = round(Int, recovery_period * (rand(rng) * 0.4 + 0.8))
         add_agent!(model, vel, mass, 0, status, β, p)
     end
     return model
diff --git a/docs/make.jl b/docs/make.jl
index 63c5433e0a..029f39a842 100644
--- a/docs/make.jl
+++ b/docs/make.jl
@@ -8,7 +8,7 @@ using Documenter
 println("Agents...")
 using Agents
 println("Literate...")
-import Literate
+using Literate: Literate
 println("InteractiveDynamics...")
 using InteractiveDynamics
 println("LightOSM...")
@@ -18,25 +18,25 @@ println("Converting Examples...")
 
 indir = joinpath(@__DIR__, "..", "examples")
 outdir = joinpath(@__DIR__, "src", "examples")
-rm(outdir; force = true, recursive = true) # cleans up previous examples
+rm(outdir; force=true, recursive=true) # cleans up previous examples
 mkpath(outdir)
 toskip = ()
 for file in readdir(indir)
     file ∈ toskip && continue
-    Literate.markdown(joinpath(indir, file), outdir; credit = false)
+    Literate.markdown(joinpath(indir, file), outdir; credit=false)
 end
 
 # Also bring in visualizations from interactive dynamics docs:
 using Literate
 infile = joinpath(pkgdir(InteractiveDynamics), "docs", "src", "agents.jl")
 outdir = joinpath(@__DIR__, "src")
-Literate.markdown(infile, outdir; credit = false, name = "agents_visualizations")
+Literate.markdown(infile, outdir; credit=false, name="agents_visualizations")
 
 # %%
 # download the themes
 println("Theme-ing")
-using DocumenterTools:Themes
-import Downloads
+using DocumenterTools: Themes
+using Downloads: Downloads
 for file in (
     "juliadynamics-lightdefs.scss",
     "juliadynamics-darkdefs.scss",
@@ -66,22 +66,22 @@ Themes.compile(
 # %%
 println("Documentation Build")
 ENV["JULIA_DEBUG"] = "Documenter"
-makedocs(
-    modules = [Agents, InteractiveDynamics, LightOSM],
-    sitename = "Agents.jl",
-    authors = "Tim DuBois, George Datseris, Aayush Sabharwal, Ali R. Vahdati and contributors.",
-    doctest = false,
-    format = Documenter.HTML(
-        prettyurls = CI,
-        assets = [
+makedocs(;
+    modules=[Agents, InteractiveDynamics, LightOSM],
+    sitename="Agents.jl",
+    authors="Tim DuBois, George Datseris, Aayush Sabharwal, Ali R. Vahdati and contributors.",
+    doctest=false,
+    format=Documenter.HTML(;
+        prettyurls=CI,
+        assets=[
             asset(
-                "https://fonts.googleapis.com/css?family=Montserrat|Source+Code+Pro&display=swap",
-                class = :css,
+                "https://fonts.googleapis.com/css?family=Montserrat|Source+Code+Pro&display=swap";
+                class=:css,
             ),
         ],
-        collapselevel = 1,
+        collapselevel=1,
     ),
-    pages = [
+    pages=[
         "Introduction" => "index.md",
         "Tutorial" => "tutorial.md",
         "Examples" => [
@@ -92,7 +92,7 @@ makedocs(
             "examples/predator_prey.md",
             "examples/rabbit_fox_hawk.md",
             "models.md",
-            "examples.md"
+            "examples.md",
         ],
         "api.md",
         "Plotting and Interactivity" => "agents_visualizations.md",
@@ -111,11 +111,11 @@ makedocs(
 
 @info "Deploying Documentation"
 if CI
-    deploydocs(
-        repo = "github.com/JuliaDynamics/Agents.jl.git",
-        target = "build",
-        push_preview = true,
-        devbranch = "main",
+    deploydocs(;
+        repo="github.com/JuliaDynamics/Agents.jl.git",
+        target="build",
+        push_preview=true,
+        devbranch="main",
     )
 end
 
diff --git a/docs/src/distances_example_plot.jl b/docs/src/distances_example_plot.jl
index 99324e5349..a65b4b1fc1 100644
--- a/docs/src/distances_example_plot.jl
+++ b/docs/src/distances_example_plot.jl
@@ -1,9 +1,9 @@
 using CairoMakie
-fig = Figure(resolution = (850, 300))
+fig = Figure(; resolution=(850, 300))
 
 function circle!(ax, r, color, distance)
     if distance == :euclidean
-        θ = 0:0.01:2π
+        θ = 0:0.01:(2π)
         lines!(ax, r .* cos.(θ), r .* sin.(θ); color)
     elseif distance == :chebyshev
         lines!(ax, [-r, -r], [-r, r]; color)
@@ -20,27 +20,27 @@ end
 
 function scatter_dots!(ax, r)
     r0 = ceil(r)
-    X = -r0:r0
+    X = (-r0):r0
     points = [Point2f(x, y) for x in X for y in X]
-    scatter!(ax, points; color = :black)
+    return scatter!(ax, points; color=:black)
 end
 
 rs = [1, 2, 3.4]
 colors = [:blue, :red, :orange]
 
 for (i, distance) in enumerate((:euclidean, :chebyshev, :manhattan))
-    ax = Axis(fig[1, i]; title = string(distance))
+    ax = Axis(fig[1, i]; title=string(distance))
     scatter_dots!(ax, maximum(rs))
     for (j, r) in enumerate(rs)
         label = j == i ? "r = $(r)" : ""
         circle!(ax, r, colors[j], distance)
     end
     ax.xticks = ax.yticks = -4:2:4
-    i > 1 && hideydecorations!(ax; grid = false)
+    i > 1 && hideydecorations!(ax; grid=false)
 end
 
-elems = [LineElement(color = c, linestyle = nothing) for c in colors]
+elems = [LineElement(; color=c, linestyle=nothing) for c in colors]
 
-fig[1, 4] = Legend(fig[1,4], elems, string.(rs), "radius", framevisible = false)
+fig[1, 4] = Legend(fig[1, 4], elems, string.(rs), "radius"; framevisible=false)
 
-fig
\ No newline at end of file
+fig
diff --git a/examples/celllistmap.jl b/examples/celllistmap.jl
index 55199b25fe..344a9591e6 100644
--- a/examples/celllistmap.jl
+++ b/examples/celllistmap.jl
@@ -81,7 +81,7 @@ function initialize_model(;
     sides=SVector(500.0, 500.0),
     dt=0.001,
     max_radius=10.0,
-    parallel=true
+    parallel=true,
 )
     ## initial random positions
     positions = [sides .* rand(SVector{2,Float64}) for _ in 1:number_of_particles]
@@ -93,7 +93,7 @@ function initialize_model(;
     space2d = ContinuousSpace(Tuple(sides); periodic=true)
 
     ## Initialize CellListMap periodic system
-    system = PeriodicSystem(
+    system = PeriodicSystem(;
         positions=positions,
         unitcell=sides,
         cutoff=2 * max_radius,
@@ -104,20 +104,13 @@ function initialize_model(;
 
     ## define the model properties
     ## The clmap_system field contains the data required for CellListMap.jl
-    properties = (
-        dt=dt,
-        number_of_particles=number_of_particles,
-        system=system,
-    )
-    model = ABM(Particle,
-        space2d,
-        properties=properties
-    )
+    properties = (dt=dt, number_of_particles=number_of_particles, system=system)
+    model = ABM(Particle, space2d; properties=properties)
 
     ## Create active agents
     for id in 1:number_of_particles
         add_agent_pos!(
-            Particle(
+            Particle(;
                 id=id,
                 r=(0.5 + 0.9 * rand()) * max_radius,
                 k=(10 + 20 * rand()), # random force constants
@@ -125,7 +118,8 @@ function initialize_model(;
                 pos=Tuple(positions[id]),
                 vel=(100 * randn(), 100 * randn()), # initial velocities
             ),
-            model)
+            model,
+        )
     end
 
     return model
@@ -200,11 +194,9 @@ end
 # Finally, the function below runs an example simulation, for 1000 steps.
 function simulate(model=nothing; nsteps=1_000, number_of_particles=10_000)
     if isnothing(model)
-        model = initialize_model(number_of_particles=number_of_particles)
+        model = initialize_model(; number_of_particles=number_of_particles)
     end
-    Agents.step!(
-        model, agent_step!, model_step!, nsteps, false,
-    )
+    return Agents.step!(model, agent_step!, model_step!, nsteps, false)
 end
 # Which should be quite fast
 model = initialize_model()
@@ -218,13 +210,18 @@ simulate(model) # compile
 using InteractiveDynamics
 using CairoMakie
 CairoMakie.activate!() # hide
-model = initialize_model(number_of_particles=1000)
+model = initialize_model(; number_of_particles=1000)
 abmvideo(
-    "celllistmap.mp4", model, agent_step!, model_step!;
-    framerate=20, frames=200, spf=5,
+    "celllistmap.mp4",
+    model,
+    agent_step!,
+    model_step!;
+    framerate=20,
+    frames=200,
+    spf=5,
     title="Bouncing particles with CellListMap.jl acceleration",
     as=p -> p.r, # marker size
-    ac=p -> p.k # marker color
+    ac=p -> p.k, # marker color
 )
 
 # ```@raw html
diff --git a/examples/diffeq.jl b/examples/diffeq.jl
index c696330a41..6a18699e2f 100644
--- a/examples/diffeq.jl
+++ b/examples/diffeq.jl
@@ -43,19 +43,22 @@ end
 
 function agent_step!(agent, model)
     ## Make sure we sample from the fish distribution
-    agent.yearly_catch = rand(model.rng, Poisson(agent.competence))
+    return agent.yearly_catch = rand(model.rng, Poisson(agent.competence))
 end
 
 function dstock(model)
     ## Only allow fishing if stocks are high enough
-    h = model.stock > model.min_threshold ? sum(a.yearly_catch for a in allagents(model)) :
+    h = if model.stock > model.min_threshold
+        sum(a.yearly_catch for a in allagents(model))
+    else
         0.0
+    end
 
-    model.stock * (1 - (model.stock / model.max_population)) - h
+    return model.stock * (1 - (model.stock / model.max_population)) - h
 end
 
 function model_step!(model)
-    model.stock += dstock(model)
+    return model.stock += dstock(model)
 end
 nothing #hide
 
@@ -71,14 +74,14 @@ nothing #hide
 # with some competence.
 
 function initialise(;
-    stock = 5.0, # Initial population of fish
-    max_population = 500.0, # Maximum value of fish stock
-    min_threshold = 60.0, # Regulate fishing if population drops below this value
-    nagents = 50,
+    stock=5.0, # Initial population of fish
+    max_population=500.0, # Maximum value of fish stock
+    min_threshold=60.0, # Regulate fishing if population drops below this value
+    nagents=50,
 )
     model = ABM(
         Fisher;
-        properties = Dict(
+        properties=Dict(
             :stock => stock,
             :max_population => max_population,
             :min_threshold => min_threshold,
@@ -93,7 +96,7 @@ function initialise(;
             0.0,
         )
     end
-    model
+    return model
 end
 nothing #hide
 
@@ -102,17 +105,11 @@ nothing #hide
 Random.seed!(6549) #hide
 
 model = initialise()
-_, results = run!(model, agent_step!, model_step!, 20; mdata = [:stock])
-
-f = Figure(resolution = (600, 400))
-ax =
-    f[1, 1] = Axis(
-        f,
-        xlabel = "Year",
-        ylabel = "Stock",
-        title = "Fishery Inventory",
-    )
-lines!(ax, results.stock, linewidth = 2, color = :blue)
+_, results = run!(model, agent_step!, model_step!, 20; mdata=[:stock])
+
+f = Figure(; resolution=(600, 400))
+ax = f[1, 1] = Axis(f; xlabel="Year", ylabel="Stock", title="Fishery Inventory")
+lines!(ax, results.stock; linewidth=2, color=:blue)
 f
 
 # ### Add in some bureaucracy
@@ -136,26 +133,29 @@ end
 function dstock(model)
     ## Only allow fishing if stocks are high enough
     ## (monitored yearly, so this will return 0 364 days of the year)
-    h = model.tick % 365 == 0 && model.stock > model.min_threshold ?
-        sum(a.yearly_catch for a in allagents(model)) : 0.0
+    h = if model.tick % 365 == 0 && model.stock > model.min_threshold
+        sum(a.yearly_catch for a in allagents(model))
+    else
+        0.0
+    end
 
-    model.stock * (1 - (model.stock / model.max_population)) - h
+    return model.stock * (1 - (model.stock / model.max_population)) - h
 end
 
 function model_step!(model)
     model.tick += 1
-    model.stock += dstock(model)
+    return model.stock += dstock(model)
 end
 
 function initialise(;
-    stock = 400.0, # Initial population of fish (lets move to an equilibrium position)
-    max_population = 500.0, # Maximum value of fish stock
-    min_threshold = 60.0, # Regulate fishing if population drops below this value
-    nagents = 50,
+    stock=400.0, # Initial population of fish (lets move to an equilibrium position)
+    max_population=500.0, # Maximum value of fish stock
+    min_threshold=60.0, # Regulate fishing if population drops below this value
+    nagents=50,
 )
     model = ABM(
         Fisher;
-        properties = Dict(
+        properties=Dict(
             :stock => stock,
             :max_population => max_population,
             :min_threshold => min_threshold,
@@ -165,7 +165,7 @@ function initialise(;
     for _ in 1:nagents
         add_agent!(model, floor(rand(model.rng, truncated(LogNormal(), 1, 6))), 0.0)
     end
-    model
+    return model
 end
 nothing #hide
 
@@ -175,18 +175,11 @@ nothing #hide
 Random.seed!(6549) #hide
 model = initialise()
 yearly(model, s) = s % 365 == 0
-_, results =
-    run!(model, agent_step!, model_step!, 20 * 365; mdata = [:stock], when = yearly)
-
-f = Figure(resolution = (600, 400))
-ax =
-    f[1, 1] = Axis(
-        f,
-        xlabel = "Year",
-        ylabel = "Stock",
-        title = "Fishery Inventory",
-    )
-lines!(ax, results.stock, linewidth = 2, color = :blue)
+_, results = run!(model, agent_step!, model_step!, 20 * 365; mdata=[:stock], when=yearly)
+
+f = Figure(; resolution=(600, 400))
+ax = f[1, 1] = Axis(f; xlabel="Year", ylabel="Stock", title="Fishery Inventory")
+lines!(ax, results.stock; linewidth=2, color=:blue)
 f
 
 # ### Baseline benchmark
@@ -196,8 +189,9 @@ f
 using BenchmarkTools
 
 Random.seed!(6549) #hide
-@btime Agents.step!(model, agent_step!, model_step!, 20 * 365) setup =
-    (model = initialise())
+@btime Agents.step!(model, agent_step!, model_step!, 20 * 365) setup = (
+    model = initialise()
+)
 
 # So this is fairly quick since the model is a simple one, but it's certainly not as efficient
 # as it could be.
@@ -214,19 +208,21 @@ Random.seed!(6549) #hide
 # Lets therefore modify our system to solve the logistic equation in a continuous context, but
 # discretely monitor and harvest.
 
-import OrdinaryDiffEq
+using OrdinaryDiffEq: OrdinaryDiffEq
 
 function agent_diffeq_step!(agent, model)
-    agent.yearly_catch = rand(model.rng, Poisson(agent.competence))
+    return agent.yearly_catch = rand(model.rng, Poisson(agent.competence))
 end
 
 function model_diffeq_step!(model)
     ## We step 364 days with this call.
     OrdinaryDiffEq.step!(model.i, 364.0, true)
     ## Only allow fishing if stocks are high enough
-    model.i.p[2] =
-        model.i.u[1] > model.min_threshold ? sum(a.yearly_catch for a in allagents(model)) :
+    model.i.p[2] = if model.i.u[1] > model.min_threshold
+        sum(a.yearly_catch for a in allagents(model))
+    else
         0.0
+    end
     ## Notify the integrator that conditions may be altered
     OrdinaryDiffEq.u_modified!(model.i, true)
     ## Then apply our catch modifier
@@ -235,27 +231,27 @@ function model_diffeq_step!(model)
     model.stock = model.i.u[1]
     ## And reset for the next year
     model.i.p[2] = 0.0
-    OrdinaryDiffEq.u_modified!(model.i, true)
+    return OrdinaryDiffEq.u_modified!(model.i, true)
 end
 
 function initialise_diffeq(;
-    stock = 400.0, # Initial population of fish (lets move to an equilibrium position)
-    max_population = 500.0, # Maximum value of fish stock
-    min_threshold = 60.0, # Regulate fishing if population drops below this value
-    nagents = 50,
+    stock=400.0, # Initial population of fish (lets move to an equilibrium position)
+    max_population=500.0, # Maximum value of fish stock
+    min_threshold=60.0, # Regulate fishing if population drops below this value
+    nagents=50,
 )
-
     function fish_stock!(ds, s, p, t)
         max_population, h = p
-        ds[1] = s[1] * (1 - (s[1] / max_population)) - h
+        return ds[1] = s[1] * (1 - (s[1] / max_population)) - h
     end
-    prob =
-        OrdinaryDiffEq.ODEProblem(fish_stock!, [stock], (0.0, Inf), [max_population, 0.0])
-    integrator = OrdinaryDiffEq.init(prob, OrdinaryDiffEq.Tsit5(); advance_to_tstop = true)
+    prob = OrdinaryDiffEq.ODEProblem(
+        fish_stock!, [stock], (0.0, Inf), [max_population, 0.0]
+    )
+    integrator = OrdinaryDiffEq.init(prob, OrdinaryDiffEq.Tsit5(); advance_to_tstop=true)
 
     model = ABM(
         Fisher;
-        properties = Dict(
+        properties=Dict(
             :stock => stock,
             :max_population => max_population,
             :min_threshold => min_threshold,
@@ -265,7 +261,7 @@ function initialise_diffeq(;
     for _ in 1:nagents
         add_agent!(model, floor(rand(model.rng, truncated(LogNormal(), 1, 6))), 0.0)
     end
-    model
+    return model
 end
 nothing #hide
 
@@ -289,24 +285,19 @@ nothing #hide
 
 Random.seed!(6549) #hide
 modeldeq = initialise_diffeq()
-_, resultsdeq = run!(modeldeq, agent_diffeq_step!, model_diffeq_step!, 20; mdata = [:stock])
-
-f = Figure(resolution = (600, 400))
-ax =
-    f[1, 1] = Axis(
-        f,
-        xlabel = "Year",
-        ylabel = "Stock",
-        title = "Fishery Inventory",
-    )
-lines!(ax, resultsdeq.stock, linewidth = 2, color = :blue)
+_, resultsdeq = run!(modeldeq, agent_diffeq_step!, model_diffeq_step!, 20; mdata=[:stock])
+
+f = Figure(; resolution=(600, 400))
+ax = f[1, 1] = Axis(f; xlabel="Year", ylabel="Stock", title="Fishery Inventory")
+lines!(ax, resultsdeq.stock; linewidth=2, color=:blue)
 f
 
 # The small complexity addition yields us a generous speed up of around 4.5x.
 
 Random.seed!(6549) #hide
-@btime Agents.step!(model, agent_diffeq_step!, model_diffeq_step!, 20) setup =
-    (model = initialise_diffeq())
+@btime Agents.step!(model, agent_diffeq_step!, model_diffeq_step!, 20) setup = (
+    model = initialise_diffeq()
+)
 
 # Digging into the results a little more, we can see that the `DifferentialEquations`
 # solver did not need to solve the logistic equation at every agent step to achieve
@@ -326,17 +317,11 @@ length(modeldeq.i.sol.t)
 # Compare our two results directly, both start with the same random seed and evolve in
 # precisely the same manner:
 
-f = Figure(resolution = (600, 400))
-ax =
-    f[1, 1] = Axis(
-        f,
-        xlabel = "Year",
-        ylabel = "Stock",
-        title = "Fishery Inventory",
-    )
-lineE = lines!(ax, results.stock, linewidth = 2, color = :blue)
-lineTS = lines!(ax, resultsdeq.stock, linewidth = 2, color = :red)
-leg = f[1, end+1] = Legend(f, [lineE, lineTS], ["Euler", "TSit5"])
+f = Figure(; resolution=(600, 400))
+ax = f[1, 1] = Axis(f; xlabel="Year", ylabel="Stock", title="Fishery Inventory")
+lineE = lines!(ax, results.stock; linewidth=2, color=:blue)
+lineTS = lines!(ax, resultsdeq.stock; linewidth=2, color=:red)
+leg = f[1, end + 1] = Legend(f, [lineE, lineTS], ["Euler", "TSit5"])
 f
 
 # That's an average discrepancy of 30 fish! Optimising the step size in the Euler method
@@ -357,16 +342,16 @@ f
 # to handle the agent based aspects of our problem.
 
 function agent_cb_step!(agent, model)
-    agent.yearly_catch = rand(model.rng, Poisson(agent.competence))
+    return agent.yearly_catch = rand(model.rng, Poisson(agent.competence))
 end
 
-function initialise_cb(; min_threshold = 60.0, nagents = 50)
-    model = ABM(Fisher; properties = Dict(:min_threshold => min_threshold))
+function initialise_cb(; min_threshold=60.0, nagents=50)
+    model = ABM(Fisher; properties=Dict(:min_threshold => min_threshold))
 
     for _ in 1:nagents
         add_agent!(model, floor(rand(model.rng, truncated(LogNormal(), 1, 6))), 0.0)
     end
-    model
+    return model
 end
 
 Random.seed!(759) #hide
@@ -374,17 +359,20 @@ modelcb = initialise_cb()
 
 # That's it for the `Agents` side of things! Now to build the ODE.
 
-import DiffEqCallbacks
+using DiffEqCallbacks: DiffEqCallbacks
 
 function fish!(integrator, model)
-    integrator.p[2] = integrator.u[1] > model.min_threshold ?
-        sum(a.yearly_catch for a in allagents(model)) : 0.0
-    Agents.step!(model, agent_cb_step!, 1)
+    integrator.p[2] = if integrator.u[1] > model.min_threshold
+        sum(a.yearly_catch for a in allagents(model))
+    else
+        0.0
+    end
+    return Agents.step!(model, agent_cb_step!, 1)
 end
 
 function fish_stock!(ds, s, p, t)
     max_population, h = p
-    ds[1] = s[1] * (1 - (s[1] / max_population)) - h
+    return ds[1] = s[1] * (1 - (s[1] / max_population)) - h
 end
 
 tspan = (0.0, 20.0 * 365.0)
@@ -399,20 +387,12 @@ fish = DiffEqCallbacks.PeriodicCallback(i -> fish!(i, modelcb), 364)
 reset = DiffEqCallbacks.PeriodicCallback(i -> i.p[2] = 0.0, 365)
 
 sol = OrdinaryDiffEq.solve(
-    prob,
-    OrdinaryDiffEq.Tsit5();
-    callback = OrdinaryDiffEq.CallbackSet(fish, reset),
+    prob, OrdinaryDiffEq.Tsit5(); callback=OrdinaryDiffEq.CallbackSet(fish, reset)
 )
-discrete = vcat(sol(0:365:(365 * 20))[:,:]...)
-f = Figure(resolution = (600, 400))
-ax =
-    f[1, 1] = Axis(
-        f,
-        xlabel = "Year",
-        ylabel = "Stock",
-        title = "Fishery Inventory",
-    )
-lines!(ax, discrete, linewidth = 2, color = :blue)
+discrete = vcat(sol(0:365:(365 * 20))[:, :]...)
+f = Figure(; resolution=(600, 400))
+ax = f[1, 1] = Axis(f; xlabel="Year", ylabel="Stock", title="Fishery Inventory")
+lines!(ax, discrete; linewidth=2, color=:blue)
 f
 
 # The results are different here, since the construction of this version and the one
@@ -420,4 +400,3 @@ f
 #
 # However, as you can see, it is for the most part just a re-arranged implementation
 # of the integrator method - giving users flexibility in their architecture choices.
-
diff --git a/examples/flock.jl b/examples/flock.jl
index 3d75b3cd98..e3be0ef999 100644
--- a/examples/flock.jl
+++ b/examples/flock.jl
@@ -46,20 +46,20 @@ end
 # The function `initialize_model` generates birds and returns
 # a model object using default values.
 function initialize_model(;
-    n_birds = 100,
-    speed = 1.0,
-    cohere_factor = 0.25,
-    separation = 4.0,
-    separate_factor = 0.25,
-    match_factor = 0.01,
-    visual_distance = 5.0,
-    extent = (100, 100),
-    seed = 42,
+    n_birds=100,
+    speed=1.0,
+    cohere_factor=0.25,
+    separation=4.0,
+    separate_factor=0.25,
+    match_factor=0.01,
+    visual_distance=5.0,
+    extent=(100, 100),
+    seed=42,
 )
-    space2d = ContinuousSpace(extent; spacing = visual_distance/1.5)
+    space2d = ContinuousSpace(extent; spacing=visual_distance / 1.5)
     rng = Random.MersenneTwister(seed)
 
-    model = ABM(Bird, space2d; rng, scheduler = Schedulers.Randomly())
+    model = ABM(Bird, space2d; rng, scheduler=Schedulers.Randomly())
     for _ in 1:n_birds
         vel = Tuple(rand(model.rng, 2) * 2 .- 1)
         add_agent!(
@@ -110,7 +110,7 @@ function agent_step!(bird, model)
     bird.vel = (bird.vel .+ cohere .+ separate .+ match) ./ 2
     bird.vel = bird.vel ./ norm(bird.vel)
     ## Move bird according to new velocity and speed
-    move_agent!(bird, model, bird.speed)
+    return move_agent!(bird, model, bird.speed)
 end
 
 # ## Plotting the flock
@@ -126,7 +126,7 @@ CairoMakie.activate!() # hide
 const bird_polygon = Polygon(Point2f[(-0.5, -0.5), (1, 0), (-0.5, 0.5)])
 function bird_marker(b::Bird)
     φ = atan(b.vel[2], b.vel[1]) #+ π/2 + π
-    scale(rotate2D(bird_polygon, φ), 2)
+    return scale(rotate2D(bird_polygon, φ), 2)
 end
 
 # Where we have used the utility functions `scale` and `rotate2D` to act on a
@@ -134,15 +134,18 @@ end
 # the `as` keyword is meaningless when using polygons as markers.
 
 model = initialize_model()
-figure, = abmplot(model; am = bird_marker)
+figure, = abmplot(model; am=bird_marker)
 figure
 
 # And let's also do a nice little video for it:
 abmvideo(
-    "flocking.mp4", model, agent_step!;
-    am = bird_marker,
-    framerate = 20, frames = 100,
-    title = "Flocking"
+    "flocking.mp4",
+    model,
+    agent_step!;
+    am=bird_marker,
+    framerate=20,
+    frames=100,
+    title="Flocking",
 )
 
 # ```@raw html
diff --git a/examples/measurements.jl b/examples/measurements.jl
index 42cc09b6c0..488778a1d9 100644
--- a/examples/measurements.jl
+++ b/examples/measurements.jl
@@ -37,7 +37,7 @@ end
 using CairoMakie
 using Statistics: mean
 import DrWatson: @dict
-import StatsBase
+using StatsBase: StatsBase
 CairoMakie.activate!() # hide
 using Random # hide
 
@@ -52,7 +52,7 @@ function update_surface_temperature!(pos::Dims{2}, model::DaisyWorld)
     end
     local_heating = absorbed_luminosity > 0 ? 72 * log(absorbed_luminosity) + 80 : 80
     T0 = model[ids[1]].temperature
-    model[ids[1]].temperature = (T0 + local_heating) / 2
+    return model[ids[1]].temperature = (T0 + local_heating) / 2
 end
 
 function diffuse_temperature!(pos::Dims{2}, model::DaisyWorld)
@@ -60,7 +60,7 @@ function diffuse_temperature!(pos::Dims{2}, model::DaisyWorld)
     ids = nearby_ids(pos, model)
     meantemp = sum(model[i].temperature for i in ids if model[i] isa Land) / 8
     land = model[ids_in_position(pos, model)[1]]
-    land.temperature = (1 - ratio) * land.temperature + ratio * meantemp
+    return land.temperature = (1 - ratio) * land.temperature + ratio * meantemp
 end
 
 function propagate!(pos::Dims{2}, model::DaisyWorld)
@@ -88,7 +88,7 @@ end
 
 function agent_step!(agent::Daisy, model::DaisyWorld)
     agent.age += 1
-    agent.age >= model.max_age && kill_agent!(agent, model)
+    return agent.age >= model.max_age && kill_agent!(agent, model)
 end
 
 agent_step!(agent::Land, model::DaisyWorld) = nothing
@@ -100,7 +100,7 @@ function model_step!(model)
         propagate!(p, model)
     end
     model.tick += 1
-    solar_activity!(model)
+    return solar_activity!(model)
 end
 
 function solar_activity!(model::DaisyWorld)
@@ -122,45 +122,40 @@ end
 # automatically through our model.
 
 function daisyworld(;
-    griddims = (30, 30),
-    max_age = 25,
-    init_white = 0.2,
-    init_black = 0.2,
-    albedo_white = 0.75,
-    albedo_black = 0.25,
+    griddims=(30, 30),
+    max_age=25,
+    init_white=0.2,
+    init_black=0.2,
+    albedo_white=0.75,
+    albedo_black=0.25,
     ## Surface albedo measurements are complicated for our satellites perhaps
-    surface_albedo = 0.4 ± 0.15,
+    surface_albedo=0.4 ± 0.15,
     ## Measurements from the sun are generally stable, but fluctuate around 10%
-    solar_change = 0.005 ± 0.002,
-    solar_luminosity = 1.0 ± 0.1,
-    scenario = :default,
+    solar_change=0.005 ± 0.002,
+    solar_luminosity=1.0 ± 0.1,
+    scenario=:default,
 )
-
     space = GridSpace(griddims)
     properties = @dict max_age surface_albedo solar_luminosity solar_change scenario
     properties[:tick] = 0
     daisysched(model) = [a.id for a in allagents(model) if a isa Daisy]
     model = ABM(
-        Union{Daisy,Land},
-        space;
-        scheduler = daisysched,
-        properties = properties,
-        warn = false,
+        Union{Daisy,Land}, space; scheduler=daisysched, properties=properties, warn=false
     )
 
     ## An uncertain initial temperature, solely for type stability
     fill_space!(Land, model, 0.0 ± 0.0)
     grid = collect(positions(model))
     num_positions = prod(griddims)
-    white_positions =
-        StatsBase.sample(grid, Int(init_white * num_positions); replace = false)
+    white_positions = StatsBase.sample(grid, Int(init_white * num_positions); replace=false)
     for wp in white_positions
         wd = Daisy(nextid(model), wp, :white, rand(model.rng, 0:max_age), albedo_white)
         add_agent_pos!(wd, model)
     end
     allowed = setdiff(grid, white_positions)
-    black_positions =
-        StatsBase.sample(allowed, Int(init_black * num_positions); replace = false)
+    black_positions = StatsBase.sample(
+        allowed, Int(init_black * num_positions); replace=false
+    )
     for bp in black_positions
         wd = Daisy(nextid(model), bp, :black, rand(model.rng, 0:max_age), albedo_black)
         add_agent_pos!(wd, model)
@@ -193,55 +188,54 @@ mdata = [:solar_luminosity]
 # And now the simulation
 
 Random.seed!(19) # hide
-model = daisyworld(scenario = :ramp)
-agent_df, model_df =
-    run!(model, agent_step!, model_step!, 1000; adata = adata, mdata = mdata)
-
-f = Figure(resolution = (600, 800))
-ax = f[1, 1] = Axis(f, ylabel = "Daisy count", title = "Daisyworld Analysis")
-lb = lines!(ax, agent_df.step, agent_df.count_black_daisies, linewidth = 2, color = :blue)
-lw = lines!(ax, agent_df.step, agent_df.count_white_daisies, linewidth = 2, color = :red)
+model = daisyworld(; scenario=:ramp)
+agent_df, model_df = run!(model, agent_step!, model_step!, 1000; adata=adata, mdata=mdata)
+
+f = Figure(; resolution=(600, 800))
+ax = f[1, 1] = Axis(f; ylabel="Daisy count", title="Daisyworld Analysis")
+lb = lines!(ax, agent_df.step, agent_df.count_black_daisies; linewidth=2, color=:blue)
+lw = lines!(ax, agent_df.step, agent_df.count_white_daisies; linewidth=2, color=:red)
 leg =
     f[1, 1] = Legend(
         f,
         [lb, lw],
-        ["black", "white"],
-        tellheight = false,
-        tellwidth = false,
-        halign = :right,
-        valign = :top,
-        margin = (10, 10, 10, 10),
+        ["black", "white"];
+        tellheight=false,
+        tellwidth=false,
+        halign=:right,
+        valign=:top,
+        margin=(10, 10, 10, 10),
     )
 
-ax2 = f[2, 1] = Axis(f, ylabel = "Temperature")
+ax2 = f[2, 1] = Axis(f; ylabel="Temperature")
 highband =
     Measurements.value.(agent_df[!, dataname(adata[3])]) +
     Measurements.uncertainty.(agent_df[!, dataname(adata[3])])
 lowband =
     Measurements.value.(agent_df[!, dataname(adata[3])]) -
     Measurements.uncertainty.(agent_df[!, dataname(adata[3])])
-band!(ax2, agent_df.step, lowband, highband, color = (:steelblue, 0.5))
+band!(ax2, agent_df.step, lowband, highband; color=(:steelblue, 0.5))
 lines!(
     ax2,
     agent_df.step,
-    Measurements.value.(agent_df[!, dataname(adata[3])]),
-    linewidth = 2,
-    color = :blue,
+    Measurements.value.(agent_df[!, dataname(adata[3])]);
+    linewidth=2,
+    color=:blue,
 )
 
-ax3 = f[3, 1] = Axis(f, ylabel = "Luminosity")
+ax3 = f[3, 1] = Axis(f; ylabel="Luminosity")
 highband =
     Measurements.value.(model_df.solar_luminosity) +
     Measurements.uncertainty.(model_df.solar_luminosity)
 lowband =
     Measurements.value.(model_df.solar_luminosity) -
     Measurements.uncertainty.(model_df.solar_luminosity)
-band!(ax3, agent_df.step, lowband, highband, color = (:steelblue, 0.5))
+band!(ax3, agent_df.step, lowband, highband; color=(:steelblue, 0.5))
 lines!(
     ax3,
     agent_df.step,
-    Measurements.value.(model_df.solar_luminosity),
-    linewidth = 2,
-    color = :blue,
+    Measurements.value.(model_df.solar_luminosity);
+    linewidth=2,
+    color=:blue,
 )
 f
diff --git a/examples/optim.jl b/examples/optim.jl
index bfb6c4f463..dfed6f770e 100644
--- a/examples/optim.jl
+++ b/examples/optim.jl
@@ -283,4 +283,3 @@
 # We now have a set of parameters to strive towards in the real world. Insights
 # such as these assist us to enact countermeasures like social distancing to mitigate
 # infection risks.
-
diff --git a/examples/predator_prey.jl b/examples/predator_prey.jl
index 2a446c25c5..50a018e4a8 100644
--- a/examples/predator_prey.jl
+++ b/examples/predator_prey.jl
@@ -67,37 +67,34 @@ end
 # directions.
 
 function initialize_model(;
-        n_sheep = 100,
-        n_wolves = 50,
-        dims = (20, 20),
-        regrowth_time = 30,
-        Δenergy_sheep = 4,
-        Δenergy_wolf = 20,
-        sheep_reproduce = 0.04,
-        wolf_reproduce = 0.05,
-        seed = 23182,
-    )
-
+    n_sheep=100,
+    n_wolves=50,
+    dims=(20, 20),
+    regrowth_time=30,
+    Δenergy_sheep=4,
+    Δenergy_wolf=20,
+    sheep_reproduce=0.04,
+    wolf_reproduce=0.05,
+    seed=23182,
+)
     rng = MersenneTwister(seed)
-    space = GridSpace(dims, periodic = true)
+    space = GridSpace(dims; periodic=true)
     ## Model properties contain the grass as two arrays: whether it is fully grown
     ## and the time to regrow. Also have static parameter `regrowth_time`.
     ## Notice how the properties are a `NamedTuple` to ensure type stability.
     properties = (
-        fully_grown = falses(dims),
-        countdown = zeros(Int, dims),
-        regrowth_time = regrowth_time,
+        fully_grown=falses(dims), countdown=zeros(Int, dims), regrowth_time=regrowth_time
     )
-    model = ABM(Union{Sheep, Wolf}, space;
-        properties, rng, scheduler = Schedulers.randomly, warn = false
+    model = ABM(
+        Union{Sheep,Wolf}, space; properties, rng, scheduler=Schedulers.randomly, warn=false
     )
     ## Add agents
     for _ in 1:n_sheep
-        energy = rand(model.rng, 1:(Δenergy_sheep*2)) - 1
+        energy = rand(model.rng, 1:(Δenergy_sheep * 2)) - 1
         add_agent!(Sheep, model, energy, sheep_reproduce, Δenergy_sheep)
     end
     for _ in 1:n_wolves
-        energy = rand(model.rng, 1:(Δenergy_wolf*2)) - 1
+        energy = rand(model.rng, 1:(Δenergy_wolf * 2)) - 1
         add_agent!(Wolf, model, energy, wolf_reproduce, Δenergy_wolf)
     end
     ## Add grass with random initial growth
@@ -126,7 +123,7 @@ function sheepwolf_step!(sheep::Sheep, model)
     sheep.energy -= 1
     if sheep.energy < 0
         kill_agent!(sheep, model)
-        return
+        return nothing
     end
     eat!(sheep, model)
     if rand(model.rng) ≤ sheep.reproduction_prob
@@ -139,7 +136,7 @@ function sheepwolf_step!(wolf::Wolf, model)
     wolf.energy -= 1
     if wolf.energy < 0
         kill_agent!(wolf, model)
-        return
+        return nothing
     end
     ## If there is any sheep on this grid cell, it's dinner time!
     dinner = first_sheep_in_position(wolf.pos, model)
@@ -152,11 +149,9 @@ end
 function first_sheep_in_position(pos, model)
     ids = ids_in_position(pos, model)
     j = findfirst(id -> model[id] isa Sheep, ids)
-    isnothing(j) ? nothing : model[ids[j]]::Sheep
+    return isnothing(j) ? nothing : model[ids[j]]::Sheep
 end
 
-
-
 # Sheep and wolves have separate `eat!` functions. If a sheep eats grass, it will acquire
 # additional energy and the grass will not be available for consumption until regrowth time
 # has elapsed. If a wolf eats a sheep, the sheep dies and the wolf acquires more energy.
@@ -165,13 +160,13 @@ function eat!(sheep::Sheep, model)
         sheep.energy += sheep.Δenergy
         model.fully_grown[sheep.pos...] = false
     end
-    return
+    return nothing
 end
 
 function eat!(wolf::Wolf, sheep::Sheep, model)
     kill_agent!(sheep, model)
     wolf.energy += wolf.Δenergy
-    return
+    return nothing
 end
 
 # Sheep and wolves share a common reproduction method. Reproduction has a cost of 1/2 the
@@ -182,7 +177,7 @@ function reproduce!(agent::A, model) where {A}
     id = nextid(model)
     offspring = A(id, agent.pos, agent.energy, agent.reproduction_prob, agent.Δenergy)
     add_agent_pos!(offspring, model)
-    return
+    return nothing
 end
 
 # The behavior of grass function differently. If it is fully grown, it is consumable.
@@ -211,32 +206,31 @@ CairoMakie.activate!() # hide
 
 # To view our starting population, we can build an overview plot using [`abmplot`](@ref).
 # We define the plotting details for the wolves and sheep:
-offset(a) = a isa Sheep ? (-0.1, -0.1*rand()) : (+0.1, +0.1*rand())
+offset(a) = a isa Sheep ? (-0.1, -0.1 * rand()) : (+0.1, +0.1 * rand())
 ashape(a) = a isa Sheep ? :circle : :utriangle
 acolor(a) = a isa Sheep ? RGBAf(1.0, 1.0, 1.0, 0.8) : RGBAf(0.2, 0.2, 0.3, 0.8)
 
 # and instruct [`abmplot`](@ref) how to plot grass as a heatmap:
 grasscolor(model) = model.countdown ./ model.regrowth_time
 # and finally define a colormap for the grass:
-heatkwargs = (colormap = [:brown, :green], colorrange = (0, 1))
+heatkwargs = (colormap=[:brown, :green], colorrange=(0, 1))
 
 # and put everything together and give it to [`abmplot`](@ref)
 plotkwargs = (;
-    ac = acolor,
-    as = 25,
-    am = ashape,
+    ac=acolor,
+    as=25,
+    am=ashape,
     offset,
-    scatterkwargs = (strokewidth = 1.0, strokecolor = :black),
-    heatarray = grasscolor,
-    heatkwargs = heatkwargs,
+    scatterkwargs=(strokewidth=1.0, strokecolor=:black),
+    heatarray=grasscolor,
+    heatkwargs=heatkwargs,
 )
 
 sheepwolfgrass = initialize_model()
 
-fig, ax, abmobs = abmplot(sheepwolfgrass;
-    agent_step! = sheepwolf_step!,
-    model_step! = grass_step!,
-plotkwargs...)
+fig, ax, abmobs = abmplot(
+    sheepwolfgrass; (agent_step!)=sheepwolf_step!, (model_step!)=grass_step!, plotkwargs...
+)
 fig
 
 # Now, lets run the simulation and collect some data. Define datacollection:
@@ -255,13 +249,13 @@ adf, mdf = run!(sheepwolfgrass, sheepwolf_step!, grass_step!, steps; adata, mdat
 # The few remaining sheep reproduce and gradually reach an
 # equilibrium that can be supported by the amount of available grass.
 function plot_population_timeseries(adf, mdf)
-    figure = Figure(resolution = (600, 400))
-    ax = figure[1, 1] = Axis(figure; xlabel = "Step", ylabel = "Population")
-    sheepl = lines!(ax, adf.step, adf.count_sheep, color = :cornsilk4)
-    wolfl = lines!(ax, adf.step, adf.count_wolf, color = RGBAf(0.2, 0.2, 0.3))
-    grassl = lines!(ax, mdf.step, mdf.count_grass, color = :green)
+    figure = Figure(; resolution=(600, 400))
+    ax = figure[1, 1] = Axis(figure; xlabel="Step", ylabel="Population")
+    sheepl = lines!(ax, adf.step, adf.count_sheep; color=:cornsilk4)
+    wolfl = lines!(ax, adf.step, adf.count_wolf; color=RGBAf(0.2, 0.2, 0.3))
+    grassl = lines!(ax, mdf.step, mdf.count_grass; color=:green)
     figure[1, 2] = Legend(figure, [sheepl, wolfl, grassl], ["Sheep", "Wolves", "Grass"])
-    figure
+    return figure
 end
 
 plot_population_timeseries(adf, mdf)
@@ -270,17 +264,17 @@ plot_population_timeseries(adf, mdf)
 # find an equilibrium
 # %% #src
 stable_params = (;
-    n_sheep = 140,
-    n_wolves = 20,
-    dims = (30, 30),
-    Δenergy_sheep = 5,
-    sheep_reproduce = 0.31,
-    wolf_reproduce = 0.06,
-    Δenergy_wolf = 30,
-    seed = 71758,
+    n_sheep=140,
+    n_wolves=20,
+    dims=(30, 30),
+    Δenergy_sheep=5,
+    sheep_reproduce=0.31,
+    wolf_reproduce=0.06,
+    Δenergy_wolf=30,
+    seed=71758,
 )
 
-sheepwolfgrass = initialize_model(;stable_params...)
+sheepwolfgrass = initialize_model(; stable_params...)
 adf, mdf = run!(sheepwolfgrass, sheepwolf_step!, grass_step!, 2000; adata, mdata)
 plot_population_timeseries(adf, mdf)
 
@@ -291,16 +285,16 @@ plot_population_timeseries(adf, mdf)
 
 # ## Video
 # Given that we have defined plotting functions, making a video is as simple as
-sheepwolfgrass = initialize_model(;stable_params...)
+sheepwolfgrass = initialize_model(; stable_params...)
 
 abmvideo(
     "sheepwolf.mp4",
     sheepwolfgrass,
     sheepwolf_step!,
     grass_step!;
-    frames = 100,
-    framerate = 8,
-    title = "Sheep Wolf Grass",
+    frames=100,
+    framerate=8,
+    title="Sheep Wolf Grass",
     plotkwargs...,
 )
 
diff --git a/examples/rabbit_fox_hawk.jl b/examples/rabbit_fox_hawk.jl
index cf516b341a..5f9c34cd5f 100644
--- a/examples/rabbit_fox_hawk.jl
+++ b/examples/rabbit_fox_hawk.jl
@@ -21,7 +21,7 @@
 # and reproduce. Eating food (grass or rabbits) replenishes `energy` by a fixed amount.
 using Agents, Agents.Pathfinding
 using Random
-import ImageMagick
+using ImageMagick: ImageMagick
 using FileIO: load
 
 @agent Animal ContinuousAgent{3} begin
@@ -56,29 +56,28 @@ eunorm(vec) = √sum(vec .^ 2)
 # with the specified heightmap and containing the specified number of rabbits, foxes and hawks.
 
 function initialize_model(
-    heightmap_url =
-    "https://raw.githubusercontent.com/JuliaDynamics/" *
-    "JuliaDynamics/master/videos/agents/rabbit_fox_hawk_heightmap.png",
-    water_level = 8,
-    grass_level = 20,
-    mountain_level = 35;
-    n_rabbits = 160,  ## initial number of rabbits
-    n_foxes = 30,  ## initial number of foxes
-    n_hawks = 30,  ## initial number of hawks
-    Δe_grass = 25,  ## energy gained from eating grass
-    Δe_rabbit = 30,  ## energy gained from eating one rabbit
-    rabbit_repr = 0.06,  ## probability for a rabbit to (asexually) reproduce at any step
-    fox_repr = 0.03,  ## probability for a fox to (asexually) reproduce at any step
-    hawk_repr = 0.02, ## probability for a hawk to (asexually) reproduce at any step
-    rabbit_vision = 6,  ## how far rabbits can see grass and spot predators
-    fox_vision = 10,  ## how far foxes can see rabbits to hunt
-    hawk_vision = 15,  ## how far hawks can see rabbits to hunt
-    rabbit_speed = 1.3, ## movement speed of rabbits
-    fox_speed = 1.1,  ## movement speed of foxes
-    hawk_speed = 1.2, ## movement speed of hawks
-    regrowth_chance = 0.03,  ## probability that a patch of grass regrows at any step
-    dt = 0.1,   ## discrete timestep each iteration of the model
-    seed = 42,  ## seed for random number generator
+    heightmap_url="https://raw.githubusercontent.com/JuliaDynamics/" *
+                  "JuliaDynamics/master/videos/agents/rabbit_fox_hawk_heightmap.png",
+    water_level=8,
+    grass_level=20,
+    mountain_level=35;
+    n_rabbits=160,  ## initial number of rabbits
+    n_foxes=30,  ## initial number of foxes
+    n_hawks=30,  ## initial number of hawks
+    Δe_grass=25,  ## energy gained from eating grass
+    Δe_rabbit=30,  ## energy gained from eating one rabbit
+    rabbit_repr=0.06,  ## probability for a rabbit to (asexually) reproduce at any step
+    fox_repr=0.03,  ## probability for a fox to (asexually) reproduce at any step
+    hawk_repr=0.02, ## probability for a hawk to (asexually) reproduce at any step
+    rabbit_vision=6,  ## how far rabbits can see grass and spot predators
+    fox_vision=10,  ## how far foxes can see rabbits to hunt
+    hawk_vision=15,  ## how far hawks can see rabbits to hunt
+    rabbit_speed=1.3, ## movement speed of rabbits
+    fox_speed=1.1,  ## movement speed of foxes
+    hawk_speed=1.2, ## movement speed of hawks
+    regrowth_chance=0.03,  ## probability that a patch of grass regrows at any step
+    dt=0.1,   ## discrete timestep each iteration of the model
+    seed=42,  ## seed for random number generator
 )
 
     ## Download and load the heightmap. The grayscale value is converted to `Float64` and
@@ -93,11 +92,11 @@ function initialize_model(
     for i in 1:dims[1], j in 1:dims[2]
         ## land animals can only walk on top of the terrain between water_level and grass_level
         if water_level < heightmap[i, j] < grass_level
-            land_walkmap[i, j, heightmap[i, j]+1] = true
+            land_walkmap[i, j, heightmap[i, j] + 1] = true
         end
         ## air animals can fly at any height upto mountain_level
         if heightmap[i, j] < mountain_level
-            air_walkmap[i, j, (heightmap[i, j]+1):mountain_level] .= true
+            air_walkmap[i, j, (heightmap[i, j] + 1):mountain_level] .= true
         end
     end
 
@@ -106,36 +105,37 @@ function initialize_model(
 
     ## Note that the dimensions of the space do not have to correspond to the dimensions
     ## of the pathfinder. Discretisation is handled by the pathfinding methods
-    space = ContinuousSpace((100., 100., 50.); periodic = false)
+    space = ContinuousSpace((100.0, 100.0, 50.0); periodic=false)
 
     ## Generate an array of random numbers, and threshold it by the probability of grass growing
     ## at that location. Although this causes grass to grow below `water_level`, it is
     ## effectively ignored by `land_walkmap`
     grass = BitArray(
-        rand(rng, dims[1:2]...) .< ((grass_level .- heightmap) ./ (grass_level - water_level)),
+        rand(rng, dims[1:2]...) .<
+        ((grass_level .- heightmap) ./ (grass_level - water_level)),
     )
     properties = (
         ## The pathfinder for rabbits and foxes
-        landfinder = AStar(space; walkmap = land_walkmap),
+        landfinder=AStar(space; walkmap=land_walkmap),
         ## The pathfinder for hawks
-        airfinder = AStar(space; walkmap = air_walkmap, cost_metric = MaxDistance{3}()),
-        Δe_grass = Δe_grass,
-        Δe_rabbit = Δe_rabbit,
-        rabbit_repr = rabbit_repr,
-        fox_repr = fox_repr,
-        hawk_repr = hawk_repr,
-        rabbit_vision = rabbit_vision,
-        fox_vision = fox_vision,
-        hawk_vision = hawk_vision,
-        rabbit_speed = rabbit_speed,
-        fox_speed = fox_speed,
-        hawk_speed = hawk_speed,
-        heightmap = heightmap,
-        grass = grass,
-        regrowth_chance = regrowth_chance,
-        water_level = water_level,
-        grass_level = grass_level,
-        dt = dt,
+        airfinder=AStar(space; walkmap=air_walkmap, cost_metric=MaxDistance{3}()),
+        Δe_grass=Δe_grass,
+        Δe_rabbit=Δe_rabbit,
+        rabbit_repr=rabbit_repr,
+        fox_repr=fox_repr,
+        hawk_repr=hawk_repr,
+        rabbit_vision=rabbit_vision,
+        fox_vision=fox_vision,
+        hawk_vision=hawk_vision,
+        rabbit_speed=rabbit_speed,
+        fox_speed=fox_speed,
+        hawk_speed=hawk_speed,
+        heightmap=heightmap,
+        grass=grass,
+        regrowth_chance=regrowth_chance,
+        water_level=water_level,
+        grass_level=grass_level,
+        dt=dt,
     )
 
     model = ABM(Animal, space; rng, properties)
@@ -145,9 +145,9 @@ function initialize_model(
         add_agent_pos!(
             Rabbit(
                 nextid(model), ## Using `nextid` prevents us from having to manually keep track
-                               ## of animal IDs
+                ## of animal IDs
                 random_walkable(model, model.landfinder),
-                rand(model.rng, Δe_grass:2Δe_grass),
+                rand(model.rng, Δe_grass:(2Δe_grass)),
             ),
             model,
         )
@@ -157,7 +157,7 @@ function initialize_model(
             Fox(
                 nextid(model),
                 random_walkable(model, model.landfinder),
-                rand(model.rng, Δe_rabbit:2Δe_rabbit),
+                rand(model.rng, Δe_rabbit:(2Δe_rabbit)),
             ),
             model,
         )
@@ -167,7 +167,7 @@ function initialize_model(
             Hawk(
                 nextid(model),
                 random_walkable(model, model.airfinder),
-                rand(model.rng, Δe_rabbit:2Δe_rabbit),
+                rand(model.rng, Δe_rabbit:(2Δe_rabbit)),
             ),
             model,
         )
@@ -216,38 +216,42 @@ function rabbit_step!(rabbit, model)
     ## All animals die if their energy reaches 0
     if rabbit.energy <= 0
         kill_agent!(rabbit, model, model.landfinder)
-        return
+        return nothing
     end
 
     ## Get a list of positions of all nearby predators
     predators = [
         x.pos for x in nearby_agents(rabbit, model, model.rabbit_vision) if
-            x.type == :fox || x.type == :hawk
-            ]
+        x.type == :fox || x.type == :hawk
+    ]
     ## If the rabbit sees a predator and isn't already moving somewhere
     if !isempty(predators) && is_stationary(rabbit, model.landfinder)
         ## Try and get an ideal direction away from predators
-        direction = (0., 0., 0.)
+        direction = (0.0, 0.0, 0.0)
         for predator in predators
             ## Get the direction away from the predator
             away_direction = (rabbit.pos .- predator)
             ## In case there is already a predator at our location, moving anywhere is
             ## moving away from it, so it doesn't contribute to `direction`
-            all(away_direction .≈ 0.) && continue
+            all(away_direction .≈ 0.0) && continue
             ## Add this to the overall direction, scaling inversely with distance.
             ## As a result, closer predators contribute more to the direction to move in
-            direction = direction .+ away_direction ./ eunorm(away_direction) ^ 2
+            direction = direction .+ away_direction ./ eunorm(away_direction)^2
         end
         ## If the only predator is right on top of the rabbit
-        if all(direction .≈ 0.)
+        if all(direction .≈ 0.0)
             ## Move anywhere
-            chosen_position = random_walkable(rabbit.pos, model, model.landfinder, model.rabbit_vision)
+            chosen_position = random_walkable(
+                rabbit.pos, model, model.landfinder, model.rabbit_vision
+            )
         else
             ## Normalize the resultant direction, and get the ideal position to move it
             direction = direction ./ eunorm(direction)
             ## Move to a random position in the general direction of away from predators
-            position = rabbit.pos .+ direction .* (model.rabbit_vision / 2.)
-            chosen_position = random_walkable(position, model, model.landfinder, model.rabbit_vision / 2.)
+            position = rabbit.pos .+ direction .* (model.rabbit_vision / 2.0)
+            chosen_position = random_walkable(
+                position, model, model.landfinder, model.rabbit_vision / 2.0
+            )
         end
         plan_route!(rabbit, chosen_position, model.landfinder)
     end
@@ -261,12 +265,12 @@ function rabbit_step!(rabbit, model)
         plan_route!(
             rabbit,
             random_walkable(rabbit.pos, model, model.landfinder, model.rabbit_vision),
-            model.landfinder
+            model.landfinder,
         )
     end
 
     ## Move along the route planned above
-    move_along_route!(rabbit, model, model.landfinder, model.rabbit_speed, model.dt)
+    return move_along_route!(rabbit, model, model.landfinder, model.rabbit_speed, model.dt)
 end
 
 # Foxes hunt for rabbits, and eat rabbits within a unit radius of its position.
@@ -279,14 +283,13 @@ function fox_step!(fox, model)
         fox.energy += model.Δe_rabbit
     end
 
-
     ## The energy cost at each step corresponds to the amount of time that has passed
     ## since the last step
     fox.energy -= model.dt
     ## All animals die once their energy reaches 0
     if fox.energy <= 0
         kill_agent!(fox, model, model.landfinder)
-        return
+        return nothing
     end
 
     ## Random chance to reproduce every step
@@ -309,7 +312,7 @@ function fox_step!(fox, model)
         end
     end
 
-    move_along_route!(fox, model, model.landfinder, model.fox_speed, model.dt)
+    return move_along_route!(fox, model, model.landfinder, model.fox_speed, model.dt)
 end
 
 # Hawks function similarly to foxes, except they can also fly. They dive down for prey and
@@ -323,7 +326,7 @@ function hawk_step!(hawk, model)
         kill_agent!(rand(model.rng, food), model, model.airfinder)
         hawk.energy += model.Δe_rabbit
         ## Fly back up
-        plan_route!(hawk, hawk.pos .+ (0., 0., 7.), model.airfinder)
+        plan_route!(hawk, hawk.pos .+ (0.0, 0.0, 7.0), model.airfinder)
     end
 
     ## The rest of the stepping function is similar to that of foxes, except hawks use a
@@ -331,13 +334,15 @@ function hawk_step!(hawk, model)
     hawk.energy -= model.dt
     if hawk.energy <= 0
         kill_agent!(hawk, model, model.airfinder)
-        return
+        return nothing
     end
 
     rand(model.rng) <= model.hawk_repr * model.dt && reproduce!(hawk, model)
 
     if is_stationary(hawk, model.airfinder)
-        prey = [x for x in nearby_agents(hawk, model, model.hawk_vision) if x.type == :rabbit]
+        prey = [
+            x for x in nearby_agents(hawk, model, model.hawk_vision) if x.type == :rabbit
+        ]
         if isempty(prey)
             plan_route!(
                 hawk,
@@ -349,7 +354,7 @@ function hawk_step!(hawk, model)
         end
     end
 
-    move_along_route!(hawk, model, model.airfinder, model.hawk_speed, model.dt)
+    return move_along_route!(hawk, model, model.airfinder, model.hawk_speed, model.dt)
 end
 
 # This function is called when an animal reproduces. The animal loses half its energy, and
@@ -357,7 +362,9 @@ end
 
 function reproduce!(animal, model)
     animal.energy = Float64(ceil(Int, animal.energy / 2))
-    add_agent_pos!(Animal(nextid(model), animal.pos, v0, animal.type, animal.energy), model)
+    return add_agent_pos!(
+        Animal(nextid(model), animal.pos, v0, animal.type, animal.energy), model
+    )
 end
 
 # The model stepping function simulates the growth of grass
@@ -371,7 +378,7 @@ function model_step!(model)
     )
     ## Grass regrows with a random probability, scaling with the amount of time passing
     ## each step of the model
-    growable .= rand(model.rng, length(growable)) .< model.regrowth_chance * model.dt
+    return growable .= rand(model.rng, length(growable)) .< model.regrowth_chance * model.dt
 end
 
 # ## Visualization
@@ -398,12 +405,12 @@ animalcolor(a) =
 # colormap. Since the heightmap dimensions don't correspond to the dimensions of the space,
 # we explicitly provide ranges to specify where the heightmap should be plotted.
 function static_preplot!(ax, model)
-    surface!(
+    return surface!(
         ax,
-        (100/205):(100/205):100,
-        (100/205):(100/205):100,
+        (100 / 205):(100 / 205):100,
+        (100 / 205):(100 / 205):100,
         model.heightmap;
-        colormap = :terrain
+        colormap=:terrain,
     )
 end
 
diff --git a/examples/schelling.jl b/examples/schelling.jl
index e6a7e26ee6..e7628f2033 100644
--- a/examples/schelling.jl
+++ b/examples/schelling.jl
@@ -31,7 +31,7 @@
 # ## Creating a space
 using Agents
 
-space = GridSpaceSingle((10, 10); periodic = false)
+space = GridSpaceSingle((10, 10); periodic=false)
 # Notice that by default the `GridSpaceSingle` has `metric = Chebyshev()`,
 # which is what we want.
 # Agents existing in this type of space must have a position field that is a
@@ -82,12 +82,7 @@ schelling = ABM(SchellingAgent, space; properties)
 # property `:group`, so that all agents of group 1 act first.
 # We would then use the scheduler [`Schedulers.ByProperty`](@ref) like so:
 
-schelling2 = ABM(
-    SchellingAgent,
-    space;
-    properties,
-    scheduler = Schedulers.ByProperty(:group),
-)
+schelling2 = ABM(SchellingAgent, space; properties, scheduler=Schedulers.ByProperty(:group))
 
 # Notice that `Schedulers.ByProperty` accepts an argument and returns a struct,
 # which is why we didn't just give `Schedulers.ByProperty` to `scheduler`.
@@ -112,7 +107,6 @@ nagents(schelling)
 # We can obtain the created and added agent, that got assigned the ID 2, like so
 agent = schelling[2]
 
-
 # ## Using an `UnkillableABM`
 
 # We know that the number of agents in the model never change.
@@ -141,13 +135,12 @@ schelling = UnkillableABM(SchellingAgent, space; properties)
 # it will be of further use in [`paramscan`](@ref) below.
 
 using Random # for reproducibility
-function initialize(; total_agents = 320, griddims = (20, 20), min_to_be_happy = 3, seed = 125)
-    space = GridSpaceSingle(griddims, periodic = false)
+function initialize(; total_agents=320, griddims=(20, 20), min_to_be_happy=3, seed=125)
+    space = GridSpaceSingle(griddims; periodic=false)
     properties = Dict(:min_to_be_happy => min_to_be_happy)
     rng = Random.Xoshiro(seed)
     model = UnkillableABM(
-        SchellingAgent, space;
-        properties, rng, scheduler = Schedulers.Randomly()
+        SchellingAgent, space; properties, rng, scheduler=Schedulers.Randomly()
     )
     ## populate the model with agents, adding equal amount of the two types of agents
     ## at random positions in the model
@@ -160,7 +153,6 @@ end
 
 model = initialize()
 
-
 # ## Defining a step function
 
 # Finally, we define a _step_ function to determine what happens to an
@@ -190,7 +182,7 @@ function agent_step!(agent, model)
         agent.mood = false
         move_agent_single!(agent, model)
     end
-    return
+    return nothing
 end
 
 # When defining `agent_step!`, we used some of the built-in functions of Agents.jl,
@@ -228,7 +220,7 @@ CairoMakie.activate!() # hide
 
 groupcolor(a) = a.group == 1 ? :blue : :orange
 groupmarker(a) = a.group == 1 ? :circle : :rect
-figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac=groupcolor, am=groupmarker, as=10)
 figure # returning the figure displays it
 
 # ## Animating the evolution
@@ -239,10 +231,15 @@ figure # returning the figure displays it
 
 model = initialize();
 abmvideo(
-    "schelling.mp4", model, agent_step!;
-    ac = groupcolor, am = groupmarker, as = 10,
-    framerate = 4, frames = 20,
-    title = "Schelling's segregation model"
+    "schelling.mp4",
+    model,
+    agent_step!;
+    ac=groupcolor,
+    am=groupmarker,
+    as=10,
+    framerate=4,
+    frames=20,
+    title="Schelling's segregation model",
 )
 
 # ```@raw html
@@ -299,7 +296,7 @@ parange = Dict(:min_to_be_happy => 0:8)
 adata = [(:mood, sum), (x, mean)]
 alabels = ["happy", "avg. x"]
 
-model = initialize(; total_agents = 300) # fresh model, noone happy
+model = initialize(; total_agents=300) # fresh model, noone happy
 
 # ```julia
 # using GLMakie # using a different plotting backend that enables interactive plots
@@ -330,10 +327,10 @@ model = initialize(; total_agents = 300) # fresh model, noone happy
 # First, let's create a model with 200 agents and run it for 40 iterations.
 @eval Main __atexample__named__schelling = $(@__MODULE__) # hide
 
-model = initialize(total_agents = 200, min_to_be_happy = 5, seed = 42)
+model = initialize(; total_agents=200, min_to_be_happy=5, seed=42)
 run!(model, agent_step!, 40)
 
-figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac=groupcolor, am=groupmarker, as=10)
 figure
 
 # Most of the agents have settled happily. Now, let's save the model.
@@ -341,11 +338,11 @@ AgentsIO.save_checkpoint("schelling.jld2", model)
 
 # Note that we can now leave the REPL, and come back later to run the model,
 # right from where we left off.
-model = AgentsIO.load_checkpoint("schelling.jld2"; scheduler = Schedulers.Randomly())
+model = AgentsIO.load_checkpoint("schelling.jld2"; scheduler=Schedulers.Randomly())
 
 # Since functions are not saved, the scheduler has to be passed while loading
 # the model. Let's now verify that we loaded back exactly what we saved.
-figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac=groupcolor, am=groupmarker, as=10)
 figure
 
 # For starters, let's see what happens if we add 100 more agents of group 1
@@ -355,19 +352,19 @@ for i in 1:100
 end
 
 # Let's see what our model looks like now.
-figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac=groupcolor, am=groupmarker, as=10)
 figure
 
 # And then run it for 40 iterations.
 run!(model, agent_step!, 40)
 
-figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac=groupcolor, am=groupmarker, as=10)
 figure
 
 # It looks like the agents eventually cluster again. What if the agents are of a new group?
 # We can start by loading the model back in from the file, thus resetting the
 # changes we made.
-model = AgentsIO.load_checkpoint("schelling.jld2"; scheduler = Schedulers.Randomly())
+model = AgentsIO.load_checkpoint("schelling.jld2"; scheduler=Schedulers.Randomly())
 
 for i in 1:100
     agent = SchellingAgent(nextid(model), (1, 1), false, 3)
@@ -379,13 +376,13 @@ end
 groupcolor(a) = (:blue, :orange, :green)[a.group]
 groupmarker(a) = (:circle, :rect, :cross)[a.group]
 
-figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac=groupcolor, am=groupmarker, as=10)
 figure
 
 # The new agents are scattered randomly, as expected. Now let's run the model.
 run!(model, agent_step!, 40)
 
-figure, _ = abmplot(model; ac = groupcolor, am = groupmarker, as = 10)
+figure, _ = abmplot(model; ac=groupcolor, am=groupmarker, as=10)
 figure
 
 # The new agents also form their own clusters, despite being completely scattered.
@@ -400,7 +397,7 @@ rm("schelling.jld2") # hide
 # To that end we use the [`ensemblerun!`](@ref) function.
 # The function accepts a `Vector` of ABMs, each (typically) initialized with a different
 # seed and/or agent distribution. For example we can do
-models = [initialize(seed = x) for x in rand(UInt8, 3)];
+models = [initialize(; seed=x) for x in rand(UInt8, 3)];
 
 # and then
 adf, = ensemblerun!(models, agent_step!, dummystep, 5; adata)
@@ -452,7 +449,7 @@ parameters = Dict(
     :griddims => (20, 20),            # not Vector = not expanded
 )
 
-adf, _ = paramscan(parameters, initialize; adata, agent_step!, n = 3)
+adf, _ = paramscan(parameters, initialize; adata, agent_step!, n=3)
 adf
 
 # We nicely see that the larger `:min_to_be_happy` is, the slower the convergence to
diff --git a/examples/schoolyard.jl b/examples/schoolyard.jl
index 8bd8aa1381..8ff4ada36e 100644
--- a/examples/schoolyard.jl
+++ b/examples/schoolyard.jl
@@ -47,24 +47,24 @@ const Student = ContinuousAgent{2}
 # ## Initialising the model
 
 function schoolyard(;
-    numStudents = 50,
-    teacher_attractor = 0.15,
-    noise = 0.1,
-    max_force = 1.7,
-    spacing = 4.0,
-    seed = 6998,
-    velocity = (0, 0),
+    numStudents=50,
+    teacher_attractor=0.15,
+    noise=0.1,
+    max_force=1.7,
+    spacing=4.0,
+    seed=6998,
+    velocity=(0, 0),
 )
     model = ABM(
         Student,
-        ContinuousSpace((100, 100), spacing; periodic = false);
-        properties = Dict(
+        ContinuousSpace((100, 100), spacing; periodic=false);
+        properties=Dict(
             :teacher_attractor => teacher_attractor,
             :noise => noise,
             :buddies => SimpleWeightedDiGraph(numStudents),
             :max_force => max_force,
         ),
-        rng = MersenneTwister(seed)
+        rng=MersenneTwister(seed),
     )
     for student in 1:numStudents
         ## Students begin near the school building
@@ -77,7 +77,7 @@ function schoolyard(;
         foe = rand(model.rng, filter(s -> s != student, 1:numStudents))
         add_edge!(model.buddies, student, foe, -rand(model.rng))
     end
-    model
+    return model
 end
 
 # Our model contains the `buddies` property, which is our Graphs.jl directed, weighted graph.
@@ -122,7 +122,7 @@ function agent_step!(student, model)
 
     ## Add all forces together to assign the students next position
     new_pos = student.pos .+ noise .+ teacher .+ network_force
-    move_agent!(student, new_pos, model)
+    return move_agent!(student, new_pos, model)
 end
 
 # Applying the rules for movement is relatively simple. For the network specifically,
@@ -145,15 +145,19 @@ using CairoMakie
 CairoMakie.activate!() # hide
 
 function static_preplot!(ax, model)
-    obj = CairoMakie.scatter!([50 50]; color = :red) # Show position of teacher
+    obj = CairoMakie.scatter!([50 50]; color=:red) # Show position of teacher
     CairoMakie.hidedecorations!(ax) # hide tick labels etc.
-    CairoMakie.translate!(obj, 0, 0, 5) # be sure that the teacher will be above students
+    return CairoMakie.translate!(obj, 0, 0, 5) # be sure that the teacher will be above students
 end
 
 abmvideo(
-    "schoolyard.mp4", model, agent_step!, dummystep;
-    framerate = 15, frames = 40,
-    title = "Playgound dynamics",
+    "schoolyard.mp4",
+    model,
+    agent_step!,
+    dummystep;
+    framerate=15,
+    frames=40,
+    title="Playgound dynamics",
     static_preplot!,
 )
 
diff --git a/examples/sir.jl b/examples/sir.jl
index 7a335b3547..b0d447e225 100644
--- a/examples/sir.jl
+++ b/examples/sir.jl
@@ -58,25 +58,24 @@ function model_initiation(;
     migration_rates,
     β_und,
     β_det,
-    infection_period = 30,
-    reinfection_probability = 0.05,
-    detection_time = 14,
-    death_rate = 0.02,
-    Is = [zeros(Int, length(Ns) - 1)..., 1],
-    seed = 0,
+    infection_period=30,
+    reinfection_probability=0.05,
+    detection_time=14,
+    death_rate=0.02,
+    Is=[zeros(Int, length(Ns) - 1)..., 1],
+    seed=0,
 )
-
     rng = Xoshiro(seed)
     @assert length(Ns) ==
-    length(Is) ==
-    length(β_und) ==
-    length(β_det) ==
-    size(migration_rates, 1) "length of Ns, Is, and B, and number of rows/columns in migration_rates should be the same "
+        length(Is) ==
+        length(β_und) ==
+        length(β_det) ==
+        size(migration_rates, 1) "length of Ns, Is, and B, and number of rows/columns in migration_rates should be the same "
     @assert size(migration_rates, 1) == size(migration_rates, 2) "migration_rates rates should be a square matrix"
 
     C = length(Ns)
     ## normalize migration_rates
-    migration_rates_sum = sum(migration_rates, dims = 2)
+    migration_rates_sum = sum(migration_rates; dims=2)
     for c in 1:C
         migration_rates[c, :] ./= migration_rates_sum[c]
     end
@@ -127,14 +126,13 @@ using LinearAlgebra: diagind
 function create_params(;
     C,
     max_travel_rate,
-    infection_period = 30,
-    reinfection_probability = 0.05,
-    detection_time = 14,
-    death_rate = 0.02,
-    Is = [zeros(Int, C - 1)..., 1],
-    seed = 19,
+    infection_period=30,
+    reinfection_probability=0.05,
+    detection_time=14,
+    death_rate=0.02,
+    Is=[zeros(Int, C - 1)..., 1],
+    seed=19,
 )
-
     Random.seed!(seed)
     Ns = rand(50:5000, C)
     β_und = rand(0.3:0.02:0.6, C)
@@ -166,7 +164,7 @@ function create_params(;
     return params
 end
 
-params = create_params(C = 8, max_travel_rate = 0.01)
+params = create_params(; C=8, max_travel_rate=0.01)
 model = model_initiation(; params...)
 
 # ## SIR Stepping functions
@@ -177,7 +175,7 @@ function agent_step!(agent, model)
     migrate!(agent, model)
     transmit!(agent, model)
     update!(agent, model)
-    recover_or_die!(agent, model)
+    return recover_or_die!(agent, model)
 end
 
 function migrate!(agent, model)
@@ -189,7 +187,7 @@ function migrate!(agent, model)
 end
 
 function transmit!(agent, model)
-    agent.status == :S && return
+    agent.status == :S && return nothing
     rate = if agent.days_infected < model.detection_time
         model.β_und[agent.pos]
     else
@@ -197,15 +195,15 @@ function transmit!(agent, model)
     end
 
     n = rate * abs(randn(model.rng))
-    n <= 0 && return
+    n <= 0 && return nothing
 
     for contactID in ids_in_position(agent, model)
         contact = model[contactID]
         if contact.status == :S ||
-           (contact.status == :R && rand(model.rng) ≤ model.reinfection_probability)
+            (contact.status == :R && rand(model.rng) ≤ model.reinfection_probability)
             contact.status = :I
             n -= 1
-            n <= 0 && return
+            n <= 0 && return nothing
         end
     end
 end
@@ -239,17 +237,18 @@ fracs = lift(infected_fractions, abmobs.model)
 color = lift(fs -> [cgrad(:inferno)[f] for f in fs], fracs)
 title = lift(
     (s, m) -> "step = $(s), infected = $(round(Int, 100infected_fraction(m, allids(m))))%",
-    abmobs.s, abmobs.model
+    abmobs.s,
+    abmobs.model,
 )
 
 # And lastly we use them to plot things in a figure
-fig = Figure(resolution = (600, 400))
-ax = Axis(fig[1, 1]; title, xlabel = "City", ylabel = "Population")
-barplot!(ax, model.Ns; strokecolor = :black, strokewidth = 1, color)
+fig = Figure(; resolution=(600, 400))
+ax = Axis(fig[1, 1]; title, xlabel="City", ylabel="Population")
+barplot!(ax, model.Ns; strokecolor=:black, strokewidth=1, color)
 fig
 
 # Now we can even make an animation of it
-record(fig, "covid_evolution.mp4"; framerate = 5) do io
+record(fig, "covid_evolution.mp4"; framerate=5) do io
     for j in 1:30
         recordframe!(io)
         Agents.step!(abmobs, 1)
@@ -278,7 +277,7 @@ nothing # hide
 model = model_initiation(; params...)
 
 to_collect = [(:status, f) for f in (infected, recovered, length)]
-data, _ = run!(model, agent_step!, 100; adata = to_collect)
+data, _ = run!(model, agent_step!, 100; adata=to_collect)
 data[1:10, :]
 
 # We now plot how quantities evolved in time to show
@@ -286,12 +285,12 @@ data[1:10, :]
 
 N = sum(model.Ns) # Total initial population
 x = data.step
-fig = Figure(resolution = (600, 400))
-ax = fig[1, 1] = Axis(fig, xlabel = "steps", ylabel = "log10(count)")
-li = lines!(ax, x, log10.(data[:, aggname(:status, infected)]), color = :blue)
-lr = lines!(ax, x, log10.(data[:, aggname(:status, recovered)]), color = :red)
+fig = Figure(; resolution=(600, 400))
+ax = fig[1, 1] = Axis(fig; xlabel="steps", ylabel="log10(count)")
+li = lines!(ax, x, log10.(data[:, aggname(:status, infected)]); color=:blue)
+lr = lines!(ax, x, log10.(data[:, aggname(:status, recovered)]); color=:red)
 dead = log10.(N .- data[:, aggname(:status, length)])
-ld = lines!(ax, x, dead, color = :green)
+ld = lines!(ax, x, dead; color=:green)
 Legend(fig[1, 2], [li, lr, ld], ["infected", "recovered", "dead"])
 fig
 
diff --git a/examples/zombies.jl b/examples/zombies.jl
index 3d394c8e84..78d707d0d0 100644
--- a/examples/zombies.jl
+++ b/examples/zombies.jl
@@ -38,14 +38,14 @@ end
 # Unfortunately one of the population has turned and will begin infecting anyone who
 # comes close.
 
-function initialise(; seed = 1234)
+function initialise(; seed=1234)
     map_path = OSM.test_map()
     properties = Dict(:dt => 1 / 60)
     model = ABM(
         Zombie,
         OpenStreetMapSpace(map_path);
-        properties = properties,
-        rng = Random.MersenneTwister(seed)
+        properties=properties,
+        rng=Random.MersenneTwister(seed),
     )
 
     for id in 1:100
@@ -53,7 +53,7 @@ function initialise(; seed = 1234)
         speed = rand(model.rng) * 5.0 + 2.0 # Random speed from 2-7kmph
         human = Zombie(id, start, false, speed)
         add_agent_pos!(human, model)
-        OSM.plan_random_route!(human, model; limit = 50) # try 50 times to find a random route
+        OSM.plan_random_route!(human, model; limit=50) # try 50 times to find a random route
     end
     ## We'll add patient zero at a specific (longitude, latitude)
     start = OSM.nearest_road((9.9351811, 51.5328328), model)
@@ -78,7 +78,7 @@ function agent_step!(agent, model)
 
     if is_stationary(agent, model) && rand(model.rng) < 0.1
         ## When stationary, give the agent a 10% chance of going somewhere else
-        OSM.plan_random_route!(agent, model; limit = 50)
+        OSM.plan_random_route!(agent, model; limit=50)
         ## Start on new route, moving the remaining distance
         move_along_route!(agent, model, distance_left)
     end
@@ -87,7 +87,7 @@ function agent_step!(agent, model)
         ## Agents will be infected if they get too close (within 10m) to a zombie.
         map(i -> model[i].infected = true, nearby_ids(agent, model, 0.01))
     end
-    return
+    return nothing
 end
 
 # ## Visualising the fall of humanity
@@ -98,8 +98,16 @@ ac(agent) = agent.infected ? :green : :black
 as(agent) = agent.infected ? 10 : 8
 model = initialise()
 
-abmvideo("outbreak.mp4", model, agent_step!;
-title = "Zombie outbreak", framerate = 15, frames = 200, as, ac)
+abmvideo(
+    "outbreak.mp4",
+    model,
+    agent_step!;
+    title="Zombie outbreak",
+    framerate=15,
+    frames=200,
+    as,
+    ac,
+)
 
 # ```@raw html
 # <video width="auto" controls autoplay loop>
diff --git a/src/Agents.jl b/src/Agents.jl
index 2af054d377..d1e270c285 100644
--- a/src/Agents.jl
+++ b/src/Agents.jl
@@ -6,9 +6,9 @@ using DataStructures
 using Graphs
 using DataFrames
 using Random
-import ProgressMeter
+using ProgressMeter: ProgressMeter
 import Base.length # TODO: This should not be imported!!!
-import LinearAlgebra
+using LinearAlgebra: LinearAlgebra
 
 # Core structures of Agents.jl
 include("core/agents.jl")
diff --git a/src/core/higher_order_iteration.jl b/src/core/higher_order_iteration.jl
index b1cf57663b..f4c94658a4 100644
--- a/src/core/higher_order_iteration.jl
+++ b/src/core/higher_order_iteration.jl
@@ -28,10 +28,12 @@ applied to remove unwanted matches from the results. **Note:** This option canno
 matrix order, so should be used in conjunction with [`index_mapped_groups`](@ref) to
 associate agent ids with the resultant data.
 """
-map_agent_groups(order::Int, f::Function, model::ABM; kwargs...) =
-    (f(idx) for idx in iter_agent_groups(order, model; kwargs...))
-map_agent_groups(order::Int, f::Function, model::ABM, filter::Function; kwargs...) =
-    (f(idx) for idx in iter_agent_groups(order, model; kwargs...) if filter(idx))
+function map_agent_groups(order::Int, f::Function, model::ABM; kwargs...)
+    return (f(idx) for idx in iter_agent_groups(order, model; kwargs...))
+end
+function map_agent_groups(order::Int, f::Function, model::ABM, filter::Function; kwargs...)
+    return (f(idx) for idx in iter_agent_groups(order, model; kwargs...) if filter(idx))
+end
 
 """
     index_mapped_groups(order::Int, model::ABM; scheduler = Schedulers.by_id)
diff --git a/src/core/model_abstract.jl b/src/core/model_abstract.jl
index 57ae98a9c7..03d02aad2c 100644
--- a/src/core/model_abstract.jl
+++ b/src/core/model_abstract.jl
@@ -227,7 +227,9 @@ function Base.getproperty(m::ABM, s::Symbol)
 end
 
 function Base.setproperty!(m::ABM, s::Symbol, x)
-    exception = ErrorException("Cannot set $(s) in this manner. Please use the `AgentBasedModel` constructor.")
+    exception = ErrorException(
+        "Cannot set $(s) in this manner. Please use the `AgentBasedModel` constructor."
+    )
     properties = getfield(m, :properties)
     properties === nothing && throw(exception)
     if properties isa Dict && haskey(properties, s)
diff --git a/src/core/model_concrete.jl b/src/core/model_concrete.jl
index 2c9423e131..78ee0a0825 100644
--- a/src/core/model_concrete.jl
+++ b/src/core/model_concrete.jl
@@ -4,7 +4,9 @@ using StaticArrays: SizedVector
 ContainerType{A} = Union{AbstractDict{Int,A},AbstractVector{A}}
 
 # And the three implementations here are just variants with different `C` type.
-struct SingleContainerABM{S<:SpaceType,A<:AbstractAgent,C<:ContainerType{A},F,P,R<:AbstractRNG} <: AgentBasedModel{S,A}
+struct SingleContainerABM{
+    S<:SpaceType,A<:AbstractAgent,C<:ContainerType{A},F,P,R<:AbstractRNG
+} <: AgentBasedModel{S,A}
     agents::C
     space::S
     scheduler::F
@@ -49,7 +51,9 @@ function SingleContainerABM(
     agent_validator(A, space, warn)
     C = construct_agent_container(container, A)
     agents = C()
-    return SingleContainerABM{S,A,C,F,P,R}(agents, space, scheduler, properties, rng, Ref(0))
+    return SingleContainerABM{S,A,C,F,P,R}(
+        agents, space, scheduler, properties, rng, Ref(0)
+    )
 end
 
 function SingleContainerABM(agent::AbstractAgent, args...; kwargs...)
@@ -71,7 +75,9 @@ as well as the default version of the generic [`AgentBasedModel`](@ref) construc
 `StandardABM` stores agents in a dictionary mapping unique `Int` IDs to agents.
 See also [`UnkillableABM`](@ref), [`FixedMassABM`](@ref).
 """
-StandardABM(args...; kwargs...) = SingleContainerABM(args...; kwargs..., container=Dict{Int})
+function StandardABM(args...; kwargs...)
+    return SingleContainerABM(args...; kwargs..., container=Dict{Int})
+end
 
 """
     UnkillableABM(AgentType [, space]; properties, kwargs...) → model
@@ -114,7 +120,9 @@ function FixedMassABM(
         i ≠ a.id && throw(ArgumentError("$(i)-th agent had ID $(a.id) instead of $i."))
     end
     agent_validator(A, space, warn)
-    return SingleContainerABM{S,A,C,F,P,R}(fixed_agents, space, scheduler, properties, rng, Ref(0))
+    return SingleContainerABM{S,A,C,F,P,R}(
+        fixed_agents, space, scheduler, properties, rng, Ref(0)
+    )
 end
 
 #######################################################################################
@@ -122,7 +130,9 @@ end
 #######################################################################################
 nextid(model::SingleContainerABM{<:SpaceType,A,Dict{Int,A}}) where {A} = getfield(model, :maxid)[] + 1
 nextid(model::SingleContainerABM{<:SpaceType,A,Vector{A}}) where {A} = nagents(model) + 1
-nextid(::SingleContainerABM{<:SpaceType,A,<:SizedVector}) where {A} = error("There is no `nextid` in a `FixedMassABM`. Most likely an internal error.")
+function nextid(::SingleContainerABM{<:SpaceType,A,<:SizedVector}) where {A}
+    return error("There is no `nextid` in a `FixedMassABM`. Most likely an internal error.")
+end
 
 function add_agent_to_model!(agent, model::SingleContainerABM{<:SpaceType,A,Dict{Int,A}}) where {A<:AbstractAgent}
     if haskey(agent_container(model), agent.id)
@@ -139,10 +149,14 @@ function add_agent_to_model!(agent, model::SingleContainerABM{<:SpaceType,A,Dict
     return
 end
 
-function add_agent_to_model!(agent, model::SingleContainerABM{<:SpaceType,A,Vector{A}}) where {A}
-    agent.id == nagents(model) + 1 || error("Cannot add agent of ID $(agent.id) in a vector ABM of $(nagents(model)) agents. Expected ID == $(nagents(model)+1).")
+function add_agent_to_model!(
+    agent, model::SingleContainerABM{<:SpaceType,A,Vector{A}}
+) where {A}
+    agent.id == nagents(model) + 1 || error(
+        "Cannot add agent of ID $(agent.id) in a vector ABM of $(nagents(model)) agents. Expected ID == $(nagents(model)+1).",
+    )
     push!(agent_container(model), agent)
-    return
+    return nothing
 end
 
 function remove_agent_from_model!(agent::A, model::SingleContainerABM{<:SpaceType,A,<:AbstractDict{Int,A}}) where {A<:AbstractAgent}
@@ -164,9 +178,7 @@ Validate the user supplied agent (subtype of `AbstractAgent`).
 Checks for mutability and existence and correct types for fields depending on `SpaceType`.
 """
 function agent_validator(
-    ::Type{A},
-    space::S,
-    warn::Bool,
+    ::Type{A}, space::S, warn::Bool
 ) where {A<:AbstractAgent,S<:SpaceType}
     # Check A for required properties & fields
     if isconcretetype(A)
@@ -206,16 +218,28 @@ function do_checks(::Type{A}, space::S, warn::Bool) where {A<:AbstractAgent,S<:S
         pos_type = fieldtype(A, :pos)
         space_type = typeof(space)
         if space_type <: GraphSpace && !(pos_type <: Integer)
-            throw(ArgumentError("`pos` field in agent type must be of type `Int` when using GraphSpace."))
+            throw(
+                ArgumentError(
+                    "`pos` field in agent type must be of type `Int` when using GraphSpace."
+                ),
+            )
         elseif space_type <: GridSpace && !(pos_type <: NTuple{D,Integer} where {D})
-            throw(ArgumentError("`pos` field in agent type must be of type `NTuple{Int}` when using GridSpace."))
+            throw(
+                ArgumentError(
+                    "`pos` field in agent type must be of type `NTuple{Int}` when using GridSpace.",
+                ),
+            )
         elseif space_type <: ContinuousSpace || space_type <: ContinuousSpace
             if !(pos_type <: NTuple{D,<:AbstractFloat} where {D})
-                throw(ArgumentError("`pos` field in agent type must be of type `NTuple{<:AbstractFloat}` when using ContinuousSpace."))
+                throw(
+                    ArgumentError(
+                        "`pos` field in agent type must be of type `NTuple{<:AbstractFloat}` when using ContinuousSpace.",
+                    ),
+                )
             end
             if warn &&
-               any(isequal(:vel), fieldnames(A)) &&
-               !(fieldtype(A, :vel) <: NTuple{D,<:AbstractFloat} where {D})
+                any(isequal(:vel), fieldnames(A)) &&
+                !(fieldtype(A, :vel) <: NTuple{D,<:AbstractFloat} where {D})
                 @warn "`vel` field in agent type should be of type `NTuple{<:AbstractFloat}` when using ContinuousSpace."
             end
         end
diff --git a/src/core/space_interaction_API.jl b/src/core/space_interaction_API.jl
index b599a63b75..28c2d311ac 100644
--- a/src/core/space_interaction_API.jl
+++ b/src/core/space_interaction_API.jl
@@ -90,11 +90,13 @@ nearby_positions(position, model, r=1) = notimplemented(model)
 #######################################################################################
 # %% OPTIONAL IMPLEMENT
 #######################################################################################
-plan_route!(agent, dest, model_or_pathfinder; kwargs...) =
-    notimplemented(model_or_pathfinder)
+function plan_route!(agent, dest, model_or_pathfinder; kwargs...)
+    return notimplemented(model_or_pathfinder)
+end
 
-plan_best_route!(agent, dests, model_or_pathfinder; kwargs...) =
-    notimplemented(model_or_pathfinder)
+function plan_best_route!(agent, dests, model_or_pathfinder; kwargs...)
+    return notimplemented(model_or_pathfinder)
+end
 
 # """
 #     move_along_route!(agent, model, args...; kwargs...)
@@ -121,7 +123,9 @@ Move agent to the given position, or to a random one if a position is not given.
 
 The agent's position is updated to match `pos` after the move.
 """
-function move_agent!(agent::A, pos::ValidPos, model::ABM{<:AbstractSpace,A}) where {A<:AbstractAgent}
+function move_agent!(
+    agent::A, pos::ValidPos, model::ABM{<:AbstractSpace,A}
+) where {A<:AbstractAgent}
     remove_agent_from_space!(agent, model)
     agent.pos = pos
     add_agent_to_space!(agent, model)
@@ -261,21 +265,14 @@ function add_agent!(A::Type{<:AbstractAgent}, model::ABM, properties...; kwargs.
 end
 
 function add_agent!(
-    pos::ValidPos,
-    model::ABM{S,A},
-    properties...;
-    kwargs...,
+    pos::ValidPos, model::ABM{S,A}, properties...; kwargs...
 ) where {S,A<:AbstractAgent}
     return add_agent!(pos, A, model, properties...; kwargs...)
 end
 
 # lowest level:
 function add_agent!(
-    pos::ValidPos,
-    A::Type{<:AbstractAgent},
-    model::ABM,
-    properties...;
-    kwargs...,
+    pos::ValidPos, A::Type{<:AbstractAgent}, model::ABM, properties...; kwargs...
 )
     id = nextid(model)
     newagent = A(id, pos, properties...; kwargs...)
@@ -334,7 +331,7 @@ function random_nearby_id(a, model, r=1; kwargs...)
     iter = nearby_ids(a, model, r; kwargs...)
 
     res = iterate(iter)
-    isnothing(res) && return    # `iterate` returns `nothing` when it ends
+    isnothing(res) && return nothing    # `iterate` returns `nothing` when it ends
 
     choice, state = res         # random ID to return, and the state of the iterator
     w = max(rand(model.rng), eps())  # rand returns in range [0,1)
@@ -367,6 +364,6 @@ The value of the argument `r` and possible keywords operate identically to [`nea
 """
 function random_nearby_agent(a, model, r=1; kwargs...)
     id = random_nearby_id(a, model, r; kwargs...)
-    isnothing(id) && return
+    isnothing(id) && return nothing
     return model[id]
 end
diff --git a/src/deprecations.jl b/src/deprecations.jl
index 89d8bd8f5d..d87895260a 100644
--- a/src/deprecations.jl
+++ b/src/deprecations.jl
@@ -32,7 +32,9 @@ Invoke a random walk by providing the `rand` function in place of
 
 This functionality is deprecated. Use [`randomwalk!`](@ref) instead.
 """
-function walk!(agent, ::typeof(rand), model::ABM{<:AbstractGridSpace{D}}; kwargs...) where {D}
+function walk!(
+    agent, ::typeof(rand), model::ABM{<:AbstractGridSpace{D}}; kwargs...
+) where {D}
     @warn "Producing random walks through `walk!` is deprecated. Use `randomwalk!` instead."
     return walk!(agent, Tuple(rand(model.rng, -1:1, D)), model; kwargs...)
 end
diff --git a/src/models/schelling.jl b/src/models/schelling.jl
index 27b3326005..cfdd6b50d2 100644
--- a/src/models/schelling.jl
+++ b/src/models/schelling.jl
@@ -26,7 +26,7 @@ function schelling(; numagents=320, griddims=(20, 20), min_to_be_happy=3)
 end
 
 function schelling_agent_step!(agent, model)
-    agent.mood == true && return # do nothing if already happy
+    agent.mood == true && return nothing # do nothing if already happy
     count_neighbors_same_group = 0
     for neighbor in nearby_agents(agent, model)
         if agent.group == neighbor.group
diff --git a/src/models/sir.jl b/src/models/sir.jl
index 5920aeabb4..58cf27a3ea 100644
--- a/src/models/sir.jl
+++ b/src/models/sir.jl
@@ -110,7 +110,7 @@ function sir_migrate!(agent, model)
 end
 
 function sir_transmit!(agent, model)
-    agent.status == :S && return
+    agent.status == :S && return nothing
     rate = if agent.days_infected < model.detection_time
         model.β_und[agent.pos]
     else
@@ -118,15 +118,15 @@ function sir_transmit!(agent, model)
     end
 
     n = rate * abs(randn(model.rng))
-    n <= 0 && return
+    n <= 0 && return nothing
 
     for contactID in ids_in_position(agent, model)
         contact = model[contactID]
         if contact.status == :S ||
-           (contact.status == :R && rand(model.rng) ≤ model.reinfection_probability)
+            (contact.status == :R && rand(model.rng) ≤ model.reinfection_probability)
             contact.status = :I
             n -= 1
-            n <= 0 && return
+            n <= 0 && return nothing
         end
     end
 end
diff --git a/src/models/zombies.jl b/src/models/zombies.jl
index 15a7b8eae7..7843303751 100644
--- a/src/models/zombies.jl
+++ b/src/models/zombies.jl
@@ -52,5 +52,5 @@ function zombie_agent_step!(agent, model)
         ## Agents will be infected if they get too close (within 10m) to a zombie.
         map(i -> model[i].infected = true, nearby_ids(agent, model, 0.01))
     end
-    return
+    return nothing
 end
diff --git a/src/simulations/collect.jl b/src/simulations/collect.jl
index 03da80d860..8422ef0f31 100644
--- a/src/simulations/collect.jl
+++ b/src/simulations/collect.jl
@@ -12,8 +12,9 @@ export run!,
 get_data(a, s::Symbol, obtainer::Function=identity) = obtainer(getproperty(a, s))
 get_data(a, f::Function, obtainer::Function=identity) = obtainer(f(a))
 
-get_data_missing(a, s::Symbol, obtainer::Function) =
-    hasproperty(a, s) ? obtainer(getproperty(a, s)) : missing
+function get_data_missing(a, s::Symbol, obtainer::Function)
+    return hasproperty(a, s) ? obtainer(getproperty(a, s)) : missing
+end
 function get_data_missing(a, f::Function, obtainer::Function)
     try
         obtainer(f(a))
@@ -182,8 +183,7 @@ is not known.
 collect_agent_data!(df, model, properties::Nothing, step::Int=0; kwargs...) = df
 
 function init_agent_dataframe(
-    model::ABM{S,A},
-    properties::AbstractArray,
+    model::ABM{S,A}, properties::AbstractArray
 ) where {S,A<:AbstractAgent}
     nagents(model) < 1 &&
         throw(ArgumentError("Model must have at least one agent to initialize data collection"))
@@ -196,7 +196,7 @@ function init_agent_dataframe(
     headers[2] = "id"
 
     for i in 1:length(properties)
-        headers[i+std_headers] = dataname(properties[i])
+        headers[i + std_headers] = dataname(properties[i])
     end
 
     types = Vector{Vector}(undef, std_headers + length(properties))
@@ -214,26 +214,21 @@ function init_agent_dataframe(
 end
 
 function single_agent_types!(
-    types::Vector{Vector{T} where T},
-    model::ABM,
-    properties::AbstractArray,
+    types::Vector{Vector{T} where T}, model::ABM, properties::AbstractArray
 )
     a = first(model.agents).second
     for (i, k) in enumerate(properties)
         current_type = typeof(get_data(a, k, identity))
         isconcretetype(current_type) || @warn(
             "Type is not concrete when using $(k) " *
-            "on agents. Consider narrowning the type signature of $(k).",
+                "on agents. Consider narrowning the type signature of $(k).",
         )
-        types[i+2] = current_type[]
+        types[i + 2] = current_type[]
     end
 end
 
 function multi_agent_types!(
-    types::Vector{Vector{T} where T},
-    utypes::Tuple,
-    model::ABM,
-    properties::AbstractArray,
+    types::Vector{Vector{T} where T}, utypes::Tuple, model::ABM, properties::AbstractArray
 )
     types[3] = Symbol[]
 
@@ -261,7 +256,7 @@ function multi_agent_types!(
             end
             isconcretetype(current_type) || @warn(
                 "Type is not concrete when using $(k) " *
-                "on $(atype) agents. Consider narrowing the type signature of $(k).",
+                    "on $(atype) agents. Consider narrowing the type signature of $(k).",
             )
             push!(current_types, current_type)
         end
@@ -269,9 +264,9 @@ function multi_agent_types!(
         if length(current_types) == 1
             current_types[1] <: Missing &&
                 error("$(k) does not yield a valid agent property.")
-            types[i+3] = current_types[1][]
+            types[i + 3] = current_types[1][]
         else
-            types[i+3] = Union{current_types...}[]
+            types[i + 3] = Union{current_types...}[]
         end
     end
 end
@@ -315,12 +310,13 @@ end
 
 # Aggregating version
 function init_agent_dataframe(
-    model::ABM{S,A},
-    properties::Vector{<:Tuple},
+    model::ABM{S,A}, properties::Vector{<:Tuple}
 ) where {S,A<:AbstractAgent}
-    nagents(model) < 1 && throw(ArgumentError(
-        "Model must have at least one agent to " * "initialize data collection",
-    ))
+    nagents(model) < 1 && throw(
+        ArgumentError(
+            "Model must have at least one agent to " * "initialize data collection"
+        ),
+    )
     headers = Vector{String}(undef, 1 + length(properties))
     types = Vector{Vector}(undef, 1 + length(properties))
 
@@ -345,16 +341,16 @@ function single_agent_agg_types!(
 )
     for (i, property) in enumerate(properties)
         k, agg = property
-        headers[i+1] = dataname(property)
+        headers[i + 1] = dataname(property)
         # This line assumes that `agg` can work with iterators directly
-        current_type = typeof(agg(
-            get_data(a, k, identity) for a in Iterators.take(allagents(model), 1)
-        ))
+        current_type = typeof(
+            agg(get_data(a, k, identity) for a in Iterators.take(allagents(model), 1))
+        )
         isconcretetype(current_type) || @warn(
             "Type is not concrete when using function $(agg) " *
-            "on key $(k). Consider using type annotation, e.g. $(agg)(a)::Float64 = ...",
+                "on key $(k). Consider using type annotation, e.g. $(agg)(a)::Float64 = ...",
         )
-        types[i+1] = current_type[]
+        types[i + 1] = current_type[]
     end
 end
 
@@ -367,7 +363,7 @@ function multi_agent_agg_types!(
 )
     for (i, property) in enumerate(properties)
         k, agg = property
-        headers[i+1] = dataname(property)
+        headers[i + 1] = dataname(property)
         current_types = DataType[]
         for atype in utypes
             a = try
@@ -388,14 +384,14 @@ function multi_agent_agg_types!(
             end
             isconcretetype(current_type) || @warn(
                 "Type is not concrete when using function $(agg) " *
-                "on key $(k) for $(atype) agents. Consider using type annotation, e.g. $(agg)(a)::Float64 = ...",
+                    "on key $(k) for $(atype) agents. Consider using type annotation, e.g. $(agg)(a)::Float64 = ...",
             )
             push!(current_types, current_type)
         end
         unique!(current_types)
         filter!(t -> !(t <: Missing), current_types) # Ignore missings here
         if length(current_types) == 1
-            types[i+1] = current_types[1][]
+            types[i + 1] = current_types[1][]
         elseif length(current_types) > 1
             error("Multiple types found for aggregate function $(agg) on key $(k).")
         else
@@ -411,15 +407,20 @@ Return the name of the column of the `i`-th collected data where `k = adata[i]`
 (or `mdata[i]`).
 `dataname` also accepts tuples with aggregate and conditional values.
 """
-dataname(x::Tuple) =
-    join(vcat([dataname(x[2]), dataname(x[1])], [dataname(s) for s in x[3:end]]), "_")
+function dataname(x::Tuple)
+    return join(
+        vcat([dataname(x[2]), dataname(x[1])], [dataname(s) for s in x[3:end]]), "_"
+    )
+end
 dataname(x::Union{Symbol,String}) = string(x)
 # This takes care to include fieldnames and values in the column name to make column names unique
 # if the same function is used with different values of outer scope variables.
-dataname(x::Function) = join(
-    vcat([string(x)], ["$(prop)=$(getproperty(x, prop))" for prop in propertynames(x)]),
-    "_",
-)
+function dataname(x::Function)
+    return join(
+        vcat([string(x)], ["$(prop)=$(getproperty(x, prop))" for prop in propertynames(x)]),
+        "_",
+    )
+end
 @deprecate aggname dataname
 @deprecate aggname(k, agg) dataname((k, agg))
 @deprecate aggname(k, agg, condition) dataname((k, agg, condition))
@@ -434,7 +435,7 @@ function collect_agent_data!(
     alla = allagents(model)
     push!(df[!, 1], step)
     for (i, prop) in enumerate(properties)
-        _add_col_data!(df[!, i+1], prop, alla; kwargs...)
+        _add_col_data!(df[!, i + 1], prop, alla; kwargs...)
     end
     return df
 end
@@ -473,13 +474,13 @@ function init_model_dataframe(model::ABM, properties::Vector)
     headers = Vector{String}(undef, 1 + length(properties))
     headers[1] = "step"
     for i in 1:length(properties)
-        headers[i+1] = dataname(properties[i])
+        headers[i + 1] = dataname(properties[i])
     end
 
     types = Vector{Vector}(undef, 1 + length(properties))
     types[1] = Int[]
     for (i, k) in enumerate(properties)
-        types[i+1] = if typeof(k) <: Symbol
+        types[i + 1] = if typeof(k) <: Symbol
             current_props = model.properties
             # How the properties are accessed depends on the type
             if typeof(current_props) <: Dict || typeof(current_props) <: Tuple
@@ -491,7 +492,7 @@ function init_model_dataframe(model::ABM, properties::Vector)
             current_type = typeof(k(model))
             isconcretetype(current_type) || @warn(
                 "Type is not concrete when using $(k)" *
-                "on the model. Considering narrowing the type signature of $(k).",
+                    "on the model. Considering narrowing the type signature of $(k).",
             )
             current_type[]
         end
@@ -499,8 +500,9 @@ function init_model_dataframe(model::ABM, properties::Vector)
     return DataFrame(types, headers)
 end
 
-init_model_dataframe(model::ABM, properties::Function) =
-    init_model_dataframe(model, properties(model))
+function init_model_dataframe(model::ABM, properties::Function)
+    return init_model_dataframe(model, properties(model))
+end
 
 init_model_dataframe(model::ABM, properties::Nothing) = DataFrame()
 
diff --git a/src/simulations/step.jl b/src/simulations/step.jl
index 5d4a419801..f0e403a6e8 100644
--- a/src/simulations/step.jl
+++ b/src/simulations/step.jl
@@ -42,7 +42,9 @@ dummystep(agent, model) = nothing
 until(s, n::Integer, model) = s < n
 until(s, n, model) = !n(model, s)
 
-step!(model::ABM, agent_step!, n::Integer=1, agents_first::Bool=true) = step!(model, agent_step!, dummystep, n, agents_first)
+function step!(model::ABM, agent_step!, n::Integer=1, agents_first::Bool=true)
+    return step!(model, agent_step!, dummystep, n, agents_first)
+end
 
 function step!(model::ABM, agent_step!, model_step!, n=1, agents_first=true)
     s = 0
diff --git a/src/spaces/continuous.jl b/src/spaces/continuous.jl
index 8e2b7a1ad0..91058765bb 100644
--- a/src/spaces/continuous.jl
+++ b/src/spaces/continuous.jl
@@ -107,8 +107,9 @@ function cell_center(pos::NTuple{D,<:AbstractFloat}, model) where {D}
     return (pos2cell(pos, model) .- 1) .* ε .+ ε / 2
 end
 
-distance_from_cell_center(pos, model::ABM) =
-    distance_from_cell_center(pos, cell_center(pos, model))
+function distance_from_cell_center(pos, model::ABM)
+    return distance_from_cell_center(pos, cell_center(pos, model))
+end
 function distance_from_cell_center(pos::Tuple, center::Tuple)
     return sqrt(sum(abs2.(pos .- center)))
 end
@@ -161,9 +162,7 @@ For non-periodic spaces, agents will walk up to, but not reach, the space extent
 For periodic spaces movement properly wraps around the extent.
 """
 function move_agent!(
-    agent::A,
-    model::ABM{<:ContinuousSpace,A},
-    dt::Real,
+    agent::A, model::ABM{<:ContinuousSpace,A}, dt::Real
 ) where {A<:AbstractAgent}
     model.space.update_vel!(agent, model)
     direction = dt .* agent.vel
@@ -412,9 +411,7 @@ function interacting_pairs(model::ABM{<:ContinuousSpace}, r::Real, method;
 end
 
 function all_pairs!(
-    pairs::Vector{Tuple{Int,Int}},
-    model::ABM{<:ContinuousSpace},
-    r::Real, nearby_f,
+    pairs::Vector{Tuple{Int,Int}}, model::ABM{<:ContinuousSpace}, r::Real, nearby_f
 )
     for a in allagents(model)
         for nid in nearby_f(a, model, r)
@@ -425,7 +422,9 @@ function all_pairs!(
     end
 end
 
-function true_pairs!(pairs::Vector{Tuple{Int,Int}}, model::ABM{<:ContinuousSpace}, r::Real, scheduler)
+function true_pairs!(
+    pairs::Vector{Tuple{Int,Int}}, model::ABM{<:ContinuousSpace}, r::Real, scheduler
+)
     distances = Vector{Float64}(undef, 0)
     for a in (model[id] for id in scheduler(model))
         nn = nearest_neighbor(a, model, r)
@@ -450,7 +449,8 @@ function true_pairs!(pairs::Vector{Tuple{Int,Int}}, model::ABM{<:ContinuousSpace
         end
     end
     to_remove = Int[]
-    for doubles in symdiff(unique(Iterators.flatten(pairs)), collect(Iterators.flatten(pairs)))
+    for doubles in
+        symdiff(unique(Iterators.flatten(pairs)), collect(Iterators.flatten(pairs)))
         # This list is the set of pairs that have two distances in the pair list.
         # The one with the largest distance value must be dropped.
         fidx = findfirst(isequal(doubles), first.(pairs))
@@ -472,7 +472,9 @@ end
 function type_pairs!(
     pairs::Vector{Tuple{Int,Int}},
     model::ABM{<:ContinuousSpace},
-    r::Real, scheduler, nearby_f,
+    r::Real,
+    scheduler,
+    nearby_f,
 )
     # We don't know ahead of time what types the scheduler will provide. Get a list.
     available_types = unique(typeof(model[id]) for id in scheduler(model))
diff --git a/src/spaces/discrete.jl b/src/spaces/discrete.jl
index e2204bfd04..a2c6f8e4e6 100644
--- a/src/spaces/discrete.jl
+++ b/src/spaces/discrete.jl
@@ -52,8 +52,9 @@ npositions(model::ABM) = npositions(model.space)
 Return the ids of agents in the position corresponding to `position` or position
 of `agent`.
 """
-ids_in_position(agent::A, model) where {A<:AbstractAgent} =
-    ids_in_position(agent.pos, model)
+function ids_in_position(agent::A, model) where {A<:AbstractAgent}
+    return ids_in_position(agent.pos, model)
+end
 
 """
     agents_in_position(position, model::ABM{<:DiscreteSpace})
@@ -61,8 +62,9 @@ ids_in_position(agent::A, model) where {A<:AbstractAgent} =
 
 Return the agents in the position corresponding to `position` or position of `agent`.
 """
-agents_in_position(agent::A, model) where {A<:AbstractAgent} =
-    agents_in_position(agent.pos, model)
+function agents_in_position(agent::A, model) where {A<:AbstractAgent}
+    return agents_in_position(agent.pos, model)
+end
 agents_in_position(pos, model) = (model[id] for id in ids_in_position(pos, model))
 
 """
@@ -161,14 +163,12 @@ applying `f` where `pos` is each position (tuple for grid, integer index for gra
 An optional first argument is an agent **type** to be created, and targets mixed agent
 models where the agent constructor cannot be deduced (since it is a union).
 """
-fill_space!(model::ABM{S,A}, args...; kwargs...) where {S,A<:AbstractAgent} =
-    fill_space!(A, model, args...; kwargs...)
+function fill_space!(model::ABM{S,A}, args...; kwargs...) where {S,A<:AbstractAgent}
+    return fill_space!(A, model, args...; kwargs...)
+end
 
 function fill_space!(
-    ::Type{A},
-    model::ABM{<:DiscreteSpace,U},
-    args...;
-    kwargs...,
+    ::Type{A}, model::ABM{<:DiscreteSpace,U}, args...; kwargs...
 ) where {A<:AbstractAgent,U<:AbstractAgent}
     for p in positions(model)
         id = nextid(model)
@@ -178,10 +178,7 @@ function fill_space!(
 end
 
 function fill_space!(
-    ::Type{A},
-    model::ABM{<:DiscreteSpace,U},
-    f::Function;
-    kwargs...,
+    ::Type{A}, model::ABM{<:DiscreteSpace,U}, f::Function; kwargs...
 ) where {A<:AbstractAgent,U<:AbstractAgent}
     for p in positions(model)
         id = nextid(model)
diff --git a/src/spaces/graph.jl b/src/spaces/graph.jl
index cf2038abe2..2530dd097d 100644
--- a/src/spaces/graph.jl
+++ b/src/spaces/graph.jl
@@ -198,7 +198,9 @@ Returns a boolean, true if the operation was successful.
 
 `args` and `kwargs` are directly passed to the `add_edge!` dispatch that acts the underlying graph type.
 """
-Graphs.add_edge!(model::ABM{<:GraphSpace}, args...; kwargs...) = add_edge!(model.space.graph, args...; kwargs...)
+function Graphs.add_edge!(model::ABM{<:GraphSpace}, args...; kwargs...)
+    return add_edge!(model.space.graph, args...; kwargs...)
+end
 
 """
     rem_edge!(model::ABM{<:GraphSpace}, n, m)
diff --git a/src/spaces/grid_general.jl b/src/spaces/grid_general.jl
index 63ae944733..1156fcd038 100644
--- a/src/spaces/grid_general.jl
+++ b/src/spaces/grid_general.jl
@@ -86,7 +86,7 @@ end
 
 # Make grid space Abstract if indeed faster
 function calculate_offsets(space::AbstractGridSpace{D}, r::Int) where {D}
-    hypercube = Iterators.product(repeat([-r:r], D)...)
+    hypercube = Iterators.product(repeat([(-r):r], D)...)
     if space.metric == :euclidean
         # select subset which is in Hypersphere
         βs = [β for β in hypercube if sum(β .^ 2) ≤ r^2]
@@ -105,8 +105,9 @@ function random_position(model::ABM{<:AbstractGridSpace})
     return Tuple(rand(model.rng, CartesianIndices(model.space.stored_ids)))
 end
 
-offsets_within_radius_no_0(model::ABM, r::Real) =
-    offsets_within_radius_no_0(model.space, r::Real)
+function offsets_within_radius_no_0(model::ABM, r::Real)
+    return offsets_within_radius_no_0(model.space, r::Real)
+end
 function offsets_within_radius_no_0(
     space::AbstractGridSpace{D}, r::Real)::Vector{NTuple{D,Int}} where {D}
     r₀ = floor(Int, r)
diff --git a/src/spaces/grid_single.jl b/src/spaces/grid_single.jl
index f1b82d17c4..88ee8aa96d 100644
--- a/src/spaces/grid_single.jl
+++ b/src/spaces/grid_single.jl
@@ -29,7 +29,9 @@ All arguments and keywords behave exactly as in [`GridSpace`](@ref).
 """
 function GridSpaceSingle(d::NTuple{D,Int}; periodic=true, metric=:chebyshev) where {D}
     s = zeros(Int, d)
-    return GridSpaceSingle{D,periodic}(s, metric,
+    return GridSpaceSingle{D,periodic}(
+        s,
+        metric,
         Dict{Int,Vector{NTuple{D,Int}}}(),
         Dict{Int,Vector{NTuple{D,Int}}}(),
         Dict{Int,Vector{NTuple{D,Int}}}(),
@@ -43,7 +45,9 @@ function add_agent_to_space!(a::A, model::ABM{<:GridSpaceSingle,A}) where {A<:Ab
     return a
 end
 
-function remove_agent_from_space!(a::A, model::ABM{<:GridSpaceSingle,A}) where {A<:AbstractAgent}
+function remove_agent_from_space!(
+    a::A, model::ABM{<:GridSpaceSingle,A}
+) where {A<:AbstractAgent}
     model.space.stored_ids[a.pos...] = 0
     return a
 end
@@ -85,7 +89,9 @@ function nearby_ids(pos::NTuple{D,Int}, model::ABM{<:GridSpaceSingle{D,true}}, r
     nindices = get_offset_indices(model, r)
     stored_ids = model.space.stored_ids
     space_size = size(stored_ids)
-    array_accesses_iterator = (stored_ids[(mod1.(pos .+ β, space_size))...] for β in nindices)
+    array_accesses_iterator = (
+        stored_ids[(mod1.(pos .+ β, space_size))...] for β in nindices
+    )
     # Notice that not all positions are valid; some are empty! Need to filter:
     valid_pos_iterator = Base.Iterators.filter(x -> x ≠ 0, array_accesses_iterator)
     return valid_pos_iterator
diff --git a/src/spaces/openstreetmap.jl b/src/spaces/openstreetmap.jl
index 5c5372df0b..31866ba337 100644
--- a/src/spaces/openstreetmap.jl
+++ b/src/spaces/openstreetmap.jl
@@ -135,6 +135,7 @@ struct OpenStreetMapSpace <: Agents.AbstractSpace
 end
 
 function OpenStreetMapSpace(path::AbstractString; kwargs...)
+    m = graph_from_file(path; weight_type=:distance, kwargs...)
     m = graph_from_file(path; weight_type=:distance, kwargs...)
     LightOSM.add_rtree!(m)
     agent_positions = [Int[] for _ in 1:Agents.nv(m.graph)]
@@ -252,11 +253,7 @@ function Agents.plan_route!(
             dest = get_reverse_direction(dest, model)
         end
         model.space.routes[agent.id] = OpenStreetMapPath(
-            Int[],
-            agent.pos,
-            dest,
-            Int[],
-            return_trip,
+            Int[], agent.pos, dest, Int[], return_trip
         )
         return true
     end
@@ -270,31 +267,23 @@ function Agents.plan_route!(
             end_node == dest[2] && (dest = get_reverse_direction(dest, model))
             move_agent!(agent, (dest[1], dest[2], 0.0), model)
             model.space.routes[agent.id] = OpenStreetMapPath(
-                Int[],
-                agent.pos,
-                dest,
-                return_trip ? Int[agent.pos[1]] : Int[],
-                return_trip,
+                Int[], agent.pos, dest, return_trip ? Int[agent.pos[1]] : Int[], return_trip
             )
             return true
         end
         if dest[1] == dest[2] # end at node
-            start_node == agent.pos[1] && move_agent!(agent, get_reverse_direction(agent.pos, model), model)
+            start_node == agent.pos[1] &&
+                move_agent!(agent, get_reverse_direction(agent.pos, model), model)
             dest = (agent.pos[1], agent.pos[2], road_length(agent.pos, model))
             model.space.routes[agent.id] = OpenStreetMapPath(
-                Int[],
-                agent.pos,
-                dest,
-                Int[],
-                return_trip,
+                Int[], agent.pos, dest, Int[], return_trip
             )
             return true
         end
         # start and end in middle of edge, but edges have common node
         start_node == agent.pos[1] &&
             move_agent!(agent, get_reverse_direction(agent.pos, model), model)
-        end_node == dest[2] &&
-            (dest = get_reverse_direction(dest, model))
+        end_node == dest[2] && (dest = get_reverse_direction(dest, model))
         model.space.routes[agent.id] = OpenStreetMapPath(
             Int[start_node],
             agent.pos,
@@ -358,18 +347,15 @@ function Agents.plan_route!(
     end
 
     model.space.routes[agent.id] = OpenStreetMapPath(
-        route,
-        agent.pos,
-        dest,
-        return_route,
-        return_trip,
+        route, agent.pos, dest, return_route, return_trip
     )
     return true
 end
 
 # Allows passing destination as a node number
-Agents.plan_route!(agent::A, dest::Int, model; kwargs...) where {A<:AbstractAgent} =
-    plan_route!(agent, (dest, dest, 0.0), model; kwargs...)
+function Agents.plan_route!(agent::A, dest::Int, model; kwargs...) where {A<:AbstractAgent}
+    return plan_route!(agent, (dest, dest, 0.0), model; kwargs...)
+end
 
 """
     OSM.distance(pos_1, pos_2, model::ABM{<:OpenStreetMapSpace}; kwargs...)
@@ -452,13 +438,13 @@ function distance(
 
     if pos_2[1] != pos_2[2]
         if route[end] == pos_2[1]
-            if route[end-1] == pos_2[2]
+            if route[end - 1] == pos_2[2]
                 dist -= pos_2[3]
             else
                 dist += pos_2[3]
             end
         else
-            if route[end-1] == pos_2[1]
+            if route[end - 1] == pos_2[1]
                 dist -= road_length(pos_2, model) - pos_2[3]
             else
                 dist += road_length(pos_2, model) - pos_2[3]
@@ -494,8 +480,9 @@ end
 
 Return `(longitude, latitude)` of current road or intersection position.
 """
-lonlat(pos::Int, model::ABM{<:OpenStreetMapSpace}) =
-    Tuple(reverse(model.space.map.node_coordinates[pos]))
+function lonlat(pos::Int, model::ABM{<:OpenStreetMapSpace})
+    return Tuple(reverse(model.space.map.node_coordinates[pos]))
+end
 
 function lonlat(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace})
     # extra checks to ensure consistency between both versions of `lonlat`
@@ -513,15 +500,19 @@ function lonlat(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace})
     end
 end
 
-lonlat(agent::A, model::ABM{<:OpenStreetMapSpace,A}) where {A<:AbstractAgent} =
-    lonlat(agent.pos, model)
+function lonlat(agent::A, model::ABM{<:OpenStreetMapSpace,A}) where {A<:AbstractAgent}
+    return lonlat(agent.pos, model)
+end
 
-latlon(pos::Int, model::ABM{<:OpenStreetMapSpace}) =
-    Tuple(model.space.map.node_coordinates[pos])
-latlon(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace}) =
-    reverse(lonlat(pos, model))
-latlon(agent::A, model::ABM{<:OpenStreetMapSpace,A}) where {A<:AbstractAgent} =
-    latlon(agent.pos, model)
+function latlon(pos::Int, model::ABM{<:OpenStreetMapSpace})
+    return Tuple(model.space.map.node_coordinates[pos])
+end
+function latlon(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace})
+    return reverse(lonlat(pos, model))
+end
+function latlon(agent::A, model::ABM{<:OpenStreetMapSpace,A}) where {A<:AbstractAgent}
+    return latlon(agent.pos, model)
+end
 
 """
     OSM.nearest_node(lonlat::Tuple{Float64,Float64}, model::ABM{<:OpenStreetMapSpace})
@@ -531,8 +522,7 @@ Quicker, but less precise than [`OSM.nearest_road`](@ref).
 """
 function nearest_node(ll::Tuple{Float64,Float64}, model::ABM{<:OpenStreetMapSpace})
     ll = reverse(ll)
-    nearest_node_id = LightOSM.nearest_node(model.space.map,
-        [GeoLocation(ll..., 0.0)])[1][1][1]
+    nearest_node_id = LightOSM.nearest_node(model.space.map, [GeoLocation(ll..., 0.0)])[1][1][1]
     vert = Int(model.space.map.node_to_index[nearest_node_id])
     return (vert, vert, 0.0)
 end
@@ -570,8 +560,9 @@ same as `OSM.road_length(pos_2, pos_1, model)`. Units of the returned quantity
 are as specified by the underlying graph's `weight_type`. If `start` and `finish`
 are the same or `pos[1]` and `pos[2]` are the same, then return 0.
 """
-road_length(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace}) =
-    road_length(pos[1], pos[2], model)
+function road_length(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace})
+    return road_length(pos[1], pos[2], model)
+end
 function road_length(p1::Int, p2::Int, model::ABM{<:OpenStreetMapSpace})
     p1 == p2 && return 0.0
     len = model.space.map.weights[p1, p2]
@@ -610,25 +601,34 @@ end
 
 Return `GeoLocation` corresponding to node `pos`.
 """
-get_geoloc(pos::Int, model::ABM{<:OpenStreetMapSpace}) =
-    GeoLocation(model.space.map.node_coordinates[pos]..., 0.0)
+function get_geoloc(pos::Int, model::ABM{<:OpenStreetMapSpace})
+    return GeoLocation(model.space.map.node_coordinates[pos]..., 0.0)
+end
 
 """
     OSM.get_reverse_direction(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace})
 
 Return the same position, but with `pos[1]` and `pos[2]` swapped and `pos[3]` updated.
 """
-get_reverse_direction(pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace}) =
-    (pos[2], pos[1], road_length(pos, model) - pos[3])
+function get_reverse_direction(
+    pos::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace}
+)
+    return (pos[2], pos[1], road_length(pos, model) - pos[3])
+end
 
 """
     OSM.same_position(a::Tuple{Int,Int,Float64}, b::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace})
 
 Return `true` if the given positions `a` and `b` are (approximately) identical
 """
-same_position(a::Tuple{Int,Int,Float64}, b::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace}) =
-    _same_position_node(a, b, model) || _same_position_node(b, a, model) ||
-    _same_position_edge(a, b, model) || _same_position_internal(a, b, model)
+function same_position(
+    a::Tuple{Int,Int,Float64}, b::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace}
+)
+    return _same_position_node(a, b, model) ||
+           _same_position_node(b, a, model) ||
+           _same_position_edge(a, b, model) ||
+           _same_position_internal(a, b, model)
+end
 
 # Handles the case when `a` is a node
 function _same_position_node(
@@ -649,9 +649,7 @@ end
 
 # Handles the case when both points are on edges with a common node, and close to that end of the edge
 function _same_position_edge(
-    a::Tuple{Int,Int,Float64},
-    b::Tuple{Int,Int,Float64},
-    model::ABM{<:OpenStreetMapSpace},
+    a::Tuple{Int,Int,Float64}, b::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace}
 )
     # common node could be either end of either edge, so 4 cases total + the checks to ensure the position
     # along the edge (index 3) is also at that end
@@ -680,9 +678,9 @@ function _same_position_internal(
     model::ABM{<:OpenStreetMapSpace},
 )
     # facing same direction
-    return (a[1] == b[1] && a[2] == b[2] && a[3] ≈ b[3]) ||
+    (a[1] == b[1] && a[2] == b[2] && a[3] ≈ b[3]) ||
     # facing opposite direction
-        (a[1] == b[2] && a[2] == b[1] && a[3] ≈ road_length(a, model) - b[3])
+    (a[1] == b[2] && a[2] == b[1] && a[3] ≈ road_length(a, model) - b[3])
 end
 
 """
@@ -690,10 +688,9 @@ end
 
 Return `true` if both points lie on the same road of the graph
 """
-same_road(
-    a::Tuple{Int,Int,Float64},
-    b::Tuple{Int,Int,Float64},
-) = (a[1] == b[1] && a[2] == b[2]) || (a[1] == b[2] && a[2] == b[1])
+function same_road(a::Tuple{Int,Int,Float64}, b::Tuple{Int,Int,Float64})
+    return (a[1] == b[1] && a[2] == b[2]) || (a[1] == b[2] && a[2] == b[1])
+end
 
 """
     OSM.closest_node_on_edge(a::Tuple{Int,Int,Float64}, model::ABM{<:OpenStreetMapSpace})
@@ -780,17 +777,16 @@ function Agents.move_along_route!(
                 if agent.pos[1] == agent.pos[2]
                     osmpath.return_route[end] == agent.pos[1] && pop!(osmpath.return_route)
 
-                    move_agent!(agent, (agent.pos[1], osmpath.return_route[end], 0.0), model)
+                    move_agent!(
+                        agent, (agent.pos[1], osmpath.return_route[end], 0.0), model
+                    )
                 elseif osmpath.return_route[end] == agent.pos[1]
                     move_agent!(agent, get_reverse_direction(agent.pos, model), model)
                 end
-                osmpath = model.space.routes[agent.id] = OpenStreetMapPath(
-                    osmpath.return_route,
-                    agent.pos,
-                    osmpath.start,
-                    Int[],
-                    false,
-                )
+                osmpath =
+                    model.space.routes[agent.id] = OpenStreetMapPath(
+                        osmpath.return_route, agent.pos, osmpath.start, Int[], false
+                    )
                 continue
             end
 
@@ -830,7 +826,9 @@ function Agents.move_along_route!(
                 b = osmpath.route[end]
                 move_agent!(agent, (a, b, 0.0), model)
             else
-                move_agent!(agent, (agent.pos[1], agent.pos[2], agent.pos[3] + distance), model)
+                move_agent!(
+                    agent, (agent.pos[1], agent.pos[2], agent.pos[3] + distance), model
+                )
                 distance = 0.0
             end
         end
@@ -972,8 +970,26 @@ function Agents.nearby_ids(
     return filter!(i -> i ≠ agent.id, all)
 end
 
-Agents.nearby_positions(pos::Tuple{Int,Int,Float64}, model, args...; kwargs...) =
-    nearby_positions(pos[1], model, args...; kwargs...)
+function reverse_ids_on_road(pos_1::Int, pos_2::Int, model::ABM{<:OpenStreetMapSpace})
+    return forward_ids_on_road(pos_2, pos_1, model)
+end
+
+function ids_on_road(pos_1::Int, pos_2::Int, model::ABM{<:OpenStreetMapSpace})
+    return Iterators.flatten((
+        forward_ids_on_road(pos_1, pos_2, model), reverse_ids_on_road(pos_1, pos_2, model)
+    ))
+end
+
+function Agents.nearby_ids(
+    agent::A, model::ABM{<:OpenStreetMapSpace,A}, args...; kwargs...
+) where {A<:AbstractAgent}
+    all = nearby_ids(agent.pos, model, args...; kwargs...)
+    return filter!(i -> i ≠ agent.id, all)
+end
+
+function Agents.nearby_positions(pos::Tuple{Int,Int,Float64}, model, args...; kwargs...)
+    return nearby_positions(pos[1], model, args...; kwargs...)
+end
 
 function Agents.nearby_positions(
     position::Int,
diff --git a/src/spaces/utilities.jl b/src/spaces/utilities.jl
index a2319e8fbe..45d557c114 100644
--- a/src/spaces/utilities.jl
+++ b/src/spaces/utilities.jl
@@ -117,10 +117,7 @@ Graphs.ne(abm::ABM{<:GraphBasedSpace}) = Graphs.ne(_get_graph(abm.space))
 positions(model::ABM{<:GraphBasedSpace}) = 1:nv(model)
 
 function nearby_positions(
-    position::Integer,
-    model::ABM{<:GraphBasedSpace},
-    radius::Integer;
-    kwargs...,
+    position::Integer, model::ABM{<:GraphBasedSpace}, radius::Integer; kwargs...
 )
     nearby = copy(nearby_positions(position, model; kwargs...))
     radius == 1 && return nearby
@@ -128,7 +125,7 @@ function nearby_positions(
     push!(seen, position)
     k, n = 0, nv(model)
     for _ in 2:radius
-        thislevel = @view nearby[k+1:end]
+        thislevel = @view nearby[(k + 1):end]
         isempty(thislevel) && return nearby
         k = length(nearby)
         k == n && return nearby
diff --git a/src/submodules/io/jld2_integration.jl b/src/submodules/io/jld2_integration.jl
index 54d5cac4e0..9e26d234a2 100644
--- a/src/submodules/io/jld2_integration.jl
+++ b/src/submodules/io/jld2_integration.jl
@@ -82,7 +82,9 @@ struct SerializableAStar{D,P,M,T,C}
     cost_metric::C
 end
 
-JLD2.writeas(::Type{Pathfinding.AStar{D,P,M,T,C}}) where {D,P,M,T,C} = SerializableAStar{D,P,M,T,C}
+function JLD2.writeas(::Type{Pathfinding.AStar{D,P,M,T,C}}) where {D,P,M,T,C}
+    return SerializableAStar{D,P,M,T,C}
+end
 
 function to_serializable(t::ABM{S}) where {S}
     sabm = SerializableABM(
@@ -95,20 +97,29 @@ function to_serializable(t::ABM{S}) where {S}
     return sabm
 end
 
-to_serializable(t::GridSpace{D,P}) where {D,P} =
-    SerializableGridSpace{D,P}(size(t), t.metric)
-to_serializable(t::GridSpaceSingle{D,P}) where {D,P} =
-    SerializableGridSpaceSingle{D,P}(size(t), t.metric)
+function to_serializable(t::GridSpace{D,P}) where {D,P}
+    return SerializableGridSpace{D,P}(size(t), t.metric)
+end
+function to_serializable(t::GridSpaceSingle{D,P}) where {D,P}
+    return SerializableGridSpaceSingle{D,P}(size(t), t.metric)
+end
 
-to_serializable(t::ContinuousSpace{D,P,T}) where {D,P,T} =
-    SerializableContinuousSpace{D,P,T}(to_serializable(t.grid), t.dims, t.spacing, t.extent)
+function to_serializable(t::ContinuousSpace{D,P,T}) where {D,P,T}
+    return SerializableContinuousSpace{D,P,T}(
+        to_serializable(t.grid), t.dims, t.spacing, t.extent
+    )
+end
 
 to_serializable(t::GraphSpace{G}) where {G} = SerializableGraphSpace{G}(t.graph)
 
-to_serializable(t::OSM.OpenStreetMapSpace) = SerializableOSMSpace([(k, v) for (k, v) in t.routes])
+function to_serializable(t::OSM.OpenStreetMapSpace)
+    return SerializableOSMSpace([(k, v) for (k, v) in t.routes])
+end
 
-JLD2.wconvert(::Type{SerializableAStar{D,P,M,T,C}}, t::Pathfinding.AStar{D,P,M,T,C}) where {D,P,M,T,C} =
-    SerializableAStar{D,P,M,T,C}(
+function JLD2.wconvert(
+    ::Type{SerializableAStar{D,P,M,T,C}}, t::Pathfinding.AStar{D,P,M,T,C}
+) where {D,P,M,T,C}
+    return SerializableAStar{D,P,M,T,C}(
         [(k, collect(v)) for (k, v) in t.agent_paths],
         t.dims,
         map(Tuple, t.neighborhood),
@@ -116,6 +127,7 @@ JLD2.wconvert(::Type{SerializableAStar{D,P,M,T,C}}, t::Pathfinding.AStar{D,P,M,T
         t.walkmap,
         t.cost_metric,
     )
+end
 
 function from_serializable(t::SerializableABM{S,A}; kwargs...) where {S,A}
     abm = ABM(
@@ -171,8 +183,10 @@ function from_serializable(t::SerializableOSMSpace; kwargs...)
     return space
 end
 
-JLD2.rconvert(::Type{Pathfinding.AStar{D,P,M,T,C}}, t::SerializableAStar{D,P,M,T,C}) where {D,P,M,T,C} =
-    Pathfinding.AStar{D,P,M,T,C}(
+function JLD2.rconvert(
+    ::Type{Pathfinding.AStar{D,P,M,T,C}}, t::SerializableAStar{D,P,M,T,C}
+) where {D,P,M,T,C}
+    return Pathfinding.AStar{D,P,M,T,C}(
         Dict{Int,Pathfinding.Path{D,T}}(
             k => Pathfinding.Path{D,T}(v...) for (k, v) in t.agent_paths
         ),
@@ -182,6 +196,7 @@ JLD2.rconvert(::Type{Pathfinding.AStar{D,P,M,T,C}}, t::SerializableAStar{D,P,M,T
         t.walkmap,
         t.cost_metric,
     )
+end
 
 """
     AgentsIO.save_checkpoint(filename, model::ABM)
diff --git a/src/submodules/pathfinding/astar.jl b/src/submodules/pathfinding/astar.jl
index b1d68e5043..771c727256 100644
--- a/src/submodules/pathfinding/astar.jl
+++ b/src/submodules/pathfinding/astar.jl
@@ -22,7 +22,8 @@ struct AStar{D,P,M,T,C<:CostMetric{D}} <: GridPathfinder{D,P,M}
         cost_metric::C,
     ) where {D,P,M,C,T}
         @assert all(dims .> 0) "Invalid pathfinder dimensions: $(dims)"
-        T <: Integer && @assert size(walkmap) == dims "Walkmap must be same dimensions as grid"
+        T <: Integer &&
+            @assert size(walkmap) == dims "Walkmap must be same dimensions as grid"
         @assert admissibility >= 0 "Invalid value for admissibility: $admissibility ≱ 0"
         if cost_metric isa PenaltyMap{D}
             @assert size(cost_metric.pmap) == size(walkmap) "Penaltymap dimensions must be same as walkable map"
@@ -71,9 +72,34 @@ function AStar(
 ) where {D,T}
     neighborhood = diagonal_movement ? moore_neighborhood(D) : vonneumann_neighborhood(D)
     return AStar{D,periodic,diagonal_movement,T,typeof(cost_metric)}(
-        Dict{Int,Path{D,T}}(),
-        dims,
-        neighborhood,
+        Dict{Int,Path{D,T}}(), dims, neighborhood, admissibility, walkmap, cost_metric
+    )
+end
+
+function AStar(
+    space::GridSpace{D,periodic};
+    diagonal_movement::Bool=true,
+    admissibility::Float64=0.0,
+    walkmap::BitArray{D}=trues(size(space)),
+    cost_metric::CostMetric{D}=DirectDistance{D}(),
+) where {D,periodic}
+    return AStar(
+        size(space); periodic, diagonal_movement, admissibility, walkmap, cost_metric
+    )
+end
+
+function AStar(
+    space::ContinuousSpace{D,periodic};
+    walkmap::Union{BitArray{D},Nothing}=nothing,
+    admissibility::Float64=0.0,
+    cost_metric::CostMetric{D}=DirectDistance{D}(),
+) where {D,periodic}
+    @assert walkmap isa BitArray{D} || cost_metric isa PenaltyMap "Pathfinding in ContinuousSpace requires either walkmap to be specified or cost_metric to be a PenaltyMap"
+    isnothing(walkmap) && (walkmap = BitArray(trues(size(cost_metric.pmap))))
+    return AStar(
+        Agents.spacesize(space);
+        periodic,
+        diagonal_movement=true,
         admissibility,
         walkmap,
         cost_metric,
@@ -125,8 +151,9 @@ struct GridCell
     h::Int
 end
 
-GridCell(g::Int, h::Int, admissibility::Float64) =
-    GridCell(round(Int, g + (1 + admissibility) * h), g, h)
+function GridCell(g::Int, h::Int, admissibility::Float64)
+    return GridCell(round(Int, g + (1 + admissibility) * h), g, h)
+end
 
 GridCell() = GridCell(typemax(Int), typemax(Int), typemax(Int))
 
@@ -168,9 +195,7 @@ function find_path(pathfinder::AStar{D}, from::Dims{D}, to::Dims{D}) where {D}
             if new_g_cost < nbor_cell.g
                 parent[nbor] = cur
                 open_list[nbor] = GridCell(
-                    new_g_cost,
-                    delta_cost(pathfinder, nbor, to),
-                    pathfinder.admissibility,
+                    new_g_cost, delta_cost(pathfinder, nbor, to), pathfinder.admissibility
                 )
             end
         end
@@ -183,28 +208,33 @@ function find_path(pathfinder::AStar{D}, from::Dims{D}, to::Dims{D}) where {D}
         pushfirst!(agent_path, cur)
         cur = parent[cur]
     end
-    cur == from || return # nothing
+    cur == from || return nothing # nothing
     return agent_path
 end
 
-@inline get_neighbors(cur, pathfinder::AStar{D,true}) where {D} =
-    (mod1.(cur .+ β.I, size(pathfinder.walkmap)) for β in pathfinder.neighborhood)
-@inline get_neighbors(cur, pathfinder::AStar{D,false}) where {D} =
-    (cur .+ β.I for β in pathfinder.neighborhood)
-@inline inbounds(n, pathfinder, closed) =
-    all(1 .<= n .<= size(pathfinder.walkmap)) && pathfinder.walkmap[n...] && n ∉ closed
+@inline function get_neighbors(cur, pathfinder::AStar{D,true}) where {D}
+    return (mod1.(cur .+ β.I, size(pathfinder.walkmap)) for β in pathfinder.neighborhood)
+end
+@inline function get_neighbors(cur, pathfinder::AStar{D,false}) where {D}
+    return (cur .+ β.I for β in pathfinder.neighborhood)
+end
+@inline function inbounds(n, pathfinder, closed)
+    return all(1 .<= n .<= size(pathfinder.walkmap)) &&
+           pathfinder.walkmap[n...] &&
+           n ∉ closed
+end
 
-Base.isempty(id::Int, pathfinder::AStar) =
-    !haskey(pathfinder.agent_paths, id) || isempty(pathfinder.agent_paths[id])
+function Base.isempty(id::Int, pathfinder::AStar)
+    return !haskey(pathfinder.agent_paths, id) || isempty(pathfinder.agent_paths[id])
+end
 
 """
     is_stationary(agent, astar::AStar)
 Same, but for pathfinding with A*.
 """
-Agents.is_stationary(
-    agent::A,
-    pathfinder::AStar,
-) where {A<:AbstractAgent} = isempty(agent.id, pathfinder)
+function Agents.is_stationary(agent::A, pathfinder::AStar) where {A<:AbstractAgent}
+    return isempty(agent.id, pathfinder)
+end
 
 """
     Pathfinding.penaltymap(pathfinder)
@@ -230,9 +260,7 @@ The same as `kill_agent!(agent, model)`, but also removes the agent's path data
 from `pathfinder`.
 """
 function Agents.kill_agent!(
-    agent::A,
-    model::ABM{S,A},
-    pathfinder::AStar,
+    agent::A, model::ABM{S,A}, pathfinder::AStar
 ) where {S,A<:AbstractAgent}
     delete!(pathfinder.agent_paths, agent.id)
     Agents.remove_agent_from_model!(agent, model)
diff --git a/src/submodules/pathfinding/astar_continuous.jl b/src/submodules/pathfinding/astar_continuous.jl
index edb2d3475a..e5bbd18147 100644
--- a/src/submodules/pathfinding/astar_continuous.jl
+++ b/src/submodules/pathfinding/astar_continuous.jl
@@ -15,15 +15,13 @@ space used by the corresponding `ContinuousSpace`. Performs checks on the last t
 in the discrete path to ensure continuous path is optimal.
 """
 function find_continuous_path(
-    pathfinder::AStar{D},
-    from::NTuple{D,Float64},
-    to::NTuple{D,Float64},
+    pathfinder::AStar{D}, from::NTuple{D,Float64}, to::NTuple{D,Float64}
 ) where {D}
     discrete_from = to_discrete_position(from, pathfinder)
     discrete_to = to_discrete_position(to, pathfinder)
     discrete_path = find_path(pathfinder, discrete_from, discrete_to)
     # find_path returns nothing if no path exists
-    isnothing(discrete_path) && return
+    isnothing(discrete_path) && return nothing
     # if discrete_path is empty, `from` and `to` are in the same grid cell,
     # so `to` is the only waypoint
     isempty(discrete_path) && return Path{D,Float64}(to)
@@ -55,9 +53,7 @@ function find_continuous_path(
 end
 
 function Agents.plan_route!(
-    agent::A,
-    dest::NTuple{D,Float64},
-    pathfinder::AStar{D,P,M,Float64},
+    agent::A, dest::NTuple{D,Float64}, pathfinder::AStar{D,P,M,Float64}
 ) where {A<:AbstractAgent,D,P,M}
     path = find_continuous_path(pathfinder, agent.pos, dest)
     isnothing(path) && return
@@ -83,7 +79,7 @@ function Agents.plan_best_route!(
         end
     end
 
-    isnothing(best_target) && return
+    isnothing(best_target) && return nothing
     pathfinder.agent_paths[agent.id] = best_path
     return best_target
 end
@@ -104,7 +100,7 @@ function Agents.move_along_route!(
     speed::Float64,
     dt::Real=1.0,
 ) where {D,A<:AbstractAgent}
-    isempty(agent.id, pathfinder) && return
+    isempty(agent.id, pathfinder) && return nothing
     from = agent.pos
     next_pos = agent.pos
     while true
@@ -166,15 +162,17 @@ walkable_cells_in_radius(pos, r, pathfinder::AStar{D,false}) where {D} =
                  sum(((x .- pos) ./ r) .^ 2) <= 1,
         Iterators.product([(pos[i]-r[i]):(pos[i]+r[i]) for i in 1:D]...),
     )
+end
 
-walkable_cells_in_radius(pos, r, pathfinder::AStar{D,true}) where {D} =
-    Iterators.map(
+function walkable_cells_in_radius(pos, r, pathfinder::AStar{D,true}) where {D}
+    return Iterators.map(
         x -> mod1.(x, size(pathfinder.walkmap)),
         Iterators.filter(
             x -> pathfinder.walkmap[mod1.(x, size(pathfinder.walkmap))...] && sum(((x .- pos) ./ r) .^ 2) <= 1,
             Iterators.product([(pos[i]-r[i]):(pos[i]+r[i]) for i in 1:D]...),
         ),
     )
+end
 
 """
     Pathfinding.random_walkable(pos, model::ABM{<:ContinuousSpace{D}}, pathfinder::AStar{D}, r = 1.0)
diff --git a/src/submodules/pathfinding/astar_grid.jl b/src/submodules/pathfinding/astar_grid.jl
index a86c0ed453..4a13439792 100644
--- a/src/submodules/pathfinding/astar_grid.jl
+++ b/src/submodules/pathfinding/astar_grid.jl
@@ -6,9 +6,7 @@ Calculate and store the shortest path to move the agent from its current positio
 Use this method in conjuction with [`move_along_route!`](@ref).
 """
 function Agents.plan_route!(
-    agent::A,
-    dest::Dims{D},
-    pathfinder::AStar{D},
+    agent::A, dest::Dims{D}, pathfinder::AStar{D}
 ) where {D,A<:AbstractAgent}
     path = find_path(pathfinder, agent.pos, dest)
     isnothing(path) && return
@@ -45,7 +43,7 @@ function Agents.plan_best_route!(
         end
     end
 
-    isnothing(best_target) && return
+    isnothing(best_target) && return nothing
     pathfinder.agent_paths[agent.id] = best_path
     return best_target
 end
@@ -63,7 +61,7 @@ function Agents.move_along_route!(
     model::ABM{<:GridSpace{D},A},
     pathfinder::AStar{D},
 ) where {D,A<:AbstractAgent}
-    isempty(agent.id, pathfinder) && return
+    isempty(agent.id, pathfinder) && return nothing
 
     move_agent!(agent, first(pathfinder.agent_paths[agent.id]), model)
     return popfirst!(pathfinder.agent_paths[agent.id])
diff --git a/src/submodules/pathfinding/metrics.jl b/src/submodules/pathfinding/metrics.jl
index 1b1a2c56f8..14c67708a1 100644
--- a/src/submodules/pathfinding/metrics.jl
+++ b/src/submodules/pathfinding/metrics.jl
@@ -54,8 +54,10 @@ An example usage can be found in [Mountain Runners](https://juliadynamics.github
 """
 PenaltyMap(pmap::Array{Int,D}) where {D} = PenaltyMap{D}(DirectDistance{D}(), pmap)
 
-PenaltyMap(pmap::Array{Int,D}, base_metric::CostMetric{D}) where {D} =
-    PenaltyMap{D}(base_metric, pmap)
+function PenaltyMap(pmap::Array{Int,D}, base_metric::CostMetric{D}) where {D}
+    return PenaltyMap{D}(base_metric, pmap)
+end
 
-Base.show(io::IO, metric::PenaltyMap) =
-    print(io, "HeightMap with base: $(metric.base_metric)")
+function Base.show(io::IO, metric::PenaltyMap)
+    return print(io, "HeightMap with base: $(metric.base_metric)")
+end
diff --git a/src/submodules/pathfinding/pathfinding_utils.jl b/src/submodules/pathfinding/pathfinding_utils.jl
index 6e3f360d4e..d8e6f1a274 100644
--- a/src/submodules/pathfinding/pathfinding_utils.jl
+++ b/src/submodules/pathfinding/pathfinding_utils.jl
@@ -3,11 +3,17 @@
 Returns the absolute difference in coordinates between `from` and `to` taking into account
 periodicity of `pathfinder`.
 """
-position_delta(pathfinder::GridPathfinder{D,true}, from::Dims{D}, to::Dims{D}) where {D} =
-    min.(abs.(to .- from), size(pathfinder.walkmap) .- abs.(to .- from))
+function position_delta(
+    pathfinder::GridPathfinder{D,true}, from::Dims{D}, to::Dims{D}
+) where {D}
+    return min.(abs.(to .- from), size(pathfinder.walkmap) .- abs.(to .- from))
+end
 
-position_delta(pathfinder::GridPathfinder{D,false}, from::Dims{D}, to::Dims{D}) where {D} =
-    abs.(to .- from)
+function position_delta(
+    pathfinder::GridPathfinder{D,false}, from::Dims{D}, to::Dims{D}
+) where {D}
+    return abs.(to .- from)
+end
 
 """
     Pathfinding.delta_cost(pathfinder::GridPathfinder{D}, metric::M, from, to) where {M<:CostMetric}
@@ -26,8 +32,8 @@ function delta_cost(
     carry = 0
     hdist = 0
     for i in D:-1:1
-        hdist += metric.direction_costs[i] * (delta[D+1-i] - carry)
-        carry = delta[D+1-i]
+        hdist += metric.direction_costs[i] * (delta[D + 1 - i] - carry)
+        carry = delta[D + 1 - i]
     end
     return hdist
 end
@@ -43,21 +49,19 @@ function delta_cost(
     return sum(delta) * metric.direction_costs[1]
 end
 
-delta_cost(
-    pathfinder::GridPathfinder{D},
-    metric::MaxDistance{D},
-    from::Dims{D},
-    to::Dims{D},
-) where {D} = max(position_delta(pathfinder, from, to)...)
+function delta_cost(
+    pathfinder::GridPathfinder{D}, metric::MaxDistance{D}, from::Dims{D}, to::Dims{D}
+) where {D}
+    return max(position_delta(pathfinder, from, to)...)
+end
 
-delta_cost(
-    pathfinder::GridPathfinder{D},
-    metric::PenaltyMap{D},
-    from::Dims{D},
-    to::Dims{D},
-) where {D} =
-    delta_cost(pathfinder, metric.base_metric, from, to) +
-    abs(metric.pmap[from...] - metric.pmap[to...])
+function delta_cost(
+    pathfinder::GridPathfinder{D}, metric::PenaltyMap{D}, from::Dims{D}, to::Dims{D}
+) where {D}
+    return delta_cost(pathfinder, metric.base_metric, from, to) +
+           abs(metric.pmap[from...] - metric.pmap[to...])
+end
 
-delta_cost(pathfinder::GridPathfinder{D}, from::Dims{D}, to::Dims{D}) where {D} =
-    delta_cost(pathfinder, pathfinder.cost_metric, from, to)
+function delta_cost(pathfinder::GridPathfinder{D}, from::Dims{D}, to::Dims{D}) where {D}
+    return delta_cost(pathfinder, pathfinder.cost_metric, from, to)
+end
diff --git a/test/api_tests.jl b/test/api_tests.jl
index 47a70b9a78..12c702bfc2 100644
--- a/test/api_tests.jl
+++ b/test/api_tests.jl
@@ -8,9 +8,9 @@ using StableRNGs
     properties = Dict(:x1 => 1)
     space = GraphSpace(complete_digraph(10))
     model = ABM(Agent7, space; properties)
-    attributes = (f1 = true, f2 = 1)
+    attributes = (f1=true, f2=1)
     add_agent!(1, model, attributes...)
-    attributes = (f2 = 1, f1 = true)
+    attributes = (f2=1, f1=true)
     add_agent!(1, model; attributes...)
     @test model[1].id != model[2].id
     @test model[1].pos == model[2].pos
@@ -135,7 +135,7 @@ end
     @test_throws ErrorException kill_agent!(model[1], model)
     @test_throws ErrorException genocide!(model, [1, 3])
 
-    for (i,a) in enumerate(allagents(model))
+    for (i, a) in enumerate(allagents(model))
         @test a.id == i
     end
 
@@ -194,7 +194,6 @@ end
     @test nagents(model) == 20
     genocide!(model, a -> a.id > 5)
     @test nagents(model) == 5
-
 end
 
 mutable struct Daisy <: AbstractAgent
@@ -218,7 +217,7 @@ end
     end
 
     space = GridSpace((10, 10))
-    model = ABM(Union{Daisy,Land}, space; warn = false)
+    model = ABM(Union{Daisy,Land}, space; warn=false)
     fill_space!(Daisy, model, "black")
     @test nagents(model) == 100
     for a in allagents(model)
@@ -226,15 +225,14 @@ end
         @test a.breed == "black"
     end
 
-    space = GridSpace((10, 10), periodic = true)
-    model = ABM(Union{Daisy,Land}, space; warn = false)
+    space = GridSpace((10, 10); periodic=true)
+    model = ABM(Union{Daisy,Land}, space; warn=false)
     temperature(pos) = (pos[1] / 10,) # make it Tuple!
     fill_space!(Land, model, temperature)
     @test nagents(model) == 100
     for a in allagents(model)
         @test a.temperature == a.pos[1] / 10
     end
-
 end
 
 @testset "model step order" begin
@@ -246,11 +244,11 @@ end
         end
     end
     function agent_step!(a, model)
-        a.weight += 1
+        return a.weight += 1
     end
 
     for bool in (true, false)
-        model = ABM(Agent2; properties = Dict(:count => 0))
+        model = ABM(Agent2; properties=Dict(:count => 0))
         for i in 1:100
             add_agent!(model, rand(model.rng))
         end
@@ -270,7 +268,7 @@ end
         weight::Float64
     end
 
-    model = ABM(AgentWithWeight, GridSpace((10, 10)); scheduler = Schedulers.ByID())
+    model = ABM(AgentWithWeight, GridSpace((10, 10)); scheduler=Schedulers.ByID())
     for i in 1:10
         add_agent!(model, i)
     end
@@ -287,15 +285,17 @@ end
     @test second[15] == 7.0
     @test second[end] == 20.0
 
-    third =
-        collect(map_agent_groups(3, x -> x[1].weight + x[2].weight + x[3].weight, model))
+    third = collect(
+        map_agent_groups(3, x -> x[1].weight + x[2].weight + x[3].weight, model)
+    )
     @test size(third) == (10, 10, 10)
     @test third[1] == 3.0
     @test third[15] == 8.0
     @test third[end] == 30.0
 
-    second_filtered =
-        collect(map_agent_groups(2, x -> x[1].weight + x[2].weight, model, allunique))
+    second_filtered = collect(
+        map_agent_groups(2, x -> x[1].weight + x[2].weight, model, allunique)
+    )
     @test size(second_filtered) == (90,)
     @test second_filtered[1] == 3.0
     @test second_filtered[15] == 9.0
diff --git a/test/astar_tests.jl b/test/astar_tests.jl
index bbead85378..8ec3354716 100644
--- a/test/astar_tests.jl
+++ b/test/astar_tests.jl
@@ -5,56 +5,61 @@ using Agents.Pathfinding
     moore = Pathfinding.moore_neighborhood(2)
     vonneumann = Pathfinding.vonneumann_neighborhood(2)
     gspace = GridSpace((5, 5))
-    cspace = ContinuousSpace((5., 5.))
+    cspace = ContinuousSpace((5.0, 5.0))
     atol = 0.0001
     @testset "constructors" begin
         # GridSpace
-        @test_throws AssertionError AStar(gspace; admissibility = -1.0)
+        @test_throws AssertionError AStar(gspace; admissibility=-1.0)
         # Default/DirectDistance metric
         cost = AStar(gspace).cost_metric
         @test typeof(cost) <: DirectDistance{2}
         @test cost.direction_costs == [10, 14]
-        @test_throws AssertionError AStar(gspace; cost_metric = DirectDistance{2}([1]))
+        @test_throws AssertionError AStar(gspace; cost_metric=DirectDistance{2}([1]))
         @test_throws AssertionError AStar(
-            gspace;
-            diagonal_movement = false,
-            cost_metric = DirectDistance{2}([])
+            gspace; diagonal_movement=false, cost_metric=DirectDistance{2}([])
         )
 
         # MaxDistance metric
-        cost = AStar(gspace; cost_metric = MaxDistance{2}()).cost_metric
+        cost = AStar(gspace; cost_metric=MaxDistance{2}()).cost_metric
         @test typeof(cost) <: MaxDistance{2}
 
         # PenaltyMap metric
-        @test_throws TypeError AStar(gspace; cost_metric = PenaltyMap)
-        @test_throws AssertionError AStar(gspace; cost_metric = PenaltyMap([1 1]))
+        @test_throws TypeError AStar(gspace; cost_metric=PenaltyMap)
+        @test_throws AssertionError AStar(gspace; cost_metric=PenaltyMap([1 1]))
 
-        cost = AStar(gspace; cost_metric = PenaltyMap(fill(1, 5, 5))).cost_metric
+        cost = AStar(gspace; cost_metric=PenaltyMap(fill(1, 5, 5))).cost_metric
         @test typeof(cost) <: PenaltyMap{2}
         @test typeof(cost.base_metric) <: DirectDistance{2}
         @test cost.pmap == fill(1, 5, 5)
 
-        cost = AStar(gspace; cost_metric = PenaltyMap(fill(1, 5, 5), MaxDistance{2}())).cost_metric
+        cost =
+            AStar(
+                gspace; cost_metric=PenaltyMap(fill(1, 5, 5), MaxDistance{2}())
+            ).cost_metric
         @test typeof(cost) <: PenaltyMap{2}
         @test typeof(cost.base_metric) <: MaxDistance{2}
         @test cost.pmap == fill(1, 5, 5)
         pmap = zeros(Int, 1, 1, 1)
-        @test_throws TypeError AStar(gspace; cost_metric = PenaltyMap(pmap))
+        @test_throws TypeError AStar(gspace; cost_metric=PenaltyMap(pmap))
 
         # ContinuousSpace
-        @test_throws AssertionError AStar(cspace; walkmap = trues((10, 10)), cost_metric = PenaltyMap(fill(1, 5, 5)))
-        @test_throws AssertionError AStar(cspace; walkmap = trues((10, 10)), cost_metric = PenaltyMap(fill(1, 5, 5)))
+        @test_throws AssertionError AStar(
+            cspace; walkmap=trues((10, 10)), cost_metric=PenaltyMap(fill(1, 5, 5))
+        )
+        @test_throws AssertionError AStar(
+            cspace; walkmap=trues((10, 10)), cost_metric=PenaltyMap(fill(1, 5, 5))
+        )
 
-        astar = AStar(cspace; walkmap = trues(10, 10))
+        astar = AStar(cspace; walkmap=trues(10, 10))
         @test astar isa AStar{2,true,true,Float64}
-        astar = AStar(cspace; cost_metric = PenaltyMap(fill(1, 5, 5)))
+        astar = AStar(cspace; cost_metric=PenaltyMap(fill(1, 5, 5)))
         @test astar isa AStar{2,true,true,Float64}
     end
 
     @testset "API functions" begin
         @testset "GridSpace" begin
             pathfinder = AStar(gspace)
-            model = ABM(Agent3, gspace; properties = (pf = pathfinder,))
+            model = ABM(Agent3, gspace; properties=(pf=pathfinder,))
             a = add_agent!((5, 2), model, 654.5)
             @test is_stationary(a, model.pf)
 
@@ -75,8 +80,8 @@ using Agents.Pathfinding
 
             @test isnothing(penaltymap(model.pf))
             pmap = fill(1, 5, 5)
-            pathfinder = AStar(gspace; cost_metric = PenaltyMap(pmap))
-            model = ABM(Agent3, gspace; properties = (pf = pathfinder, ))
+            pathfinder = AStar(gspace; cost_metric=PenaltyMap(pmap))
+            model = ABM(Agent3, gspace; properties=(pf=pathfinder,))
             @test penaltymap(model.pf) == pmap
 
             pathfinder.walkmap[:, 3] .= false
@@ -86,22 +91,22 @@ using Agents.Pathfinding
             @test all(x in npos for x in ans)
             @test all(pathfinder.walkmap[random_walkable(model, model.pf)...] for _ in 1:10)
 
-            sp = GridSpace((5, 5); periodic = false)
+            sp = GridSpace((5, 5); periodic=false)
             pf = AStar(sp)
-            model = ABM(Agent3, sp; properties = (pf = pf,))
+            model = ABM(Agent3, sp; properties=(pf=pf,))
             model.pf.walkmap[3, :] .= 0
-            a = add_agent!((1, 3), model, 0.)
+            a = add_agent!((1, 3), model, 0.0)
             @test plan_best_route!(a, [(1, 3), (4, 1)], model.pf) == (1, 3)
             @test isnothing(plan_best_route!(a, [(5, 3), (4, 1)], model.pf))
         end
 
         @testset "ContinuousSpace" begin
-            pathfinder = AStar(cspace; walkmap = trues(10, 10))
-            model = ABM(Agent6, cspace; properties = (pf = pathfinder,))
-            a = add_agent!((0., 0.), model, (0., 0.), 0.)
+            pathfinder = AStar(cspace; walkmap=trues(10, 10))
+            model = ABM(Agent6, cspace; properties=(pf=pathfinder,))
+            a = add_agent!((0.0, 0.0), model, (0.0, 0.0), 0.0)
             @test is_stationary(a, model.pf)
 
-            plan_route!(a, (4., 4.), model.pf)
+            plan_route!(a, (4.0, 4.0), model.pf)
             @test !is_stationary(a, model.pf)
             @test length(model.pf.agent_paths) == 1
             move_along_route!(a, model, model.pf, 0.35355)
@@ -111,79 +116,77 @@ using Agents.Pathfinding
             move_agent!(a, (0.25, 0.25), model)
             plan_route!(a, (0.75, 1.25), model.pf)
             move_along_route!(a, model, model.pf, 0.807106)
-            @test all(isapprox.(a.pos, (0.75, 0.849999); atol)) || all(isapprox.(a.pos, (0.467156, 0.967156); atol))
+            @test all(isapprox.(a.pos, (0.75, 0.849999); atol)) ||
+                all(isapprox.(a.pos, (0.467156, 0.967156); atol))
             # make sure it doesn't overshoot the end
-            move_along_route!(a, model, model.pf, 20.)
+            move_along_route!(a, model, model.pf, 20.0)
             @test all(isapprox.(a.pos, (0.75, 1.25); atol))
 
             delete!(model.pf.agent_paths, 1)
             @test length(model.pf.agent_paths) == 0
 
             model.pf.walkmap[:, 3] .= 0
-            @test all(get_spatial_property(random_walkable(model, model.pf), model.pf.walkmap, model) for _ in 1:10)
+            @test all(
+                get_spatial_property(
+                    random_walkable(model, model.pf), model.pf.walkmap, model
+                ) for _ in 1:10
+            )
             rpos = [random_walkable((2.5, 0.75), model, model.pf, 2.0) for _ in 1:50]
-            @test all(get_spatial_property(x, model.pf.walkmap, model) && euclidean_distance(x, (2.5, 0.75), model) <= 2.0 + atol for x in rpos)
-
-            pcspace = ContinuousSpace((5., 5.); periodic = false)
-            pathfinder = AStar(pcspace; walkmap = trues(10, 10))
-            model = ABM(Agent6, pcspace; properties = (pf = pathfinder,))
-            a = add_agent!((0., 0.), model, (0., 0.), 0.)
-            @test all(plan_best_route!(a, [(2.5, 2.5), (4.99,0.), (0., 4.99)], model.pf) .≈ (2.5, 2.5))
+            @test all(
+                get_spatial_property(x, model.pf.walkmap, model) &&
+                euclidean_distance(x, (2.5, 0.75), model) <= 2.0 + atol for x in rpos
+            )
+
+            pcspace = ContinuousSpace((5.0, 5.0); periodic=false)
+            pathfinder = AStar(pcspace; walkmap=trues(10, 10))
+            model = ABM(Agent6, pcspace; properties=(pf=pathfinder,))
+            a = add_agent!((0.0, 0.0), model, (0.0, 0.0), 0.0)
+            @test all(
+                plan_best_route!(a, [(2.5, 2.5), (4.99, 0.0), (0.0, 4.99)], model.pf) .≈
+                (2.5, 2.5),
+            )
             @test length(model.pf.agent_paths) == 1
             move_along_route!(a, model, model.pf, 1.0)
             @test all(isapprox.(a.pos, (0.7071, 0.7071); atol))
 
             model.pf.walkmap[:, 3] .= 0
             move_agent!(a, (2.5, 2.5), model)
-            @test all(plan_best_route!(a, [(3., 0.3), (2.5, 2.5)], model.pf) .≈ (2.5, 2.5))
-            @test isnothing(plan_best_route!(a, [(3., 0.3), (1., 0.1)], model.pf))
+            @test all(plan_best_route!(a, [(3.0, 0.3), (2.5, 2.5)], model.pf) .≈ (2.5, 2.5))
+            @test isnothing(plan_best_route!(a, [(3.0, 0.3), (1.0, 0.1)], model.pf))
 
             kill_agent!(a, model, model.pf)
             @test length(model.pf.agent_paths) == 0
 
             @test isnothing(penaltymap(model.pf))
             pmap = fill(1, 10, 10)
-            pathfinder = AStar(cspace; cost_metric = PenaltyMap(pmap))
+            pathfinder = AStar(cspace; cost_metric=PenaltyMap(pmap))
             @test penaltymap(pathfinder) == pmap
 
-            @test all(get_spatial_property(random_walkable(model, model.pf), model.pf.walkmap, model) for _ in 1:10)
+            @test all(
+                get_spatial_property(
+                    random_walkable(model, model.pf), model.pf.walkmap, model
+                ) for _ in 1:10
+            )
             rpos = [random_walkable((2.5, 0.75), model, model.pf, 2.0) for _ in 1:50]
-            @test all(get_spatial_property(x, model.pf.walkmap, model) && euclidean_distance(x, (2.5, 0.75), model) <= 2.0 + atol for x in rpos)
+            @test all(
+                get_spatial_property(x, model.pf.walkmap, model) &&
+                euclidean_distance(x, (2.5, 0.75), model) <= 2.0 + atol for x in rpos
+            )
         end
     end
 
     @testset "metrics" begin
         pfinder_2d_np_m = AStar{2,false,true,Int64,DirectDistance{2}}(
-            Dict(),
-            (10, 10),
-            copy(moore),
-            0.0,
-            trues(10, 10),
-            DirectDistance{2}(),
+            Dict(), (10, 10), copy(moore), 0.0, trues(10, 10), DirectDistance{2}()
         )
         pfinder_2d_np_nm = AStar{2,false,false,Int64,DirectDistance{2}}(
-            Dict(),
-            (10, 10),
-            copy(vonneumann),
-            0.0,
-            trues(10, 10),
-            DirectDistance{2}(),
+            Dict(), (10, 10), copy(vonneumann), 0.0, trues(10, 10), DirectDistance{2}()
         )
         pfinder_2d_p_m = AStar{2,true,true,Int64,DirectDistance{2}}(
-            Dict(),
-            (10, 10),
-            copy(moore),
-            0.0,
-            trues(10, 10),
-            DirectDistance{2}(),
+            Dict(), (10, 10), copy(moore), 0.0, trues(10, 10), DirectDistance{2}()
         )
         pfinder_2d_p_nm = AStar{2,true,false,Int64,DirectDistance{2}}(
-            Dict(),
-            (10, 10),
-            copy(vonneumann),
-            0.0,
-            trues(10, 10),
-            DirectDistance{2}(),
+            Dict(), (10, 10), copy(vonneumann), 0.0, trues(10, 10), DirectDistance{2}()
         )
         pmap = fill(0, 10, 10)
         pmap[:, 6] .= 100
@@ -216,57 +219,60 @@ using Agents.Pathfinding
         wlk[5, 3] = false
 
         pfinder_2d_np_m = AStar{2,false,true,Float64,DirectDistance{2}}(
-            Dict(),
-            (10., 10.),
-            copy(moore),
-            0.0,
-            wlk,
-            DirectDistance{2}(),
+            Dict(), (10.0, 10.0), copy(moore), 0.0, wlk, DirectDistance{2}()
         )
         pfinder_2d_np_nm = AStar{2,false,false,Float64,DirectDistance{2}}(
-            Dict(),
-            (10., 10.),
-            copy(vonneumann),
-            0.0,
-            wlk,
-            DirectDistance{2}(),
+            Dict(), (10.0, 10.0), copy(vonneumann), 0.0, wlk, DirectDistance{2}()
         )
         pfinder_2d_p_m = AStar{2,true,true,Float64,DirectDistance{2}}(
-            Dict(),
-            (10., 10.),
-            copy(moore),
-            0.0,
-            wlk,
-            DirectDistance{2}(),
+            Dict(), (10.0, 10.0), copy(moore), 0.0, wlk, DirectDistance{2}()
         )
         pfinder_2d_p_nm = AStar{2,true,false,Float64,DirectDistance{2}}(
-            Dict(),
-            (10., 10.),
-            copy(vonneumann),
-            0.0,
-            wlk,
-            DirectDistance{2}(),
+            Dict(), (10.0, 10.0), copy(vonneumann), 0.0, wlk, DirectDistance{2}()
         )
 
         p = collect(Pathfinding.find_path(pfinder_2d_np_m, (1, 1), (6, 6)))
         @test p == [(1, 2), (1, 3), (1, 4), (1, 5), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6)]
         p = collect(Pathfinding.find_path(pfinder_2d_np_nm, (1, 1), (6, 6)))
-        @test p ==
-            [(1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6)]
+        @test p == [
+            (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6)
+        ]
         p = collect(Pathfinding.find_path(pfinder_2d_p_m, (1, 1), (6, 6)))
         @test p == [(2, 6), (3, 6), (4, 6), (5, 6), (6, 6)]
         p = collect(Pathfinding.find_path(pfinder_2d_p_nm, (1, 1), (6, 6)))
         @test p == [(1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6)]
 
         # Continuous
-        model = ABM(Agent6, ContinuousSpace((10., 10.)))
-        p = collect(Pathfinding.find_continuous_path(pfinder_2d_np_m, (0.25, 0.25), (7.8, 9.5)))
-        testp = [(0.71429, 2.5), (0.71429, 4.16667), (0.71429, 5.83333), (0.71429, 7.5), (2.14286, 9.16667), (3.57143, 9.16667), (5.0, 9.16667), (6.42857, 9.16667), (7.85714, 9.16667), (7.8, 9.5)]
+        model = ABM(Agent6, ContinuousSpace((10.0, 10.0)))
+        p = collect(
+            Pathfinding.find_continuous_path(pfinder_2d_np_m, (0.25, 0.25), (7.8, 9.5))
+        )
+        testp = [
+            (0.71429, 2.5),
+            (0.71429, 4.16667),
+            (0.71429, 5.83333),
+            (0.71429, 7.5),
+            (2.14286, 9.16667),
+            (3.57143, 9.16667),
+            (5.0, 9.16667),
+            (6.42857, 9.16667),
+            (7.85714, 9.16667),
+            (7.8, 9.5),
+        ]
         @test length(p) == length(testp)
         @test all(all(isapprox.(p[i], testp[i]; atol)) for i in 1:length(p))
 
-        p = collect(Pathfinding.find_continuous_path(pfinder_2d_p_m, (0.25, 0.25), (7.8, 9.5)))
-        testp = [(2.14286, 9.16667), (3.57143, 9.16667), (5.0, 9.16667), (6.42857, 9.16667), (7.85714, 9.16667), (7.8, 9.5)]
+        p = collect(
+            Pathfinding.find_continuous_path(pfinder_2d_p_m, (0.25, 0.25), (7.8, 9.5))
+        )
+        testp = [
+            (2.14286, 9.16667),
+            (3.57143, 9.16667),
+            (5.0, 9.16667),
+            (6.42857, 9.16667),
+            (7.85714, 9.16667),
+            (7.8, 9.5),
+        ]
         @test length(p) == length(testp)
         @test all(all(isapprox.(p[i], testp[i]; atol)) for i in 1:length(p))
     end
diff --git a/test/collect_tests.jl b/test/collect_tests.jl
index 1fc232e423..6ec5014c21 100644
--- a/test/collect_tests.jl
+++ b/test/collect_tests.jl
@@ -10,7 +10,7 @@ end
         model = ABM(
             Agent3,
             GridSpace((10, 10));
-            properties = Dict(
+            properties=Dict(
                 :year => 0,
                 :tick => 0,
                 :flag => false,
@@ -51,16 +51,12 @@ end
 
         props = [:weight]
         @test sprint(
-            show,
-            "text/csv",
-            describe(init_agent_dataframe(model, props), :eltype),
+            show, "text/csv", describe(init_agent_dataframe(model, props), :eltype)
         ) ==
-              "\"variable\",\"eltype\"\n\"step\",\"Int64\"\n\"id\",\"Int64\"\n\"weight\",\"Float64\"\n"
+            "\"variable\",\"eltype\"\n\"step\",\"Int64\"\n\"id\",\"Int64\"\n\"weight\",\"Float64\"\n"
         props = [:year]
         @test sprint(
-            show,
-            "text/csv",
-            describe(init_model_dataframe(model, props), :eltype),
+            show, "text/csv", describe(init_model_dataframe(model, props), :eltype)
         ) == "\"variable\",\"eltype\"\n\"step\",\"Int64\"\n\"year\",\"Int64\"\n"
 
         @test_throws ErrorException init_agent_dataframe(model, [:UNKNOWN])
@@ -153,10 +149,10 @@ end
             agent_step!,
             model_step!,
             365 * 5;
-            when_model = each_year,
-            when = six_months,
-            mdata = [:flag, :year],
-            adata = [(:weight, mean)],
+            when_model=each_year,
+            when=six_months,
+            mdata=[:flag, :year],
+            adata=[(:weight, mean)],
         )
 
         @test size(agent_data) == (11, 2)
@@ -172,10 +168,10 @@ end
             agent_step!,
             model_step!,
             365 * 5;
-            when_model = [1, 365 * 5],
-            when = false,
-            mdata = [:flag, :year],
-            adata = [(:weight, mean)],
+            when_model=[1, 365 * 5],
+            when=false,
+            mdata=[:flag, :year],
+            adata=[(:weight, mean)],
         )
         @test size(agent_data) == (0, 2)
         @test size(model_data) == (2, 3)
@@ -185,10 +181,10 @@ end
             agent_step!,
             model_step!,
             365 * 5;
-            when_model = [1, 365 * 5],
-            when = false,
-            mdata = [:deep],
-            obtainer = deepcopy,
+            when_model=[1, 365 * 5],
+            when=false,
+            mdata=[:deep],
+            obtainer=deepcopy,
         )
         @test model_data[1, :deep].data[1] < model_data[end, :deep].data[1]
 
@@ -197,9 +193,9 @@ end
             agent_step!,
             model_step!,
             365 * 5;
-            when_model = [365 * 5],
-            when = false,
-            mdata = [(m) -> (m.deep.data[i]) for i in 1:length(model.deep.data)],
+            when_model=[365 * 5],
+            when=false,
+            mdata=[(m) -> (m.deep.data[i]) for i in 1:length(model.deep.data)],
         )
         @test Array{Float64,1}(model_data[1, 2:end]) == model.deep.data
     end
@@ -261,7 +257,7 @@ end
     end
 
     @testset "Mixed-ABM collections" begin
-        model = ABM(Union{Agent3,Agent4}, GridSpace((10, 10)); warn = false)
+        model = ABM(Union{Agent3,Agent4}, GridSpace((10, 10)); warn=false)
         add_agent_pos!(Agent3(1, (6, 8), 54.65), model)
         add_agent_pos!(Agent4(2, (10, 7), 5), model)
 
@@ -355,7 +351,7 @@ end
             pos::Dims{2}
             weight::Int
         end
-        model = ABM(Union{Agent3,Agent3Int}, GridSpace((10, 10)); warn = false)
+        model = ABM(Union{Agent3,Agent3Int}, GridSpace((10, 10)); warn=false)
         add_agent_pos!(Agent3(1, (6, 8), 54.65), model)
         add_agent_pos!(Agent3Int(2, (10, 7), 5), model)
         add_agent_pos!(Agent3(3, (2, 4), 19.81), model)
@@ -380,14 +376,14 @@ end
         @test df[1, :sum_fweight] ≈ 82.46
 
         # Handle dataframe initialization when one agent type is absent
-        model = ABM(Union{Agent3,Agent4}, GridSpace((10, 10)); warn = false)
+        model = ABM(Union{Agent3,Agent4}, GridSpace((10, 10)); warn=false)
         add_agent_pos!(Agent3(1, (6, 8), 54.65), model)
 
         # get fieldtype from Agent4 struct definition when agent is absent 
         props = [:weight, :p]
         df = init_agent_dataframe(model, props)
-        @test eltype(df[!, :p]) == Union{Int, Missing}
-        
+        @test eltype(df[!, :p]) == Union{Int,Missing}
+
         # Add Agent4 and check data collection
         add_agent_pos!(Agent4(2, (4, 1), 3), model)
         collect_agent_data!(df, model, props)
@@ -403,11 +399,11 @@ end
         model_props = [:container]
         model_data = init_model_dataframe(model, model_props)
         push!(model.container, 50.0)
-        collect_model_data!(model_data, model, model_props, 0; obtainer = copy)
+        collect_model_data!(model_data, model, model_props, 0; obtainer=copy)
         push!(model.container, 37.2)
-        collect_model_data!(model_data, model, model_props, 1; obtainer = copy)
+        collect_model_data!(model_data, model, model_props, 1; obtainer=copy)
         model.container[1] += 21.9
-        collect_model_data!(model_data, model, model_props, 2; obtainer = copy)
+        collect_model_data!(model_data, model, model_props, 2; obtainer=copy)
         @test model_data.container[1][1] ≈ 50.0
         @test model_data.container[3][1] ≈ 71.9
         @test length.(model_data.container) == [1, 2, 2]
@@ -416,11 +412,11 @@ end
         model_props = [:deep]
         model_data = init_model_dataframe(model, model_props)
         push!(model.deep.data, 17.5)
-        collect_model_data!(model_data, model, model_props, 0; obtainer = deepcopy)
+        collect_model_data!(model_data, model, model_props, 0; obtainer=deepcopy)
         push!(model.deep.data, 1.2)
-        collect_model_data!(model_data, model, model_props, 1; obtainer = deepcopy)
+        collect_model_data!(model_data, model, model_props, 1; obtainer=deepcopy)
         model.deep.data[1] += 0.9
-        collect_model_data!(model_data, model, model_props, 2; obtainer = deepcopy)
+        collect_model_data!(model_data, model, model_props, 2; obtainer=deepcopy)
         @test model_data[1, :deep].data[1] ≈ 20.0
         @test model_data[3, :deep].data[1] ≈ 20.9
         @test [length(d.data) for d in model_data[!, :deep]] == [3, 4, 4]
@@ -431,11 +427,11 @@ end
             agent_step!,
             model_step!,
             365 * 5;
-            when_model = [1, 365 * 5],
-            when = false,
-            mdata = [:flag, :year, :container, :deep],
-            adata = [(:weight, mean)],
-            obtainer = deepcopy,
+            when_model=[1, 365 * 5],
+            when=false,
+            mdata=[:flag, :year, :container, :deep],
+            adata=[(:weight, mean)],
+            obtainer=deepcopy,
         )
         @test size(agent_data) == (0, 2)
         @test size(model_data) == (2, 5)
@@ -448,11 +444,7 @@ end
             b::Bool
         end
 
-        model = ABM(
-            Agent3,
-            GridSpace((10, 10));
-            properties=Props(1, false),
-        )
+        model = ABM(Agent3, GridSpace((10, 10)); properties=Props(1, false))
         mdata = [:a, :b]
 
         model_data = init_model_dataframe(model, mdata)
@@ -461,7 +453,6 @@ end
 end
 
 @testset "Ensemble runs" begin
-
     nsteps = 100
     nreplicates = 2
     numagents_low = 280
@@ -470,54 +461,74 @@ end
 
     expected_nensembles = nreplicates * (numagents_high - numagents_low + 1)
     function genmodels()
-        basemodels = [Models.schelling(; numagents)[1]
-                      for numagents in numagents_low:numagents_high]
+        basemodels = [
+            Models.schelling(; numagents)[1] for numagents in numagents_low:numagents_high
+        ]
 
         return repeat(basemodels, nreplicates)
     end
 
-    @testset begin "Serial ensemblerun!"
+    @testset begin
+        "Serial ensemblerun!"
 
         models = genmodels()
         @assert length(models) == expected_nensembles
 
-        adf, mdf, _ = ensemblerun!(models, schelling_agent_step!, dummystep, nsteps;
-                                   parallel = false, adata = [:pos, :mood, :group],
-                                   mdata = [numagents, :min_to_be_happy])
+        adf, mdf, _ = ensemblerun!(
+            models,
+            schelling_agent_step!,
+            dummystep,
+            nsteps;
+            parallel=false,
+            adata=[:pos, :mood, :group],
+            mdata=[numagents, :min_to_be_happy],
+        )
 
         @test length(unique(adf.ensemble)) == expected_nensembles
         @test length(unique(adf.step)) == nsteps + 1
         @test length(unique(mdf.numagents)) == (numagents_high - numagents_low + 1)
     end
 
-    @testset begin "Parallel ensemblerun!"
+    @testset begin
+        "Parallel ensemblerun!"
 
         models = genmodels()
         @assert length(models) == expected_nensembles
 
-        adf, mdf, _ = ensemblerun!(models, schelling_agent_step!, dummystep, nsteps;
-                                   parallel = true,
-                                   adata = [:pos, :mood, :group],
-                                   mdata = [numagents, :min_to_be_happy],
-                                   when = (model, step) -> step % 10 == 0 )
+        adf, mdf, _ = ensemblerun!(
+            models,
+            schelling_agent_step!,
+            dummystep,
+            nsteps;
+            parallel=true,
+            adata=[:pos, :mood, :group],
+            mdata=[numagents, :min_to_be_happy],
+            when=(model, step) -> step % 10 == 0,
+        )
 
         @test length(unique(adf.ensemble)) == expected_nensembles
         @test length(unique(adf.step)) == (nsteps / 10) + 1
         @test length(unique(mdf.numagents)) == (numagents_high - numagents_low + 1)
     end
 
-    @testset begin "Parallel ensemblerun! with stopping function"
+    @testset begin
+        "Parallel ensemblerun! with stopping function"
 
         models = genmodels()
         @assert length(models) == expected_nensembles
 
         stopfn(model, step) = all(map(agent -> agent.mood, allagents(model)))
 
-        adf, mdf, _ = ensemblerun!(models, schelling_agent_step!, dummystep, stopfn;
-                                   parallel = true,
-                                   adata = [:pos, :mood, :group],
-                                   mdata = [numagents, :min_to_be_happy],
-                                   when = (model, step) -> step % 10 == 0 )
+        adf, mdf, _ = ensemblerun!(
+            models,
+            schelling_agent_step!,
+            dummystep,
+            stopfn;
+            parallel=true,
+            adata=[:pos, :mood, :group],
+            mdata=[numagents, :min_to_be_happy],
+            when=(model, step) -> step % 10 == 0,
+        )
 
         @test length(unique(adf.ensemble)) == expected_nensembles
         @test length(unique(adf.step)) ≤ (nsteps / 10) + 1
@@ -527,9 +538,9 @@ end
 
 @testset "Parameter scan" begin
     @everywhere @agent Automata GridAgent{2} begin end
-    function forest_fire(; density = 0.7, griddims = (100, 100))
-        space = GridSpace(griddims; periodic = false, metric = :euclidean)
-        forest = ABM(Automata, space; properties = (trees = zeros(Int, griddims),))
+    function forest_fire(; density=0.7, griddims=(100, 100))
+        space = GridSpace(griddims; periodic=false, metric=:euclidean)
+        forest = ABM(Automata, space; properties=(trees=zeros(Int, griddims),))
         for I in CartesianIndices(forest.trees)
             if rand(forest.rng) < density
                 forest.trees[I] = I[1] == 1 ? 2 : 1
@@ -558,11 +569,7 @@ end
     @testset "Serial Scan" begin
         mdata = [unburnt, burnt]
         _, mdf = paramscan(
-            parameters,
-            forest_fire;
-            n,
-            model_step! = forest_model_step!,
-            mdata,
+            parameters, forest_fire; n, (model_step!)=forest_model_step!, mdata
         )
         # 3 is the number of combinations of changing params
         @test size(mdf) == ((n + 1) * 3, 4)
@@ -570,8 +577,8 @@ end
             parameters,
             forest_fire;
             n,
-            model_step! = forest_model_step!,
-            include_constants = true,
+            (model_step!)=forest_model_step!,
+            include_constants=true,
             mdata,
         )
         # 3 is the number of combinations of changing params,
@@ -579,11 +586,7 @@ end
         @test size(mdf) == ((n + 1) * 3, 5)
         mdata = [burnt]
         _, mdf = paramscan(
-            parameters,
-            forest_fire;
-            n,
-            model_step! = forest_model_step!,
-            mdata,
+            parameters, forest_fire; n, (model_step!)=forest_model_step!, mdata
         )
         @test unique(mdf.step) == 0:10
         @test unique(mdf.density) == [0.6, 0.7, 0.8]
@@ -591,22 +594,15 @@ end
         # test whether paramscan accepts n::Function
         mdata = []
         _, mdf = paramscan(
-            parameters,
-            forest_fire;
-            n = terminate,
-            model_step! = forest_model_step!,
-            mdata)
+            parameters, forest_fire; n=terminate, (model_step!)=forest_model_step!, mdata
+        )
         @test unique(mdf.step) == 0:3
     end
 
     @testset "Parallel Scan" begin
         mdata = [unburnt, burnt]
         _, mdf = paramscan(
-            parameters,
-            forest_fire;
-            n,
-            model_step! = forest_model_step!,
-            mdata,
+            parameters, forest_fire; n, (model_step!)=forest_model_step!, mdata
         )
         # 3 is the number of combinations of changing params
         @test size(mdf) == ((n + 1) * 3, 4)
@@ -614,10 +610,10 @@ end
             parameters,
             forest_fire;
             n,
-            model_step! = forest_model_step!,
-            include_constants = true,
+            (model_step!)=forest_model_step!,
+            include_constants=true,
             mdata,
-            parallel = true
+            parallel=true,
         )
         # 3 is the number of combinations of changing params,
         # 5 is 3+2, where 2 is the number of constant parameters
@@ -627,9 +623,9 @@ end
             parameters,
             forest_fire;
             n,
-            model_step! = forest_model_step!,
+            (model_step!)=forest_model_step!,
             mdata,
-            parallel = true
+            parallel=true,
         )
         @test unique(mdf.step) == 0:10
         @test unique(mdf.density) == [0.6, 0.7, 0.8]
@@ -639,10 +635,11 @@ end
         _, mdf = paramscan(
             parameters,
             forest_fire;
-            n = terminate,
-            model_step! = forest_model_step!,
+            n=terminate,
+            (model_step!)=forest_model_step!,
             mdata,
-            parallel = true)
+            parallel=true,
+        )
         @test unique(mdf.step) == 0:3
     end
 end
@@ -653,7 +650,7 @@ end
     for i in 1:5
         add_agent!(model, i * 0.2)
     end
-    data, _ = run!(model, dummystep, 2; adata = [:weight])
+    data, _ = run!(model, dummystep, 2; adata=[:weight])
     @test data[1, :id] == 1 && data[1, :weight] ≈ 0.2
     @test data[3, :id] == 3 && data[3, :weight] ≈ 0.6
     @test data[6, :id] == 1 && data[6, :weight] ≈ 0.2
@@ -661,9 +658,9 @@ end
 
 @testset "ensemblerun! and different seeds" begin
     function fake_model(seed)
-        abm = ABM(Agent4, GridSpace((4, 4)); rng = MersenneTwister(seed))
+        abm = ABM(Agent4, GridSpace((4, 4)); rng=MersenneTwister(seed))
         fill_space!(abm, _ -> rand(abm.rng, 1:1000))
-        abm
+        return abm
     end
     as!(agent, model) = (agent.p = rand(model.rng, 1:1000))
     seeds = [1234, 563, 211]
diff --git a/test/continuous_space_tests.jl b/test/continuous_space_tests.jl
index 83e0bd13fe..97ab7479b2 100644
--- a/test/continuous_space_tests.jl
+++ b/test/continuous_space_tests.jl
@@ -11,18 +11,18 @@ using LinearAlgebra: norm, dot
 
     @testset "space initialization" begin
         space1 = ContinuousSpace((1, 1))
-        space2 = ContinuousSpace((1, 1, 1); spacing=0.25, periodic = false)
+        space2 = ContinuousSpace((1, 1, 1); spacing=0.25, periodic=false)
         @test spacesize(space1) == (1.0, 1.0)
         @test spacesize(space2) == (1.0, 1.0, 1.0)
-        @test_throws ArgumentError ContinuousSpace((-1,1)) # Cannot have negative extent
-        @test_throws MethodError ContinuousSpace([1,1]) # Must be a tuple
+        @test_throws ArgumentError ContinuousSpace((-1, 1)) # Cannot have negative extent
+        @test_throws MethodError ContinuousSpace([1, 1]) # Must be a tuple
         model = ABM(SpeedyContinuousAgent, space1)
         model2 = ABM(SpeedyContinuousAgent, space2)
     end
 
     @testset "add/kill/move agent" begin
         space1 = ContinuousSpace((1, 1))
-        model = ABM(SpeedyContinuousAgent, space1; rng = StableRNG(42))
+        model = ABM(SpeedyContinuousAgent, space1; rng=StableRNG(42))
         @test nagents(model) == 0
         # add_agent! with no existing agent (the agent is created)
         pos0 = (0.51, 0.51)
@@ -102,18 +102,17 @@ using LinearAlgebra: norm, dot
             @test collect(nearby_ids(a, model, r1)) == [2]
             @test collect(nearby_ids_exact(a, model, r1)) == [2]
             # With position everything includes ID 1
-            @test collect(nearby_ids(a.pos, model, r0)) == [1,2]
+            @test collect(nearby_ids(a.pos, model, r0)) == [1, 2]
             @test collect(nearby_ids_exact(a.pos, model, r0)) == Int[1]
-            @test collect(nearby_ids(a.pos, model, r1)) == [1,2]
-            @test collect(nearby_ids_exact(a.pos, model, r1)) == [1,2]
+            @test collect(nearby_ids(a.pos, model, r1)) == [1, 2]
+            @test collect(nearby_ids_exact(a.pos, model, r1)) == [1, 2]
         end
     end
 
-
     @testset "Interacting pairs" begin
         @testset "standard" begin
-            space = ContinuousSpace((10, 10); spacing = 0.2, periodic = false)
-            model = ABM(SpeedyContinuousAgent, space; scheduler = Schedulers.ByID())
+            space = ContinuousSpace((10, 10); spacing=0.2, periodic=false)
+            model = ABM(SpeedyContinuousAgent, space; scheduler=Schedulers.ByID())
             pos = [
                 (7.074386436066224, 4.963014649338054)
                 (5.831962448496828, 4.926297135685473)
@@ -121,14 +120,14 @@ using LinearAlgebra: norm, dot
                 (3.9715633336430156, 4.8106570045816675)
             ]
             for i in 1:4
-                add_agent_pos!(SpeedyContinuousAgent(i+2, pos[i], (0.0, 0.0), 0), model)
+                add_agent_pos!(SpeedyContinuousAgent(i + 2, pos[i], (0.0, 0.0), 0), model)
             end
             pairs = interacting_pairs(model, 2.0, :all).pairs
             @test length(pairs) == 5
             @test (3, 6) ∉ pairs
 
-            space2 = ContinuousSpace((10, 10); spacing = 0.1, periodic = false)
-            model2 = ABM(SpeedyContinuousAgent, space2; scheduler = Schedulers.ByID())
+            space2 = ContinuousSpace((10, 10); spacing=0.1, periodic=false)
+            model2 = ABM(SpeedyContinuousAgent, space2; scheduler=Schedulers.ByID())
             for i in 1:4
                 add_agent_pos!(SpeedyContinuousAgent(i, pos[i], (0.0, 0.0), 0), model2)
             end
@@ -150,50 +149,60 @@ using LinearAlgebra: norm, dot
                 vel::NTuple{2,Float64}
             end
             function ignore_normal(model::ABM)
-                [a.id for a in allagents(model) if !(typeof(a) <: SpeedyContinuousAgent)]
+                return [
+                    a.id for a in allagents(model) if !(typeof(a) <: SpeedyContinuousAgent)
+                ]
             end
-            space3 = ContinuousSpace((10,10); spacing = 1.0, periodic = false)
-            model3 = ABM(Union{SpeedyContinuousAgent, AgentU1, AgentU2}, space3; warn = false)
+            space3 = ContinuousSpace((10, 10); spacing=1.0, periodic=false)
+            model3 = ABM(Union{SpeedyContinuousAgent,AgentU1,AgentU2}, space3; warn=false)
             for i in 1:10
-                add_agent_pos!(SpeedyContinuousAgent(i, (i/10, i/10), (0.0, 0.0), 0), model3)
+                add_agent_pos!(
+                    SpeedyContinuousAgent(i, (i / 10, i / 10), (0.0, 0.0), 0), model3
+                )
             end
             for i in 11:20
-                add_agent_pos!(AgentU1(i, (i/10-1, 0.5), (0.0, 0.0)), model3)
+                add_agent_pos!(AgentU1(i, (i / 10 - 1, 0.5), (0.0, 0.0)), model3)
             end
             for i in 21:30
-                add_agent_pos!(AgentU2(i, (0.45, i/10-2), (0.0, 0.0)), model3)
+                add_agent_pos!(AgentU2(i, (0.45, i / 10 - 2), (0.0, 0.0)), model3)
             end
             pairs = interacting_pairs(model3, 0.1, :types).pairs
             @test length(pairs) == 7
-            for (a,b) in pairs
+            for (a, b) in pairs
                 @test typeof(model3[a]) !== typeof(model3[b])
             end
             @test (3, 6) ∉ pairs
 
             # Test that we have at least some SpeedyContinuousAgent's in this match
-            @test any(typeof(model3[a]) <: SpeedyContinuousAgent || typeof(model3[b]) <: SpeedyContinuousAgent for (a,b) in pairs)
-            pairs = interacting_pairs(model3, 0.2, :types; scheduler = ignore_normal).pairs
+            @test any(
+                typeof(model3[a]) <: SpeedyContinuousAgent ||
+                typeof(model3[b]) <: SpeedyContinuousAgent for (a, b) in pairs
+            )
+            pairs = interacting_pairs(model3, 0.2, :types; scheduler=ignore_normal).pairs
             @test length(pairs) == 12
             # No SpeedyContinuousAgent's when using the ignore_normal scheduler
-            @test all(!(typeof(model3[a]) <: SpeedyContinuousAgent) && !(typeof(model3[b]) <: SpeedyContinuousAgent) for (a,b) in pairs)
+            @test all(
+                !(typeof(model3[a]) <: SpeedyContinuousAgent) &&
+                !(typeof(model3[b]) <: SpeedyContinuousAgent) for (a, b) in pairs
+            )
         end
         @testset "fix #288" begin
-            space = ContinuousSpace((1,1); spacing = 0.1, periodic = true)
+            space = ContinuousSpace((1, 1); spacing=0.1, periodic=true)
             model = ABM(SpeedyContinuousAgent, space)
-            pos = [(0.01, 0.01),(0.2,0.2),(0.5,0.5)]
+            pos = [(0.01, 0.01), (0.2, 0.2), (0.5, 0.5)]
             for i in pos
-            add_agent!(i,model,(0.0,0.0),1.0)
+                add_agent!(i, model, (0.0, 0.0), 1.0)
             end
             pairs = collect(interacting_pairs(model, 0.29, :all))
             @test length(pairs) == 1
-            (a,b) = first(pairs)
-            @test (a.id, b.id) == (1,2)
+            (a, b) = first(pairs)
+            @test (a.id, b.id) == (1, 2)
             # Before the #288 fix, this would return (2,3) as a pair
             # which has a euclidean distance of 0.42
             pairs = collect(interacting_pairs(model, 0.3, :all))
             @test length(pairs) == 1
-            (a,b) = first(pairs)
-            @test (a.id, b.id) == (1,2)
+            (a, b) = first(pairs)
+            @test (a.id, b.id) == (1, 2)
         end
     end
 
@@ -204,11 +213,11 @@ using LinearAlgebra: norm, dot
             vel::NTuple{2,Float64}
             f1::Union{Int,Nothing}
         end
-        space = ContinuousSpace((1,1); spacing = 0.1, periodic = true)
+        space = ContinuousSpace((1, 1); spacing=0.1, periodic=true)
         model = ABM(AgentNNContinuous, space)
-        pos = [(0.01, 0.01),(0.2, 0.01),(0.2, 0.2),(0.5, 0.5)]
+        pos = [(0.01, 0.01), (0.2, 0.01), (0.2, 0.2), (0.5, 0.5)]
         for i in pos
-            add_agent!(i,model,(0.0,0.0),nothing)
+            add_agent!(i, model, (0.0, 0.0), nothing)
         end
 
         for agent in allagents(model)
@@ -223,7 +232,7 @@ using LinearAlgebra: norm, dot
 
     @testset "walk" begin
         # ContinuousSpace
-        model = ABM(SpeedyContinuousAgent, ContinuousSpace((12, 10); periodic = false))
+        model = ABM(SpeedyContinuousAgent, ContinuousSpace((12, 10); periodic=false))
         a = add_agent!((0.0, 0.0), model, (0.0, 0.0), rand(model.rng))
         walk!(a, (1.0, 1.0), model)
         @test a.pos == (1.0, 1.0)
@@ -231,7 +240,7 @@ using LinearAlgebra: norm, dot
         @test a.pos == (prevfloat(12.0), 2.0)
 
         @agent ContinuousAgent3D ContinuousAgent{3} begin end
-        model = ABM(ContinuousAgent3D, ContinuousSpace((12, 10, 5); spacing = 0.2))
+        model = ABM(ContinuousAgent3D, ContinuousSpace((12, 10, 5); spacing=0.2))
         a = add_agent!((0.0, 0.0, 0.0), model, (0.0, 0.0, 0.0))
         walk!(a, (1.0, 1.0, 1.0), model)
         @test a.pos == (1.0, 1.0, 1.0)
@@ -241,15 +250,13 @@ using LinearAlgebra: norm, dot
         # Must use Float64 for continuousspace
         @test_throws MethodError walk!(a, (1, 1, 5), model)
 
-
         @testset "periodic" begin
-            model = ABM(ContinuousAgent{2}, ContinuousSpace((12, 10); periodic = true))
+            model = ABM(ContinuousAgent{2}, ContinuousSpace((12, 10); periodic=true))
             a = add_agent!((11.0, 9.0), model, (3.0, 1.0))
             move_agent!(a, model, 1.0)
             @test a.pos[1] == 2
             @test a.pos[2] == 0.0
         end
-
     end
 
     @testset "collisions" begin
@@ -261,14 +268,15 @@ using LinearAlgebra: norm, dot
         end
 
         function model_initiation()
-            space = ContinuousSpace((10,10); periodic=true)
-            model = ABM(MassContinuousAgent, space;
-            rng=StableRNG(42), properties= Dict(:c => 0));
+            space = ContinuousSpace((10, 10); periodic=true)
+            model = ABM(
+                MassContinuousAgent, space; rng=StableRNG(42), properties=Dict(:c => 0)
+            )
             # Add initial individuals
             for i in 1:10, j in 1:10
-                    pos = (i/10, j/10)
+                pos = (i / 10, j / 10)
                 if i > 5
-                    vel = sincos(2π*rand(model.rng)) .* speed
+                    vel = sincos(2π * rand(model.rng)) .* speed
                     mass = 1.33
                 else
                     # these agents have infinite mass and 0 velocity. They are fixed.
@@ -297,7 +305,7 @@ using LinearAlgebra: norm, dot
             # Momentum
             p = (0.0, 0.0)
             for a in allagents(model)
-                 p = p .+ a.vel
+                p = p .+ a.vel
             end
             return K, p
         end
@@ -331,9 +339,9 @@ using LinearAlgebra: norm, dot
     end
 
     @testset "random walk" begin
-        ≃(x,y) = isapprox(x,y,atol=1e-12) # \simeq
+        ≃(x, y) = isapprox(x, y; atol=1e-12) # \simeq
         @testset "2D" begin
-            space = ContinuousSpace((10,10), periodic=true)
+            space = ContinuousSpace((10, 10); periodic=true)
             model = ABM(ContinuousAgent{2}, space)
             x₀ = (5.0, 5.0)
             v₀ = (1.0, 0.0)
@@ -348,13 +356,13 @@ using LinearAlgebra: norm, dot
             @test !(norm(model[1].pos .- x₀) ≃ norm(v₀))
 
             # verify that reorientations obey the specified angles
-            space = ContinuousSpace((10,10), periodic=true)
+            space = ContinuousSpace((10, 10); periodic=true)
             model = ABM(ContinuousAgent{2}, space)
             x₀ = (5.0, 5.0)
             v₀ = (1.0, 0.0)
             add_agent!(x₀, model, v₀)
             r = 1.0
-            polar = [π/2] # degenerate distribution, only π/2 reorientations
+            polar = [π / 2] # degenerate distribution, only π/2 reorientations
             # at the 4th step, the agent should come back to its initial position
             v₁ = (0.0, 1.0) # π/2
             x₁ = x₀ .+ v₁
@@ -376,8 +384,8 @@ using LinearAlgebra: norm, dot
             @test all(model[1].pos .≃ x₀)
 
             # verify boundary conditions are respected
-            space1 = ContinuousSpace((2,2), periodic=true)
-            space2 = ContinuousSpace((2,2), periodic=false)
+            space1 = ContinuousSpace((2, 2); periodic=true)
+            space2 = ContinuousSpace((2, 2); periodic=false)
             model1 = ABM(ContinuousAgent{2}, space1)
             model2 = ABM(ContinuousAgent{2}, space2)
             x₀ = (1.0, 1.0)
@@ -394,7 +402,7 @@ using LinearAlgebra: norm, dot
         end
 
         @testset "3D" begin
-            space = ContinuousSpace((10,10,10), periodic=true)
+            space = ContinuousSpace((10, 10, 10); periodic=true)
             model = ABM(ContinuousAgent{3}, space)
             x₀ = (5.0, 5.0, 5.0)
             v₀ = (1.0, 0.0, 0.0)
@@ -409,12 +417,12 @@ using LinearAlgebra: norm, dot
             @test !(norm(model[1].pos .- x₀) ≃ norm(v₀))
 
             # verify that reorientations obey the specified angles
-            space = ContinuousSpace((10,10,10), periodic=true)
+            space = ContinuousSpace((10, 10, 10); periodic=true)
             model = ABM(ContinuousAgent{3}, space)
             v₀ = (1.0, 0.0, 0.0)
             add_agent!(model, v₀)
             r = 1.0
-            θ = π/6
+            θ = π / 6
             polar = [θ]
             azimuthal = Arccos()
             randomwalk!(model[1], model, r; polar, azimuthal)
@@ -422,30 +430,29 @@ using LinearAlgebra: norm, dot
             v₁ = model[1].vel
             @test dot(v₁, v₀) ≃ cos(θ)
 
-            space = ContinuousSpace((10,10,10), periodic=true)
+            space = ContinuousSpace((10, 10, 10); periodic=true)
             model = ABM(ContinuousAgent{3}, space)
             v₀ = (1.0, 0.0, 0.0)
             add_agent!(model, v₀)
             r = 1.0
-            θ = π/4
-            φ = π/6
+            θ = π / 4
+            φ = π / 6
             polar = [θ]
             azimuthal = [φ]
             randomwalk!(model[1], model, r; polar, azimuthal)
             v₁ = model[1].vel
             @test v₁[1] ≃ cos(θ)
-            @test v₁[2] ≃ sin(θ)*sin(φ)
-            @test v₁[3] ≃ -sin(θ)*cos(φ)
+            @test v₁[2] ≃ sin(θ) * sin(φ)
+            @test v₁[3] ≃ -sin(θ) * cos(φ)
             @test dot(v₁, v₀) ≃ cos(θ)
 
             # test that velocity measure changes
-            space = ContinuousSpace((10,10,10), periodic=true)
+            space = ContinuousSpace((10, 10, 10); periodic=true)
             model = ABM(ContinuousAgent{3}, space)
             v₀ = (1.0, 0.0, 0.0)
             add_agent!(model, v₀)
             randomwalk!(model[1], model, 2)
             @test norm(model[1].vel) ≈ 2
-
         end
     end
 end
@@ -519,4 +526,4 @@ circ = [Point2f(cos(t)*r + cc[1], sin(t)*r + cc[2]) for t in range(0, 2π; lengt
 poly!(ax, circ; color = RGBAf(0.3, 0.2, 0.4, 0.0),
 strokecolor = RGBf(0.3, 0.5, 0.4), strokewidth = 1, linestyle = :dash)
 end
-=#
\ No newline at end of file
+=#
diff --git a/test/csv_tests.jl b/test/csv_tests.jl
index 73fae01ca9..5f85de109d 100644
--- a/test/csv_tests.jl
+++ b/test/csv_tests.jl
@@ -6,8 +6,8 @@
         previous_opinion::Float64
     end
 
-    function hk(; numagents = 100, ϵ = 0.2)
-        model = ABM(HKAgent, scheduler = Schedulers.fastest, properties = Dict(:ϵ => ϵ))
+    function hk(; numagents=100, ϵ=0.2)
+        model = ABM(HKAgent; scheduler=Schedulers.fastest, properties=Dict(:ϵ => ϵ))
         for i in 1:numagents
             o = rand(model.rng)
             add_agent!(model, o, o, -1)
@@ -16,66 +16,82 @@
     end
 
     HKAgent(id, op) = HKAgent(id, op, op, -1)
-    HKAgent(; id = -1, op1 = -1, op2 = -1, op3 = -1) = HKAgent(id, op1, op2, op3)
-    
-    Models.SchellingAgent(id, p1, p2, mood, group) = Models.SchellingAgent(id, (p1, p2), mood, group)
+    HKAgent(; id=-1, op1=-1, op2=-1, op3=-1) = HKAgent(id, op1, op2, op3)
+
+    function Models.SchellingAgent(id, p1, p2, mood, group)
+        return Models.SchellingAgent(id, (p1, p2), mood, group)
+    end
 
     @agent Foo GridAgent{2} begin end
     @agent Bar GridAgent{2} begin end
 
-    model = ABM(Union{Foo,Bar}, GridSpace((5,5)); warn = false)
-    
+    model = ABM(Union{Foo,Bar}, GridSpace((5, 5)); warn=false)
+
     @test_throws AssertionError AgentsIO.populate_from_csv!(model, "test.csv")
 
-    model = hk(; numagents = 10)
-    empty_model = hk(; numagents = 0)
+    model = hk(; numagents=10)
+    empty_model = hk(; numagents=0)
 
     AgentsIO.dump_to_csv("test.csv", allagents(model))
-    
+
     open("test.csv", "r") do f
         @test length(split(readline(f), ',')) == 4
     end
-    
+
     AgentsIO.populate_from_csv!(empty_model, "test.csv")
 
     @test nagents(empty_model) == nagents(model)
     @test all(haskey(empty_model.agents, i) for i in allids(model))
     @test all(model[i].old_opinion == empty_model[i].old_opinion for i in allids(model))
     @test all(model[i].new_opinion == empty_model[i].new_opinion for i in allids(model))
-    @test all(model[i].previous_opinion == empty_model[i].previous_opinion for i in allids(model))
+    @test all(
+        model[i].previous_opinion == empty_model[i].previous_opinion for i in allids(model)
+    )
 
     genocide!(empty_model)
-    AgentsIO.populate_from_csv!(empty_model, "test.csv", HKAgent, Dict(:id => 1, :op1 => 3, :op2 => 2))
-    
+    AgentsIO.populate_from_csv!(
+        empty_model, "test.csv", HKAgent, Dict(:id => 1, :op1 => 3, :op2 => 2)
+    )
+
     @test nagents(empty_model) == nagents(model)
     @test all(haskey(empty_model.agents, i) for i in allids(model))
     @test all(model[i].old_opinion == empty_model[i].old_opinion for i in allids(model))
     @test all(model[i].new_opinion == empty_model[i].new_opinion for i in allids(model))
-    @test all(model[i].previous_opinion == empty_model[i].previous_opinion for i in allids(model))
+    @test all(
+        model[i].previous_opinion == empty_model[i].previous_opinion for i in allids(model)
+    )
 
-    AgentsIO.dump_to_csv("test.csv", HKAgent[model[i] for i in 1:nagents(model)], [:old_opinion])
+    AgentsIO.dump_to_csv(
+        "test.csv", HKAgent[model[i] for i in 1:nagents(model)], [:old_opinion]
+    )
 
     open("test.csv", "r") do f
         @test length(split(readline(f), ',')) == 1
     end
 
     genocide!(empty_model)
-    AgentsIO.populate_from_csv!(empty_model, "test.csv"; row_number_is_id = true)
+    AgentsIO.populate_from_csv!(empty_model, "test.csv"; row_number_is_id=true)
 
     @test nagents(empty_model) == nagents(model)
     @test all(haskey(empty_model.agents, i) for i in allids(model))
     @test all(model[i].old_opinion == empty_model[i].old_opinion for i in allids(model))
     @test all(model[i].new_opinion == empty_model[i].new_opinion for i in allids(model))
-    @test all(model[i].previous_opinion == empty_model[i].previous_opinion for i in allids(model))
+    @test all(
+        model[i].previous_opinion == empty_model[i].previous_opinion for i in allids(model)
+    )
 
     genocide!(empty_model)
-    AgentsIO.populate_from_csv!(empty_model, "test.csv", HKAgent, Dict(:op1 => 1, :op2 => 1); row_number_is_id = true)
-    
+    AgentsIO.populate_from_csv!(
+        empty_model, "test.csv", HKAgent, Dict(:op1 => 1, :op2 => 1); row_number_is_id=true
+    )
+
     @test nagents(empty_model) == nagents(model)
     @test all(haskey(empty_model.agents, i) for i in allids(model))
     @test all(model[i].old_opinion == empty_model[i].old_opinion for i in allids(model))
     @test all(model[i].new_opinion == empty_model[i].new_opinion for i in allids(model))
-    @test all(model[i].previous_opinion == empty_model[i].previous_opinion for i in allids(model))
+    @test all(
+        model[i].previous_opinion == empty_model[i].previous_opinion for i in allids(model)
+    )
 
     AgentsIO.dump_to_csv("test.csv", allagents(model), [:id, :old_opinion])
 
@@ -90,10 +106,12 @@
     @test all(haskey(empty_model.agents, i) for i in allids(model))
     @test all(model[i].old_opinion == empty_model[i].old_opinion for i in allids(model))
     @test all(model[i].new_opinion == empty_model[i].new_opinion for i in allids(model))
-    @test all(model[i].previous_opinion == empty_model[i].previous_opinion for i in allids(model))
+    @test all(
+        model[i].previous_opinion == empty_model[i].previous_opinion for i in allids(model)
+    )
 
-    model, _ = Models.schelling(; numagents = 10)
-    empty_model, _ = Models.schelling(; numagents = 0)
+    model, _ = Models.schelling(; numagents=10)
+    empty_model, _ = Models.schelling(; numagents=0)
 
     AgentsIO.dump_to_csv("test.csv", allagents(model))
     AgentsIO.populate_from_csv!(empty_model, "test.csv")
@@ -103,7 +121,6 @@
     @test all(model[i].pos == empty_model[i].pos for i in allids(model))
     @test all(model[i].mood == empty_model[i].mood for i in allids(model))
     @test all(model[i].group == empty_model[i].group for i in allids(model))
-    
+
     rm("test.csv")
 end
-    
\ No newline at end of file
diff --git a/test/graph_tests.jl b/test/graph_tests.jl
index c4defbdd7a..2873cccff2 100644
--- a/test/graph_tests.jl
+++ b/test/graph_tests.jl
@@ -2,7 +2,6 @@ using Agents, Test
 using Agents.Graphs
 
 @testset "mutable graph" begin
-
     g = complete_digraph(5)
     abm = ABM(GraphAgent, GraphSpace(g))
     for n in 1:5
@@ -41,5 +40,4 @@ using Agents.Graphs
     @test add_edge!(abm, 1, 2) == false
     add_vertex!(abm)
     @test add_edge!(abm, 1, 2) == true
-
 end
diff --git a/test/grid_space_tests.jl b/test/grid_space_tests.jl
index ee2a286710..0023888f54 100644
--- a/test/grid_space_tests.jl
+++ b/test/grid_space_tests.jl
@@ -2,7 +2,7 @@ using Test, Agents, Random
 using StableRNGs
 
 @testset "$(SpaceType)" for SpaceType in (GridSpace, GridSpaceSingle)
-    @testset "size, dim=$D" for D in (1,3)
+    @testset "size, dim=$D" for D in (1, 3)
         dims = (fill(5, D)...,)
         for periodic in (true, false)
             space = SpaceType(dims; periodic)
@@ -15,17 +15,17 @@ using StableRNGs
 
     @testset "add/move/kill" begin
         space = SpaceType((3, 3))
-        model = ABM(GridAgent{2}, space; rng = StableRNG(42))
-        pos0 = (2,2)
+        model = ABM(GridAgent{2}, space; rng=StableRNG(42))
+        pos0 = (2, 2)
         agent = add_agent!(pos0, model)
         id0 = agent.id
         @test collect(allids(model)) == [1]
         @test model[1].pos == agent.pos == pos0
-        move_agent!(agent, (3,3), model)
-        @test agent.pos == (3,3)
+        move_agent!(agent, (3, 3), model)
+        @test agent.pos == (3, 3)
         move_agent!(agent, model)
-        @test agent.pos != (3,3)
-        move_agent!(agent, (2,2), model)
+        @test agent.pos != (3, 3)
+        move_agent!(agent, (2, 2), model)
         kill_agent!(agent, model)
         @test id0 ∉ allids(model)
         # Test move single
@@ -82,28 +82,30 @@ using StableRNGs
     end
 
     @testset "Distances" begin
-    @testset "Euclidean distance" begin
-        model = ABM(GridAgent{2}, SpaceType((12, 10); periodic = true))
-        a = add_agent!((1.0, 6.0), model)
-        b = add_agent!((11.0, 4.0), model)
-        @test euclidean_distance(a, b, model) ≈ 2.82842712
+        @testset "Euclidean distance" begin
+            model = ABM(GridAgent{2}, SpaceType((12, 10); periodic=true))
+            a = add_agent!((1.0, 6.0), model)
+            b = add_agent!((11.0, 4.0), model)
+            @test euclidean_distance(a, b, model) ≈ 2.82842712
 
-        model = ABM(GridAgent{2}, SpaceType((12, 10); periodic = false))
-        a = add_agent!((1.0, 6.0), model)
-        b = add_agent!((11.0, 4.0), model)
-        @test euclidean_distance(a, b, model) ≈ 10.198039
-    end
-    @testset "Manhattan Distance" begin
-        model = ABM(GridAgent{2}, SpaceType((12, 10); metric = :manhattan, periodic = true))
-        a = add_agent!((1.0, 6.0), model)
-        b = add_agent!((11.0, 4.0), model)
-        @test manhattan_distance(a, b, model) ≈ 4
+            model = ABM(GridAgent{2}, SpaceType((12, 10); periodic=false))
+            a = add_agent!((1.0, 6.0), model)
+            b = add_agent!((11.0, 4.0), model)
+            @test euclidean_distance(a, b, model) ≈ 10.198039
+        end
+        @testset "Manhattan Distance" begin
+            model = ABM(GridAgent{2}, SpaceType((12, 10); metric=:manhattan, periodic=true))
+            a = add_agent!((1.0, 6.0), model)
+            b = add_agent!((11.0, 4.0), model)
+            @test manhattan_distance(a, b, model) ≈ 4
 
-        model = ABM(GridAgent{2}, SpaceType((12, 10); metric = :manhattan, periodic = false))
-        a = add_agent!((1.0, 6.0), model)
-        b = add_agent!((11.0, 4.0), model)
-        @test manhattan_distance(a, b, model) ≈ 12
-    end
+            model = ABM(
+                GridAgent{2}, SpaceType((12, 10); metric=:manhattan, periodic=false)
+            )
+            a = add_agent!((1.0, 6.0), model)
+            b = add_agent!((11.0, 4.0), model)
+            @test manhattan_distance(a, b, model) ≈ 12
+        end
     end
 
     @testset "Nearby pos/ids/agents" begin
@@ -121,20 +123,21 @@ using StableRNGs
                         sort!([(2, 1), (1, 2), (3, 2), (2, 3)])
                     if !periodic
                         @test sort!(collect(nearby_positions((1, 1), model))) ==
-                        sort!([(1, 2), (2, 1)])
+                            sort!([(1, 2), (2, 1)])
                     else # in periodic case we still have all nearby 4 positions
                         @test sort!(collect(nearby_positions((1, 1), model))) ==
-                        sort!([(1, 2), (2, 1), (1 ,5), (5, 1)])
+                            sort!([(1, 2), (2, 1), (1, 5), (5, 1)])
                     end
                 elseif metric == :chebyshev
                     @test sort!(collect(nearby_positions((2, 2), model))) ==
-                        [(1,1), (1,2), (1,3), (2,1), (2,3), (3,1), (3,2), (3,3)]
+                        [(1, 1), (1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3)]
                     if !periodic
                         @test sort!(collect(nearby_positions((1, 1), model))) ==
-                            [(1,2), (2,1), (2,2)]
+                            [(1, 2), (2, 1), (2, 2)]
                     else
-                        @test sort!(collect(nearby_positions((1, 1), model))) ==
-                            [(1,2), (1,5), (2,1), (2,2), (2,5), (5,1), (5,2), (5,5)]
+                        @test sort!(collect(nearby_positions((1, 1), model))) == [
+                            (1, 2), (1, 5), (2, 1), (2, 2), (2, 5), (5, 1), (5, 2), (5, 5)
+                        ]
                     end
                 end
 
@@ -153,19 +156,22 @@ using StableRNGs
                 if !periodic && metric ∈ (:euclidean, :mahnattan)
                     near_agent == [1]
                 elseif periodic && metric ∈ (:euclidean, :mahnattan)
-                    near_agent == [1,4]
+                    near_agent == [1, 4]
                 elseif !periodic && metric == :chebyshev
-                    near_agent == [1,3]
+                    near_agent == [1, 3]
                 elseif periodic && metric == :chebyshev
-                    near_agent == [1,3,4]
+                    near_agent == [1, 3, 4]
                 end
-
             end
             # also test larger r. See figure at docs for metrics to get the numbers
-            models = [ABM(GridAgent{2}, SpaceType((9, 9); metric, periodic)) for metric in metrics]
-            for m in models; fill_space!(m); end
-            near_pos = [collect(nearby_positions((5,5), m, 3.4)) for m in models]
-            near_ids = [collect(nearby_ids((5,5), m, 3.4)) for m in models] # this is 1 more
+            models = [
+                ABM(GridAgent{2}, SpaceType((9, 9); metric, periodic)) for metric in metrics
+            ]
+            for m in models
+                fill_space!(m)
+            end
+            near_pos = [collect(nearby_positions((5, 5), m, 3.4)) for m in models]
+            near_ids = [collect(nearby_ids((5, 5), m, 3.4)) for m in models] # this is 1 more
             @test length(near_pos[1]) == length(near_pos[2]) + 4
             @test length(near_pos[3]) == 7^2 - 1
             @test length(near_ids[1]) == length(near_ids[2]) + 4
@@ -176,7 +182,7 @@ using StableRNGs
 
     @testset "Random nearby" begin
         # Test random_nearby_*
-        abm = ABM(GridAgent{2}, GridSpace((10, 10)); rng = StableRNG(42))
+        abm = ABM(GridAgent{2}, GridSpace((10, 10)); rng=StableRNG(42))
         fill_space!(abm)
 
         nearby_id = random_nearby_id(abm[1], abm, 5)
@@ -189,15 +195,15 @@ using StableRNGs
         a = add_agent!((1, 1), abm)
         @test isnothing(random_nearby_id(a, abm))
         @test isnothing(random_nearby_agent(a, abm))
-        add_agent!((1,2), abm)
-        add_agent!((2,1), abm)
+        add_agent!((1, 2), abm)
+        add_agent!((2, 1), abm)
         rand_nearby_ids = Set([random_nearby_id(a, abm, 2) for _ in 1:100])
         @test length(rand_nearby_ids) == 2
     end
 
     @testset "walk!" begin
         # Periodic
-        model = ABM(GridAgent{2}, GridSpace((3, 3); periodic = true))
+        model = ABM(GridAgent{2}, GridSpace((3, 3); periodic=true))
         a = add_agent!((1, 1), model)
         walk!(a, (0, 1), model) # North
         @test a.pos == (1, 2)
@@ -220,12 +226,12 @@ using StableRNGs
         # if empty
         a = add_agent!((1, 1), model)
         add_agent!((2, 2), model)
-        walk!(a, (1, 1), model; ifempty = true)
+        walk!(a, (1, 1), model; ifempty=true)
         @test a.pos == (1, 1)
-        walk!(a, (1, 0), model; ifempty = true)
+        walk!(a, (1, 0), model; ifempty=true)
         @test a.pos == (2, 1)
         # aperiodic
-        model = ABM(GridAgent{2}, GridSpace((3, 3); periodic = false))
+        model = ABM(GridAgent{2}, GridSpace((3, 3); periodic=false))
         a = add_agent!((1, 1), model)
         walk!(a, (0, 1), model) # North
         @test a.pos == (1, 2)
@@ -256,16 +262,16 @@ using StableRNGs
 
     @testset "random walk" begin
         # random walks on grid spaces with euclidean metric are not defined
-        space = SpaceType((10,10), metric=:euclidean)
+        space = SpaceType((10, 10); metric=:euclidean)
         model = ABM(GridAgent{2}, space)
         add_agent!(model)
         r = 1.0
         @test_throws ArgumentError randomwalk!(model.agents[1], model, r)
 
         # chebyshev metric
-        space = SpaceType((100,100), metric=:chebyshev)
+        space = SpaceType((100, 100); metric=:chebyshev)
         model = ABM(GridAgent{2}, space)
-        x₀ = (50,50)
+        x₀ = (50, 50)
         add_agent!(x₀, model)
         r = 1.5
         randomwalk!(model.agents[1], model, r)
@@ -278,9 +284,9 @@ using StableRNGs
         @test model.agents[1].pos == x₁
 
         # manhattan metric
-        space = SpaceType((100,100), metric=:manhattan)
+        space = SpaceType((100, 100); metric=:manhattan)
         model = ABM(GridAgent{2}, space)
-        x₀ = (50,50)
+        x₀ = (50, 50)
         add_agent!(x₀, model)
         r = 1.5
         randomwalk!(model.agents[1], model, r)
@@ -292,13 +298,15 @@ using StableRNGs
         randomwalk!(model.agents[1], model, r)
         @test model.agents[1].pos == x₁
 
-        space = SpaceType((100,100), metric=:manhattan)
+        space = SpaceType((100, 100); metric=:manhattan)
         model = ABM(GridAgent{2}, space)
-        pos = (50,50)
+        pos = (50, 50)
         add_agent!(pos, model) # agent id = 1
         # fill surrounding positions with other agents
-        offsets = [(-1,0), (1,0), (0,1), (0,-1)]
-        for β in offsets; add_agent!(pos.+β, model); end
+        offsets = [(-1, 0), (1, 0), (0, 1), (0, -1)]
+        for β in offsets
+            add_agent!(pos .+ β, model)
+        end
         if SpaceType == GridSpaceSingle
             # agent 1 should not move since there are no available offsets
             randomwalk!(model.agents[1], model, 1)
@@ -312,7 +320,7 @@ using StableRNGs
             # to the position that was just freed
             randomwalk!(model.agents[2], model, 1)
             randomwalk!(model.agents[1], model, 1)
-            @test model.agents[1].pos == (49,50)
+            @test model.agents[1].pos == (49, 50)
         elseif SpaceType == GridSpace
             # if ifempty=true (default), agent 1 should not move since there are
             # no available offsets
@@ -324,10 +332,9 @@ using StableRNGs
             @test model.agents[1].pos ≠ pos
             # 5 agents but only 4 unique positions
             unique_pos = unique([a.second.pos for a in model.agents])
-            @test (length(model.agents)==5) && length(unique_pos)==4
+            @test (length(model.agents) == 5) && length(unique_pos) == 4
         end
     end
-
 end
 
 # TODO: Test nearby_ids(r = Tuple)
diff --git a/test/jld2_tests.jl b/test/jld2_tests.jl
index 791432f5da..baf464e40a 100644
--- a/test/jld2_tests.jl
+++ b/test/jld2_tests.jl
@@ -2,23 +2,34 @@
 # TODO: None of these tests should access internal fields like .stored_ids!
 # instead they should use public API like `ids_in_position` etc.
 @testset "JLD2" begin
-
     function test_model_data(model, other)
-        @test (model.scheduler isa Function && model.scheduler == other.scheduler) || (!isa(model.scheduler, Function) && typeof(model.scheduler) == typeof(other.scheduler))
+        @test (model.scheduler isa Function && model.scheduler == other.scheduler) || (
+            !isa(model.scheduler, Function) &&
+            typeof(model.scheduler) == typeof(other.scheduler)
+        )
         @test model.rng == other.rng
         @test model.maxid.x == other.maxid.x
     end
 
     function test_space(space::GridSpace, other)
         @test size(space) == size(other)
-        @test all(length(other.stored_ids[pos]) == length(space.stored_ids[pos]) for pos in eachindex(space.stored_ids))
-        @test all(all(x in other.stored_ids[pos] for x in space.stored_ids[pos]) for pos in eachindex(space.stored_ids))
+        @test all(
+            length(other.stored_ids[pos]) == length(space.stored_ids[pos]) for
+            pos in eachindex(space.stored_ids)
+        )
+        @test all(
+            all(x in other.stored_ids[pos] for x in space.stored_ids[pos]) for
+            pos in eachindex(space.stored_ids)
+        )
         @test space.metric == other.metric
     end
 
     function test_space(space::GridSpaceSingle, other)
         @test size(space) == size(other)
-        @test all(other.stored_ids[pos] == space.stored_ids[pos] for pos in eachindex(space.stored_ids))
+        @test all(
+            other.stored_ids[pos] == space.stored_ids[pos] for
+            pos in eachindex(space.stored_ids)
+        )
         @test space.metric == other.metric
     end
 
@@ -31,25 +42,25 @@
     end
 
     test_costmetric(metric, other) = @test false
-    test_costmetric(
-        metric::Pathfinding.DirectDistance{D},
-        other::Pathfinding.DirectDistance{D}
-    ) where {D} = @test metric.direction_costs == other.direction_costs
+    function test_costmetric(
+        metric::Pathfinding.DirectDistance{D}, other::Pathfinding.DirectDistance{D}
+    ) where {D}
+        @test metric.direction_costs == other.direction_costs
+    end
 
-    test_costmetric(
-        metric::Pathfinding.MaxDistance{D},
-        other::Pathfinding.MaxDistance{D}
-    ) where {D} = @test true
+    function test_costmetric(
+        metric::Pathfinding.MaxDistance{D}, other::Pathfinding.MaxDistance{D}
+    ) where {D}
+        @test true
+    end
 
     function test_costmetric(
-        metric::Pathfinding.PenaltyMap{D},
-        other::Pathfinding.PenaltyMap{D}
+        metric::Pathfinding.PenaltyMap{D}, other::Pathfinding.PenaltyMap{D}
     ) where {D}
         @test metric.pmap == other.pmap
-        test_costmetric(metric.base_metric, other.base_metric)
+        return test_costmetric(metric.base_metric, other.base_metric)
     end
 
-
     function test_astar(astar, other)
         @test typeof(astar) == typeof(other)
         @test astar.agent_paths == other.agent_paths
@@ -57,7 +68,7 @@
         @test astar.neighborhood == other.neighborhood
         @test astar.admissibility == other.admissibility
         @test astar.walkmap == other.walkmap
-        test_costmetric(astar.cost_metric, other.cost_metric)
+        return test_costmetric(astar.cost_metric, other.cost_metric)
     end
 
     function test_pathfinding_model(model, other)
@@ -71,11 +82,11 @@
         @test typeof(model.space) == typeof(other.space)    # to check periodicity
         test_space(model.space, other.space)
         # pathfinder data
-        test_astar(model.pathfinder, other.pathfinder)
+        return test_astar(model.pathfinder, other.pathfinder)
     end
 
     @testset "No space" begin
-        model = ABM(Agent2, nothing; properties = Dict(:abc => 123), rng = MersenneTwister(42))
+        model = ABM(Agent2, nothing; properties=Dict(:abc => 123), rng=MersenneTwister(42))
         for i in 1:100
             add_agent!(model, rand(model.rng))
         end
@@ -98,7 +109,7 @@
         model, astep, mstep = Models.schelling()
         step!(model, astep, mstep, 50)
         AgentsIO.save_checkpoint("test.jld2", model)
-        other = AgentsIO.load_checkpoint("test.jld2"; scheduler = Schedulers.Randomly())
+        other = AgentsIO.load_checkpoint("test.jld2"; scheduler=Schedulers.Randomly())
 
         # agent data
         @test nagents(other) == nagents(model)
@@ -117,11 +128,13 @@
     end
 
     @testset "GridSpaceSingle" begin
-        function schelling_single(; numagents = 320, griddims = (20, 20), min_to_be_happy = 3)
+        function schelling_single(; numagents=320, griddims=(20, 20), min_to_be_happy=3)
             @assert numagents < prod(griddims)
-            space = GridSpaceSingle(griddims, periodic = false)
+            space = GridSpaceSingle(griddims; periodic=false)
             properties = Dict(:min_to_be_happy => min_to_be_happy)
-            model = ABM(Models.SchellingAgent, space; properties, scheduler = Schedulers.Randomly())
+            model = ABM(
+                Models.SchellingAgent, space; properties, scheduler=Schedulers.Randomly()
+            )
             for n in 1:numagents
                 agent = Models.SchellingAgent(n, (1, 1), false, n < numagents / 2 ? 1 : 2)
                 add_agent_single!(agent, model)
@@ -132,7 +145,7 @@
         model, astep, mstep = Models.schelling()
         step!(model, astep, mstep, 50)
         AgentsIO.save_checkpoint("test.jld2", model)
-        other = AgentsIO.load_checkpoint("test.jld2"; scheduler = Schedulers.Randomly())
+        other = AgentsIO.load_checkpoint("test.jld2"; scheduler=Schedulers.Randomly())
 
         # agent data
         @test nagents(other) == nagents(model)
@@ -151,10 +164,10 @@
     end
 
     @testset "ContinuousSpace" begin
-        model, astep, mstep = Models.flocking(n_birds = 300)
+        model, astep, mstep = Models.flocking(; n_birds=300)
         step!(model, astep, mstep, 100)
         AgentsIO.save_checkpoint("test.jld2", model)
-        other = AgentsIO.load_checkpoint("test.jld2"; scheduler = Schedulers.Randomly())
+        other = AgentsIO.load_checkpoint("test.jld2"; scheduler=Schedulers.Randomly())
 
         # agent data
         @test nagents(other) == nagents(model)
@@ -164,9 +177,13 @@
         @test all(model[i].speed == other[i].speed for i in allids(model))
         @test all(model[i].cohere_factor == other[i].cohere_factor for i in allids(model))
         @test all(model[i].separation == other[i].separation for i in allids(model))
-        @test all(model[i].separate_factor == other[i].separate_factor for i in allids(model))
+        @test all(
+            model[i].separate_factor == other[i].separate_factor for i in allids(model)
+        )
         @test all(model[i].match_factor == other[i].match_factor for i in allids(model))
-        @test all(model[i].visual_distance == other[i].visual_distance for i in allids(model))
+        @test all(
+            model[i].visual_distance == other[i].visual_distance for i in allids(model)
+        )
         # model data
         test_model_data(model, other)
         # space data
@@ -186,12 +203,14 @@
         model = ABM(
             Agent7,
             GraphSpace(complete_graph(10));
-            properties = ModelData(3, 4.2f32, Dict(1 => "foo", 2 => "bar")),
-            rng = MersenneTwister(42)
+            properties=ModelData(3, 4.2f32, Dict(1 => "foo", 2 => "bar")),
+            rng=MersenneTwister(42),
         )
 
         for i in 1:30
-            add_agent_pos!(Agent7(i, i % 10 + 1, rand(model.rng) < 0.5, rand(model.rng, Int)), model)
+            add_agent_pos!(
+                Agent7(i, i % 10 + 1, rand(model.rng) < 0.5, rand(model.rng, Int)), model
+            )
         end
 
         AgentsIO.save_checkpoint("test.jld2", model)
@@ -213,8 +232,14 @@
         # space data
         @test model.space.graph == other.space.graph
         @test length(model.space.stored_ids) == length(other.space.stored_ids)
-        @test all(length(model.space.stored_ids[pos]) == length(other.space.stored_ids[pos]) for pos in eachindex(model.space.stored_ids))
-        @test all(all(x in other.space.stored_ids[pos] for x in model.space.stored_ids[pos]) for pos in eachindex(model.space.stored_ids))
+        @test all(
+            length(model.space.stored_ids[pos]) == length(other.space.stored_ids[pos]) for
+            pos in eachindex(model.space.stored_ids)
+        )
+        @test all(
+            all(x in other.space.stored_ids[pos] for x in model.space.stored_ids[pos]) for
+            pos in eachindex(model.space.stored_ids)
+        )
 
         rm("test.jld2")
     end
@@ -230,13 +255,10 @@
         hmm = Pathfinding.PenaltyMap(pmap)
 
         function setup_model(; kwargs...)
-            space = GridSpace((10, 10); periodic = false)
+            space = GridSpace((10, 10); periodic=false)
             pathfinder = Pathfinding.AStar(space; kwargs...)
             model = ABM(
-                Agent1,
-                space;
-                properties = (pathfinder = pathfinder,),
-                rng = MersenneTwister(42)
+                Agent1, space; properties=(pathfinder=pathfinder,), rng=MersenneTwister(42)
             )
             add_agent!((1, 1), model)
             plan_route!(model[1], (10, 10), model.pathfinder)
@@ -248,15 +270,21 @@
         end
 
         test_pathfinding_model(setup_model()...)
-        test_pathfinding_model(setup_model(; diagonal_movement = true)...)
-        test_pathfinding_model(setup_model(; admissibility = 0.5)...)
-        test_pathfinding_model(setup_model(; walkmap = walk)...)
-        test_pathfinding_model(setup_model(; cost_metric = direct)...)
-        test_pathfinding_model(setup_model(; cost_metric = maxd)...)
-        test_pathfinding_model(setup_model(; cost_metric = hmm)...)
-        test_pathfinding_model(setup_model(; cost_metric = Pathfinding.PenaltyMap(pmap, direct))...)
-        test_pathfinding_model(setup_model(; cost_metric = Pathfinding.PenaltyMap(pmap, maxd))...)
-        test_pathfinding_model(setup_model(; cost_metric = Pathfinding.PenaltyMap(pmap, hmm))...)
+        test_pathfinding_model(setup_model(; diagonal_movement=true)...)
+        test_pathfinding_model(setup_model(; admissibility=0.5)...)
+        test_pathfinding_model(setup_model(; walkmap=walk)...)
+        test_pathfinding_model(setup_model(; cost_metric=direct)...)
+        test_pathfinding_model(setup_model(; cost_metric=maxd)...)
+        test_pathfinding_model(setup_model(; cost_metric=hmm)...)
+        test_pathfinding_model(
+            setup_model(; cost_metric=Pathfinding.PenaltyMap(pmap, direct))...
+        )
+        test_pathfinding_model(
+            setup_model(; cost_metric=Pathfinding.PenaltyMap(pmap, maxd))...
+        )
+        test_pathfinding_model(
+            setup_model(; cost_metric=Pathfinding.PenaltyMap(pmap, hmm))...
+        )
 
         rm("test.jld2")
     end
@@ -272,13 +300,13 @@
         hmm = Pathfinding.PenaltyMap(pmap)
 
         function setup_model(; kwargs...)
-            space = ContinuousSpace((10.0, 10.0); periodic = false)
+            space = ContinuousSpace((10.0, 10.0); periodic=false)
             pathfinder = Pathfinding.AStar(space; kwargs...)
             model = ABM(
                 Agent6,
                 deepcopy(space);
-                properties = (pathfinder = pathfinder,),
-                rng = MersenneTwister(42)
+                properties=(pathfinder=pathfinder,),
+                rng=MersenneTwister(42),
             )
             add_agent!((1.3, 1.5), model, (0.0, 0.0), 0.0)
             plan_route!(model[1], (9.7, 4.8), model.pathfinder)
@@ -289,29 +317,37 @@
             return model, other
         end
 
-        test_pathfinding_model(setup_model(walkmap = trues(10, 10))...)
-        test_pathfinding_model(setup_model(walkmap = trues(10, 10), admissibility = 0.5)...)
-        test_pathfinding_model(setup_model(walkmap = walk)...)
-        test_pathfinding_model(setup_model(walkmap = trues(10, 10), cost_metric = direct)...)
-        test_pathfinding_model(setup_model(walkmap = trues(10, 10), cost_metric = maxd)...)
-        test_pathfinding_model(setup_model(walkmap = trues(10, 10), cost_metric = hmm)...)
-        test_pathfinding_model(setup_model(cost_metric = Pathfinding.PenaltyMap(pmap, direct))...)
-        test_pathfinding_model(setup_model(cost_metric = Pathfinding.PenaltyMap(pmap, maxd))...)
-        test_pathfinding_model(setup_model(cost_metric = Pathfinding.PenaltyMap(pmap, hmm))...)
+        test_pathfinding_model(setup_model(; walkmap=trues(10, 10))...)
+        test_pathfinding_model(setup_model(; walkmap=trues(10, 10), admissibility=0.5)...)
+        test_pathfinding_model(setup_model(; walkmap=walk)...)
+        test_pathfinding_model(setup_model(; walkmap=trues(10, 10), cost_metric=direct)...)
+        test_pathfinding_model(setup_model(; walkmap=trues(10, 10), cost_metric=maxd)...)
+        test_pathfinding_model(setup_model(; walkmap=trues(10, 10), cost_metric=hmm)...)
+        test_pathfinding_model(
+            setup_model(; cost_metric=Pathfinding.PenaltyMap(pmap, direct))...
+        )
+        test_pathfinding_model(
+            setup_model(; cost_metric=Pathfinding.PenaltyMap(pmap, maxd))...
+        )
+        test_pathfinding_model(
+            setup_model(; cost_metric=Pathfinding.PenaltyMap(pmap, hmm))...
+        )
 
         rm("test.jld2")
     end
 
     @testset "Multi-agent" begin
-        model = ABM(Union{Agent1,Agent3}, GridSpace((10, 10)); warn = false)
+        model = ABM(Union{Agent1,Agent3}, GridSpace((10, 10)); warn=false)
         AgentsIO.save_checkpoint("test.jld2", model)
-        other = @test_nowarn AgentsIO.load_checkpoint("test.jld2"; warn = false)
+        other = @test_nowarn AgentsIO.load_checkpoint("test.jld2"; warn=false)
 
         # agent data
         @test nagents(other) == nagents(model)
         @test all(haskey(other.agents, i) for i in allids(model))
         @test all(model[i].pos == other[i].pos for i in allids(model))
-        @test all(model[i].weight == other[i].weight for i in allids(model) if model[i] isa Agent3)
+        @test all(
+            model[i].weight == other[i].weight for i in allids(model) if model[i] isa Agent3
+        )
         # model data
         test_model_data(model, other)
         # space data
@@ -324,7 +360,7 @@
         @agent Zombie OSMAgent begin
             infected::Bool
         end
-        model = ABM(Zombie, OpenStreetMapSpace(OSM.test_map()); rng = MersenneTwister(42))
+        model = ABM(Zombie, OpenStreetMapSpace(OSM.test_map()); rng=MersenneTwister(42))
 
         for id in 1:100
             start = random_position(model)
@@ -341,21 +377,40 @@
 
         AgentsIO.save_checkpoint("test.jld2", model)
         @test_throws AssertionError AgentsIO.load_checkpoint("test.jld2")
-        other = AgentsIO.load_checkpoint("test.jld2"; map = OSM.test_map())
+        other = AgentsIO.load_checkpoint("test.jld2"; map=OSM.test_map())
 
         # agent data
         @test nagents(other) == nagents(model)
         @test all(haskey(other.agents, i) for i in allids(model))
-        @test all(OSM.latlon(model[i].pos, model) == OSM.latlon(other[i].pos, other) for i in allids(model))
+        @test all(
+            OSM.latlon(model[i].pos, model) == OSM.latlon(other[i].pos, other) for
+            i in allids(model)
+        )
         @test all(model[i].infected == other[i].infected for i in allids(model))
         # model data
         test_model_data(model, other)
-        @test sort(collect(keys(model.space.routes))) == sort(collect(keys(other.space.routes)))
-        @test all(model.space.routes[i].route == other.space.routes[i].route for i in keys(model.space.routes))
-        @test all(model.space.routes[i].start == other.space.routes[i].start for i in keys(model.space.routes))
-        @test all(model.space.routes[i].dest == other.space.routes[i].dest for i in keys(model.space.routes))
-        @test all(model.space.routes[i].return_route == other.space.routes[i].return_route for i in keys(model.space.routes))
-        @test all(model.space.routes[i].has_to_return == other.space.routes[i].has_to_return for i in keys(model.space.routes))
+        @test sort(collect(keys(model.space.routes))) ==
+            sort(collect(keys(other.space.routes)))
+        @test all(
+            model.space.routes[i].route == other.space.routes[i].route for
+            i in keys(model.space.routes)
+        )
+        @test all(
+            model.space.routes[i].start == other.space.routes[i].start for
+            i in keys(model.space.routes)
+        )
+        @test all(
+            model.space.routes[i].dest == other.space.routes[i].dest for
+            i in keys(model.space.routes)
+        )
+        @test all(
+            model.space.routes[i].return_route == other.space.routes[i].return_route for
+            i in keys(model.space.routes)
+        )
+        @test all(
+            model.space.routes[i].has_to_return == other.space.routes[i].has_to_return for
+            i in keys(model.space.routes)
+        )
 
         rm("test.jld2")
     end
diff --git a/test/model_access.jl b/test/model_access.jl
index 2bc4f6cd58..57dc94e396 100644
--- a/test/model_access.jl
+++ b/test/model_access.jl
@@ -1,87 +1,89 @@
 using Agents, Test
 
 @testset "Model Access" begin
-@testset "Accessing model" begin
-    @testset "ModelType=$(ModelType)" for ModelType in (ABM, StandardABM, UnkillableABM)
-    model = ModelType(NoSpaceAgent; properties = Dict(:a => 2, :b => "test"))
-    for i in 1:5
-        add_agent!(model)
-    end
-    @test abmscheduler(model) == Schedulers.fastest
-    @test abmproperties(model) == Dict(:a => 2, :b => "test")
-    a = model[1]
-    @test a isa NoSpaceAgent
-    @test a.id == 1
-    @test model.a == 2
-    @test model.b == "test"
+    @testset "Accessing model" begin
+        @testset "ModelType=$(ModelType)" for ModelType in (ABM, StandardABM, UnkillableABM)
+            model = ModelType(NoSpaceAgent; properties=Dict(:a => 2, :b => "test"))
+            for i in 1:5
+                add_agent!(model)
+            end
+            @test abmscheduler(model) == Schedulers.fastest
+            @test abmproperties(model) == Dict(:a => 2, :b => "test")
+            a = model[1]
+            @test a isa NoSpaceAgent
+            @test a.id == 1
+            @test model.a == 2
+            @test model.b == "test"
 
-    model.a = 7
-    model.b = "Changed"
-    @test model.a == 7
-    @test model.b == "Changed"
-    @test_throws ErrorException model.c = 5
+            model.a = 7
+            model.b = "Changed"
+            @test model.a == 7
+            @test model.b == "Changed"
+            @test_throws ErrorException model.c = 5
 
-    newa = NoSpaceAgent(6)
-    add_agent!(newa, model)
-    @test model[6] == newa
-    # setindex must errors
-    @test_throws ErrorException model[7] = newa
+            newa = NoSpaceAgent(6)
+            add_agent!(newa, model)
+            @test model[6] == newa
+            # setindex must errors
+            @test_throws ErrorException model[7] = newa
 
-    mutable struct Properties
-        par1::Int
-        par2::Float64
-        par3::String
-    end
-    properties = Properties(1,1.0,"Test")
-    model = ModelType(NoSpaceAgent; properties)
-    @test abmproperties(model) isa Properties
-    @test model.par1 == 1
-    @test model.par2 == 1.0
-    @test model.par3 == "Test"
+            mutable struct Properties
+                par1::Int
+                par2::Float64
+                par3::String
+            end
+            properties = Properties(1, 1.0, "Test")
+            model = ModelType(NoSpaceAgent; properties)
+            @test abmproperties(model) isa Properties
+            @test model.par1 == 1
+            @test model.par2 == 1.0
+            @test model.par3 == "Test"
 
-    model.par1 = 7
-    model.par2 = 7
-    model.par3 = "Changed"
-    @test model.par1 == 7
-    @test model.par2 == 7.0
-    @test model.par3 == "Changed"
-    @test_throws ErrorException model.par4 = 5
+            model.par1 = 7
+            model.par2 = 7
+            model.par3 = "Changed"
+            @test model.par1 == 7
+            @test model.par2 == 7.0
+            @test model.par3 == "Changed"
+            @test_throws ErrorException model.par4 = 5
 
-    model = ModelType(NoSpaceAgent)
-    @test_throws ErrorException model.a = 5
+            model = ModelType(NoSpaceAgent)
+            @test_throws ErrorException model.a = 5
+        end
     end
-end
 
-@testset "model access typestability" begin
-    prop1 = Dict(:a => 0.5)
-    prop2 = Agent2(1, 0.5)
-    model1 = ABM(NoSpaceAgent; properties = prop1)
-    model2 = ABM(NoSpaceAgent; properties = prop2)
-
-    test1(model) = model.a
-    test2(model) = model.weight
-    @test_nowarn @inferred test1(model1)
-    @test_nowarn @inferred test2(model2)
-end
+    @testset "model access typestability" begin
+        prop1 = Dict(:a => 0.5)
+        prop2 = Agent2(1, 0.5)
+        model1 = ABM(NoSpaceAgent; properties=prop1)
+        model2 = ABM(NoSpaceAgent; properties=prop2)
 
-@testset "Core methods" begin
-    model = ABM(Agent3, GridSpace((5,5)))
-    @test Agents.agenttype(model) == Agent3
-    @test Agents.spacetype(model) <: GridSpace
-    @test size(model.space) == (5,5)
-    @test all(isempty(p, model) for p in positions(model))
-end
+        test1(model) = model.a
+        test2(model) = model.weight
+        @test_nowarn @inferred test1(model1)
+        @test_nowarn @inferred test2(model2)
+    end
 
-@testset "Display" begin
-    model = ABM(NoSpaceAgent)
-    @test occursin("no spatial structure", sprint(show, model))
-    model = ABM(Agent3, GridSpace((5,5)))
-    @test sprint(show, model)[1:25] == "StandardABM with 0 agents"
-    @test sprint(show, Agents.abmspace(model)) == "GridSpace with size (5, 5), metric=chebyshev, periodic=true"
-    model = ABM(Agent6, ContinuousSpace((1.0,1.0)))
-    @test sprint(show, Agents.abmspace(model)) == "periodic continuous space with (1.0, 1.0) extent and spacing=0.05"
-    model = ABM(Agent5, GraphSpace(path_graph(5)))
-    @test sprint(show, Agents.abmspace(model)) == "GraphSpace with 5 positions and 4 edges"
-end
+    @testset "Core methods" begin
+        model = ABM(Agent3, GridSpace((5, 5)))
+        @test Agents.agenttype(model) == Agent3
+        @test Agents.spacetype(model) <: GridSpace
+        @test size(model.space) == (5, 5)
+        @test all(isempty(p, model) for p in positions(model))
+    end
 
+    @testset "Display" begin
+        model = ABM(NoSpaceAgent)
+        @test occursin("no spatial structure", sprint(show, model))
+        model = ABM(Agent3, GridSpace((5, 5)))
+        @test sprint(show, model)[1:25] == "StandardABM with 0 agents"
+        @test sprint(show, Agents.abmspace(model)) ==
+            "GridSpace with size (5, 5), metric=chebyshev, periodic=true"
+        model = ABM(Agent6, ContinuousSpace((1.0, 1.0)))
+        @test sprint(show, Agents.abmspace(model)) ==
+            "periodic continuous space with (1.0, 1.0) extent and spacing=0.05"
+        model = ABM(Agent5, GraphSpace(path_graph(5)))
+        @test sprint(show, Agents.abmspace(model)) ==
+            "GraphSpace with 5 positions and 4 edges"
+    end
 end
diff --git a/test/model_creation_tests.jl b/test/model_creation_tests.jl
index ea12ab26dd..4c9b92f99b 100644
--- a/test/model_creation_tests.jl
+++ b/test/model_creation_tests.jl
@@ -7,7 +7,7 @@ using Test, Agents, Random
     end
     @test A3 <: AbstractAgent
     @test fieldnames(A3) == (:id, :pos, :weight)
-    @test fieldtypes(A3) == (Int, NTuple{2, Int}, Float64)
+    @test fieldtypes(A3) == (Int, NTuple{2,Int}, Float64)
 
     """
     This is a test docstring for agent A4
@@ -17,7 +17,7 @@ using Test, Agents, Random
     end
     @test A4 <: AbstractAgent
     @test fieldnames(A4) == (:id, :pos, :weight, :z)
-    @test fieldtypes(A4) == (Int, NTuple{2, Int}, Float64, Bool)
+    @test fieldtypes(A4) == (Int, NTuple{2,Int}, Float64, Bool)
     @test contains(string(@doc(A4)), "This is a test docstring for agent A4")
 
     # Also test subtyping
@@ -37,7 +37,6 @@ using Test, Agents, Random
     @test :fish_per_day ∈ fieldnames(Fisher)
 end
 
-
 @testset "Model construction" begin
     mutable struct BadAgent <: AbstractAgent
         useless::Int
@@ -53,11 +52,10 @@ end
     # Shouldn't use ImmutableAgent since it cannot be edited
     agent = ImmutableAgent(1)
     @test_logs (
-        :warn,
-        "Agent type is not mutable, and most library functions assume that it is.",
+        :warn, "Agent type is not mutable, and most library functions assume that it is."
     ) ABM(agent)
     # Warning is suppressed if flag is set
-    @test Agents.agenttype(ABM(agent; warn = false)) <: AbstractAgent
+    @test Agents.agenttype(ABM(agent; warn=false)) <: AbstractAgent
     # Cannot use BadAgent since it has no `id` field
     @test_throws ArgumentError ABM(BadAgent)
     agent = BadAgent(1, 1)
@@ -97,7 +95,7 @@ end
         "`vel` field in agent type should be of type `NTuple{<:AbstractFloat}` when using ContinuousSpace.",
     ) ABM(agent, ContinuousSpace((1, 1)))
     # Warning is suppressed if flag is set
-    @test Agents.agenttype(ABM(agent, ContinuousSpace((1, 1)); warn = false)) <: AbstractAgent
+    @test Agents.agenttype(ABM(agent, ContinuousSpace((1, 1)); warn=false)) <: AbstractAgent
     # Shouldn't use ParametricAgent since it is not a concrete type
     mutable struct ParametricAgent{T<:Integer} <: AbstractAgent
         id::T
@@ -112,11 +110,11 @@ end
         seeing this warning because you gave `Agent` instead of `Agent{Float64}`
         (for example) to this function. You can also create an instance of your agent
         and pass it to this function. If you want to use `Union` types for mixed agent
-        models, you can silence this warning.\n"""
+        models, you can silence this warning.\n""",
     ) ABM(ParametricAgent, GridSpace((1, 1)))
     # Warning is suppressed if flag is set
-    @test Agents.agenttype(ABM(ParametricAgent, GridSpace((1, 1)); warn = false)) <:
-          AbstractAgent
+    @test Agents.agenttype(ABM(ParametricAgent, GridSpace((1, 1)); warn=false)) <:
+        AbstractAgent
     # ParametricAgent{Int} is the correct way to use such an agent
     @test Agents.agenttype(ABM(ParametricAgent{Int}, GridSpace((1, 1)))) <: AbstractAgent
     #Type inferance using an instance can help users here
@@ -127,7 +125,7 @@ end
         dummy::Bool
     end
 
-    @test Agents.agenttype(ABM(Union{NoSpaceAgent,ValidAgent}; warn = false)) <: AbstractAgent
+    @test Agents.agenttype(ABM(Union{NoSpaceAgent,ValidAgent}; warn=false)) <: AbstractAgent
     @test_logs (
         :warn,
         """
@@ -135,7 +133,7 @@ end
         seeing this warning because you gave `Agent` instead of `Agent{Float64}`
         (for example) to this function. You can also create an instance of your agent
         and pass it to this function. If you want to use `Union` types for mixed agent
-        models, you can silence this warning.\n"""
+        models, you can silence this warning.\n""",
     ) ABM(Union{NoSpaceAgent,ValidAgent})
-    @test_throws ArgumentError ABM(Union{NoSpaceAgent,BadAgent}; warn = false)
+    @test_throws ArgumentError ABM(Union{NoSpaceAgent,BadAgent}; warn=false)
 end
diff --git a/test/osm_tests.jl b/test/osm_tests.jl
index 66015a1200..1c7fabf2a8 100644
--- a/test/osm_tests.jl
+++ b/test/osm_tests.jl
@@ -9,12 +9,11 @@ end
 
 @testset "OpenStreetMap space" begin
     goettingen = OSM.test_map()
-    space = OpenStreetMapSpace(goettingen; network_type = :none, weight_type = :time)
+    space = OpenStreetMapSpace(goettingen; network_type=:none, weight_type=:time)
     @test length(space.s) == 9753
-    @test sprint(show, space) ==
-          "OpenStreetMapSpace with 3353 ways and 9753 nodes"
+    @test sprint(show, space) == "OpenStreetMapSpace with 3353 ways and 9753 nodes"
 
-    model = ABM(AgentOSM, space; rng = StableRNG(42))
+    model = ABM(AgentOSM, space; rng=StableRNG(42))
 
     start_lonlat = (9.9351811, 51.5328328)
     start_intersection = OSM.nearest_node(start_lonlat, model)
@@ -40,7 +39,9 @@ end
         @test 51.525 < lat < 51.545
 
         # Test that finding nearest nodes works, and that road version is closer
-        intersection_diff = maximum(abs.(OSM.lonlat(start_intersection, model) .- start_lonlat))
+        intersection_diff = maximum(
+            abs.(OSM.lonlat(start_intersection, model) .- start_lonlat)
+        )
         start_road = OSM.nearest_road(start_lonlat, model)
         road_diff = maximum(abs.(OSM.lonlat(start_road, model) .- start_lonlat))
         @test intersection_diff < 0.1 # 0.1 degrees is max degree distance for goettingen
@@ -66,7 +67,8 @@ end
         @test all(OSM.latlon(np_latlon[1], model) .≈ (51.5307792, 9.9451386))
 
         @test OSM.road_length(model[1].pos, model) ≈ 0.0002591692620559716
-        @test OSM.road_length(finish_road[1], finish_road[2], model) ≈ 0.00030269737299400725
+        @test OSM.road_length(finish_road[1], finish_road[2], model) ≈
+            0.00030269737299400725
     end
 
     @testset "Moving along routes" begin
@@ -100,7 +102,7 @@ end
         for i in 1:5
             s = (start_road[1:2]..., i / 5 * OSM.road_length(start_road, model))
             add_agent!(s, model)
-            route = plan_route!(model[2+i], finish_road, model)
+            route = plan_route!(model[2 + i], finish_road, model)
         end
 
         @test sort!(nearby_ids(model[6], model, 0.01)) == [2, 3, 4, 5, 7]
@@ -113,10 +115,10 @@ end
         move_along_route!(model[1], model, 1e5)
         @test all(model[1].pos .≈ finish_intersection)
         move_agent!(model[1], start_intersection, model)
-        plan_route!(model[1], finish_intersection, model; return_trip = true)
+        plan_route!(model[1], finish_intersection, model; return_trip=true)
         move_along_route!(model[1], model, 1e5)
         @test OSM.same_position(model[1].pos, start_intersection, model)
-        @test OSM.plan_random_route!(model[1], model; limit = 100)
+        @test OSM.plan_random_route!(model[1], model; limit=100)
         @test !is_stationary(model[1], model)
         move_along_route!(model[1], model, 1e5)
         @test all(model[1].pos .!= start_intersection)
@@ -127,15 +129,19 @@ end
         nbor = Int(outneighbors(model.space.map.graph, pos_1[1])[1])
         rl = OSM.road_length(pos_1, nbor, model)
         @test OSM.distance(pos_1, nbor, model) ≈ rl
-        @test OSM.distance(pos_1, pos_1, model) == 0.
+        @test OSM.distance(pos_1, pos_1, model) == 0.0
         @test OSM.distance((pos_1, nbor, 0.0), (nbor, pos_1, rl), model) == 0.0
-        @test OSM.distance((pos_1, nbor, rl/4), (nbor, pos_1, rl/4), model) ≈ rl/2
+        @test OSM.distance((pos_1, nbor, rl / 4), (nbor, pos_1, rl / 4), model) ≈ rl / 2
         move_agent!(model[1], (pos_1, pos_1, 0.0), model)
         plan_route!(model[1], finish_intersection, model)
-        len = sum(OSM.LightOSM.weights_from_path(
-            model.space.map,
-            reverse([model.space.map.index_to_node[i] for i in model.space.routes[1].route]),
-        ))
+        len = sum(
+            OSM.LightOSM.weights_from_path(
+                model.space.map,
+                reverse([
+                    model.space.map.index_to_node[i] for i in model.space.routes[1].route
+                ]),
+            ),
+        )
         len += OSM.road_length(pos_1, model.space.routes[1].route[end], model)
         @test OSM.distance(pos_1, finish_intersection, model) ≈ len
         @test OSM.route_length(model[1], model) ≈ len
diff --git a/test/performance/branching_faster_than_dispatch.jl b/test/performance/branching_faster_than_dispatch.jl
index 25fcf0b5e2..c56dbcb271 100644
--- a/test/performance/branching_faster_than_dispatch.jl
+++ b/test/performance/branching_faster_than_dispatch.jl
@@ -47,43 +47,43 @@ end
 model1 = ABM(
     Union{GridAgentOne,GridAgentTwo,GridAgentThree,GridAgentFour,GridAgentFive},
     GridSpace((15, 15));
-    warn = false,
-    rng = MersenneTwister(42),
-    scheduler = Schedulers.randomly,
+    warn=false,
+    rng=MersenneTwister(42),
+    scheduler=Schedulers.randomly,
 )
 
 for _ in 1:50
-    a = GridAgentOne(nextid(model1), (1,1), rand(model1.rng), rand(model1.rng, Bool))
+    a = GridAgentOne(nextid(model1), (1, 1), rand(model1.rng), rand(model1.rng, Bool))
     add_agent!(a, model1)
-    a = GridAgentTwo(nextid(model1), (1,1), rand(model1.rng), rand(model1.rng, Bool))
+    a = GridAgentTwo(nextid(model1), (1, 1), rand(model1.rng), rand(model1.rng, Bool))
     add_agent!(a, model1)
-    a = GridAgentThree(nextid(model1), (1,1), rand(model1.rng), rand(model1.rng, Bool))
+    a = GridAgentThree(nextid(model1), (1, 1), rand(model1.rng), rand(model1.rng, Bool))
     add_agent!(a, model1)
-    a = GridAgentFour(nextid(model1), (1,1), rand(model1.rng), rand(model1.rng, Bool))
+    a = GridAgentFour(nextid(model1), (1, 1), rand(model1.rng), rand(model1.rng, Bool))
     add_agent!(a, model1)
-    a = GridAgentFive(nextid(model1), (1,1), rand(model1.rng), rand(model1.rng, Bool))
+    a = GridAgentFive(nextid(model1), (1, 1), rand(model1.rng), rand(model1.rng, Bool))
     add_agent!(a, model1)
 end
 
 agent_step!(agent::GridAgentOne, model1) = walk!(agent, rand, model1)
 function agent_step!(agent::GridAgentTwo, model1)
     agent.one += rand(model1.rng)
-    agent.two = rand(model1.rng, Bool)
+    return agent.two = rand(model1.rng, Bool)
 end
 function agent_step!(agent::GridAgentThree, model1)
-    if any(a-> a isa GridAgentTwo, nearby_agents(agent, model1))
+    if any(a -> a isa GridAgentTwo, nearby_agents(agent, model1))
         agent.two = true
         walk!(agent, rand, model1)
     end
 end
 function agent_step!(agent::GridAgentFour, model1)
-    agent.one += sum(a.one for a in nearby_agents(agent, model1))
+    return agent.one += sum(a.one for a in nearby_agents(agent, model1))
 end
 function agent_step!(agent::GridAgentFive, model1)
-    targets = filter!(a->a.one > 0.8, collect(nearby_agents(agent, model1, 3)))
-    idx = argmax(map(t->euclidean_distance(agent, t, model1), targets))
+    targets = filter!(a -> a.one > 0.8, collect(nearby_agents(agent, model1, 3)))
+    idx = argmax(map(t -> euclidean_distance(agent, t, model1), targets))
     farthest = targets[idx]
-    walk!(agent, sign.(farthest.pos .- agent.pos), model1)
+    return walk!(agent, sign.(farthest.pos .- agent.pos), model1)
 end
 
 ################### DEFINITION 2 ###############
@@ -99,20 +99,26 @@ end
 model2 = ABM(
     GridAgentAll,
     GridSpace((15, 15));
-    rng = MersenneTwister(42),
-    scheduler = Schedulers.randomly,
+    rng=MersenneTwister(42),
+    scheduler=Schedulers.randomly,
 )
 
 for _ in 1:50
-    a = GridAgentAll(nextid(model2), (1,1), rand(model2.rng), rand(model2.rng, Bool), :one)
+    a = GridAgentAll(nextid(model2), (1, 1), rand(model2.rng), rand(model2.rng, Bool), :one)
     add_agent!(a, model2)
-    a = GridAgentAll(nextid(model2), (1,1), rand(model2.rng), rand(model2.rng, Bool), :two)
+    a = GridAgentAll(nextid(model2), (1, 1), rand(model2.rng), rand(model2.rng, Bool), :two)
     add_agent!(a, model2)
-    a = GridAgentAll(nextid(model2), (1,1), rand(model2.rng), rand(model2.rng, Bool), :three)
+    a = GridAgentAll(
+        nextid(model2), (1, 1), rand(model2.rng), rand(model2.rng, Bool), :three
+    )
     add_agent!(a, model2)
-    a = GridAgentAll(nextid(model2), (1,1), rand(model2.rng), rand(model2.rng, Bool), :four)
+    a = GridAgentAll(
+        nextid(model2), (1, 1), rand(model2.rng), rand(model2.rng, Bool), :four
+    )
     add_agent!(a, model2)
-    a = GridAgentAll(nextid(model2), (1,1), rand(model2.rng), rand(model2.rng, Bool), :five)
+    a = GridAgentAll(
+        nextid(model2), (1, 1), rand(model2.rng), rand(model2.rng, Bool), :five
+    )
     add_agent!(a, model2)
 end
 
@@ -132,21 +138,21 @@ end
 agent_step_one!(agent, model2) = walk!(agent, rand, model2)
 function agent_step_two!(agent, model2)
     agent.one += rand(model2.rng)
-    agent.two = rand(model2.rng, Bool)
+    return agent.two = rand(model2.rng, Bool)
 end
 function agent_step_three!(agent, model2)
-    if any(a-> a.type == :two, nearby_agents(agent, model2))
+    if any(a -> a.type == :two, nearby_agents(agent, model2))
         agent.two = true
         walk!(agent, rand, model2)
     end
 end
 function agent_step_four!(agent, model2)
-    agent.one += sum(a.one for a in nearby_agents(agent, model2))
+    return agent.one += sum(a.one for a in nearby_agents(agent, model2))
 end
 function agent_step_five!(agent, model2)
-    targets = filter!(a->a.one > 1.0, collect(nearby_agents(agent, model2, 3)))
+    targets = filter!(a -> a.one > 1.0, collect(nearby_agents(agent, model2, 3)))
     if !isempty(targets)
-        idx = argmax(map(t->euclidean_distance(agent, t, model2), targets))
+        idx = argmax(map(t -> euclidean_distance(agent, t, model2), targets))
         farthest = targets[idx]
         walk!(agent, sign.(farthest.pos .- agent.pos), model2)
     end
diff --git a/test/performance/get_random_agent.jl b/test/performance/get_random_agent.jl
index a1b1a8d5b0..4fcb28682b 100644
--- a/test/performance/get_random_agent.jl
+++ b/test/performance/get_random_agent.jl
@@ -7,7 +7,7 @@ mutable struct LabelledAgent <: AbstractAgent
 end
 
 n_agents = 100
-agents = [LabelledAgent(id, id<=n_agents/3) for id in 1:n_agents]
+agents = [LabelledAgent(id, id <= n_agents / 3) for id in 1:n_agents]
 noremove_model = UnkillableABM(LabelledAgent)
 dict_model = ABM(LabelledAgent)
 fixed_model = FixedMassABM(agents)
@@ -47,4 +47,4 @@ end
 @benchmark optimistic_random_agent($dict_model, $cond)
 @benchmark allocating_random_agent($dict_model, $cond)
 @benchmark random_agent($dict_model, $cond)
-@benchmark old_random_agent($dict_model, $cond)
\ No newline at end of file
+@benchmark old_random_agent($dict_model, $cond)
diff --git a/test/performance/variable_agent_types_simple_dynamics.jl b/test/performance/variable_agent_types_simple_dynamics.jl
index df0e542465..6a177f7aee 100644
--- a/test/performance/variable_agent_types_simple_dynamics.jl
+++ b/test/performance/variable_agent_types_simple_dynamics.jl
@@ -97,20 +97,35 @@ mutable struct Agent15 <: AbstractAgent
     money::Int
 end
 
-function initialize_model_1(;n_agents=600,dims=(5,5))
+function initialize_model_1(; n_agents=600, dims=(5, 5))
     space = GridSpace(dims)
     model = ABM(Agent1, space; scheduler=Schedulers.randomly, warn=false)
     id = 0
     for id in 1:n_agents
-        agent = Agent1(id, (0,0), 10)
+        agent = Agent1(id, (0, 0), 10)
         add_agent!(agent, model)
     end
     return model
 end
 
-function initialize_model(;n_agents=600, n_types=1, dims=(5,5))
-    agent_types = [Agent1,Agent2,Agent3,Agent4,Agent5,Agent6,Agent7,Agent8,
-        Agent9,Agent10,Agent11,Agent12,Agent13,Agent14,Agent15]
+function initialize_model(; n_agents=600, n_types=1, dims=(5, 5))
+    agent_types = [
+        Agent1,
+        Agent2,
+        Agent3,
+        Agent4,
+        Agent5,
+        Agent6,
+        Agent7,
+        Agent8,
+        Agent9,
+        Agent10,
+        Agent11,
+        Agent12,
+        Agent13,
+        Agent14,
+        Agent15,
+    ]
     agents_used = agent_types[1:n_types]
     space = GridSpace(dims)
     model = ABM(Union{agents_used...}, space; scheduler=Schedulers.randomly, warn=false)
@@ -119,7 +134,7 @@ function initialize_model(;n_agents=600, n_types=1, dims=(5,5))
     for A in agents_used
         for _ in 1:agents_per_type
             id += 1
-            agent = A(id, (0,0), 10)
+            agent = A(id, (0, 0), 10)
             add_agent!(agent, model)
         end
     end
@@ -129,7 +144,9 @@ end
 function agent_step!(agent, model)
     move!(agent, model)
     agents = agents_in_position(agent.pos, model)
-    for a in agents; exchange!(agent, a); end
+    for a in agents
+        exchange!(agent, a)
+    end
     return nothing
 end
 
@@ -153,35 +170,37 @@ function run_simulation_1(n_steps, n_reps)
         model = initialize_model_1()
         Agents.step!(model, agent_step!, n_steps)
     end
-    return t[2]/n_reps
+    return t[2] / n_reps
 end
 
 function run_simulation(n_steps, n_reps; n_types)
     t = @timed for _ in 1:n_reps
-        model = initialize_model(;n_types=n_types)
+        model = initialize_model(; n_types=n_types)
         Agents.step!(model, agent_step!, n_steps)
     end
-    return t[2]/n_reps
+    return t[2] / n_reps
 end
 
 # %% Run the simulation, do performance estimate, first with 1, then with many
 Random.seed!(2514)
 n_steps = 500
 n_reps = 5
-n_types = [2,3,4,5,10,15]
+n_types = [2, 3, 4, 5, 10, 15]
 # compile
 run_simulation_1(1, 1)
-for n in n_types; run_simulation(1, 1; n_types=n); end  # compile
+for n in n_types
+    run_simulation(1, 1; n_types=n)
+end  # compile
 
 time_1 = run_simulation_1(n_steps, n_reps)
 times = Float64[]
 for n in n_types
     println(n)
     t = run_simulation(n_steps, n_reps; n_types=n)
-    push!(times, t/time_1)
+    push!(times, t / time_1)
 end
 
-import CairoMakie
+using CairoMakie: CairoMakie
 fig, ax, = CairoMakie.lines(n_types, times)
 CairoMakie.scatter!(ax, n_types, times)
 ax.xlabel = "# types"
diff --git a/test/randomness_tests.jl b/test/randomness_tests.jl
index 4a29830088..e692066fb1 100644
--- a/test/randomness_tests.jl
+++ b/test/randomness_tests.jl
@@ -8,16 +8,16 @@ using Agents, Test
     rng = StableRNG(42)
     rng0 = StableRNG(42)
 
-    model = ABM(Agent1, GridSpace((3,3)); rng)
-    agent = Agent1(1, (1,1))
+    model = ABM(Agent1, GridSpace((3, 3)); rng)
+    agent = Agent1(1, (1, 1))
     add_agent_pos!(agent, model)
-    agent = Agent1(2, (1,1))
+    agent = Agent1(2, (1, 1))
     add_agent_single!(agent, model)
     # Test that model rng pool was used
     @test abmrng(model) ≠ rng0
-    @test agent.pos == (2,1)
+    @test agent.pos == (2, 1)
 
-    model = ABM(Agent2; rng = RandomDevice())
+    model = ABM(Agent2; rng=RandomDevice())
     @test_throws MethodError seed!(abmrng(model), 64)
 end
 
@@ -46,8 +46,8 @@ end
         allunique(allweights) && break
     end
     # Cannot draw 50 samples out of a pool of 20 without replacement
-    @test_throws ErrorException sample!(model3, 50, :weight; replace = false)
-    sample!(model3, 15, :weight; replace = false)
+    @test_throws ErrorException sample!(model3, 50, :weight; replace=false)
+    sample!(model3, 15, :weight; replace=false)
     allweights = [i.weight for i in allagents(model3)]
     @test allunique(allweights)
     model3 = ABM(Agent2)
@@ -58,14 +58,14 @@ end
         allweights = [i.weight for i in allagents(model3)]
         allunique(allweights) && break
     end
-    sample!(model3, 100, :weight; replace = true)
+    sample!(model3, 100, :weight; replace=true)
     allweights = [i.weight for i in allagents(model3)]
     @test !allunique(allweights)
 end
 
 @testset "random agent" begin
     space = GridSpace((10, 10))
-    model = ABM(Union{Daisy,Land}, space; warn = false)
+    model = ABM(Union{Daisy,Land}, space; warn=false)
     fill_space!(Daisy, model, "black")
     add_agent!(Land(999, (1, 1), 999), model)
 
diff --git a/test/scheduler_tests.jl b/test/scheduler_tests.jl
index 5b32110b72..ce495c5e8e 100644
--- a/test/scheduler_tests.jl
+++ b/test/scheduler_tests.jl
@@ -1,231 +1,71 @@
 # %% Scheduler tests
 @testset "Scheduler tests" begin
-@testset "Simple Schedulers" begin
-    N = 1000
+    @testset "Simple Schedulers" begin
+        N = 1000
 
-    # Schedulers.by_id
-    model = ABM(Agent0; scheduler = Schedulers.by_id)
-    for i in 1:N
-        add_agent!(model)
-    end
-    @test sort!(collect(keys(model.agents))) == 1:N
-    @test model.scheduler(model) == 1:N
-
-    # fastest
-    Random.seed!(12)
-    model = ABM(Agent0; scheduler = Schedulers.fastest)
-    for i in 1:N
-        add_agent!(model)
-    end
-    @test sort!(collect(model.scheduler(model))) == 1:N
-
-    # random
-    model = ABM(Agent0; scheduler = Schedulers.randomly, rng = StableRNG(12))
-    for i in 1:N
-        add_agent!(model)
-    end
-    fastest_order = collect(keys(model.agents))[1:3]
-    @test model.scheduler(model)[1:3] != fastest_order
-
-    # partial
-    model = ABM(Agent0; scheduler = Schedulers.partially(0.1), rng = StableRNG(12))
-    for i in 1:N
-        add_agent!(model)
-    end
-
-    a = model.scheduler(model)
-    @test length(a) <= N/10
-
-    # by property
-    model = ABM(Agent2; scheduler = Schedulers.by_property(:weight))
-    for i in 1:N
-        add_agent!(model, rand(model.rng) / rand(model.rng))
-    end
-
-    Random.seed!(12)
-    a = model.scheduler(model)
-
-    ids = collect(keys(model.agents))
-    properties = [model.agents[id].weight for id in ids]
-
-    @test ids[sortperm(properties)] == a
-end
-
-@testset "Union Types" begin
-    @test Agents.union_types(Union{Agent0}) == (Agent0,)
-    @test Agents.union_types(Union{Agent0,Agent1}) == (Agent0, Agent1)
-    @test Agents.union_types(Union{Agent0,Agent1,Agent2,Agent3}) ==
-          (Agent0, Agent1, Agent2, Agent3)
-    #Union types are not order preserving
-    @test Agents.union_types(Union{Agent1,Agent0}) == (Agent0, Agent1)
-    @test Agents.union_types(Union{Agent1,Agent3,Agent2,Agent0}) ==
-          (Agent0, Agent1, Agent2, Agent3)
-end
-
-# Mixed model
-function init_mixed_model(choices = [3, 3, 3, 3]; scheduler = Schedulers.fastest)
-    model = ABM(Union{Agent0,Agent1,Agent2,Agent3}, scheduler = scheduler, warn = false)
-    atypes = (Agent0,Agent1,Agent2,Agent3)
-    id = 1
-    for i in 1:choices[1]
-        a0 = Agent0(id)
-        add_agent!(a0, model)
-        id += 1
-    end
-    for i in 1:choices[2]
-        a1 = Agent1(id, (0, 0))
-        add_agent!(a1, model)
-        id +=1
-    end
-    for i in 1:choices[3]
-        a2 = Agent2(id, 5.0)
-        add_agent!(a2, model)
-        id += 1
-    end
-    for i in 1:choices[4]
-        a3 = Agent3(id, (0, 0), 5.0)
-        add_agent!(a3, model)
-        id += 1
-    end
-    return model
-end
-
-@testset "Mixed Scheduler" begin
-    # standard scheduler
-    model = init_mixed_model()
-    @test sort!(collect(model.scheduler(model))) == 1:12
-
-    # shuffling types scheduler
-    Random.seed!(12)
-    model = init_mixed_model(scheduler = Schedulers.by_type(true, false))
-    s1 = model.scheduler(model)
-    s2 = model.scheduler(model)
-    @test unique([typeof(model[id]) for id in s1]) != unique([typeof(model[id]) for id in s2])
-    @test count(model[id] isa Agent2 for id in model.scheduler(model)) == 3
-    c = begin
-        x = 0; s = model.scheduler(model)
-        x += count(a -> a == Agent0, typeof(model[id]) for id in s)
-        x += count(a -> a == Agent1, typeof(model[id]) for id in s)
-        x += count(a -> a == Agent2, typeof(model[id]) for id in s)
-        x += count(a -> a == Agent3, typeof(model[id]) for id in s)
-    end
-    @test c == 12
-
-    # NOT shuffling types scheduler
-    Random.seed!(12)
-    model = init_mixed_model(scheduler = Schedulers.by_type(false, false))
-    s1 = model.scheduler(model)
-    s2 = model.scheduler(model)
-    @test unique([typeof(model[id]) for id in s1]) == unique([typeof(model[id]) for id in s2])
-
-    # Not shuffling types, but shuffling agents
-    Random.seed!(12)
-    model = init_mixed_model(scheduler = Schedulers.by_type(false, true))
-    s1 = model.scheduler(model)
-    s2 = model.scheduler(model)
-    @test [typeof(model[id]) for id in s1] == [typeof(model[id]) for id in s2]
-    # here we actually check whether agents of same type are shuffled
-    @test model[s1[1]].id ≠ model[s2[1]] || model[s1[2]].id ≠ model[s2[2]]
-
-    # Explicit order of types scheduling
-    Random.seed!(12)
-    model =
-        ABM(Union{Agent1,Agent0}, scheduler = Schedulers.by_type((Agent1, Agent0), true), warn = false)
-    for id in 1:3
-        a1 = Agent1(id, (0, 0))
-        add_agent!(a1, model)
-    end
-    for id in 4:6
-        a0 = Agent0(id)
-        add_agent!(a0, model)
-    end
-    s = model.scheduler(model)
-    @test [typeof(model[id]) for id in s] ==
-          [Agent1, Agent1, Agent1, Agent0, Agent0, Agent0]
-    @test all(x -> x < 4, s[1:3])
-    @test all(x -> x > 3, s[4:6])
-end
-
-@testset "Scheduler as struct" begin
-    mutable struct MyScheduler
-        n::Int # step number
-        w::Float64
-    end
-    function (ms::MyScheduler)(model::ABM)
-        ms.n += 1 # increment internal counter by 1 for each step
-        if ms.n < 5
-            return keys(model.agents) # order doesn't matter in this case
-        else
-            ids = collect(allids(model))
-            # filter all ids whose agents have `w` less than some amount
-            filter!(id -> model[id].weight > ms.w, ids)
-            return ids
+        # Schedulers.by_id
+        model = ABM(Agent0; scheduler=Schedulers.by_id)
+        for i in 1:N
+            add_agent!(model)
         end
-    end
+        @test sort!(collect(keys(model.agents))) == 1:N
+        @test model.scheduler(model) == 1:N
+
+        # fastest
+        Random.seed!(12)
+        model = ABM(Agent0; scheduler=Schedulers.fastest)
+        for i in 1:N
+            add_agent!(model)
+        end
+        @test sort!(collect(model.scheduler(model))) == 1:N
 
-    model = ABM(Agent2;
-        properties = Dict{Int, Bool}(),
-        scheduler = MyScheduler(0, 5.0)
-    )
-    for w in 1.0:10.0
-        add_agent!(model, w)
-    end
-    for i in 1:10
-        ids = sort!(collect(model.scheduler(model)))
-        if i < 5
-            @test ids == 1:10
-        else
-            @test ids == 6:10
+        # random
+        model = ABM(Agent0; scheduler=Schedulers.randomly, rng=StableRNG(12))
+        for i in 1:N
+            add_agent!(model)
         end
-    end
-end
+        fastest_order = collect(keys(model.agents))[1:3]
+        @test model.scheduler(model)[1:3] != fastest_order
 
-@testset "Non-allocating schedulers" begin
-    N = 1000
+        # partial
+        model = ABM(Agent0; scheduler=Schedulers.partially(0.1), rng=StableRNG(12))
+        for i in 1:N
+            add_agent!(model)
+        end
 
-    # Schedulers.by_id
-    model = ABM(Agent0; scheduler = Schedulers.ByID())
-    for i in 1:N
-        add_agent!(model)
-    end
-    @test sort!(collect(keys(model.agents))) == 1:N
-    @test model.scheduler(model) == 1:N
+        a = model.scheduler(model)
+        @test length(a) <= N / 10
 
-    # random
-    model = ABM(Agent0; scheduler = Schedulers.Randomly(), rng = StableRNG(12))
-    for i in 1:N
-        add_agent!(model)
-    end
-    fastest_order = collect(keys(model.agents))[1:3]
-    @test model.scheduler(model)[1:3] != fastest_order
+        # by property
+        model = ABM(Agent2; scheduler=Schedulers.by_property(:weight))
+        for i in 1:N
+            add_agent!(model, rand(model.rng) / rand(model.rng))
+        end
 
-    # partial
-    model = ABM(Agent0; scheduler = Schedulers.Partially(0.1), rng = StableRNG(12))
-    for i in 1:N
-        add_agent!(model)
-    end
+        Random.seed!(12)
+        a = model.scheduler(model)
 
-    a = model.scheduler(model)
-    @test length(a) <= N/10
+        ids = collect(keys(model.agents))
+        properties = [model.agents[id].weight for id in ids]
 
-    # by property
-    model = ABM(Agent2; scheduler = Schedulers.ByProperty(:weight))
-    for i in 1:N
-        add_agent!(model, rand(model.rng) / rand(model.rng))
+        @test ids[sortperm(properties)] == a
     end
 
-    Random.seed!(12)
-    a = collect(model.scheduler(model))
-
-    ids = collect(keys(model.agents))
-    properties = [model.agents[id].weight for id in ids]
-
-    @test ids[sortperm(properties)] == a
+    @testset "Union Types" begin
+        @test Agents.union_types(Union{Agent0}) == (Agent0,)
+        @test Agents.union_types(Union{Agent0,Agent1}) == (Agent0, Agent1)
+        @test Agents.union_types(Union{Agent0,Agent1,Agent2,Agent3}) ==
+            (Agent0, Agent1, Agent2, Agent3)
+        #Union types are not order preserving
+        @test Agents.union_types(Union{Agent1,Agent0}) == (Agent0, Agent1)
+        @test Agents.union_types(Union{Agent1,Agent3,Agent2,Agent0}) ==
+            (Agent0, Agent1, Agent2, Agent3)
+    end
 
     # Mixed model
-    function init_mixed_model2(choices = [3, 3, 3, 3]; scheduler = Schedulers.fastest)
-        model = ABM(Union{Agent0,Agent1,Agent2,Agent3}, scheduler = scheduler, warn = false)
-        atypes = (Agent0,Agent1,Agent2,Agent3)
+    function init_mixed_model(choices=[3, 3, 3, 3]; scheduler=Schedulers.fastest)
+        model = ABM(Union{Agent0,Agent1,Agent2,Agent3}; scheduler=scheduler, warn=false)
+        atypes = (Agent0, Agent1, Agent2, Agent3)
         id = 1
         for i in 1:choices[1]
             a0 = Agent0(id)
@@ -235,7 +75,7 @@ end
         for i in 1:choices[2]
             a1 = Agent1(id, (0, 0))
             add_agent!(a1, model)
-            id +=1
+            id += 1
         end
         for i in 1:choices[3]
             a2 = Agent2(id, 5.0)
@@ -250,60 +90,229 @@ end
         return model
     end
 
-    # standard scheduler
-    model = init_mixed_model2()
-    @test sort!(collect(model.scheduler(model))) == 1:12
-
-    # shuffling types scheduler
-    Random.seed!(12)
-    model = init_mixed_model2(scheduler = Schedulers.ByType(true, false, Union{Agent0,Agent1,Agent2,Agent3}))
-    s1 = model.scheduler(model)
-    s1_types = unique([typeof(model[x]) for x in s1])
-    s2 = model.scheduler(model)
-    s2_types = unique([typeof(model[x]) for x in s2])
-    @test s1_types != s2_types
-    @test count(model[id] isa Agent2 for id in model.scheduler(model)) == 3
-    c = begin
-        x = 0; s = model.scheduler(model)
-        x += count(a -> a == Agent0, typeof(model[id]) for id in s)
-        x += count(a -> a == Agent1, typeof(model[id]) for id in s)
-        x += count(a -> a == Agent2, typeof(model[id]) for id in s)
-        x += count(a -> a == Agent3, typeof(model[id]) for id in s)
+    @testset "Mixed Scheduler" begin
+        # standard scheduler
+        model = init_mixed_model()
+        @test sort!(collect(model.scheduler(model))) == 1:12
+
+        # shuffling types scheduler
+        Random.seed!(12)
+        model = init_mixed_model(; scheduler=Schedulers.by_type(true, false))
+        s1 = model.scheduler(model)
+        s2 = model.scheduler(model)
+        @test unique([typeof(model[id]) for id in s1]) != unique([typeof(model[id]) for id in s2])
+        @test count(model[id] isa Agent2 for id in model.scheduler(model)) == 3
+        c = begin
+            x = 0
+            s = model.scheduler(model)
+            x += count(a -> a == Agent0, typeof(model[id]) for id in s)
+            x += count(a -> a == Agent1, typeof(model[id]) for id in s)
+            x += count(a -> a == Agent2, typeof(model[id]) for id in s)
+            x += count(a -> a == Agent3, typeof(model[id]) for id in s)
+        end
+        @test c == 12
+
+        # NOT shuffling types scheduler
+        Random.seed!(12)
+        model = init_mixed_model(; scheduler=Schedulers.by_type(false, false))
+        s1 = model.scheduler(model)
+        s2 = model.scheduler(model)
+        @test unique([typeof(model[id]) for id in s1]) == unique([typeof(model[id]) for id in s2])
+
+        # Not shuffling types, but shuffling agents
+        Random.seed!(12)
+        model = init_mixed_model(; scheduler=Schedulers.by_type(false, true))
+        s1 = model.scheduler(model)
+        s2 = model.scheduler(model)
+        @test [typeof(model[id]) for id in s1] == [typeof(model[id]) for id in s2]
+        # here we actually check whether agents of same type are shuffled
+        @test model[s1[1]].id ≠ model[s2[1]] || model[s1[2]].id ≠ model[s2[2]]
+
+        # Explicit order of types scheduling
+        Random.seed!(12)
+        model = ABM(
+            Union{Agent1,Agent0};
+            scheduler=Schedulers.by_type((Agent1, Agent0), true),
+            warn=false,
+        )
+        for id in 1:3
+            a1 = Agent1(id, (0, 0))
+            add_agent!(a1, model)
+        end
+        for id in 4:6
+            a0 = Agent0(id)
+            add_agent!(a0, model)
+        end
+        s = model.scheduler(model)
+        @test [typeof(model[id]) for id in s] == [Agent1, Agent1, Agent1, Agent0, Agent0, Agent0]
+        @test all(x -> x < 4, s[1:3])
+        @test all(x -> x > 3, s[4:6])
     end
-    @test c == 12
-
-    # NOT shuffling types scheduler
-    Random.seed!(12)
-    model = init_mixed_model2(scheduler = Schedulers.ByType(false, false, Union{Agent0,Agent1,Agent2,Agent3}))
-    s1 = model.scheduler(model)
-    s2 = model.scheduler(model)
-    @test unique([typeof(model[id]) for id in s1]) == unique([typeof(model[id]) for id in s2])
-
-    # Not shuffling types, but shuffling agents
-    Random.seed!(12)
-    model = init_mixed_model2(scheduler = Schedulers.ByType(false, true, Union{Agent0,Agent1,Agent2,Agent3}))
-    s1 = collect(model.scheduler(model))
-    s2 = collect(model.scheduler(model))
-    @test [typeof(model[id]) for id in s1] == [typeof(model[id]) for id in s2]
-    # here we actually check whether agents of same type are shuffled
-    @test model[s1[1]].id ≠ model[s2[1]] || model[s1[2]].id ≠ model[s2[2]]
-
-    # Explicit order of types scheduling
-    Random.seed!(12)
-    model =
-        ABM(Union{Agent1,Agent0}, scheduler = Schedulers.ByType((Agent1, Agent0), true), warn = false)
-    for id in 1:3
-        a1 = Agent1(id, (0, 0))
-        add_agent!(a1, model)
+
+    @testset "Scheduler as struct" begin
+        mutable struct MyScheduler
+            n::Int # step number
+            w::Float64
+        end
+        function (ms::MyScheduler)(model::ABM)
+            ms.n += 1 # increment internal counter by 1 for each step
+            if ms.n < 5
+                return keys(model.agents) # order doesn't matter in this case
+            else
+                ids = collect(allids(model))
+                # filter all ids whose agents have `w` less than some amount
+                filter!(id -> model[id].weight > ms.w, ids)
+                return ids
+            end
+        end
+
+        model = ABM(Agent2; properties=Dict{Int,Bool}(), scheduler=MyScheduler(0, 5.0))
+        for w in 1.0:10.0
+            add_agent!(model, w)
+        end
+        for i in 1:10
+            ids = sort!(collect(model.scheduler(model)))
+            if i < 5
+                @test ids == 1:10
+            else
+                @test ids == 6:10
+            end
+        end
     end
-    for id in 4:6
-        a0 = Agent0(id)
-        add_agent!(a0, model)
+
+    @testset "Non-allocating schedulers" begin
+        N = 1000
+
+        # Schedulers.by_id
+        model = ABM(Agent0; scheduler=Schedulers.ByID())
+        for i in 1:N
+            add_agent!(model)
+        end
+        @test sort!(collect(keys(model.agents))) == 1:N
+        @test model.scheduler(model) == 1:N
+
+        # random
+        model = ABM(Agent0; scheduler=Schedulers.Randomly(), rng=StableRNG(12))
+        for i in 1:N
+            add_agent!(model)
+        end
+        fastest_order = collect(keys(model.agents))[1:3]
+        @test model.scheduler(model)[1:3] != fastest_order
+
+        # partial
+        model = ABM(Agent0; scheduler=Schedulers.Partially(0.1), rng=StableRNG(12))
+        for i in 1:N
+            add_agent!(model)
+        end
+
+        a = model.scheduler(model)
+        @test length(a) <= N / 10
+
+        # by property
+        model = ABM(Agent2; scheduler=Schedulers.ByProperty(:weight))
+        for i in 1:N
+            add_agent!(model, rand(model.rng) / rand(model.rng))
+        end
+
+        Random.seed!(12)
+        a = collect(model.scheduler(model))
+
+        ids = collect(keys(model.agents))
+        properties = [model.agents[id].weight for id in ids]
+
+        @test ids[sortperm(properties)] == a
+
+        # Mixed model
+        function init_mixed_model2(choices=[3, 3, 3, 3]; scheduler=Schedulers.fastest)
+            model = ABM(Union{Agent0,Agent1,Agent2,Agent3}; scheduler=scheduler, warn=false)
+            atypes = (Agent0, Agent1, Agent2, Agent3)
+            id = 1
+            for i in 1:choices[1]
+                a0 = Agent0(id)
+                add_agent!(a0, model)
+                id += 1
+            end
+            for i in 1:choices[2]
+                a1 = Agent1(id, (0, 0))
+                add_agent!(a1, model)
+                id += 1
+            end
+            for i in 1:choices[3]
+                a2 = Agent2(id, 5.0)
+                add_agent!(a2, model)
+                id += 1
+            end
+            for i in 1:choices[4]
+                a3 = Agent3(id, (0, 0), 5.0)
+                add_agent!(a3, model)
+                id += 1
+            end
+            return model
+        end
+
+        # standard scheduler
+        model = init_mixed_model2()
+        @test sort!(collect(model.scheduler(model))) == 1:12
+
+        # shuffling types scheduler
+        Random.seed!(12)
+        model = init_mixed_model2(;
+            scheduler=Schedulers.ByType(true, false, Union{Agent0,Agent1,Agent2,Agent3})
+        )
+        s1 = model.scheduler(model)
+        s1_types = unique([typeof(model[x]) for x in s1])
+        s2 = model.scheduler(model)
+        s2_types = unique([typeof(model[x]) for x in s2])
+        @test s1_types != s2_types
+        @test count(model[id] isa Agent2 for id in model.scheduler(model)) == 3
+        c = begin
+            x = 0
+            s = model.scheduler(model)
+            x += count(a -> a == Agent0, typeof(model[id]) for id in s)
+            x += count(a -> a == Agent1, typeof(model[id]) for id in s)
+            x += count(a -> a == Agent2, typeof(model[id]) for id in s)
+            x += count(a -> a == Agent3, typeof(model[id]) for id in s)
+        end
+        @test c == 12
+
+        # NOT shuffling types scheduler
+        Random.seed!(12)
+        model = init_mixed_model2(;
+            scheduler=Schedulers.ByType(false, false, Union{Agent0,Agent1,Agent2,Agent3})
+        )
+        s1 = model.scheduler(model)
+        s2 = model.scheduler(model)
+        @test unique([typeof(model[id]) for id in s1]) == unique([typeof(model[id]) for id in s2])
+
+        # Not shuffling types, but shuffling agents
+        Random.seed!(12)
+        model = init_mixed_model2(;
+            scheduler=Schedulers.ByType(false, true, Union{Agent0,Agent1,Agent2,Agent3})
+        )
+        s1 = collect(model.scheduler(model))
+        s2 = collect(model.scheduler(model))
+        @test [typeof(model[id]) for id in s1] == [typeof(model[id]) for id in s2]
+        # here we actually check whether agents of same type are shuffled
+        @test model[s1[1]].id ≠ model[s2[1]] || model[s1[2]].id ≠ model[s2[2]]
+
+        # Explicit order of types scheduling
+        Random.seed!(12)
+        model = ABM(
+            Union{Agent1,Agent0};
+            scheduler=Schedulers.ByType((Agent1, Agent0), true),
+            warn=false,
+        )
+        for id in 1:3
+            a1 = Agent1(id, (0, 0))
+            add_agent!(a1, model)
+        end
+        for id in 4:6
+            a0 = Agent0(id)
+            add_agent!(a0, model)
+        end
+        s = collect(model.scheduler(model))
+        @test [typeof(model[id]) for id in s] == [Agent1, Agent1, Agent1, Agent0, Agent0, Agent0]
+        @test all(x -> x < 4, s[1:3])
+        @test all(x -> x > 3, s[4:6])
     end
-    s = collect(model.scheduler(model))
-    @test [typeof(model[id]) for id in s] ==
-            [Agent1, Agent1, Agent1, Agent0, Agent0, Agent0]
-    @test all(x -> x < 4, s[1:3])
-    @test all(x -> x > 3, s[4:6])
-end
 end
diff --git a/test/space_test.jl b/test/space_test.jl
index 3197b1ecda..c2d4009bab 100644
--- a/test/space_test.jl
+++ b/test/space_test.jl
@@ -14,10 +14,10 @@
         @test nearby_positions(5, undirected) == [4]
         @test sort!(nearby_positions(5, undirected, 2)) == [3, 4]
         @test sort!(nearby_positions(3, undirected, 2)) == [1, 2, 4, 5]
-        @test nearby_positions(3, undirected; neighbor_type = :out) ==
-              nearby_positions(3, undirected; neighbor_type = :in) ==
-              nearby_positions(3, undirected; neighbor_type = :all) ==
-              nearby_positions(3, undirected; neighbor_type = :default)
+        @test nearby_positions(3, undirected; neighbor_type=:out) ==
+            nearby_positions(3, undirected; neighbor_type=:in) ==
+            nearby_positions(3, undirected; neighbor_type=:all) ==
+            nearby_positions(3, undirected; neighbor_type=:default)
         add_agent!(1, undirected, rand(undirected.rng))
         agent = add_agent!(2, undirected, rand(undirected.rng))
         add_agent!(3, undirected, rand(undirected.rng))
@@ -31,27 +31,24 @@
         @test nearby_positions(3, directed) == [4]
         @test nearby_positions(1, directed) == [2]
         @test nearby_positions(5, directed) == []
-        @test nearby_positions(3, directed; neighbor_type = :default) ==
-              nearby_positions(3, directed)
-        @test nearby_positions(3, directed; neighbor_type = :in) == [2]
-        @test nearby_positions(3, directed; neighbor_type = :out) == [4]
-        @test sort!(nearby_positions(3, directed; neighbor_type = :all)) == [2, 4]
+        @test nearby_positions(3, directed; neighbor_type=:default) ==
+            nearby_positions(3, directed)
+        @test nearby_positions(3, directed; neighbor_type=:in) == [2]
+        @test nearby_positions(3, directed; neighbor_type=:out) == [4]
+        @test sort!(nearby_positions(3, directed; neighbor_type=:all)) == [2, 4]
         add_agent!(1, directed, rand(directed.rng))
         add_agent!(2, directed, rand(directed.rng))
         add_agent!(3, directed, rand(directed.rng))
         @test sort!(nearby_ids(2, directed)) == [2, 3]
-        @test sort!(nearby_ids(2, directed; neighbor_type = :in)) == [1, 2]
-        @test sort!(nearby_ids(2, directed; neighbor_type = :all)) == [1, 2, 3]
+        @test sort!(nearby_ids(2, directed; neighbor_type=:in)) == [1, 2]
+        @test sort!(nearby_ids(2, directed; neighbor_type=:all)) == [1, 2, 3]
         @test collect(nearby_ids(directed[2], directed)) == [3]
-        @test collect(nearby_ids(directed[2], directed; neighbor_type = :in)) == [1]
-        @test sort!(collect(nearby_ids(directed[2], directed; neighbor_type = :all))) ==
-              [1, 3]
+        @test collect(nearby_ids(directed[2], directed; neighbor_type=:in)) == [1]
+        @test sort!(collect(nearby_ids(directed[2], directed; neighbor_type=:all))) ==
+            [1, 3]
 
-
-
-
-###################################################################################
-# Continuous space
+        ###################################################################################
+        # Continuous space
 
     end
 
@@ -67,5 +64,4 @@
         vel::NTuple{3,Float64}
         weight::Float64
     end
-
 end