Apply Runic formatter

Author: gdalle

DifferentiationInterface/docs/make.jl

@@ -21,11 +21,11 @@ readme_str = replace(readme_str, "> [!CAUTION]\n> " => "!!! warning\n    ")
 write(joinpath(@__DIR__, "src", "index.md"), readme_str)
 
 makedocs(;
-    modules=[DifferentiationInterface],
-    authors="Guillaume Dalle, Adrian Hill",
-    sitename="DifferentiationInterface.jl",
-    format=Documenter.HTML(; assets=["assets/favicon.ico"]),
-    pages=[
+    modules = [DifferentiationInterface],
+    authors = "Guillaume Dalle, Adrian Hill",
+    sitename = "DifferentiationInterface.jl",
+    format = Documenter.HTML(; assets = ["assets/favicon.ico"]),
+    pages = [
         "Home" => "index.md",
         "Tutorials" => ["tutorials/basic.md", "tutorials/advanced.md"],
         "Explanation" => [
@@ -37,13 +37,13 @@ makedocs(;
         "api.md",
         "dev_guide.md",
     ],
-    plugins=[links],
+    plugins = [links],
 )
 
 deploydocs(;
-    repo="github.com/JuliaDiff/DifferentiationInterface.jl",
-    devbranch="main",
-    dirname="DifferentiationInterface",
-    tag_prefix="DifferentiationInterface-",
-    push_preview=false,
+    repo = "github.com/JuliaDiff/DifferentiationInterface.jl",
+    devbranch = "main",
+    dirname = "DifferentiationInterface",
+    tag_prefix = "DifferentiationInterface-",
+    push_preview = false,
 )

DifferentiationInterface/docs/src/assets/logo.jl

@@ -32,13 +32,13 @@ logo = begin
 
     # Define center points and corners of triangle
     center = Point(0, 4)
-    corners = ngon(center, 16, 3, -0.75π / 2; vertices=true)
+    corners = ngon(center, 16, 3, -0.75π / 2; vertices = true)
 
     # Draw three blended partials
     for (i, c) in enumerate(corners)
         b = blend(c, 0, center, 50, colors[i], black)
         setblend(b)
-        text("∂", c; valign=:middle, halign=:center, angle=0.68π + 2π / 3 * i)
+        text("∂", c; valign = :middle, halign = :center, angle = 0.68π + 2π / 3 * i)
     end
 
     finish()

DifferentiationInterface/ext/DifferentiationInterfaceChainRulesCoreExt/reverse_onearg.jl

@@ -1,46 +1,46 @@
 ## Pullback
 
-struct ChainRulesPullbackPrepSamePoint{SIG,Y,PB} <: DI.PullbackPrep{SIG}
+struct ChainRulesPullbackPrepSamePoint{SIG, Y, PB} <: DI.PullbackPrep{SIG}
     _sig::Val{SIG}
     y::Y
     pb::PB
 end
 
 function DI.prepare_pullback_nokwarg(
-    strict::Val,
-    f,
-    backend::AutoReverseChainRules,
-    x,
-    ty::NTuple,
-    contexts::Vararg{DI.GeneralizedConstant,C};
-) where {C}
+        strict::Val,
+        f,
+        backend::AutoReverseChainRules,
+        x,
+        ty::NTuple,
+        contexts::Vararg{DI.GeneralizedConstant, C}
+    ) where {C}
     _sig = DI.signature(f, backend, x, ty, contexts...; strict)
     return DI.NoPullbackPrep(_sig)
 end
 
 function DI.prepare_pullback_same_point(
-    f,
-    prep::DI.NoPullbackPrep,
-    backend::AutoReverseChainRules,
-    x,
-    ty::NTuple,
-    contexts::Vararg{DI.GeneralizedConstant,C};
-) where {C}
+        f,
+        prep::DI.NoPullbackPrep,
+        backend::AutoReverseChainRules,
+        x,
+        ty::NTuple,
+        contexts::Vararg{DI.GeneralizedConstant, C}
+    ) where {C}
     DI.check_prep(f, prep, backend, x, ty, contexts...)
-    _sig = DI.signature(f, backend, x, ty, contexts...; strict=DI.is_strict(prep))
+    _sig = DI.signature(f, backend, x, ty, contexts...; strict = DI.is_strict(prep))
     rc = ruleconfig(backend)
     y, pb = rrule_via_ad(rc, f, x, map(DI.unwrap, contexts)...)
     return ChainRulesPullbackPrepSamePoint(_sig, y, pb)
 end
 
 function DI.value_and_pullback(
-    f,
-    prep::DI.NoPullbackPrep,
-    backend::AutoReverseChainRules,
-    x,
-    ty::NTuple,
-    contexts::Vararg{DI.GeneralizedConstant,C},
-) where {C}
+        f,
+        prep::DI.NoPullbackPrep,
+        backend::AutoReverseChainRules,
+        x,
+        ty::NTuple,
+        contexts::Vararg{DI.GeneralizedConstant, C},
+    ) where {C}
     DI.check_prep(f, prep, backend, x, ty, contexts...)
     rc = ruleconfig(backend)
     y, pb = rrule_via_ad(rc, f, x, map(DI.unwrap, contexts)...)
