ozzo/ozzo-validation - Plugin operators

This page lists all operators available in the ozzo/ozzo-validation sub-package of ro.

Help improve this documentation

This documentation is still new and evolving. If you spot any mistakes, unclear explanations, or missing details, please open an issue.

Your feedback helps us improve!

Install

First, import the sub-package in your project:

go get -u github.com/samber/ro/plugins/ozzo/ozzo-validation

• Validate

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates values with rules, emitting a Result[T] that is either ok (valid) or err (invalid).

  import (
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  obs := ro.Pipe1(
      ro.Just("hello", "", "world"),
      roozzo.Validate[string](
          validation.Required,
          validation.Length(1, 10),
      ),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[roozzo.Result[string]]())
  defer sub.Unsubscribe()
  
  // Next: {false hello <nil>}
  // Next: {true  {validation_required cannot be blank map[]}}
  // Next: {false world <nil>}
  // Completed

  Similar:

  validateorerrorvalidatestruct

  Prototype:

  func Validate[T any](rules ...ozzo.Rule)

• ValidateOrSkip

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates values with rules, skipping items that fail validation and forwarding valid items unchanged.

  import (
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  obs := ro.Pipe1(
      ro.Just("hello", "", "world", "x-too-long-string"),
      roozzo.ValidateOrSkip[string](
          validation.Required,
          validation.Length(1, 10),
      ),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[string]())
  defer sub.Unsubscribe()
  
  // Next: hello
  // Next: world
  // Completed

  Similar:

  validatevalidatestructorskip

  Prototype:

  func ValidateOrSkip[T any](rules ...ozzo.Rule)

• ValidateStructOrSkip

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates struct items using the ozzo.Validatable interface, skipping items that fail validation and forwarding valid items unchanged.

  import (
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  type User struct {
      Name string
      Age  int
  }
  
  func (u User) Validate() error {
      return validation.ValidateStruct(&u,
          validation.Field(&u.Name, validation.Required),
          validation.Field(&u.Age, validation.Min(18)),
      )
  }
  
  obs := ro.Pipe1(
      ro.Just(
          User{Name: "Alice", Age: 30},
          User{Name: "", Age: 15},
          User{Name: "Bob", Age: 25},
      ),
      roozzo.ValidateStructOrSkip[User](),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[User]())
  defer sub.Unsubscribe()
  
  // Next: {Alice 30}
  // Next: {Bob 25}
  // Completed

  Similar:

  validateorskipvalidatestruct

  Prototype:

  func ValidateStructOrSkip[T any]()

• ValidateOrSkipWithContext

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates values with rules using context propagation, skipping items that fail validation and forwarding valid items unchanged.

  import (
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  obs := ro.Pipe1(
      ro.Just("hello", "", "world", "x-too-long-string"),
      roozzo.ValidateOrSkipWithContext[string](
          validation.Required,
          validation.Length(1, 10),
      ),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[string]())
  defer sub.Unsubscribe()
  
  // Next: hello
  // Next: world
  // Completed

  Similar:

  validateorskipvalidatestructorskipwithcontext

  Prototype:

  func ValidateOrSkipWithContext[T any](rules ...ozzo.Rule)

• ValidateWithContext

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates values with rules using context propagation, emitting a Result[T] for each item.

  import (
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  obs := ro.Pipe1(
      ro.Just("hello", "", "world"),
      roozzo.ValidateWithContext[string](
          validation.Required,
          validation.Length(1, 10),
      ),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[roozzo.Result[string]]())
  defer sub.Unsubscribe()
  
  // Next: {false hello <nil>}
  // Next: {true  {validation_required cannot be blank map[]}}
  // Next: {false world <nil>}
  // Completed

  Similar:

  validatevalidateorerrorwithcontextvalidatestructwithcontext

  Prototype:

  func ValidateWithContext[T any](rules ...ozzo.Rule)

• ValidateStructOrSkipWithContext

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates struct items using the ozzo.ValidatableWithContext interface with context propagation, skipping items that fail validation and forwarding valid items unchanged.

  import (
      "context"
  
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  type User struct {
      Name string
      Age  int
  }
  
  func (u User) ValidateWithContext(ctx context.Context) error {
      return validation.ValidateStructWithContext(ctx, &u,
          validation.Field(&u.Name, validation.Required),
          validation.Field(&u.Age, validation.Min(18)),
      )
  }
  
  obs := ro.Pipe1(
      ro.Just(
          User{Name: "Alice", Age: 30},
          User{Name: "", Age: 15},
          User{Name: "Bob", Age: 25},
      ),
      roozzo.ValidateStructOrSkipWithContext[User](),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[User]())
  defer sub.Unsubscribe()
  
  // Next: {Alice 30}
  // Next: {Bob 25}
  // Completed

  Similar:

  validateorskipwithcontextvalidatestructorskip

  Prototype:

  func ValidateStructOrSkipWithContext[T any]()

• ValidateStruct

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates struct values that implement the ozzo.Validatable interface, emitting a Result[T] for each item.

  import (
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  type User struct {
      Name string
      Age  int
  }
  
  func (u User) Validate() error {
      return validation.ValidateStruct(&u,
          validation.Field(&u.Name, validation.Required),
          validation.Field(&u.Age, validation.Min(18)),
      )
  }
  
  obs := ro.Pipe1(
      ro.Just(
          User{Name: "Alice", Age: 30},
          User{Name: "", Age: 15},
      ),
      roozzo.ValidateStruct[User](),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[roozzo.Result[User]]())
  defer sub.Unsubscribe()
  
  // Next: {false {Alice 30} <nil>}
  // Next: {true { 0} map[Age:{validation_min_greater_equal_than_required must be no less than {{.threshold}} map[threshold:18]} Name:{validation_required cannot be blank map[]}]}
  // Completed

  Similar:

  validatevalidatestructorerrorvalidatestructwithcontext

  Prototype:

  func ValidateStruct[T any]()

• ValidateStructWithContext

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates struct values that implement the ozzo.ValidatableWithContext interface using context propagation.

  import (
      "context"
  
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  type User struct {
      Name string
      Age  int
  }
  
  func (u User) ValidateWithContext(ctx context.Context) error {
      return validation.ValidateStructWithContext(ctx, &u,
          validation.Field(&u.Name, validation.Required),
          validation.Field(&u.Age, validation.Min(18)),
      )
  }
  
  obs := ro.Pipe1(
      ro.Just(
          User{Name: "Alice", Age: 30},
          User{Name: "", Age: 15},
      ),
      roozzo.ValidateStructWithContext[User](),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[roozzo.Result[User]]())
  defer sub.Unsubscribe()
  
  // Next: {false {Alice 30} <nil>}
  // Next: {true { 0} map[Age:{validation_min_greater_equal_than_required must be no less than {{.threshold}} map[threshold:18]} Name:{validation_required cannot be blank map[]}]}
  // Completed

  Similar:

  validatestructvalidatestructorerrorwithcontextvalidatewithcontext

  Prototype:

  func ValidateStructWithContext[T any]()

• ValidateOrError

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates values with rules. Valid items are forwarded unchanged; the first invalid item terminates the stream with an error.

  import (
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  obs := ro.Pipe1(
      ro.Just("hello", "", "world"),
      roozzo.ValidateOrError[string](
          validation.Required,
          validation.Length(1, 10),
      ),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[string]())
  defer sub.Unsubscribe()
  
  // Next: hello
  // Error: cannot be blank

  Similar:

  validatevalidateorerrorwithcontext

  Prototype:

  func ValidateOrError[T any](rules ...ozzo.Rule)

• ValidateOrErrorWithContext

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates each item using context-aware ozzo-validation rules. Items that fail validation cause the stream to error; valid items are forwarded unchanged.

  import (
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  obs := ro.Pipe[int, int](
      ro.Just(5, 15, 25),
      roozzo.ValidateOrErrorWithContext[int](
          validation.Min(10),
      ),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[int]())
  defer sub.Unsubscribe()
  
  // Error: must be no less than 10

  Similar:

  validateorerrorvalidateorskipwithcontext

  Prototype:

  func ValidateOrErrorWithContext[T any](rules ...ozzo.Rule)

• ValidateStructOrError

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates each struct item using ozzo-validation. Items that fail validation cause the stream to error; valid items are forwarded unchanged. The struct must implement validation.Validatable.

  import (
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  type User struct {
      Name  string
      Email string
  }
  
  func (u User) Validate() error {
      return validation.ValidateStruct(&u,
          validation.Field(&u.Name, validation.Required),
          validation.Field(&u.Email, validation.Required),
      )
  }
  
  obs := ro.Pipe[User, User](
      ro.Just(
          User{Name: "Alice", Email: "[email protected]"},
          User{Name: "", Email: ""},
      ),
      roozzo.ValidateStructOrError[User](),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[User]())
  defer sub.Unsubscribe()
  
  // Next: {Alice [email protected]}
  // Error: Email: cannot be blank; Name: cannot be blank.

  Similar:

  validateorerrorvalidatestructvalidatestructorskip

  Prototype:

  func ValidateStructOrError[T any]()

• ValidateStructOrErrorWithContext

  ozzo-validationplugin

  🧩 Source📚 GoDoc🎮 Try on Go Playground

  Validates each struct item using context-aware ozzo-validation. Items that fail validation cause the stream to error; valid items are forwarded unchanged. The struct must implement validation.ValidatableWithContext.

  import (
      "context"
  
      validation "github.com/go-ozzo/ozzo-validation/v4"
      "github.com/samber/ro"
      roozzo "github.com/samber/ro/plugins/ozzo/ozzo-validation"
  )
  
  type User struct {
      Name  string
      Email string
  }
  
  func (u User) ValidateWithContext(ctx context.Context) error {
      return validation.ValidateStructWithContext(ctx, &u,
          validation.Field(&u.Name, validation.Required),
          validation.Field(&u.Email, validation.Required),
      )
  }
  
  obs := ro.Pipe[User, User](
      ro.Just(
          User{Name: "Alice", Email: "[email protected]"},
          User{Name: "", Email: ""},
      ),
      roozzo.ValidateStructOrErrorWithContext[User](),
  )
  
  sub := obs.Subscribe(ro.PrintObserver[User]())
  defer sub.Unsubscribe()
  
  // Next: {Alice [email protected]}
  // Error: Email: cannot be blank; Name: cannot be blank.

  Similar:

  validateorerrorwithcontextvalidatestructorerrorvalidatestructorskipwithcontext

  Prototype:

  func ValidateStructOrErrorWithContext[T any]()