JIT compiled validators should be much much faster

In the intro you perform a comparison against class-transformer which is probably at the lowest end of validators in terms of performance…

You should actually compare to other JIT libraries and not to composition library.

ts-json-validator (avj) or quartet

They both have a huge advantage over marshal.ts

Since the top 3 libraries are JIT, you can see the gap.

Note that JIT libraries do excel at benchmarks, less at realtime world scenarios since JIT libraries LOVE it when the same validator function is running over and over, getting inlined all the way.

---

BTW, I believe that if you can shorten the amount of function calls done from calling to perform validation and until returning a result you will get better benchmark results.

[marcj]

Ah I see, you talk about the linked benchmark repo. Well I talked with the author already that he is using Marshal wrong. Marshal has 2 main features: Validating and transforming data. The author uses both features at the same time for a simple validation check, although transforming is traditionally way slower and not necessary for validation. In other libraries like ts-json-validator (avj) or quartet he uses only the validation feature. So clearly the benchmark is flawed. I tried to correct it in https://github.com/moltar/typescript-runtime-type-benchmarks/pull/148, but the author refuses to merge since a totally different topic type guarding doesn’t meet his criteria.

Also here is the issue where I explain in detail why his benchmark is fundamentally flawed for validation. https://github.com/moltar/typescript-runtime-type-benchmarks/issues/149. There is explained why Marshal is faster than ts-json-validator and ajv for actua validation use-cases. The overall consensus was

Ok, I missed that you even stated in the README that this library is not supposed to be a validation benchmark, but just a type checker

So, the linked repo is not actually a validation benchmark, but just a very simple runtime type checker. It’s very misleading to say now that Marshal is slower in validation, when you really talk about a very specific subset, namely just type checking.

I’m going to remove the link as its highly misleading and instead link to the benchmark I use in Marshal’s test suite.

[marcj]

Are you trolling? You literally added to Marshal’s case additional validation rules like isNegative etc which you did not add to quartet etc and wonder why the latter is faster?

I linked the benchmark code so you can clearly see that Marshal is in actual real-world use-cases (where nobody only checks for types, but also for content stuff, like arrays, string length, number range…) way way faster. In synthetic benchmarks where only types are checked is Marshal slower - as it was not tuned for those rather exotic use-cases.