arcis 0.14.1

//! Comparison traits accepted by the arcis interpreter.
//!
//! The traits in this module are documentation-only handles: they exist so
//! rustdoc renders a page per trait, with an auto-generated implementors list
//! showing which types the arcis interpreter recognizes the trait on.
//!
//! They are never imported by user code. Inside `#[encrypted]` code the
//! interpreter dispatches `==`, `!=`, and the inherent `.eq()` / `.ne()`
//! methods directly; you do not need to bring this trait into scope.

/// `PartialEq` semantics accepted by the arcis interpreter.
///
/// # Implementing
///
/// User types gain `PartialEq` via [`#[derive(PartialEq)]`](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#derivable).
/// A hand-written `impl PartialEq for MyType` is **not** accepted — the
/// interpreter's forbidden-trait list rejects it.
///
/// # Calling
///
/// Inside `#[encrypted]` code, the supported forms are:
///
/// * `a == b` and `a != b`.
/// * `a.eq(&b)` and `a.ne(&b)`.
/// * `<T as PartialEq>::eq(&a, &b)` and `<T as PartialEq>::ne(&a, &b)`.
///
/// The unqualified trait form `PartialEq::eq(&a, &b)` is not accepted: the
/// interpreter needs the receiver type to know which impl to dispatch to.
///
/// # Implementors
///
/// The impl list below shows the types the interpreter recognizes as
/// partially-equatable. User types with `#[derive(PartialEq)]` are accepted
/// at use sites but do not appear in this list (their impls live in user code,
/// not in arcis).
pub trait PartialEq<Rhs: ?Sized = Self> {}

// ---- Primitives ----
//
// Integer and float impls point at the doc-only unit structs defined in
// [`crate::std::integer`] / [`crate::std::float`], so the implementors list
// links into our own doc pages instead of the unlinkable primitive names.

impl PartialEq for crate::std::boolean::bool {}

impl PartialEq for crate::std::integer::u8 {}
impl PartialEq for crate::std::integer::u16 {}
impl PartialEq for crate::std::integer::u32 {}
impl PartialEq for crate::std::integer::u64 {}
impl PartialEq for crate::std::integer::u128 {}
impl PartialEq for crate::std::integer::usize {}

impl PartialEq for crate::std::integer::i8 {}
impl PartialEq for crate::std::integer::i16 {}
impl PartialEq for crate::std::integer::i32 {}
impl PartialEq for crate::std::integer::i64 {}
impl PartialEq for crate::std::integer::i128 {}
impl PartialEq for crate::std::integer::isize {}

impl PartialEq for crate::std::float::f32 {}
impl PartialEq for crate::std::float::f64 {}

// ---- Arcis built-in scalar types ----

impl PartialEq for crate::BaseField25519 {}
impl PartialEq for crate::ArcisX25519Pubkey {}

// ---- Composite ----

impl PartialEq for () {}

impl<T: PartialEq> PartialEq for [T] {}
impl<T: PartialEq, const N: usize> PartialEq for [T; N] {}

