From 01e40df22aa793dbf4072a49b1834dc08d94756e Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Fri, 12 Apr 2019 17:06:04 +0200
Subject: [PATCH 01/21] Use more specific type in implicit macro search

---
 .../src/main/scala/io/udash/macros/PropertyMacros.scala   | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/macros/src/main/scala/io/udash/macros/PropertyMacros.scala b/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
index 816d3c191..b45e35896 100644
--- a/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
+++ b/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
@@ -12,6 +12,7 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
   val IsModelPropertyTemplateCls = tq"$Package.IsModelPropertyTemplate"
 
   val PropertyCreatorCls = tq"$Package.PropertyCreator"
+  val SeqPropertyCreatorCls = tq"$Package.SeqPropertyCreator"
   val SinglePropertyCreatorCls = tq"$Package.SinglePropertyCreator"
   val PropertyCreatorCompanion = q"$Package.PropertyCreator"
   val ModelPropertyCreatorCls = tq"$Package.ModelPropertyCreator"
@@ -217,7 +218,12 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
         members.map {
           case (name, returnTpe) =>
             val reifiedReturnTpe = reifySeqTpe(returnTpe)
-            q"""properties(${name.toString}) = implicitly[$PropertyCreatorCls[$reifiedReturnTpe]].newProperty(null.asInstanceOf[$reifiedReturnTpe], this)"""
+            val reifiedCreatorTpe = getType(
+              if (tpe <:< SeqTpe) tq"$SeqPropertyCreatorCls[${tpe.typeArgs.head}]"
+              else tq"$PropertyCreatorCls[$reifiedReturnTpe]"
+            )
+
+            q"""properties(${name.toString}) = implicitly[$reifiedCreatorTpe].newProperty(null.asInstanceOf[$reifiedReturnTpe], this)"""
         }
       }
           }

From c82fd029fbe54d6a4164fdb9d3676361d73f64e1 Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Fri, 12 Apr 2019 17:26:20 +0200
Subject: [PATCH 02/21] More specific requirement for SeqProperty factories

---
 .../main/scala/io/udash/properties/seq/SeqProperty.scala    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/main/scala/io/udash/properties/seq/SeqProperty.scala b/core/src/main/scala/io/udash/properties/seq/SeqProperty.scala
index 6c0f4b006..e54711c7e 100644
--- a/core/src/main/scala/io/udash/properties/seq/SeqProperty.scala
+++ b/core/src/main/scala/io/udash/properties/seq/SeqProperty.scala
@@ -5,15 +5,15 @@ import io.udash.properties.single.{AbstractProperty, CastableProperty, Property}
 
 object SeqProperty {
   /** Creates a blank DirectSeqProperty[T]. */
-  def blank[T : PropertyCreator](implicit pc: PropertyCreator[Seq[T]], blank: Blank[Seq[T]]): SeqProperty[T, CastableProperty[T]] =
+  def blank[T: SeqPropertyCreator](implicit blank: Blank[Seq[T]]): SeqProperty[T, CastableProperty[T]] =
     Property.blank[Seq[T]].asSeq[T]
 
   /** Creates a DirectSeqProperty[T] with initial value. */
-  def apply[T : PropertyCreator](item: T, more: T*)(implicit pc: PropertyCreator[Seq[T]]): SeqProperty[T, CastableProperty[T]] =
+  def apply[T: SeqPropertyCreator](item: T, more: T*): SeqProperty[T, CastableProperty[T]] =
     apply(item +: more)
 
   /** Creates a DirectSeqProperty[T] with initial value. */
-  def apply[T : PropertyCreator](init: Seq[T])(implicit pc: PropertyCreator[Seq[T]]): SeqProperty[T, CastableProperty[T]] =
+  def apply[T: SeqPropertyCreator](init: Seq[T]): SeqProperty[T, CastableProperty[T]] =
     Property[Seq[T]](init).asSeq[T]
 }
 

From b26a3b38f79ed7a24748994bf9a7e9e547862d6e Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Fri, 12 Apr 2019 17:36:59 +0200
Subject: [PATCH 03/21] Test harness

---
 build.sbt                                       |  1 +
 .../udash/properties/PropertyCreatorTest.scala  | 17 +++++++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/build.sbt b/build.sbt
