Создать набор функций tupled с набором параметров, и осуществить взыскание в порядке в Scala


Я пытаюсь создать коллекцию Unit функции, которые имеют любой арности и тип, и будет выполнять их по порядку.

Это рабочая реализация, которая у меня есть:

/** A Subroutine simply represents a unit function that takes any number of parameters. */
type Subroutine = (Any) => Unit

/** A Routine represents a collection of functions which may consume a collection of parameters and will always
  * complete an action.
  */
type Routine = List[(Subroutine, Seq[_])]

/** This function will consume a list of functions executing them in order.
  *
  * @param routine is the list of functions and their parameters to be consumed.
  */
def executeRoutine(routine: Routine): Unit = {
  routine.headOption match {
    case Some((f, x)) =>
      f(x)
      executeRoutine(routine.tail)
    case None => ()
  }
}

и когда я объявляю функцию или "метка", я должен объявить его, как это для того, чтобы извлечь параметры:

def myFunction: Subroutine = {
  case (firstParam: Int) :: (secondParam: String) :: _ => ...
  case _ => throw new InvalidParameterException()
}

def myFunction2: Subroutine = {
  case (firstParam: Int) :: _ => ...
  case _ => throw new InvalidParameterException()
}

val routine: Routine = List(
  (myFunction, Seq(firstParam, secondParam)),
  (myFunction2, Seq(firstParam))
)

Я понимаю, что это не близко к идиоматический код на Scala, и я работаю на реализации другой подход, который будет частично применять функции одного параметра за один раз, а затем выполнить функцию после параметров, применяются в полном объеме. У меня пока нет рабочей версии этого подхода, но это, насколько я получил:

/** A Subroutine simply represents a unit function that takes any number of parameters. */
sealed abstract class Subroutine extends (Any => Unit)

case class Curried(partiallyApplied: Function[_, Function[_, _]], unapplied: Function[_, _]) extends Subroutine

case class Uncurried(function: Function[_, Unit]) extends Subroutine

/** A Routine represents a collection of functions which may consume a collection of parameters and will always
  * complete an action.
  * Using HList for the parameters, from Shapeless
  */
type Routine = List[(Subroutine, HList)]

/** This function will consume a list of functions executing them in order.
  *
  * @param routine is the list of functions and their parameters to be consumed.
  */
def executeRoutine(routine: Routine): Unit = {
  routine.headOption match {
    case Some((f, x)) =>
      executeSubroutine(f, x)
      executeRoutine(routine.tail)
    case None => ()
  }
}

private def executeSubroutine(subroutine: Subroutine, params: HList): Any = {
  subroutine match {
    case Curried(partiallyApplied, unapplied) =>
      partiallyApplied(params.head)(executeSubroutine(unapplied, params.tail))
    case Uncurried(function) => function(params.head)
  }
}

Если кто может помочь мне, что будет принята с благодарностью!



Комментарии