Contents
- OrdArr <OrdA, A>
- Inst = default(OrdArr<OrdA, A>)
- Equals (Arr<A> x, Arr<A> y)
- Compare (Arr<A> mx, Arr<A> my)
- GetHashCode (Arr<A> x)
- EqualsAsync (Arr<A> x, Arr<A> y)
- GetHashCodeAsync (Arr<A> x)
- CompareAsync (Arr<A> x, Arr<A> y)
- OrdArr <A>
- Inst = default(OrdArr<A>)
- Equals (Arr<A> x, Arr<A> y)
- Compare (Arr<A> mx, Arr<A> my)
- GetHashCode (Arr<A> x)
- EqualsAsync (Arr<A> x, Arr<A> y)
- GetHashCodeAsync (Arr<A> x)
- CompareAsync (Arr<A> x, Arr<A> y)
- OrdArray <OrdA, A>
- Inst = default(OrdArray<OrdA, A>)
- Equals (A[] x, A[] y)
- Compare (A[] mx, A[] my)
- GetHashCode (A[] x)
- EqualsAsync (A[] x, A[] y)
- GetHashCodeAsync (A[] x)
- CompareAsync (A[] x, A[] y)
- OrdArray <A>
- Inst = default(OrdArray<A>)
- Equals (A[] x, A[] y)
- Compare (A[] mx, A[] my)
- GetHashCode (A[] x)
- EqualsAsync (A[] x, A[] y)
- GetHashCodeAsync (A[] x)
- CompareAsync (A[] x, A[] y)
- OrdBigInt
- Inst = default(OrdBigInt)
- Equals (bigint x, bigint y)
- Compare (bigint x, bigint y)
- GetHashCode (bigint x)
- EqualsAsync (bigint x, bigint y)
- GetHashCodeAsync (bigint x)
- CompareAsync (bigint x, bigint y)
- OrdBool
- Inst = default(OrdBool)
- Equals (bool x, bool y)
- Compare (bool x, bool y)
- GetHashCode (bool x)
- EqualsAsync (bool x, bool y)
- GetHashCodeAsync (bool x)
- CompareAsync (bool x, bool y)
- OrdChar
- Inst = default(OrdChar)
- Equals (char x, char y)
- Compare (char x, char y)
- GetHashCode (char x)
- EqualsAsync (char x, char y)
- GetHashCodeAsync (char x)
- CompareAsync (char x, char y)
- OrdChoice <OrdA, OrdB, ChoiceAB, CH, A, B>
- Inst = default(OrdChoice<OrdA, OrdB, ChoiceAB, CH, A, B>)
- Compare (CH x, CH y)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- EqualsAsync (CH x, CH y)
- GetHashCodeAsync (CH x)
- CompareAsync (CH x, CH y)
- OrdChoice <OrdB, ChoiceAB, CH, A, B>
- Inst = default(OrdChoice<OrdB, ChoiceAB, CH, A, B>)
- Compare (CH x, CH y)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- EqualsAsync (CH x, CH y)
- GetHashCodeAsync (CH x)
- CompareAsync (CH x, CH y)
- OrdChoice <ChoiceAB, CH, A, B>
- Inst = default(OrdChoice<ChoiceAB, CH, A, B>)
- Compare (CH x, CH y)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- EqualsAsync (CH x, CH y)
- GetHashCodeAsync (CH x)
- CompareAsync (CH x, CH y)
- OrdChoiceUnsafe <OrdA, OrdB, ChoiceAB, CH, A, B>
- Inst = default(OrdChoiceUnsafe<OrdA, OrdB, ChoiceAB, CH, A, B>)
- Compare (CH x, CH y)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- EqualsAsync (CH x, CH y)
- GetHashCodeAsync (CH x)
- CompareAsync (CH x, CH y)
- OrdChoiceUnsafe <OrdB, ChoiceAB, CH, A, B>
- Inst = default(OrdChoiceUnsafe<OrdB, ChoiceAB, CH, A, B>)
- Compare (CH x, CH y)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- EqualsAsync (CH x, CH y)
- GetHashCodeAsync (CH x)
- CompareAsync (CH x, CH y)
- OrdChoiceUnsafe <ChoiceAB, CH, A, B>
- Inst = default(OrdChoiceUnsafe<ChoiceAB, CH, A, B>)
- Compare (CH x, CH y)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- EqualsAsync (CH x, CH y)
- GetHashCodeAsync (CH x)
- CompareAsync (CH x, CH y)
- OrdDateTime
- Inst = default(OrdDateTime)
- Equals (DateTime x, DateTime y)
- Compare (DateTime x, DateTime y)
- GetHashCode (DateTime x)
- EqualsAsync (DateTime x, DateTime y)
- GetHashCodeAsync (DateTime x)
- CompareAsync (DateTime x, DateTime y)
- OrdDecimal
- Inst = default(OrdDecimal)
- Equals (decimal x, decimal y)
- Compare (decimal x, decimal y)
- GetHashCode (decimal x)
- EqualsAsync (decimal x, decimal y)
- GetHashCodeAsync (decimal x)
- CompareAsync (decimal x, decimal y)
- OrdDefault <A>
- Inst = default(OrdDefault<A>)
- Compare (A x, A y)
- Equals (A x, A y)
- GetHashCode (A x)
- EqualsAsync (A x, A y)
- GetHashCodeAsync (A x)
- CompareAsync (A x, A y)
- OrdDouble
- Inst = default(OrdDouble)
- Equals (double x, double y)
- Compare (double x, double y)
- GetHashCode (double x)
- EqualsAsync (double x, double y)
- GetHashCodeAsync (double x)
- CompareAsync (double x, double y)
- OrdEither <OrdL, OrdR, L, R>
- Compare (Either<L, R> x, Either<L, R> y)
- Equals (Either<L, R> x, Either<L, R> y)
- GetHashCode (Either<L, R> x)
- GetHashCodeAsync (Either<L, R> x)
- EqualsAsync (Either<L, R> x, Either<L, R> y)
- CompareAsync (Either<L, R> x, Either<L, R> y)
- OrdEither <L, R>
- Compare (Either<L, R> x, Either<L, R> y)
- Equals (Either<L, R> x, Either<L, R> y)
- GetHashCode (Either<L, R> x)
- GetHashCodeAsync (Either<L, R> x)
- EqualsAsync (Either<L, R> x, Either<L, R> y)
- CompareAsync (Either<L, R> x, Either<L, R> y)
- OrdEitherUnsafe <OrdL, OrdR, L, R>
- Compare (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
- Equals (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
- GetHashCode (EitherUnsafe<L, R> x)
- GetHashCodeAsync (EitherUnsafe<L, R> x)
- EqualsAsync (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
- CompareAsync (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
- OrdEitherUnsafe <L, R>
- Compare (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
- Equals (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
- GetHashCode (EitherUnsafe<L, R> x)
- GetHashCodeAsync (EitherUnsafe<L, R> x)
- EqualsAsync (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
- CompareAsync (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
- OrdEnumerable <OrdA, A>
- Inst = default(OrdEnumerable<OrdA, A>)
- Equals (IEnumerable<A> x, IEnumerable<A> y)
- Compare (IEnumerable<A> x, IEnumerable<A> y)
- GetHashCode (IEnumerable<A> x)
- EqualsAsync (IEnumerable<A> x, IEnumerable<A> y)
- GetHashCodeAsync (IEnumerable<A> x)
- CompareAsync (IEnumerable<A> x, IEnumerable<A> y)
- OrdEnumerable <A>
- Inst = default(OrdEnumerable<A>)
- Equals (IEnumerable<A> x, IEnumerable<A> y)
- Compare (IEnumerable<A> x, IEnumerable<A> y)
- GetHashCode (IEnumerable<A> x)
- EqualsAsync (IEnumerable<A> x, IEnumerable<A> y)
- GetHashCodeAsync (IEnumerable<A> x)
- CompareAsync (IEnumerable<A> x, IEnumerable<A> y)
- OrdException
- GetHashCode (Exception x)
- Equals (Exception x, Exception y)
- Compare (Exception x, Exception y)
- EqualsAsync (Exception x, Exception y)
- GetHashCodeAsync (Exception x)
- CompareAsync (Exception x, Exception y)
- OrdFloat
- Inst = default(OrdFloat)
- Equals (float x, float y)
- Compare (float x, float y)
- GetHashCode (float x)
- EqualsAsync (float x, float y)
- GetHashCodeAsync (float x)
- CompareAsync (float x, float y)
- OrdGuid
- Inst = default(OrdGuid)
- Equals (Guid x, Guid y)
- Compare (Guid x, Guid y)
- GetHashCode (Guid x)
- EqualsAsync (Guid x, Guid y)
- GetHashCodeAsync (Guid x)
- CompareAsync (Guid x, Guid y)
- OrdHashSet <OrdA, A>
- Inst = default(OrdHashSet<OrdA, A>)
- Equals (HashSet<A> x, HashSet<A> y)
- Compare (HashSet<A> x, HashSet<A> y)
- GetHashCode (HashSet<A> x)
- EqualsAsync (HashSet<A> x, HashSet<A> y)
- GetHashCodeAsync (HashSet<A> x)
- CompareAsync (HashSet<A> x, HashSet<A> y)
- OrdHashSet <A>
- Inst = default(OrdHashSet<A>)
- Equals (HashSet<A> x, HashSet<A> y)
- Compare (HashSet<A> x, HashSet<A> y)
- GetHashCode (HashSet<A> x)
- EqualsAsync (HashSet<A> x, HashSet<A> y)
- GetHashCodeAsync (HashSet<A> x)
- CompareAsync (HashSet<A> x, HashSet<A> y)
- OrdIdentity <A>
- Inst = default(OrdIdentity<A>)
- Compare (Identity<A> a, Identity<A> b)
- Equals (Identity<A> a, Identity<A> b)
- GetHashCode (Identity<A> x)
- EqualsAsync (Identity<A> x, Identity<A> y)
- GetHashCodeAsync (Identity<A> x)
- CompareAsync (Identity<A> x, Identity<A> y)
- OrdInt
- Inst = default(OrdInt)
- Equals (int x, int y)
- Compare (int x, int y)
- GetHashCode (int x)
- EqualsAsync (int x, int y)
- GetHashCodeAsync (int x)
- CompareAsync (int x, int y)
- OrdLong
- Inst = default(OrdLong)
- Equals (long x, long y)
- Compare (long x, long y)
- GetHashCode (long x)
- EqualsAsync (long x, long y)
- GetHashCodeAsync (long x)
- CompareAsync (long x, long y)
- OrdLst <OrdA, A>
- Inst = default(OrdLst<OrdA, A>)
- Equals (Lst<A> x, Lst<A> y)
- Compare (Lst<A> mx, Lst<A> my)
- GetHashCode (Lst<A> x)
- EqualsAsync (Lst<A> x, Lst<A> y)
- GetHashCodeAsync (Lst<A> x)
- CompareAsync (Lst<A> x, Lst<A> y)
- OrdLst <A>
- Inst = default(OrdLst<A>)
- Equals (Lst<A> x, Lst<A> y)
- Compare (Lst<A> x, Lst<A> y)
- GetHashCode (Lst<A> x)
- EqualsAsync (Lst<A> x, Lst<A> y)
- GetHashCodeAsync (Lst<A> x)
- CompareAsync (Lst<A> x, Lst<A> y)
- OrdMap <OrdK, K, V>
- Compare (Map<OrdK, K, V> x, Map<OrdK, K, V> y)
- Equals (Map<OrdK, K, V> x, Map<OrdK, K, V> y)
- GetHashCode (Map<OrdK, K, V> x)
- EqualsAsync (Map<OrdK, K, V> x, Map<OrdK, K, V> y)
- GetHashCodeAsync (Map<OrdK, K, V> x)
- CompareAsync (Map<OrdK, K, V> x, Map<OrdK, K, V> y)
- OrdMap <K, V>
- Compare (Map<K, V> x, Map<K, V> y)
- Equals (Map<K, V> x, Map<K, V> y)
- GetHashCode (Map<K, V> x)
- EqualsAsync (Map<K, V> x, Map<K, V> y)
- GetHashCodeAsync (Map<K, V> x)
- CompareAsync (Map<K, V> x, Map<K, V> y)
- OrdNewType <NEWTYPE, ORD, A>
- Inst = default(OrdNewType<NEWTYPE, ORD, A>)
- Equals (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y)
- Compare (NewType<NEWTYPE, A> mx, NewType<NEWTYPE, A> my)
- GetHashCode (NewType<NEWTYPE, A> x)
- EqualsAsync (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y)
- GetHashCodeAsync (NewType<NEWTYPE, A> x)
- CompareAsync (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y)
- OrdNewType <NEWTYPE, A>
- Inst = default(OrdNewType<NEWTYPE, A>)
- Equals (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y)
- Compare (NewType<NEWTYPE, A> mx, NewType<NEWTYPE, A> my)
- GetHashCode (NewType<NEWTYPE, A> x)
- EqualsAsync (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y)
- GetHashCodeAsync (NewType<NEWTYPE, A> x)
- CompareAsync (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y)
- OrdNewType <NEWTYPE, ORD, A, PRED>
- Inst = default(OrdNewType<NEWTYPE, ORD, A, PRED>)
- Equals (NewType<NEWTYPE, A, PRED, ORD> x, NewType<NEWTYPE, A, PRED, ORD> y)
- Compare (NewType<NEWTYPE, A, PRED, ORD> mx, NewType<NEWTYPE, A, PRED, ORD> my)
- GetHashCode (NewType<NEWTYPE, A, PRED, ORD> x)
- EqualsAsync (NewType<NEWTYPE, A, PRED, ORD> x, NewType<NEWTYPE, A, PRED, ORD> y)
- GetHashCodeAsync (NewType<NEWTYPE, A, PRED, ORD> x)
- CompareAsync (NewType<NEWTYPE, A, PRED, ORD> x, NewType<NEWTYPE, A, PRED, ORD> y)
- OrdNumType <NUMTYPE, NUM, A>
- Inst = default(OrdNumType<NUMTYPE, NUM, A>)
- Equals (NumType<NUMTYPE, NUM, A> x, NumType<NUMTYPE, NUM, A> y)
- Compare (NumType<NUMTYPE, NUM, A> mx, NumType<NUMTYPE, NUM, A> my)
- GetHashCode (NumType<NUMTYPE, NUM, A> x)
- EqualsAsync (NumType<NUMTYPE, NUM, A> x, NumType<NUMTYPE, NUM, A> y)
- GetHashCodeAsync (NumType<NUMTYPE, NUM, A> x)
- CompareAsync (NumType<NUMTYPE, NUM, A> x, NumType<NUMTYPE, NUM, A> y)
- OrdNumType <NUMTYPE, NUM, A, PRED>
- Inst = default(OrdNumType<NUMTYPE, NUM, A, PRED>)
- Equals (NumType<NUMTYPE, NUM, A, PRED> x, NumType<NUMTYPE, NUM, A, PRED> y)
- Compare (NumType<NUMTYPE, NUM, A, PRED> mx, NumType<NUMTYPE, NUM, A, PRED> my)
- GetHashCode (NumType<NUMTYPE, NUM, A, PRED> x)
- EqualsAsync (NumType<NUMTYPE, NUM, A, PRED> x, NumType<NUMTYPE, NUM, A, PRED> y)
- GetHashCodeAsync (NumType<NUMTYPE, NUM, A, PRED> x)
- CompareAsync (NumType<NUMTYPE, NUM, A, PRED> x, NumType<NUMTYPE, NUM, A, PRED> y)
- OrdOption <OrdA, A>
- Compare (Option<A> x, Option<A> y)
- Equals (Option<A> x, Option<A> y)
- GetHashCode (Option<A> x)
- EqualsAsync (Option<A> x, Option<A> y)
- GetHashCodeAsync (Option<A> x)
- CompareAsync (Option<A> x, Option<A> y)
- OrdOption <A>
- Compare (Option<A> x, Option<A> y)
- Equals (Option<A> x, Option<A> y)
- GetHashCode (Option<A> x)
- EqualsAsync (Option<A> x, Option<A> y)
- GetHashCodeAsync (Option<A> x)
- CompareAsync (Option<A> x, Option<A> y)
- OrdOptional <OrdA, OPTION, OA, A>
- Inst = default(OrdOptional<OrdA, OPTION, OA, A>)
- Equals (OA x, OA y)
- Compare (OA mx, OA my)
- GetHashCode (OA x)
- EqualsAsync (OA x, OA y)
- GetHashCodeAsync (OA x)
- CompareAsync (OA x, OA y)
- OrdOptional <OPTION, OA, A>
- Inst = default(OrdOptional<OPTION, OA, A>)
- Equals (OA x, OA y)
- Compare (OA mx, OA my)
- GetHashCode (OA x)
- EqualsAsync (OA x, OA y)
- GetHashCodeAsync (OA x)
- CompareAsync (OA x, OA y)
- OrdOptionalUnsafe <OrdA, OPTION, OA, A>
- Inst = default(OrdOptionalUnsafe<OrdA, OPTION, OA, A>)
- Equals (OA x, OA y)
- Compare (OA mx, OA my)
- GetHashCode (OA x)
- EqualsAsync (OA x, OA y)
- GetHashCodeAsync (OA x)
- CompareAsync (OA x, OA y)
- OrdOptionalUnsafe <OPTION, OA, A>
- Inst = default(OrdOptionalUnsafe<OPTION, OA, A>)
- Equals (OA x, OA y)
- Compare (OA mx, OA my)
- GetHashCode (OA x)
- EqualsAsync (OA x, OA y)
- GetHashCodeAsync (OA x)
- CompareAsync (OA x, OA y)
- OrdOptionUnsafe <OrdA, A>
- Compare (OptionUnsafe<A> x, OptionUnsafe<A> y)
- Equals (OptionUnsafe<A> x, OptionUnsafe<A> y)
- GetHashCode (OptionUnsafe<A> x)
- EqualsAsync (OptionUnsafe<A> x, OptionUnsafe<A> y)
- GetHashCodeAsync (OptionUnsafe<A> x)
- CompareAsync (OptionUnsafe<A> x, OptionUnsafe<A> y)
- OrdOptionUnsafe <A>
- Compare (OptionUnsafe<A> x, OptionUnsafe<A> y)
- Equals (OptionUnsafe<A> x, OptionUnsafe<A> y)
- GetHashCode (OptionUnsafe<A> x)
- EqualsAsync (OptionUnsafe<A> x, OptionUnsafe<A> y)
- GetHashCodeAsync (OptionUnsafe<A> x)
- CompareAsync (OptionUnsafe<A> x, OptionUnsafe<A> y)
- OrdQue <OrdA, A>
- Inst = default(OrdQue<OrdA, A>)
- Equals (Que<A> x, Que<A> y)
- Compare (Que<A> x, Que<A> y)
- GetHashCode (Que<A> x)
- EqualsAsync (Que<A> x, Que<A> y)
- GetHashCodeAsync (Que<A> x)
- CompareAsync (Que<A> x, Que<A> y)
- OrdQue <A>
- Inst = default(OrdQue<A>)
- Equals (Que<A> x, Que<A> y)
- Compare (Que<A> x, Que<A> y)
- GetHashCode (Que<A> x)
- EqualsAsync (Que<A> x, Que<A> y)
- GetHashCodeAsync (Que<A> x)
- CompareAsync (Que<A> x, Que<A> y)
- OrdRecord <A>
- Compare (A x, A y)
- Equals (A x, A y)
- GetHashCode (A x)
- EqualsAsync (A x, A y)
- GetHashCodeAsync (A x)
- CompareAsync (A x, A y)
- OrdResult <A>
- Compare (Result<A> x, Result<A> y)
- Equals (Result<A> x, Result<A> y)
- GetHashCode (Result<A> x)
- EqualsAsync (Result<A> x, Result<A> y)
- GetHashCodeAsync (Result<A> x)
- CompareAsync (Result<A> x, Result<A> y)
- OrdOptionalResult <A>
- Compare (OptionalResult<A> x, OptionalResult<A> y)
- Equals (OptionalResult<A> x, OptionalResult<A> y)
- GetHashCode (OptionalResult<A> x)
- EqualsAsync (OptionalResult<A> x, OptionalResult<A> y)
- GetHashCodeAsync (OptionalResult<A> x)
- CompareAsync (OptionalResult<A> x, OptionalResult<A> y)
- OrdSeq <OrdA, A>
- Inst = default(OrdSeq<OrdA, A>)
- Equals (Seq<A> x, Seq<A> y)
- Compare (Seq<A> x, Seq<A> y)
- GetHashCode (Seq<A> x)
- EqualsAsync (Seq<A> x, Seq<A> y)
- GetHashCodeAsync (Seq<A> x)
- CompareAsync (Seq<A> x, Seq<A> y)
- OrdSeq <A>
- Inst = default(OrdSeq<A>)
- Equals (Seq<A> x, Seq<A> y)
- Compare (Seq<A> x, Seq<A> y)
- GetHashCode (Seq<A> x)
- EqualsAsync (Seq<A> x, Seq<A> y)
- GetHashCodeAsync (Seq<A> x)
- CompareAsync (Seq<A> x, Seq<A> y)
- OrdSet <OrdA, A>
- Inst = default(OrdSet<OrdA, A>)
- Equals (Set<A> x, Set<A> y)
- Compare (Set<A> x, Set<A> y)
- GetHashCode (Set<A> x)
- EqualsAsync (Set<A> x, Set<A> y)
- GetHashCodeAsync (Set<A> x)
- CompareAsync (Set<A> x, Set<A> y)
- OrdSet <A>
- Inst = default(OrdSet<A>)
- Equals (Set<A> x, Set<A> y)
- Compare (Set<A> x, Set<A> y)
- GetHashCode (Set<A> x)
- EqualsAsync (Set<A> x, Set<A> y)
- GetHashCodeAsync (Set<A> x)
- CompareAsync (Set<A> x, Set<A> y)
- OrdShort
- Inst = default(OrdShort)
- Equals (short x, short y)
- Compare (short x, short y)
- GetHashCode (short x)
- EqualsAsync (short x, short y)
- GetHashCodeAsync (short x)
- CompareAsync (short x, short y)
- OrdStck <OrdA, A>
- Inst = default(OrdStck<OrdA, A>)
- Equals (Stck<A> x, Stck<A> y)
- Compare (Stck<A> x, Stck<A> y)
- GetHashCode (Stck<A> x)
- EqualsAsync (Stck<A> x, Stck<A> y)
- GetHashCodeAsync (Stck<A> x)
- CompareAsync (Stck<A> x, Stck<A> y)
- OrdStck <A>
- Inst = default(OrdStck<A>)
- Equals (Stck<A> x, Stck<A> y)
- Compare (Stck<A> x, Stck<A> y)
- GetHashCode (Stck<A> x)
- EqualsAsync (Stck<A> x, Stck<A> y)
- GetHashCodeAsync (Stck<A> x)
- CompareAsync (Stck<A> x, Stck<A> y)
- OrdString
- Inst = default(OrdString)
- Compare (string a, string b)
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- CompareAsync (string x, string y)
- OrdStringOrdinalIgnoreCase
- Inst = default(OrdStringOrdinalIgnoreCase)
- Compare (string a, string b)
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- CompareAsync (string x, string y)
- OrdStringOrdinal
- Inst = default(OrdStringOrdinal)
- Compare (string a, string b)
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- CompareAsync (string x, string y)
- OrdStringCurrentCultureIgnoreCase
- Inst = default(OrdStringCurrentCultureIgnoreCase)
- Compare (string a, string b)
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- CompareAsync (string x, string y)
- OrdStringCurrentCulture
- Inst = default(OrdStringCurrentCulture)
- Compare (string a, string b)
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- CompareAsync (string x, string y)
- OrdTask <A>
- Compare (Task<A> x, Task<A> y)
- Equals (Task<A> x, Task<A> y)
- GetHashCode (Task<A> x)
- EqualsAsync (Task<A> x, Task<A> y)
- GetHashCodeAsync (Task<A> x)
- CompareAsync (Task<A> x, Task<A> y)
- OrdTrue <A>
- Compare (A x, A y)
- Equals (A x, A y)
- GetHashCode (A x)
- EqualsAsync (A x, A y)
- GetHashCodeAsync (A x)
- CompareAsync (A x, A y)
- OrdTry <OrdA, A>
- Compare (Try<A> x, Try<A> y)
- Equals (Try<A> x, Try<A> y)
- GetHashCode (Try<A> x)
- GetHashCodeAsync (Try<A> x)
- EqualsAsync (Try<A> x, Try<A> y)
- CompareAsync (Try<A> x, Try<A> y)
- OrdTry <A>
- Compare (Try<A> x, Try<A> y)
- Equals (Try<A> x, Try<A> y)
- GetHashCode (Try<A> x)
- GetHashCodeAsync (Try<A> x)
- EqualsAsync (Try<A> x, Try<A> y)
- CompareAsync (Try<A> x, Try<A> y)
- OrdTryOption <OrdA, A>
- Compare (TryOption<A> x, TryOption<A> y)
- Equals (TryOption<A> x, TryOption<A> y)
- GetHashCode (TryOption<A> x)
- GetHashCodeAsync (TryOption<A> x)
- EqualsAsync (TryOption<A> x, TryOption<A> y)
- CompareAsync (TryOption<A> x, TryOption<A> y)
- OrdTryOption <A>
- Compare (TryOption<A> x, TryOption<A> y)
- Equals (TryOption<A> x, TryOption<A> y)
- GetHashCode (TryOption<A> x)
- GetHashCodeAsync (TryOption<A> x)
- EqualsAsync (TryOption<A> x, TryOption<A> y)
- CompareAsync (TryOption<A> x, TryOption<A> y)
- OrdTupleFirst <OrdA, A, B>
- Compare ((A, B) x, (A, B) y)
- Equals ((A, B) x, (A, B) y)
- GetHashCode ((A, B) x)
- EqualsAsync ((A, B) x, (A, B) y)
- GetHashCodeAsync ((A, B) x)
- CompareAsync ((A, B) x, (A, B) y)
- OrdTypeInfo
struct OrdArr <OrdA, A> Source #
Equality and ordering
Fields
field OrdArr<OrdA, A> Inst = default(OrdArr<OrdA, A>) Source #
Methods
method bool Equals (Arr<A> x, Arr<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Arr<A> mx, Arr<A> my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Arr<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Arr<A> x, Arr<A> y) Source #
method Task<int> GetHashCodeAsync (Arr<A> x) Source #
method Task<int> CompareAsync (Arr<A> x, Arr<A> y) Source #
Equality and ordering
Fields
field OrdArr<A> Inst = default(OrdArr<A>) Source #
Methods
method bool Equals (Arr<A> x, Arr<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Arr<A> mx, Arr<A> my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Arr<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Arr<A> x, Arr<A> y) Source #
method Task<int> GetHashCodeAsync (Arr<A> x) Source #
method Task<int> CompareAsync (Arr<A> x, Arr<A> y) Source #
struct OrdArray <OrdA, A> Source #
Equality and ordering
Fields
field OrdArray<OrdA, A> Inst = default(OrdArray<OrdA, A>) Source #
Methods
method bool Equals (A[] x, A[] y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (A[] mx, A[] my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (A[] x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (A[] x, A[] y) Source #
method Task<int> GetHashCodeAsync (A[] x) Source #
method Task<int> CompareAsync (A[] x, A[] y) Source #
Equality and ordering
Fields
field OrdArray<A> Inst = default(OrdArray<A>) Source #
Methods
method bool Equals (A[] x, A[] y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (A[] mx, A[] my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (A[] x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (A[] x, A[] y) Source #
method Task<int> GetHashCodeAsync (A[] x) Source #
method Task<int> CompareAsync (A[] x, A[] y) Source #
Equality and ordering
Fields
field OrdBigInt Inst = default(OrdBigInt) Source #
Methods
method bool Equals (bigint x, bigint y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (bigint x, bigint y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (bigint x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (bigint x, bigint y) Source #
method Task<int> GetHashCodeAsync (bigint x) Source #
method Task<int> CompareAsync (bigint x, bigint y) Source #
Equality and ordering
Fields
field OrdBool Inst = default(OrdBool) Source #
Methods
method bool Equals (bool x, bool y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (bool x, bool y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (bool x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (bool x, bool y) Source #
method Task<int> GetHashCodeAsync (bool x) Source #
method Task<int> CompareAsync (bool x, bool y) Source #
Equality and ordering
Fields
field OrdChar Inst = default(OrdChar) Source #
Methods
method bool Equals (char x, char y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (char x, char y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (char x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (char x, char y) Source #
method Task<int> GetHashCodeAsync (char x) Source #
method Task<int> CompareAsync (char x, char y) Source #
struct OrdChoice <OrdA, OrdB, ChoiceAB, CH, A, B> Source #
Compare the equality of any type in the Choice type-class. Taking into account the ordering of both possible bound values.
Fields
field OrdChoice<OrdA, OrdB, ChoiceAB, CH, A, B> Inst = default(OrdChoice<OrdA, OrdB, ChoiceAB, CH, A, B>) Source #
Methods
method int Compare (CH x, CH y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method bool Equals (CH x, CH y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int GetHashCode (CH x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (CH x, CH y) Source #
method Task<int> GetHashCodeAsync (CH x) Source #
method Task<int> CompareAsync (CH x, CH y) Source #
struct OrdChoice <OrdB, ChoiceAB, CH, A, B> Source #
Compare the equality of any type in the Choice type-class. Taking into account only the 'success bound value' of B.
Fields
field OrdChoice<OrdB, ChoiceAB, CH, A, B> Inst = default(OrdChoice<OrdB, ChoiceAB, CH, A, B>) Source #
Methods
method int Compare (CH x, CH y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method bool Equals (CH x, CH y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int GetHashCode (CH x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (CH x, CH y) Source #
method Task<int> GetHashCodeAsync (CH x) Source #
method Task<int> CompareAsync (CH x, CH y) Source #
struct OrdChoice <ChoiceAB, CH, A, B> Source #
Compare the equality of any type in the Choice type-class. Taking into account only the 'success bound value' of B.
Fields
field OrdChoice<ChoiceAB, CH, A, B> Inst = default(OrdChoice<ChoiceAB, CH, A, B>) Source #
Methods
method int Compare (CH x, CH y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method bool Equals (CH x, CH y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int GetHashCode (CH x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (CH x, CH y) Source #
method Task<int> GetHashCodeAsync (CH x) Source #
method Task<int> CompareAsync (CH x, CH y) Source #
struct OrdChoiceUnsafe <OrdA, OrdB, ChoiceAB, CH, A, B> Source #
Compare the equality of any type in the Choice type-class. Taking into account the ordering of both possible bound values.
Fields
field OrdChoiceUnsafe<OrdA, OrdB, ChoiceAB, CH, A, B> Inst = default(OrdChoiceUnsafe<OrdA, OrdB, ChoiceAB, CH, A, B>) Source #
Methods
method int Compare (CH x, CH y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method bool Equals (CH x, CH y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int GetHashCode (CH x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (CH x, CH y) Source #
method Task<int> GetHashCodeAsync (CH x) Source #
method Task<int> CompareAsync (CH x, CH y) Source #
struct OrdChoiceUnsafe <OrdB, ChoiceAB, CH, A, B> Source #
Compare the equality of any type in the Choice type-class. Taking into account only the 'success bound value' of B.
Fields
field OrdChoiceUnsafe<OrdB, ChoiceAB, CH, A, B> Inst = default(OrdChoiceUnsafe<OrdB, ChoiceAB, CH, A, B>) Source #
Methods
method int Compare (CH x, CH y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method bool Equals (CH x, CH y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int GetHashCode (CH x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (CH x, CH y) Source #
method Task<int> GetHashCodeAsync (CH x) Source #
method Task<int> CompareAsync (CH x, CH y) Source #
struct OrdChoiceUnsafe <ChoiceAB, CH, A, B> Source #
Compare the equality of any type in the Choice type-class. Taking into account only the 'success bound value' of B.
Fields
field OrdChoiceUnsafe<ChoiceAB, CH, A, B> Inst = default(OrdChoiceUnsafe<ChoiceAB, CH, A, B>) Source #
Methods
method int Compare (CH x, CH y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method bool Equals (CH x, CH y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int GetHashCode (CH x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (CH x, CH y) Source #
method Task<int> GetHashCodeAsync (CH x) Source #
method Task<int> CompareAsync (CH x, CH y) Source #
struct OrdDateTime Source #
Equality and ordering
Fields
field OrdDateTime Inst = default(OrdDateTime) Source #
Methods
method bool Equals (DateTime x, DateTime y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (DateTime x, DateTime y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (DateTime x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (DateTime x, DateTime y) Source #
method Task<int> GetHashCodeAsync (DateTime x) Source #
method Task<int> CompareAsync (DateTime x, DateTime y) Source #
struct OrdDecimal Source #
Equality and ordering
Fields
field OrdDecimal Inst = default(OrdDecimal) Source #
Methods
method bool Equals (decimal x, decimal y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (decimal x, decimal y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (decimal x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (decimal x, decimal y) Source #
method Task<int> GetHashCodeAsync (decimal x) Source #
method Task<int> CompareAsync (decimal x, decimal y) Source #
struct OrdDefault <A> Source #
Uses the standard .NET Comparer.Default.Compare(a,b) method to provide equality testing.
Fields
field OrdDefault<A> Inst = default(OrdDefault<A>) Source #
Methods
method int Compare (A x, A y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int GetHashCode (A x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (A x, A y) Source #
method Task<int> GetHashCodeAsync (A x) Source #
method Task<int> CompareAsync (A x, A y) Source #
Equality and ordering
Fields
field OrdDouble Inst = default(OrdDouble) Source #
Methods
method bool Equals (double x, double y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (double x, double y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (double x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (double x, double y) Source #
method Task<int> GetHashCodeAsync (double x) Source #
method Task<int> CompareAsync (double x, double y) Source #
struct OrdEither <OrdL, OrdR, L, R> Source #
Either type hashing
Methods
method int GetHashCode (Either<L, R> x) Source #
Get hash code of the value
Parameters
| param | x | Value to get the hash code of |
| returns | The hash code of x | |
method Task<int> GetHashCodeAsync (Either<L, R> x) Source #
Get hash code of the value
Parameters
| param | x | Value to get the hash code of |
| returns | The hash code of x | |
method Task<bool> EqualsAsync (Either<L, R> x, Either<L, R> y) Source #
Equality test
method Task<int> CompareAsync (Either<L, R> x, Either<L, R> y) Source #
struct OrdEither <L, R> Source #
Either type hashing
Methods
method int GetHashCode (Either<L, R> x) Source #
Get hash code of the value
Parameters
| param | x | Value to get the hash code of |
| returns | The hash code of x | |
method Task<int> GetHashCodeAsync (Either<L, R> x) Source #
Get hash code of the value
Parameters
| param | x | Value to get the hash code of |
| returns | The hash code of x | |
method Task<bool> EqualsAsync (Either<L, R> x, Either<L, R> y) Source #
Equality test
method Task<int> CompareAsync (Either<L, R> x, Either<L, R> y) Source #
struct OrdEitherUnsafe <OrdL, OrdR, L, R> Source #
Either type hashing
Methods
method int GetHashCode (EitherUnsafe<L, R> x) Source #
Get hash code of the value
Parameters
| param | x | Value to get the hash code of |
| returns | The hash code of x | |
method Task<int> GetHashCodeAsync (EitherUnsafe<L, R> x) Source #
Get hash code of the value
Parameters
| param | x | Value to get the hash code of |
| returns | The hash code of x | |
method Task<bool> EqualsAsync (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y) Source #
Equality test
method Task<int> CompareAsync (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y) Source #
struct OrdEitherUnsafe <L, R> Source #
Either type hashing
Methods
method int GetHashCode (EitherUnsafe<L, R> x) Source #
Get hash code of the value
Parameters
| param | x | Value to get the hash code of |
| returns | The hash code of x | |
method Task<int> GetHashCodeAsync (EitherUnsafe<L, R> x) Source #
Get hash code of the value
Parameters
| param | x | Value to get the hash code of |
| returns | The hash code of x | |
method Task<bool> EqualsAsync (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y) Source #
Equality test
method Task<int> CompareAsync (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y) Source #
struct OrdEnumerable <OrdA, A> Source #
Equality and ordering
Fields
field OrdEnumerable<OrdA, A> Inst = default(OrdEnumerable<OrdA, A>) Source #
Methods
method bool Equals (IEnumerable<A> x, IEnumerable<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (IEnumerable<A> x, IEnumerable<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (IEnumerable<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (IEnumerable<A> x, IEnumerable<A> y) Source #
method Task<int> GetHashCodeAsync (IEnumerable<A> x) Source #
method Task<int> CompareAsync (IEnumerable<A> x, IEnumerable<A> y) Source #
struct OrdEnumerable <A> Source #
Equality and ordering
Fields
field OrdEnumerable<A> Inst = default(OrdEnumerable<A>) Source #
Methods
method bool Equals (IEnumerable<A> x, IEnumerable<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (IEnumerable<A> x, IEnumerable<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (IEnumerable<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (IEnumerable<A> x, IEnumerable<A> y) Source #
method Task<int> GetHashCodeAsync (IEnumerable<A> x) Source #
method Task<int> CompareAsync (IEnumerable<A> x, IEnumerable<A> y) Source #
struct OrdException Source #
Methods
method int GetHashCode (Exception x) Source #
method Task<bool> EqualsAsync (Exception x, Exception y) Source #
method Task<int> GetHashCodeAsync (Exception x) Source #
method Task<int> CompareAsync (Exception x, Exception y) Source #
Equality and ordering
Fields
field OrdFloat Inst = default(OrdFloat) Source #
Methods
method bool Equals (float x, float y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (float x, float y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (float x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (float x, float y) Source #
method Task<int> GetHashCodeAsync (float x) Source #
method Task<int> CompareAsync (float x, float y) Source #
Equality and ordering
Fields
field OrdGuid Inst = default(OrdGuid) Source #
Methods
method bool Equals (Guid x, Guid y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Guid x, Guid y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Guid x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Guid x, Guid y) Source #
method Task<int> GetHashCodeAsync (Guid x) Source #
method Task<int> CompareAsync (Guid x, Guid y) Source #
struct OrdHashSet <OrdA, A> Source #
Equality and ordering
Fields
field OrdHashSet<OrdA, A> Inst = default(OrdHashSet<OrdA, A>) Source #
Methods
method bool Equals (HashSet<A> x, HashSet<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (HashSet<A> x, HashSet<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (HashSet<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (HashSet<A> x, HashSet<A> y) Source #
method Task<int> GetHashCodeAsync (HashSet<A> x) Source #
method Task<int> CompareAsync (HashSet<A> x, HashSet<A> y) Source #
struct OrdHashSet <A> Source #
Equality and ordering
Fields
field OrdHashSet<A> Inst = default(OrdHashSet<A>) Source #
Methods
method bool Equals (HashSet<A> x, HashSet<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (HashSet<A> x, HashSet<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (HashSet<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (HashSet<A> x, HashSet<A> y) Source #
method Task<int> GetHashCodeAsync (HashSet<A> x) Source #
method Task<int> CompareAsync (HashSet<A> x, HashSet<A> y) Source #
struct OrdIdentity <A> Source #
Identity equality
Fields
field OrdIdentity<A> Inst = default(OrdIdentity<A>) Source #
Methods
method int Compare (Identity<A> a, Identity<A> b) Source #
Ordering test
Parameters
| param | x | The left hand side of the ordering operation |
| param | y | The right hand side of the ordering operation |
| returns | -1 if less than, 0 if equal, 1 if greater than | |
method bool Equals (Identity<A> a, Identity<A> b) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int GetHashCode (Identity<A> x) Source #
Get hash code of the value
Parameters
| param | x | Value to get the hash code of |
| returns | The hash code of x | |
method Task<bool> EqualsAsync (Identity<A> x, Identity<A> y) Source #
method Task<int> GetHashCodeAsync (Identity<A> x) Source #
method Task<int> CompareAsync (Identity<A> x, Identity<A> y) Source #
Equality and ordering
Fields
field OrdInt Inst = default(OrdInt) Source #
Methods
method bool Equals (int x, int y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (int x, int y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (int x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (int x, int y) Source #
method Task<int> GetHashCodeAsync (int x) Source #
method Task<int> CompareAsync (int x, int y) Source #
Equality and ordering
Fields
field OrdLong Inst = default(OrdLong) Source #
Methods
method bool Equals (long x, long y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (long x, long y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (long x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (long x, long y) Source #
method Task<int> GetHashCodeAsync (long x) Source #
method Task<int> CompareAsync (long x, long y) Source #
struct OrdLst <OrdA, A> Source #
Equality and ordering
Fields
field OrdLst<OrdA, A> Inst = default(OrdLst<OrdA, A>) Source #
Methods
method bool Equals (Lst<A> x, Lst<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Lst<A> mx, Lst<A> my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Lst<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Lst<A> x, Lst<A> y) Source #
method Task<int> GetHashCodeAsync (Lst<A> x) Source #
method Task<int> CompareAsync (Lst<A> x, Lst<A> y) Source #
Equality and ordering
Fields
field OrdLst<A> Inst = default(OrdLst<A>) Source #
Methods
method bool Equals (Lst<A> x, Lst<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Lst<A> x, Lst<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Lst<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Lst<A> x, Lst<A> y) Source #
method Task<int> GetHashCodeAsync (Lst<A> x) Source #
method Task<int> CompareAsync (Lst<A> x, Lst<A> y) Source #
struct OrdMap <OrdK, K, V> Source #
Equality and ordering
Methods
method int Compare (Map<OrdK, K, V> x, Map<OrdK, K, V> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if | |
method bool Equals (Map<OrdK, K, V> x, Map<OrdK, K, V> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if | |
method int GetHashCode (Map<OrdK, K, V> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of | |
method Task<bool> EqualsAsync (Map<OrdK, K, V> x, Map<OrdK, K, V> y) Source #
method Task<int> GetHashCodeAsync (Map<OrdK, K, V> x) Source #
method Task<int> CompareAsync (Map<OrdK, K, V> x, Map<OrdK, K, V> y) Source #
Equality and ordering
Methods
method int Compare (Map<K, V> x, Map<K, V> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if | |
method bool Equals (Map<K, V> x, Map<K, V> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if | |
method int GetHashCode (Map<K, V> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of | |
method Task<bool> EqualsAsync (Map<K, V> x, Map<K, V> y) Source #
method Task<int> GetHashCodeAsync (Map<K, V> x) Source #
method Task<int> CompareAsync (Map<K, V> x, Map<K, V> y) Source #
struct OrdNewType <NEWTYPE, ORD, A> Source #
Compare the equality and ordering of any type in the NewType type-class
Fields
field OrdNewType<NEWTYPE, ORD, A> Inst = default(OrdNewType<NEWTYPE, ORD, A>) Source #
Methods
method bool Equals (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (NewType<NEWTYPE, A> mx, NewType<NEWTYPE, A> my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (NewType<NEWTYPE, A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y) Source #
method Task<int> GetHashCodeAsync (NewType<NEWTYPE, A> x) Source #
method Task<int> CompareAsync (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y) Source #
struct OrdNewType <NEWTYPE, A> Source #
Compare the equality and ordering of any type in the NewType type-class
Fields
field OrdNewType<NEWTYPE, A> Inst = default(OrdNewType<NEWTYPE, A>) Source #
Methods
method bool Equals (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (NewType<NEWTYPE, A> mx, NewType<NEWTYPE, A> my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (NewType<NEWTYPE, A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y) Source #
method Task<int> GetHashCodeAsync (NewType<NEWTYPE, A> x) Source #
method Task<int> CompareAsync (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y) Source #
struct OrdNewType <NEWTYPE, ORD, A, PRED> Source #
Compare the equality and ordering of any type in the NewType type-class
Fields
field OrdNewType<NEWTYPE, ORD, A, PRED> Inst = default(OrdNewType<NEWTYPE, ORD, A, PRED>) Source #
Methods
method bool Equals (NewType<NEWTYPE, A, PRED, ORD> x, NewType<NEWTYPE, A, PRED, ORD> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (NewType<NEWTYPE, A, PRED, ORD> mx, NewType<NEWTYPE, A, PRED, ORD> my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (NewType<NEWTYPE, A, PRED, ORD> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (NewType<NEWTYPE, A, PRED, ORD> x, NewType<NEWTYPE, A, PRED, ORD> y) Source #
method Task<int> GetHashCodeAsync (NewType<NEWTYPE, A, PRED, ORD> x) Source #
method Task<int> CompareAsync (NewType<NEWTYPE, A, PRED, ORD> x, NewType<NEWTYPE, A, PRED, ORD> y) Source #
struct OrdNumType <NUMTYPE, NUM, A> Source #
Compare the equality and ordering of any type in the NumType type-class
Fields
field OrdNumType<NUMTYPE, NUM, A> Inst = default(OrdNumType<NUMTYPE, NUM, A>) Source #
Methods
method bool Equals (NumType<NUMTYPE, NUM, A> x, NumType<NUMTYPE, NUM, A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (NumType<NUMTYPE, NUM, A> mx, NumType<NUMTYPE, NUM, A> my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (NumType<NUMTYPE, NUM, A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (NumType<NUMTYPE, NUM, A> x, NumType<NUMTYPE, NUM, A> y) Source #
method Task<int> GetHashCodeAsync (NumType<NUMTYPE, NUM, A> x) Source #
method Task<int> CompareAsync (NumType<NUMTYPE, NUM, A> x, NumType<NUMTYPE, NUM, A> y) Source #
struct OrdNumType <NUMTYPE, NUM, A, PRED> Source #
Compare the equality and ordering of any type in the NumType type-class
Fields
field OrdNumType<NUMTYPE, NUM, A, PRED> Inst = default(OrdNumType<NUMTYPE, NUM, A, PRED>) Source #
Methods
method bool Equals (NumType<NUMTYPE, NUM, A, PRED> x, NumType<NUMTYPE, NUM, A, PRED> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (NumType<NUMTYPE, NUM, A, PRED> mx, NumType<NUMTYPE, NUM, A, PRED> my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (NumType<NUMTYPE, NUM, A, PRED> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (NumType<NUMTYPE, NUM, A, PRED> x, NumType<NUMTYPE, NUM, A, PRED> y) Source #
method Task<int> GetHashCodeAsync (NumType<NUMTYPE, NUM, A, PRED> x) Source #
method Task<int> CompareAsync (NumType<NUMTYPE, NUM, A, PRED> x, NumType<NUMTYPE, NUM, A, PRED> y) Source #
struct OrdOption <OrdA, A> Source #
Methods
method int GetHashCode (Option<A> x) Source #
method Task<bool> EqualsAsync (Option<A> x, Option<A> y) Source #
method Task<int> GetHashCodeAsync (Option<A> x) Source #
method Task<int> CompareAsync (Option<A> x, Option<A> y) Source #
Methods
method int GetHashCode (Option<A> x) Source #
method Task<bool> EqualsAsync (Option<A> x, Option<A> y) Source #
method Task<int> GetHashCodeAsync (Option<A> x) Source #
method Task<int> CompareAsync (Option<A> x, Option<A> y) Source #
struct OrdOptional <OrdA, OPTION, OA, A> Source #
Compare the equality and ordering of any type in the Optional type-class
Fields
field OrdOptional<OrdA, OPTION, OA, A> Inst = default(OrdOptional<OrdA, OPTION, OA, A>) Source #
Methods
method bool Equals (OA x, OA y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (OA mx, OA my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (OA x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (OA x, OA y) Source #
method Task<int> GetHashCodeAsync (OA x) Source #
method Task<int> CompareAsync (OA x, OA y) Source #
struct OrdOptional <OPTION, OA, A> Source #
Compare the equality and ordering of any type in the Optional type-class
Fields
field OrdOptional<OPTION, OA, A> Inst = default(OrdOptional<OPTION, OA, A>) Source #
Methods
method bool Equals (OA x, OA y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (OA mx, OA my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (OA x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (OA x, OA y) Source #
method Task<int> GetHashCodeAsync (OA x) Source #
method Task<int> CompareAsync (OA x, OA y) Source #
struct OrdOptionalUnsafe <OrdA, OPTION, OA, A> Source #
Compare the equality and ordering of any type in the Optional type-class
Fields
field OrdOptionalUnsafe<OrdA, OPTION, OA, A> Inst = default(OrdOptionalUnsafe<OrdA, OPTION, OA, A>) Source #
Methods
method bool Equals (OA x, OA y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (OA mx, OA my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (OA x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (OA x, OA y) Source #
method Task<int> GetHashCodeAsync (OA x) Source #
method Task<int> CompareAsync (OA x, OA y) Source #
struct OrdOptionalUnsafe <OPTION, OA, A> Source #
Compare the equality and ordering of any type in the Optional type-class
Fields
field OrdOptionalUnsafe<OPTION, OA, A> Inst = default(OrdOptionalUnsafe<OPTION, OA, A>) Source #
Methods
method bool Equals (OA x, OA y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (OA mx, OA my) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (OA x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (OA x, OA y) Source #
method Task<int> GetHashCodeAsync (OA x) Source #
method Task<int> CompareAsync (OA x, OA y) Source #
struct OrdOptionUnsafe <OrdA, A> Source #
Methods
method int GetHashCode (OptionUnsafe<A> x) Source #
method Task<bool> EqualsAsync (OptionUnsafe<A> x, OptionUnsafe<A> y) Source #
method Task<int> GetHashCodeAsync (OptionUnsafe<A> x) Source #
method Task<int> CompareAsync (OptionUnsafe<A> x, OptionUnsafe<A> y) Source #
struct OrdOptionUnsafe <A> Source #
Methods
method int GetHashCode (OptionUnsafe<A> x) Source #
method Task<bool> EqualsAsync (OptionUnsafe<A> x, OptionUnsafe<A> y) Source #
method Task<int> GetHashCodeAsync (OptionUnsafe<A> x) Source #
method Task<int> CompareAsync (OptionUnsafe<A> x, OptionUnsafe<A> y) Source #
struct OrdQue <OrdA, A> Source #
Equality and ordering
Fields
field OrdQue<OrdA, A> Inst = default(OrdQue<OrdA, A>) Source #
Methods
method bool Equals (Que<A> x, Que<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Que<A> x, Que<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Que<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Que<A> x, Que<A> y) Source #
method Task<int> GetHashCodeAsync (Que<A> x) Source #
method Task<int> CompareAsync (Que<A> x, Que<A> y) Source #
Equality and ordering
Fields
field OrdQue<A> Inst = default(OrdQue<A>) Source #
Methods
method bool Equals (Que<A> x, Que<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Que<A> x, Que<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Que<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Que<A> x, Que<A> y) Source #
method Task<int> GetHashCodeAsync (Que<A> x) Source #
method Task<int> CompareAsync (Que<A> x, Que<A> y) Source #
Ordering class instance for all record types
Parameters
| type | A | Record type |
Methods
method int GetHashCode (A x) Source #
method Task<bool> EqualsAsync (A x, A y) Source #
method Task<int> GetHashCodeAsync (A x) Source #
method Task<int> CompareAsync (A x, A y) Source #
Methods
method int GetHashCode (Result<A> x) Source #
method Task<bool> EqualsAsync (Result<A> x, Result<A> y) Source #
method Task<int> GetHashCodeAsync (Result<A> x) Source #
method Task<int> CompareAsync (Result<A> x, Result<A> y) Source #
struct OrdOptionalResult <A> Source #
Methods
method int GetHashCode (OptionalResult<A> x) Source #
method Task<bool> EqualsAsync (OptionalResult<A> x, OptionalResult<A> y) Source #
method Task<int> GetHashCodeAsync (OptionalResult<A> x) Source #
method Task<int> CompareAsync (OptionalResult<A> x, OptionalResult<A> y) Source #
struct OrdSeq <OrdA, A> Source #
Equality and ordering
Fields
field OrdSeq<OrdA, A> Inst = default(OrdSeq<OrdA, A>) Source #
Methods
method bool Equals (Seq<A> x, Seq<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Seq<A> x, Seq<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Seq<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Seq<A> x, Seq<A> y) Source #
method Task<int> GetHashCodeAsync (Seq<A> x) Source #
method Task<int> CompareAsync (Seq<A> x, Seq<A> y) Source #
Equality and ordering
Fields
field OrdSeq<A> Inst = default(OrdSeq<A>) Source #
Methods
method bool Equals (Seq<A> x, Seq<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Seq<A> x, Seq<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Seq<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Seq<A> x, Seq<A> y) Source #
method Task<int> GetHashCodeAsync (Seq<A> x) Source #
method Task<int> CompareAsync (Seq<A> x, Seq<A> y) Source #
struct OrdSet <OrdA, A> Source #
Equality and ordering
Fields
field OrdSet<OrdA, A> Inst = default(OrdSet<OrdA, A>) Source #
Methods
method bool Equals (Set<A> x, Set<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Set<A> x, Set<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Set<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Set<A> x, Set<A> y) Source #
method Task<int> GetHashCodeAsync (Set<A> x) Source #
method Task<int> CompareAsync (Set<A> x, Set<A> y) Source #
Equality and ordering
Fields
field OrdSet<A> Inst = default(OrdSet<A>) Source #
Methods
method bool Equals (Set<A> x, Set<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Set<A> x, Set<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Set<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Set<A> x, Set<A> y) Source #
method Task<int> GetHashCodeAsync (Set<A> x) Source #
method Task<int> CompareAsync (Set<A> x, Set<A> y) Source #
Equality and ordering
Fields
field OrdShort Inst = default(OrdShort) Source #
Methods
method bool Equals (short x, short y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (short x, short y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (short x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (short x, short y) Source #
method Task<int> GetHashCodeAsync (short x) Source #
method Task<int> CompareAsync (short x, short y) Source #
struct OrdStck <OrdA, A> Source #
Equality and ordering
Fields
field OrdStck<OrdA, A> Inst = default(OrdStck<OrdA, A>) Source #
Methods
method bool Equals (Stck<A> x, Stck<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Stck<A> x, Stck<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Stck<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Stck<A> x, Stck<A> y) Source #
method Task<int> GetHashCodeAsync (Stck<A> x) Source #
method Task<int> CompareAsync (Stck<A> x, Stck<A> y) Source #
Equality and ordering
Fields
field OrdStck<A> Inst = default(OrdStck<A>) Source #
Methods
method bool Equals (Stck<A> x, Stck<A> y) Source #
Equality test
Parameters
| param | x | The left hand side of the equality operation |
| param | y | The right hand side of the equality operation |
| returns | True if x and y are equal | |
method int Compare (Stck<A> x, Stck<A> y) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if x greater than y : 1 if x less than y : -1 if x equals y : 0 | |
method int GetHashCode (Stck<A> x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (Stck<A> x, Stck<A> y) Source #
method Task<int> GetHashCodeAsync (Stck<A> x) Source #
method Task<int> CompareAsync (Stck<A> x, Stck<A> y) Source #
String comparison
Fields
field OrdString Inst = default(OrdString) Source #
Methods
method int Compare (string a, string b) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if a greater than b : 1 if a less than b : -1 if a equals b : 0 | |
method bool Equals (string a, string b) Source #
Equality test
Parameters
| param | a | The left hand side of the equality operation |
| param | b | The right hand side of the equality operation |
| returns | True if a and b are equal | |
method int GetHashCode (string x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) Source #
method Task<int> CompareAsync (string x, string y) Source #
struct OrdStringOrdinalIgnoreCase Source #
String comparison (ordinal, ignore case)
Fields
field OrdStringOrdinalIgnoreCase Inst = default(OrdStringOrdinalIgnoreCase) Source #
Methods
method int Compare (string a, string b) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if a greater than b : 1 if a less than b : -1 if a equals b : 0 | |
method bool Equals (string a, string b) Source #
Equality test
Parameters
| param | a | The left hand side of the equality operation |
| param | b | The right hand side of the equality operation |
| returns | True if a and b are equal | |
method int GetHashCode (string x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) Source #
method Task<int> CompareAsync (string x, string y) Source #
struct OrdStringOrdinal Source #
String comparison (ordinal)
Fields
field OrdStringOrdinal Inst = default(OrdStringOrdinal) Source #
Methods
method int Compare (string a, string b) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if a greater than b : 1 if a less than b : -1 if a equals b : 0 | |
method bool Equals (string a, string b) Source #
Equality test
Parameters
| param | a | The left hand side of the equality operation |
| param | b | The right hand side of the equality operation |
| returns | True if a and b are equal | |
method int GetHashCode (string x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) Source #
method Task<int> CompareAsync (string x, string y) Source #
struct OrdStringCurrentCultureIgnoreCase Source #
String comparison (current culture, ignore case)
Fields
field OrdStringCurrentCultureIgnoreCase Inst = default(OrdStringCurrentCultureIgnoreCase) Source #
Methods
method int Compare (string a, string b) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if a greater than b : 1 if a less than b : -1 if a equals b : 0 | |
method bool Equals (string a, string b) Source #
Equality test
Parameters
| param | a | The left hand side of the equality operation |
| param | b | The right hand side of the equality operation |
| returns | True if a and b are equal | |
method int GetHashCode (string x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) Source #
method Task<int> CompareAsync (string x, string y) Source #
struct OrdStringCurrentCulture Source #
String comparison (current culture)
Fields
field OrdStringCurrentCulture Inst = default(OrdStringCurrentCulture) Source #
Methods
method int Compare (string a, string b) Source #
Compare two values
Parameters
| param | x | Left hand side of the compare operation |
| param | y | Right hand side of the compare operation |
| returns | if a greater than b : 1 if a less than b : -1 if a equals b : 0 | |
method bool Equals (string a, string b) Source #
Equality test
Parameters
| param | a | The left hand side of the equality operation |
| param | b | The right hand side of the equality operation |
| returns | True if a and b are equal | |
method int GetHashCode (string x) Source #
Get the hash-code of the provided value
Parameters
| returns | Hash code of x | |
method Task<bool> EqualsAsync (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) Source #
method Task<int> CompareAsync (string x, string y) Source #
Methods
method int GetHashCode (Task<A> x) Source #
method Task<bool> EqualsAsync (Task<A> x, Task<A> y) Source #
method Task<int> GetHashCodeAsync (Task<A> x) Source #
method Task<int> CompareAsync (Task<A> x, Task<A> y) Source #
Always returns true for equality checks and 0 for ordering
Methods
method int GetHashCode (A x) Source #
method Task<bool> EqualsAsync (A x, A y) Source #
method Task<int> GetHashCodeAsync (A x) Source #
method Task<int> CompareAsync (A x, A y) Source #
struct OrdTry <OrdA, A> Source #
Methods
method int GetHashCode (Try<A> x) Source #
method Task<int> GetHashCodeAsync (Try<A> x) Source #
method Task<bool> EqualsAsync (Try<A> x, Try<A> y) Source #
method Task<int> CompareAsync (Try<A> x, Try<A> y) Source #
Methods
method int GetHashCode (Try<A> x) Source #
method Task<int> GetHashCodeAsync (Try<A> x) Source #
method Task<bool> EqualsAsync (Try<A> x, Try<A> y) Source #
method Task<int> CompareAsync (Try<A> x, Try<A> y) Source #
struct OrdTryOption <OrdA, A> Source #
Methods
method int GetHashCode (TryOption<A> x) Source #
method Task<int> GetHashCodeAsync (TryOption<A> x) Source #
method Task<bool> EqualsAsync (TryOption<A> x, TryOption<A> y) Source #
method Task<int> CompareAsync (TryOption<A> x, TryOption<A> y) Source #
struct OrdTryOption <A> Source #
Methods
method int GetHashCode (TryOption<A> x) Source #
method Task<int> GetHashCodeAsync (TryOption<A> x) Source #
method Task<bool> EqualsAsync (TryOption<A> x, TryOption<A> y) Source #
method Task<int> CompareAsync (TryOption<A> x, TryOption<A> y) Source #
struct OrdTupleFirst <OrdA, A, B> Source #
Ord instance for a pair tuple. It orders using the first item in the tuple only and the provided OrdA.
Methods
method int GetHashCode ((A, B) x) Source #
method Task<bool> EqualsAsync ((A, B) x, (A, B) y) Source #
method Task<int> GetHashCodeAsync ((A, B) x) Source #
method Task<int> CompareAsync ((A, B) x, (A, B) y) Source #
struct OrdTypeInfo Source #
Methods
method int GetHashCode (TypeInfo x) Source #
method Task<bool> EqualsAsync (TypeInfo x, TypeInfo y) Source #
method Task<int> GetHashCodeAsync (TypeInfo x) Source #
method Task<int> CompareAsync (TypeInfo x, TypeInfo y) Source #