Вопрос по playframework-2.0 – Скала: возвращение имеет свое место

как Хаскеллер, очевидно, на мой взгляд, решение всего - Монады. Шагните со мной на мгновение в упрощенный мир (то есть упрощенный для меня), где ваша проблема в Haskell, и у вас есть следующие типы для решения (как у Haskeller, у меня вроде есть этот фетиш для типов):

bindFormRequest :: Request -> Form -> BoundForm
hasErrors :: BoundForm -> Bool

processPayment :: Model -> OrderNum -> TransID
isEmpty :: TransID -> Bool

Давай остановимся здесь. На данный момент, я как бы немного цепляюсь заboundFormHasErrors а такжеtransIDisEmpty. Обе эти вещи подразумевают, что возможность отказа вводитс BoundForm а такжеTransID соответственно. Плохо. Вместо этого возможность отказа должна поддерживаться отдельно. Позвольте мне предложить эту альтернативу:

bindFormRequest :: Request -> Form -> Either FormBindError BoundForm
processPayment :: Model -> OrderNum -> Either TransError TransID 

Это чувствует себя немного лучше, и эти Итеры ведут к использованию монады Итер. Давайте напишем еще несколько типов, хотя. Я собираюсь игнорироватьOK потому что это оборачивается практически всем; Я немного выдумал, но концепции все равно будут переводиться. Доверьтесь мне; В конце я возвращаю это Скале.

save :: Request -> IO Action

form :: Form
withForm :: BoundForm -> Action

getModel :: BoundForm -> Model
generateOrderNum :: IO OrderNum
withGlobalError :: ... -> BoundForm -> BoundForm

getHeader :: String -> Request -> String
dao :: DAO
createMember :: Model -> String -> OrderNum -> TransID
             -> DAO -> IO (Either DAOErr (Foo, Bar, Baz))

allGood :: Foo -> Bar -> Baz -> IO Action

Ладно, теперь я собираюсь сделать что-то немного странное, и позвольте мне рассказать вам, почему. Любая монада работает так: как только вы нажметеLeft, ты прекрати. (Удивительно ли, что я выбрал эту монаду для имитации ранних возвратов?) Это все хорошо, но мы хотим всегда останавливаться наAction и поэтому останавливаясь сFormBindError не собирается сокращать это. Итак, давайте определим две функции, которые позволят нам работать с Eithers таким образом, чтобы мы могли установить немного больше «обработки», если мы обнаружимLeft.

-- if we have an `Either a a', then we can always get an `a' out of it!
unEither :: Either a a -> a
unEither (Left a) = a
unEither (Right a) = a