impl<T1: PartialEq> PartialEq for (T1,) {}
impl<T1: PartialEq, T2: PartialEq> PartialEq for (T1, T2) {}
impl<T1: PartialEq, T2: PartialEq, T3: PartialEq> PartialEq for (T1, T2, T3) {}
impl<T1: PartialEq, T2: PartialEq, T3: PartialEq, T4: PartialEq> PartialEq for (T1, T2, T3, T4) {}
impl<T1: PartialEq, T2: PartialEq, T3: PartialEq, T4: PartialEq, T5: PartialEq> PartialEq
    for (T1, T2, T3, T4, T5)
{
}
impl<T1: PartialEq, T2: PartialEq, T3: PartialEq, T4: PartialEq, T5: PartialEq, T6: PartialEq>
    PartialEq for (T1, T2, T3, T4, T5, T6)
{
}
impl<
        T1: PartialEq,
        T2: PartialEq,
        T3: PartialEq,
        T4: PartialEq,
        T5: PartialEq,
        T6: PartialEq,
        T7: PartialEq,
    > PartialEq for (T1, T2, T3, T4, T5, T6, T7)
{
}
impl<
        T1: PartialEq,
        T2: PartialEq,
        T3: PartialEq,
        T4: PartialEq,
        T5: PartialEq,
        T6: PartialEq,
        T7: PartialEq,
        T8: PartialEq,
    > PartialEq for (T1, T2, T3, T4, T5, T6, T7, T8)
{
}
impl<
        T1: PartialEq,
        T2: PartialEq,
        T3: PartialEq,
        T4: PartialEq,
        T5: PartialEq,
        T6: PartialEq,
        T7: PartialEq,
        T8: PartialEq,
        T9: PartialEq,
    > PartialEq for (T1, T2, T3, T4, T5, T6, T7, T8, T9)
{
}
impl<
        T1: PartialEq,
        T2: PartialEq,
        T3: PartialEq,
        T4: PartialEq,
        T5: PartialEq,
        T6: PartialEq,
        T7: PartialEq,
        T8: PartialEq,
        T9: PartialEq,
        T10: PartialEq,
    > PartialEq for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
{
}
impl<
        T1: PartialEq,
        T2: PartialEq,
        T3: PartialEq,
        T4: PartialEq,
        T5: PartialEq,
        T6: PartialEq,
        T7: PartialEq,
        T8: PartialEq,
        T9: PartialEq,
        T10: PartialEq,
        T11: PartialEq,
    > PartialEq for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
{
}
impl<
        T1: PartialEq,
        T2: PartialEq,
        T3: PartialEq,
        T4: PartialEq,
        T5: PartialEq,
        T6: PartialEq,
        T7: PartialEq,
        T8: PartialEq,
        T9: PartialEq,
        T10: PartialEq,
        T11: PartialEq,
        T12: PartialEq,
    > PartialEq for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
{
}

// ---- References ----

impl<T: PartialEq + ?Sized> PartialEq for &T {}
impl<T: PartialEq + ?Sized> PartialEq for &mut T {}

// ---- Wrappers ----

impl<T: PartialEq> PartialEq for crate::std::option::Option<T> {}
impl<T: PartialEq + ?Sized> PartialEq for crate::std::boxed::Box<T> {}
impl<T: PartialEq> PartialEq for crate::std::cell::Cell<T> {}

// ---- Ranges ----

impl<Idx: PartialEq> PartialEq for crate::std::ops::Range<Idx> {}
impl<Idx: PartialEq> PartialEq for crate::std::ops::RangeInclusive<Idx> {}
impl<Idx: PartialEq> PartialEq for crate::std::ops::RangeFrom<Idx> {}
impl<Idx: PartialEq> PartialEq for crate::std::ops::RangeTo<Idx> {}
impl<Idx: PartialEq> PartialEq for crate::std::ops::RangeToInclusive<Idx> {}
impl PartialEq for crate::std::ops::RangeFull {}

// ---- Encrypted / packed data ----

impl<C: crate::Cipher + PartialEq, T: crate::ArcisType + PartialEq> PartialEq for crate::Enc<C, T> {}
impl<T: crate::ArcisType + PartialEq> PartialEq for crate::EncData<T> {}
impl<T: crate::ArcisType + PartialEq> PartialEq for crate::Pack<T> {}
impl PartialEq for crate::Shared {}
impl PartialEq for crate::Mxe {}

// =================== Eq ===================

/// `Eq` membership recognized by the arcis interpreter.
///
/// `Eq` is a marker that `PartialEq` is a true equivalence relation (reflexive,
/// symmetric, transitive). It has no methods of its own; the user-facing
/// surface is the same as [`PartialEq`].
///
/// # Implementing
///
/// User types gain `Eq` via [`#[derive(Eq, PartialEq)]`](https://doc.rust-lang.org/std/cmp/trait.Eq.html#derivable).
/// A hand-written `impl Eq for MyType` is **not** accepted — the interpreter's
/// forbidden-trait list rejects it.
///
/// # Implementors
///
/// The impl list below shows the types the interpreter recognizes as `Eq`.
/// Floating-point types (`f32`, `f64`) are deliberately absent, matching std.
/// User types with `#[derive(Eq, PartialEq)]` are accepted at use sites but
/// do not appear in this list (their impls live in user code, not in arcis).
pub trait Eq: PartialEq {}

