I think the answer to this is no but just in case I want to

Question

I think the answer to this is no but just in case I want to write this extension function on the jOOQ SQL DSL ```fun lt R Record gt SelectConditionStep lt R gt andIf check gt Boolean clause gt Condition SelectConditionStep lt R gt = if check this and clause else this``` The idea is you can do something like this ```val name String = TODO val maybeId Id = TODO dsl select MY TABLE fields from MY TABLE where MY TABLE NAME eq name andIf maybeId = null MY TABLE COLLECTION ID eq maybeId value fetch ``` but of course the compiler cannot infer that `maybeId` is not null in the second lambda could a custom contract make it possible for the compiler to work this out

Rob Elliot · Answer

It s basically meant to be a more readable form of this ```val name String = TODO val maybeId Id = TODO dsl select MY TABLE fields from MY TABLE where MY TABLE NAME eq name run if catalogueId = null and MY TABLE COLLECTION ID eq maybeId value else this fetch ``` where the compiler can do the smart cast but the `run` and the `if` and the `else` rather obscure the legibility of the DSL

Rob Elliot · Answer

There s a less flexible version which does work ```fun lt R Record T Any gt SelectConditionStep lt R gt andIf nullable T clause T gt Condition SelectConditionStep lt R gt = nullable let notNull gt this and clause notNull this``` but apart from being less flexible it s also a bit more implicit I like the explicitness of the first one where it s completely explicit inline that the check is for the nullness

David Kubecka · Answer

I would use this ^ but with `takeIf` e g ```something takeIf check let clause something ```

Rob Elliot · Answer

But at that point I m up to three arguments to `andIf` and I m still constrained to there just being the one argument that can be cast from nullable to not null

Rob Elliot · Answer

I was sort of hoping there might be a way to state in a contract that anything the compiler can infer from `check` returning `true` can be assumed to be true in the lambda passed as `clause`

David Kubecka · Answer

It depends on how flexible you want your `andIf` to be If you want to pass 1 any value 2 perform an arbitrary check on it and 3 if that check succeeds do something with the value I think you need those 3 parameters But you are talking specifically about nullability checks so not sure how generic you want that to be

David Kubecka · Answer

Anyway I do not know whether how your original `check` and `clause` parameters can share a contract disappointed

Rob Elliot · Answer

This isn t too bad ```fun lt R Record gt SelectOnConditionStep lt R gt and clause gt Condition SelectOnConditionStep lt R gt val maybeCondition = clause return if maybeCondition = null and maybeCondition else this dsl select MY TABLE fields from MY TABLE where MY TABLE NAME eq name and if maybeId = null MY TABLE COLLECTION ID eq maybeId value else null fetch ``` Shame about that ugly little `else null` at the end guess we d need partial application to avoid that though

David Kubecka · Answer

I see now that you were concerned with the implicitness of your previous solution So why not solve it with proper naming e g `andIfNotNull maybeId MY TABLE COLLECTION ID eq maybeId value ` Or are there also functional concerns

Rob Elliot · Answer

It would have to be `andIfNotNull maybeId id gt MY TABLE COLLECTION ID eq id value `

Rob Elliot · Answer

It s more that it s inflexible it accepts one parameter checks for one condition and does one smart cast With my latest version I can do arbitrary checks on N parameters benefitting from smart casting ``` and if x is String amp amp y = null MY TABLE COLLECTION ID eq $x $y else null ```

Rob Elliot · Answer

Oh of course I could do ` and maybeId run MY TABLE COLLECTION ID eq maybeId value ` to lose the ugly `else null` Though it feels a bit less legible

dmitriy.novozhilov · Answer

Rob Elliot · Answer

Thanks voted

dmitriy.novozhilov · Answer

I really hope to implement it in Kotlin 2 1