onLeft :: Either l r -> (l -> l') -> Either l' r
(Left l)  `onLeft` f = Left (f l)
(Right r) `onLeft` _ = Right r

В этот момент в Хаскеле ябыло б говорить о монадных трансформаторах и укладкеEitherT на вершинеIO. Однако в Scala это не проблема, поэтому везде, где мы видимIO Foo, мы можем просто притвориться, что этоFoo.

Хорошо, давай напишемsave. Мы будем использоватьdo синтаксис, а позже переведет его наScala sfor синтаксис. Напомним, вfor синтаксис вы можете делать три вещи:

А потом в конце мы сможемyield, что совпадает сreturn в Хаскеле. Мы ограничимся этими вещами, чтобы убедиться, что перевод с Haskell на Scala проходит гладко.

save :: Request -> Action
save request = unEither $ do
  bound <- bindFormRequest request form
           `onLeft` (\err -> withForm (getSomeForm err))

  let model = getModel bound
  let orderNum = generateOrderNum
  transID <- processPayment model orderNum
             `onLeft` (\err -> withForm (withGlobalError ... bound))

  let ip = getHeader "X-Forwarded-For" request
  (foo, bar, baz) <- createMember model ip orderNum transID dao
                     `onLeft` (\err -> withForm (withGlobalError ... bound))

  return $ allGood foo bar baz

Заметили что-нибудь? Это выглядит почти Тождественны к коду, который ты написал в императивном стиле!

Возможно, вам интересно, почему я приложил все усилия, чтобы написать ответ на Хаскелле. Ну, это потому, что мне нравится перепроверять мои ответы, и я довольно хорошо знаю, как это сделать в Haskell. Вот файл, который проверяет типы и содержит все сигнатуры типов, которые я только что указал (sansIO):http: //hpaste.org/6944

Ладно, теперь давайте переведем это на Scala. Во-первых,Either помощники.

Вот начинается Скала

// be careful how you use this.
// Scala's subtyping can really screw with you if you don't know what you're doing
def unEither[A](e: Either[A, A]): A = e match {
  case Left(a)  => a
  case Right(a) => a
}

def onLeft[L1, L2, R](e: Either[L1, R], f: L1 => L2) = e match {
  case Left(l) = Left(f(l))
  case Right(r) = Right(r)
}

Сейчасsave метод

def save = Action { implicit request => unEither( for {
  bound <- onLeft(form.bindFormRequest,
                  err => Ok(withForm(err.getSomeForm))).right

  model = bound.get
  orderNum = generateOrderNum()
  transID <- onLeft(processPayment(model, orderNum),
                    err => Ok(withForm(bound.withGlobalError(...))).right

  ip = request.headers.get("X-Forwarded-For")
  (foo, bar, baz) <- onLeft(dao.createMember(model, ip, orderNum, transID),
                            err => Ok(withForm(bound.withGlobalError(...))).right
} yield allGood(foo, bar, baz) ) }

Обратите внимание, что переменные в левой части<- или= неявно считаетсяval с, так как они находятся внутриfor блок. Вы должны смело менятьonLeft так, что он насаживается наEither значения для более красивого использования. Также убедитесь, что вы импортировали соответствующий «экземпляр Monad» дляEither S.

В заключение я просто хотел бы отметить, что цель монадного сахара в том, чтобы сгладить вложенный функциональный код. используйте его!

[править: в Scala вам нужно «смещаться вправо»Eithers, чтобы заставить их работать сfor синтаксис. Это делается путем добавления.right наEither значения в правой части<-. Никакого дополнительного импорта не требуется. Это можно сделать внутриonLeft для более красивого кода. Смотрите также:https: //stackoverflow.com/a/10866844/20825 ]

Как насчет вложенногоdefs?

def save = Action { implicit request =>
  def transID = {
    val model = bound.get
    val orderNum = generateOrderNum()
    processPayment(model, orderNum)
  }
  def result = {
    val ip = request.headers.get("X-Forwarded-For")
    dao.createMember(model, ip, orderNum, transID)
  }
  val bound = form.bindFromRequest

  if(bound.hasErrors) Ok(withForm(bound))
  else if(transID.isEmpty) Ok(withForm( bound.withGlobalError(...) ))
  else result match {
    case Left(_) => 
      Ok(withForm( bound.withGlobalError(...) ))
    case Right((foo, bar, baz)) =>
      // all good: generate pdf, email, redirect with success msg
    }
  }
}

тов в тех местах, где синтаксически все нормально, но на самом деле приходится выпрыгивать из нескольких методов. Так что вы можете позволить этому сделать это:

def save = Action { implicit request =>
  def result(): Foo = {
    /* All your logic goes in here, including returns */
  }
  result()
}

или, если хотите, вы можете использовать свой собственный класс для передачи данных (без трассировки стека):

import scala.util.control.ControlThrowable
case class Return[A](val value: A) extends ControlThrowable {}

def save = Action { implicit request =>
  try {
    /* Logic */
    if (exitEarly) throw Return(Ok(blahBlah))
    /* More logic */
  }
  catch {
    case Return(x: Foo) => x
  }
}

Или вы можете немного повеселиться и добавить собственную обработку исключений:

case class Return[A](val value: A) extends ControlThrowable {}
class ReturnFactory[A]{ def apply(a: A) = throw new Return(a) }
def returning[A: ClassManifest](f: ReturnFactory[A] => A) = {
  try { f(new ReturnFactory[A]) } catch {
    case r: Return[_] =>
      if (implicitly[ClassManifest[A]].erasure.isAssignableFrom(r.value.getClass)) {
        r.value.asInstanceOf[A]
      } else {
        throw new IllegalArgumentException("Wrong Return type")
      }
  } 
}

(Если вы хотите иметь возможность вкладыватьreturnings, просто отброситьReturn вместо броскаIllegalArgumentException когда тип не совпадает.) Вы можете использовать это так:

def bar(i: Int) = returning[String] { ret =>
  if (i<0) ret("fish")
  val j = i*4
  if (j>=20) ret("dish")
  "wish"*j
}

bar(-3)   // "fish"
bar(2)    // "wishwishwishwishwishwishwishwish"
bar(5)    // "dish"

или в вашем конкретном случае

def save = Action{ implicit request => returning[Foo] { ret =>
  /* Logic goes here, using ret(foo) as needed */
}}

Он не встроен, но не должно быть очень сложно объяснить людям, как Использование это даже если не так просто понять, как строится такая возможность. (Примечание: Scala имеет встроеннbreak возможность вscala.util.control.Breaks который использует нечто очень похожее на эту стратегию.)

похоже, проблема в том, что вы выполняете бизнес-логику в контроллере, а подписи Play не делают Гм играть хорошо с возвращаемыми значениями, как это вторично.

Я бы порекомендовал вам инкапсулировать вызовы generateOrderNum, processPayment, createMember за фасадом, и это возвращаемое значение может возвращать соответствующее состояние бизнес-транзакции, которое затем можно использовать для возврата надлежащего состояния контроллера.

Скоро обновлю этот ответ примеро

Редактировать: это довольно небрежно, поэтому перепроверьте синтаксис, но суть моего ответа состоит в том, чтобы переместить вашу последовательность бизнес-логики во внешний класс, который будет использовать те или иные / влево / вправо, которые вы уже используете, но теперь включает вашу проверку для пустого идентификатора транзакции в левом ответе.

def save = Action {implicit request =>
  val bound = form.bindFromRequest
  if (!bound.hasErrors) {
    val model = bound.get
    val ip = request.headers.get("X-Forwarded-For")

    val result = paymentService.processPayment(model, ip)

    result match {
      case Left(_) => Ok(withForm(bound.withGlobalError(...)))
      case Right((foo, bar, baz)) => // all good: generate pdf, email, redirect with success msg
    }
  }
  else Ok(withForm(bound))
}

class PaymentService {
  def processPayment(model, ip): Either[Blah, Blah] = {
    val orderNum = generateOrderNum()
    val transID = processPayment(model, orderNum)
    if (transID.isEmpty) Left(yadda)
    else Right(dao.createMember(model, ip, orderNum, transID))
  }
}

Единственное, что немного обманывает - это if / else для bound.hasErrors, но он не уверен в правильном способе сложить это в матч.

Имеет смысл?