impl Eq for crate::std::boolean::bool {}

impl Eq for crate::std::integer::u8 {}
impl Eq for crate::std::integer::u16 {}
impl Eq for crate::std::integer::u32 {}
impl Eq for crate::std::integer::u64 {}
impl Eq for crate::std::integer::u128 {}
impl Eq for crate::std::integer::usize {}

impl Eq for crate::std::integer::i8 {}
impl Eq for crate::std::integer::i16 {}
impl Eq for crate::std::integer::i32 {}
impl Eq for crate::std::integer::i64 {}
impl Eq for crate::std::integer::i128 {}
impl Eq for crate::std::integer::isize {}

impl Eq for crate::BaseField25519 {}
// `ArcisX25519Pubkey` derives only `PartialEq`, not `Eq` — deliberately absent.

impl Eq for () {}

impl<T: Eq> Eq for [T] {}
impl<T: Eq, const N: usize> Eq for [T; N] {}

impl<T1: Eq> Eq for (T1,) {}
impl<T1: Eq, T2: Eq> Eq for (T1, T2) {}
impl<T1: Eq, T2: Eq, T3: Eq> Eq for (T1, T2, T3) {}
impl<T1: Eq, T2: Eq, T3: Eq, T4: Eq> Eq for (T1, T2, T3, T4) {}
impl<T1: Eq, T2: Eq, T3: Eq, T4: Eq, T5: Eq> Eq for (T1, T2, T3, T4, T5) {}
impl<T1: Eq, T2: Eq, T3: Eq, T4: Eq, T5: Eq, T6: Eq> Eq for (T1, T2, T3, T4, T5, T6) {}
impl<T1: Eq, T2: Eq, T3: Eq, T4: Eq, T5: Eq, T6: Eq, T7: Eq> Eq for (T1, T2, T3, T4, T5, T6, T7) {}
impl<T1: Eq, T2: Eq, T3: Eq, T4: Eq, T5: Eq, T6: Eq, T7: Eq, T8: Eq> Eq
    for (T1, T2, T3, T4, T5, T6, T7, T8)
{
}
impl<T1: Eq, T2: Eq, T3: Eq, T4: Eq, T5: Eq, T6: Eq, T7: Eq, T8: Eq, T9: Eq> Eq
    for (T1, T2, T3, T4, T5, T6, T7, T8, T9)
{
}
impl<T1: Eq, T2: Eq, T3: Eq, T4: Eq, T5: Eq, T6: Eq, T7: Eq, T8: Eq, T9: Eq, T10: Eq> Eq
    for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
{
}
impl<T1: Eq, T2: Eq, T3: Eq, T4: Eq, T5: Eq, T6: Eq, T7: Eq, T8: Eq, T9: Eq, T10: Eq, T11: Eq> Eq
    for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
{
}
impl<
        T1: Eq,
        T2: Eq,
        T3: Eq,
        T4: Eq,
        T5: Eq,
        T6: Eq,
        T7: Eq,
        T8: Eq,
        T9: Eq,
        T10: Eq,
        T11: Eq,
        T12: Eq,
    > Eq for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
{
}

impl<T: Eq + ?Sized> Eq for &T {}
impl<T: Eq + ?Sized> Eq for &mut T {}

impl<T: Eq> Eq for crate::std::option::Option<T> {}
impl<T: Eq + ?Sized> Eq for crate::std::boxed::Box<T> {}
impl<T: Eq> Eq for crate::std::cell::Cell<T> {}

// ---- Ranges ----

