Nested objects without generics support: workarounds - forms

Question

Hitting a catch 22 situation due to lack of generics support in Play template layer.
I have several shopping cart screens that all require a User and a Payment + optional custom fields.
case class Conference(
user: User,
payment: Payment
... custom fields here
)
So, rather than duplicating all the user and payment form fields per shop cart model, I've consolidated as above and implemented nested forms.
Now, the problem occurs at the template layer where there is to-date no generics support.
The parent/container form pulls in nested child forms like so:
#(_form: Form[Conference])
#user.nested( UserForm.form.fill(_form.get.user) )
#payment.nested( PaymentForm.form.fill(_form.get.payment) )
and then the child User form looks like:
#(_form: Form[User])
#inputText(_form("user.firstName"), '_label-> "First Name*", 'class-> "required")
#inputText(_form("user.lastName"), '_label-> "Last Name*", 'class-> "required")
...
and the User model:
case class User(firstName: String, lastName: String ...)
How do I access "user.firstName", "user.lastName", etc. when there is no user property in the User model? The Play Form apply method is:
def apply(key: String): Field = Field(
this,
key,
constraints.get(key).getOrElse(Nil),
formats.get(key),
errors.collect { case e if e.key == key => e },
data.get(key))
Basically it's going to look for property data.user.firstName which is obviously not going to work.
I've thought about adding a user property to User model:
case class User(firstName: String, lastName: String ...) {
val user: User
}
but not sure if that will work and/or wreak havoc with case class companion object apply/unapply.
At any rate, given the lack of generics, what's a viable solution to the problem?
Were generics supported we could pass in an upper bound and everything would be rosy:
trait CartOrder {
user: User,
payment: Payment
}
case class Conference(...) extends CartOrder
and then nested User form is passed an instance that contains a user property and we're good
#[T <: CartOrder](_form: Form[T])
#inputText(_form("user.firstName"), '_label-> "First Name*", 'class-> "required")
...

Answer 1

If type safety isn't a concern (Forms aren't all that type safe to begin with), you can just use Form[_] as the parameter type for your nested templates.
If you do want type safety, one option is to make a wrapper class for Form that is covariant and use that in place of Form. One implementation is:
package views.html
import play.api.data._
import play.api.libs.json.JsValue
object FormView {
implicit def formToFormView[A, T >: A](form: Form[A]): FormView[T] = new FormView[T] {
type F = A
def realForm = form
}
}
trait FormView[+T] {
type F <: T
def realForm: Form[F]
def apply(key: String): Field = realForm(key)
def constraints : Map[String, Seq[(String, Seq[Any])]] = realForm.constraints
def data: Map[String, String] = realForm.data
def error(key: String): Option[FormError] = realForm.error(key)
def errors(key: String): Seq[FormError] = realForm.errors(key)
def errors: Seq[FormError] = realForm.errors
def errorsAsJson: JsValue = realForm.errorsAsJson
def get: T = realForm.get
def formats: Map[String, (String, Seq[Any])] = realForm.formats
def globalError: Option[FormError] = realForm.globalError
def globalErrors: Seq[FormError] = realForm.globalErrors
def hasErrors: Boolean = realForm.hasErrors
def hasGlobalErrors: Boolean = realForm.hasGlobalErrors
override def hashCode: Int = realForm.hashCode
def mapping: Mapping[F] = realForm.mapping
def value: Option[T] = realForm.value
}
Now instead of your templates being
#(_form: Form[CartOrder])
which won't work because of invariance, you can use
#(_form: FormView[CartOrder])
and you can simply pass in any Form[T] where T is a subtype of CartOrder like
#user.nested(_form)
the implicits will handle the conversion from Form to FormView
A complete example can be found at: https://github.com/thatsmydoing/formtest

Answer 2

Ok, the dilly-o follows thusly (chime in if you have a better way):
play.api.data.Form[T] is invariant, so no dice passing in the super type of Conference (i.e. CartOrder) to the User form. In other words, this blows up:
// user.scala.html
#(_form: Form[CartOrder])
Basically you have to pass in an instance that itself is Form mappable.
To workaround the template layer fun house, I have implemented the following hack:
case class CartModel(user: User, payment: Payment)
EDIT
gets better, added in a bind helper to CartForm mapper below, which makes for clean syntax in views
object CartForm {
import play.api.data.Forms._
val form =
Form( mapping(
'user -> UserForm.mapper,
'payment -> PaymentForm.mapper )(CartModel.apply)(CartModel.unapply) )
// hey, generics!
def bind[T <: Form[_ <: CartContract]](t: T) =
t.value map{x=> form.fill( CartModel(x.user, x.payment) )} getOrElse form
}
and then in the Conference parent form, pull in User form fields like so:
#user.nested( CartForm.bind(_form) )
and the User form then receives:
#(_form: Form[CartModel])
A good deal of boilerplate is eliminated with nested forms in general, so overall, progress. Would be great not to rely on the intermediary Form mapper, but this is as good as I can come up with for now...

Answer 3

Guess you want
#(_form: Form[_ <: CartOrder])
instead of suggested
#[T <: CartOrder](_form: Form[T])