Reduce instances of Init.Apply

main-settings/src/main/scala/sbt/Def.scala

@@ -242,7 +242,7 @@ object Def extends BuildSyntax with Init[Scope] with InitializeImplicits:
     sbt.internal.util.complete.Parsers.spaceDelimited(argLabel)
 
   /** Lifts the result of a setting initialization into a Task. */
-  def toITask[A1](i: Initialize[A1]): Initialize[Task[A1]] = map(i)(std.TaskExtra.inlineTask)
+  def toITask[A1](i: Initialize[A1]): Initialize[Task[A1]] = i(std.TaskExtra.inlineTask)
 
   inline def toSParser[A1](p: Parser[A1]): State => Parser[A1] = const(p)
   def toISParser[A1](p: Initialize[Parser[A1]]): Initialize[State => Parser[A1]] =

main-settings/src/main/scala/sbt/std/Instances.scala

@@ -18,7 +18,7 @@ object InitializeInstance:
     type F[x] = Initialize[x]
 
     override def pure[A1](a: () => A1): Initialize[A1] = Def.pure(a)
-    override def map[A1, A2](in: Initialize[A1])(f: A1 => A2): Initialize[A2] = Def.map(in)(f)
+    override def map[A1, A2](in: Initialize[A1])(f: A1 => A2): Initialize[A2] = in(f)
     override def ap[A1, A2](ff: Initialize[A1 => A2])(fa: Initialize[A1]): Initialize[A2] =
       Def.ap[A1, A2](ff)(fa)
     override def flatMap[A1, A2](fa: Initialize[A1])(f: A1 => Initialize[A2]) =

util-collection/src/main/scala/sbt/internal/util/INode.scala

@@ -221,7 +221,7 @@ abstract class EvaluateSettings[ScopeType]:
   private[this] final class MixedNode[Tup <: Tuple, A1](in: Tuple.Map[Tup, INode], f: Tup => A1)
       extends INode[A1]:
     import TupleMapExtension.*
-    protected override def dependsOn: Seq[INode[_]] = in.iterator.toList
+    protected override def dependsOn: Seq[INode[_]] = in.toList0
     protected override def evaluate0(): Unit = setValue(f(in.unmap(getValue)))
 
   private[this] final class UniformNode[A1, A2](in: List[INode[A1]], f: List[A1] => A2)

util-collection/src/main/scala/sbt/internal/util/Settings.scala

@@ -104,12 +104,12 @@ trait Init[ScopeType]:
     Optional(Some(i), f)
 
   def update[A1](key: ScopedKey[A1])(f: A1 => A1): Setting[A1] =
-    setting[A1](key, map(key)(f), NoPosition)
+    setting[A1](key, key(f), NoPosition)
 
   def flatMap[A1, A2](in: Initialize[A1])(f: A1 => Initialize[A2]): Initialize[A2] = Bind(f, in)
 
-  def map[A1, A2](in: Initialize[A1])(f: A1 => A2): Initialize[A2] =
-    app[Tuple1[A1], A2](Tuple1(in)) { case Tuple1(x) => f(x) }
+  private[this] def map[A1, A2](in: Initialize[A1])(f: A1 => A2): Initialize[A2] =
+    Apply[Tuple1[A1], A2](x => f(x(0)), Tuple1(in))
 
   def app[Tup <: Tuple, A2](inputs: Tuple.Map[Tup, Initialize])(f: Tup => A2): Initialize[A2] =
     Apply[Tup, A2](f, inputs)
@@ -969,16 +969,7 @@ trait Init[ScopeType]:
 
     private[sbt] override def processAttributes[A2](init: A2)(f: (A2, AttributeMap) => A2): A2 =
       inputs.foldLeft(init)((v, i) => i.processAttributes(v)(f))
-
-  /*   private[sbt] final class Mapped[A1, A2](f: A1 => A2, input: Initialize[A1]) extends Initialize[A1]:
-    override def dependencies: Seq[ScopedKey[_]] = deps(Seq(inputs))
-    override def mapReferenced(g: MapScoped): Initialize[A2] = Mapped(f, input.mapReferenced(g))
-    override def mapConstant(g: MapConstant): Initialize[A2] = Mapped(f, input.mapConstant(g))
-    override def apply[A3](g: A2 => A3): Initialize[A3] = Mapped(g.compose(f), input)
-    override def evaluate(ss: Settings[ScopeType]): A2 = f(input.evaluate(ss))
-    override def validateKeyReferenced(g: ValidateKeyRef): ValidatedInit[A1] = input.validateKeyReferenced(g)
-    private[sbt] override def processAttributes[A2](init: A2)(f: (A2, AttributeMap) => A2): A2 =
-      input.processAttributes(init)(f) */
+  end Uniform
 
   private[sbt] final class Apply[Tup <: Tuple, A1](
       val f: Tup => A1,

util-collection/src/test/scala/SettingsExample.scala

@@ -57,7 +57,7 @@ case class SettingsUsage(val settingsExample: SettingsExample) {
   // Define some settings
   val mySettings: Seq[Setting[_]] = Seq(
     setting(a3, value(3)),
-    setting(b4, map(a4)(_ * 3)),
+    setting(b4, a4(_ * 3)),
     update(a5)(_ + 1)
   )