impl<Idx: Eq> Eq for crate::std::ops::Range<Idx> {}
impl<Idx: Eq> Eq for crate::std::ops::RangeInclusive<Idx> {}
impl<Idx: Eq> Eq for crate::std::ops::RangeFrom<Idx> {}
impl<Idx: Eq> Eq for crate::std::ops::RangeTo<Idx> {}
impl<Idx: Eq> Eq for crate::std::ops::RangeToInclusive<Idx> {}
impl Eq for crate::std::ops::RangeFull {}

// Encrypted / packed data deliberately absent: `Enc`, `EncData`, `Pack`,
// `Shared`, and `Mxe` all derive only `PartialEq`, not `Eq`.

// =================== PartialOrd ===================

/// `PartialOrd` recognized by the arcis interpreter.
///
/// # Implementing
///
/// `PartialOrd` is currently **neither derivable nor implementable** inside
/// `#[encrypted]` code. `#[derive(PartialOrd)]` and a hand-written
/// `impl PartialOrd for MyType` are both rejected. This will be revisited in
/// a future PR.
///
/// If you need custom ordering today, you can compare specific fields with
/// the operators below, or wrap a sortable value in a newtype and use that
/// directly in comparisons.
///
/// # Calling
///
/// Inside `#[encrypted]` code, the only supported surface is the comparison
/// operators on the primitive types listed below:
///
/// * `a < b`, `a <= b`, `a > b`, `a >= b`.
///
/// The trait methods themselves — `.partial_cmp()`, `.lt()`, `.le()`,
/// `.gt()`, `.ge()` — are **not** accepted. `Ordering` is not a supported
/// type in `#[encrypted]` code.
///
/// # Implementors
///
/// The impl list below shows the types the interpreter recognizes for the
/// comparison operators. Tuples, arrays, references, and other composites
/// that implement `PartialOrd` in std are deliberately absent here — the
/// interpreter does not accept `<`/`<=`/`>`/`>=` on them.
pub trait PartialOrd {}

impl PartialOrd for crate::std::boolean::bool {}

impl PartialOrd for crate::std::integer::u8 {}
impl PartialOrd for crate::std::integer::u16 {}
impl PartialOrd for crate::std::integer::u32 {}
impl PartialOrd for crate::std::integer::u64 {}
impl PartialOrd for crate::std::integer::u128 {}
impl PartialOrd for crate::std::integer::usize {}

impl PartialOrd for crate::std::integer::i8 {}
impl PartialOrd for crate::std::integer::i16 {}
impl PartialOrd for crate::std::integer::i32 {}
impl PartialOrd for crate::std::integer::i64 {}
impl PartialOrd for crate::std::integer::i128 {}
impl PartialOrd for crate::std::integer::isize {}

impl PartialOrd for crate::std::float::f32 {}
impl PartialOrd for crate::std::float::f64 {}

// =================== Ord ===================

/// `Ord` recognized by the arcis interpreter.
///
/// `Ord` is a marker that [`PartialOrd`] is a true total order. It has no
/// user-facing surface of its own; comparison goes through the same operators
/// listed on `PartialOrd`. Floating-point types are deliberately absent,
/// matching std.
///
/// # Implementing
///
/// `Ord` is currently **neither derivable nor implementable** inside
/// `#[encrypted]` code, for the same reasons as `PartialOrd`. This will be
/// revisited in a future PR.
///
/// # Implementors
pub trait Ord: PartialOrd {}

impl Ord for crate::std::boolean::bool {}

impl Ord for crate::std::integer::u8 {}
impl Ord for crate::std::integer::u16 {}
impl Ord for crate::std::integer::u32 {}
impl Ord for crate::std::integer::u64 {}
impl Ord for crate::std::integer::u128 {}
impl Ord for crate::std::integer::usize {}

impl Ord for crate::std::integer::i8 {}
impl Ord for crate::std::integer::i16 {}
impl Ord for crate::std::integer::i32 {}
impl Ord for crate::std::integer::i64 {}
impl Ord for crate::std::integer::i128 {}
impl Ord for crate::std::integer::isize {}