A modern programming language that makes developers happier.

kotlinlang

Sounds like conflating layers to me… your request has nullable fields; your domain model does not

yes, request has nulls, and I want in response to write that `baz` and `bar` fields are required

But Kotlin throw an execption when pass null to not nullable, so we fail at first field, and can write only about 1 field at once

the desired result will be to write about both fields

Non-Nullable types are not for user-input validation. If there is a possibility that `null` can come in from the outside world, the type in kotlin must be nullable. Validation is a separate step.

if field is nullable, I will have to check field if it is not null everytime I want to use it, but it was already validated at some step

Yes, unfortunately Kotlin's type system is not as rich as e.g. TypeScript's. That would allow you express something like that

The way to do it would be to have _two_ versions of your data classes, one that is not validated and one that is validated.
Then you can also introduce domain classes like `Email`.

Do you have an example of TypeScript in such cases?

I don't want 2 classes, why is it not ok to disable null checks in this only for module with such classes, in these classes validation is done by framework and will guarantee that fields will not be null

Typescript example:
```
type Foo&lt;T&gt; = {
    baz: string | T
    bar: number | T
}

type FooUnvalidated = Foo&lt;null&gt;
type FooValidated = Foo&lt;never&gt;

function validate(input: FooUnvalidated): FooValidated {
    const {baz, bar} = input;
    if (baz === null) throw Error();
    if (bar === null) throw Error();
    return {
        baz, bar
    }
}

const input: FooUnvalidated = {baz: null, bar: 123};
const validated = validate(input);
const bar: number = validated.bar;
const doesntWork: number = input.bar; // does not compile, input.bar could be null
```