Contents
- EqArr <EqA, A>
- Inst = default(EqArr<EqA, A>)
- Equals (Arr<A> x, Arr<A> y)
- GetHashCode (Arr<A> x)
- EqualsAsync (Arr<A> x, Arr<A> y)
- GetHashCodeAsync (Arr<A> x)
- EqArr <A>
- Inst = default(EqArr<A>)
- Equals (Arr<A> x, Arr<A> y)
- GetHashCode (Arr<A> x)
- EqualsAsync (Arr<A> x, Arr<A> y)
- GetHashCodeAsync (Arr<A> x)
- EqArray <EqA, A>
- Inst = default(EqArray<EqA, A>)
- Equals (A[] x, A[] y)
- GetHashCode (A[] x)
- EqualsAsync (A[] x, A[] y)
- GetHashCodeAsync (A[] x)
- EqArray <A>
- Inst = default(EqArray<A>)
- Equals (A[] x, A[] y)
- GetHashCode (A[] x)
- EqualsAsync (A[] x, A[] y)
- GetHashCodeAsync (A[] x)
- EqBigInt
- Inst = default(EqBigInt)
- Equals (bigint a, bigint b)
- GetHashCode (bigint x)
- EqualsAsync (bigint x, bigint y)
- GetHashCodeAsync (bigint x)
- EqBool
- Inst = default(EqBool)
- Equals (bool a, bool b)
- GetHashCode (bool x)
- EqualsAsync (bool x, bool y)
- GetHashCodeAsync (bool x)
- EqChar
- Inst = default(EqChar)
- Equals (char a, char b)
- GetHashCode (char x)
- EqualsAsync (char x, char y)
- GetHashCodeAsync (char x)
- EqCharOrdinalIgnoreCase
- Inst = default(EqCharOrdinalIgnoreCase)
- Equals (char a, char b)
- GetHashCode (char x)
- EqualsAsync (char x, char y)
- GetHashCodeAsync (char x)
- EqChoice <EQA, EQB, CHOICE, CH, A, B>
- Inst = default(EqChoice<EQA, EQB, CHOICE, CH, A, B>)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- EqualsAsync (CH x, CH y)
- GetHashCodeAsync (CH x)
- EqChoice <EQB, CHOICE, CH, A, B>
- Inst = default(EqChoice<EQB, CHOICE, CH, A, B>)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- GetHashCodeAsync (CH x)
- EqualsAsync (CH x, CH y)
- EqChoice <CHOICE, CH, A, B>
- Inst = default(EqChoice<CHOICE, CH, A, B>)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- EqualsAsync (CH x, CH y)
- GetHashCodeAsync (CH x)
- EqChoiceUnsafe <EQA, EQB, CHOICE, CH, A, B>
- Inst = default(EqChoiceUnsafe<EQA, EQB, CHOICE, CH, A, B>)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- EqualsAsync (CH x, CH y)
- GetHashCodeAsync (CH x)
- EqChoiceUnsafe <EQB, CHOICE, CH, A, B>
- Inst = default(EqChoiceUnsafe<EQB, CHOICE, CH, A, B>)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- EqualsAsync (CH x, CH y)
- GetHashCodeAsync (CH x)
- EqChoiceUnsafe <CHOICE, CH, A, B>
- Inst = default(EqChoiceUnsafe<CHOICE, CH, A, B>)
- Equals (CH x, CH y)
- GetHashCode (CH x)
- EqualsAsync (CH x, CH y)
- GetHashCodeAsync (CH x)
- EqCompositions <A>
- Equals (Compositions<A> x, Compositions<A> y)
- GetHashCode (Compositions<A> x)
- EqualsAsync (Compositions<A> x, Compositions<A> y)
- GetHashCodeAsync (Compositions<A> x)
- EqDateTime
- Inst = default(EqDateTime)
- Equals (DateTime a, DateTime b)
- GetHashCode (DateTime x)
- EqualsAsync (DateTime x, DateTime y)
- GetHashCodeAsync (DateTime x)
- EqDecimal
- Inst = default(EqDecimal)
- Equals (decimal a, decimal b)
- GetHashCode (decimal x)
- EqualsAsync (decimal x, decimal y)
- GetHashCodeAsync (decimal x)
- EqDefault <A>
- Inst = default(EqDefault<A>)
- Equals (A a, A b)
- GetHashCode (A x)
- EqualsAsync (A x, A y)
- GetHashCodeAsync (A x)
- EqDefault <A, B>
- EqDouble
- Inst = default(EqDouble)
- Equals (double a, double b)
- GetHashCode (double x)
- EqualsAsync (double x, double y)
- GetHashCodeAsync (double x)
- EqEdit <EqA, A>
- Equals (Edit<EqA, A> x, Edit<EqA, A> y)
- GetHashCode (Edit<EqA, A> x)
- EqualsAsync (Edit<EqA, A> x, Edit<EqA, A> y)
- GetHashCodeAsync (Edit<EqA, A> x)
- EqEither <EqL, EqR, L, R>
- 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)
- EqEither <L, R>
- 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)
- EqEitherUnsafe <EqL, EqR, L, R>
- 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)
- EqEitherUnsafe <L, R>
- 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)
- EqEnumerable <EQ, A>
- Inst = default(EqEnumerable<EQ, A>)
- Equals (IEnumerable<A> x, IEnumerable<A> y)
- GetHashCode (IEnumerable<A> x)
- EqualsAsync (IEnumerable<A> x, IEnumerable<A> y)
- GetHashCodeAsync (IEnumerable<A> x)
- EqEnumerable <A>
- Inst = default(EqEnumerable<A>)
- Equals (IEnumerable<A> x, IEnumerable<A> y)
- GetHashCode (IEnumerable<A> x)
- EqualsAsync (IEnumerable<A> x, IEnumerable<A> y)
- GetHashCodeAsync (IEnumerable<A> x)
- EqException
- GetHashCode (Exception x)
- Equals (Exception x, Exception y)
- EqualsAsync (Exception x, Exception y)
- GetHashCodeAsync (Exception x)
- EqFloat
- Inst = default(EqFloat)
- Equals (float a, float b)
- GetHashCode (float x)
- EqualsAsync (float x, float y)
- GetHashCodeAsync (float x)
- EqGuid
- Inst = default(EqGuid)
- Equals (Guid a, Guid b)
- GetHashCode (Guid x)
- EqualsAsync (Guid x, Guid y)
- GetHashCodeAsync (Guid x)
- EqHashSet <EQ, A>
- Inst = default(EqHashSet<EQ, A>)
- Equals (HashSet<A> x, HashSet<A> y)
- GetHashCode (HashSet<A> x)
- EqualsAsync (HashSet<A> x, HashSet<A> y)
- GetHashCodeAsync (HashSet<A> x)
- EqHashSet <A>
- Inst = default(EqHashSet<A>)
- Equals (HashSet<A> x, HashSet<A> y)
- GetHashCode (HashSet<A> x)
- EqualsAsync (HashSet<A> x, HashSet<A> y)
- GetHashCodeAsync (HashSet<A> x)
- EqIdentity <A>
- Inst = default(EqIdentity<A>)
- Equals (Identity<A> a, Identity<A> b)
- GetHashCode (Identity<A> x)
- EqualsAsync (Identity<A> x, Identity<A> y)
- GetHashCodeAsync (Identity<A> x)
- EqInt
- Inst = default(EqInt)
- Equals (int a, int b)
- GetHashCode (int x)
- EqualsAsync (int x, int y)
- GetHashCodeAsync (int x)
- EqLong
- Inst = default(EqLong)
- Equals (long a, long b)
- GetHashCode (long x)
- EqualsAsync (long x, long y)
- GetHashCodeAsync (long x)
- EqLst <EQ, A>
- Inst = default(EqLst<EQ, A>)
- Equals (Lst<A> x, Lst<A> y)
- GetHashCode (Lst<A> x)
- EqualsAsync (Lst<A> x, Lst<A> y)
- GetHashCodeAsync (Lst<A> x)
- EqLst <A>
- Inst = default(EqLst<A>)
- Equals (Lst<A> x, Lst<A> y)
- GetHashCode (Lst<A> x)
- EqualsAsync (Lst<A> x, Lst<A> y)
- GetHashCodeAsync (Lst<A> x)
- EqMap <K, V>
- 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)
- EqMap <OrdK, K, V>
- 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)
- EqNewType <NEWTYPE, EQ, A>
- Inst = default(EqNewType<NEWTYPE, EQ, A>)
- Equals (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y)
- GetHashCode (NewType<NEWTYPE, A> x)
- EqualsAsync (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y)
- GetHashCodeAsync (NewType<NEWTYPE, A> x)
- EqNewType <NEWTYPE, A>
- Inst = default(EqNewType<NEWTYPE, A>)
- Equals (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y)
- GetHashCode (NewType<NEWTYPE, A> x)
- EqualsAsync (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y)
- GetHashCodeAsync (NewType<NEWTYPE, A> x)
- EqNewType <NEWTYPE, ORD, A, PRED>
- Inst = default(EqNewType<NEWTYPE, ORD, A, PRED>)
- Equals (NewType<NEWTYPE, A, PRED, ORD> x, NewType<NEWTYPE, A, PRED, ORD> y)
- 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)
- EqNumType <NUMTYPE, NUM, A>
- Equals (NumType<NUMTYPE, NUM, A> x, NumType<NUMTYPE, NUM, A> y)
- GetHashCode (NumType<NUMTYPE, NUM, A> x)
- EqualsAsync (NumType<NUMTYPE, NUM, A> x, NumType<NUMTYPE, NUM, A> y)
- GetHashCodeAsync (NumType<NUMTYPE, NUM, A> x)
- EqNumType <NUMTYPE, NUM, A, PRED>
- Equals (NumType<NUMTYPE, NUM, A, PRED> x, NumType<NUMTYPE, NUM, A, PRED> y)
- 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)
- EqOption <A>
- Equals (Option<A> x, Option<A> y)
- GetHashCode (Option<A> x)
- EqualsAsync (Option<A> x, Option<A> y)
- GetHashCodeAsync (Option<A> x)
- EqOptional <EQ, OPTION, OA, A>
- Inst = default(EqOptional<EQ, OPTION, OA, A>)
- Equals (OA x, OA y)
- GetHashCode (OA x)
- EqualsAsync (OA x, OA y)
- GetHashCodeAsync (OA x)
- EqOptional <OPTION, OA, A>
- Inst = default(EqOptional<OPTION, OA, A>)
- Equals (OA x, OA y)
- GetHashCode (OA x)
- EqualsAsync (OA x, OA y)
- GetHashCodeAsync (OA x)
- EqOptionalUnsafe <EQ, OPTION, OA, A>
- Inst = default(EqOptionalUnsafe<EQ, OPTION, OA, A>)
- Equals (OA x, OA y)
- GetHashCode (OA x)
- EqualsAsync (OA x, OA y)
- GetHashCodeAsync (OA x)
- EqOptionalUnsafe <OPTION, OA, A>
- Inst = default(EqOptionalUnsafe<OPTION, OA, A>)
- Equals (OA x, OA y)
- GetHashCode (OA x)
- EqualsAsync (OA x, OA y)
- GetHashCodeAsync (OA x)
- EqOptionUnsafe <A>
- Equals (OptionUnsafe<A> x, OptionUnsafe<A> y)
- GetHashCode (OptionUnsafe<A> x)
- EqualsAsync (OptionUnsafe<A> x, OptionUnsafe<A> y)
- GetHashCodeAsync (OptionUnsafe<A> x)
- EqPatch <EqA, A>
- Equals (Patch<EqA, A> x, Patch<EqA, A> y)
- GetHashCode (Patch<EqA, A> x)
- EqualsAsync (Patch<EqA, A> x, Patch<EqA, A> y)
- GetHashCodeAsync (Patch<EqA, A> x)
- EqQue <EQ, A>
- Inst = default(EqQue<EQ, A>)
- Equals (Que<A> x, Que<A> y)
- GetHashCode (Que<A> x)
- EqualsAsync (Que<A> x, Que<A> y)
- GetHashCodeAsync (Que<A> x)
- EqQue <A>
- Inst = default(EqQue<A>)
- Equals (Que<A> x, Que<A> y)
- GetHashCode (Que<A> x)
- EqualsAsync (Que<A> x, Que<A> y)
- GetHashCodeAsync (Que<A> x)
- EqRecord <A>
- EqResult <A>
- Equals (Result<A> x, Result<A> y)
- GetHashCode (Result<A> x)
- EqualsAsync (Result<A> x, Result<A> y)
- GetHashCodeAsync (Result<A> x)
- EqOptionalResult <A>
- Equals (OptionalResult<A> x, OptionalResult<A> y)
- GetHashCode (OptionalResult<A> x)
- EqualsAsync (OptionalResult<A> x, OptionalResult<A> y)
- GetHashCodeAsync (OptionalResult<A> x)
- EqSeq <EqA, A>
- Inst = default(EqSeq<EqA, A>)
- Equals (Seq<A> x, Seq<A> y)
- GetHashCode (Seq<A> x)
- EqualsAsync (Seq<A> x, Seq<A> y)
- GetHashCodeAsync (Seq<A> x)
- EqSeq <A>
- Inst = default(EqSeq<A>)
- Equals (Seq<A> x, Seq<A> y)
- GetHashCode (Seq<A> x)
- EqualsAsync (Seq<A> x, Seq<A> y)
- GetHashCodeAsync (Seq<A> x)
- EqSet <EQ, A>
- Inst = default(EqSet<EQ, A>)
- Equals (Set<A> x, Set<A> y)
- GetHashCode (Set<A> x)
- EqualsAsync (Set<A> x, Set<A> y)
- GetHashCodeAsync (Set<A> x)
- EqSet <A>
- Inst = default(EqSet<A>)
- Equals (Set<A> x, Set<A> y)
- GetHashCode (Set<A> x)
- EqualsAsync (Set<A> x, Set<A> y)
- GetHashCodeAsync (Set<A> x)
- EqShort
- Inst = default(EqShort)
- Equals (short a, short b)
- GetHashCode (short x)
- EqualsAsync (short x, short y)
- GetHashCodeAsync (short x)
- EqStck <EQ, A>
- Inst = default(EqStck<EQ, A>)
- Equals (Stck<A> x, Stck<A> y)
- GetHashCode (Stck<A> x)
- EqualsAsync (Stck<A> x, Stck<A> y)
- GetHashCodeAsync (Stck<A> x)
- EqStck <A>
- Inst = default(EqStck<A>)
- Equals (Stck<A> x, Stck<A> y)
- GetHashCode (Stck<A> x)
- EqualsAsync (Stck<A> x, Stck<A> y)
- GetHashCodeAsync (Stck<A> x)
- EqString
- Inst = default
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- EqStringInvariantCulture
- Inst = default
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- EqStringInvariantCultureIgnoreCase
- Inst = default
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- EqStringOrdinalIgnoreCase
- Inst = default
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- EqStringOrdinal
- Inst = default
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- EqStringCurrentCultureIgnoreCase
- Inst = default
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- EqStringCurrentCulture
- Inst = default
- Equals (string a, string b)
- GetHashCode (string x)
- EqualsAsync (string x, string y)
- GetHashCodeAsync (string x)
- EqTask <A>
- Equals (Task<A> x, Task<A> y)
- GetHashCode (Task<A> x)
- EqualsAsync (Task<A> x, Task<A> y)
- GetHashCodeAsync (Task<A> x)
- EqTrue <A>
- EqTry <EQ, A>
- Inst = default(EqTry<EQ, A>)
- Equals (Try<A> x, Try<A> y)
- GetHashCode (Try<A> x)
- EqualsAsync (Try<A> x, Try<A> y)
- GetHashCodeAsync (Try<A> x)
- EqTry <A>
- Inst = default(EqTry<A>)
- Equals (Try<A> x, Try<A> y)
- GetHashCode (Try<A> x)
- EqualsAsync (Try<A> x, Try<A> y)
- GetHashCodeAsync (Try<A> x)
- EqTryOption <EQ, A>
- Inst = default(EqTryOption<EQ, A>)
- Equals (TryOption<A> lhs, TryOption<A> rhs)
- GetHashCode (TryOption<A> x)
- EqualsAsync (TryOption<A> x, TryOption<A> y)
- GetHashCodeAsync (TryOption<A> x)
- EqTryOption <A>
- Inst = default(EqTryOption<A>)
- Equals (TryOption<A> lhs, TryOption<A> rhs)
- GetHashCode (TryOption<A> x)
- EqualsAsync (TryOption<A> x, TryOption<A> y)
- GetHashCodeAsync (TryOption<A> x)
- EqTuple2 <EqA, EqB, A, B>
- GetHashCodeAsync ((A, B) pair)
- GetHashCode ((A, B) pair)
- EqualsAsync ((A, B) x, (A, B) y)
- Equals ((A, B) x, (A, B) y)
- EqTypeInfo
struct EqArr <EqA, A> Source #
Array equality
Fields
field EqArr<EqA, A> Inst = default(EqArr<EqA, 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 GetHashCode (Arr<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 (Arr<A> x, Arr<A> y) Source #
method Task<int> GetHashCodeAsync (Arr<A> x) Source #
Array equality
Fields
field EqArr<A> Inst = default(EqArr<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 GetHashCode (Arr<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 (Arr<A> x, Arr<A> y) Source #
method Task<int> GetHashCodeAsync (Arr<A> x) Source #
struct EqArray <EqA, A> Source #
Array equality
Fields
field EqArray<EqA, A> Inst = default(EqArray<EqA, 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 GetHashCode (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 (A[] x, A[] y) Source #
method Task<int> GetHashCodeAsync (A[] x) Source #
Array equality
Fields
field EqArray<A> Inst = default(EqArray<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 GetHashCode (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 (A[] x, A[] y) Source #
method Task<int> GetHashCodeAsync (A[] x) Source #
Integer equality
Fields
field EqBigInt Inst = default(EqBigInt) Source #
Methods
method bool Equals (bigint a, bigint 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 (bigint 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 (bigint x, bigint y) Source #
method Task<int> GetHashCodeAsync (bigint x) Source #
Boolean equality
Fields
field EqBool Inst = default(EqBool) Source #
Methods
method bool Equals (bool a, bool 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 (bool 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 (bool x, bool y) Source #
method Task<int> GetHashCodeAsync (bool x) Source #
Char equality
Fields
field EqChar Inst = default(EqChar) Source #
Methods
method bool Equals (char a, char 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 (char 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 (char x, char y) Source #
method Task<int> GetHashCodeAsync (char x) Source #
struct EqCharOrdinalIgnoreCase Source #
Char equality (ordinal, ignore case)
Fields
field EqCharOrdinalIgnoreCase Inst = default(EqCharOrdinalIgnoreCase) Source #
Methods
method bool Equals (char a, char 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 (char 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 (char x, char y) Source #
method Task<int> GetHashCodeAsync (char x) Source #
struct EqChoice <EQA, EQB, CHOICE, CH, A, B> Source #
Compare the equality of any type in the Either type-class
Fields
field EqChoice<EQA, EQB, CHOICE, CH, A, B> Inst = default(EqChoice<EQA, EQB, CHOICE, CH, A, B>) Source #
Methods
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 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 (CH x, CH y) Source #
method Task<int> GetHashCodeAsync (CH x) Source #
struct EqChoice <EQB, CHOICE, CH, A, B> Source #
Compare the equality of any type in the Either type-class
Fields
field EqChoice<EQB, CHOICE, CH, A, B> Inst = default(EqChoice<EQB, CHOICE, CH, A, B>) Source #
Methods
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 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 (CH 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 (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 | |
struct EqChoice <CHOICE, CH, A, B> Source #
Compare the equality of any type in the Either type-class
Fields
field EqChoice<CHOICE, CH, A, B> Inst = default(EqChoice<CHOICE, CH, A, B>) Source #
Methods
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 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 (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 Task<int> GetHashCodeAsync (CH x) Source #
Get hash code of the value
Parameters
| param | x | Value to get the hash code of |
| returns | The hash code of x | |
struct EqChoiceUnsafe <EQA, EQB, CHOICE, CH, A, B> Source #
Compare the equality of any type in the Either type-class
Fields
field EqChoiceUnsafe<EQA, EQB, CHOICE, CH, A, B> Inst = default(EqChoiceUnsafe<EQA, EQB, CHOICE, CH, A, B>) Source #
Methods
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 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 (CH x, CH y) Source #
method Task<int> GetHashCodeAsync (CH x) Source #
struct EqChoiceUnsafe <EQB, CHOICE, CH, A, B> Source #
Compare the equality of any type in the Either type-class
Fields
field EqChoiceUnsafe<EQB, CHOICE, CH, A, B> Inst = default(EqChoiceUnsafe<EQB, CHOICE, CH, A, B>) Source #
Methods
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 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 (CH x, CH y) Source #
method Task<int> GetHashCodeAsync (CH x) Source #
struct EqChoiceUnsafe <CHOICE, CH, A, B> Source #
Compare the equality of any type in the Either type-class
Fields
field EqChoiceUnsafe<CHOICE, CH, A, B> Inst = default(EqChoiceUnsafe<CHOICE, CH, A, B>) Source #
Methods
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 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 (CH x, CH y) Source #
method Task<int> GetHashCodeAsync (CH x) Source #
struct EqCompositions <A> Source #
Methods
method int GetHashCode (Compositions<A> x) Source #
method Task<bool> EqualsAsync (Compositions<A> x, Compositions<A> y) Source #
method Task<int> GetHashCodeAsync (Compositions<A> x) Source #
struct EqDateTime Source #
DateTime equality
Fields
field EqDateTime Inst = default(EqDateTime) Source #
Methods
method bool Equals (DateTime a, DateTime 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 (DateTime 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 (DateTime x, DateTime y) Source #
method Task<int> GetHashCodeAsync (DateTime x) Source #
Floating point equality
Fields
field EqDecimal Inst = default(EqDecimal) Source #
Methods
method bool Equals (decimal a, decimal 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 (decimal 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 (decimal x, decimal y) Source #
method Task<int> GetHashCodeAsync (decimal x) Source #
Finds an appropriate Eq from the loaded assemblies, if one can't be found then it falls back to the standard .NET EqualityComparer.Default.Equals(a,b) method to provide equality testing.
Fields
field EqDefault<A> Inst = default(EqDefault<A>) Source #
Methods
method bool Equals (A a, 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 (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 (A x, A y) Source #
method Task<int> GetHashCodeAsync (A x) Source #
class EqDefault <A, B> Source #
This is a utility type for when two generic types are used, but it's not clear if they have the same underlying type. We'd like to do structural equality if they are, and return false if they're not.
Floating point equality
Fields
field EqDouble Inst = default(EqDouble) Source #
Methods
method bool Equals (double a, double 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 (double 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 (double x, double y) Source #
method Task<int> GetHashCodeAsync (double x) Source #
struct EqEdit <EqA, A> Source #
Equality instance for Patch Edit
Methods
method int GetHashCode (Edit<EqA, A> x) Source #
method Task<bool> EqualsAsync (Edit<EqA, A> x, Edit<EqA, A> y) Source #
method Task<int> GetHashCodeAsync (Edit<EqA, A> x) Source #
struct EqEither <EqL, EqR, 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
struct EqEither <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
struct EqEitherUnsafe <EqL, EqR, 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
struct EqEitherUnsafe <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
struct EqEnumerable <EQ, A> 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 | |
Fields
field EqEnumerable<EQ, A> Inst = default(EqEnumerable<EQ, A>) Source #
Methods
method int GetHashCode (IEnumerable<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 (IEnumerable<A> x, IEnumerable<A> y) Source #
method Task<int> GetHashCodeAsync (IEnumerable<A> x) Source #
struct EqEnumerable <A> 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 | |
Fields
field EqEnumerable<A> Inst = default(EqEnumerable<A>) Source #
Methods
method int GetHashCode (IEnumerable<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 (IEnumerable<A> x, IEnumerable<A> y) Source #
method Task<int> GetHashCodeAsync (IEnumerable<A> x) Source #
struct EqException Source #
Methods
method int GetHashCode (Exception x) Source #
method Task<bool> EqualsAsync (Exception x, Exception y) Source #
method Task<int> GetHashCodeAsync (Exception x) Source #
Floating point equality
Fields
field EqFloat Inst = default(EqFloat) Source #
Methods
method bool Equals (float a, float 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 (float 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 (float x, float y) Source #
method Task<int> GetHashCodeAsync (float x) Source #
Guid equality
Fields
field EqGuid Inst = default(EqGuid) Source #
Methods
method bool Equals (Guid a, Guid 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 (Guid 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 (Guid x, Guid y) Source #
method Task<int> GetHashCodeAsync (Guid x) Source #
struct EqHashSet <EQ, A> Source #
HashSet equality
Fields
field EqHashSet<EQ, A> Inst = default(EqHashSet<EQ, 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 GetHashCode (HashSet<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 (HashSet<A> x, HashSet<A> y) Source #
method Task<int> GetHashCodeAsync (HashSet<A> x) Source #
HashSet equality
Fields
field EqHashSet<A> Inst = default(EqHashSet<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 GetHashCode (HashSet<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 (HashSet<A> x, HashSet<A> y) Source #
method Task<int> GetHashCodeAsync (HashSet<A> x) Source #
struct EqIdentity <A> Source #
Identity equality
Fields
field EqIdentity<A> Inst = default(EqIdentity<A>) Source #
Methods
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 #
Integer equality
Fields
field EqInt Inst = default(EqInt) Source #
Methods
method bool Equals (int a, int 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 (int 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 (int x, int y) Source #
method Task<int> GetHashCodeAsync (int x) Source #
Integer equality
Fields
field EqLong Inst = default(EqLong) Source #
Methods
method bool Equals (long a, long 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 (long 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 (long x, long y) Source #
method Task<int> GetHashCodeAsync (long x) 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 | |
Fields
field EqLst<EQ, A> Inst = default(EqLst<EQ, A>) Source #
Methods
method int GetHashCode (Lst<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 (Lst<A> x, Lst<A> y) Source #
method Task<int> GetHashCodeAsync (Lst<A> x) 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 | |
Fields
field EqLst<A> Inst = default(EqLst<A>) Source #
Methods
method int GetHashCode (Lst<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 (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 Task<int> GetHashCodeAsync (Lst<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 | |
Methods
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 #
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 Task<int> GetHashCodeAsync (Map<K, V> x) Source #
Get hash code of the value
Parameters
| param | x | Value to get the hash code of |
| returns | The hash code of x | |
struct EqMap <OrdK, K, V> Source #
Methods
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 #
struct EqNewType <NEWTYPE, EQ, A> Source #
Compare the equality of any type in the NewType type-class
Fields
field EqNewType<NEWTYPE, EQ, A> Inst = default(EqNewType<NEWTYPE, EQ, 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 GetHashCode (NewType<NEWTYPE, 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 (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y) Source #
method Task<int> GetHashCodeAsync (NewType<NEWTYPE, A> x) Source #
struct EqNewType <NEWTYPE, A> Source #
Compare the equality of any type in the NewType type-class
Fields
field EqNewType<NEWTYPE, A> Inst = default(EqNewType<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 GetHashCode (NewType<NEWTYPE, 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 (NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y) Source #
method Task<int> GetHashCodeAsync (NewType<NEWTYPE, A> x) Source #
struct EqNewType <NEWTYPE, ORD, A, PRED> Source #
Compare the equality of any type in the NewType type-class
Fields
field EqNewType<NEWTYPE, ORD, A, PRED> Inst = default(EqNewType<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 GetHashCode (NewType<NEWTYPE, A, PRED, ORD> 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 (NewType<NEWTYPE, A, PRED, ORD> x, NewType<NEWTYPE, A, PRED, ORD> y) Source #
method Task<int> GetHashCodeAsync (NewType<NEWTYPE, A, PRED, ORD> x) Source #
struct EqNumType <NUMTYPE, NUM, A> Source #
Compare the equality of any type in the NumType type-class
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 GetHashCode (NumType<NUMTYPE, NUM, 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 (NumType<NUMTYPE, NUM, A> x, NumType<NUMTYPE, NUM, A> y) Source #
method Task<int> GetHashCodeAsync (NumType<NUMTYPE, NUM, A> x) Source #
struct EqNumType <NUMTYPE, NUM, A, PRED> Source #
Compare the equality of any type in the NumType type-class
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 GetHashCode (NumType<NUMTYPE, NUM, A, PRED> 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 (NumType<NUMTYPE, NUM, A, PRED> x, NumType<NUMTYPE, NUM, A, PRED> y) Source #
method Task<int> GetHashCodeAsync (NumType<NUMTYPE, NUM, A, PRED> x) Source #
Option type equality
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 #
struct EqOptional <EQ, OPTION, OA, A> Source #
Compare the equality of any type in the Optional type-class
Fields
field EqOptional<EQ, OPTION, OA, A> Inst = default(EqOptional<EQ, 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 GetHashCode (OA 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 (OA x, OA y) Source #
method Task<int> GetHashCodeAsync (OA x) Source #
struct EqOptional <OPTION, OA, A> Source #
Compare the equality of any type in the Optional type-class
Fields
field EqOptional<OPTION, OA, A> Inst = default(EqOptional<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 GetHashCode (OA 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 (OA x, OA y) Source #
method Task<int> GetHashCodeAsync (OA x) Source #
struct EqOptionalUnsafe <EQ, OPTION, OA, A> Source #
Compare the equality of any type in the Optional type-class
Fields
field EqOptionalUnsafe<EQ, OPTION, OA, A> Inst = default(EqOptionalUnsafe<EQ, 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 GetHashCode (OA 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 (OA x, OA y) Source #
method Task<int> GetHashCodeAsync (OA x) Source #
struct EqOptionalUnsafe <OPTION, OA, A> Source #
Compare the equality of any type in the Optional type-class
Fields
field EqOptionalUnsafe<OPTION, OA, A> Inst = default(EqOptionalUnsafe<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 GetHashCode (OA 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 (OA x, OA y) Source #
method Task<int> GetHashCodeAsync (OA x) Source #
struct EqOptionUnsafe <A> Source #
Option type equality
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 #
struct EqPatch <EqA, A> Source #
Equality instance for Patch
Parameters
| type | EqA | |
| type | A |
Methods
method int GetHashCode (Patch<EqA, A> x) Source #
method Task<bool> EqualsAsync (Patch<EqA, A> x, Patch<EqA, A> y) Source #
method Task<int> GetHashCodeAsync (Patch<EqA, A> x) 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 | |
Fields
field EqQue<EQ, A> Inst = default(EqQue<EQ, A>) Source #
Methods
method int GetHashCode (Que<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 (Que<A> x, Que<A> y) Source #
method Task<int> GetHashCodeAsync (Que<A> x) 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 | |
Fields
field EqQue<A> Inst = default(EqQue<A>) Source #
Methods
method int GetHashCode (Que<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 (Que<A> x, Que<A> y) Source #
method Task<int> GetHashCodeAsync (Que<A> x) Source #
Equality 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 #
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 #
struct EqOptionalResult <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 #
struct EqSeq <EqA, A> 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 | |
Fields
field EqSeq<EqA, A> Inst = default(EqSeq<EqA, A>) Source #
Methods
method int GetHashCode (Seq<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 (Seq<A> x, Seq<A> y) Source #
method Task<int> GetHashCodeAsync (Seq<A> x) 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 | |
Fields
field EqSeq<A> Inst = default(EqSeq<A>) Source #
Methods
method int GetHashCode (Seq<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 (Seq<A> x, Seq<A> y) Source #
method Task<int> GetHashCodeAsync (Seq<A> x) Source #
Set
Fields
field EqSet<EQ, A> Inst = default(EqSet<EQ, 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 GetHashCode (Set<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 (Set<A> x, Set<A> y) Source #
method Task<int> GetHashCodeAsync (Set<A> x) Source #
Set
Fields
field EqSet<A> Inst = default(EqSet<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 GetHashCode (Set<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 (Set<A> x, Set<A> y) Source #
method Task<int> GetHashCodeAsync (Set<A> x) Source #
Integer equality
Fields
field EqShort Inst = default(EqShort) Source #
Methods
method bool Equals (short a, short 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 (short 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 (short x, short y) Source #
method Task<int> GetHashCodeAsync (short x) Source #
struct EqStck <EQ, A> 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 | |
Fields
field EqStck<EQ, A> Inst = default(EqStck<EQ, A>) Source #
Methods
method int GetHashCode (Stck<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 (Stck<A> x, Stck<A> y) Source #
method Task<int> GetHashCodeAsync (Stck<A> x) 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 | |
Fields
field EqStck<A> Inst = default(EqStck<A>) Source #
Methods
method int GetHashCode (Stck<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 (Stck<A> x, Stck<A> y) Source #
method Task<int> GetHashCodeAsync (Stck<A> x) Source #
String equality
Fields
field EqString Inst = default Source #
Methods
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 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 (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) Source #
struct EqStringInvariantCulture Source #
String equality (invariant culture)
Fields
field EqStringInvariantCulture Inst = default Source #
Methods
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 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 (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) Source #
struct EqStringInvariantCultureIgnoreCase Source #
String equality (invariant culture, ignore case)
Fields
field EqStringInvariantCultureIgnoreCase Inst = default Source #
Methods
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 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 (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) Source #
struct EqStringOrdinalIgnoreCase Source #
String equality (ordinal, ignore case)
Fields
field EqStringOrdinalIgnoreCase Inst = default Source #
Methods
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 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 (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) Source #
struct EqStringOrdinal Source #
String equality (ordinal)
Fields
field EqStringOrdinal Inst = default Source #
Methods
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 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 (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) Source #
struct EqStringCurrentCultureIgnoreCase Source #
String equality (current culture, ignore case)
Fields
field EqStringCurrentCultureIgnoreCase Inst = default Source #
Methods
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 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 (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) Source #
struct EqStringCurrentCulture Source #
String equality (current culture)
Fields
field EqStringCurrentCulture Inst = default Source #
Methods
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 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 (string x, string y) Source #
method Task<int> GetHashCodeAsync (string x) 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 #
Always returns true for equality checks
Methods
method int GetHashCode (A x) Source #
method Task<bool> EqualsAsync (A x, A y) Source #
method Task<int> GetHashCodeAsync (A x) Source #
Compare the equality of any values bound by the Try monad
Fields
field EqTry<EQ, A> Inst = default(EqTry<EQ, A>) Source #
Methods
method bool Equals (Try<A> x, Try<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 (Try<A> x) Source #
method Task<bool> EqualsAsync (Try<A> x, Try<A> y) Source #
method Task<int> GetHashCodeAsync (Try<A> x) Source #
Compare the equality of any values bound by the Try monad
Fields
field EqTry<A> Inst = default(EqTry<A>) Source #
Methods
method bool Equals (Try<A> x, Try<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 (Try<A> x) Source #
method Task<bool> EqualsAsync (Try<A> x, Try<A> y) Source #
method Task<int> GetHashCodeAsync (Try<A> x) Source #
struct EqTryOption <EQ, A> Source #
Compare the equality of any type in the TryOption type-class
Fields
field EqTryOption<EQ, A> Inst = default(EqTryOption<EQ, A>) Source #
Methods
method bool Equals (TryOption<A> lhs, TryOption<A> rhs) Source #
Equality test
Parameters
| param | lhs | The left hand side of the equality operation |
| param | rhs | The right hand side of the equality operation |
| returns | True if lhs and rhs are equal | |
method int GetHashCode (TryOption<A> x) Source #
method Task<bool> EqualsAsync (TryOption<A> x, TryOption<A> y) Source #
method Task<int> GetHashCodeAsync (TryOption<A> x) Source #
struct EqTryOption <A> Source #
Compare the equality of any type in the TryOption type-class
Fields
field EqTryOption<A> Inst = default(EqTryOption<A>) Source #
Methods
method bool Equals (TryOption<A> lhs, TryOption<A> rhs) Source #
Equality test
Parameters
| param | lhs | The left hand side of the equality operation |
| param | rhs | The right hand side of the equality operation |
| returns | True if lhs and rhs are equal | |
method int GetHashCode (TryOption<A> x) Source #
method Task<bool> EqualsAsync (TryOption<A> x, TryOption<A> y) Source #
method Task<int> GetHashCodeAsync (TryOption<A> x) Source #
struct EqTuple2 <EqA, EqB, A, B> Source #
Methods
method Task<int> GetHashCodeAsync ((A, B) pair) Source #
method int GetHashCode ((A, B) pair) Source #
method Task<bool> EqualsAsync ((A, B) x, (A, B) y) Source #
struct EqTypeInfo Source #
Methods
method int GetHashCode (TypeInfo x) Source #
method Task<bool> EqualsAsync (TypeInfo x, TypeInfo y) Source #
method Task<int> GetHashCodeAsync (TypeInfo x) Source #