index 033fdeccb..c28fc4b11 100644
--- a/build.sbt
+++ b/build.sbt
@@ -37,6 +37,7 @@ val commonSettings = Seq(
     "-Xfuture",
     "-Xfatal-warnings",
     "-Xlint:_,-missing-interpolator",
+    "-Xlog-implicits",
   ),
   scalacOptions ++= {
     if (scalaBinaryVersion.value == "2.12") Seq(
diff --git a/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala b/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
index 09939f16b..6b8e80562 100644
--- a/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
@@ -6,6 +6,8 @@ class PropertyCreatorTest extends UdashCoreTest {
   // DO NOT REMOVE THIS IMPORT!
   import io.udash.properties.Properties._
 
+  val x = SeqProperty.apply[Nothing](Seq.empty)
+
   "PropertyCreator" should {
     "create Property for basic types (and handle init value)" in {
       """val p = Property.blank[String]""".stripMargin should compile
@@ -1013,5 +1015,20 @@ class PropertyCreatorTest extends UdashCoreTest {
         |println(t.subSeq(_.y).get)
         |""".stripMargin should compile
     }
+
+
+    //    "fail implicit search for SeqPropertyCreator[Nothing]" in {
+    //      "SeqProperty.apply[Nothing](Seq.empty)" shouldNot compile
+    //    }
+    //    case class Chunk[T](
+    //      data: Property[T] = Property.blank
+    //    )
+    //    case class Chunk[T](
+    //      data: SeqProperty[T] = SeqProperty.blank
+    //    )
+    //    //https://github.com/UdashFramework/udash-core/issues/271
+    //    "work with inferred SeqProperty factory type params" in {
+    //
+    //    }
   }
 }

From 9b2722319b223e13a8460fd66d002fe45695c6df Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Mon, 15 Apr 2019 09:41:52 +0200
Subject: [PATCH 04/21] Cleanup implicit provider traits

---
 .../io/udash/properties/PropertyCreator.scala |  5 +-
 .../properties/PropertyCreatorImplicits.scala | 57 -------------------
 .../properties/TuplePropertyCreators.scala    | 53 +++++++++++++++++
 3 files changed, 57 insertions(+), 58 deletions(-)
 delete mode 100644 core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
 create mode 100644 core/src/main/scala/io/udash/properties/TuplePropertyCreators.scala

diff --git a/core/src/main/scala/io/udash/properties/PropertyCreator.scala b/core/src/main/scala/io/udash/properties/PropertyCreator.scala
index be15aa350..d5cd7ed60 100644
--- a/core/src/main/scala/io/udash/properties/PropertyCreator.scala
+++ b/core/src/main/scala/io/udash/properties/PropertyCreator.scala
@@ -18,7 +18,7 @@ trait PropertyCreator[T] {
   protected def create(prt: ReadableProperty[_]): CastableProperty[T]
 }
 
-object PropertyCreator extends PropertyCreatorImplicits {
+object PropertyCreator extends TuplePropertyCreators with PropertyCreatorImplicitsLow {
   /** Marker trait for macro-materialized ModelProperty instances. Serves to prioritize macro-generated instance over other implicits. */
   trait MacroGeneratedPropertyCreator
 
@@ -37,6 +37,9 @@ class SeqPropertyCreator[T : PropertyCreator] extends PropertyCreator[Seq[T]] {
   protected def create(prt: ReadableProperty[_]): CastableProperty[Seq[T]] =
     new DirectSeqPropertyImpl[T](prt, PropertyCreator.newID())
 }
+object SeqPropertyCreator {
+  implicit def materializeSeq[T: PropertyCreator]: SeqPropertyCreator[T] = new SeqPropertyCreator[T]
+}
 
 @implicitNotFound("Class ${T} cannot be used as ModelProperty template. Add `extends HasModelPropertyCreator[${T}]` to companion object of ${T}.")
 abstract class ModelPropertyCreator[T] extends PropertyCreator[T]
diff --git a/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala b/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
deleted file mode 100644
index a5c9e6d56..000000000
--- a/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
+++ /dev/null
@@ -1,57 +0,0 @@
-package io.udash.properties
-
-trait PropertyCreatorImplicitsLow {
-  implicit def materializeSingle[T]: PropertyCreator[T] =
-    macro io.udash.macros.PropertyMacros.reifyPropertyCreator[T]
-}
-
-trait PropertyCreatorImplicits extends PropertyCreatorImplicitsLow {
-  implicit def materializeSeq[T : PropertyCreator]: SeqPropertyCreator[T] =
-    new SeqPropertyCreator[T]
-
-  private type PC[T] = PropertyCreator[T]
-  implicit def tuple1[T : PC]: ModelPropertyCreator[Tuple1[T]] =
-    ModelPropertyCreator.materialize[Tuple1[T]]
-  implicit def tuple2[T1 : PC, T2 : PC]: ModelPropertyCreator[(T1, T2)] =
-    ModelPropertyCreator.materialize[(T1, T2)]
-  implicit def tuple3[T1 : PC, T2 : PC, T3 : PC]: ModelPropertyCreator[(T1, T2, T3)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3)]
-  implicit def tuple4[T1 : PC, T2 : PC, T3 : PC, T4 : PC]: ModelPropertyCreator[(T1, T2, T3, T4)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4)]
-  implicit def tuple5[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5)]
-  implicit def tuple6[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6)]
-  implicit def tuple7[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7)]
-  implicit def tuple8[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8)]
-  implicit def tuple9[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9)]
-  implicit def tuple10[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)]
-  implicit def tuple11[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)]
-  implicit def tuple12[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC, T12 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)]
-  implicit def tuple13[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC, T12 : PC, T13 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)]
-  implicit def tuple14[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC, T12 : PC, T13 : PC, T14 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)]
-  implicit def tuple15[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC, T12 : PC, T13 : PC, T14 : PC, T15 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)]
-  implicit def tuple16[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC, T12 : PC, T13 : PC, T14 : PC, T15 : PC, T16 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)]
-  implicit def tuple17[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC, T12 : PC, T13 : PC, T14 : PC, T15 : PC, T16 : PC, T17 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)]
-  implicit def tuple18[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC, T12 : PC, T13 : PC, T14 : PC, T15 : PC, T16 : PC, T17 : PC, T18 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)]
-  implicit def tuple19[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC, T12 : PC, T13 : PC, T14 : PC, T15 : PC, T16 : PC, T17 : PC, T18 : PC, T19 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)]
-  implicit def tuple20[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC, T12 : PC, T13 : PC, T14 : PC, T15 : PC, T16 : PC, T17 : PC, T18 : PC, T19 : PC, T20 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)]
-  implicit def tuple21[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC, T12 : PC, T13 : PC, T14 : PC, T15 : PC, T16 : PC, T17 : PC, T18 : PC, T19 : PC, T20 : PC, T21 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)]
-  implicit def tuple22[T1 : PC, T2 : PC, T3 : PC, T4 : PC, T5 : PC, T6 : PC, T7 : PC, T8 : PC, T9 : PC, T10 : PC, T11 : PC, T12 : PC, T13 : PC, T14 : PC, T15 : PC, T16 : PC, T17 : PC, T18 : PC, T19 : PC, T20 : PC, T21 : PC, T22 : PC]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)]
-}
\ No newline at end of file
diff --git a/core/src/main/scala/io/udash/properties/TuplePropertyCreators.scala b/core/src/main/scala/io/udash/properties/TuplePropertyCreators.scala
new file mode 100644
index 000000000..26e552f59
--- /dev/null
+++ b/core/src/main/scala/io/udash/properties/TuplePropertyCreators.scala
@@ -0,0 +1,53 @@
+package io.udash.properties
+
+trait PropertyCreatorImplicitsLow { this: PropertyCreator.type =>
+  implicit def materializeSingle[T]: PropertyCreator[T] = macro io.udash.macros.PropertyMacros.reifyPropertyCreator[T]
+}
+
+trait TuplePropertyCreators { this: PropertyCreator.type =>
+
+  implicit def tuple1[T: PropertyCreator]: ModelPropertyCreator[Tuple1[T]] =
+    ModelPropertyCreator.materialize[Tuple1[T]]
+  implicit def tuple2[T1: PropertyCreator, T2: PropertyCreator]: ModelPropertyCreator[(T1, T2)] =
+    ModelPropertyCreator.materialize[(T1, T2)]
+  implicit def tuple3[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3)]
+  implicit def tuple4[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4)]
+  implicit def tuple5[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5)]
+  implicit def tuple6[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6)]
+  implicit def tuple7[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7)]
+  implicit def tuple8[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8)]
+  implicit def tuple9[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9)]
+  implicit def tuple10[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)]
+  implicit def tuple11[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)]
+  implicit def tuple12[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)]
+  implicit def tuple13[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)]
+  implicit def tuple14[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)]
+  implicit def tuple15[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)]
+  implicit def tuple16[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)]
+  implicit def tuple17[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)]
+  implicit def tuple18[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator, T18: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)]
+  implicit def tuple19[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator, T18: PropertyCreator, T19: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)]
+  implicit def tuple20[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator, T18: PropertyCreator, T19: PropertyCreator, T20: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)]
+  implicit def tuple21[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator, T18: PropertyCreator, T19: PropertyCreator, T20: PropertyCreator, T21: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)]
+  implicit def tuple22[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator, T18: PropertyCreator, T19: PropertyCreator, T20: PropertyCreator, T21: PropertyCreator, T22: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)] =
+    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)]
+}
\ No newline at end of file

From a3dcdb215e1543cd9cdc59a5c2271f69aeec3c64 Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Mon, 15 Apr 2019 14:55:38 +0200
Subject: [PATCH 05/21] Add Properties to always used imports

---
 .idea/codeStyles/Project.xml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index d6f6d5d23..a4412b8e0 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -4,6 +4,11 @@
       <option name="RIGHT_MARGIN" value="-1" />
     </MarkdownNavigatorCodeStyleSettings>
     <ScalaCodeStyleSettings>
+      <option name="alwaysUsedImports">
+        <array>
+          <option value="io.udash.properties.Properties._" />
+        </array>
+      </option>
       <option name="PLACE_SELF_TYPE_ON_NEW_LINE" value="false" />
       <option name="BLANK_LINES_AROUND_METHOD_IN_INNER_SCOPES" value="0" />
     </ScalaCodeStyleSettings>

From 96019efaed50f15f31595bfb895e5c49abbc1920 Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Mon, 15 Apr 2019 16:00:18 +0200
Subject: [PATCH 06/21] Remove null default blank & typeclass cleanups

---
 .../scala/io/udash/properties/Blank.scala     | 97 +++++++++----------
 .../io/udash/properties/PropertyCreator.scala |  8 +-
 ...s.scala => PropertyCreatorImplicits.scala} |  3 +-
 .../io/udash/properties/seq/SeqProperty.scala |  8 +-
 .../properties/PropertyCreatorTest.scala      | 18 ++--
 5 files changed, 64 insertions(+), 70 deletions(-)
 rename core/src/main/scala/io/udash/properties/{TuplePropertyCreators.scala => PropertyCreatorImplicits.scala} (97%)

diff --git a/core/src/main/scala/io/udash/properties/Blank.scala b/core/src/main/scala/io/udash/properties/Blank.scala
index f85c10858..c2a60a0a5 100644
--- a/core/src/main/scala/io/udash/properties/Blank.scala
+++ b/core/src/main/scala/io/udash/properties/Blank.scala
@@ -14,6 +14,8 @@ trait Blank[A] {
 }
 
 object Blank extends LowPrioImplicits {
+  def apply[A](implicit ev: Blank[A]): Blank[A] = ev
+  
   case class Simple[A](value: A) extends AbstractCase with Blank[A]
   case class Factory[A](factory: () => A) extends AbstractCase with Blank[A] {
     override def value: A = factory()
@@ -38,54 +40,49 @@ object Blank extends LowPrioImplicits {
   implicit def traversable[T, A[_] <: Traversable[_]](implicit ev: CanBuildFrom[Nothing, T, A[T]]): Blank[A[T]] = Simple(Seq.empty[T].to[A])
 }
 
-trait LowPrioImplicits {
-  private val nullBlank = Blank.Simple(null)
-  @deprecated("Setting Property value to `null` is highly discouraged. Please, define implicit `Blank` for your type.", "0.7.0")
-  implicit def fallbackNull[A]: Blank[A] = nullBlank.asInstanceOf[Blank[A]]
-
-  private type D[T] = Blank[T]
-  implicit def tuple1[T : D]: D[Tuple1[T]] =
-    Blank.Simple(Tuple1(implicitly[D[T]].value))
-  implicit def tuple2[T1 : D, T2 : D]: D[(T1, T2)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value))
-  implicit def tuple3[T1 : D, T2 : D, T3 : D]: D[(T1, T2, T3)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value))
-  implicit def tuple4[T1 : D, T2 : D, T3 : D, T4 : D]: D[(T1, T2, T3, T4)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value))
-  implicit def tuple5[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D]: D[(T1, T2, T3, T4, T5)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value))
-  implicit def tuple6[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D]: D[(T1, T2, T3, T4, T5, T6)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value))
-  implicit def tuple7[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D]: D[(T1, T2, T3, T4, T5, T6, T7)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value))
-  implicit def tuple8[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value))
-  implicit def tuple9[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value))
-  implicit def tuple10[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value))
-  implicit def tuple11[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value))
-  implicit def tuple12[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D, T12 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value, implicitly[D[T12]].value))
-  implicit def tuple13[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D, T12 : D, T13 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value, implicitly[D[T12]].value, implicitly[D[T13]].value))
-  implicit def tuple14[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D, T12 : D, T13 : D, T14 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value, implicitly[D[T12]].value, implicitly[D[T13]].value, implicitly[D[T14]].value))
-  implicit def tuple15[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D, T12 : D, T13 : D, T14 : D, T15 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value, implicitly[D[T12]].value, implicitly[D[T13]].value, implicitly[D[T14]].value, implicitly[D[T15]].value))
-  implicit def tuple16[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D, T12 : D, T13 : D, T14 : D, T15 : D, T16 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value, implicitly[D[T12]].value, implicitly[D[T13]].value, implicitly[D[T14]].value, implicitly[D[T15]].value, implicitly[D[T16]].value))
-  implicit def tuple17[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D, T12 : D, T13 : D, T14 : D, T15 : D, T16 : D, T17 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value, implicitly[D[T12]].value, implicitly[D[T13]].value, implicitly[D[T14]].value, implicitly[D[T15]].value, implicitly[D[T16]].value, implicitly[D[T17]].value))
-  implicit def tuple18[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D, T12 : D, T13 : D, T14 : D, T15 : D, T16 : D, T17 : D, T18 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value, implicitly[D[T12]].value, implicitly[D[T13]].value, implicitly[D[T14]].value, implicitly[D[T15]].value, implicitly[D[T16]].value, implicitly[D[T17]].value, implicitly[D[T18]].value))
-  implicit def tuple19[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D, T12 : D, T13 : D, T14 : D, T15 : D, T16 : D, T17 : D, T18 : D, T19 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value, implicitly[D[T12]].value, implicitly[D[T13]].value, implicitly[D[T14]].value, implicitly[D[T15]].value, implicitly[D[T16]].value, implicitly[D[T17]].value, implicitly[D[T18]].value, implicitly[D[T19]].value))
-  implicit def tuple20[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D, T12 : D, T13 : D, T14 : D, T15 : D, T16 : D, T17 : D, T18 : D, T19 : D, T20 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value, implicitly[D[T12]].value, implicitly[D[T13]].value, implicitly[D[T14]].value, implicitly[D[T15]].value, implicitly[D[T16]].value, implicitly[D[T17]].value, implicitly[D[T18]].value, implicitly[D[T19]].value, implicitly[D[T20]].value))
-  implicit def tuple21[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D, T12 : D, T13 : D, T14 : D, T15 : D, T16 : D, T17 : D, T18 : D, T19 : D, T20 : D, T21 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value, implicitly[D[T12]].value, implicitly[D[T13]].value, implicitly[D[T14]].value, implicitly[D[T15]].value, implicitly[D[T16]].value, implicitly[D[T17]].value, implicitly[D[T18]].value, implicitly[D[T19]].value, implicitly[D[T20]].value, implicitly[D[T21]].value))
-  implicit def tuple22[T1 : D, T2 : D, T3 : D, T4 : D, T5 : D, T6 : D, T7 : D, T8 : D, T9 : D, T10 : D, T11 : D, T12 : D, T13 : D, T14 : D, T15 : D, T16 : D, T17 : D, T18 : D, T19 : D, T20 : D, T21 : D, T22 : D]: D[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)] =
-    Blank.Simple((implicitly[D[T1]].value, implicitly[D[T2]].value, implicitly[D[T3]].value, implicitly[D[T4]].value, implicitly[D[T5]].value, implicitly[D[T6]].value, implicitly[D[T7]].value, implicitly[D[T8]].value, implicitly[D[T9]].value, implicitly[D[T10]].value, implicitly[D[T11]].value, implicitly[D[T12]].value, implicitly[D[T13]].value, implicitly[D[T14]].value, implicitly[D[T15]].value, implicitly[D[T16]].value, implicitly[D[T17]].value, implicitly[D[T18]].value, implicitly[D[T19]].value, implicitly[D[T20]].value, implicitly[D[T21]].value, implicitly[D[T22]].value))
+trait LowPrioImplicits { this: Blank.type =>
+  implicit def tuple1[T: Blank]: Blank[Tuple1[T]] =
+    Blank.Simple(Tuple1(Blank[T].value))
+  implicit def tuple2[T1: Blank, T2: Blank]: Blank[(T1, T2)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value))
+  implicit def tuple3[T1: Blank, T2: Blank, T3: Blank]: Blank[(T1, T2, T3)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value))
+  implicit def tuple4[T1: Blank, T2: Blank, T3: Blank, T4: Blank]: Blank[(T1, T2, T3, T4)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value))
+  implicit def tuple5[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank]: Blank[(T1, T2, T3, T4, T5)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value))
+  implicit def tuple6[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank]: Blank[(T1, T2, T3, T4, T5, T6)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value))
+  implicit def tuple7[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value))
+  implicit def tuple8[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value))
+  implicit def tuple9[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value))
+  implicit def tuple10[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value))
+  implicit def tuple11[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value))
+  implicit def tuple12[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value))
+  implicit def tuple13[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value))
+  implicit def tuple14[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value))
+  implicit def tuple15[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value))
+  implicit def tuple16[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value))
+  implicit def tuple17[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value))
+  implicit def tuple18[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank, T18: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value, Blank[T18].value))
+  implicit def tuple19[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank, T18: Blank, T19: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value, Blank[T18].value, Blank[T19].value))
+  implicit def tuple20[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank, T18: Blank, T19: Blank, T20: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value, Blank[T18].value, Blank[T19].value, Blank[T20].value))
+  implicit def tuple21[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank, T18: Blank, T19: Blank, T20: Blank, T21: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value, Blank[T18].value, Blank[T19].value, Blank[T20].value, Blank[T21].value))
+  implicit def tuple22[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank, T18: Blank, T19: Blank, T20: Blank, T21: Blank, T22: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)] =
+    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value, Blank[T18].value, Blank[T19].value, Blank[T20].value, Blank[T21].value, Blank[T22].value))
 }
\ No newline at end of file
diff --git a/core/src/main/scala/io/udash/properties/PropertyCreator.scala b/core/src/main/scala/io/udash/properties/PropertyCreator.scala
index d5cd7ed60..27dc46c4a 100644
--- a/core/src/main/scala/io/udash/properties/PropertyCreator.scala
+++ b/core/src/main/scala/io/udash/properties/PropertyCreator.scala
@@ -18,12 +18,11 @@ trait PropertyCreator[T] {
   protected def create(prt: ReadableProperty[_]): CastableProperty[T]
 }
 
-object PropertyCreator extends TuplePropertyCreators with PropertyCreatorImplicitsLow {
+object PropertyCreator extends PropertyCreatorImplicits {
   /** Marker trait for macro-materialized ModelProperty instances. Serves to prioritize macro-generated instance over other implicits. */
   trait MacroGeneratedPropertyCreator
 
-  def propertyCreator[T: PropertyCreator]: PropertyCreator[T] =
-    implicitly[PropertyCreator[T]]
+  def apply[T](implicit ev: PropertyCreator[T]): PropertyCreator[T] = ev
 
   def newID(): PropertyId = PropertyIdGenerator.next()
 }
@@ -37,9 +36,6 @@ class SeqPropertyCreator[T : PropertyCreator] extends PropertyCreator[Seq[T]] {
   protected def create(prt: ReadableProperty[_]): CastableProperty[Seq[T]] =
     new DirectSeqPropertyImpl[T](prt, PropertyCreator.newID())
 }
-object SeqPropertyCreator {
-  implicit def materializeSeq[T: PropertyCreator]: SeqPropertyCreator[T] = new SeqPropertyCreator[T]
-}
 
 @implicitNotFound("Class ${T} cannot be used as ModelProperty template. Add `extends HasModelPropertyCreator[${T}]` to companion object of ${T}.")
 abstract class ModelPropertyCreator[T] extends PropertyCreator[T]
diff --git a/core/src/main/scala/io/udash/properties/TuplePropertyCreators.scala b/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
similarity index 97%
rename from core/src/main/scala/io/udash/properties/TuplePropertyCreators.scala
rename to core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
index 26e552f59..60c95bfb5 100644
--- a/core/src/main/scala/io/udash/properties/TuplePropertyCreators.scala
+++ b/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
@@ -4,7 +4,8 @@ trait PropertyCreatorImplicitsLow { this: PropertyCreator.type =>
   implicit def materializeSingle[T]: PropertyCreator[T] = macro io.udash.macros.PropertyMacros.reifyPropertyCreator[T]
 }
 
-trait TuplePropertyCreators { this: PropertyCreator.type =>
+trait PropertyCreatorImplicits extends PropertyCreatorImplicitsLow { this: PropertyCreator.type =>
+  implicit def materializeSeq[T: PropertyCreator]: SeqPropertyCreator[T] = new SeqPropertyCreator[T]
 
   implicit def tuple1[T: PropertyCreator]: ModelPropertyCreator[Tuple1[T]] =
     ModelPropertyCreator.materialize[Tuple1[T]]
diff --git a/core/src/main/scala/io/udash/properties/seq/SeqProperty.scala b/core/src/main/scala/io/udash/properties/seq/SeqProperty.scala
index e54711c7e..9be87b3ae 100644
--- a/core/src/main/scala/io/udash/properties/seq/SeqProperty.scala
+++ b/core/src/main/scala/io/udash/properties/seq/SeqProperty.scala
@@ -5,16 +5,16 @@ import io.udash.properties.single.{AbstractProperty, CastableProperty, Property}
 
 object SeqProperty {
   /** Creates a blank DirectSeqProperty[T]. */
-  def blank[T: SeqPropertyCreator](implicit blank: Blank[Seq[T]]): SeqProperty[T, CastableProperty[T]] =
-    Property.blank[Seq[T]].asSeq[T]
+  def blank[T](implicit pc: SeqPropertyCreator[T], blank: Blank[Seq[T]]): SeqProperty[T, CastableProperty[T]] =
+    Property.blank[Seq[T]](pc, blank).asSeq[T]
 
   /** Creates a DirectSeqProperty[T] with initial value. */
   def apply[T: SeqPropertyCreator](item: T, more: T*): SeqProperty[T, CastableProperty[T]] =
     apply(item +: more)
 
   /** Creates a DirectSeqProperty[T] with initial value. */
-  def apply[T: SeqPropertyCreator](init: Seq[T]): SeqProperty[T, CastableProperty[T]] =
-    Property[Seq[T]](init).asSeq[T]
+  def apply[T](init: Seq[T])(implicit pc: SeqPropertyCreator[T]): SeqProperty[T, CastableProperty[T]] =
+    Property[Seq[T]](init)(pc).asSeq[T]
 }
 
 trait SeqProperty[A, +ElemType <: Property[A]] extends ReadableSeqProperty[A, ElemType] with Property[Seq[A]] {
diff --git a/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala b/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
index 6b8e80562..46d66f6d5 100644
--- a/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
@@ -6,7 +6,7 @@ class PropertyCreatorTest extends UdashCoreTest {
   // DO NOT REMOVE THIS IMPORT!
   import io.udash.properties.Properties._
 
-  val x = SeqProperty.apply[Nothing](Seq.empty)
+  //val x = SeqProperty.apply[Nothing](Seq.empty)
 
   "PropertyCreator" should {
     "create Property for basic types (and handle init value)" in {
@@ -940,38 +940,38 @@ class PropertyCreatorTest extends UdashCoreTest {
         |  def x: T
         |}
         |object Test {
-        |  implicit val pc: PropertyCreator[T] = PropertyCreator.propertyCreator[T]
+        |  implicit val pc: PropertyCreator[T] = PropertyCreator[T]
         |}""".stripMargin should compile
     }
 
     "handle explicit creation of property creator for recursive model (case class)" in {
       """case class T(a: Int, t: T)
         |object Test {
-        |  implicit val pc: PropertyCreator[T] = PropertyCreator.propertyCreator[T]
+        |  implicit val pc: PropertyCreator[T] = PropertyCreator[T]
         |}""".stripMargin should compile
     }
 
     "handle explicit creation of property creator for recursive model (case class with Seq)" in {
       """case class T(a: Int, t: T, st: Seq[T])
         |object Test {
-        |  implicit val pc: PropertyCreator[T] = PropertyCreator.propertyCreator[T]
-        |  implicit val pcS: PropertyCreator[Seq[T]] = PropertyCreator.propertyCreator[Seq[T]]
+        |  implicit val pc: PropertyCreator[T] = PropertyCreator[T]
+        |  implicit val pcS: PropertyCreator[Seq[T]] = PropertyCreator[Seq[T]]
         |}""".stripMargin should compile
     }
 
     "handle explicit creation of property creator for recursive model (case class with Vector, PropertyCreator[Seq[T]])" in {
       """case class T(a: Int, t: T, st: Vector[T])
         |object Test {
-        |  implicit val pc: PropertyCreator[T] = PropertyCreator.propertyCreator[T]
-        |  implicit val pcS: PropertyCreator[Seq[T]] = PropertyCreator.propertyCreator[Seq[T]]
+        |  implicit val pc: PropertyCreator[T] = PropertyCreator[T]
+        |  implicit val pcS: PropertyCreator[Seq[T]] = PropertyCreator[Seq[T]]
         |}""".stripMargin should compile
     }
 
     "handle explicit creation of property creator for recursive model (case class with Vector, PropertyCreator[Vector[T]])" in {
       """case class T(a: Int, t: T, st: Vector[T])
         |object Test {
-        |  implicit val pc: PropertyCreator[T] = PropertyCreator.propertyCreator[T]
-        |  implicit val pcS: PropertyCreator[Vector[T]] = PropertyCreator.propertyCreator[Vector[T]]
+        |  implicit val pc: PropertyCreator[T] = PropertyCreator[T]
+        |  implicit val pcS: PropertyCreator[Vector[T]] = PropertyCreator[Vector[T]]
         |}""".stripMargin should compile
     }
 

From c7c3bb4a44e8f3e09fb2db122c4d6f90a28cb4f5 Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Mon, 15 Apr 2019 16:01:10 +0200
Subject: [PATCH 07/21] Remove redundant macro code for single properties

---
 .../udash/properties/PropertyCreatorImplicits.scala   |  4 ++--
 .../main/scala/io/udash/macros/PropertyMacros.scala   | 11 -----------
 2 files changed, 2 insertions(+), 13 deletions(-)

diff --git a/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala b/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
index 60c95bfb5..5d7a5076b 100644
--- a/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
+++ b/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
@@ -1,7 +1,7 @@
 package io.udash.properties
 
-trait PropertyCreatorImplicitsLow { this: PropertyCreator.type =>
-  implicit def materializeSingle[T]: PropertyCreator[T] = macro io.udash.macros.PropertyMacros.reifyPropertyCreator[T]
+trait PropertyCreatorImplicitsLow { this: PropertyCreatorImplicits =>
+  implicit def materializeSingle[T]: PropertyCreator[T] = new SinglePropertyCreator[T]
 }
 
 trait PropertyCreatorImplicits extends PropertyCreatorImplicitsLow { this: PropertyCreator.type =>
diff --git a/macros/src/main/scala/io/udash/macros/PropertyMacros.scala b/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
index b45e35896..35923c9ae 100644
--- a/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
+++ b/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
@@ -396,17 +396,6 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
     """
   }
 
-  def reifyPropertyCreator[A: c.WeakTypeTag]: c.Tree = {
-    val tpe = weakTypeOf[A].dealias
-    if (!tpe.typeSymbol.isClass) {
-      c.abort(c.enclosingPosition, s"Implicit PropertyCreator[$tpe] not found.")
-    } else if (tpe =:= SeqTpe) {
-      c.abort(c.enclosingPosition,
-        s"Implicit PropertyCreator[Seq[_]] not found. If you use Seq[_] in your model, replace it with Seq[Any]."
-      )
-    } else q"new $SinglePropertyCreatorCls[$tpe]"
-  }
-
   def checkModelPropertyTemplate[A: c.WeakTypeTag]: c.Tree = {
     val tpe = weakTypeOf[A]
     if (doesMeetTraitModelRequirements(tpe) || doesMeetClassModelRequirements(tpe)) q"new $IsModelPropertyTemplateCls[$tpe]"

From e889cef2301dbdc661b5274603034effeba2f15e Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Mon, 15 Apr 2019 19:34:21 +0200
Subject: [PATCH 08/21] Avoid implicit search loop on PropertyCreators for
 tuples

---
 .../properties/PropertyCreatorImplicits.scala | 45 -------------------
 .../properties/PropertyCreatorTest.scala      | 21 ---------
 .../io/udash/properties/PropertyTest.scala    | 21 +++++----
 .../properties/ReadableWrapperTest.scala      |  2 +-
 .../BootstrappingIntroView.scala              |  1 +
 5 files changed, 14 insertions(+), 76 deletions(-)

diff --git a/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala b/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
index 5d7a5076b..27ce54898 100644
--- a/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
+++ b/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
@@ -6,49 +6,4 @@ trait PropertyCreatorImplicitsLow { this: PropertyCreatorImplicits =>
 
 trait PropertyCreatorImplicits extends PropertyCreatorImplicitsLow { this: PropertyCreator.type =>
   implicit def materializeSeq[T: PropertyCreator]: SeqPropertyCreator[T] = new SeqPropertyCreator[T]
-
-  implicit def tuple1[T: PropertyCreator]: ModelPropertyCreator[Tuple1[T]] =
-    ModelPropertyCreator.materialize[Tuple1[T]]
-  implicit def tuple2[T1: PropertyCreator, T2: PropertyCreator]: ModelPropertyCreator[(T1, T2)] =
-    ModelPropertyCreator.materialize[(T1, T2)]
-  implicit def tuple3[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3)]
-  implicit def tuple4[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4)]
-  implicit def tuple5[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5)]
-  implicit def tuple6[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6)]
-  implicit def tuple7[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7)]
-  implicit def tuple8[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8)]
-  implicit def tuple9[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9)]
-  implicit def tuple10[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)]
-  implicit def tuple11[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)]
-  implicit def tuple12[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)]
-  implicit def tuple13[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)]
-  implicit def tuple14[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)]
-  implicit def tuple15[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)]
-  implicit def tuple16[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)]
-  implicit def tuple17[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)]
-  implicit def tuple18[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator, T18: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)]
-  implicit def tuple19[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator, T18: PropertyCreator, T19: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)]
-  implicit def tuple20[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator, T18: PropertyCreator, T19: PropertyCreator, T20: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)]
-  implicit def tuple21[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator, T18: PropertyCreator, T19: PropertyCreator, T20: PropertyCreator, T21: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)]
-  implicit def tuple22[T1: PropertyCreator, T2: PropertyCreator, T3: PropertyCreator, T4: PropertyCreator, T5: PropertyCreator, T6: PropertyCreator, T7: PropertyCreator, T8: PropertyCreator, T9: PropertyCreator, T10: PropertyCreator, T11: PropertyCreator, T12: PropertyCreator, T13: PropertyCreator, T14: PropertyCreator, T15: PropertyCreator, T16: PropertyCreator, T17: PropertyCreator, T18: PropertyCreator, T19: PropertyCreator, T20: PropertyCreator, T21: PropertyCreator, T22: PropertyCreator]: ModelPropertyCreator[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)] =
-    ModelPropertyCreator.materialize[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)]
 }
\ No newline at end of file
diff --git a/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala b/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
index 46d66f6d5..7c60bf0b0 100644
--- a/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
@@ -434,27 +434,6 @@ class PropertyCreatorTest extends UdashCoreTest {
         |val test = p.subSeq(_.x)""".stripMargin shouldNot compile
     }
 
-    "create ModelProperty for tuples" in {
-      """val p = ModelProperty(Tuple1("String"))""".stripMargin should compile
-      """val p = ModelProperty(("String", 25))""".stripMargin should compile
-      """val p = ModelProperty(("String", 25, 3))""".stripMargin should compile
-      """val p = ModelProperty(("String", 25, 3, 4))""".stripMargin should compile
-      """val p = ModelProperty(("String", 25, 3, 4, 5))""".stripMargin should compile
-      """val p = ModelProperty(("String", 25, 3, 4, 5, 6))""".stripMargin should compile
-
-      """val p = ModelProperty(("String", 25, 3))
-        |val s1 = p.subProp(_._1)
-        |val s2 = p.subProp(_._2)
-        |val s3 = p.subProp(_._3)
-      """.stripMargin should compile
-
-      """val p = ModelProperty(("String", 25, 3))
-        |val s1 = p.subProp(_._1)
-        |val s2 = p.subProp(_._2)
-        |val s3 = p.subProp(_._4)
-      """.stripMargin shouldNot compile
-    }
-
     "not create ModelProperty for anything other than trait or simple case class" in {
       """val p = Property[Int](null.asInstanceOf[Int]).asModel""".stripMargin shouldNot compile
 
diff --git a/core/src/test/scala/io/udash/properties/PropertyTest.scala b/core/src/test/scala/io/udash/properties/PropertyTest.scala
index 94a6d98ea..75a422c2e 100644
--- a/core/src/test/scala/io/udash/properties/PropertyTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyTest.scala
@@ -1276,7 +1276,7 @@ class PropertyTest extends UdashCoreTest {
 
     "work with simple case class" in {
       case class Simple(i: Int, s:  String)
-      implicit val propertyCreator: ModelPropertyCreator[Simple] = MacroModelPropertyCreator.materialize[Simple].pc
+      implicit val propertyCreator: ModelPropertyCreator[Simple] = ModelPropertyCreator.materialize
 
       val p = ModelProperty(Simple(1, "xxx"))
       p.get should be(Simple(1, "xxx"))
@@ -1289,6 +1289,7 @@ class PropertyTest extends UdashCoreTest {
 
     "work with tuples" in {
       val init = (123, "sth", true, new C(42, "s"))
+      implicit val pc: ModelPropertyCreator[(Int, String, Boolean, C)] = ModelPropertyCreator.materialize
       val p = ModelProperty(init)
 
       var changeCount = 0
@@ -1305,6 +1306,7 @@ class PropertyTest extends UdashCoreTest {
 
     "work with Tuple2" in {
       val init = (123, "sth")
+      implicit val pc: ModelPropertyCreator[(Int, String)] = ModelPropertyCreator.materialize
       val p = ModelProperty(init)
 
       var changeCount = 0
@@ -1486,14 +1488,15 @@ class PropertyTest extends UdashCoreTest {
 
       val s = create(Outer.Bla(5, "asd2", Outer.Bla(7, "qwe", 1)), 8, "asd")
       s.elemProperties.foreach { v =>
-        val p = v.asModel
-        p.subProp(_._1.x).get should be(5)
-        p.subProp(_._1.s).get should be("asd2")
-        p.subProp(_._1.t.x).get should be(7)
-        p.subProp(_._1.t.s).get should be("qwe")
-        p.subProp(_._1.t.t).get should be(1)
-        p.subProp(_._2).get should be(8)
-        p.subProp(_._3).get should be("asd")
+        //todo
+        v.asModel(ModelPropertyCreator.materialize)
+        //p.subProp(_._1.x).get should be(5)
+        //p.subProp(_._1.s).get should be("asd2")
+        //p.subProp(_._1.t.x).get should be(7)
+        //p.subProp(_._1.t.s).get should be("qwe")
+        //p.subProp(_._1.t.t).get should be(1)
+        //p.subProp(_._2).get should be(8)
+        //p.subProp(_._3).get should be("asd")
       }
     }
 
diff --git a/core/src/test/scala/io/udash/properties/ReadableWrapperTest.scala b/core/src/test/scala/io/udash/properties/ReadableWrapperTest.scala
index 5bc5a0ca1..0e644adc7 100644
--- a/core/src/test/scala/io/udash/properties/ReadableWrapperTest.scala
+++ b/core/src/test/scala/io/udash/properties/ReadableWrapperTest.scala
@@ -18,7 +18,7 @@ class ReadableWrapperTest extends UdashCoreTest {
     }
 
     "not allow access to the mutable API of ModelProperty" in {
-      val p = ModelProperty[(Int, Int)]((7, 42))
+      val p = ModelProperty[(Int, Int)]((7, 42))(ModelPropertyCreator.materialize)
       p.readable match {
         case p: ModelProperty[(Int, Int)] => p.set((42, 7))
         case _ => // ignore
diff --git a/guide/guide/src/main/scala/io/udash/web/guide/views/bootstrapping/BootstrappingIntroView.scala b/guide/guide/src/main/scala/io/udash/web/guide/views/bootstrapping/BootstrappingIntroView.scala
index b67e3ea8f..4e94da8e6 100644
--- a/guide/guide/src/main/scala/io/udash/web/guide/views/bootstrapping/BootstrappingIntroView.scala
+++ b/guide/guide/src/main/scala/io/udash/web/guide/views/bootstrapping/BootstrappingIntroView.scala
@@ -1,5 +1,6 @@
 package io.udash.web.guide.views.bootstrapping
 
+import com.avsystem.commons.serialization.GenCodec
 import io.udash._
 import io.udash.css.CssView
 import io.udash.web.commons.views.{ClickableImageFactory, ImageFactoryPrefixSet}

From cb36d8a3fb50f0904fa0533849761b318e3f5836 Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Tue, 16 Apr 2019 09:04:10 +0200
Subject: [PATCH 09/21] Enable tests for problematic implicit case

---
 .../io/udash/properties/PropertyCreator.scala | 10 +++----
 .../properties/PropertyCreatorTest.scala      | 26 ++++++++-----------
 2 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/core/src/main/scala/io/udash/properties/PropertyCreator.scala b/core/src/main/scala/io/udash/properties/PropertyCreator.scala
index 27dc46c4a..513258736 100644
--- a/core/src/main/scala/io/udash/properties/PropertyCreator.scala
+++ b/core/src/main/scala/io/udash/properties/PropertyCreator.scala
@@ -6,16 +6,16 @@ import io.udash.properties.single.{CastableProperty, DirectPropertyImpl, Readabl
 import scala.annotation.implicitNotFound
 
 trait PropertyCreator[T] {
-  def newProperty(prt: ReadableProperty[_])(implicit blank: Blank[T]): CastableProperty[T] =
-    newProperty(blank.value, prt)
+  def newProperty(parent: ReadableProperty[_])(implicit blank: Blank[T]): CastableProperty[T] =
+    newProperty(blank.value, parent)
 
-  def newProperty(value: T, prt: ReadableProperty[_]): CastableProperty[T] = {
-    val prop = create(prt)
+  def newProperty(value: T, parent: ReadableProperty[_]): CastableProperty[T] = {
+    val prop = create(parent)
     prop.setInitValue(value)
     prop
   }
 
-  protected def create(prt: ReadableProperty[_]): CastableProperty[T]
+  protected def create(parent: ReadableProperty[_]): CastableProperty[T]
 }
 
 object PropertyCreator extends PropertyCreatorImplicits {
diff --git a/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala b/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
index 7c60bf0b0..a5a622bd2 100644
--- a/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
@@ -6,8 +6,6 @@ class PropertyCreatorTest extends UdashCoreTest {
   // DO NOT REMOVE THIS IMPORT!
   import io.udash.properties.Properties._
 
-  //val x = SeqProperty.apply[Nothing](Seq.empty)
-
   "PropertyCreator" should {
     "create Property for basic types (and handle init value)" in {
       """val p = Property.blank[String]""".stripMargin should compile
@@ -995,19 +993,17 @@ class PropertyCreatorTest extends UdashCoreTest {
         |""".stripMargin should compile
     }
 
+    "fail implicit search for SeqPropertyCreator[Nothing]" in {
+      "SeqProperty.apply[Nothing](Seq.empty)" shouldNot compile
+    }
 
-    //    "fail implicit search for SeqPropertyCreator[Nothing]" in {
-    //      "SeqProperty.apply[Nothing](Seq.empty)" shouldNot compile
-    //    }
-    //    case class Chunk[T](
-    //      data: Property[T] = Property.blank
-    //    )
-    //    case class Chunk[T](
-    //      data: SeqProperty[T] = SeqProperty.blank
-    //    )
-    //    //https://github.com/UdashFramework/udash-core/issues/271
-    //    "work with inferred SeqProperty factory type params" in {
-    //
-    //    }
+    //https://github.com/UdashFramework/udash-core/issues/271
+    "fail implicit search for SeqPropertyCreator on default generic value" in {
+      """
+        |case class Chunk[T](
+        |  data: SeqProperty[T] = SeqProperty.blank
+        |)
+      """.stripMargin shouldNot compile
+    }
   }
 }

From a512076228720f68197ab8a643a230646003bda1 Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Tue, 16 Apr 2019 10:04:22 +0200
Subject: [PATCH 10/21] Throw exceptions on property creator mismatch

---
 build.sbt                                     |   1 -
 .../properties/single/CastableProperty.scala  |  25 +-
 .../io/udash/properties/PropertyTest.scala    | 262 ++++++++++--------
 .../BootstrappingIntroView.scala              |   1 -
 4 files changed, 164 insertions(+), 125 deletions(-)

diff --git a/build.sbt b/build.sbt
index c28fc4b11..033fdeccb 100644
--- a/build.sbt
+++ b/build.sbt
@@ -37,7 +37,6 @@ val commonSettings = Seq(
     "-Xfuture",
     "-Xfatal-warnings",
     "-Xlint:_,-missing-interpolator",
-    "-Xlog-implicits",
   ),
   scalacOptions ++= {
     if (scalaBinaryVersion.value == "2.12") Seq(
diff --git a/core/src/main/scala/io/udash/properties/single/CastableProperty.scala b/core/src/main/scala/io/udash/properties/single/CastableProperty.scala
index 29f1fb4d6..b3a56936a 100644
--- a/core/src/main/scala/io/udash/properties/single/CastableProperty.scala
+++ b/core/src/main/scala/io/udash/properties/single/CastableProperty.scala
@@ -5,8 +5,8 @@ import io.udash.properties.model.{ModelProperty, ReadableModelProperty}
 import io.udash.properties.seq.{ReadableSeqProperty, SeqProperty}
 
 /** Property which can be casted. <br/>
-  * <b>NOTE:</b> Those casts are checked in compilation time: "it compiles" == "it works".
-  */
+ * <b>NOTE:</b> Those casts are checked in compilation time: "it compiles" == "it works".
+ */
 trait CastableReadableProperty[A] extends ReadableProperty[A] {
   /** Safely casts DirectProperty[A] to ModelProperty[A] */
   def asModel(implicit ev: ModelPropertyCreator[A]): ReadableModelProperty[A] =
@@ -18,14 +18,23 @@ trait CastableReadableProperty[A] extends ReadableProperty[A] {
 }
 
 /** Property which can be casted. <br/>
-  * <b>NOTE:</b> Those casts are checked in compilation time: "it compiles" == "it works".
-  */
+ * <b>NOTE:</b> Those casts are checked in compilation time: "it compiles" == "it works", as long as the property creators
+ * were not explicitly passed and relevant implicit scope is equal for property creation and cast.
+ */
 trait CastableProperty[A] extends CastableReadableProperty[A] with Property[A] {
-  /** Safely casts DirectProperty[A] to ModelProperty[A] */
-  override def asModel(implicit ev: ModelPropertyCreator[A]): ModelProperty[A] =
+  /** Safely casts `DirectProperty[A]` to `ModelProperty[A]` */
+  override def asModel(implicit ev: ModelPropertyCreator[A]): ModelProperty[A] = {
+    if (!this.isInstanceOf[ModelProperty[A]])
+      throw new IllegalStateException("Property was created without provided ModelPropertyCreator in scope. " +
+        "Make sure it is uniformly available, e.g. in the companion object of the model class.")
     this.asInstanceOf[ModelProperty[A]]
+  }
 
-  /** Safely casts DirectProperty[Seq[A]] to DirectSeqProperty[A] */
-  override def asSeq[B](implicit sev: A <:< Seq[B], ev: SeqPropertyCreator[B]): SeqProperty[B, CastableProperty[B]] =
+  /** Safely casts `DirectProperty[Seq[A]]` to `DirectSeqProperty[A]` */
+  override def asSeq[B](implicit sev: A <:< Seq[B], ev: SeqPropertyCreator[B]): SeqProperty[B, CastableProperty[B]] = {
+    if (!this.isInstanceOf[SeqProperty[_, _]])
+      throw new IllegalStateException("Property was created without provided SeqPropertyCreator in scope. " +
+        "Make sure not to explicitly pass creators on property creation.")
     this.asInstanceOf[SeqProperty[B, CastableProperty[B]]]
+  }
 }
diff --git a/core/src/test/scala/io/udash/properties/PropertyTest.scala b/core/src/test/scala/io/udash/properties/PropertyTest.scala
index 75a422c2e..67ce3244d 100644
--- a/core/src/test/scala/io/udash/properties/PropertyTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyTest.scala
@@ -4,7 +4,7 @@ import com.avsystem.commons._
 import com.github.ghik.silencer.silent
 import io.udash.properties.model.ModelProperty
 import io.udash.properties.seq.{Patch, ReadableSeqProperty, SeqProperty}
-import io.udash.properties.single.{CastableProperty, Property, ReadableProperty}
+import io.udash.properties.single.{Property, ReadableProperty}
 import io.udash.testing.UdashCoreTest
 import io.udash.utils.Registration
 
@@ -540,7 +540,7 @@ class PropertyTest extends UdashCoreTest {
 
       p1.set(2)
       p2.set(3)
-      s.set(Seq(2,1))
+      s.set(Seq(2, 1))
       sc.get should be(Seq(10, 5))
       sqc.get should be(Seq(10, 5))
     }
@@ -661,13 +661,13 @@ class PropertyTest extends UdashCoreTest {
       elementsUpdated should be(0)
 
       p.set("1,0,1,0,1")
-      s.get should be(Seq(1,0,1,0,1))
+      s.get should be(Seq(1, 0, 1, 0, 1))
 
       lastValue = null
       lastPatch = null
       elementsUpdated = 0
       p.set("1,0,1,0,1,0,1")
-      s.get should be(Seq(1,0,1,0,1,0,1))
+      s.get should be(Seq(1, 0, 1, 0, 1, 0, 1))
       lastValue should be(s.get)
       lastPatch.added.size should be(2)
       lastPatch.removed.size should be(0)
@@ -677,7 +677,7 @@ class PropertyTest extends UdashCoreTest {
       lastPatch = null
       elementsUpdated = 0
       p.set("1,0,1,0,1")
-      s.get should be(Seq(1,0,1,0,1))
+      s.get should be(Seq(1, 0, 1, 0, 1))
       lastValue should be(s.get)
       lastPatch.idx should be(5)
       lastPatch.added.size should be(0)
@@ -688,7 +688,7 @@ class PropertyTest extends UdashCoreTest {
       lastPatch = null
       elementsUpdated = 0
       p.touch()
-      s.get should be(Seq(1,0,1,0,1))
+      s.get should be(Seq(1, 0, 1, 0, 1))
       lastValue should be(s.get)
       lastPatch should be(null)
       elementsUpdated should be(0)
@@ -703,9 +703,9 @@ class PropertyTest extends UdashCoreTest {
       p.listenersCount() should be(0)
 
       p.set("1,2,3")
-      s.get should be(Seq(1,2,3))
+      s.get should be(Seq(1, 2, 3))
       p.set("1,2,3,-1,-2,-3")
-      s.get should be(Seq(1,2,3,-1,-2,-3))
+      s.get should be(Seq(1, 2, 3, -1, -2, -3))
     }
 
     "not allow children modification after transformation into ReadableSeqProperty" in {
@@ -718,7 +718,7 @@ class PropertyTest extends UdashCoreTest {
         case _: ReadableProperty[Int] => //ignore
       }
 
-      s.get should be(Seq(1,2,3,4,5))
+      s.get should be(Seq(1, 2, 3, 4, 5))
     }
 
     "transform to SeqProperty" in {
@@ -836,7 +836,7 @@ class PropertyTest extends UdashCoreTest {
       lastPatch.removed.size should be(3)
       elementsUpdated should be(0)
 
-      s.set(Seq(1,0,1,0,1))
+      s.set(Seq(1, 0, 1, 0, 1))
       p.get should be("1,0,1,0,1")
 
       lastValue = null
@@ -852,7 +852,7 @@ class PropertyTest extends UdashCoreTest {
       lastValue = null
       lastPatch = null
       elementsUpdated = 0
-      s.set(Seq(1,0,1,0,1))
+      s.set(Seq(1, 0, 1, 0, 1))
       p.get should be("1,0,1,0,1")
       lastValue should be(s.get)
       lastPatch.idx should be(5)
@@ -877,9 +877,9 @@ class PropertyTest extends UdashCoreTest {
       p.listenersCount() should be(0)
 
       p.set("1,-1,2,-2")
-      s.get should be(Seq(1,-1,2,-2))
+      s.get should be(Seq(1, -1, 2, -2))
 
-      s.set(Seq(4,-4,2,-2))
+      s.set(Seq(4, -4, 2, -2))
       p.get should be("4,-4,2,-2")
     }
 
@@ -887,7 +887,7 @@ class PropertyTest extends UdashCoreTest {
       val s = Property("1,2,3,4,5,6")
       val i = s.transformToSeq(_.split(",").map(_.toInt), (v: Seq[Int]) => v.map(_.toString).mkString(","))
 
-      i.get should be(Seq(1,2,3,4,5,6))
+      i.get should be(Seq(1, 2, 3, 4, 5, 6))
 
       var counter = 0
       val r1 = s.listen(_ => counter += 1)
@@ -895,7 +895,7 @@ class PropertyTest extends UdashCoreTest {
       i.append(7)
 
       s.get should be("1,2,3,4,5,6,7")
-      i.get should be(Seq(1,2,3,4,5,6,7))
+      i.get should be(Seq(1, 2, 3, 4, 5, 6, 7))
       counter should be(1)
 
       CallbackSequencer().sequence {
@@ -903,13 +903,13 @@ class PropertyTest extends UdashCoreTest {
       }
 
       s.get should be("12,12,12,12,12,12,12")
-      i.get should be(Seq(12,12,12,12,12,12,12))
+      i.get should be(Seq(12, 12, 12, 12, 12, 12, 12))
       counter should be(2)
 
       i.elemProperties.foreach(_.set(1))
 
       s.get should be("1,1,1,1,1,1,1")
-      i.get should be(Seq(1,1,1,1,1,1,1))
+      i.get should be(Seq(1, 1, 1, 1, 1, 1, 1))
       counter should be(9)
 
       r1.cancel()
@@ -919,13 +919,13 @@ class PropertyTest extends UdashCoreTest {
       }
 
       s.get should be("13,13,13,13,13,13,13")
-      i.get should be(Seq(13,13,13,13,13,13,13))
+      i.get should be(Seq(13, 13, 13, 13, 13, 13, 13))
       counter should be(9)
 
       i.elemProperties.foreach(_.set(1))
 
       s.get should be("1,1,1,1,1,1,1")
-      i.get should be(Seq(1,1,1,1,1,1,1))
+      i.get should be(Seq(1, 1, 1, 1, 1, 1, 1))
       counter should be(9)
     }
 
@@ -1242,7 +1242,7 @@ class PropertyTest extends UdashCoreTest {
       val p = ModelProperty(null: TT)
       val t = p.transform[Int](
         (p: TT) => p.i + p.t.c.i,
-        (x: Int) => newTT(x/2, None, new C(x/2, ""), Seq.empty)
+        (x: Int) => newTT(x / 2, None, new C(x / 2, ""), Seq.empty)
       )
 
       val r1 = p.listen(listener)
@@ -1275,7 +1275,7 @@ class PropertyTest extends UdashCoreTest {
     }
 
     "work with simple case class" in {
-      case class Simple(i: Int, s:  String)
+      case class Simple(i: Int, s: String)
       implicit val propertyCreator: ModelPropertyCreator[Simple] = ModelPropertyCreator.materialize
 
       val p = ModelProperty(Simple(1, "xxx"))
@@ -1336,10 +1336,14 @@ class PropertyTest extends UdashCoreTest {
     "work with recursive trait" in {
       import ReqModels._
 
-      val p = ModelProperty[ReqT](new ReqT { def t: ReqT = null })
+      val p = ModelProperty[ReqT](new ReqT {
+        def t: ReqT = null
+      })
       p.get.t should be(null)
       val s = p.subModel(_.t)
-      s.set(new ReqT { def t: ReqT = null })
+      s.set(new ReqT {
+        def t: ReqT = null
+      })
       s.get.t should be(null)
       p.get.t shouldNot be(null)
     }
@@ -1474,6 +1478,21 @@ class PropertyTest extends UdashCoreTest {
       sub.get.x should be(7)
     }
 
+    "handle Seq[_]" in {
+      case class Bla(s: Seq[_])
+      object Bla extends HasModelPropertyCreator[Bla]
+
+      val mp = ModelProperty(Bla(Seq(1, 8L)))
+      val s = mp.subSeq(_.s)
+
+      s.get should contain inOrderOnly(1, 8L)
+
+      s.prepend("0")
+      s.replace(1, 2, 0.0, 7)
+
+      s.get should contain inOrderOnly("0", 0.0, 7)
+    }
+
     "handle generic types" in {
       object Outer {
         case class Bla[Type](x: Int, s: String, t: Type)
@@ -1483,23 +1502,35 @@ class PropertyTest extends UdashCoreTest {
         }
       }
 
-      def create[A : PropertyCreator, B : PropertyCreator, D : PropertyCreator](a: A, b: B, d: D): SeqProperty[(A, B, D), CastableProperty[(A, B, D)]] =
-        SeqProperty(Seq.tabulate(10)(_ => (a, b, d)))
-
-      val s = create(Outer.Bla(5, "asd2", Outer.Bla(7, "qwe", 1)), 8, "asd")
+      implicit val mpc: ModelPropertyCreator[(Outer.Bla[Outer.Bla[Int]], Int, String)] = ModelPropertyCreator.materialize
+      val s = SeqProperty(Seq.tabulate(10)(_ => (Outer.Bla(5, "asd2", Outer.Bla(7, "qwe", 1)), 8, "asd")))
       s.elemProperties.foreach { v =>
-        //todo
-        v.asModel(ModelPropertyCreator.materialize)
-        //p.subProp(_._1.x).get should be(5)
-        //p.subProp(_._1.s).get should be("asd2")
-        //p.subProp(_._1.t.x).get should be(7)
-        //p.subProp(_._1.t.s).get should be("qwe")
-        //p.subProp(_._1.t.t).get should be(1)
-        //p.subProp(_._2).get should be(8)
-        //p.subProp(_._3).get should be("asd")
+        val p = v.asModel
+        p.subProp(_._1.x).get should be(5)
+        p.subProp(_._1.s).get should be("asd2")
+        p.subProp(_._1.t.x).get should be(7)
+        p.subProp(_._1.t.s).get should be("qwe")
+        p.subProp(_._1.t.t).get should be(1)
+        p.subProp(_._2).get should be(8)
+        p.subProp(_._3).get should be("asd")
       }
     }
 
+    "fail on static creator mismatch" in {
+      case class Bla[Type](x: Int, s: String, t: Type)
+      object Bla {
+        implicit def pc[Type: PropertyCreator]: ModelPropertyCreator[Bla[Type]] =
+          ModelPropertyCreator.materialize[Bla[Type]]
+      }
+
+      val p = Property((Bla(5, "asd2", Bla(7, "qwe", 1)), 8, "asd"))
+
+      an[IllegalStateException] shouldBe thrownBy(p.asModel(ModelPropertyCreator.materialize))
+
+      val p2 = Property(Seq(1, 2, 3))(new SinglePropertyCreator[BSeq[Int]])
+      an[IllegalStateException] shouldBe thrownBy(p2.asSeq)
+    }
+
     "cache subproperties" in {
       val p = ModelProperty(null: TT)
       p.set(newTT(5, Some("s"), new C(123, "asd"), Seq('a', 'b', 'c')))
@@ -1529,7 +1560,7 @@ class PropertyTest extends UdashCoreTest {
 
   "SeqProperty" should {
     "handle sequence of properties" in {
-      val p = SeqProperty[Int](Seq(1,2,3))
+      val p = SeqProperty[Int](Seq(1, 2, 3))
       val pt = SeqProperty[T](TO1, TC1(5), TO2)
       val ptt = SeqProperty[TT](randTT(), randTT(), randTT())
 
@@ -1668,7 +1699,7 @@ class PropertyTest extends UdashCoreTest {
     }
 
     "handle null value as empty Seq" in {
-      val p = SeqProperty[Int](1,2,3)
+      val p = SeqProperty[Int](1, 2, 3)
       p.set(null)
       p.get.size should be(0)
       p.touch()
@@ -1689,7 +1720,7 @@ class PropertyTest extends UdashCoreTest {
       values.size should be(1)
       values.clear()
 
-      p.set(Seq(1,2,3))
+      p.set(Seq(1, 2, 3))
       values.size should be(1)
       values.last should be(Seq(1, 2, 3))
 
@@ -1738,7 +1769,7 @@ class PropertyTest extends UdashCoreTest {
 
       p.listen(listener)
 
-      p.set(Seq(1,2,3))
+      p.set(Seq(1, 2, 3))
       values.size should be(1)
       values.last should be(Seq(1, 2, 3))
 
@@ -1767,7 +1798,7 @@ class PropertyTest extends UdashCoreTest {
 
       p.listenStructure(listener)
 
-      p.set(Seq(1,2,3))
+      p.set(Seq(1, 2, 3))
       patches.size should be(1)
       patches.last.idx should be(0)
       patches.last.added.size should be(3)
@@ -1829,7 +1860,7 @@ class PropertyTest extends UdashCoreTest {
 
       p.listenStructure(listener)
 
-      p.set(Seq(1,2,3))
+      p.set(Seq(1, 2, 3))
       patches.size should be(1)
       p.elemProperties(1).set(5)
       patches.size should be(1)
@@ -1954,7 +1985,8 @@ class PropertyTest extends UdashCoreTest {
       val f = p.filter(_ % 2 == 0)
 
       val states = mutable.ArrayBuffer.empty[Seq[Int]]: @silent
-      val patches = mutable.ArrayBuffer.empty[Patch[ReadableProperty[Int]]]: @silent
+      val patches = mutable.ArrayBuffer.empty[Patch[ReadableProperty[Int]]]:
+      @silent
 
       ensureNoListeners(p)
 
@@ -2328,7 +2360,7 @@ class PropertyTest extends UdashCoreTest {
     }
 
     "provide reversed version" in {
-      val p = SeqProperty(1,2,3)
+      val p = SeqProperty(1, 2, 3)
       val r: SeqProperty[Int, Property[Int]] = p.reversed()
       val r2: SeqProperty[Int, Property[Int]] = r.reversed()
 
@@ -2350,9 +2382,9 @@ class PropertyTest extends UdashCoreTest {
 
       p.append(4)
 
-      pValue should be(Seq(1,2,3,4))
-      rValue should be(Seq(4,3,2,1))
-      r2Value should be(Seq(1,2,3,4))
+      pValue should be(Seq(1, 2, 3, 4))
+      rValue should be(Seq(4, 3, 2, 1))
+      r2Value should be(Seq(1, 2, 3, 4))
       pPatch.idx should be(3)
       pPatch.added.size should be(1)
       pPatch.removed.size should be(0)
@@ -2365,9 +2397,9 @@ class PropertyTest extends UdashCoreTest {
 
       p.prepend(0)
 
-      pValue should be(Seq(0,1,2,3,4))
-      rValue should be(Seq(4,3,2,1,0))
-      r2Value should be(Seq(0,1,2,3,4))
+      pValue should be(Seq(0, 1, 2, 3, 4))
+      rValue should be(Seq(4, 3, 2, 1, 0))
+      r2Value should be(Seq(0, 1, 2, 3, 4))
       pPatch.idx should be(0)
       pPatch.added.size should be(1)
       pPatch.removed.size should be(0)
@@ -2380,9 +2412,9 @@ class PropertyTest extends UdashCoreTest {
 
       p.replace(1, 2, 9, 9, 9)
 
-      pValue should be(Seq(0,9,9,9,3,4))
-      rValue should be(Seq(4,3,9,9,9,0))
-      r2Value should be(Seq(0,9,9,9,3,4))
+      pValue should be(Seq(0, 9, 9, 9, 3, 4))
+      rValue should be(Seq(4, 3, 9, 9, 9, 0))
+      r2Value should be(Seq(0, 9, 9, 9, 3, 4))
       pPatch.idx should be(1)
       pPatch.added.size should be(3)
       pPatch.removed.size should be(2)
@@ -2395,7 +2427,7 @@ class PropertyTest extends UdashCoreTest {
     }
 
     "provide reversed version of transformed and filtered SeqProperty" in {
-      val p = SeqProperty(-3,-2,-1,0,1,2)
+      val p = SeqProperty(-3, -2, -1, 0, 1, 2)
       val f = p.filter(_ >= 0).transform((i: Int) => i + 1)
       val r: ReadableSeqProperty[Int, ReadableProperty[Int]] = f.reversed()
       val r2: ReadableSeqProperty[Int, ReadableProperty[Int]] = r.reversed()
@@ -2418,9 +2450,9 @@ class PropertyTest extends UdashCoreTest {
 
       p.append(3)
 
-      fValue should be(Seq(1,2,3,4))
-      rValue should be(Seq(4,3,2,1))
-      r2Value should be(Seq(1,2,3,4))
+      fValue should be(Seq(1, 2, 3, 4))
+      rValue should be(Seq(4, 3, 2, 1))
+      r2Value should be(Seq(1, 2, 3, 4))
       fPatch.idx should be(3)
       fPatch.added.size should be(1)
       fPatch.removed.size should be(0)
@@ -2434,9 +2466,9 @@ class PropertyTest extends UdashCoreTest {
       p.prepend(-1)
       p.prepend(0)
 
-      fValue should be(Seq(1,1,2,3,4))
-      rValue should be(Seq(4,3,2,1,1))
-      r2Value should be(Seq(1,1,2,3,4))
+      fValue should be(Seq(1, 1, 2, 3, 4))
+      rValue should be(Seq(4, 3, 2, 1, 1))
+      r2Value should be(Seq(1, 1, 2, 3, 4))
       fPatch.idx should be(0)
       fPatch.added.size should be(1)
       fPatch.removed.size should be(0)
@@ -2449,9 +2481,9 @@ class PropertyTest extends UdashCoreTest {
 
       p.replace(5, 2, 8, 8, 8)
 
-      fValue should be(Seq(1,9,9,9,3,4))
-      rValue should be(Seq(4,3,9,9,9,1))
-      r2Value should be(Seq(1,9,9,9,3,4))
+      fValue should be(Seq(1, 9, 9, 9, 3, 4))
+      rValue should be(Seq(4, 3, 9, 9, 9, 1))
+      r2Value should be(Seq(1, 9, 9, 9, 3, 4))
       fPatch.idx should be(1)
       fPatch.added.size should be(3)
       fPatch.removed.size should be(2)
@@ -2464,9 +2496,9 @@ class PropertyTest extends UdashCoreTest {
 
       p.touch()
 
-      fValue should be(Seq(1,9,9,9,3,4))
-      rValue should be(Seq(4,3,9,9,9,1))
-      r2Value should be(Seq(1,9,9,9,3,4))
+      fValue should be(Seq(1, 9, 9, 9, 3, 4))
+      rValue should be(Seq(4, 3, 9, 9, 9, 1))
+      r2Value should be(Seq(1, 9, 9, 9, 3, 4))
     }
 
     "zip with another ReadableProperty" in {
@@ -2481,13 +2513,13 @@ class PropertyTest extends UdashCoreTest {
       ensureNoListeners(evens)
 
       numbers.append(20, 21)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,20)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 20)))
 
       numbers.remove(21)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,20)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 20)))
 
       numbers.remove(20)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8)))
 
       numbers.append(10)
 
@@ -2500,37 +2532,37 @@ class PropertyTest extends UdashCoreTest {
       evens.structureListenersCount() should be(1)
 
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10)))
       patches.size should be(0)
 
       numbers.elemProperties(3).set(8)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,8), (5,6), (7,8), (9,10)))
+      pairs.get should be(Seq((1, 2), (3, 8), (5, 6), (7, 8), (9, 10)))
       patches.size should be(0)
 
       numbers.elemProperties(3).set(4)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10)))
       patches.size should be(0)
 
       numbers.elemProperties(2).set(9)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (9,4), (5,6), (7,8), (9,10)))
+      pairs.get should be(Seq((1, 2), (9, 4), (5, 6), (7, 8), (9, 10)))
       patches.size should be(0)
 
       numbers.elemProperties(2).set(3)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10)))
       patches.size should be(0)
 
       numbers.append(11)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10)))
       patches.size should be(0)
 
       numbers.append(12)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10), (11,12)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, 12)))
       patches.size should be(1)
       patches.last.idx should be(5)
       patches.last.added.size should be(1)
@@ -2538,12 +2570,12 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.append(14)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10), (11,12)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, 12)))
       patches.size should be(1)
 
       numbers.append(13)
       pairs.size should be(7)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10), (11,12), (13,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, 12), (13, 14)))
       patches.size should be(2)
       patches.last.idx should be(6)
       patches.last.added.size should be(1)
@@ -2551,7 +2583,7 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.remove(5)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (7,6), (9,8), (11,10), (13,12)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 6), (9, 8), (11, 10), (13, 12)))
       patches.size should be(3)
       patches.last.idx should be(2)
       patches.last.added.size should be(4)
@@ -2559,7 +2591,7 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.remove(6)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (7,8), (9,10), (11,12), (13,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 8), (9, 10), (11, 12), (13, 14)))
       patches.size should be(4)
       patches.last.idx should be(2)
       patches.last.added.size should be(4)
@@ -2567,17 +2599,17 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.elemProperties(7).set(20)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (7,8), (9,20), (11,12), (13,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 8), (9, 20), (11, 12), (13, 14)))
       patches.size should be(4)
 
       numbers.elemProperties(7).set(10)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (7,8), (9,10), (11,12), (13,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 8), (9, 10), (11, 12), (13, 14)))
       patches.size should be(4)
 
       numbers.remove(12)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (7,8), (9,10), (11,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 8), (9, 10), (11, 14)))
       patches.size should be(5)
       patches.last.idx should be(4)
       patches.last.added.size should be(1)
@@ -2585,7 +2617,7 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.remove(11)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (7,8), (9,10), (13,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 8), (9, 10), (13, 14)))
       patches.size should be(6)
       patches.last.idx should be(4)
       patches.last.added.size should be(1)
@@ -2596,14 +2628,14 @@ class PropertyTest extends UdashCoreTest {
         numbers.remove(2)
       }
       pairs.size should be(4)
-      pairs.get should be(Seq((3,4), (7,8), (9,10), (13,14)))
+      pairs.get should be(Seq((3, 4), (7, 8), (9, 10), (13, 14)))
       patches.size should be(8)
       patches.last.idx should be(0)
       patches.last.added.size should be(4)
       patches.last.removed.size should be(4)
 
       numbers.touch()
-      pairs.get should be(Seq((3,4), (7,8), (9,10), (13,14)))
+      pairs.get should be(Seq((3, 4), (7, 8), (9, 10), (13, 14)))
 
       odds.listenersCount() should be(0)
       evens.listenersCount() should be(0)
@@ -2617,13 +2649,13 @@ class PropertyTest extends UdashCoreTest {
       ensureNoListeners(evens)
 
       numbers.append(20, 21)
-      pairs.get should be(Seq((3,4), (7,8), (9,10), (13,14), (21, 20)))
+      pairs.get should be(Seq((3, 4), (7, 8), (9, 10), (13, 14), (21, 20)))
 
       numbers.remove(4)
-      pairs.get should be(Seq((3,8), (7,10), (9,14), (13,20)))
+      pairs.get should be(Seq((3, 8), (7, 10), (9, 14), (13, 20)))
 
       numbers.remove(9)
-      pairs.get should be(Seq((3,8), (7,10), (13,14), (21,20)))
+      pairs.get should be(Seq((3, 8), (7, 10), (13, 14), (21, 20)))
     }
 
     "zip all with another ReadableProperty" in {
@@ -2641,13 +2673,13 @@ class PropertyTest extends UdashCoreTest {
       ensureNoListeners(evens)
 
       numbers.append(20, 21)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,20), (21, -2)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 20), (21, -2)))
 
       numbers.remove(21)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,20)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 20)))
 
       numbers.remove(20)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,-2)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, -2)))
 
       val patches = mutable.ArrayBuffer.empty[Patch[ReadableProperty[(Int, Int)]]]
       val r1 = pairs.listenStructure(p => patches.append(p))
@@ -2658,42 +2690,42 @@ class PropertyTest extends UdashCoreTest {
       evens.structureListenersCount() should be(1)
 
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,-2)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, -2)))
       patches.size should be(0)
 
       numbers.elemProperties(3).set(8)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,8), (5,6), (7,8), (9,-2)))
+      pairs.get should be(Seq((1, 2), (3, 8), (5, 6), (7, 8), (9, -2)))
       patches.size should be(0)
 
       numbers.elemProperties(3).set(4)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,-2)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, -2)))
       patches.size should be(0)
 
       numbers.elemProperties(2).set(9)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (9,4), (5,6), (7,8), (9,-2)))
+      pairs.get should be(Seq((1, 2), (9, 4), (5, 6), (7, 8), (9, -2)))
       patches.size should be(0)
 
       numbers.elemProperties(2).set(3)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,-2)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, -2)))
       patches.size should be(0)
 
       defaultB.set(256)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,256)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 256)))
       patches.size should be(0)
 
       defaultB.set(-2)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,-2)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, -2)))
       patches.size should be(0)
 
       numbers.append(10)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10)))
       patches.size should be(1)
       patches.last.idx should be(4)
       patches.last.added.size should be(1)
@@ -2701,7 +2733,7 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.append(11)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10), (11,-2)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, -2)))
       patches.size should be(2)
       patches.last.idx should be(5)
       patches.last.added.size should be(1)
@@ -2709,7 +2741,7 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.append(12)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10), (11,12)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, 12)))
       patches.size should be(3)
       patches.last.idx should be(5)
       patches.last.added.size should be(1)
@@ -2717,7 +2749,7 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.append(14)
       pairs.size should be(7)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10), (11,12), (-1, 14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, 12), (-1, 14)))
       patches.size should be(4)
       patches.last.idx should be(6)
       patches.last.added.size should be(1)
@@ -2725,7 +2757,7 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.append(13)
       pairs.size should be(7)
-      pairs.get should be(Seq((1,2), (3,4), (5,6), (7,8), (9,10), (11,12), (13,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, 12), (13, 14)))
       patches.size should be(5)
       patches.last.idx should be(6)
       patches.last.added.size should be(1)
@@ -2733,7 +2765,7 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.remove(5)
       pairs.size should be(7)
-      pairs.get should be(Seq((1,2), (3,4), (7,6), (9,8), (11,10), (13,12), (-1,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 6), (9, 8), (11, 10), (13, 12), (-1, 14)))
       patches.size should be(6)
       patches.last.idx should be(2)
       patches.last.added.size should be(5)
@@ -2741,7 +2773,7 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.remove(6)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (7,8), (9,10), (11,12), (13,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 8), (9, 10), (11, 12), (13, 14)))
       patches.size should be(7)
       patches.last.idx should be(2)
       patches.last.added.size should be(4)
@@ -2749,17 +2781,17 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.elemProperties(7).set(20)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (7,8), (9,20), (11,12), (13,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 8), (9, 20), (11, 12), (13, 14)))
       patches.size should be(7)
 
       numbers.elemProperties(7).set(10)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (7,8), (9,10), (11,12), (13,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 8), (9, 10), (11, 12), (13, 14)))
       patches.size should be(7)
 
       numbers.remove(12)
       pairs.size should be(6)
-      pairs.get should be(Seq((1,2), (3,4), (7,8), (9,10), (11,14), (13,-2)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 8), (9, 10), (11, 14), (13, -2)))
       patches.size should be(8)
       patches.last.idx should be(4)
       patches.last.added.size should be(2)
@@ -2767,7 +2799,7 @@ class PropertyTest extends UdashCoreTest {
 
       numbers.remove(11)
       pairs.size should be(5)
-      pairs.get should be(Seq((1,2), (3,4), (7,8), (9,10), (13,14)))
+      pairs.get should be(Seq((1, 2), (3, 4), (7, 8), (9, 10), (13, 14)))
       patches.size should be(9)
       patches.last.idx should be(4)
       patches.last.added.size should be(1)
@@ -2778,7 +2810,7 @@ class PropertyTest extends UdashCoreTest {
         numbers.remove(2)
       }
       pairs.size should be(4)
-      pairs.get should be(Seq((3,4), (7,8), (9,10), (13,14)))
+      pairs.get should be(Seq((3, 4), (7, 8), (9, 10), (13, 14)))
       patches.size should be(11)
       patches.last.idx should be(0)
       patches.last.added.size should be(4)
@@ -2796,13 +2828,13 @@ class PropertyTest extends UdashCoreTest {
       ensureNoListeners(evens)
 
       numbers.append(20, 21)
-      pairs.get should be(Seq((3,4), (7,8), (9,10), (13,14), (21, 20)))
+      pairs.get should be(Seq((3, 4), (7, 8), (9, 10), (13, 14), (21, 20)))
 
       numbers.remove(4)
-      pairs.get should be(Seq((3,8), (7,10), (9,14), (13,20), (21, -2)))
+      pairs.get should be(Seq((3, 8), (7, 10), (9, 14), (13, 20), (21, -2)))
 
       numbers.remove(9)
-      pairs.get should be(Seq((3,8), (7,10), (13,14), (21,20)))
+      pairs.get should be(Seq((3, 8), (7, 10), (13, 14), (21, 20)))
     }
 
     "zip with indexes" in {
@@ -2997,7 +3029,7 @@ class PropertyTest extends UdashCoreTest {
 }
 
 private object ReqModels {
-  case class Simple(i: Int, s:  Simple)
+  case class Simple(i: Int, s: Simple)
   object Simple extends HasModelPropertyCreator[Simple]
 
   trait ReqT {
diff --git a/guide/guide/src/main/scala/io/udash/web/guide/views/bootstrapping/BootstrappingIntroView.scala b/guide/guide/src/main/scala/io/udash/web/guide/views/bootstrapping/BootstrappingIntroView.scala
index 4e94da8e6..b67e3ea8f 100644
--- a/guide/guide/src/main/scala/io/udash/web/guide/views/bootstrapping/BootstrappingIntroView.scala
+++ b/guide/guide/src/main/scala/io/udash/web/guide/views/bootstrapping/BootstrappingIntroView.scala
@@ -1,6 +1,5 @@
 package io.udash.web.guide.views.bootstrapping
 
-import com.avsystem.commons.serialization.GenCodec
 import io.udash._
 import io.udash.css.CssView
 import io.udash.web.commons.views.{ClickableImageFactory, ImageFactoryPrefixSet}

From ff073a783da6cae76f5db3206ab26bd082553f92 Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Tue, 16 Apr 2019 13:22:29 +0200
Subject: [PATCH 11/21] Use MacroInstances for HasPropertyCreator

---
 .idea/codeStyles/Project.xml                  |   3 +
 .../io/udash/bindings/TagsBindingTest.scala   |  62 ++--
 .../HasGenCodecAndModelPropertyCreator.scala  |  19 +-
 .../properties/HasModelPropertyCreator.scala  |  10 +-
 .../io/udash/properties/PropertyCreator.scala |   7 -
 .../properties/PropertyCreatorTest.scala      | 334 +++++++++---------
 .../io/udash/properties/PropertyTest.scala    |  60 ++--
 .../udash/properties/PropertyUsageTest.scala  | 327 +++++------------
 .../demos/bootstrap/BootstrapDemos.scala      |  49 +--
 9 files changed, 337 insertions(+), 534 deletions(-)

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index a4412b8e0..2a263378c 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -7,6 +7,9 @@
       <option name="alwaysUsedImports">
         <array>
           <option value="io.udash.properties.Properties._" />
+          <option value="io.udash.properties.model._" />
+          <option value="io.udash.properties.seq._" />
+          <option value="io.udash.properties.single._" />
         </array>
       </option>
       <option name="PLACE_SELF_TYPE_ON_NEW_LINE" value="false" />
diff --git a/core/.js/src/test/scala/io/udash/bindings/TagsBindingTest.scala b/core/.js/src/test/scala/io/udash/bindings/TagsBindingTest.scala
index d04bcc025..94893ae3c 100644
--- a/core/.js/src/test/scala/io/udash/bindings/TagsBindingTest.scala
+++ b/core/.js/src/test/scala/io/udash/bindings/TagsBindingTest.scala
@@ -13,6 +13,31 @@ import scala.collection.mutable
 class TagsBindingTest extends UdashFrontendTest with Bindings { bindings: Bindings =>
   import scalatags.JsDom.all._
 
+  object Model {
+    class WithSubClass(val i: Int, val subType: SubClass)
+    object WithSubClass extends HasModelPropertyCreator[WithSubClass]
+
+    class SubClass(val i: Int)
+    object SubClass extends HasModelPropertyCreator[SubClass]
+
+    trait WithSubTrait {
+      def i: Int
+      def subType: SubTrait
+    }
+    object WithSubTrait extends HasModelPropertyCreator[WithSubTrait]
+
+    trait SubTrait {
+      def i: Int
+    }
+    object SubTrait extends HasModelPropertyCreator[SubTrait]
+  }
+
+  trait TodoElement {
+    def name: String
+    def completed: Boolean
+  }
+  object TodoElement extends HasModelPropertyCreator[TodoElement]
+
   "bind" should {
     "update content of DOM element" in {
       val p = Property[String]("A")
@@ -538,15 +563,7 @@ class TagsBindingTest extends UdashFrontendTest with Bindings { bindings: Bindin
     }
 
     "handle empty case class based model properties" in {
-      object Model {
-        class Test(val i: Int, val subType: SubTest)
-        object Test extends HasModelPropertyCreator[Test]
-
-        class SubTest(val i: Int)
-        object SubTest extends HasModelPropertyCreator[SubTest]
-      }
-
-      val p = ModelProperty(null: Model.Test)
+      val p = ModelProperty(null: Model.WithSubClass)
       val sub = p.subProp(_.subType)
       val template = div(
         produce(p) { t =>
@@ -559,25 +576,12 @@ class TagsBindingTest extends UdashFrontendTest with Bindings { bindings: Bindin
 
       template.textContent should be("")
 
-      p.set(new Model.Test(5, new Model.SubTest(7)))
+      p.set(new Model.WithSubClass(5, new Model.SubClass(7)))
       template.textContent should be("577")
     }
 
     "handle empty trait based model properties" in {
-      object Model {
-        trait Test {
-          def i: Int
-          def subType: SubTest
-        }
-        object Test extends HasModelPropertyCreator[Test]
-
-        trait SubTest {
-          def i: Int
-        }
-        object SubTest extends HasModelPropertyCreator[SubTest]
-      }
-
-      val p = ModelProperty(null: Model.Test)
+      val p = ModelProperty(null: Model.WithSubTrait)
       val sub = p.subProp(_.subType)
       val template = div(
         produce(p) { t =>
@@ -590,9 +594,9 @@ class TagsBindingTest extends UdashFrontendTest with Bindings { bindings: Bindin
 
       template.textContent should be("")
 
-      p.set(new Model.Test {
+      p.set(new Model.WithSubTrait {
         override def i = 5
-        override def subType = new Model.SubTest {
+        override def subType = new Model.SubTrait {
           override def i = 7
         }
       })
@@ -1520,12 +1524,6 @@ class TagsBindingTest extends UdashFrontendTest with Bindings { bindings: Bindin
       case object ActiveTodosFilter    extends TodosFilter(todo => !todo.completed)
       case object CompletedTodosFilter extends TodosFilter(todo => todo.completed)
 
-      trait TodoElement {
-        def name: String
-        def completed: Boolean
-      }
-      object TodoElement extends HasModelPropertyCreator[TodoElement]
-
       case class Todo(override val name: String,
                       override val completed: Boolean) extends TodoElement
 
diff --git a/core/src/main/scala/io/udash/properties/HasGenCodecAndModelPropertyCreator.scala b/core/src/main/scala/io/udash/properties/HasGenCodecAndModelPropertyCreator.scala
index 910c23329..90ec6d437 100644
--- a/core/src/main/scala/io/udash/properties/HasGenCodecAndModelPropertyCreator.scala
+++ b/core/src/main/scala/io/udash/properties/HasGenCodecAndModelPropertyCreator.scala
@@ -11,21 +11,6 @@ trait GenCodecAndModelPropertyCreator[T] {
 abstract class HasGenCodecAndModelPropertyCreator[T](implicit
   instances: MacroInstances[Unit, GenCodecAndModelPropertyCreator[T]]
 ) {
-  /**
-    * Use this constructor and pass `ModelPropertyCreator.materialize` and `GenCodec.materialize` explicitly
-    * if you're getting the "super constructor cannot be passed a self reference unless parameter is declared by-name" error.
-    */
-  def this(explicitCreator: => ModelPropertyCreator[T], explicitCodec: => GenCodec[T]) =
-    this()(new MacroInstances[Unit, GenCodecAndModelPropertyCreator[T]] {
-      def apply(implicits: Unit, companion: Any): GenCodecAndModelPropertyCreator[T] =
-        new GenCodecAndModelPropertyCreator[T] {
-          def codec: GenCodec[T] = explicitCodec
-          def modelPropertyCreator: ModelPropertyCreator[T] = explicitCreator
-        }
-    })
-
-  implicit lazy val modelPropertyCreator: ModelPropertyCreator[T] =
-    instances((), this).modelPropertyCreator
-  implicit lazy val codec: GenCodec[T] =
-    instances((), this).codec
+  implicit final lazy val modelPropertyCreator: ModelPropertyCreator[T] = instances((), this).modelPropertyCreator
+  implicit final lazy val codec: GenCodec[T] = instances((), this).codec
 }
diff --git a/core/src/main/scala/io/udash/properties/HasModelPropertyCreator.scala b/core/src/main/scala/io/udash/properties/HasModelPropertyCreator.scala
index b43b7e6fc..1865ee7d4 100644
--- a/core/src/main/scala/io/udash/properties/HasModelPropertyCreator.scala
+++ b/core/src/main/scala/io/udash/properties/HasModelPropertyCreator.scala
@@ -1,11 +1,7 @@
 package io.udash.properties
 
-abstract class HasModelPropertyCreator[T](implicit mpc: MacroModelPropertyCreator[T]) {
-  /**
-    * Use this constructor and pass `ModelPropertyCreator.materialize` explicitly if you're getting the
-    * "super constructor cannot be passed a self reference unless parameter is declared by-name" error.
-    */
-  def this(creator: => ModelPropertyCreator[T]) = this()(MacroModelPropertyCreator(creator))
+import com.avsystem.commons.meta.MacroInstances
 
-  implicit val modelPropertyCreator: ModelPropertyCreator[T] = mpc.pc
+abstract class HasModelPropertyCreator[T](implicit instances: MacroInstances[Unit, () => ModelPropertyCreator[T]]) {
+  implicit final lazy val modelPropertyCreator: ModelPropertyCreator[T] = instances((), this).apply()
 }
\ No newline at end of file
diff --git a/core/src/main/scala/io/udash/properties/PropertyCreator.scala b/core/src/main/scala/io/udash/properties/PropertyCreator.scala
index 513258736..c8f73ba5e 100644
--- a/core/src/main/scala/io/udash/properties/PropertyCreator.scala
+++ b/core/src/main/scala/io/udash/properties/PropertyCreator.scala
@@ -42,11 +42,4 @@ abstract class ModelPropertyCreator[T] extends PropertyCreator[T]
 object ModelPropertyCreator {
   def materialize[T](implicit ev: IsModelPropertyTemplate[T]): ModelPropertyCreator[T] =
     macro io.udash.macros.PropertyMacros.reifyModelPropertyCreator[T]
-}
-
-@implicitNotFound("Class ${T} cannot be used as ModelProperty template. Add `extends HasModelPropertyCreator[${T}]` to companion object of ${T}.")
-case class MacroModelPropertyCreator[T](pc: ModelPropertyCreator[T]) extends AnyVal
-object MacroModelPropertyCreator {
-  implicit def materialize[T](implicit ev: IsModelPropertyTemplate[T]): MacroModelPropertyCreator[T] =
-    macro io.udash.macros.PropertyMacros.reifyMacroModelPropertyCreator[T]
 }
\ No newline at end of file
diff --git a/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala b/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
index a5a622bd2..531b84726 100644
--- a/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyCreatorTest.scala
@@ -6,6 +6,14 @@ class PropertyCreatorTest extends UdashCoreTest {
   // DO NOT REMOVE THIS IMPORT!
   import io.udash.properties.Properties._
 
+  trait T {
+    def i: Int
+    def x: Int = 5
+    val s: String
+    val l: Long = 8L
+  }
+  object T extends HasModelPropertyCreator[T]
+
   "PropertyCreator" should {
     "create Property for basic types (and handle init value)" in {
       """val p = Property.blank[String]""".stripMargin should compile
@@ -95,187 +103,91 @@ class PropertyCreatorTest extends UdashCoreTest {
     }
 
     "create ModelProperty for trait" in {
-      """trait T {
-        |  def i: Int
-        |  def s: String
-        |}
-        |object T extends HasModelPropertyCreator[T]
-        |
-        |val p = Property[T](null).asModel
-        |val s = p.subProp(_.s)""".stripMargin should compile
-
-      """trait T {
-        |  val i: Int
-        |  val s: String
-        |}
-        |object T extends HasModelPropertyCreator[T]
-        |
+      """
         |val p = Property[T](null).asModel
+        |val i = p.subProp(_.i)
         |val s = p.subProp(_.s)""".stripMargin should compile
 
-      """trait T {
-        |  def i: Int
-        |  def s: String
-        |  def x: Int = 5
-        |}
-        |object T extends HasModelPropertyCreator[T]
-        |
-        |val p = Property[T](null).asModel""".stripMargin should compile
-
-      """trait T {
-        |  def i: Int
-        |  def s: String
-        |  def x: Int = 5
-        |}
-        |object T extends HasModelPropertyCreator[T]
-        |
+      """
         |val p = Property[T](null).asModel
         |val x = p.subProp(_.x)""".stripMargin shouldNot compile
 
-      """trait T {
-        |  def i: Int
-        |  def s: String
-        |  val x: Int = 5
-        |}
-        |object T extends HasModelPropertyCreator[T]
-        |
-        |val p = Property[T](null).asModel""".stripMargin should compile
+      """
+        |val p = Property[T](null).asModel
+        |val x = p.subProp(_.l)""".stripMargin shouldNot compile
 
       """trait T {
         |  def i: Int
         |  def s: String
         |  var x: Int
         |}
-        |object T extends HasModelPropertyCreator[T]
-        |
-        |val p = Property[T](null).asModel""".stripMargin shouldNot compile
-
-      """trait T {
-        |  def i: Int
-        |  def s: String
-        |  var x: Int = 5
-        |}
-        |object T extends HasModelPropertyCreator[T]
-        |
-        |val p = Property[T](null).asModel""".stripMargin shouldNot compile
-
-      """trait T {
-        |  def i: Int
-        |  def s: String
-        |  var x: Int = 5
-        |}
-        |object T extends HasModelPropertyCreator[T]
-        |
-        |trait T2 {
-        |  def t: T
-        |}
-        |object T2 extends HasModelPropertyCreator[T2]
-        |
-        |val p = Property[T2](null).asModel""".stripMargin shouldNot compile
+        |implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize""".stripMargin shouldNot compile
 
       """trait T {
         |  def i: Int
         |  def s: String
         |  var x: Int = 5
         |}
-        |object T extends HasModelPropertyCreator[T]
-        |
-        |trait T2 {
-        |  val t: T
-        |}
-        |object T2 extends HasModelPropertyCreator[T2]
-        |
-        |val p = Property[T2](null).asModel""".stripMargin shouldNot compile
-
-      """trait T {
-        |  def i: Int
-        |  def s: String
-        |  val x: Int = 5
-        |}
-        |object T extends HasModelPropertyCreator[T]
-        |
-        |val p = Property[T](null).asModel
-        |val x = p.subProp(_.x)""".stripMargin shouldNot compile
-
-      """trait T {
-        |  def i: Int
-        |  def s: String
-        |  val x: Int
-        |}
-        |object T extends HasModelPropertyCreator[T]
-        |
-        |val p = Property[T](null).asModel
-        |val x = p.subProp(_.x)""".stripMargin should compile
+        |implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize""".stripMargin shouldNot compile
 
       """object Model {
         |  trait X {
         |    def a: String
         |  }
-        |  object X extends HasModelPropertyCreator[X]
+        |  object X {
+        |    implicit val mpc: ModelPropertyCreator[X] = ModelPropertyCreator.materialize
+        |  }
         |
         |  trait T {
         |    def i: Int
         |    def s: String
         |    def x: X
         |  }
-        |  object T extends HasModelPropertyCreator[T]
+        |  object T {
+        |    implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |  }
         |}
         |
         |val p = Property[Model.T](null).asModel
         |val x = p.subModel(_.x)
         |val a = p.subProp(_.x.a)""".stripMargin should compile
 
-      """trait X {
-        |  def a: String
-        |}
+      """object Model {
+        |  trait X {
+        |    def a: String
+        |  }
         |
-        |trait T {
-        |  def i: Int
-        |  def s: String
-        |  def x: X
+        |  trait T {
+        |    def i: Int
+        |    def s: String
+        |    def x: X
+        |  }
+        |  object T {
+        |    implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |  }
         |}
-        |object T extends HasModelPropertyCreator[T]
         |
-        |val p = Property[T](null).asModel
+        |val p = Property[Model.T](null).asModel
         |val x = p.subModel(_.x)""".stripMargin shouldNot compile
-
-      """trait X {
-        |  def a: String
-        |}
-        |
-        |trait T {
-        |  def i: Int
-        |  def s: String
-        |  def x: X
-        |}
-        |object T extends HasModelPropertyCreator[T]
-        |
-        |val p = Property[T](null).asModel
-        |val x = p.subModel(_.x.a)""".stripMargin shouldNot compile
     }
 
     "create ModelProperty for recursive trait" in {
-      """trait T {
-        |  def i: Int
-        |  def s: String
-        |  def t: T
-        |}
-        |object T extends HasModelPropertyCreator[T](ModelPropertyCreator.materialize[T])
-        |
-        |val p = Property[T](null).asModel""".stripMargin should compile
-
       """trait X {
         |  def a: String
         |  def t: T
         |}
-        |object X extends HasModelPropertyCreator[X](ModelPropertyCreator.materialize[X])
+        |object X {
+        |  implicit val mpc: ModelPropertyCreator[X] = ModelPropertyCreator.materialize
+        |}
         |
         |trait T {
         |  def i: Int
         |  def s: String
         |  def x: X
         |}
-        |object T extends HasModelPropertyCreator[T](ModelPropertyCreator.materialize[T])
+        |object T {
+        |  implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |}
         |
         |val p = Property[T](null).asModel
         |val x = p.subModel(_.x)
@@ -367,7 +279,9 @@ class PropertyCreatorTest extends UdashCoreTest {
 
       """object Model {
         |  case class A(s: Seq[String], i: A)
-        |  object A extends HasModelPropertyCreator[A]
+        |  object A {
+        |    implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = Property[Model.A](null).asModel
         |val s = p.subSeq(_.s)
@@ -375,7 +289,9 @@ class PropertyCreatorTest extends UdashCoreTest {
 
       """object Model {
         |  case class A(s: List[String], i: A)
-        |  object A extends HasModelPropertyCreator[A]
+        |  object A {
+        |    implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = Property[Model.A](null).asModel
         |val s = p.subSeq(_.s)
@@ -383,21 +299,27 @@ class PropertyCreatorTest extends UdashCoreTest {
 
       """object Test {
         |  case class Todo(name: String, editName: String, completed: Boolean = false, editing: Boolean = false)
-        |  object Todo extends HasModelPropertyCreator[Todo]
+        |  object Todo {
+        |    implicit val mpc: ModelPropertyCreator[Todo] = ModelPropertyCreator.materialize
+        |  }
         |  val x = ModelProperty[Todo](null)
         |}""".stripMargin should compile
     }
 
     "create ModelProperty for simple classes" in {
       """class A(val s: Seq[String], val i: A)
-        |object A extends HasModelPropertyCreator[A](ModelPropertyCreator.materialize)
+        |object A {
+        |  implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |}
         |
         |val p = Property[A](null).asModel
         |val s = p.subSeq(_.s)
         |val i = p.subModel(_.i)""".stripMargin should compile
 
       """class A(val s: Vector[String], val i: A)
-        |object A extends HasModelPropertyCreator[A](ModelPropertyCreator.materialize)
+        |object A {
+        |  implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |}
         |
         |val p = Property[A](null).asModel
         |val s = p.subSeq(_.s)
@@ -407,7 +329,9 @@ class PropertyCreatorTest extends UdashCoreTest {
         |  val test: Int = 5
         |  def x: String = "qwe"
         |}
-        |object A extends HasModelPropertyCreator[A](ModelPropertyCreator.materialize)
+        |object A {
+        |  implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |}
         |
         |val p = Property[A](null).asModel
         |val s = p.subSeq(_.s)
@@ -417,7 +341,9 @@ class PropertyCreatorTest extends UdashCoreTest {
         |  val test: Int = 5
         |  def x: String = "qwe"
         |}
-        |object A extends HasModelPropertyCreator[A](ModelPropertyCreator.materialize)
+        |object A {
+        |  implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |}
         |
         |val p = Property[A](null).asModel
         |val test = p.subSeq(_.test)""".stripMargin shouldNot compile
@@ -426,7 +352,9 @@ class PropertyCreatorTest extends UdashCoreTest {
         |  val test: Int = 5
         |  def x: String = "qwe"
         |}
-        |object A extends HasModelPropertyCreator[A](ModelPropertyCreator.materialize)
+        |object A {
+        |  implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |}
         |
         |val p = Property[A](null).asModel
         |val test = p.subSeq(_.x)""".stripMargin shouldNot compile
@@ -444,21 +372,27 @@ class PropertyCreatorTest extends UdashCoreTest {
       """sealed trait T
         |case object A extends T
         |case object B extends T
-        |object T extends HasModelPropertyCreator[T]
+        |object T {
+        |  implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |}
         |
         |val p = Property[T](null).asModel""".stripMargin shouldNot compile
 
       """sealed trait T
         |case object A extends T
         |case object B extends T
-        |object T extends HasModelPropertyCreator[T]
+        |object T {
+        |  implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |}
         |
         |val p = Property[Seq[T]](null).asModel""".stripMargin shouldNot compile
 
       """sealed trait T
         |case object A extends T
         |case object B extends T
-        |object T extends HasModelPropertyCreator[T]
+        |object T {
+        |  implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |}
         |
         |val p = Property[List[T]](null).asModel""".stripMargin shouldNot compile
 
@@ -466,7 +400,9 @@ class PropertyCreatorTest extends UdashCoreTest {
         |  def i: Int
         |  def s: String
         |}
-        |object T extends HasModelPropertyCreator[T]
+        |object T {
+        |  implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |}
         |
         |val p = Property[Seq[T]](null).asModel""".stripMargin shouldNot compile
 
@@ -474,63 +410,83 @@ class PropertyCreatorTest extends UdashCoreTest {
         |  def i: Int
         |  def s: String
         |}
-        |object T extends HasModelPropertyCreator[T]
+        |object T {
+        |  implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |}
         |
         |val p = Property[Vector[T]](null).asModel""".stripMargin shouldNot compile
 
       """object Model {
         |  case class A(s: String, i: Int)
-        |  object A extends HasModelPropertyCreator[A]
+        |  object A {
+        |    implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = Property[Seq[Model.A]](null).asModel""".stripMargin shouldNot compile
 
       """object Model {
         |  case class A(s: String, i: Int)
-        |  object A extends HasModelPropertyCreator[A]
+        |  object T {
+        |    implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = Property[List[Model.A]](null).asModel""".stripMargin shouldNot compile
 
       """object Model {
         |  case class SimpleWithVar(i: Int, var s: String)
-        |  object SimpleWithVar extends HasModelPropertyCreator[SimpleWithVar]
+        |  object SimpleWithVar {
+        |    implicit val mpc: ModelPropertyCreator[SimpleWithVar] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = ModelProperty[Model.SimpleWithVar](null)""".stripMargin shouldNot compile
 
       """object Model {
         |  case class Simple(i: Int, s: String) { val t = 5 }
-        |  object Simple extends HasModelPropertyCreator[Simple]
+        |  object Simple {
+        |    implicit val mpc: ModelPropertyCreator[Simple] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = ModelProperty[Model.Simple](null)""".stripMargin should compile
 
       """object Model {
         |  case class SimpleWithVar(i: Int, s: String) { var t = 5 }
-        |  object SimpleWithVar extends HasModelPropertyCreator[SimpleWithVar]
+        |  object SimpleWithVar {
+        |    implicit val mpc: ModelPropertyCreator[SimpleWithVar] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = ModelProperty[Model.SimpleWithVar](null)""".stripMargin shouldNot compile
 
       """object Model {
         |  case class Simple(i: Int, s: String) { def t = 5 }
-        |  object Simple extends HasModelPropertyCreator[Simple]
+        |  object Simple {
+        |    implicit val mpc: ModelPropertyCreator[Simple] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = ModelProperty[Model.Simple](null)""".stripMargin should compile
 
       """object Model {
         |  class C { val x = 5 }
         |  case class Simple(i: Int, s: String) extends C
-        |  object Simple extends HasModelPropertyCreator[Simple]
+        |  object Simple {
+        |    implicit val mpc: ModelPropertyCreator[Simple] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = ModelProperty[Model.Simple](null)""".stripMargin should compile
 
       """object Model {
         |  class C { var x = 5 }
         |  case class SimpleWithVar(i: Int, c: C)
-        |  object SimpleWithVar extends HasModelPropertyCreator[SimpleWithVar]
+        |  object SimpleWithVar {
+        |    implicit val mpc: ModelPropertyCreator[SimpleWithVar] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = ModelProperty[Model.SimpleWithVar](null)""".stripMargin should compile
 
       """object Model {
         |  case class A(s: Seq[String], i: Set[Int])
-        |  object A extends HasModelPropertyCreator[A]
+        |  object A {
+        |    implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = Property[Model.A](null).asModel
         |val s = p.subSeq(_.s)
@@ -538,14 +494,18 @@ class PropertyCreatorTest extends UdashCoreTest {
 
       """object Model {
         |  case class A(s: Seq[String], i: Set[Int])
-        |  object A extends HasModelPropertyCreator[A]
+        |  object A {
+        |    implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = Property[Model.A](null).asModel
         |val s = p.subSeq(_.i)""".stripMargin shouldNot compile
 
       """object Model {
         |  case class A(s: Seq[String], i: scala.collection.mutable.Seq[Int])
-        |  object A extends HasModelPropertyCreator[A]
+        |  object A {
+        |    implicit val mpc: ModelPropertyCreator[A] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = Property[Model.A](null).asModel
         |val s = p.subSeq(_.s)
@@ -612,7 +572,9 @@ class PropertyCreatorTest extends UdashCoreTest {
         |    def s: String
         |    def t: T
         |  }
-        |  object T extends HasModelPropertyCreator[T](ModelPropertyCreator.materialize)
+        |  object T {
+        |    implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |  }
         |}
         |val p = Property[Seq[Model.T]](null).asSeq[Model.T]
         |val m: ModelProperty[Model.T] = p.elemProperties.head.asModel
@@ -630,7 +592,9 @@ class PropertyCreatorTest extends UdashCoreTest {
         |    def s: String
         |    def t: T
         |  }
-        |  object T extends HasModelPropertyCreator[T](ModelPropertyCreator.materialize)
+        |  object T {
+        |    implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |  }
         |}
         |
         |val p = Property[Seq[Seq[Model.T]]](null).asSeq[Seq[Model.T]]
@@ -788,20 +752,26 @@ class PropertyCreatorTest extends UdashCoreTest {
     "create complex properties" in {
       """object Model {
         |  case class C(i: Int, s: String)
-        |  object C extends HasModelPropertyCreator[C]
+        |  object C {
+        |    implicit val mpc: ModelPropertyCreator[C] = ModelPropertyCreator.materialize
+        |  }
         |
         |  trait T {
         |    def i: Int
         |    def s: Option[String]
         |    def t: ST
         |  }
-        |  object T extends HasModelPropertyCreator[T]
+        |  object T {
+        |    implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |  }
         |
         |  trait ST {
         |    def c: C
         |    def s: Seq[Char]
         |  }
-        |  object ST extends HasModelPropertyCreator[ST]
+        |  object ST {
+        |    implicit val mpc: ModelPropertyCreator[ST] = ModelPropertyCreator.materialize
+        |  }
         |}
         |
         |val p = Property[Model.T](null).asModel
@@ -811,20 +781,26 @@ class PropertyCreatorTest extends UdashCoreTest {
 
       """object Model {
         |  case class C(i: Int, s: String)
-        |  object C extends HasModelPropertyCreator[C]
+        |  object C {
+        |    implicit val mpc: ModelPropertyCreator[C] = ModelPropertyCreator.materialize
+        |  }
         |
         |  trait T {
         |    def i: Int
         |    def s: Option[String]
         |    def t: ST
         |  }
-        |  object T extends HasModelPropertyCreator[T]
+        |  object T {
+        |    implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |  }
         |
         |  trait ST {
         |    def c: C
         |    def s: List[Char]
         |  }
-        |  object ST extends HasModelPropertyCreator[ST]
+        |  object ST {
+        |    implicit val mpc: ModelPropertyCreator[ST] = ModelPropertyCreator.materialize
+        |  }
         |}
         |
         |val p = Property[Model.T](null).asModel
@@ -840,13 +816,17 @@ class PropertyCreatorTest extends UdashCoreTest {
         |    def s: Option[String]
         |    def t: ST
         |  }
-        |  object T extends HasModelPropertyCreator[T]
+        |  object T {
+        |    implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
+        |  }
         |
         |  trait ST {
         |    def c: C
         |    def s: Seq[Char]
         |  }
-        |  object ST extends HasModelPropertyCreator[ST]
+        |  object ST {
+        |    implicit val mpc: ModelPropertyCreator[ST] = ModelPropertyCreator.materialize
+        |  }
         |}
         |
         |val p = Property[Model.T](null).asModel
@@ -856,14 +836,18 @@ class PropertyCreatorTest extends UdashCoreTest {
 
       """object Model {
         |  case class RestExampleClass(i: Int, s: String, tuple: (Double, String))
-        |  object RestExampleClass extends HasModelPropertyCreator[RestExampleClass]
+        |  object RestExampleClass {
+        |    implicit val mpc: ModelPropertyCreator[RestExampleClass] = ModelPropertyCreator.materialize
+        |  }
         |
         |  trait ExampleModel {
         |    def string: String
         |    def int: Int
         |    def cls: RestExampleClass
         |  }
-        |  object ExampleModel extends HasModelPropertyCreator[ExampleModel]
+        |  object ExampleModel {
+        |    implicit val mpc: ModelPropertyCreator[ExampleModel] = ModelPropertyCreator.materialize
+        |  }
         |}
         |
         |val responsesModel = ModelProperty[Model.ExampleModel](null)""".stripMargin should compile
@@ -874,7 +858,9 @@ class PropertyCreatorTest extends UdashCoreTest {
         |  case object Orange extends Fruit
         |
         |  case class DemoCaseClass(x: String, i: Int)
-        |  object DemoCaseClass extends HasModelPropertyCreator[DemoCaseClass]
+        |  object DemoCaseClass {
+        |    implicit val mpc: ModelPropertyCreator[DemoCaseClass] = ModelPropertyCreator.materialize
+        |  }
         |
         |  trait GenCodecsDemoModel {
         |    def int: Int
@@ -888,7 +874,9 @@ class PropertyCreatorTest extends UdashCoreTest {
         |    def clsVar: Int
         |    def sealedTrait: Fruit
         |  }
-        |  object GenCodecsDemoModel extends HasModelPropertyCreator[GenCodecsDemoModel]
+        |  object GenCodecsDemoModel {
+        |    implicit val mpc: ModelPropertyCreator[GenCodecsDemoModel] = ModelPropertyCreator.materialize
+        |  }
         |}
         |
         |val GenCodecs = ModelProperty[Model.GenCodecsDemoModel](null)""".stripMargin should compile
@@ -956,7 +944,9 @@ class PropertyCreatorTest extends UdashCoreTest {
       """object Test {
         |  class A[T](val a: T)
         |  case class B(x: A[_], y: String)
-        |  object B extends HasModelPropertyCreator[B]
+        |  object B {
+        |    implicit val mpc: ModelPropertyCreator[B] = ModelPropertyCreator.materialize
+        |  }
         |}
         |
         |val t = ModelProperty[Test.B](null)
@@ -969,7 +959,9 @@ class PropertyCreatorTest extends UdashCoreTest {
       """object Test {
         |  class A[T](val a: T)
         |  case class B(x: A[_], y: String, z: Seq[_])
-        |  object B extends HasModelPropertyCreator[B]
+        |  object B {
+        |    implicit val mpc: ModelPropertyCreator[B] = ModelPropertyCreator.materialize
+        |  }
         |}
         |
         |val t = ModelProperty[Test.B](null)
@@ -983,7 +975,9 @@ class PropertyCreatorTest extends UdashCoreTest {
     "work with immutable Seq[_] in model" in {
       """object Test {
         |  case class B(x: String, y: scala.collection.immutable.Seq[_])
-        |  object B extends HasModelPropertyCreator[B]
+        |  object B {
+        |    implicit val mpc: ModelPropertyCreator[B] = ModelPropertyCreator.materialize
+        |  }
         |}
         |
         |val t = ModelProperty[Test.B](null)
diff --git a/core/src/test/scala/io/udash/properties/PropertyTest.scala b/core/src/test/scala/io/udash/properties/PropertyTest.scala
index 67ce3244d..ba6ff024c 100644
--- a/core/src/test/scala/io/udash/properties/PropertyTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyTest.scala
@@ -65,6 +65,27 @@ class PropertyTest extends UdashCoreTest {
 
   def randTT() = newTT(Random.nextInt(20), Some(Random.nextString(5)), new C(Random.nextInt(20), Random.nextString(5)), Random.nextString(20))
 
+  trait M {
+    def x: Double
+    def y: Double
+  }
+  object M extends HasModelPropertyCreator[M] {
+    def apply(_x: Double, _y: Double): M =
+      new M {
+        override def x: Double = _x
+        override def y: Double = _y
+      }
+  }
+
+  case class Bla(s: Seq[_])
+  object Bla extends HasModelPropertyCreator[Bla]
+
+  object Test {
+    class A[G](val a: G)
+    case class B(x: A[_], y: String)
+    object B extends HasModelPropertyCreator[B]
+  }
+
   "Property" should {
     "update value" in {
       val p = Property[Int](5)
@@ -398,18 +419,6 @@ class PropertyTest extends UdashCoreTest {
     }
 
     "combine with other properties (model properties)" in {
-      trait M {
-        def x: Double
-        def y: Double
-      }
-      object M extends HasModelPropertyCreator[M] {
-        def apply(_x: Double, _y: Double): M =
-          new M {
-            override def x: Double = _x
-            override def y: Double = _y
-          }
-      }
-
       val p1 = Property(12)
       val p2 = Property(-2)
 
@@ -1367,9 +1376,9 @@ class PropertyTest extends UdashCoreTest {
       case class CCWithRequire(a: Int, b: Int) {
         require((a > 0 && b > 0) || (a < 0 && b < 0))
       }
-      implicit val propertyCreatorCC: ModelPropertyCreator[CCWithRequire] = MacroModelPropertyCreator.materialize[CCWithRequire].pc
+      implicit val propertyCreatorCC: ModelPropertyCreator[CCWithRequire] = ModelPropertyCreator.materialize[CCWithRequire]
       case class TopModel(child: CCWithRequire)
-      implicit val propertyCreator: ModelPropertyCreator[TopModel] = MacroModelPropertyCreator.materialize[TopModel].pc
+      implicit val propertyCreator: ModelPropertyCreator[TopModel] = ModelPropertyCreator.materialize[TopModel]
 
       val p = ModelProperty[TopModel](TopModel(CCWithRequire(1, 2)))
       val c = p.subModel(_.child)
@@ -1390,12 +1399,12 @@ class PropertyTest extends UdashCoreTest {
         def x: Int
         def y: Int = 5
       }
-      implicit val propertyCreator: ModelPropertyCreator[ModelWithImplDef] = MacroModelPropertyCreator.materialize[ModelWithImplDef].pc
+      implicit val propertyCreator: ModelPropertyCreator[ModelWithImplDef] = ModelPropertyCreator.materialize[ModelWithImplDef]
       trait ModelWithImplVal {
         val x: Int
         val y: Int = 5
       }
-      implicit val propertyCreatorVal: ModelPropertyCreator[ModelWithImplVal] = MacroModelPropertyCreator.materialize[ModelWithImplVal].pc
+      implicit val propertyCreatorVal: ModelPropertyCreator[ModelWithImplVal] = ModelPropertyCreator.materialize[ModelWithImplVal]
 
       val p1 = ModelProperty(null: ModelWithImplDef)
       val p2 = ModelProperty(null: ModelWithImplVal)
@@ -1421,7 +1430,7 @@ class PropertyTest extends UdashCoreTest {
         def withLabel: String =
           s"$userLabel $displayName"
       }
-      implicit val propertyCreator: ModelPropertyCreator[User] = MacroModelPropertyCreator.materialize[User].pc
+      implicit val propertyCreator: ModelPropertyCreator[User] = ModelPropertyCreator.materialize[User]
 
       val p = ModelProperty[User](User("udash", Some("Udash Framework")))
       p.get.withLabel should be("User: Udash Framework")
@@ -1438,9 +1447,9 @@ class PropertyTest extends UdashCoreTest {
 
     "handle empty model property after subProp call" in {
       case class SubTest(x: Int)
-      implicit val propertyCreatorSub: ModelPropertyCreator[SubTest] = MacroModelPropertyCreator.materialize[SubTest].pc
+      implicit val propertyCreatorSub: ModelPropertyCreator[SubTest] = ModelPropertyCreator.materialize[SubTest]
       case class Test(a: SubTest, s: SubTest)
-      implicit val propertyCreator: ModelPropertyCreator[Test] = MacroModelPropertyCreator.materialize[Test].pc
+      implicit val propertyCreator: ModelPropertyCreator[Test] = ModelPropertyCreator.materialize[Test]
 
       val p = ModelProperty(null: Test)
       val sub = p.subModel(_.s)
@@ -1458,12 +1467,12 @@ class PropertyTest extends UdashCoreTest {
       trait SubTest {
         def x: Int
       }
-      implicit val propertyCreatorSub: ModelPropertyCreator[SubTest] = MacroModelPropertyCreator.materialize[SubTest].pc
+      implicit val propertyCreatorSub: ModelPropertyCreator[SubTest] = ModelPropertyCreator.materialize[SubTest]
       trait Test {
         def a: SubTest
         def s: SubTest
       }
-      implicit val propertyCreator: ModelPropertyCreator[Test] = MacroModelPropertyCreator.materialize[Test].pc
+      implicit val propertyCreator: ModelPropertyCreator[Test] = ModelPropertyCreator.materialize[Test]
 
       val p = ModelProperty(null: Test)
       val sub = p.subModel(_.s)
@@ -1479,9 +1488,6 @@ class PropertyTest extends UdashCoreTest {
     }
 
     "handle Seq[_]" in {
-      case class Bla(s: Seq[_])
-      object Bla extends HasModelPropertyCreator[Bla]
-
       val mp = ModelProperty(Bla(Seq(1, 8L)))
       val s = mp.subSeq(_.s)
 
@@ -1544,12 +1550,6 @@ class PropertyTest extends UdashCoreTest {
     }
 
     "work with generic wildcard" in {
-      object Test {
-        class A[G](val a: G)
-        case class B(x: A[_], y: String)
-        object B extends HasModelPropertyCreator[B]
-      }
-
       val t = ModelProperty[Test.B](Test.B(new Test.A("a"), "y"))
       t.subProp(_.x).get.a should be("a")
       t.subProp(_.y).get should be("y")
diff --git a/core/src/test/scala/io/udash/properties/PropertyUsageTest.scala b/core/src/test/scala/io/udash/properties/PropertyUsageTest.scala
index 3d9e6ed5c..2890f9b4a 100644
--- a/core/src/test/scala/io/udash/properties/PropertyUsageTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyUsageTest.scala
@@ -4,9 +4,13 @@ import io.udash.testing.UdashCoreTest
 
 class PropertyUsageTest extends UdashCoreTest {
   // DO NOT REMOVE THESE IMPORTS!
-  import io.udash.properties.single._
   import io.udash.properties.model._
   import io.udash.properties.seq._
+  import io.udash.properties.single._
+
+  trait T {
+    def i: Int
+  }
 
   "CastableProperty" should {
     "allow safe casting to ModelProperty or SeqProperty " in {
@@ -16,12 +20,12 @@ class PropertyUsageTest extends UdashCoreTest {
       """val p = Property[Int](5)
         |val s: SeqProperty[Int, _ <: Property[Int]] = p.asSeq[Int]""".stripMargin shouldNot compile
 
-      """trait T { def a: Int }
-        |object T extends HasModelPropertyCreator[T]
+      """
+        |implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
         |val p = Property[T](null: T)
         |val m: ModelProperty[T] = p.asModel""".stripMargin should compile
 
-      """trait T { def a: Int }
+      """
         |val p = Property[T](null: T)
         |val s: SeqProperty[T, _ <: Property[T]] = p.asSeq[T]""".stripMargin shouldNot compile
 
@@ -31,14 +35,14 @@ class PropertyUsageTest extends UdashCoreTest {
       """val p = Property.blank[Seq[Int]]
         |val s: SeqProperty[Int, _ <: Property[Int]] = p.asSeq[Int]""".stripMargin should compile
 
-      """trait T { def a: Int }
-        |object T extends HasModelPropertyCreator[T]
+      """
+        |implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
         |
         |val p = Property.blank[Seq[T]]
         |val m: ModelProperty[Seq[T]] = p.asModel""".stripMargin shouldNot compile
 
-      """trait T { def a: Int }
-        |object T extends HasModelPropertyCreator[T]
+      """
+        |implicit val mpc: ModelPropertyCreator[T] = ModelPropertyCreator.materialize
         |
         |val p = Property.blank[Seq[T]]
         |val el = p.asSeq[T].elemProperties(0)
@@ -46,62 +50,39 @@ class PropertyUsageTest extends UdashCoreTest {
     }
   }
 
+  object Model {
+    trait T {
+      def i: Int
+      def t: T
+      def s: Seq[String]
+    }
+    object T extends HasModelPropertyCreator[T]
+  }
+
   "ReadableModelProperty" should {
     "grant read only access to subproperties" in {
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |    def s: Seq[String]
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableModelProperty[Model.T] = ModelProperty(null: Model.T)
         |val i: ReadableProperty[Int] = p.roSubProp(_.i)
         |val t: ReadableModelProperty[Model.T] = p.roSubModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.roSubSeq(_.s)
         |""".stripMargin should compile
 
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |    def s: Seq[String]
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableModelProperty[Model.T] = ModelProperty(null: Model.T)
         |val i: Property[Int] = p.roSubProp(_.i)
         |val t: ReadableModelProperty[Model.T] = p.roSubModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.roSubSeq(_.s)
         |""".stripMargin shouldNot compile
 
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |    def s: Seq[String]
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableModelProperty[Model.T] = ModelProperty(null: Model.T)
         |val i: ReadableProperty[Int] = p.roSubProp(_.i)
         |val t: ModelProperty[Model.T] = p.roSubModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.roSubSeq(_.s)
         |""".stripMargin shouldNot compile
 
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |    def s: Seq[String]
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableModelProperty[Model.T] = ModelProperty(null: Model.T)
         |val i: ReadableProperty[Int] = p.roSubProp(_.i)
         |val t: ReadableModelProperty[Model.T] = p.roSubModel(_.t)
@@ -112,60 +93,28 @@ class PropertyUsageTest extends UdashCoreTest {
 
   "ModelProperty" should {
     "grant read&write access to subproperties" in {
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |    def s: Seq[String]
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ModelProperty[Model.T] = ModelProperty(null: Model.T)
         |val i: ReadableProperty[Int] = p.subProp(_.i)
         |val t: ReadableModelProperty[Model.T] = p.subModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.subSeq(_.s)
         |""".stripMargin should compile
 
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |    def s: Seq[String]
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ModelProperty[Model.T] = ModelProperty(null: Model.T)
         |val i: Property[Int] = p.subProp(_.i)
         |val t: ReadableModelProperty[Model.T] = p.subModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.subSeq(_.s)
         |""".stripMargin should compile
 
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |    def s: Seq[String]
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ModelProperty[Model.T] = ModelProperty(null: Model.T)
         |val i: ReadableProperty[Int] = p.subProp(_.i)
         |val t: ModelProperty[Model.T] = p.subModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.subSeq(_.s)
         |""".stripMargin should compile
 
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |    def s: Seq[String]
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ModelProperty[Model.T] = ModelProperty(null: Model.T)
         |val i: ReadableProperty[Int] = p.subProp(_.i)
         |val t: ReadableModelProperty[Model.T] = p.subModel(_.t)
@@ -174,49 +123,38 @@ class PropertyUsageTest extends UdashCoreTest {
     }
   }
 
+  object ClassModel {
+    case class T(i: Int, t: T, s: Seq[String])
+    object T extends HasModelPropertyCreator[T]
+  }
+
   "ReadableModelProperty based on CC" should {
     "grant read only access to subproperties" in {
-      """object Model {
-        |  case class T(i: Int, t: T, s: Seq[String])
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
-        |val p: ReadableModelProperty[Model.T] = ModelProperty(null: Model.T)
+      """
+        |val p: ReadableModelProperty[ClassModel.T] = ModelProperty(null: ClassModel.T)
         |val i: ReadableProperty[Int] = p.roSubProp(_.i)
-        |val t: ReadableModelProperty[Model.T] = p.roSubModel(_.t)
+        |val t: ReadableModelProperty[ClassModel.T] = p.roSubModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.roSubSeq(_.s)
         |""".stripMargin should compile
 
-      """object Model {
-        |  case class T(i: Int, t: T, s: Seq[String])
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
-        |val p: ReadableModelProperty[Model.T] = ModelProperty(null: Model.T)
+      """
+        |val p: ReadableModelProperty[ClassModel.T] = ModelProperty(null: ClassModel.T)
         |val i: Property[Int] = p.roSubProp(_.i)
-        |val t: ReadableModelProperty[Model.T] = p.roSubModel(_.t)
+        |val t: ReadableModelProperty[ClassModel.T] = p.roSubModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.roSubSeq(_.s)
         |""".stripMargin shouldNot compile
 
-      """object Model {
-        |  case class T(i: Int, t: T, s: Seq[String])
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
-        |val p: ReadableModelProperty[Model.T] = ModelProperty(null: Model.T)
+      """
+        |val p: ReadableModelProperty[ClassModel.T] = ModelProperty(null: ClassModel.T)
         |val i: ReadableProperty[Int] = p.roSubProp(_.i)
-        |val t: ModelProperty[Model.T] = p.roSubModel(_.t)
+        |val t: ModelProperty[ClassModel.T] = p.roSubModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.roSubSeq(_.s)
         |""".stripMargin shouldNot compile
 
-      """object Model {
-        |  case class T(i: Int, t: T, s: Seq[String])
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
-        |val p: ReadableModelProperty[Model.T] = ModelProperty(null: Model.T)
+      """
+        |val p: ReadableModelProperty[ClassModel.T] = ModelProperty(null: ClassModel.T)
         |val i: ReadableProperty[Int] = p.roSubProp(_.i)
-        |val t: ReadableModelProperty[Model.T] = p.roSubModel(_.t)
+        |val t: ReadableModelProperty[ClassModel.T] = p.roSubModel(_.t)
         |val s: SeqProperty[String, _ <: ReadableProperty[String]] = p.roSubSeq(_.s)
         |""".stripMargin shouldNot compile
     }
@@ -224,47 +162,31 @@ class PropertyUsageTest extends UdashCoreTest {
 
   "ModelProperty based on CC" should {
     "grant read&write access to subproperties" in {
-      """object Model {
-        |  case class T(i: Int, t: T, s: Seq[String])
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
-        |val p: ModelProperty[Model.T] = ModelProperty(null: Model.T)
+      """
+        |val p: ModelProperty[ClassModel.T] = ModelProperty(null: ClassModel.T)
         |val i: ReadableProperty[Int] = p.subProp(_.i)
-        |val t: ReadableModelProperty[Model.T] = p.subModel(_.t)
+        |val t: ReadableModelProperty[ClassModel.T] = p.subModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.subSeq(_.s)
         |""".stripMargin should compile
 
-      """object Model {
-        |  case class T(i: Int, t: T, s: Seq[String])
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
-        |val p: ModelProperty[Model.T] = ModelProperty(null: Model.T)
+      """
+        |val p: ModelProperty[ClassModel.T] = ModelProperty(null: ClassModel.T)
         |val i: Property[Int] = p.subProp(_.i)
-        |val t: ReadableModelProperty[Model.T] = p.subModel(_.t)
+        |val t: ReadableModelProperty[ClassModel.T] = p.subModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.subSeq(_.s)
         |""".stripMargin should compile
 
-      """object Model {
-        |  case class T(i: Int, t: T, s: Seq[String])
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
-        |val p: ModelProperty[Model.T] = ModelProperty(null: Model.T)
+      """
+        |val p: ModelProperty[ClassModel.T] = ModelProperty(null: ClassModel.T)
         |val i: ReadableProperty[Int] = p.subProp(_.i)
-        |val t: ModelProperty[Model.T] = p.subModel(_.t)
+        |val t: ModelProperty[ClassModel.T] = p.subModel(_.t)
         |val s: ReadableSeqProperty[String, _ <: ReadableProperty[String]] = p.subSeq(_.s)
         |""".stripMargin should compile
 
-      """object Model {
-        |  case class T(i: Int, t: T, s: Seq[String])
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
-        |val p: ModelProperty[Model.T] = ModelProperty(null: Model.T)
+      """
+        |val p: ModelProperty[ClassModel.T] = ModelProperty(null: ClassModel.T)
         |val i: ReadableProperty[Int] = p.subProp(_.i)
-        |val t: ReadableModelProperty[Model.T] = p.subModel(_.t)
+        |val t: ReadableModelProperty[ClassModel.T] = p.subModel(_.t)
         |val s: SeqProperty[String, _ <: ReadableProperty[String]] = p.subSeq(_.s)
         |""".stripMargin should compile
     }
@@ -272,11 +194,7 @@ class PropertyUsageTest extends UdashCoreTest {
 
   "ReadableSeqProperty" should {
     "grant read only access to contained properties" in {
-      """object Model {
-        |  trait T { def i: Int }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableSeqProperty[Model.T, _ <: CastableReadableProperty[Model.T]] = SeqProperty.blank[Model.T]
         |val p2: ReadableSeqProperty[Int, _ <: CastableReadableProperty[Int]] = SeqProperty.blank[Int]
         |val cm: ReadableModelProperty[Model.T] = p.elemProperties(0).asModel
@@ -284,11 +202,7 @@ class PropertyUsageTest extends UdashCoreTest {
         |val c2: ReadableProperty[Int] = p2.elemProperties(0)
         |""".stripMargin should compile
 
-      """object Model {
-        |  trait T { def i: Int }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableSeqProperty[Model.T, _ <: CastableReadableProperty[Model.T]] = SeqProperty.blank[Model.T]
         |val p2: ReadableSeqProperty[Int, _ <: CastableReadableProperty[Int]] = SeqProperty.blank[Int]
         |val cm: ModelProperty[Model.T] = p.elemProperties(0).asModel
@@ -296,11 +210,7 @@ class PropertyUsageTest extends UdashCoreTest {
         |val c2: ReadableProperty[Int] = p2.elemProperties(0)
         |""".stripMargin shouldNot compile
 
-      """object Model {
-        |  trait T { def i: Int }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableSeqProperty[Model.T, _ <: CastableReadableProperty[Model.T]] = SeqProperty.blank[Model.T]
         |val p2: ReadableSeqProperty[Int, _ <: CastableReadableProperty[Int]] = SeqProperty.blank[Int]
         |val cm: ReadableModelProperty[Model.T] = p.elemProperties(0).asModel
@@ -308,11 +218,7 @@ class PropertyUsageTest extends UdashCoreTest {
         |val c2: ReadableProperty[Int] = p2.elemProperties(0)
         |""".stripMargin shouldNot compile
 
-      """object Model {
-        |  trait T { def i: Int }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableSeqProperty[Model.T, _ <: CastableReadableProperty[Model.T]] = SeqProperty.blank[Model.T]
         |val p2: ReadableSeqProperty[Int, _ <: CastableReadableProperty[Int]] = SeqProperty.blank[Int]
         |val cm: ReadableModelProperty[Model.T] = p.elemProperties(0).asModel
@@ -322,27 +228,13 @@ class PropertyUsageTest extends UdashCoreTest {
     }
 
     "allow transformation of elements to ReadableProperty" in {
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableSeqProperty[Model.T, _ <: CastableReadableProperty[Model.T]] = SeqProperty.blank[Model.T]
         |val t: ReadableSeqProperty[Int, ReadableProperty[Int]] = p.transform((el: Model.T) => el.i)
         |p.transform((el: Model.T) => el.t).elemProperties(0).get.i
         |""".stripMargin should compile
 
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableSeqProperty[Model.T, _ <: ReadableProperty[Model.T]] = SeqProperty.blank[Model.T]
         |val t = p.transform((el: Model.T) => el.i)
         |p.transform((el: Model.T) => el.t).elemProperties(0).asModel
@@ -350,27 +242,13 @@ class PropertyUsageTest extends UdashCoreTest {
     }
 
     "allow filtering of elements" in {
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableSeqProperty[Model.T, _ <: CastableReadableProperty[Model.T]] = SeqProperty.blank[Model.T]
         |val t = p.filter((el: Model.T) => el.i % 2 == 0)
         |t.elemProperties(0).asModel
         |""".stripMargin should compile
 
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: ReadableSeqProperty[Model.T, _ <: ReadableProperty[Model.T]] = SeqProperty.blank[Model.T]
         |val t = p.filter((el: Model.T) => el.i % 2 == 0)
         |t.elemProperties(0).asModel
@@ -380,23 +258,14 @@ class PropertyUsageTest extends UdashCoreTest {
 
   "SeqProperty" should {
     "grant read&write access to contained properties" in {
-      """object Model {
-        |  trait T { def i: Int }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
-        |val p = SeqProperty.blank[Model.T]
-        |val p2 = SeqProperty.blank[Int]
-        |val cm: ReadableModelProperty[Model.T] = p.elemProperties(0).asModel
-        |val c: ReadableProperty[Model.T] = p.elemProperties(0)
-        |val c2: ReadableProperty[Int] = p2.elemProperties(0)
-        |""".stripMargin should compile
-
-      """object Model {
-        |  trait T { def i: Int }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """|val p = SeqProperty.blank[Model.T]
+         |val p2 = SeqProperty.blank[Int]
+         |val cm: ReadableModelProperty[Model.T] = p.elemProperties(0).asModel
+         |val c: ReadableProperty[Model.T] = p.elemProperties(0)
+         |val c2: ReadableProperty[Int] = p2.elemProperties(0)
+         |""".stripMargin should compile
+
+      """
         |val p = SeqProperty.blank[Model.T]
         |val p2 = SeqProperty.blank[Int]
         |val cm: ModelProperty[Model.T] = p.elemProperties(0).asModel
@@ -404,11 +273,7 @@ class PropertyUsageTest extends UdashCoreTest {
         |val c2: ReadableProperty[Int] = p2.elemProperties(0)
         |""".stripMargin should compile
 
-      """object Model {
-        |  trait T { def i: Int }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p = SeqProperty.blank[Model.T]
         |val p2 = SeqProperty.blank[Int]
         |val cm: ReadableModelProperty[Model.T] = p.elemProperties(0).asModel
@@ -416,11 +281,7 @@ class PropertyUsageTest extends UdashCoreTest {
         |val c2: ReadableProperty[Int] = p2.elemProperties(0)
         |""".stripMargin should compile
 
-      """object Model {
-        |  trait T { def i: Int }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p = SeqProperty.blank[Model.T]
         |val p2 = SeqProperty.blank[Int]
         |val cm: ReadableModelProperty[Model.T] = p.elemProperties(0).asModel
@@ -430,27 +291,13 @@ class PropertyUsageTest extends UdashCoreTest {
     }
 
     "allow transformation of elements to ReadableProperty" in {
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p = SeqProperty.blank[Model.T]
         |val t = p.transform((el: Model.T) => el.i)
         |p.transform((el: Model.T) => el.t).elemProperties(0).get.i
         |""".stripMargin should compile
 
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p = SeqProperty.blank[Model.T]
         |val t = p.transform((el: Model.T) => el.i)
         |p.transform((el: Model.T) => el.t).elemProperties(0).asModel
@@ -458,27 +305,13 @@ class PropertyUsageTest extends UdashCoreTest {
     }
 
     "allow filtering of elements" in {
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p = SeqProperty.blank[Model.T]
         |val t = p.filter((el: Model.T) => el.i % 2 == 0)
         |t.elemProperties(0).asModel
         |""".stripMargin should compile
 
-      """object Model {
-        |  trait T {
-        |    def i: Int
-        |    def t: T
-        |  }
-        |  object T extends HasModelPropertyCreator[T]
-        |}
-        |
+      """
         |val p: SeqProperty[Model.T, _ <: ReadableProperty[Model.T]] = SeqProperty.blank[Model.T]
         |val t = p.filter((el: Model.T) => el.i % 2 == 0)
         |t.elemProperties(0).asModel
diff --git a/selenium/.js/src/main/scala/io/udash/selenium/views/demos/bootstrap/BootstrapDemos.scala b/selenium/.js/src/main/scala/io/udash/selenium/views/demos/bootstrap/BootstrapDemos.scala
index d15947358..6fed6a550 100644
--- a/selenium/.js/src/main/scala/io/udash/selenium/views/demos/bootstrap/BootstrapDemos.scala
+++ b/selenium/.js/src/main/scala/io/udash/selenium/views/demos/bootstrap/BootstrapDemos.scala
@@ -32,11 +32,10 @@ import io.udash.bootstrap.utils._
 import io.udash.css.CssView
 import io.udash.logging.CrossLogging
 import io.udash.properties.seq.SeqProperty
-import org.scalajs.dom.Element
 import scalatags.JsDom
 
-import scala.concurrent.Future
 import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
 import scala.language.postfixOps
 import scala.util.Random
 
@@ -441,11 +440,25 @@ object BootstrapDemos extends CrossLogging {
     ).render
   }
 
+  sealed trait ShirtSize
+  case object Small extends ShirtSize
+  case object Medium extends ShirtSize
+  case object Large extends ShirtSize
+
+  trait UserModel {
+    def name: String
+    def age: Int
+    def shirtSize: ShirtSize
+  }
+  object UserModel extends HasModelPropertyCreator[UserModel] {
+    implicit val blank: Blank[UserModel] = Blank.Simple(new UserModel {
+      override def name: String = ""
+      override def age: Int = 25
+      override def shirtSize: ShirtSize = Medium
+    })
+  }
+
   def simpleForm(): Element = {
-    sealed trait ShirtSize
-    case object Small extends ShirtSize
-    case object Medium extends ShirtSize
-    case object Large extends ShirtSize
 
     def shirtSizeToLabel(size: ShirtSize): String = size match {
       case Small => "S"
@@ -453,19 +466,6 @@ object BootstrapDemos extends CrossLogging {
       case Large => "L"
     }
 
-    trait UserModel {
-      def name: String
-      def age: Int
-      def shirtSize: ShirtSize
-    }
-    object UserModel extends HasModelPropertyCreator[UserModel] {
-      implicit val blank: Blank[UserModel] = Blank.Simple(new UserModel {
-        override def name: String = ""
-        override def age: Int = 25
-        override def shirtSize: ShirtSize = Medium
-      })
-    }
-
     val user = ModelProperty.blank[UserModel]
     user.subProp(_.age).addValidator(new Validator[Int] {
       override def apply(element: Int): Future[ValidationResult] =
@@ -524,12 +524,13 @@ object BootstrapDemos extends CrossLogging {
     ).render
   }
 
+  trait Panel {
+    def title: String
+    def content: String
+  }
+  object Panel extends HasModelPropertyCreator[Panel]
+
   def navs(): Element = {
-    trait Panel {
-      def title: String
-      def content: String
-    }
-    object Panel extends HasModelPropertyCreator[Panel]
     case class DefaultPanel(override val title: String, override val content: String) extends Panel
 
     val panels = SeqProperty[Panel](

From 9257249337965dd962bc5eb380853f9f46fdbd26 Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Tue, 16 Apr 2019 13:25:34 +0200
Subject: [PATCH 12/21] Cosmetic

---
 .../scala/io/udash/properties/seq/DirectSeqPropertyImpl.scala | 4 ++--
 .../io/udash/properties/seq/SeqPropertyFromSingleValue.scala  | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/main/scala/io/udash/properties/seq/DirectSeqPropertyImpl.scala b/core/src/main/scala/io/udash/properties/seq/DirectSeqPropertyImpl.scala
index 5659a4920..41d7345b7 100644
--- a/core/src/main/scala/io/udash/properties/seq/DirectSeqPropertyImpl.scala
+++ b/core/src/main/scala/io/udash/properties/seq/DirectSeqPropertyImpl.scala
@@ -13,7 +13,7 @@ private[properties] class DirectSeqPropertyImpl[A: PropertyCreator](val parent:
 
   override def replace(idx: Int, amount: Int, values: A*): Unit = {
     val oldProperties = CrossCollections.slice(properties, idx, idx + amount)
-    val newProperties = if (values != null) values.map(value => implicitly[PropertyCreator[A]].newProperty(value, this)) else Seq.empty
+    val newProperties = if (values != null) values.map(value => PropertyCreator[A].newProperty(value, this)) else Seq.empty
 
     CrossCollections.replace(properties, idx, amount, newProperties: _*)
 
@@ -29,7 +29,7 @@ private[properties] class DirectSeqPropertyImpl[A: PropertyCreator](val parent:
   override def setInitValue(t: Seq[A]): Unit = {
     val newProperties = Option(t)
       .getOrElse(Seq.empty)
-      .map(value => implicitly[PropertyCreator[A]].newProperty(value, this))
+      .map(value => PropertyCreator[A].newProperty(value, this))
     properties.insertAll(0, newProperties)
   }
 
diff --git a/core/src/main/scala/io/udash/properties/seq/SeqPropertyFromSingleValue.scala b/core/src/main/scala/io/udash/properties/seq/SeqPropertyFromSingleValue.scala
index b7cf069a4..bf26c7377 100644
--- a/core/src/main/scala/io/udash/properties/seq/SeqPropertyFromSingleValue.scala
+++ b/core/src/main/scala/io/udash/properties/seq/SeqPropertyFromSingleValue.scala
@@ -60,7 +60,7 @@ private[properties] abstract class BaseReadableSeqPropertyFromSingleValue[A, B:
 
     val patch = if (transformed.size > current.size) {
       val added: Seq[CastableProperty[B]] = Seq.tabulate(transformed.size - current.size) { idx =>
-        implicitly[PropertyCreator[B]].newProperty(transformed(current.size + idx), this)
+        PropertyCreator[B].newProperty(transformed(current.size + idx), this)
       }
       CrossCollections.replace(children, commonBegin, 0, added: _*)
       Some(Patch[ElemType](commonBegin, Seq(), added.map(toElemProp), clearsProperty = false))

From df47b9139dc26002b35b9f0cb192378d10e8bbf3 Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Tue, 16 Apr 2019 13:31:54 +0200
Subject: [PATCH 13/21] 2.11 test fix

---
 .../src/test/scala/io/udash/properties/PropertyTest.scala | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/core/src/test/scala/io/udash/properties/PropertyTest.scala b/core/src/test/scala/io/udash/properties/PropertyTest.scala
index ba6ff024c..b9582d4c8 100644
--- a/core/src/test/scala/io/udash/properties/PropertyTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyTest.scala
@@ -1523,13 +1523,9 @@ class PropertyTest extends UdashCoreTest {
     }
 
     "fail on static creator mismatch" in {
-      case class Bla[Type](x: Int, s: String, t: Type)
-      object Bla {
-        implicit def pc[Type: PropertyCreator]: ModelPropertyCreator[Bla[Type]] =
-          ModelPropertyCreator.materialize[Bla[Type]]
-      }
+      case class Clazz[Type](x: Int, s: String, t: Type)
 
-      val p = Property((Bla(5, "asd2", Bla(7, "qwe", 1)), 8, "asd"))
+      val p = Property((Clazz(5, "asd2", Clazz(7, "qwe", 1)), 8, "asd"))
 
       an[IllegalStateException] shouldBe thrownBy(p.asModel(ModelPropertyCreator.materialize))
 

From 212f5ac9bdcf3ab00b2499083371c2a79afbb23a Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Thu, 18 Apr 2019 07:44:08 +0200
Subject: [PATCH 14/21] Cleanup Blank implicits

---
 .../scala/io/udash/properties/Blank.scala     | 82 ++++---------------
 1 file changed, 16 insertions(+), 66 deletions(-)

diff --git a/core/src/main/scala/io/udash/properties/Blank.scala b/core/src/main/scala/io/udash/properties/Blank.scala
index c2a60a0a5..93da02710 100644
--- a/core/src/main/scala/io/udash/properties/Blank.scala
+++ b/core/src/main/scala/io/udash/properties/Blank.scala
@@ -13,76 +13,26 @@ trait Blank[A] {
   def value: A
 }
 
-object Blank extends LowPrioImplicits {
+object Blank {
   def apply[A](implicit ev: Blank[A]): Blank[A] = ev
-  
-  case class Simple[A](value: A) extends AbstractCase with Blank[A]
-  case class Factory[A](factory: () => A) extends AbstractCase with Blank[A] {
+
+  final case class Simple[A](value: A) extends AbstractCase with Blank[A]
+  final case class Factory[A](factory: () => A) extends AbstractCase with Blank[A] {
     override def value: A = factory()
   }
 
-  implicit val double: Blank[Double] = Simple(0.0)
-  implicit val float: Blank[Float] = Simple(0.0f)
-  implicit val long: Blank[Long] = Simple(0L)
-  implicit val int: Blank[Int] = Simple(0)
-  implicit val short: Blank[Short] = Simple(0)
-  implicit val byte: Blank[Byte] = Simple(0)
-  implicit val boolean: Blank[Boolean] = Simple(false)
-  implicit val unit: Blank[Unit] = Simple(())
-  implicit val string: Blank[String] = Simple("")
+  implicit val Double: Blank[Double] = Simple(0.0)
+  implicit val Float: Blank[Float] = Simple(0.0f)
+  implicit val Long: Blank[Long] = Simple(0L)
+  implicit val Int: Blank[Int] = Simple(0)
+  implicit val Short: Blank[Short] = Simple(0)
+  implicit val Byte: Blank[Byte] = Simple(0)
+  implicit val Boolean: Blank[Boolean] = Simple(false)
+  implicit val Unit: Blank[Unit] = Simple(())
+  implicit val String: Blank[String] = Simple("")
 
-  private val simpleNone = Simple(None)
-  implicit def option[A]: Blank[Option[A]] = simpleNone.asInstanceOf[Blank[Option[A]]]
-  private val simpleOptEmpty = Simple(Opt.Empty)
-  implicit def opt[A]: Blank[Opt[A]] = simpleOptEmpty.asInstanceOf[Blank[Opt[A]]]
-  private val simpleMapEmpty = Simple(Map.empty)
-  implicit def map[K, V]: Blank[Map[K, V]] = simpleMapEmpty.asInstanceOf[Blank[Map[K, V]]]
+  implicit def option[A]: Blank[Option[A]] = Simple(None)
+  implicit def opt[A]: Blank[Opt[A]] = Simple(Opt.Empty)
+  implicit def map[K, V]: Blank[Map[K, V]] = Simple(Map.empty)
   implicit def traversable[T, A[_] <: Traversable[_]](implicit ev: CanBuildFrom[Nothing, T, A[T]]): Blank[A[T]] = Simple(Seq.empty[T].to[A])
-}
-
-trait LowPrioImplicits { this: Blank.type =>
-  implicit def tuple1[T: Blank]: Blank[Tuple1[T]] =
-    Blank.Simple(Tuple1(Blank[T].value))
-  implicit def tuple2[T1: Blank, T2: Blank]: Blank[(T1, T2)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value))
-  implicit def tuple3[T1: Blank, T2: Blank, T3: Blank]: Blank[(T1, T2, T3)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value))
-  implicit def tuple4[T1: Blank, T2: Blank, T3: Blank, T4: Blank]: Blank[(T1, T2, T3, T4)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value))
-  implicit def tuple5[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank]: Blank[(T1, T2, T3, T4, T5)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value))
-  implicit def tuple6[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank]: Blank[(T1, T2, T3, T4, T5, T6)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value))
-  implicit def tuple7[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value))
-  implicit def tuple8[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value))
-  implicit def tuple9[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value))
-  implicit def tuple10[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value))
-  implicit def tuple11[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value))
-  implicit def tuple12[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value))
-  implicit def tuple13[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value))
-  implicit def tuple14[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value))
-  implicit def tuple15[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value))
-  implicit def tuple16[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value))
-  implicit def tuple17[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value))
-  implicit def tuple18[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank, T18: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value, Blank[T18].value))
-  implicit def tuple19[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank, T18: Blank, T19: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value, Blank[T18].value, Blank[T19].value))
-  implicit def tuple20[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank, T18: Blank, T19: Blank, T20: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value, Blank[T18].value, Blank[T19].value, Blank[T20].value))
-  implicit def tuple21[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank, T18: Blank, T19: Blank, T20: Blank, T21: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value, Blank[T18].value, Blank[T19].value, Blank[T20].value, Blank[T21].value))
-  implicit def tuple22[T1: Blank, T2: Blank, T3: Blank, T4: Blank, T5: Blank, T6: Blank, T7: Blank, T8: Blank, T9: Blank, T10: Blank, T11: Blank, T12: Blank, T13: Blank, T14: Blank, T15: Blank, T16: Blank, T17: Blank, T18: Blank, T19: Blank, T20: Blank, T21: Blank, T22: Blank]: Blank[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)] =
-    Blank.Simple((Blank[T1].value, Blank[T2].value, Blank[T3].value, Blank[T4].value, Blank[T5].value, Blank[T6].value, Blank[T7].value, Blank[T8].value, Blank[T9].value, Blank[T10].value, Blank[T11].value, Blank[T12].value, Blank[T13].value, Blank[T14].value, Blank[T15].value, Blank[T16].value, Blank[T17].value, Blank[T18].value, Blank[T19].value, Blank[T20].value, Blank[T21].value, Blank[T22].value))
 }
\ No newline at end of file

From c1e9f43dfb7adba0193d6c0a95823ace1f729f1f Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Thu, 18 Apr 2019 07:48:58 +0200
Subject: [PATCH 15/21] Cache basic PC implicits

---
 .../main/scala/io/udash/properties/PropertyCreator.scala | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/core/src/main/scala/io/udash/properties/PropertyCreator.scala b/core/src/main/scala/io/udash/properties/PropertyCreator.scala
index c8f73ba5e..03bbbe8b0 100644
--- a/core/src/main/scala/io/udash/properties/PropertyCreator.scala
+++ b/core/src/main/scala/io/udash/properties/PropertyCreator.scala
@@ -25,6 +25,15 @@ object PropertyCreator extends PropertyCreatorImplicits {
   def apply[T](implicit ev: PropertyCreator[T]): PropertyCreator[T] = ev
 
   def newID(): PropertyId = PropertyIdGenerator.next()
+
+  implicit val Double: PropertyCreator[Double] = new SinglePropertyCreator[Double]
+  implicit val Float: PropertyCreator[Float] = new SinglePropertyCreator[Float]
+  implicit val Long: PropertyCreator[Long] = new SinglePropertyCreator[Long]
+  implicit val Int: PropertyCreator[Int] = new SinglePropertyCreator[Int]
+  implicit val Short: PropertyCreator[Short] = new SinglePropertyCreator[Short]
+  implicit val Byte: PropertyCreator[Byte] = new SinglePropertyCreator[Byte]
+  implicit val Boolean: PropertyCreator[Boolean] = new SinglePropertyCreator[Boolean]
+  implicit val String: PropertyCreator[String] = new SinglePropertyCreator[String]
 }
 
 class SinglePropertyCreator[T] extends PropertyCreator[T] {

From 43634af0f7a2332d9b345e0c4b111138fa21df50 Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Wed, 24 Apr 2019 15:43:26 +0200
Subject: [PATCH 16/21] Cosmetic PR changes

---
 .../properties/PropertyCreatorImplicits.scala      |  2 +-
 .../udash/properties/single/CastableProperty.scala | 14 ++++++++------
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala b/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
index 27ce54898..7ce60818d 100644
--- a/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
+++ b/core/src/main/scala/io/udash/properties/PropertyCreatorImplicits.scala
@@ -1,6 +1,6 @@
 package io.udash.properties
 
-trait PropertyCreatorImplicitsLow { this: PropertyCreatorImplicits =>
+trait PropertyCreatorImplicitsLow { this: PropertyCreator.type =>
   implicit def materializeSingle[T]: PropertyCreator[T] = new SinglePropertyCreator[T]
 }
 
diff --git a/core/src/main/scala/io/udash/properties/single/CastableProperty.scala b/core/src/main/scala/io/udash/properties/single/CastableProperty.scala
index b3a56936a..80b65a7ba 100644
--- a/core/src/main/scala/io/udash/properties/single/CastableProperty.scala
+++ b/core/src/main/scala/io/udash/properties/single/CastableProperty.scala
@@ -24,17 +24,19 @@ trait CastableReadableProperty[A] extends ReadableProperty[A] {
 trait CastableProperty[A] extends CastableReadableProperty[A] with Property[A] {
   /** Safely casts `DirectProperty[A]` to `ModelProperty[A]` */
   override def asModel(implicit ev: ModelPropertyCreator[A]): ModelProperty[A] = {
-    if (!this.isInstanceOf[ModelProperty[A]])
-      throw new IllegalStateException("Property was created without provided ModelPropertyCreator in scope. " +
+    this match {
+      case mp: ModelProperty[A] => mp
+      case _ => throw new IllegalStateException("Property was created without provided ModelPropertyCreator in scope. " +
         "Make sure it is uniformly available, e.g. in the companion object of the model class.")
-    this.asInstanceOf[ModelProperty[A]]
+    }
   }
 
   /** Safely casts `DirectProperty[Seq[A]]` to `DirectSeqProperty[A]` */
   override def asSeq[B](implicit sev: A <:< Seq[B], ev: SeqPropertyCreator[B]): SeqProperty[B, CastableProperty[B]] = {
-    if (!this.isInstanceOf[SeqProperty[_, _]])
-      throw new IllegalStateException("Property was created without provided SeqPropertyCreator in scope. " +
+    this match {
+      case sp: this.type with SeqProperty[_, _] => sp.asInstanceOf[SeqProperty[B, CastableProperty[B]]]
+      case _ => throw new IllegalStateException("Property was created without provided SeqPropertyCreator in scope. " +
         "Make sure not to explicitly pass creators on property creation.")
-    this.asInstanceOf[SeqProperty[B, CastableProperty[B]]]
+    }
   }
 }

From f8c28fe40e4f522f65d3cd3c043f39714f6c3320 Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Wed, 24 Apr 2019 15:44:25 +0200
Subject: [PATCH 17/21] Add test for different Seq parameterization schemes

---
 .../io/udash/properties/PropertyTest.scala      | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/core/src/test/scala/io/udash/properties/PropertyTest.scala b/core/src/test/scala/io/udash/properties/PropertyTest.scala
index b9582d4c8..eae2d163a 100644
--- a/core/src/test/scala/io/udash/properties/PropertyTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyTest.scala
@@ -2922,6 +2922,23 @@ class PropertyTest extends UdashCoreTest {
       numbers.remove(-1)
       indexed.get should be(numbers.get.zipWithIndex)
     }
+
+    "handle Seq subclasses with different type parameterization scheme" in {
+      val mp = ModelProperty(WeirdSeqModel(Vector("1") /*Vector(1), Vector("def")*/))
+      println(mp.get)
+    }
+  }
+
+  type SeqAlias[A] = Seq[A]
+  type IntSeq[A] = Seq[Int]
+  type WeirdSeq[A, B] = Seq[B]
+  case class WeirdSeqModel(
+    //s1: SeqAlias[String],
+    //s2: IntSeq[String],
+    s3: WeirdSeq[Int, String],
+  )
+  object WeirdSeqModel {
+    implicit val mpc: ModelPropertyCreator[WeirdSeqModel] = ModelPropertyCreator.materialize
   }
 
   "Seq[Property]" should {

From c36787546a565196dff1ca5af8527b5408628d0c Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Wed, 24 Apr 2019 16:20:19 +0200
Subject: [PATCH 18/21] Partial fix for Seq aliases

---
 .../io/udash/properties/PropertyTest.scala    | 19 ++++++++++++-------
 .../io/udash/macros/PropertyMacros.scala      | 11 ++++++++---
 2 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/core/src/test/scala/io/udash/properties/PropertyTest.scala b/core/src/test/scala/io/udash/properties/PropertyTest.scala
index eae2d163a..7e9ed19e1 100644
--- a/core/src/test/scala/io/udash/properties/PropertyTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyTest.scala
@@ -2923,22 +2923,27 @@ class PropertyTest extends UdashCoreTest {
       indexed.get should be(numbers.get.zipWithIndex)
     }
 
-    "handle Seq subclasses with different type parameterization scheme" in {
-      val mp = ModelProperty(WeirdSeqModel(Vector("1") /*Vector(1), Vector("def")*/))
-      println(mp.get)
+    "handle Seq aliases" in {
+      val mp = ModelProperty(WeirdSeqModel(Vector("abc"), Vector("def"), Vector(1) /*, Vector("123")*/))
+      println(mp.subSeq(_.s1).get.head.length)
+      println(mp.subSeq(_.s2).get.head.length)
+      println(mp.subSeq(_.s3).get.head + 2)
+      //println(mp.subSeq(_.s4).get.head.length)
     }
   }
 
   type SeqAlias[A] = Seq[A]
+  type VectorAlias[A] = Vector[A]
   type IntSeq[A] = Seq[Int]
   type WeirdSeq[A, B] = Seq[B]
   case class WeirdSeqModel(
-    //s1: SeqAlias[String],
-    //s2: IntSeq[String],
-    s3: WeirdSeq[Int, String],
+    s1: SeqAlias[String],
+    s2: VectorAlias[String],
+    s3: IntSeq[String],
+    //s4: WeirdSeq[Int, String],
   )
   object WeirdSeqModel {
-    implicit val mpc: ModelPropertyCreator[WeirdSeqModel] = ModelPropertyCreator.materialize
+    implicit val mpc: ModelPropertyCreator[WeirdSeqModel] = ModelPropertyCreator.materialize[WeirdSeqModel]
   }
 
   "Seq[Property]" should {
diff --git a/macros/src/main/scala/io/udash/macros/PropertyMacros.scala b/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
index 35923c9ae..9f8bfbf49 100644
--- a/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
+++ b/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
@@ -206,7 +206,8 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
   private def generateModelProperty(tpe: Type): c.Tree = {
     def reifySeqTpe(tpe: Type): Type = {
       if (tpe <:< SeqTpe) {
-        getType(tq"$ScalaPkg.Seq[${tpe.typeArgs.head}]")
+        val dealiased = tpe.map(_.dealias)
+        getType(tq"$ScalaPkg.Seq[${dealiased.typeArgs.head}]")
       } else tpe
     }
 
@@ -219,7 +220,10 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
           case (name, returnTpe) =>
             val reifiedReturnTpe = reifySeqTpe(returnTpe)
             val reifiedCreatorTpe = getType(
-              if (tpe <:< SeqTpe) tq"$SeqPropertyCreatorCls[${tpe.typeArgs.head}]"
+              if (tpe <:< SeqTpe) {
+                val dealias = tpe.map(_.dealias)
+                tq"$SeqPropertyCreatorCls[${dealias.typeArgs.head}]"
+              }
               else tq"$PropertyCreatorCls[$reifiedReturnTpe]"
             )
 
@@ -362,7 +366,8 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
 
     def genTree(source: List[(Type, TermName)], targetTree: Tree): Tree = source match {
       case (resultType, term) :: _ if resultType.typeConstructor <:< SeqTpe.typeConstructor =>
-        q"""$targetTree.getSubSeq[${resultType.typeArgs.head}](${q"_.$term"}, ${term.decodedName.toString})"""
+        val dealiased = resultType.map(_.dealias)
+        q"""$targetTree.getSubSeq[${dealiased.typeArgs.head}](${q"_.$term"}, ${term.decodedName.toString})"""
       case (resultType, term) :: Nil if hasModelPropertyCreator(resultType) =>
         q"""$targetTree.getSubModel[$resultType](${q"_.$term"}, ${term.decodedName.toString})"""
       case (resultType, term) :: tail if hasModelPropertyCreator(resultType) =>

From e390b528b261fb99bb6d55b9ed21c0b80d2fc37b Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Fri, 26 Apr 2019 14:05:07 +0200
Subject: [PATCH 19/21] Handle Seq aliases in model properties

---
 .../io/udash/properties/PropertyTest.scala    | 16 +++++++--------
 .../io/udash/macros/PropertyMacros.scala      | 20 +++++++++++--------
 2 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/core/src/test/scala/io/udash/properties/PropertyTest.scala b/core/src/test/scala/io/udash/properties/PropertyTest.scala
index 7e9ed19e1..ef2b14292 100644
--- a/core/src/test/scala/io/udash/properties/PropertyTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyTest.scala
@@ -2924,11 +2924,11 @@ class PropertyTest extends UdashCoreTest {
     }
 
     "handle Seq aliases" in {
-      val mp = ModelProperty(WeirdSeqModel(Vector("abc"), Vector("def"), Vector(1) /*, Vector("123")*/))
-      println(mp.subSeq(_.s1).get.head.length)
-      println(mp.subSeq(_.s2).get.head.length)
-      println(mp.subSeq(_.s3).get.head + 2)
-      //println(mp.subSeq(_.s4).get.head.length)
+      val mp = ModelProperty(WeirdSeqModel(Vector("abc"), Vector("def"), Vector(1), Vector("123")))
+      mp.subSeq(_.s1).get.head shouldBe "abc"
+      mp.subSeq(_.s2).get.head shouldBe "def"
+      mp.subSeq(_.s3).get.head shouldBe 1
+      mp.subSeq(_.s4).get.head shouldBe "123"
     }
   }
 
@@ -2940,11 +2940,9 @@ class PropertyTest extends UdashCoreTest {
     s1: SeqAlias[String],
     s2: VectorAlias[String],
     s3: IntSeq[String],
-    //s4: WeirdSeq[Int, String],
+    s4: WeirdSeq[Int, String],
   )
-  object WeirdSeqModel {
-    implicit val mpc: ModelPropertyCreator[WeirdSeqModel] = ModelPropertyCreator.materialize[WeirdSeqModel]
-  }
+  object WeirdSeqModel extends HasModelPropertyCreator[WeirdSeqModel]
 
   "Seq[Property]" should {
     "combine into ReadableSeqProperty" in {
diff --git a/macros/src/main/scala/io/udash/macros/PropertyMacros.scala b/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
index 9f8bfbf49..cda2ffdd0 100644
--- a/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
+++ b/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
@@ -264,11 +264,14 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
             ..${
           order.map { name =>
             val returnTpe = members(name)
+            val dealiasedReturnType = returnTpe.map(_.dealias)
             val reifiedReturnTpe = reifySeqTpe(returnTpe)
-            if (returnTpe <:< SeqTpe && reifiedReturnTpe != returnTpe)
-              q"""getSubProperty[$reifiedReturnTpe](${q"_.$name"}, ${name.toString}).get.to[${returnTpe.typeConstructor}]"""
-            else
+            if (returnTpe <:< SeqTpe && reifiedReturnTpe != returnTpe) {
+              q"""getSubProperty[$reifiedReturnTpe](${q"_.$name"}, ${name.toString}).get.to[${dealiasedReturnType.typeConstructor}]"""
+            }
+            else {
               q"""getSubProperty[$returnTpe](${q"_.$name"}, ${name.toString}).get"""
+            }
           }
         }
           )
@@ -282,14 +285,15 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
             ..${
           members.map { case (name, returnTpe) =>
             val reifiedReturnTpe = reifySeqTpe(returnTpe)
-            if (returnTpe <:< SeqTpe && reifiedReturnTpe != returnTpe)
-              q"""override val $name: $returnTpe = getSubProperty[$reifiedReturnTpe](${q"_.$name"}, ${name.toString}).get.to[${returnTpe.typeConstructor}]"""
-            else
+            val dealiasedReturnType = returnTpe.map(_.dealias)
+            if (returnTpe <:< SeqTpe && reifiedReturnTpe != returnTpe) {
+              q"""override val $name: $returnTpe = getSubProperty[$reifiedReturnTpe](${q"_.$name"}, ${name.toString}).get.to[${dealiasedReturnType.typeConstructor}]"""
+            } else {
               q"""override val $name: $returnTpe = getSubProperty[$returnTpe](${q"_.$name"}, ${name.toString}).get"""
+            }
           }
         }
-          }
-        """
+        }"""
       )
     }
   }

From 42df155c71ab049097252b36567d3318e5b663ff Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Fri, 26 Apr 2019 15:09:39 +0200
Subject: [PATCH 20/21] Better support for different type parameterization
 schemes

---
 .../scala/io/udash/properties/PropertyTest.scala  |  6 +++---
 .../scala/io/udash/macros/PropertyMacros.scala    | 15 +++------------
 2 files changed, 6 insertions(+), 15 deletions(-)

diff --git a/core/src/test/scala/io/udash/properties/PropertyTest.scala b/core/src/test/scala/io/udash/properties/PropertyTest.scala
index ef2b14292..a75f7a744 100644
--- a/core/src/test/scala/io/udash/properties/PropertyTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyTest.scala
@@ -2924,7 +2924,7 @@ class PropertyTest extends UdashCoreTest {
     }
 
     "handle Seq aliases" in {
-      val mp = ModelProperty(WeirdSeqModel(Vector("abc"), Vector("def"), Vector(1), Vector("123")))
+      val mp = ModelProperty(AliasedSeqModel(Vector("abc"), Vector("def"), Vector(1), Vector("123")))
       mp.subSeq(_.s1).get.head shouldBe "abc"
       mp.subSeq(_.s2).get.head shouldBe "def"
       mp.subSeq(_.s3).get.head shouldBe 1
@@ -2936,13 +2936,13 @@ class PropertyTest extends UdashCoreTest {
   type VectorAlias[A] = Vector[A]
   type IntSeq[A] = Seq[Int]
   type WeirdSeq[A, B] = Seq[B]
-  case class WeirdSeqModel(
+  case class AliasedSeqModel(
     s1: SeqAlias[String],
     s2: VectorAlias[String],
     s3: IntSeq[String],
     s4: WeirdSeq[Int, String],
   )
-  object WeirdSeqModel extends HasModelPropertyCreator[WeirdSeqModel]
+  object AliasedSeqModel extends HasModelPropertyCreator[AliasedSeqModel]
 
   "Seq[Property]" should {
     "combine into ReadableSeqProperty" in {
diff --git a/macros/src/main/scala/io/udash/macros/PropertyMacros.scala b/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
index cda2ffdd0..c83e61206 100644
--- a/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
+++ b/macros/src/main/scala/io/udash/macros/PropertyMacros.scala
@@ -16,7 +16,6 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
   val SinglePropertyCreatorCls = tq"$Package.SinglePropertyCreator"
   val PropertyCreatorCompanion = q"$Package.PropertyCreator"
   val ModelPropertyCreatorCls = tq"$Package.ModelPropertyCreator"
-  val MacroModelPropertyCreatorCls = tq"$Package.MacroModelPropertyCreator"
 
   val ReadablePropertyCls = tq"$Package.single.ReadableProperty"
   val CastableReadablePropertyCls = tq"$Package.single.CastableReadableProperty"
@@ -206,7 +205,7 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
   private def generateModelProperty(tpe: Type): c.Tree = {
     def reifySeqTpe(tpe: Type): Type = {
       if (tpe <:< SeqTpe) {
-        val dealiased = tpe.map(_.dealias)
+        val dealiased = tpe.map(_.dealias).baseType(SeqTpe.typeSymbol)
         getType(tq"$ScalaPkg.Seq[${dealiased.typeArgs.head}]")
       } else tpe
     }
@@ -221,8 +220,8 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
             val reifiedReturnTpe = reifySeqTpe(returnTpe)
             val reifiedCreatorTpe = getType(
               if (tpe <:< SeqTpe) {
-                val dealias = tpe.map(_.dealias)
-                tq"$SeqPropertyCreatorCls[${dealias.typeArgs.head}]"
+                val dealiased = tpe.map(_.dealias).baseType(SeqTpe.typeSymbol)
+                tq"$SeqPropertyCreatorCls[${dealiased.typeArgs.head}]"
               }
               else tq"$PropertyCreatorCls[$reifiedReturnTpe]"
             )
@@ -397,14 +396,6 @@ class PropertyMacros(val ctx: blackbox.Context) extends AbstractMacroCommons(ctx
     }"""
   }
 
-  def reifyMacroModelPropertyCreator[A: c.WeakTypeTag](ev: c.Tree): c.Tree = {
-    q"""
-      new $MacroModelPropertyCreatorCls(
-        ${reifyModelPropertyCreator[A](ev)}
-      )
-    """
-  }
-
   def checkModelPropertyTemplate[A: c.WeakTypeTag]: c.Tree = {
     val tpe = weakTypeOf[A]
     if (doesMeetTraitModelRequirements(tpe) || doesMeetClassModelRequirements(tpe)) q"new $IsModelPropertyTemplateCls[$tpe]"

From 35a17947a06dac1de9d1c5c0b99d173040f42caa Mon Sep 17 00:00:00 2001
From: ddworak <dawid.dworak@gmail.com>
Date: Fri, 26 Apr 2019 15:23:31 +0200
Subject: [PATCH 21/21] 2.11 fix

---
 core/src/test/scala/io/udash/properties/PropertyTest.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/test/scala/io/udash/properties/PropertyTest.scala b/core/src/test/scala/io/udash/properties/PropertyTest.scala
index a75f7a744..ac1cc920d 100644
--- a/core/src/test/scala/io/udash/properties/PropertyTest.scala
+++ b/core/src/test/scala/io/udash/properties/PropertyTest.scala
@@ -2940,7 +2940,7 @@ class PropertyTest extends UdashCoreTest {
     s1: SeqAlias[String],
     s2: VectorAlias[String],
     s3: IntSeq[String],
-    s4: WeirdSeq[Int, String],
+    s4: WeirdSeq[Int, String]
   )
   object AliasedSeqModel extends HasModelPropertyCreator[AliasedSeqModel]