From 3922580c582f32e51ac28ea2a887661dfc4ddd8d Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Tue, 1 Mar 2011 08:48:14 -0500 Subject: [PATCH] join for tasks and settings --- main/Structure.scala | 43 +++++++++++++++++++++++++++------- util/collection/Settings.scala | 15 ++++++++++++ 2 files changed, 49 insertions(+), 9 deletions(-) diff --git a/main/Structure.scala b/main/Structure.scala index fccf17f85..bba0342c0 100644 --- a/main/Structure.scala +++ b/main/Structure.scala @@ -74,16 +74,25 @@ object Scoped implicit def richSettingListScoped[T](s: ScopedSetting[Seq[T]]): RichSettingList[T] = new RichSettingList[T](s.scope, s.key) implicit def richListTaskScoped[T](s: ScopedTask[Seq[T]]): RichListTask[T] = new RichListTask[T](s.scope, s.key) - implicit def settingScoping[T](s: SettingKey[T]): ScopingSetting[T, ScopedSetting[T]] = - new ScopingSetting(s.key, scope => scopedSetting(scope, s.key)) + implicit def scopedSettingScoping[T](s: ScopedSetting[T]): ScopingSetting[ScopedSetting[T]] = + new ScopingSetting(scope => scopedSetting(Scope.replaceThis(s.scope)(scope), s.key)) - implicit def inputScoping[T](s: InputKey[T]): ScopingSetting[InputTask[T], ScopedInput[T]] = - new ScopingSetting(s.key, scope => scopedInput(scope, s.key)) + implicit def scopedTaskScoping[T](s: ScopedTask[T]): ScopingSetting[ScopedTask[T]] = + new ScopingSetting(scope => scopedTask(Scope.replaceThis(s.scope)(scope), s.key)) - implicit def taskScoping[T](s: TaskKey[T]): ScopingSetting[Task[T], ScopedTask[T]] = - new ScopingSetting(s.key, scope => scopedTask(scope, s.key)) + implicit def scopedInputScoping[T](s: ScopedInput[T]): ScopingSetting[ScopedInput[T]] = + new ScopingSetting(scope => scopedInput(Scope.replaceThis(s.scope)(scope), s.key)) - final class ScopingSetting[T, Result](val key: AttributeKey[T], app0: Scope => Result) + implicit def settingScoping[T](s: SettingKey[T]): ScopingSetting[ScopedSetting[T]] = + new ScopingSetting(scope => scopedSetting(scope, s.key)) + + implicit def inputScoping[T](s: InputKey[T]): ScopingSetting[ScopedInput[T]] = + new ScopingSetting(scope => scopedInput(scope, s.key)) + + implicit def taskScoping[T](s: TaskKey[T]): ScopingSetting[ScopedTask[T]] = + new ScopingSetting(scope => scopedTask(scope, s.key)) + + final class ScopingSetting[Result](app0: Scope => Result) { def in(s: Scope): Result = app0(s) @@ -174,8 +183,19 @@ object Scoped } } - implicit def richTaskSeq(in: Seq[ScopedTask[_]]): RichTaskSeq = new RichTaskSeq(in) - final class RichTaskSeq(keys: Seq[ScopedTask[_]]) + implicit def richSettingSeq[T](in: Seq[ScopedSetting[T]]): RichSettingSeq[T] = new RichSettingSeq(in) + final class RichSettingSeq[T](keys: Seq[ScopedSetting[T]]) + { + def join: Initialize[Seq[T]] = joinWith(identity) + def joinWith[S](f: Seq[T] => S): Initialize[S] = Apply.uniform(keys)(f) + } + implicit def richTaskSeq[T](in: Seq[ScopedTask[T]]): RichTaskSeq[T] = new RichTaskSeq(in) + final class RichTaskSeq[T](keys: Seq[ScopedTask[T]]) + { + def join: Initialize[Task[Seq[T]]] = Apply.uniformTasks(keys) + } + implicit def richAnyTaskSeq(in: Seq[ScopedTask[_]]): RichAnyTaskSeq = new RichAnyTaskSeq(in) + final class RichAnyTaskSeq(keys: Seq[ScopedTask[_]]) { def dependOn: Initialize[Task[Unit]] = Apply.tasks(KList.fromList(keys)) { kl => nop.dependsOn(kl.toList :_*) } } @@ -348,6 +368,11 @@ object Scoped def apply[HL <: HList, T](in: KList[ScopedSetting, HL])(f: HL => T): Initialize[T] = Project.app(in transform ssToSK)(f) + def uniformTasks[S](inputs: Seq[ScopedTask[S]]): Initialize[Task[Seq[S]]] = + Project.uniform( inputs map stToSK.fn )(_ join) + def uniform[S,T](inputs: Seq[ScopedSetting[S]])(f: Seq[S] => T): Initialize[T] = + Project.uniform( inputs map ssToSK.fn )(f) + def tasks[HL <: HList, T](in: KList[ScopedTask, HL])(f: KList[Task, HL] => T): Initialize[T] = { val kapp = new Project.KApp[HL, Task, T] diff --git a/util/collection/Settings.scala b/util/collection/Settings.scala index e6b574859..ef6261c51 100644 --- a/util/collection/Settings.scala +++ b/util/collection/Settings.scala @@ -159,6 +159,21 @@ trait Init[Scope] def zipWith[S,U](o: Initialize[S])(f: (T,S) => U): Initialize[U] = new Joined[T,S,U](this, o, f) def get(map: Settings[Scope]): T } + object Initialize + { + implicit def joinInitialize[T](s: Seq[Initialize[T]]): JoinInitSeq[T] = new JoinInitSeq(s) + final class JoinInitSeq[T](s: Seq[Initialize[T]]) + { + def join[S](f: Seq[T] => S): Initialize[S] = this.join map f + def join: Initialize[Seq[T]] = Initialize.join(s) + } + def join[T](inits: Seq[Initialize[T]]): Initialize[Seq[T]] = + inits match + { + case Seq() => value( Nil ) + case Seq(x, xs @ _*) => (join(xs) zipWith x)( (t,h) => h +: t) + } + } final class Setting[T](val key: ScopedKey[T], val init: Initialize[T]) { def definitive: Boolean = !init.dependsOn.contains(key)