schema.validate(data)

parseSafe(schema, data, { abortEarly: true })

v.safeParse(schema, data, { abortEarly: true })

validate(data, schema, { abortEarly: true })

const decode = Schema.decodeUnknownOption(schema);
decode(data, { errors: "first" })

(Setup code is not benchmarked)

schema.safeParse(data)

p.object(shape).safeParse(data)

schema.validate(data, { abortEarly: true, convert: false })

const parseAsResult = S.parseAsResult(S.schema(value));
parseAsResult(data);

(Setup code is not benchmarked)

const parse = S.parseOrThrow(S.schema(value));
parse(data);

(Setup code is not benchmarked)

schema.validate(data, { abortEarly: true })

S.parseAsResult(schema, data)

S.parseOrThrow(schema, data)

const decodeFirst = Schema.decodeUnknownEither(schema, { errors: "first" });
decodeFirst(data)

(Setup code is not benchmarked)

schema.parse(data)

schema.decode(data)

compactSchema.safeParse(data)

const compiledSchema = Schema.Compile(schema);
compiledSchema.Parse(data);

(Setup code is not benchmarked)

validate(data, schema)

const compiledScriptSchema = Schema.Compile(scriptSchema);
compiledScriptSchema.Parse(data);

(Setup code is not benchmarked)

schema.validate(data)

p.object(shape).parse(data)

bagSchema.safeParse(data)

const compiled = Compile(schema);
compiled.Parse(data);

(Setup code is not benchmarked)

schema.safeParse(data)

Schema.Parse(schema, data)

v.safeParse(schema, data, { abortPipeEarly: true })

v.safeParse(schema, data)

schema.safeParse(data)

compiledSchema.safeParse(data)

Value.Parse(schema, data)

parseSafe(schema, data)

typia.validate<TypiaSchema>(data)

const validate = typia.createValidate<TypiaSchema>();
validate(data);

(Setup code is not benchmarked)

const decode = Schema.decodeUnknownOption(schema);
decode(data, { errors: "all" })

(Setup code is not benchmarked)

validate(data, schema)

schema.safeParse(data)

schema.safeParse(data, { jitless: true })

schema.safeParse(data, { jitless: true })

compiledSchema.safeParse(data)

const decodeAll = Schema.decodeUnknownEither(schema, { errors: "all" });
decodeAll(data)

(Setup code is not benchmarked)

schema.safeParse(data)

schema.validate(data, { abortEarly: false, convert: false })

schema.validateSync(data, { abortEarly: true, strict: true })

schema.decode(data)

schema.validate(data, { abortEarly: false })

const [error] = validate(data, schema);
for (const failure of error.failures()) {
  // ...
}

const [error] = schema.validate(data);
for (const failure of error.failures()) {
  // ...
}

schema.validateSync(data, { abortEarly: true })

schema(data)

schema.parse(data)

schema.run(data)

schema.inspect(data)

schema.parse(data)

schema.validateSync(data, { abortEarly: false, strict: true })

schema.validateSync(data, { abortEarly: false })