How to validate related properties

[davidmoshal]

Promising library, but examples are only given for the simplest case, namely validating individual properties.
Question: can this library be used to validate related properties.

Take the following example:

data class Foo(val bar:String, val baz:String)

How would one determine if bar and baz are both non-zero numbers, and
also that bar x baz is less than, say, 100 ?

Ideally one would be able to convert the individual properties into their typed representations, and then use them subsequently.

For example something like this (pseudo code):

val spec = validationSpec {
       constraints<Foo> {
         val bar:Long = property(Foo::bar) {
             min(0)
         }

         val baz:Long = property(Foo::bar) {
             min(0)
         }
  
        validate("total", {bar * baz} ){
             min(total, 0)
        }
     }
 }

ie: if bar and baz are invalid, then the subsequent calculation won't be run, otherwise it runs, with the values guaranteed to be valid.

[byteground]

+1 @davidmoshal

[clojj]

+1
this seems like a somewhat related workaround to me: #4 (comment)

[clojj]

Promising library, but examples are only given for the simplest case, namely validating individual properties.

Question: can this library be used to validate related properties.

Take the following example:

data class Foo(val bar:String, val baz:String)

How would one determine if bar and baz are both non-zero numbers, and

also that bar x baz is less than, say, 100 ?

Ideally one would be able to convert the individual properties into their typed representations, and then use them subsequently.

For example something like this (pseudo code):

val spec = validationSpec {

       constraints<Foo> {

         val bar:Long = property(Foo::bar) {

             min(0)

         }



         val baz:Long = property(Foo::bar) {

             min(0)

         }

  

        validate("total", {bar * baz} ){

             min(total, 0)

        }

     }

 }

ie: if bar and baz are invalid, then the subsequent calculation won't be run, otherwise it runs, with the values guaranteed to be valid.

Hi, Kalidation is nice because it returns Validated, a powerful arrow type.
I think for any such case, we can just use Validated's combinators like this https://arrow-kt.io/docs/apidocs/arrow-core/arrow.core/-validated/#improving-the-validation

[clojj]

So just to give some silly example, in which a 3rd validation only checks, when the 2 validations it depends upon are valid cases:

    val specFoo = validationSpec {
        constraints<Foo> {
            property(Foo::foo) {
                notBlank()
                inValues("GREEN", "WHITE")
            }
        }
    }

    val specBar = validationSpec {
        constraints<Bar> {
            property(Bar::bar) {
                notBlank()
                inValues("CYAN", "BLACK")
            }
        }
    }

    val foo = Foo("GREEN")
    val bar = Bar("BLAC")

    val validFoo: Validated<Nel<String>, Foo> = specFoo.validateNel(foo)
    val validBar: Validated<Nel<String>, Bar> = specBar.validateNel(bar)

    validFoo.zip(validBar) { a, b ->
        if (a.foo == "GREEN" && b.bar == "BLACK")
            "must be green and cyan".nel().invalid()
        else Pair(a, b).valid()