@@ -51,13 +51,13 @@ function DI.value_and_pullback(
 end
 
 function DI.value_and_pullback(
-    f,
-    prep::ChainRulesPullbackPrepSamePoint,
-    backend::AutoReverseChainRules,
-    x,
-    ty::NTuple,
-    contexts::Vararg{DI.GeneralizedConstant,C},
-) where {C}
+        f,
+        prep::ChainRulesPullbackPrepSamePoint,
+        backend::AutoReverseChainRules,
+        x,
+        ty::NTuple,
+        contexts::Vararg{DI.GeneralizedConstant, C},
+    ) where {C}
     DI.check_prep(f, prep, backend, x, ty, contexts...)
     (; y, pb) = prep
     tx = map(ty) do dy
@@ -67,13 +67,13 @@ function DI.value_and_pullback(
 end
 
 function DI.pullback(
-    f,
-    prep::ChainRulesPullbackPrepSamePoint,
-    backend::AutoReverseChainRules,
-    x,
-    ty::NTuple,
-    contexts::Vararg{DI.GeneralizedConstant,C},
-) where {C}
+        f,
+        prep::ChainRulesPullbackPrepSamePoint,
+        backend::AutoReverseChainRules,
+        x,
+        ty::NTuple,
+        contexts::Vararg{DI.GeneralizedConstant, C},
+    ) where {C}
     DI.check_prep(f, prep, backend, x, ty, contexts...)
     (; pb) = prep
     tx = map(ty) do dy

DifferentiationInterface/ext/DifferentiationInterfaceDiffractorExt/DifferentiationInterfaceDiffractorExt.jl

@@ -11,15 +11,15 @@ DI.pullback_performance(::AutoDiffractor) = DI.PullbackSlow()
 ## Pushforward
 
 function DI.prepare_pushforward_nokwarg(
-    strict::Val, f, backend::AutoDiffractor, x, tx::NTuple
-)
+        strict::Val, f, backend::AutoDiffractor, x, tx::NTuple
+    )
     _sig = DI.signature(f, backend, x, tx; strict)
     return DI.NoPushforwardPrep(_sig)
 end
 
 function DI.pushforward(
-    f, prep::DI.NoPushforwardPrep, backend::AutoDiffractor, x, tx::NTuple
-)
+        f, prep::DI.NoPushforwardPrep, backend::AutoDiffractor, x, tx::NTuple
+    )
     DI.check_prep(f, prep, backend, x, tx)
     ty = map(tx) do dx
         # code copied from Diffractor.jl
@@ -31,8 +31,8 @@ function DI.pushforward(
 end
 
 function DI.value_and_pushforward(
-    f, prep::DI.NoPushforwardPrep, backend::AutoDiffractor, x, tx::NTuple
-)
+        f, prep::DI.NoPushforwardPrep, backend::AutoDiffractor, x, tx::NTuple
+    )
     DI.check_prep(f, prep, backend, x, tx)
     return f(x), DI.pushforward(f, prep, backend, x, tx)
 end