[#absl-operator_not_eq-0486]
= xref:absl.adoc[absl]::operator!&equals;
:relfileprefix: ../
:mrdocs:

Inequality operators

== Synopses

Declared in `&lt;absl&sol;numeric&sol;int128&period;h&gt;`

Compares two parameter sets for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-006.adoc[operator!&equals;](
    xref:absl/exponential_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/exponential_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_not_eq-006.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0e0.adoc[operator!&equals;](
    xref:absl/uniform_real_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/uniform_real_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_not_eq-0e0.adoc[_» more&period;&period;&period;_]#

Compares two distributions for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-007.adoc[operator!&equals;](
    xref:absl/zipf_distribution.adoc[zipf&lowbar;distribution] const& a,
    xref:absl/zipf_distribution.adoc[zipf&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_not_eq-007.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-073.adoc[operator!&equals;](
    xref:absl/zipf_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/zipf_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_not_eq-073.adoc[_» more&period;&period;&period;_]#

Compares two distributions for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0cd0.adoc[operator!&equals;](
    xref:absl/uniform_int_distribution.adoc[uniform&lowbar;int&lowbar;distribution] const& a,
    xref:absl/uniform_int_distribution.adoc[uniform&lowbar;int&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_not_eq-0cd0.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0f0.adoc[operator!&equals;](
    xref:absl/uniform_int_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/uniform_int_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_not_eq-0f0.adoc[_» more&period;&period;&period;_]#

Compares two distributions for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-09d.adoc[operator!&equals;](
    xref:absl/poisson_distribution.adoc[poisson&lowbar;distribution] const& a,
    xref:absl/poisson_distribution.adoc[poisson&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_not_eq-09d.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0fb.adoc[operator!&equals;](
    xref:absl/poisson_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/poisson_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_not_eq-0fb.adoc[_» more&period;&period;&period;_]#

Compares two distributions for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-098f.adoc[operator!&equals;](
    xref:absl/bernoulli_distribution.adoc[bernoulli&lowbar;distribution] const& d1,
    xref:absl/bernoulli_distribution.adoc[bernoulli&lowbar;distribution] const& d2);
----

[.small]#xref:absl/operator_not_eq-098f.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-014.adoc[operator!&equals;](
    xref:absl/bernoulli_distribution/param_type.adoc[param&lowbar;type] const& p1,
    xref:absl/bernoulli_distribution/param_type.adoc[param&lowbar;type] const& p2);
----

[.small]#xref:absl/operator_not_eq-014.adoc[_» more&period;&period;&period;_]#

Compares two distributions for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0b8.adoc[operator!&equals;](
    xref:absl/beta_distribution.adoc[beta&lowbar;distribution] const& a,
    xref:absl/beta_distribution.adoc[beta&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_not_eq-0b8.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-03.adoc[operator!&equals;](
    xref:absl/beta_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/beta_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_not_eq-03.adoc[_» more&period;&period;&period;_]#

Compares two distributions for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-08.adoc[operator!&equals;](
    xref:absl/exponential_distribution.adoc[exponential&lowbar;distribution] const& a,
    xref:absl/exponential_distribution.adoc[exponential&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_not_eq-08.adoc[_» more&period;&period;&period;_]#

Compares two distributions for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0c0.adoc[operator!&equals;](
    xref:absl/uniform_real_distribution.adoc[uniform&lowbar;real&lowbar;distribution] const& a,
    xref:absl/uniform_real_distribution.adoc[uniform&lowbar;real&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_not_eq-0c0.adoc[_» more&period;&period;&period;_]#

Compares two distributions for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0b0.adoc[operator!&equals;](
    xref:absl/gaussian_distribution.adoc[gaussian&lowbar;distribution] const& a,
    xref:absl/gaussian_distribution.adoc[gaussian&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_not_eq-0b0.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0f6.adoc[operator!&equals;](
    xref:absl/gaussian_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/gaussian_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_not_eq-0f6.adoc[_» more&period;&period;&period;_]#

Compares two distributions for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-072.adoc[operator!&equals;](
    xref:absl/log_uniform_int_distribution.adoc[log&lowbar;uniform&lowbar;int&lowbar;distribution] const& a,
    xref:absl/log_uniform_int_distribution.adoc[log&lowbar;uniform&lowbar;int&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_not_eq-072.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-091.adoc[operator!&equals;](
    xref:absl/log_uniform_int_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/log_uniform_int_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_not_eq-091.adoc[_» more&period;&period;&period;_]#

Compares two distributions for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0fd.adoc[operator!&equals;](
    xref:absl/discrete_distribution.adoc[discrete&lowbar;distribution] const& a,
    xref:absl/discrete_distribution.adoc[discrete&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_not_eq-0fd.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-043.adoc[operator!&equals;](
    xref:absl/discrete_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/discrete_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_not_eq-043.adoc[_» more&period;&period;&period;_]#

Compares two spans for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0d2.adoc[operator!&equals;](
    xref:absl/AnySpan.adoc[AnySpan] a,
    xref:absl/AnySpan.adoc[AnySpan] b);
----

[.small]#xref:absl/operator_not_eq-0d2.adoc[_» more&period;&period;&period;_]#

Compares two const spans for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-07a.adoc[operator!&equals;](
    xref:absl/AnySpan.adoc[AnySpan&lt;T const&gt;] a,
    xref:absl/AnySpan.adoc[AnySpan&lt;T const&gt;] b);
----

[.small]#xref:absl/operator_not_eq-07a.adoc[_» more&period;&period;&period;_]#

Tests whether two iterators refer to different positions&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-092.adoc[operator!&equals;](
    Iter const& a,
    Iter const& b);
----

[.small]#xref:absl/operator_not_eq-092.adoc[_» more&period;&period;&period;_]#

Returns true if `a` and `b` refer to different elements&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-000.adoc[operator!&equals;](
    xref:absl/chunked_queue.adoc[iterator&lowbar;common] const& a,
    xref:absl/chunked_queue.adoc[iterator&lowbar;common] const& b);
----

[.small]#xref:absl/operator_not_eq-000.adoc[_» more&period;&period;&period;_]#

Returns whether two maps differ in their key&sol;value pairs&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-069.adoc[operator!&equals;](
    xref:absl/linked_hash_map.adoc[linked&lowbar;hash&lowbar;map] const& a,
    xref:absl/linked_hash_map.adoc[linked&lowbar;hash&lowbar;map] const& b);
----

[.small]#xref:absl/operator_not_eq-069.adoc[_» more&period;&period;&period;_]#

Returns whether two sets contain different elements&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0563.adoc[operator!&equals;](
    xref:absl/linked_hash_set.adoc[linked&lowbar;hash&lowbar;set] const& a,
    xref:absl/linked_hash_set.adoc[linked&lowbar;hash&lowbar;set] const& b);
----

[.small]#xref:absl/operator_not_eq-0563.adoc[_» more&period;&period;&period;_]#

Compare two CRC32C values for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-07d.adoc[operator!&equals;](
    xref:absl/crc32c_t.adoc[crc32c&lowbar;t] lhs,
    xref:absl/crc32c_t.adoc[crc32c&lowbar;t] rhs);
----

[.small]#xref:absl/operator_not_eq-07d.adoc[_» more&period;&period;&period;_]#

Compares two spans for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
constexpr
bool
xref:absl/operator_not_eq-0e4.adoc[operator!&equals;](
    xref:absl/Span.adoc[Span&lt;T const&gt;] a,
    xref:absl/Span.adoc[Span&lt;T&gt;] b);
----

[.small]#xref:absl/operator_not_eq-0e4.adoc[_» more&period;&period;&period;_]#

Compares two spans for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
constexpr
bool
xref:absl/operator_not_eq-0a.adoc[operator!&equals;](
    xref:absl/Span.adoc[Span&lt;T&gt;] a,
    xref:absl/Span.adoc[Span&lt;T const&gt;] b);
----

[.small]#xref:absl/operator_not_eq-0a.adoc[_» more&period;&period;&period;_]#

Compares a container to a span for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    typename U,
    typename = span&lowbar;internal::EnableIfConvertibleTo&lt;U, absl::Span&lt;T const&gt;&gt;&gt;
constexpr
bool
xref:absl/operator_not_eq-053f.adoc[operator!&equals;](
    U const& a,
    xref:absl/Span.adoc[Span&lt;T&gt;] b);
----

[.small]#xref:absl/operator_not_eq-053f.adoc[_» more&period;&period;&period;_]#

Compares a span to a container for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    typename U,
    typename = span&lowbar;internal::EnableIfConvertibleTo&lt;U, absl::Span&lt;T const&gt;&gt;&gt;
constexpr
bool
xref:absl/operator_not_eq-077.adoc[operator!&equals;](
    xref:absl/Span.adoc[Span&lt;T&gt;] a,
    U const& b);
----

[.small]#xref:absl/operator_not_eq-077.adoc[_» more&period;&period;&period;_]#

Returns whether two time zones are unequal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0e1.adoc[operator!&equals;](
    xref:absl/TimeZone.adoc[TimeZone] a,
    xref:absl/TimeZone.adoc[TimeZone] b);
----

[.small]#xref:absl/operator_not_eq-0e1.adoc[_» more&period;&period;&period;_]#

Returns whether two durations are unequal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
constexpr
bool
xref:absl/operator_not_eq-0e7.adoc[operator!&equals;](
    xref:absl/Duration.adoc[Duration] lhs,
    xref:absl/Duration.adoc[Duration] rhs);
----

[.small]#xref:absl/operator_not_eq-0e7.adoc[_» more&period;&period;&period;_]#

Returns whether two times are unequal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
constexpr
bool
xref:absl/operator_not_eq-052.adoc[operator!&equals;](
    xref:absl/Time.adoc[Time] lhs,
    xref:absl/Time.adoc[Time] rhs);
----

[.small]#xref:absl/operator_not_eq-052.adoc[_» more&period;&period;&period;_]#

Returns `false` if `f` is empty&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0564.adoc[operator!&equals;](
    std::nullptr&lowbar;t unused,
    xref:absl/AnyInvocable.adoc[AnyInvocable] const& f) noexcept;
----

[.small]#xref:absl/operator_not_eq-0564.adoc[_» more&period;&period;&period;_]#

Returns `false` if `f` is empty&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-049.adoc[operator!&equals;](
    xref:absl/AnyInvocable.adoc[AnyInvocable] const& f,
    std::nullptr&lowbar;t unused) noexcept;
----

[.small]#xref:absl/operator_not_eq-049.adoc[_» more&period;&period;&period;_]#

Determines whether `lhs` and `rhs` are unequal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
constexpr
bool
xref:absl/operator_not_eq-02.adoc[operator!&equals;](
    xref:absl/uint128.adoc[uint128] lhs,
    xref:absl/uint128.adoc[uint128] rhs);
----

[.small]#xref:absl/operator_not_eq-02.adoc[_» more&period;&period;&period;_]#

Determines whether `lhs` and `rhs` are unequal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
constexpr
bool
xref:absl/operator_not_eq-00b.adoc[operator!&equals;](
    xref:absl/int128.adoc[int128] lhs,
    xref:absl/int128.adoc[int128] rhs);
----

[.small]#xref:absl/operator_not_eq-00b.adoc[_» more&period;&period;&period;_]#

Tests for value&hyphen;inequality of two inlined vectors&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    size&lowbar;t N,
    typename A&gt;
bool
xref:absl/operator_not_eq-053e.adoc[operator!&equals;](
    xref:absl/InlinedVector.adoc[absl::InlinedVector&lt;T, N, A&gt;] const& a,
    xref:absl/InlinedVector.adoc[absl::InlinedVector&lt;T, N, A&gt;] const& b);
----

[.small]#xref:absl/operator_not_eq-053e.adoc[_» more&period;&period;&period;_]#

Compares two spans for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
constexpr
bool
xref:absl/operator_not_eq-0624.adoc[operator!&equals;](
    xref:absl/Span.adoc[Span&lt;T&gt;] a,
    xref:absl/Span.adoc[Span&lt;T&gt;] b);
----

[.small]#xref:absl/operator_not_eq-0624.adoc[_» more&period;&period;&period;_]#

Returns whether two fixed arrays are not elementwise equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0ca.adoc[operator!&equals;](
    xref:absl/FixedArray.adoc[FixedArray] const& lhs,
    xref:absl/FixedArray.adoc[FixedArray] const& rhs);
----

[.small]#xref:absl/operator_not_eq-0ca.adoc[_» more&period;&period;&period;_]#

Compares two Cords for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-04b.adoc[operator!&equals;](
    xref:absl/Cord.adoc[Cord] const& x,
    xref:absl/Cord.adoc[Cord] const& y);
----

[.small]#xref:absl/operator_not_eq-04b.adoc[_» more&period;&period;&period;_]#

Compares a Cord with string data for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0bf.adoc[operator!&equals;](
    xref:absl/Cord.adoc[Cord] const& x,
    std::string&lowbar;view y);
----

[.small]#xref:absl/operator_not_eq-0bf.adoc[_» more&period;&period;&period;_]#

Compares string data with a Cord for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0dd.adoc[operator!&equals;](
    std::string&lowbar;view x,
    xref:absl/Cord.adoc[Cord] const& y);
----

[.small]#xref:absl/operator_not_eq-0dd.adoc[_» more&period;&period;&period;_]#

Tests whether an `optional&lowbar;ref` holds a value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
constexpr
bool
xref:absl/operator_not_eq-0cb.adoc[operator!&equals;](
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;T&gt;] a,
    std::nullopt&lowbar;t b);
----

[.small]#xref:absl/operator_not_eq-0cb.adoc[_» more&period;&period;&period;_]#

Tests whether an `optional&lowbar;ref` holds a value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
constexpr
bool
xref:absl/operator_not_eq-0cd2.adoc[operator!&equals;](
    std::nullopt&lowbar;t a,
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;T&gt;] b);
----

[.small]#xref:absl/operator_not_eq-0cd2.adoc[_» more&period;&period;&period;_]#

Tests whether two `optional&lowbar;ref`s differ&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    typename U&gt;
constexpr
bool
xref:absl/operator_not_eq-018.adoc[operator!&equals;](
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;T&gt;] a,
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;U&gt;] b);
----

[.small]#xref:absl/operator_not_eq-018.adoc[_» more&period;&period;&period;_]#

Tests whether an `optional&lowbar;ref` differs from a value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    typename U,
    typename = &sol;&ast; implementation-defined &ast;&sol;&gt;
constexpr
bool
xref:absl/operator_not_eq-065.adoc[operator!&equals;](
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;T&gt;] a,
    U const& b);
----

[.small]#xref:absl/operator_not_eq-065.adoc[_» more&period;&period;&period;_]#

Tests whether a value differs from an `optional&lowbar;ref`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    typename U,
    typename = &sol;&ast; implementation-defined &ast;&sol;&gt;
constexpr
bool
xref:absl/operator_not_eq-0626.adoc[operator!&equals;](
    T const& a,
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;U&gt;] b);
----

[.small]#xref:absl/operator_not_eq-0626.adoc[_» more&period;&period;&period;_]#

Compares two statuses for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_not_eq-0988.adoc[operator!&equals;](
    xref:absl/Status.adoc[Status] const& lhs,
    xref:absl/Status.adoc[Status] const& rhs);
----

[.small]#xref:absl/operator_not_eq-0988.adoc[_» more&period;&period;&period;_]#

Checks the inequality of two `absl&colon;&colon;StatusOr&lt;T&gt;` objects&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
requires internal&lowbar;statusor&colon;&colon;IsEqualityComparable&lt;T&gt;&colon;&colon;value
bool
xref:absl/operator_not_eq-048f.adoc[operator!&equals;](
    xref:absl/StatusOr.adoc[StatusOr&lt;T&gt;] const& lhs,
    xref:absl/StatusOr.adoc[StatusOr&lt;T&gt;] const& rhs);
----

[.small]#xref:absl/operator_not_eq-048f.adoc[_» more&period;&period;&period;_]#

Compares two `FastTypeIdType` values for inequality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
constexpr
bool
xref:absl/operator_not_eq-045.adoc[operator!&equals;](
    xref:absl/FastTypeIdType.adoc[FastTypeIdType] a,
    xref:absl/FastTypeIdType.adoc[FastTypeIdType] b);
----

[.small]#xref:absl/operator_not_eq-045.adoc[_» more&period;&period;&period;_]#

== Return Value

* `true` if the parameter sets are not equal&period;
* `true` if the distributions have differing parameter sets&period;
* `true` if the spans differ&period;
* `true` if `a` and `b` point to different positions&period;
* true if the iterators are not equal&period;
* `true` if the maps are not equal&period;
* `true` if the sets are not equal&period;
* `true` if the values differ&period;
* `true` if the operands differ&period;
* `true` if `a` and `b` refer to different zones&period;
* `true` if `lhs` does not equal `rhs`&period;
* `false` if `f` is empty&period;
* `true` if `lhs` does not equal `rhs`&semi; `false` otherwise&period;
* `true` if the vectors are not equal, `false` otherwise&period;
* `true` if the arrays differ in size or elements&period;
* `true` if the Cords differ&period;
* `true` if the contents differ&period;
* `true` if `a` holds a value&period;
* `true` if `b` holds a value&period;
* `true` if the operands are not equal&period;
* `true` if `a` does not hold a value equal to `b`&period;
* `true` if `b` does not hold a value equal to `a`&period;
* `true` if the two statuses differ&period;
* `true` if `a` and `b` identify different types, `false` otherwise&period;

== Parameters

[cols="1,4"]
|===
| Name| Description
| *a*
| The first parameter set to compare&period;
| *b*
| The second parameter set to compare&period;
| *d1*
| The first distribution to compare&period;
| *d2*
| The second distribution to compare&period;
| *p1*
| The first parameter set to compare&period;
| *p2*
| The second parameter set to compare&period;
| *lhs*
| The left&hyphen;hand operand&period;
| *rhs*
| The right&hyphen;hand operand&period;
| *f*
| The `AnyInvocable` to check&period;
| *unused*
| Unused parameter&period;
| *x*
| The left&hyphen;hand Cord&period;
| *y*
| The right&hyphen;hand Cord&period;
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#
