Showing preview only (8,432K chars total). Download the full file or copy to clipboard to get everything.
Repository: louthy/language-ext
Branch: main
Commit: 041f74a00f66
Files: 1863
Total size: 7.7 MB
Directory structure:
gitextract_5rnkpet5/
├── .editorconfig
├── .gitattributes
├── .github/
│ └── FUNDING.yml
├── .gitignore
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE.md
├── LanguageExt.Benchmarks/
│ ├── HashMapAddBenchmarks.cs
│ ├── HashMapContainsKeyBenchmarks.cs
│ ├── HashMapIterateBenchmarks.cs
│ ├── HashMapRandomRemovalBenchmarks.cs
│ ├── HashSetAddBenchmarks.cs
│ ├── HashSetContainsBenchmarks.cs
│ ├── HashSetIterationBenchmarks.cs
│ ├── HashSetRandomRemovalBenchmarks.cs
│ ├── LanguageExt.Benchmarks.csproj
│ ├── ListAddBenchmarks.cs
│ ├── ListIterationBenchmarks.cs
│ ├── Program.cs
│ ├── ValuesGenerator.MapSetup.cs
│ ├── ValuesGenerator.SetSetup.cs
│ └── ValuesGenerator.cs
├── LanguageExt.Core/
│ ├── Catch.cs
│ ├── Class Instances/
│ │ ├── Eq/
│ │ │ ├── EqArr.cs
│ │ │ ├── EqArray.cs
│ │ │ ├── EqBigInt.cs
│ │ │ ├── EqBool.cs
│ │ │ ├── EqChar.cs
│ │ │ ├── EqCompositions.cs
│ │ │ ├── EqDateTime.cs
│ │ │ ├── EqDecimal.cs
│ │ │ ├── EqDefault.cs
│ │ │ ├── EqDouble.cs
│ │ │ ├── EqEdit.cs
│ │ │ ├── EqEither.cs
│ │ │ ├── EqEnumerable.cs
│ │ │ ├── EqException.cs
│ │ │ ├── EqFloat.cs
│ │ │ ├── EqGuid.cs
│ │ │ ├── EqHashSet.cs
│ │ │ ├── EqIdentity.cs
│ │ │ ├── EqInt.cs
│ │ │ ├── EqIterable.cs
│ │ │ ├── EqLong.cs
│ │ │ ├── EqLst.cs
│ │ │ ├── EqMap.cs
│ │ │ ├── EqOption.cs
│ │ │ ├── EqPatch.cs
│ │ │ ├── EqQue.cs
│ │ │ ├── EqRecord.cs
│ │ │ ├── EqSeq.cs
│ │ │ ├── EqSet.cs
│ │ │ ├── EqShort.cs
│ │ │ ├── EqStck.cs
│ │ │ ├── EqString.cs
│ │ │ ├── EqTask.cs
│ │ │ ├── EqTrue.cs
│ │ │ ├── EqTuple2.cs
│ │ │ └── EqTypeInfo.cs
│ │ ├── Hashable/
│ │ │ ├── HashableArr.cs
│ │ │ ├── HashableArray.cs
│ │ │ ├── HashableBigInt.cs
│ │ │ ├── HashableBool.cs
│ │ │ ├── HashableChar.cs
│ │ │ ├── HashableCompositions.cs
│ │ │ ├── HashableDateTime.cs
│ │ │ ├── HashableDecimal.cs
│ │ │ ├── HashableDefault.cs
│ │ │ ├── HashableDouble.cs
│ │ │ ├── HashableEdit.cs
│ │ │ ├── HashableEither.cs
│ │ │ ├── HashableEnumerable.cs
│ │ │ ├── HashableException.cs
│ │ │ ├── HashableFloat.cs
│ │ │ ├── HashableGuid.cs
│ │ │ ├── HashableHashSet.cs
│ │ │ ├── HashableIdentity.cs
│ │ │ ├── HashableInt.cs
│ │ │ ├── HashableIterable.cs
│ │ │ ├── HashableLong.cs
│ │ │ ├── HashableLst.cs
│ │ │ ├── HashableMap.cs
│ │ │ ├── HashableOption.cs
│ │ │ ├── HashablePair.cs
│ │ │ ├── HashablePatch.cs
│ │ │ ├── HashableQue.cs
│ │ │ ├── HashableRecord.cs
│ │ │ ├── HashableSeq.cs
│ │ │ ├── HashableSet.cs
│ │ │ ├── HashableShort.cs
│ │ │ ├── HashableStck.cs
│ │ │ ├── HashableString.cs
│ │ │ ├── HashableTask.cs
│ │ │ ├── HashableTuple.cs
│ │ │ └── HashableTypeInfo.cs
│ │ ├── Monoid/
│ │ │ ├── Addition.cs
│ │ │ ├── All.cs
│ │ │ ├── Any.cs
│ │ │ ├── MError.cs
│ │ │ ├── MUnit.cs
│ │ │ └── Product.cs
│ │ ├── Ord/
│ │ │ ├── OrdArr.cs
│ │ │ ├── OrdArray.cs
│ │ │ ├── OrdBigInt.cs
│ │ │ ├── OrdBool.cs
│ │ │ ├── OrdChar.cs
│ │ │ ├── OrdDateTime.cs
│ │ │ ├── OrdDecimal.cs
│ │ │ ├── OrdDefault.cs
│ │ │ ├── OrdDouble.cs
│ │ │ ├── OrdEither.cs
│ │ │ ├── OrdEnumerable.cs
│ │ │ ├── OrdException.cs
│ │ │ ├── OrdFloat.cs
│ │ │ ├── OrdGuid.cs
│ │ │ ├── OrdHashSet.cs
│ │ │ ├── OrdInt.cs
│ │ │ ├── OrdIterable.cs
│ │ │ ├── OrdLong.cs
│ │ │ ├── OrdLst.cs
│ │ │ ├── OrdMap.cs
│ │ │ ├── OrdOption.cs
│ │ │ ├── OrdQue.cs
│ │ │ ├── OrdRecord.cs
│ │ │ ├── OrdSeq.cs
│ │ │ ├── OrdSet.cs
│ │ │ ├── OrdShort.cs
│ │ │ ├── OrdStck.cs
│ │ │ ├── OrdString.cs
│ │ │ ├── OrdTask.cs
│ │ │ ├── OrdTrue.cs
│ │ │ ├── OrdTupleFirst.cs
│ │ │ └── OrdTypeInfo.cs
│ │ ├── README.md
│ │ ├── TBigInt.cs
│ │ ├── TBool.cs
│ │ ├── TBoolBool.cs
│ │ ├── TChar.cs
│ │ ├── TDecimal.cs
│ │ ├── TDouble.cs
│ │ ├── TFloat.cs
│ │ ├── TInt.cs
│ │ ├── TLong.cs
│ │ ├── TNumericChar.cs
│ │ ├── TShort.cs
│ │ └── TString.cs
│ ├── Combinators.cs
│ ├── Comment Alternatives.cs
│ ├── Common/
│ │ ├── Error.cs
│ │ ├── ErrorCodes.cs
│ │ ├── ErrorException.cs
│ │ ├── Errors.cs
│ │ ├── Exceptions.cs
│ │ └── README.md
│ ├── Concurrency/
│ │ ├── Async/
│ │ │ ├── Async.Module.cs
│ │ │ └── AsyncEnumerable/
│ │ │ ├── AsyncEnumberable.Extensions.cs
│ │ │ └── AsyncEnumberable.LINQ.Extensions.cs
│ │ ├── Atom/
│ │ │ ├── Atom.Metadata.cs
│ │ │ ├── Atom.cs
│ │ │ ├── AtomChangedEvent.cs
│ │ │ └── README.md
│ │ ├── AtomHashMap/
│ │ │ ├── AtomHashMap.Eq.cs
│ │ │ ├── AtomHashMap.Module.Eq.cs
│ │ │ ├── AtomHashMap.Module.cs
│ │ │ ├── AtomHashMap.cs
│ │ │ └── Events.cs
│ │ ├── AtomQue/
│ │ │ ├── AtomQue.Extensions.cs
│ │ │ ├── AtomQue.Trait.Implementation.cs
│ │ │ └── AtomQue.cs
│ │ ├── AtomSeq/
│ │ │ └── AtomSeq.cs
│ │ ├── Conflict.cs
│ │ ├── Prelude.Concurrency.cs
│ │ ├── README.md
│ │ ├── STM/
│ │ │ ├── CommuteRef.cs
│ │ │ ├── Isolation.cs
│ │ │ ├── Ref.cs
│ │ │ └── STM.cs
│ │ ├── Signals/
│ │ │ ├── CountdownSignal.cs
│ │ │ ├── Signal.Module.cs
│ │ │ └── Signal.cs
│ │ ├── Task/
│ │ │ ├── Task.Extensions.cs
│ │ │ ├── Task.Prelude.cs
│ │ │ └── Tasks.cs
│ │ ├── ValueTask/
│ │ │ ├── ValueTask.Extensions.cs
│ │ │ ├── ValueTask.Prelude.cs
│ │ │ └── ValueTasks.cs
│ │ ├── VectorClock/
│ │ │ ├── Relation.cs
│ │ │ ├── VectorClock.A.cs
│ │ │ ├── VectorClock.OrdA.NumB.A.B.cs
│ │ │ └── VectorClock.cs
│ │ ├── VersionHashMap/
│ │ │ ├── VersionHashMap.ConflictV.K.V.cs
│ │ │ ├── VersionHashMap.ConflictV.OrdActor.EqK.Actor.K.V.cs
│ │ │ └── VersionHashMap.K.V.cs
│ │ └── VersionVector/
│ │ ├── Version.cs
│ │ └── VersionVector.cs
│ ├── DataTypes/
│ │ ├── BigInt/
│ │ │ └── BigInt.cs
│ │ ├── Change/
│ │ │ ├── Change.cs
│ │ │ ├── EntryAdded.cs
│ │ │ ├── EntryMapped.cs
│ │ │ ├── EntryRemoved.cs
│ │ │ └── NoChange.cs
│ │ ├── Compositions/
│ │ │ ├── Compositions.Extensions.cs
│ │ │ ├── Compositions.Module.cs
│ │ │ ├── Compositions.cs
│ │ │ └── FoldCompositions.cs
│ │ ├── Fail/
│ │ │ ├── Fail.Extensions.cs
│ │ │ └── Fail.cs
│ │ ├── Loop/
│ │ │ ├── Loop.Extensions.cs
│ │ │ ├── Loop.Prelude.cs
│ │ │ └── Loop.cs
│ │ ├── Lower/
│ │ │ └── Lower.cs
│ │ ├── MapPatch/
│ │ │ └── HashMapPatch.cs
│ │ ├── Next/
│ │ │ ├── Next.Module.cs
│ │ │ └── Next.cs
│ │ ├── Patch/
│ │ │ ├── Edit.cs
│ │ │ ├── Patch.Internal.cs
│ │ │ ├── Patch.Module.cs
│ │ │ ├── Patch.cs
│ │ │ └── PatchParams.cs
│ │ ├── Pure/
│ │ │ ├── Pure.Extensions.cs
│ │ │ └── Pure.cs
│ │ ├── README.md
│ │ ├── Range/
│ │ │ ├── Range.Extensions.cs
│ │ │ ├── Range.Module.cs
│ │ │ ├── Range.Monad.cs
│ │ │ └── Range.cs
│ │ ├── Ratio/
│ │ │ └── Ratio.cs
│ │ ├── Record/
│ │ │ ├── Attributes.cs
│ │ │ ├── Record.cs
│ │ │ ├── RecordType.cs
│ │ │ ├── RecordTypeIgnoreBase.cs
│ │ │ └── TypeInfoExt.cs
│ │ ├── SpanArray/
│ │ │ └── SpanArray.cs
│ │ ├── StringM/
│ │ │ ├── OrdString.cs
│ │ │ ├── StringM.Ord.cs
│ │ │ ├── StringM.Trait.cs
│ │ │ └── StringM.cs
│ │ ├── Unit/
│ │ │ ├── Unit.Prelude.cs
│ │ │ └── Unit.cs
│ │ └── ValueTuple/
│ │ ├── Tuple1/
│ │ │ ├── ValueTuple1.Extensions.cs
│ │ │ └── ValueTuple1.Prelude.cs
│ │ ├── Tuple2/
│ │ │ ├── ValueTuple2.Extensions.cs
│ │ │ └── ValueTuple2.Prelude.cs
│ │ ├── Tuple3/
│ │ │ ├── ValueTuple3.Extensions.cs
│ │ │ └── ValueTuple3.Prelude.cs
│ │ ├── Tuple4/
│ │ │ ├── ValueTuple4.Extensions.cs
│ │ │ └── ValueTuple4.Prelude.cs
│ │ ├── Tuple5/
│ │ │ ├── ValueTuple5.Extensions.cs
│ │ │ └── ValueTuple5.Prelude.cs
│ │ ├── Tuple6/
│ │ │ ├── ValueTuple6.Extensions.cs
│ │ │ └── ValueTuple6.Prelude.cs
│ │ └── Tuple7/
│ │ ├── ValueTuple7.Extensions.cs
│ │ └── ValueTuple7.Prelude.cs
│ ├── Deriving/
│ │ ├── Alternative.cs
│ │ ├── Applicative.cs
│ │ ├── Choice.cs
│ │ ├── Cofunctor.cs
│ │ ├── Decidable.cs
│ │ ├── Divisible.cs
│ │ ├── Fallible.cs
│ │ ├── Final.cs
│ │ ├── Foldable.cs
│ │ ├── Functor.cs
│ │ ├── Maybe/
│ │ │ ├── MonadIO.cs
│ │ │ └── MonadUnliftIO.cs
│ │ ├── Monad.cs
│ │ ├── MonadIO.cs
│ │ ├── MonadT.cs
│ │ ├── MonadUnliftIO.cs
│ │ ├── MonoidK.cs
│ │ ├── Readable.cs
│ │ ├── SemigroupK.cs
│ │ ├── Stateful.cs
│ │ ├── Traversable.cs
│ │ └── Writable.cs
│ ├── Effects/
│ │ ├── Eff/
│ │ │ ├── Eff no runtime/
│ │ │ │ ├── Eff.Module.cs
│ │ │ │ ├── Eff.Monad.cs
│ │ │ │ ├── Eff.cs
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Eff.Extensions.MapApply.cs
│ │ │ │ │ ├── Eff.Extensions.cs
│ │ │ │ │ └── Eff.Guard.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Eff.Operators.Applicative.cs
│ │ │ │ │ ├── Eff.Operators.Choice.cs
│ │ │ │ │ ├── Eff.Operators.Fallible.cs
│ │ │ │ │ ├── Eff.Operators.Final.cs
│ │ │ │ │ ├── Eff.Operators.Functor.cs
│ │ │ │ │ ├── Eff.Operators.Monad.cs
│ │ │ │ │ └── Eff.Operators.cs
│ │ │ │ └── Prelude/
│ │ │ │ ├── Eff.Prelude.cs
│ │ │ │ └── Eff.Prelude.mapapply.cs
│ │ │ └── Eff with runtime/
│ │ │ ├── Eff.Module.cs
│ │ │ ├── Eff.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── Eff.Extensions.MapApply.cs
│ │ │ │ ├── Eff.Extensions.cs
│ │ │ │ └── Eff.Guard.cs
│ │ │ ├── Operators/
│ │ │ │ ├── Eff.Operators.Applicative.cs
│ │ │ │ ├── Eff.Operators.Choice.cs
│ │ │ │ ├── Eff.Operators.Fallible.cs
│ │ │ │ ├── Eff.Operators.Final.cs
│ │ │ │ ├── Eff.Operators.Functor.cs
│ │ │ │ ├── Eff.Operators.Monad.cs
│ │ │ │ └── Eff.Operators.cs
│ │ │ └── Prelude/
│ │ │ ├── Eff.Prelude.cs
│ │ │ └── Eff.Prelude.mapapply.cs
│ │ ├── IO/
│ │ │ ├── DSL/
│ │ │ │ ├── IOAction.cs
│ │ │ │ ├── IOActions.cs
│ │ │ │ ├── IOActionsAsync.cs
│ │ │ │ ├── IOApply.cs
│ │ │ │ ├── IOBind.cs
│ │ │ │ ├── IOBindAsync.cs
│ │ │ │ ├── IOBindMap.cs
│ │ │ │ ├── IOCatch.cs
│ │ │ │ ├── IOCatchPop.cs
│ │ │ │ ├── IOEmpty.cs
│ │ │ │ ├── IOFail.cs
│ │ │ │ ├── IOFinal.cs
│ │ │ │ ├── IOFold.cs
│ │ │ │ ├── IOFoldUntil.cs
│ │ │ │ ├── IOFoldWhile.cs
│ │ │ │ ├── IOLiftAsync.cs
│ │ │ │ ├── IOLiftSync.cs
│ │ │ │ ├── IOLocal2.cs
│ │ │ │ ├── IOMap.cs
│ │ │ │ ├── IOPure.cs
│ │ │ │ ├── IOPureAsync.cs
│ │ │ │ ├── IOTail.cs
│ │ │ │ ├── IOTimeout.cs
│ │ │ │ ├── IOToken.cs
│ │ │ │ ├── IOUninterruptible.cs
│ │ │ │ ├── IOUse.cs
│ │ │ │ ├── InvokeAsync.cs
│ │ │ │ ├── InvokeAsyncIO.cs
│ │ │ │ ├── InvokeSync.cs
│ │ │ │ └── InvokeSyncIO.cs
│ │ │ ├── EnvIO.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── IO.Extensions.MapApply.cs
│ │ │ │ ├── IO.Extensions.cs
│ │ │ │ └── IO.Guard.cs
│ │ │ ├── ForkIO.cs
│ │ │ ├── IO.Module.cs
│ │ │ ├── IO.Monad.cs
│ │ │ ├── IO.cs
│ │ │ ├── Operators/
│ │ │ │ ├── IO.Operators.Applicative.cs
│ │ │ │ ├── IO.Operators.Choice.cs
│ │ │ │ ├── IO.Operators.Fallible.cs
│ │ │ │ ├── IO.Operators.Final.cs
│ │ │ │ ├── IO.Operators.Functor.cs
│ │ │ │ ├── IO.Operators.Monad.cs
│ │ │ │ └── IO.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ ├── IO.Prelude.Concurreny.cs
│ │ │ │ ├── IO.Prelude.cs
│ │ │ │ └── IO.Prelude.mapapply.cs
│ │ │ └── Resources.cs
│ │ ├── MinRT.cs
│ │ ├── Prelude.cs
│ │ ├── README.md
│ │ └── Schedule/
│ │ ├── Duration.cs
│ │ ├── Schedule.Constructors.cs
│ │ ├── Schedule.DSL.cs
│ │ ├── Schedule.Extensions.cs
│ │ ├── Schedule.Prelude.cs
│ │ ├── Schedule.cs
│ │ ├── ScheduleTransformer.cs
│ │ └── SingletonRandom.cs
│ ├── Exceptions/
│ │ └── Exceptions.cs
│ ├── Extensions/
│ │ ├── ActionObservable.cs
│ │ ├── Compose.cs
│ │ ├── FuncExtensions.cs
│ │ ├── ObjectExt.cs
│ │ ├── ObservableExt.cs
│ │ ├── Query.cs
│ │ ├── TryOutExt.cs
│ │ └── UnsafeValueAccess.cs
│ ├── Guard.cs
│ ├── Immutable Collections/
│ │ ├── Arr/
│ │ │ ├── Arr.Module.cs
│ │ │ ├── Arr.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── Arr.Extensions.MapApply.cs
│ │ │ │ └── Arr.Extensions.cs
│ │ │ ├── Operators/
│ │ │ │ └── Arr.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Arr.Prelude.mapapply.cs
│ │ │ └── Trait/
│ │ │ └── Arr.TraitImpl.cs
│ │ ├── BiMap/
│ │ │ └── BiMap.cs
│ │ ├── HashMap/
│ │ │ ├── HashMap.Eq.cs
│ │ │ ├── HashMap.Extensions.Eq.cs
│ │ │ ├── HashMap.Extensions.MapApply.cs
│ │ │ ├── HashMap.Extensions.cs
│ │ │ ├── HashMap.Module.Eq.cs
│ │ │ ├── HashMap.Module.cs
│ │ │ ├── HashMap.Prelude.mapapply.cs
│ │ │ ├── HashMap.Trait.Implementations.Eq.cs
│ │ │ ├── HashMap.Trait.Implementations.cs
│ │ │ └── HashMap.cs
│ │ ├── HashSet/
│ │ │ ├── Extensions/
│ │ │ │ ├── HashSet.Extensions.MapApply.cs
│ │ │ │ └── HashSet.Extensions.cs
│ │ │ ├── HashSet.Eq.cs
│ │ │ ├── HashSet.Module.Eq.cs
│ │ │ ├── HashSet.Module.cs
│ │ │ ├── HashSet.cs
│ │ │ ├── Operators/
│ │ │ │ └── HashSet.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── HashSet.Prelude.mapapply.cs
│ │ │ └── Trait/
│ │ │ └── HashSet.TraitImpl.cs
│ │ ├── Iterable/
│ │ │ ├── DSL/
│ │ │ │ ├── Iterable.Add.cs
│ │ │ │ ├── Iterable.AsyncEnumerable.cs
│ │ │ │ ├── Iterable.Cast.cs
│ │ │ │ ├── Iterable.Concat.cs
│ │ │ │ ├── Iterable.Enumerable.cs
│ │ │ │ ├── Iterable.Nil.cs
│ │ │ │ ├── Iterable.Singleton.cs
│ │ │ │ ├── Iterable.SingletonIO.cs
│ │ │ │ ├── Iterable.Strict.cs
│ │ │ │ └── Iterable.Zip.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── Iterable.Extensions.MapApply.cs
│ │ │ │ └── Iterable.Extensions.cs
│ │ │ ├── Iterable.Module.cs
│ │ │ ├── Iterable.cs
│ │ │ ├── Operators/
│ │ │ │ └── Iterable.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Iterable.Prelude.mapapply.cs
│ │ │ └── Trait/
│ │ │ └── Iterable.TraitImpl.cs
│ │ ├── IterableNE/
│ │ │ ├── Extensions/
│ │ │ │ ├── IterableNE.Extensions.MapApply.cs
│ │ │ │ └── IterableNE.Extensions.cs
│ │ │ ├── IterableNE.Module.cs
│ │ │ ├── IterableNE.cs
│ │ │ ├── Operators/
│ │ │ │ └── IterableNE.Operators.cs
│ │ │ └── Trait/
│ │ │ └── IterableNE.TraitImpl.cs
│ │ ├── Iterator/
│ │ │ ├── DSL/
│ │ │ │ ├── Iterator.Cons.cs
│ │ │ │ ├── Iterator.ConsFirst.cs
│ │ │ │ ├── Iterator.ConsValue.cs
│ │ │ │ ├── Iterator.ConsValueEnum.cs
│ │ │ │ ├── Iterator.ConsValueLazy.cs
│ │ │ │ └── Iterator.Nil.cs
│ │ │ ├── Extensions/
│ │ │ │ └── Iterator.Extensions.cs
│ │ │ ├── Iterator.Module.cs
│ │ │ ├── Iterator.cs
│ │ │ ├── Operators/
│ │ │ │ └── Iterator.Operators.cs
│ │ │ ├── README.md
│ │ │ └── Trait/
│ │ │ └── Iterator.TraitImpl.cs
│ │ ├── IteratorAsync/
│ │ │ ├── DSL/
│ │ │ │ ├── IteratorAsync.Cons.cs
│ │ │ │ ├── IteratorAsync.ConsFirst.cs
│ │ │ │ ├── IteratorAsync.ConsValue.cs
│ │ │ │ ├── IteratorAsync.ConsValueEnum.cs
│ │ │ │ ├── IteratorAsync.ConsValueLazy.cs
│ │ │ │ └── IteratorAsync.Nil.cs
│ │ │ ├── Extensions/
│ │ │ │ └── IteratorAsync.Extensions.cs
│ │ │ ├── IteratorAsync.Module.cs
│ │ │ ├── IteratorAsync.cs
│ │ │ ├── Operators/
│ │ │ │ └── IteratorAsync.Operators.cs
│ │ │ ├── README.md
│ │ │ └── Trait/
│ │ │ └── IteratorAsync.TraitImpl.cs
│ │ ├── List/
│ │ │ ├── Extensions/
│ │ │ │ ├── Lst.Extensions.MapApply.cs
│ │ │ │ └── Lst.Extensions.cs
│ │ │ ├── Internal/
│ │ │ │ └── Lst.Internal.cs
│ │ │ ├── ListInfo.cs
│ │ │ ├── Lst.Module.cs
│ │ │ ├── Lst.cs
│ │ │ ├── Operators/
│ │ │ │ └── Lst.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Lst.Prelude.mapapply.cs
│ │ │ └── Trait/
│ │ │ └── Lst.TraitImpl.cs
│ │ ├── Map/
│ │ │ ├── Map.EnumeratorK.cs
│ │ │ ├── Map.EnumeratorKV.cs
│ │ │ ├── Map.EnumeratorV.cs
│ │ │ ├── Map.Extensions.MapApply.cs
│ │ │ ├── Map.Extensions.Ord.cs
│ │ │ ├── Map.Extensions.cs
│ │ │ ├── Map.Internal.cs
│ │ │ ├── Map.Module.Ord.cs
│ │ │ ├── Map.Module.cs
│ │ │ ├── Map.Ord.cs
│ │ │ ├── Map.Prelude.mapapply.cs
│ │ │ ├── Map.Trait.Implementations.cs
│ │ │ └── Map.cs
│ │ ├── Prelude.Collections.cs
│ │ ├── Queue/
│ │ │ ├── Que.Internal.cs
│ │ │ ├── Que.cs
│ │ │ └── Queue.Module.cs
│ │ ├── README.md
│ │ ├── Seq/
│ │ │ ├── DSL/
│ │ │ │ ├── Enum.cs
│ │ │ │ ├── ISeqInternal.cs
│ │ │ │ ├── SeqConcat.cs
│ │ │ │ ├── SeqEmptyInternal.cs
│ │ │ │ ├── SeqLazy.cs
│ │ │ │ └── SeqStrict.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── Seq.Extensions.MapApply.cs
│ │ │ │ └── Seq.Extensions.cs
│ │ │ ├── Operators/
│ │ │ │ └── Seq.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Seq.Prelude.mapapply.cs
│ │ │ ├── Seq.Module.cs
│ │ │ ├── Seq.cs
│ │ │ ├── SeqEmpty.cs
│ │ │ ├── SeqLoan.cs
│ │ │ └── Trait/
│ │ │ └── Seq.TraitImpl.cs
│ │ ├── Set/
│ │ │ ├── Extensions/
│ │ │ │ ├── Set.Extensions.MapApply.cs
│ │ │ │ └── Set.Extensions.cs
│ │ │ ├── Internal/
│ │ │ │ └── Set.Internal.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Set.Prelude.mapapply.cs
│ │ │ ├── Set.Module.cs
│ │ │ ├── Set.Ord.Module.cs
│ │ │ ├── Set.Ord.cs
│ │ │ ├── Set.cs
│ │ │ └── Trait/
│ │ │ └── Set.TraitImpl.cs
│ │ ├── Stack/
│ │ │ ├── Stack.Extensions.cs
│ │ │ ├── Stack.Module.cs
│ │ │ ├── Stck.Internal.cs
│ │ │ └── Stck.cs
│ │ ├── TrackingHashMap/
│ │ │ ├── TrackingHashMap.Eq.cs
│ │ │ ├── TrackingHashMap.Extensions.Eq.cs
│ │ │ ├── TrackingHashMap.Extensions.cs
│ │ │ ├── TrackingHashMap.Module.Eq.cs
│ │ │ ├── TrackingHashMap.Module.cs
│ │ │ └── TrackingHashMap.cs
│ │ ├── TrieMap/
│ │ │ └── TrieMap.cs
│ │ └── TrieSet/
│ │ └── TrieSet.cs
│ ├── LanguageExt.Core.csproj
│ ├── Lens/
│ │ ├── Lens.Operators.cs
│ │ ├── Lens.cs
│ │ ├── LensAB.cs
│ │ ├── Prelude.Lens.cs
│ │ └── README.md
│ ├── Memo/
│ │ ├── Extensions/
│ │ │ └── Memo.Extensions.cs
│ │ ├── Memo.F.cs
│ │ ├── Memo.Module.cs
│ │ ├── Memo.cs
│ │ ├── Operators/
│ │ │ └── Memo.Operators.cs
│ │ └── Prelude.Memoize.cs
│ ├── Monads/
│ │ ├── Alternative Monads/
│ │ │ ├── ChronicleT/
│ │ │ │ ├── ChronicleT.Module.2.cs
│ │ │ │ ├── ChronicleT.Module.cs
│ │ │ │ ├── ChronicleT.cs
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── ChronicleT.Extensions.cs
│ │ │ │ │ └── ChronicleT.Guard.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── ChronicleT.Operators.Applicative.cs
│ │ │ │ │ ├── ChronicleT.Operators.Choice.cs
│ │ │ │ │ ├── ChronicleT.Operators.Fallible.cs
│ │ │ │ │ ├── ChronicleT.Operators.Final.cs
│ │ │ │ │ ├── ChronicleT.Operators.Functor.cs
│ │ │ │ │ ├── ChronicleT.Operators.Monad.cs
│ │ │ │ │ ├── ChronicleT.Operators.SemigroupK.cs
│ │ │ │ │ └── ChronicleT.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── ChronicleT.Prelude.cs
│ │ │ │ └── Trait/
│ │ │ │ ├── ChronicleT.TraitImpl.2.cs
│ │ │ │ └── ChronicleT.TraitImpl.cs
│ │ │ ├── Either/
│ │ │ │ ├── Either.Left.cs
│ │ │ │ ├── Either.Module.cs
│ │ │ │ ├── Either.Right.cs
│ │ │ │ ├── Either.cs
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Either.Extensions.Apply.cs
│ │ │ │ │ ├── Either.Extensions.Map.cs
│ │ │ │ │ ├── Either.Extensions.cs
│ │ │ │ │ └── Either.Guard.cs
│ │ │ │ ├── IEither.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Either.Operators.Applicative.cs
│ │ │ │ │ ├── Either.Operators.Choice.cs
│ │ │ │ │ ├── Either.Operators.Fallible.cs
│ │ │ │ │ ├── Either.Operators.Functor.cs
│ │ │ │ │ ├── Either.Operators.Monad.cs
│ │ │ │ │ └── Either.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ ├── Either.Prelude.cs
│ │ │ │ │ └── Either.Prelude.mapapply.cs
│ │ │ │ ├── README.md
│ │ │ │ └── Trait/
│ │ │ │ ├── Either.TraitImpl.2.cs
│ │ │ │ └── Either.TraitImpl.cs
│ │ │ ├── EitherT/
│ │ │ │ ├── EitherT.Module.cs
│ │ │ │ ├── EitherT.cs
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── EitherT.Extensions.Apply.cs
│ │ │ │ │ ├── EitherT.Extensions.Map.cs
│ │ │ │ │ ├── EitherT.Extensions.cs
│ │ │ │ │ └── EitherT.Guard.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── EitherT.Operators.Applicative.cs
│ │ │ │ │ ├── EitherT.Operators.Choice.cs
│ │ │ │ │ ├── EitherT.Operators.Fallible.cs
│ │ │ │ │ ├── EitherT.Operators.Final.cs
│ │ │ │ │ ├── EitherT.Operators.Functor.cs
│ │ │ │ │ ├── EitherT.Operators.Monad.cs
│ │ │ │ │ ├── EitherT.Operators.SemigroupK.cs
│ │ │ │ │ └── EitherT.Operators.cs
│ │ │ │ └── Trait/
│ │ │ │ ├── EitherT.TraitImpl.2.cs
│ │ │ │ └── EitherT.TraitImpl.cs
│ │ │ ├── Fin/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Fin.Extensions.Apply.cs
│ │ │ │ │ ├── Fin.Extensions.Map.cs
│ │ │ │ │ ├── Fin.Extensions.cs
│ │ │ │ │ └── Fin.Guard.cs
│ │ │ │ ├── Fin.Fail.cs
│ │ │ │ ├── Fin.Module.cs
│ │ │ │ ├── Fin.Succ.cs
│ │ │ │ ├── Fin.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Fin.Operators.Applicative.cs
│ │ │ │ │ ├── Fin.Operators.Choice.cs
│ │ │ │ │ ├── Fin.Operators.Fallible.cs
│ │ │ │ │ ├── Fin.Operators.Functor.cs
│ │ │ │ │ ├── Fin.Operators.Monad.cs
│ │ │ │ │ ├── Fin.Operators.SemigroupK.cs
│ │ │ │ │ └── Fin.Operators.cs
│ │ │ │ ├── README.md
│ │ │ │ └── Trait/
│ │ │ │ └── Fin.TraitImpl.cs
│ │ │ ├── FinT/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── FinT.Extensions.Apply.cs
│ │ │ │ │ ├── FinT.Extensions.Map.cs
│ │ │ │ │ ├── FinT.Extensions.cs
│ │ │ │ │ └── FinT.Guard.cs
│ │ │ │ ├── FinT.Module.cs
│ │ │ │ ├── FinT.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── FinT.Operators.Applicative.cs
│ │ │ │ │ ├── FinT.Operators.Choice.cs
│ │ │ │ │ ├── FinT.Operators.Fallible.cs
│ │ │ │ │ ├── FinT.Operators.Final.cs
│ │ │ │ │ ├── FinT.Operators.Functor.cs
│ │ │ │ │ ├── FinT.Operators.Monad.cs
│ │ │ │ │ ├── FinT.Operators.SemigroupK.cs
│ │ │ │ │ └── FinT.Operators.cs
│ │ │ │ └── Trait/
│ │ │ │ └── FinT.TraitImpl.cs
│ │ │ ├── Nullable/
│ │ │ │ ├── Nullable.Prelude.cs
│ │ │ │ └── README.md
│ │ │ ├── Option/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Option.Extensions.MapApply.cs
│ │ │ │ │ └── Option.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Option.Operators.Applicative.cs
│ │ │ │ │ ├── Option.Operators.Choice.cs
│ │ │ │ │ ├── Option.Operators.Fallible.cs
│ │ │ │ │ ├── Option.Operators.Functor.cs
│ │ │ │ │ ├── Option.Operators.Monad.cs
│ │ │ │ │ └── Option.Operators.cs
│ │ │ │ ├── Option.Module.cs
│ │ │ │ ├── Option.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ ├── Option.Prelude.cs
│ │ │ │ │ └── Option.Prelude.mapapply.cs
│ │ │ │ ├── README.md
│ │ │ │ ├── Shared/
│ │ │ │ │ ├── IOptional.cs
│ │ │ │ │ ├── SomeContext.cs
│ │ │ │ │ └── SomeUnitContext.cs
│ │ │ │ └── Trait/
│ │ │ │ └── Option.TraitImpl.cs
│ │ │ ├── OptionT/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── OptionT.Extensions.MapApply.cs
│ │ │ │ │ └── OptionT.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── OptionT.Operators.Applicative.cs
│ │ │ │ │ ├── OptionT.Operators.Choice.cs
│ │ │ │ │ ├── OptionT.Operators.Fallible.cs
│ │ │ │ │ ├── OptionT.Operators.Final.cs
│ │ │ │ │ ├── OptionT.Operators.Functor.cs
│ │ │ │ │ ├── OptionT.Operators.Monad.cs
│ │ │ │ │ ├── OptionT.Operators.SemigroupK.cs
│ │ │ │ │ └── OptionT.Operators.cs
│ │ │ │ ├── OptionT.Module.cs
│ │ │ │ ├── OptionT.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── OptionT.Prelude.mapapply.cs
│ │ │ │ └── Trait/
│ │ │ │ └── OptionT.TraitImpl.cs
│ │ │ ├── README.md
│ │ │ ├── These/
│ │ │ │ ├── Extensions/
│ │ │ │ │ └── These.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── These.Operators.Functor.cs
│ │ │ │ │ ├── These.Operators.SemigroupK.cs
│ │ │ │ │ └── These.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── These.Prelude.cs
│ │ │ │ ├── These.Both.cs
│ │ │ │ ├── These.Module.cs
│ │ │ │ ├── These.That.cs
│ │ │ │ ├── These.This.cs
│ │ │ │ ├── These.cs
│ │ │ │ └── Trait/
│ │ │ │ └── These.TraitImpl.cs
│ │ │ ├── Try/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Try.Extensions.MapApply.cs
│ │ │ │ │ └── Try.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Try.Operators.Applicative.cs
│ │ │ │ │ ├── Try.Operators.Choice.cs
│ │ │ │ │ ├── Try.Operators.Fallible.cs
│ │ │ │ │ ├── Try.Operators.Final.cs
│ │ │ │ │ ├── Try.Operators.Functor.cs
│ │ │ │ │ ├── Try.Operators.Monad.cs
│ │ │ │ │ └── Try.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── Try.Prelude.mapapply.cs
│ │ │ │ ├── Trait/
│ │ │ │ │ └── Try.TraitImpl.cs
│ │ │ │ ├── Try.Module.cs
│ │ │ │ └── Try.cs
│ │ │ ├── TryT/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── TryT.Extensions.MapApply.cs
│ │ │ │ │ └── TryT.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── TryT.Operators.Applicative.cs
│ │ │ │ │ ├── TryT.Operators.Choice.cs
│ │ │ │ │ ├── TryT.Operators.Fallible.cs
│ │ │ │ │ ├── TryT.Operators.Functor.cs
│ │ │ │ │ ├── TryT.Operators.Monad.cs
│ │ │ │ │ └── TryT.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── TryT.Prelude.mapapply.cs
│ │ │ │ ├── Trait/
│ │ │ │ │ └── TryT.TraitImpl.cs
│ │ │ │ ├── TryT.Module.cs
│ │ │ │ └── TryT.cs
│ │ │ ├── Validation/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Validation.Extensions.Apply.cs
│ │ │ │ │ ├── Validation.Extensions.Map.cs
│ │ │ │ │ ├── Validation.Extensions.cs
│ │ │ │ │ └── Validation.Guard.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Validation.Operators.Applicative.cs
│ │ │ │ │ ├── Validation.Operators.Choice.cs
│ │ │ │ │ ├── Validation.Operators.Combine.cs
│ │ │ │ │ ├── Validation.Operators.CombineSeq.cs
│ │ │ │ │ ├── Validation.Operators.Fallible.cs
│ │ │ │ │ ├── Validation.Operators.Functor.cs
│ │ │ │ │ ├── Validation.Operators.Monad.cs
│ │ │ │ │ └── Validation.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ ├── Validation.Prelude.apply.cs
│ │ │ │ │ ├── Validation.Prelude.cs
│ │ │ │ │ └── Validation.Prelude.map.cs
│ │ │ │ ├── Trait/
│ │ │ │ │ ├── Validation.TraitImpl.2.cs
│ │ │ │ │ └── Validation.TraitImpl.cs
│ │ │ │ ├── Validation.Fail.cs
│ │ │ │ ├── Validation.Module.cs
│ │ │ │ ├── Validation.Success.cs
│ │ │ │ └── Validation.cs
│ │ │ └── ValidationT/
│ │ │ ├── Extensions/
│ │ │ │ ├── ValidationT.Extensions.Apply.cs
│ │ │ │ ├── ValidationT.Extensions.Map.cs
│ │ │ │ ├── ValidationT.Extensions.cs
│ │ │ │ └── ValidationT.Guard.cs
│ │ │ ├── Operators/
│ │ │ │ ├── ValidationT.Operators.Applicative.cs
│ │ │ │ ├── ValidationT.Operators.Choice.cs
│ │ │ │ ├── ValidationT.Operators.Combine.cs
│ │ │ │ ├── ValidationT.Operators.Fallible.cs
│ │ │ │ ├── ValidationT.Operators.Functor.cs
│ │ │ │ ├── ValidationT.Operators.Monad.cs
│ │ │ │ └── ValidationT.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── ValidationT.Prelude.mapapply.cs
│ │ │ ├── Trait/
│ │ │ │ ├── ValidationT.TraitImpl.2.cs
│ │ │ │ └── ValidationT.TraitImpl.cs
│ │ │ ├── ValidationT.Module.cs
│ │ │ └── ValidationT.cs
│ │ ├── ContT/
│ │ │ ├── ContT.Module.cs
│ │ │ ├── ContT.cs
│ │ │ └── README.md
│ │ ├── Free/
│ │ │ ├── Extensions/
│ │ │ │ ├── Free.Extensions.MapApply.cs
│ │ │ │ └── Free.Extensions.cs
│ │ │ ├── Free.Module.cs
│ │ │ ├── Free.cs
│ │ │ ├── Operators/
│ │ │ │ ├── Free.Operators.Applicative.cs
│ │ │ │ ├── Free.Operators.Functor.cs
│ │ │ │ ├── Free.Operators.Monad.cs
│ │ │ │ └── Free.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Free.Prelude.mapapply.cs
│ │ │ └── Trait/
│ │ │ └── Free.TraitImpl.cs
│ │ ├── Identity/
│ │ │ ├── Extensions/
│ │ │ │ └── Identity.Extensions.cs
│ │ │ ├── Identity.Module.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Operators/
│ │ │ │ └── Identity.Operators.cs
│ │ │ └── Trait/
│ │ │ └── Identity.TraitImpl.cs
│ │ ├── IdentityT/
│ │ │ ├── IdentityT.Extensions.cs
│ │ │ ├── IdentityT.Module.cs
│ │ │ ├── IdentityT.Monad.cs
│ │ │ └── IdentityT.cs
│ │ ├── Lifting/
│ │ │ ├── Lift.Extensions.cs
│ │ │ ├── Lift.Prelude.cs
│ │ │ └── Lift.cs
│ │ ├── Monadic conditionals/
│ │ │ ├── Prelude.guard.cs
│ │ │ ├── Prelude.guardnot.cs
│ │ │ ├── Prelude.iff.cs
│ │ │ ├── Prelude.unless.cs
│ │ │ ├── Prelude.when.cs
│ │ │ └── README.md
│ │ ├── Prelude.cs
│ │ ├── README.md
│ │ ├── State and Environment Monads/
│ │ │ ├── RWS/
│ │ │ │ └── RWST/
│ │ │ │ ├── Extensions/
│ │ │ │ │ └── RWST.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── RWST.Operators.Applicative.cs
│ │ │ │ │ ├── RWST.Operators.Choice.cs
│ │ │ │ │ ├── RWST.Operators.Fallible.cs
│ │ │ │ │ ├── RWST.Operators.Final.cs
│ │ │ │ │ ├── RWST.Operators.Functor.cs
│ │ │ │ │ ├── RWST.Operators.Monad.cs
│ │ │ │ │ ├── RWST.Operators.SemigroupK.cs
│ │ │ │ │ └── RWST.Operators.cs
│ │ │ │ ├── RWST.Module.cs
│ │ │ │ ├── RWST.cs
│ │ │ │ └── Trait/
│ │ │ │ └── RWST.TraitImpl.cs
│ │ │ ├── Reader/
│ │ │ │ ├── Ask.cs
│ │ │ │ ├── Reader/
│ │ │ │ │ ├── Extensions/
│ │ │ │ │ │ └── Reader.Extensions.cs
│ │ │ │ │ ├── Operators/
│ │ │ │ │ │ ├── Reader.Operators.Applicative.cs
│ │ │ │ │ │ ├── Reader.Operators.Functor.cs
│ │ │ │ │ │ ├── Reader.Operators.Monad.cs
│ │ │ │ │ │ └── Reader.Operators.cs
│ │ │ │ │ ├── Reader.Module.cs
│ │ │ │ │ ├── Reader.cs
│ │ │ │ │ └── Trait/
│ │ │ │ │ └── Reader.TraitImpl.cs
│ │ │ │ └── ReaderT/
│ │ │ │ ├── Extensions/
│ │ │ │ │ └── ReaderT.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── ReaderT.Operators.Applicative.cs
│ │ │ │ │ ├── ReaderT.Operators.Choice.cs
│ │ │ │ │ ├── ReaderT.Operators.Fallible.cs
│ │ │ │ │ ├── ReaderT.Operators.Final.cs
│ │ │ │ │ ├── ReaderT.Operators.Functor.cs
│ │ │ │ │ ├── ReaderT.Operators.Monad.cs
│ │ │ │ │ ├── ReaderT.Operators.SemigroupK.cs
│ │ │ │ │ └── ReaderT.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── ReaderT.Prelude.mapapply.cs
│ │ │ │ ├── ReaderT.Module.cs
│ │ │ │ ├── ReaderT.cs
│ │ │ │ └── Trait/
│ │ │ │ └── ReaderT.TraitImpl.cs
│ │ │ ├── State/
│ │ │ │ ├── PutGet.cs
│ │ │ │ ├── State/
│ │ │ │ │ ├── Extensions/
│ │ │ │ │ │ └── State.Extensions.cs
│ │ │ │ │ ├── Operators/
│ │ │ │ │ │ ├── State.Operators.Applicative.cs
│ │ │ │ │ │ ├── State.Operators.Functor.cs
│ │ │ │ │ │ ├── State.Operators.Monad.cs
│ │ │ │ │ │ └── State.Operators.cs
│ │ │ │ │ ├── State.Module.cs
│ │ │ │ │ ├── State.cs
│ │ │ │ │ └── Trait/
│ │ │ │ │ └── State.TraitImpl.cs
│ │ │ │ └── StateT/
│ │ │ │ ├── Extensions/
│ │ │ │ │ └── StateT.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── StateT.Operators.Applicative.cs
│ │ │ │ │ ├── StateT.Operators.Choice.cs
│ │ │ │ │ ├── StateT.Operators.Fallible.cs
│ │ │ │ │ ├── StateT.Operators.Final.cs
│ │ │ │ │ ├── StateT.Operators.Functor.cs
│ │ │ │ │ ├── StateT.Operators.Monad.cs
│ │ │ │ │ ├── StateT.Operators.SemigroupK.cs
│ │ │ │ │ └── StateT.Operators.cs
│ │ │ │ ├── StateT.Module.cs
│ │ │ │ ├── StateT.cs
│ │ │ │ └── Trait/
│ │ │ │ └── StateT.TraitImpl.cs
│ │ │ └── Writer/
│ │ │ ├── Tell.cs
│ │ │ ├── Writer/
│ │ │ │ ├── Extensions/
│ │ │ │ │ └── Writer.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Writer.Operators.Applicative.cs
│ │ │ │ │ ├── Writer.Operators.Functor.cs
│ │ │ │ │ ├── Writer.Operators.Monad.cs
│ │ │ │ │ └── Writer.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── Writer.Prelude.cs
│ │ │ │ ├── Trait/
│ │ │ │ │ └── Writer.TraitImpl.cs
│ │ │ │ ├── Writer.Module.cs
│ │ │ │ └── Writer.cs
│ │ │ └── WriterT/
│ │ │ ├── Extensions/
│ │ │ │ └── WriterT.Extensions.cs
│ │ │ ├── Operators/
│ │ │ │ ├── WriterT.Operators.Applicative.cs
│ │ │ │ ├── WriterT.Operators.Choice.cs
│ │ │ │ ├── WriterT.Operators.Fallible.cs
│ │ │ │ ├── WriterT.Operators.Final.cs
│ │ │ │ ├── WriterT.Operators.Functor.cs
│ │ │ │ ├── WriterT.Operators.Monad.cs
│ │ │ │ ├── WriterT.Operators.SemigroupK.cs
│ │ │ │ └── WriterT.Operators.cs
│ │ │ ├── Trait/
│ │ │ │ └── WriterT.TraitImpl.cs
│ │ │ ├── WriterT.Module.cs
│ │ │ └── WriterT.cs
│ │ └── Trampoline/
│ │ └── Trampoline.cs
│ ├── Number.cs
│ ├── Obsolete and Deprecated/
│ │ ├── Change.cs
│ │ └── Fin.Prelude.cs
│ ├── Opt.cs
│ ├── Prelude/
│ │ ├── Currying and Partial Application/
│ │ │ ├── Prelude.Curry.cs
│ │ │ ├── Prelude.PartialApplication.cs
│ │ │ └── Prelude.Uncurry.cs
│ │ ├── Function argument flipping/
│ │ │ └── Prelude.Flip.cs
│ │ ├── Hash code functions/
│ │ │ └── Prelude.Hash.cs
│ │ ├── Lambda function inference/
│ │ │ └── Prelude.Func.cs
│ │ ├── Prelude.cs
│ │ ├── README.md
│ │ ├── Random/
│ │ │ └── Prelude.Random.cs
│ │ ├── Resources/
│ │ │ └── Prelude.Resources.cs
│ │ ├── Timer/
│ │ │ └── Prelude.Timer.cs
│ │ └── Value parsing/
│ │ └── Prelude.Parse.cs
│ ├── Pretty/
│ │ ├── Doc.cs
│ │ ├── DocAnn.cs
│ │ ├── DocStream.cs
│ │ ├── Doc_A.cs
│ │ ├── FastSpace.cs
│ │ ├── FittingPredicate.cs
│ │ ├── FlattenResult.cs
│ │ ├── Layout.cs
│ │ ├── LayoutOptions.cs
│ │ ├── LayoutPipeline.cs
│ │ └── PageWidth.cs
│ ├── Prism/
│ │ ├── Prelude_Prism.cs
│ │ ├── Prism.cs
│ │ ├── PrismAB.cs
│ │ └── README.md
│ ├── README.md
│ ├── README.nuget.md
│ ├── Traits/
│ │ ├── Alternative/
│ │ │ ├── Alternative.Extensions.cs
│ │ │ ├── Alternative.Laws.cs
│ │ │ ├── Alternative.Module.cs
│ │ │ ├── Alternative.Prelude.cs
│ │ │ ├── Alternative.Trait.cs
│ │ │ └── README.md
│ │ ├── Applicative/
│ │ │ ├── Act.cs
│ │ │ ├── Applicative.Laws.cs
│ │ │ ├── Applicative.Trait.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── Applicative.Extensions.Action.cs
│ │ │ │ ├── Applicative.Extensions.Apply.cs
│ │ │ │ ├── Applicative.Extensions.ApplyM.cs
│ │ │ │ ├── Applicative.Extensions.Arithmetic.cs
│ │ │ │ ├── Applicative.Extensions.Lift.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Action.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Apply.Tuple.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Apply.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Arithmetic.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Lift.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Zip.cs
│ │ │ │ ├── Applicative.Extensions.Zip.cs
│ │ │ │ └── Applicative.Extensions.cs
│ │ │ ├── Module/
│ │ │ │ ├── Applicative.Module.Action.cs
│ │ │ │ ├── Applicative.Module.Apply.cs
│ │ │ │ ├── Applicative.Module.ApplyM.cs
│ │ │ │ ├── Applicative.Module.Arithmetic.cs
│ │ │ │ ├── Applicative.Module.Lift.cs
│ │ │ │ ├── Applicative.Module.Memo.Action.cs
│ │ │ │ ├── Applicative.Module.Memo.Apply.cs
│ │ │ │ ├── Applicative.Module.Memo.ApplyM.cs
│ │ │ │ ├── Applicative.Module.Memo.Arithmetic.cs
│ │ │ │ ├── Applicative.Module.Memo.Lift.cs
│ │ │ │ ├── Applicative.Module.Zip.cs
│ │ │ │ └── Applicative.Module.cs
│ │ │ ├── Operators/
│ │ │ │ ├── Applicative.Memo.Operators.cs
│ │ │ │ └── Applicative.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Applicative.Prelude.cs
│ │ │ └── README.md
│ │ ├── Arithmetic/
│ │ │ ├── Arithmetic.Prelude.cs
│ │ │ └── Arithmetic.cs
│ │ ├── Biapplicative/
│ │ │ └── Biapplicative.Trait.cs
│ │ ├── Bifunctor/
│ │ │ ├── Bifunctor.Extensions.cs
│ │ │ ├── Bifunctor.Module.cs
│ │ │ └── Bifunctor.Trait.cs
│ │ ├── Bimonad/
│ │ │ ├── Bimonad.Extensions.cs
│ │ │ ├── Bimonad.Module.cs
│ │ │ └── Bimonad.Trait.cs
│ │ ├── Bool/
│ │ │ └── Bool.cs
│ │ ├── Choice/
│ │ │ ├── Choice.Laws.cs
│ │ │ ├── Choice.Module.cs
│ │ │ ├── Choice.Trait.cs
│ │ │ ├── Extensions/
│ │ │ │ └── Choice.Extensions.cs
│ │ │ ├── Operators/
│ │ │ │ └── Choice.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Choice.Prelude.cs
│ │ │ └── README.md
│ │ ├── Chronicaler/
│ │ │ ├── Chronicaler.Extensions.cs
│ │ │ ├── Chronicaler.Module.cs
│ │ │ └── Chronicaler.Trait.cs
│ │ ├── Cofunctor/
│ │ │ ├── Cofunctor.Extensions.cs
│ │ │ ├── Cofunctor.Module.cs
│ │ │ ├── Cofunctor.Prelude.cs
│ │ │ └── Cofunctor.Trait.cs
│ │ ├── Const/
│ │ │ └── Const.cs
│ │ ├── Coproduct/
│ │ │ ├── Coproduct.Extensions.cs
│ │ │ ├── Coproduct.Module.cs
│ │ │ └── Coproduct.Trait.cs
│ │ ├── CoproductCons/
│ │ │ ├── CoproductCons.Module.cs
│ │ │ └── CoproductCons.Trait.cs
│ │ ├── CoproductK/
│ │ │ ├── CoproductK.Extensions.cs
│ │ │ ├── CoproductK.Module.cs
│ │ │ └── CoproductK.Trait.cs
│ │ ├── Coreadable/
│ │ │ ├── Coreadable.Extensions.cs
│ │ │ ├── Coreadable.Module.cs
│ │ │ └── Coreadable.Trait.cs
│ │ ├── Decidable/
│ │ │ ├── Decidable.Module.cs
│ │ │ ├── Decidable.Prelude.cs
│ │ │ └── Decidable.Trait.cs
│ │ ├── Deriving/
│ │ │ └── Deriving.cs
│ │ ├── Divisible/
│ │ │ ├── Divisible.Module.cs
│ │ │ ├── Divisible.Prelude.cs
│ │ │ └── Divisible.Trait.cs
│ │ ├── Domain/
│ │ │ ├── Amount.cs
│ │ │ ├── DomainType.cs
│ │ │ ├── Identifier.cs
│ │ │ ├── Locus.cs
│ │ │ ├── README.md
│ │ │ └── VectorSpace.cs
│ │ ├── Eq/
│ │ │ ├── Eq.Extensions.cs
│ │ │ ├── Eq.Module.cs
│ │ │ ├── Eq.Prelude.cs
│ │ │ └── Eq.cs
│ │ ├── Fallible/
│ │ │ ├── Fallible.Extensions.Catch.E.cs
│ │ │ ├── Fallible.Extensions.Catch.cs
│ │ │ ├── Fallible.Extensions.Fails.E.cs
│ │ │ ├── Fallible.Extensions.Fails.cs
│ │ │ ├── Fallible.Extensions.Partition.E.cs
│ │ │ ├── Fallible.Extensions.Partition.cs
│ │ │ ├── Fallible.Extensions.Succs.E.cs
│ │ │ ├── Fallible.Extensions.Succs.cs
│ │ │ ├── Fallible.Guard.cs
│ │ │ ├── Fallible.Interface.cs
│ │ │ ├── Fallible.Module.cs
│ │ │ ├── Fallible.Operators.cs
│ │ │ ├── Fallible.Prelude.Catch.E.cs
│ │ │ ├── Fallible.Prelude.Catch.cs
│ │ │ ├── Fallible.Prelude.Fails.E.cs
│ │ │ ├── Fallible.Prelude.Fails.cs
│ │ │ ├── Fallible.Prelude.Partition.E.cs
│ │ │ ├── Fallible.Prelude.Partition.cs
│ │ │ ├── Fallible.Prelude.Succs.E.cs
│ │ │ ├── Fallible.Prelude.Succs.cs
│ │ │ ├── Fallible.Prelude.cs
│ │ │ └── Fallible.Trait.cs
│ │ ├── Final/
│ │ │ ├── Final.Extensions.cs
│ │ │ ├── Final.Module.cs
│ │ │ ├── Final.Operators.cs
│ │ │ ├── Final.Prelude.cs
│ │ │ ├── Final.Trait.cs
│ │ │ └── Finally.cs
│ │ ├── Floating/
│ │ │ ├── Floating.Prelude.cs
│ │ │ └── Floating.cs
│ │ ├── Foldable/
│ │ │ ├── Fold.Module.cs
│ │ │ ├── Fold.cs
│ │ │ ├── Foldable.Extensions.cs
│ │ │ ├── Foldable.ExtensionsT.cs
│ │ │ ├── Foldable.Module.cs
│ │ │ ├── Foldable.Prelude.cs
│ │ │ └── Foldable.Trait.cs
│ │ ├── Fraction/
│ │ │ ├── Fraction.Prelude.cs
│ │ │ └── Fraction.cs
│ │ ├── Functor/
│ │ │ ├── Extensions/
│ │ │ │ ├── Functor.Extensions.cs
│ │ │ │ ├── Functor.ExtensionsT.cs
│ │ │ │ └── Functor.MemoExtensions.cs
│ │ │ ├── Functor.Laws.cs
│ │ │ ├── Functor.Module.cs
│ │ │ ├── Functor.Trait.cs
│ │ │ ├── Operators/
│ │ │ │ ├── Functor.MemoOperators.cs
│ │ │ │ └── Functor.Operators.cs
│ │ │ └── Prelude/
│ │ │ └── Functor.Prelude.cs
│ │ ├── Has/
│ │ │ ├── Has.Trait.cs
│ │ │ └── Has.cs
│ │ ├── Hashable/
│ │ │ ├── Hashable.Module.cs
│ │ │ └── Hashable.Trait.cs
│ │ ├── Identifiable/
│ │ │ ├── Identifiable.Module.cs
│ │ │ ├── Identifiable.Operators.cs
│ │ │ ├── Identifiable.Prelude.cs
│ │ │ ├── Identifiable.cs
│ │ │ └── Label.cs
│ │ ├── Indexable/
│ │ │ └── Indexable.cs
│ │ ├── K.Extensions.cs
│ │ ├── K.cs
│ │ ├── Local/
│ │ │ ├── Local.Module.cs
│ │ │ └── Local.Trait.cs
│ │ ├── Maybe Traits/
│ │ │ ├── MonadIO/
│ │ │ │ └── MonadIO.Trait.cs
│ │ │ └── MonadUnliftIO/
│ │ │ ├── MonadUnliftIO.Extensions.cs
│ │ │ └── MonadUnliftIO.Trait.cs
│ │ ├── Monads/
│ │ │ ├── Monad/
│ │ │ │ ├── Monad.Extensions.cs
│ │ │ │ ├── Monad.ExtensionsT.cs
│ │ │ │ ├── Monad.Laws.cs
│ │ │ │ ├── Monad.Module.cs
│ │ │ │ ├── Monad.Operators.cs
│ │ │ │ └── Monad.Trait.cs
│ │ │ ├── MonadIO/
│ │ │ │ ├── MonadIO.Extensions.cs
│ │ │ │ ├── MonadIO.Module.cs
│ │ │ │ └── MonadIO.Trait.cs
│ │ │ ├── MonadT/
│ │ │ │ ├── MonadT.Extensions.cs
│ │ │ │ ├── MonadT.Module.cs
│ │ │ │ └── MonadT.Trait.cs
│ │ │ ├── MonadUnliftIO/
│ │ │ │ ├── MonadUnliftIO.Extensions.cs
│ │ │ │ ├── MonadUnliftIO.Module.cs
│ │ │ │ └── MonadUnliftIO.Trait.cs
│ │ │ └── README.md
│ │ ├── Monoid/
│ │ │ ├── Monoid.Instance.cs
│ │ │ ├── Monoid.Prelude.cs
│ │ │ └── Monoid.cs
│ │ ├── MonoidK/
│ │ │ ├── MonoidK.Extensions.cs
│ │ │ ├── MonoidK.Module.cs
│ │ │ ├── MonoidK.cs
│ │ │ └── README.md
│ │ ├── Mutates/
│ │ │ ├── Mutates.Module.cs
│ │ │ └── Mutates.Trait.cs
│ │ ├── Natural/
│ │ │ ├── CoNatural.Module.cs
│ │ │ ├── CoNatural.cs
│ │ │ ├── Natural.Module.cs
│ │ │ ├── Natural.cs
│ │ │ ├── NaturalEpi.cs
│ │ │ ├── NaturalIso.cs
│ │ │ ├── NaturalMono.cs
│ │ │ └── README.md
│ │ ├── Num/
│ │ │ ├── Num.Prelude.cs
│ │ │ └── Num.cs
│ │ ├── Ord/
│ │ │ ├── Ord.Module.cs
│ │ │ ├── Ord.Prelude.cs
│ │ │ ├── Ord.cs
│ │ │ └── OrdComparer.cs
│ │ ├── Predicate/
│ │ │ └── Predicate.cs
│ │ ├── README.md
│ │ ├── Range/
│ │ │ └── Range.Trait.cs
│ │ ├── Readable/
│ │ │ ├── Readable.Extensions.cs
│ │ │ ├── Readable.Module.cs
│ │ │ ├── Readable.Prelude.cs
│ │ │ └── Readable.Trait.cs
│ │ ├── Resolve/
│ │ │ ├── EqResolver.cs
│ │ │ ├── HashableResolver.cs
│ │ │ ├── OrdResolver.cs
│ │ │ └── Resolver.cs
│ │ ├── Semigroup/
│ │ │ ├── Semigroup.Instance.cs
│ │ │ ├── Semigroup.Module.cs
│ │ │ ├── Semigroup.Operators.cs
│ │ │ ├── Semigroup.Prelude.cs
│ │ │ └── Semigroup.cs
│ │ ├── SemigroupK/
│ │ │ ├── SemigroupK.Extensions.cs
│ │ │ ├── SemigroupK.Module.cs
│ │ │ ├── SemigroupK.Operators.cs
│ │ │ ├── SemigroupK.Prelude.cs
│ │ │ └── SemigroupK.cs
│ │ ├── Stateful/
│ │ │ ├── Stateful.Extensions.cs
│ │ │ ├── Stateful.Module.cs
│ │ │ └── Stateful.Trait.cs
│ │ ├── TokenStream/
│ │ │ ├── TokenStream.Module.cs
│ │ │ └── TokenStream.cs
│ │ ├── Trait.cs
│ │ ├── TraitAttribute.cs
│ │ ├── Traversable/
│ │ │ ├── README.md
│ │ │ ├── Traversable.Extensions.cs
│ │ │ ├── Traversable.Module.cs
│ │ │ └── Traversable.Trait.cs
│ │ └── Writable/
│ │ ├── Writable.Extensions.cs
│ │ ├── Writable.Module.cs
│ │ └── Writable.Trait.cs
│ ├── Units of Measure/
│ │ ├── Accel.cs
│ │ ├── Area.cs
│ │ ├── Length.cs
│ │ ├── Mass.cs
│ │ ├── Module.cs
│ │ ├── Temperature.cs
│ │ ├── Time.cs
│ │ ├── TimeSq.cs
│ │ ├── Velocity.cs
│ │ └── VelocitySq.cs
│ ├── Utility/
│ │ ├── AsyncEnumerableEx.cs
│ │ ├── Box.cs
│ │ ├── Check.cs
│ │ ├── CollectionFormat.cs
│ │ ├── Disposable.cs
│ │ ├── EnumerableOptimal.cs
│ │ ├── Fnv.cs
│ │ ├── IL.cs
│ │ ├── Inter.cs
│ │ ├── Pool.cs
│ │ ├── ReferenceEqualityComparer.cs
│ │ ├── Reflect.cs
│ │ ├── SysInfo.cs
│ │ ├── TaskExt.cs
│ │ └── WaitAsync.cs
│ └── Void.cs
├── LanguageExt.FSharp/
│ ├── LanguageExt.FSharp.csproj
│ ├── Prelude.cs
│ └── README.nuget.md
├── LanguageExt.Megaparsec/
│ ├── Delegates.cs
│ ├── ErrorFancy/
│ │ ├── ErrorFancy.Module.cs
│ │ └── ErrorFancy.cs
│ ├── ErrorItem/
│ │ ├── ErrorItem.Extensions.cs
│ │ ├── ErrorItem.Module.cs
│ │ ├── ErrorItem.cs
│ │ └── ExpectedErrors.cs
│ ├── Hints/
│ │ ├── Hints.Module.cs
│ │ └── Hints.cs
│ ├── LanguageExt.Megaparsec.csproj
│ ├── LineText.cs
│ ├── ModuleT/
│ │ ├── Expr.cs
│ │ ├── Failure.cs
│ │ ├── Lexer.cs
│ │ ├── Prim.cs
│ │ ├── State.cs
│ │ ├── Text.cs
│ │ └── Token.cs
│ ├── MonadParsecT/
│ │ ├── MonadParsecT.Module.cs
│ │ └── MonadParsecT.cs
│ ├── Operator.cs
│ ├── PString.cs
│ ├── ParseError/
│ │ ├── ParseError.Module.cs
│ │ └── ParseError.cs
│ ├── ParsecT/
│ │ ├── DSL/
│ │ │ ├── Apply.cs
│ │ │ ├── Bind.cs
│ │ │ ├── Catch.cs
│ │ │ ├── Choose.cs
│ │ │ ├── DSL.cs
│ │ │ ├── EOF.cs
│ │ │ ├── Empty.cs
│ │ │ ├── Error.cs
│ │ │ ├── Fail.cs
│ │ │ ├── Label.cs
│ │ │ ├── Lift.cs
│ │ │ ├── LookAhead.cs
│ │ │ ├── MTransLift.cs
│ │ │ ├── Map.cs
│ │ │ ├── NoneOf.cs
│ │ │ ├── NotFollowedBy.cs
│ │ │ ├── Observing.cs
│ │ │ ├── OneOf.cs
│ │ │ ├── Pure.cs
│ │ │ ├── Reader.cs
│ │ │ ├── State.cs
│ │ │ ├── Take.cs
│ │ │ ├── TakeWhile.cs
│ │ │ ├── TakeWhile1.cs
│ │ │ ├── Token.cs
│ │ │ ├── Tokens.cs
│ │ │ ├── Try.cs
│ │ │ └── WithRecovery.cs
│ │ ├── Extensions/
│ │ │ └── ParsecTExtensions.cs
│ │ ├── ParsecT.cs
│ │ └── Trait/
│ │ └── ParsecT.TraitImpl.cs
│ ├── Pos.cs
│ ├── PosState.cs
│ ├── Reach.cs
│ ├── Reply/
│ │ ├── Extensions/
│ │ │ └── Reply.Extensions.cs
│ │ ├── Reply.Module.cs
│ │ ├── Reply.cs
│ │ └── Trait/
│ │ └── Reply.TraitImpl.cs
│ ├── Result/
│ │ ├── Extensions/
│ │ │ └── Result.Extensions.cs
│ │ ├── Result.Module.cs
│ │ ├── Result.cs
│ │ └── Trait/
│ │ └── Result.TraitImpl.cs
│ ├── SourcePos.cs
│ └── State.cs
├── LanguageExt.Parsec/
│ ├── Common.cs
│ ├── Exceptions.cs
│ ├── GenLanguageDef.cs
│ ├── GenTokenParser.cs
│ ├── GenTokenParser2.cs
│ ├── Language.cs
│ ├── LanguageExt.Parsec.csproj
│ ├── OperatorIOs.cs
│ ├── Operators.cs
│ ├── PString.cs
│ ├── PStringIO.cs
│ ├── Parsec.Internal.cs
│ ├── ParsecIO.Internal.cs
│ ├── Parser.cs
│ ├── ParserError.cs
│ ├── ParserIO.cs
│ ├── ParserIOs/
│ │ ├── Expr.cs
│ │ ├── Indent.cs
│ │ ├── Item.cs
│ │ └── Prim.cs
│ ├── ParserResult.cs
│ ├── ParserResultIO.cs
│ ├── Parsers/
│ │ ├── Char.cs
│ │ ├── Expr.cs
│ │ ├── Indent.cs
│ │ ├── Prim.cs
│ │ ├── Token.cs
│ │ └── Token2.cs
│ ├── Pipes.cs
│ ├── Pos.cs
│ ├── README.nuget.md
│ ├── Reply.cs
│ ├── ReplyIO.cs
│ ├── Sidedness.cs
│ └── StringAndCollectionExt.cs
├── LanguageExt.Rx/
│ ├── Atom.Extensions.cs
│ ├── Cast.cs
│ ├── Check.cs
│ ├── Eff.Extensions.cs
│ ├── Either.Extensions.cs
│ ├── EitherUnsafe.Extensions.cs
│ ├── LanguageExt.Rx.csproj
│ ├── Option.Extensions.cs
│ ├── PreludeRx.cs
│ ├── README.nuget.md
│ └── Validation.Extensions.cs
├── LanguageExt.Streaming/
│ ├── Buffer.cs
│ ├── Conduit/
│ │ ├── Conduit.Extensions.cs
│ │ ├── Conduit.Module.cs
│ │ ├── Conduit.TraitImpl.cs
│ │ ├── Conduit.cs
│ │ └── Internal/
│ │ └── Conduit.ABC.cs
│ ├── ConduitT/
│ │ ├── ConduitT.Extensions.cs
│ │ ├── ConduitT.Module.cs
│ │ ├── ConduitT.TraitImpl.cs
│ │ ├── ConduitT.cs
│ │ └── Internal/
│ │ └── ConduitT.ABC.cs
│ ├── Event/
│ │ ├── Event.Module.cs
│ │ └── Event.cs
│ ├── LanguageExt.Streaming.csproj
│ ├── Pipes/
│ │ ├── Consumer/
│ │ │ ├── Consumer.Extensions.cs
│ │ │ ├── Consumer.Module.cs
│ │ │ ├── Consumer.Monad.cs
│ │ │ ├── Consumer.Operators.cs
│ │ │ └── Consumer.cs
│ │ ├── ConsumerT/
│ │ │ ├── ConsumerT.Extensions.cs
│ │ │ ├── ConsumerT.Module.cs
│ │ │ ├── ConsumerT.Monad.cs
│ │ │ ├── ConsumerT.Operators.cs
│ │ │ └── ConsumerT.cs
│ │ ├── Effect/
│ │ │ ├── Effect.Extensions.cs
│ │ │ ├── Effect.Module.cs
│ │ │ ├── Effect.Monad.cs
│ │ │ ├── Effect.Operators.cs
│ │ │ └── Effect.cs
│ │ ├── EffectT/
│ │ │ ├── EffectT.Extensions.cs
│ │ │ ├── EffectT.Module.cs
│ │ │ ├── EffectT.Monad.cs
│ │ │ ├── EffectT.Operators.cs
│ │ │ └── EffectT.cs
│ │ ├── Pipe/
│ │ │ ├── Pipe.Extensions.cs
│ │ │ ├── Pipe.Module.cs
│ │ │ ├── Pipe.Monad.cs
│ │ │ ├── Pipe.Operators.cs
│ │ │ └── Pipe.cs
│ │ ├── PipeT/
│ │ │ ├── PipeT.Cached.cs
│ │ │ ├── PipeT.DSL.cs
│ │ │ ├── PipeT.Extensions.cs
│ │ │ ├── PipeT.Module.cs
│ │ │ ├── PipeT.Monad.cs
│ │ │ ├── PipeT.Operators.cs
│ │ │ └── PipeT.cs
│ │ ├── Producer/
│ │ │ ├── Producer.Extensions.cs
│ │ │ ├── Producer.Module.cs
│ │ │ ├── Producer.Monad.cs
│ │ │ ├── Producer.Operators.cs
│ │ │ └── Producer.cs
│ │ ├── ProducerT/
│ │ │ ├── ProducerT.Extensions.cs
│ │ │ ├── ProducerT.Module.cs
│ │ │ ├── ProducerT.Monad.cs
│ │ │ ├── ProducerT.Operators.cs
│ │ │ └── ProducerT.cs
│ │ └── README.md
│ ├── README.md
│ ├── README.nuget.md
│ ├── Sink/
│ │ ├── DSL/
│ │ │ ├── SinkChoose.cs
│ │ │ ├── SinkCombine.cs
│ │ │ ├── SinkContraMap.cs
│ │ │ ├── SinkContraMapT.cs
│ │ │ ├── SinkEmpty.cs
│ │ │ ├── SinkVoid.cs
│ │ │ └── SinkWriter.cs
│ │ ├── Sink.CoFunctor.cs
│ │ ├── Sink.Extensions.cs
│ │ ├── Sink.Module.cs
│ │ └── Sink.cs
│ ├── SinkT/
│ │ ├── DSL/
│ │ │ ├── SinkChoose.cs
│ │ │ ├── SinkCombine.cs
│ │ │ ├── SinkContraMap.cs
│ │ │ ├── SinkContraMapT.cs
│ │ │ ├── SinkEmpty.cs
│ │ │ ├── SinkVoid.cs
│ │ │ └── SinkWriter.cs
│ │ ├── SinkT.CoFunctor.cs
│ │ ├── SinkT.Extensions.cs
│ │ ├── SinkT.Module.cs
│ │ └── SinkT.cs
│ ├── Source/
│ │ ├── Extensions/
│ │ │ ├── Source.Extensions.cs
│ │ │ └── Source.Reducers.cs
│ │ ├── Operators/
│ │ │ ├── Source.Operators.Applicative.cs
│ │ │ ├── Source.Operators.Choice.cs
│ │ │ ├── Source.Operators.Combine.cs
│ │ │ ├── Source.Operators.Functor.cs
│ │ │ ├── Source.Operators.Monad.cs
│ │ │ ├── Source.Operators.Zip.cs
│ │ │ └── Source.Operators.cs
│ │ ├── Source.Module.cs
│ │ ├── Source.cs
│ │ └── Trait/
│ │ └── Source.TraitImpl.cs
│ ├── SourceT/
│ │ ├── DSL/
│ │ │ ├── ApplySourceT.cs
│ │ │ ├── BindSourceT.cs
│ │ │ ├── ChooseSourceT.cs
│ │ │ ├── CombineSourceT.cs
│ │ │ ├── DoneSourceT.cs
│ │ │ ├── EmptySourceT.cs
│ │ │ ├── FilterSourceT.cs
│ │ │ ├── FoldUntilSourceT.cs
│ │ │ ├── FoldWhileSourceT.cs
│ │ │ ├── FoldablePureSourceT.cs
│ │ │ ├── FoldableSourceT.cs
│ │ │ ├── ForeverSourceT.cs
│ │ │ ├── IteratorAsyncSourceT.cs
│ │ │ ├── IteratorSyncSourceT.cs
│ │ │ ├── LiftSourceT.cs
│ │ │ ├── MapIOSourceT.cs
│ │ │ ├── MapSourceT.cs
│ │ │ ├── MultiListenerPureSourceT.cs
│ │ │ ├── MultiListenerSourceT.cs
│ │ │ ├── ObservablePureSourceT.cs
│ │ │ ├── ObservableSourceT.cs
│ │ │ ├── PureSourceT.cs
│ │ │ ├── Reader2SourceT.cs
│ │ │ ├── Reader3SourceT.cs
│ │ │ ├── Reader4SourceT.cs
│ │ │ ├── SourcePureSourceT.cs
│ │ │ ├── SourceSourceT.cs
│ │ │ ├── TakeForSourceT.cs
│ │ │ ├── TakeSourceT.cs
│ │ │ ├── ToIOSourceT.cs
│ │ │ ├── TransformSourceT.cs
│ │ │ ├── Zip2SourceT.cs
│ │ │ ├── Zip3SourceT.cs
│ │ │ └── Zip4SourceT.cs
│ │ ├── Extensions/
│ │ │ ├── SourceT.Combinators.cs
│ │ │ ├── SourceT.Extensions.cs
│ │ │ └── SourceT.Reducers.cs
│ │ ├── Operators/
│ │ │ ├── SourceT.Operators.Applicative.cs
│ │ │ ├── SourceT.Operators.Choice.cs
│ │ │ ├── SourceT.Operators.Combine.cs
│ │ │ ├── SourceT.Operators.Functor.cs
│ │ │ ├── SourceT.Operators.Monad.cs
│ │ │ ├── SourceT.Operators.Zip.cs
│ │ │ └── SourceT.Operators.cs
│ │ ├── SourceT.Module.cs
│ │ ├── SourceT.cs
│ │ └── Trait/
│ │ └── SourceT.TraitImpl.cs
│ └── Transducers/
│ ├── Reduced.cs
│ ├── ReducedM.cs
│ ├── Reducer.cs
│ ├── ReducerIO.cs
│ ├── ReducerM.cs
│ ├── Transducer/
│ │ ├── DSL/
│ │ │ ├── BindTransducer.cs
│ │ │ ├── ComposeTransducer.cs
│ │ │ ├── ConstTransducer.cs
│ │ │ ├── FilterTransducer.cs
│ │ │ ├── FoldUntilTransducer.cs
│ │ │ ├── FoldWhileTransducer.cs
│ │ │ ├── IdentityTransducer.cs
│ │ │ ├── MapTransducer.cs
│ │ │ ├── SelectManyTransducer.cs
│ │ │ ├── SkipTransducer.cs
│ │ │ └── TakeTransducer.cs
│ │ ├── TransduceFrom.TraitImpl.cs
│ │ ├── TransduceTo.TraitImpl.cs
│ │ ├── Transducer.Extensions.cs
│ │ ├── Transducer.Module.cs
│ │ └── Transducer.cs
│ └── TransducerM/
│ ├── DSL/
│ │ ├── BindTransducer.cs
│ │ ├── ComposeTransducer.cs
│ │ ├── ConstTransducer.cs
│ │ ├── FilterTransducer.cs
│ │ ├── FoldUntilTransducer.cs
│ │ ├── FoldWhileTransducer.cs
│ │ ├── IdentityTransducer.cs
│ │ ├── MapTransducer.cs
│ │ ├── SelectManyTransducer.cs
│ │ ├── SkipTransducer.cs
│ │ └── TakeTransducer.cs
│ ├── TransduceFromM.TraitImpl.cs
│ ├── TransduceToM.TraitImpl.cs
│ ├── TransducerM.Extensions.cs
│ ├── TransducerM.Module.cs
│ └── TransducerM.cs
├── LanguageExt.Sys/
│ ├── ActivityEnv.cs
│ ├── EffOpt.cs
│ ├── LanguageExt.Sys.csproj
│ ├── Live/
│ │ ├── Implementations/
│ │ │ ├── ActivitySourceIO.cs
│ │ │ ├── ConsoleIO.cs
│ │ │ ├── DirectoryIO.cs
│ │ │ ├── EncodingIO.cs
│ │ │ ├── EnvironmentIO.cs
│ │ │ ├── FileIO.cs
│ │ │ ├── TextReadIO.cs
│ │ │ └── TimeIO.cs
│ │ └── Runtime.cs
│ ├── MemoryConsole.cs
│ ├── MemorySystemEnvironment.cs
│ ├── README.nuget.md
│ ├── Sys/
│ │ ├── Console.Eff.cs
│ │ ├── Console.cs
│ │ ├── Diag/
│ │ │ ├── Activity.Eff.cs
│ │ │ └── Activity.cs
│ │ ├── Encoding.Eff.cs
│ │ ├── Encoding.cs
│ │ ├── Environment.Eff.cs
│ │ ├── Environment.cs
│ │ ├── IO/
│ │ │ ├── Directory.Eff.cs
│ │ │ ├── Directory.cs
│ │ │ ├── File.Eff.cs
│ │ │ ├── File.cs
│ │ │ ├── Stream.cs
│ │ │ ├── TextRead.Eff.cs
│ │ │ └── TextRead.cs
│ │ ├── Time.Eff.cs
│ │ └── Time.cs
│ ├── Test/
│ │ ├── Implementations/
│ │ │ ├── ConsoleIO.cs
│ │ │ ├── DirectoryIO.cs
│ │ │ ├── EnvironmentIO.cs
│ │ │ ├── FileIO.cs
│ │ │ ├── TestTimeSpec.cs
│ │ │ ├── TextReadIO.cs
│ │ │ └── TimeIO.cs
│ │ └── Runtime.cs
│ └── Traits/
│ ├── ActivitySourceIO.cs
│ ├── ConsoleIO.cs
│ ├── DirectoryIO.cs
│ ├── EncodingIO.cs
│ ├── EnvironmentIO.cs
│ ├── FileIO.cs
│ ├── SysIO.cs
│ ├── TextReadIO.cs
│ └── TimeIO.cs
├── LanguageExt.Tests/
│ ├── AffTests.cs
│ ├── ArrayTests.cs
│ ├── AtomHashMapEqTests.cs
│ ├── AtomHashMapTests.cs
│ ├── AtomTests.cs
│ ├── ChoiceTests.cs
│ ├── CollectionOrderingTests.cs
│ ├── CollectionToStringTests.cs
│ ├── CombinatorsTests.cs
│ ├── CompositionTests.cs
│ ├── DefaultValueChecks/
│ │ ├── AbstractDefaultValueCheckTests.cs
│ │ ├── isDefaultPreludeTests.cs
│ │ └── notDefaultPreludeTests.cs
│ ├── DelayTests.cs
│ ├── DistinctTests.cs
│ ├── Divisible.cs
│ ├── EitherApply.cs
│ ├── EitherCoalesceTests.cs
│ ├── EitherTests.cs
│ ├── EnumerableTTests.cs
│ ├── EqualityTests.cs
│ ├── ErrorTests.cs
│ ├── FSharp/
│ │ └── FSharpTests.cs
│ ├── FunTests.cs
│ ├── GlobalSuppressions.cs
│ ├── GlobalUsings.cs
│ ├── HashMapTests.cs
│ ├── HashSetTests.cs
│ ├── IOTests/
│ │ ├── ApplyTests.cs
│ │ ├── FoldTests.cs
│ │ ├── GeneralTests.cs
│ │ ├── MapFailTests.cs
│ │ ├── RepeatTests.cs
│ │ ├── RetryTests.cs
│ │ └── TailRecursionTests.cs
│ ├── IssuesTests.cs
│ ├── IteratorTests/
│ │ └── IteratorTests.cs
│ ├── LanguageExt.Tests.csproj
│ ├── LensTests.cs
│ ├── LinqTests.cs
│ ├── ListMatchingTests.cs
│ ├── ListTests.cs
│ ├── MapTests.cs
│ ├── MemoImplTests.cs
│ ├── MemoryConsoleTests.cs
│ ├── MemoryFSTests.cs
│ ├── MonadTests.cs
│ ├── Multiplicable.cs
│ ├── NullChecks/
│ │ ├── AbstractNullCheckTests.cs
│ │ ├── IsNullExtensionTests.cs
│ │ ├── isnullPreludeTests.cs
│ │ └── notnullPreludeTests.cs
│ ├── OptionApply.cs
│ ├── OptionCoalesceTests.cs
│ ├── OptionLazy.cs
│ ├── OptionTTests.cs
│ ├── OptionTests.cs
│ ├── OptionUnsafeApply.cs
│ ├── ParsecIOTests.cs
│ ├── ParsecTests.cs
│ ├── Parsing/
│ │ ├── AbstractParseTPrecisionIntervalTests.cs
│ │ ├── AbstractParseTSignedPrecisionIntervalTests.cs
│ │ ├── AbstractParseTTests.cs
│ │ ├── AbstractParseTUnsignedPrecisionIntervalTests.cs
│ │ ├── parseBoolTests.cs
│ │ ├── parseByteTests.cs
│ │ ├── parseCharTests.cs
│ │ ├── parseDateTimeOffsetTests.cs
│ │ ├── parseDateTimeTests.cs
│ │ ├── parseDecimalTests.cs
│ │ ├── parseDoubleTests.cs
│ │ ├── parseEnumTests.cs
│ │ ├── parseFloatTests.cs
│ │ ├── parseGuidTests.cs
│ │ ├── parseIntTests.cs
│ │ ├── parseLongTests.cs
│ │ ├── parseSByteTests.cs
│ │ ├── parseShortTests.cs
│ │ ├── parseTimeSpanTests.cs
│ │ ├── parseUIntTests.cs
│ │ ├── parseULongTests.cs
│ │ └── parseUShortTests.cs
│ ├── PartialAndCurryingTests.cs
│ ├── PatchTests.cs
│ ├── PipesTests.cs
│ ├── PrismTests.cs
│ ├── QueryTests.cs
│ ├── QueueTests.cs
│ ├── RangeTests.cs
│ ├── Read-Me.cs
│ ├── RecordIgnoreBaseTests.cs
│ ├── RecordTests.cs
│ ├── RecordTypesTest.cs
│ ├── RefTest.cs
│ ├── ReflectTests.cs
│ ├── ScheduleTest/
│ │ ├── EffTests1.cs
│ │ ├── PositiveDurationTests.cs
│ │ └── ScheduleTests.cs
│ ├── SeqTypes/
│ │ ├── Seq.Arr.Tests.cs
│ │ ├── Seq.Cons.Tests.cs
│ │ ├── Seq.Enumerable.Tests.cs
│ │ ├── Seq.IList.Tests.cs
│ │ ├── Seq.Lazy.Tests.cs
│ │ ├── Seq.Lst.Tests.cs
│ │ ├── Seq.Module.Tests.cs
│ │ ├── SeqListTests.cs
│ │ └── SeqTests.cs
│ ├── SerialisationTests.cs
│ ├── SetTests.cs
│ ├── StackTests.cs
│ ├── Streaming/
│ │ ├── Source.Tests.cs
│ │ └── SourceT.Tests.cs
│ ├── Sys/
│ │ ├── Diag/
│ │ │ └── ActivityTests.cs
│ │ └── IO/
│ │ └── DirectoryTests.cs
│ ├── TESTING.cs
│ ├── TrackingHashMapTests.cs
│ ├── TraitTests/
│ │ ├── AlternativeLawTests.cs
│ │ ├── ApplicativeLawTests.cs
│ │ ├── ChoiceLawTests.cs
│ │ ├── FoldableDefaultsTests.cs
│ │ ├── FunctorLawTests.cs
│ │ └── MonadLawsTest.cs
│ ├── Transformer/
│ │ └── Traverse/
│ │ ├── Arr/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── Validation.cs
│ │ ├── Either/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── HashSet/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── IEnumerable/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ └── HashSet.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── Identity/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── Lst/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── Option/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── SeqT/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ ├── Validation.cs
│ │ │ └── ValidationWithMonoid.cs
│ │ ├── SetT/
│ │ │ ├── Collections/
│ │ │ │ └── Arr.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ └── Validation/
│ │ ├── Collections/
│ │ │ ├── Arr.cs
│ │ │ ├── HashSet.cs
│ │ │ ├── IEnumerable.cs
│ │ │ ├── Lst.cs
│ │ │ ├── Seq.cs
│ │ │ └── Set.cs
│ │ └── Sync/
│ │ ├── Either.cs
│ │ ├── Identity.cs
│ │ ├── Option.cs
│ │ └── ValidationSeq.cs
│ ├── TupleTests.cs
│ ├── UnionCustomJsonSerializerTests.cs
│ ├── UnionJsonSerializerTests.cs
│ ├── UnionTests.cs
│ ├── UnitsOfMeasureTests.cs
│ ├── ValidationTests.cs
│ ├── VectorClockTests.cs
│ ├── VersionHashMapTests.cs
│ └── WithTests.cs
├── LanguageExt.XUnitExt/
│ ├── EffExtensions.cs
│ ├── EitherExtensions.cs
│ ├── ErrorExtensions.cs
│ ├── FinExtensions.cs
│ ├── IOExtensions.cs
│ ├── LanguageExt.XUnitExt.csproj
│ ├── OptionExtensions.cs
│ ├── README.nuget.md
│ └── SourceExtensions.cs
├── Major Version Release Notes/
│ ├── Version 2/
│ │ ├── README.md
│ │ └── version-2-migration-notes.md
│ └── Version 5/
│ ├── Migration War Stories/
│ │ └── README.md
│ └── README.md
├── Performance.md
├── README.md
├── Samples/
│ ├── BlazorApp/
│ │ ├── BlazorApp.csproj
│ │ ├── Components/
│ │ │ ├── App.razor
│ │ │ ├── Layout/
│ │ │ │ ├── MainLayout.razor
│ │ │ │ ├── MainLayout.razor.css
│ │ │ │ ├── NavMenu.razor
│ │ │ │ └── NavMenu.razor.css
│ │ │ ├── Pages/
│ │ │ │ ├── Counter.razor
│ │ │ │ ├── Error.razor
│ │ │ │ ├── Home.razor
│ │ │ │ ├── Page.cs
│ │ │ │ └── Weather.razor
│ │ │ ├── Routes.razor
│ │ │ └── _Imports.razor
│ │ ├── Control/
│ │ │ └── Weather.cs
│ │ ├── Data/
│ │ │ └── WeatherForecast.cs
│ │ ├── Effects/
│ │ │ ├── AppRuntime.cs
│ │ │ ├── Impl/
│ │ │ │ └── RndImpl.cs
│ │ │ ├── Interfaces/
│ │ │ │ └── RndIO.cs
│ │ │ ├── Rnd.cs
│ │ │ ├── Runtime.cs
│ │ │ └── SafeErrorExtensions.cs
│ │ ├── Program.cs
│ │ ├── Properties/
│ │ │ └── launchSettings.json
│ │ ├── appsettings.Development.json
│ │ ├── appsettings.json
│ │ └── wwwroot/
│ │ └── app.css
│ ├── CardGame/
│ │ ├── Card.cs
│ │ ├── CardGame.csproj
│ │ ├── Console.cs
│ │ ├── Deck.cs
│ │ ├── Display.cs
│ │ ├── Game.Monad/
│ │ │ ├── Game.Extensions.cs
│ │ │ ├── Game.Module.cs
│ │ │ ├── Game.Monad.cs
│ │ │ └── Game.cs
│ │ ├── Game.cs
│ │ ├── GameState.cs
│ │ ├── Player.cs
│ │ ├── PlayerState.cs
│ │ ├── Players.cs
│ │ └── Program.cs
│ ├── CreditCardValidation/
│ │ ├── Control/
│ │ │ └── CreditCard.cs
│ │ ├── CreditCardValidation.csproj
│ │ ├── Data/
│ │ │ ├── Base12.cs
│ │ │ ├── CVV.cs
│ │ │ ├── CardNumber.cs
│ │ │ ├── CreditCardDetails.cs
│ │ │ ├── Expiry.cs
│ │ │ └── MonthSpan.cs
│ │ └── Program.cs
│ ├── DomainTypesExamples/
│ │ ├── Dimension.cs
│ │ ├── DomainTypesExamples.csproj
│ │ ├── Program.cs
│ │ ├── Time.cs
│ │ ├── TimeSpan.cs
│ │ └── Vector.cs
│ ├── EffectsExamples/
│ │ ├── EffectsExamples.csproj
│ │ ├── Examples/
│ │ │ ├── CancelExample.cs
│ │ │ ├── ErrorAndGuardExample.cs
│ │ │ ├── FoldTest.cs
│ │ │ ├── ForkCancelExample.cs
│ │ │ ├── QueueExample.cs
│ │ │ ├── RetryExample.cs
│ │ │ ├── TextFileChunkStreamExample.cs
│ │ │ ├── TextFileLineStreamExample.cs
│ │ │ ├── TimeExample.cs
│ │ │ └── TimeoutExample.cs
│ │ ├── Menu.cs
│ │ └── Program.cs
│ ├── IOExmples/
│ │ ├── IOExmples.csproj
│ │ └── Program.cs
│ ├── Newsletter/
│ │ ├── Newsletter/
│ │ │ ├── Command/
│ │ │ │ ├── Email.cs
│ │ │ │ ├── Members.cs
│ │ │ │ ├── Newsletter.cs
│ │ │ │ ├── Posts.cs
│ │ │ │ ├── Send.cs
│ │ │ │ └── Templates.cs
│ │ │ ├── Data/
│ │ │ │ ├── Letter.cs
│ │ │ │ ├── Members.cs
│ │ │ │ ├── Posts.cs
│ │ │ │ └── Templates.cs
│ │ │ ├── Effects/
│ │ │ │ ├── Config.cs
│ │ │ │ ├── Email.cs
│ │ │ │ ├── Image.cs
│ │ │ │ ├── Impl/
│ │ │ │ │ ├── Email.cs
│ │ │ │ │ ├── Image.cs
│ │ │ │ │ ├── Json.cs
│ │ │ │ │ └── Web.cs
│ │ │ │ ├── Json.cs
│ │ │ │ ├── Runtime.cs
│ │ │ │ ├── RuntimeEnv.cs
│ │ │ │ ├── Traits/
│ │ │ │ │ ├── EmailIO.cs
│ │ │ │ │ ├── ImageIO.cs
│ │ │ │ │ ├── JsonIO.cs
│ │ │ │ │ └── WebIO.cs
│ │ │ │ └── Web.cs
│ │ │ ├── GlobalUsings.cs
│ │ │ ├── JsonExtensions.cs
│ │ │ ├── Newsletter.csproj
│ │ │ ├── Newsletter.sln
│ │ │ ├── Program.cs
│ │ │ └── UI/
│ │ │ └── Display.cs
│ │ ├── README.md
│ │ ├── members-test/
│ │ │ └── members.2024-07-29.csv
│ │ └── templates/
│ │ ├── email.html
│ │ ├── email.txt
│ │ ├── recent-item.html
│ │ └── recent-item.txt
│ ├── PipesExamples/
│ │ ├── PipesExamples.csproj
│ │ └── Program.cs
│ ├── Streams/
│ │ ├── Console.cs
│ │ ├── CountForever.cs
│ │ ├── CountForeverAsync.cs
│ │ ├── Folding.cs
│ │ ├── Grouping.cs
│ │ ├── HeadsAndTails.cs
│ │ ├── Menu.cs
│ │ ├── Merging.cs
│ │ ├── OptionalItems.cs
│ │ ├── Program.cs
│ │ ├── RecursionIO.cs
│ │ ├── SourceStream.cs
│ │ ├── Streams.csproj
│ │ ├── SumOfSquares.cs
│ │ └── Zipping.cs
│ ├── TestBed/
│ │ ├── ApplicativeTest.cs
│ │ ├── AtomHashMapTests.cs
│ │ ├── AwaitAnyTest.cs
│ │ ├── BracketTest.cs
│ │ ├── FreeTests.cs
│ │ ├── Issues/
│ │ │ ├── Discussion1527.cs
│ │ │ ├── Issue1497.cs
│ │ │ └── IssueTests.cs
│ │ ├── PipesTest.cs
│ │ ├── Program.cs
│ │ ├── RWSTTests.cs
│ │ ├── RecurTests.cs
│ │ ├── ResourcesDiscussion1366.cs
│ │ ├── RobotExample.cs
│ │ ├── ScheduleTests.cs
│ │ ├── SeqConstructTests.cs
│ │ ├── SequenceParallelTest.cs
│ │ ├── SourceTTests.cs
│ │ ├── StateAsync.cs
│ │ ├── StateEff.cs
│ │ ├── TestBed.csproj
│ │ ├── TestCodeGen.cs
│ │ └── UseTest.cs
│ ├── TestBed.WPF/
│ │ ├── App.xaml
│ │ ├── App.xaml.cs
│ │ ├── AssemblyInfo.cs
│ │ ├── AtomIO.cs
│ │ ├── MainWindow.xaml
│ │ ├── MainWindow.xaml.cs
│ │ ├── TestBed.WPF.csproj
│ │ ├── WindowIO.cs
│ │ └── WindowRT.cs
│ ├── TestBed.Web/
│ │ ├── Program.cs
│ │ └── TestBed.Web.csproj
│ └── TestBed.Web.Runner/
│ ├── Program.cs
│ └── TestBed.Web.Runner.csproj
├── clean.sh
├── docs.sh
├── inc.bat
├── language-ext.sln
├── language-ext.sln.DotSettings
├── pack.bat
├── pack.sh
└── pjv/
└── LanguageExt.Core.3.1.9-beta.nuspec
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
root = true
[*.cs]
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_indent_block_contents
csharp_indent_block_contents = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_indent_braces
csharp_indent_braces = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_indent_case_contents
csharp_indent_case_contents = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_indent_switch_labels
csharp_indent_switch_labels = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_new_line_before_catch
csharp_new_line_before_catch = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_new_line_before_else
csharp_new_line_before_else = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_new_line_before_finally
csharp_new_line_before_finally = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_new_line_before_members_in_anonymous_types
csharp_new_line_before_members_in_anonymous_types = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_new_line_before_members_in_object_initializers
csharp_new_line_before_members_in_object_initializers = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_new_line_before_open_brace
csharp_new_line_before_open_brace = all
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_after_cast
csharp_space_after_cast = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_after_colon_in_inheritance_clause
csharp_space_after_colon_in_inheritance_clause = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_after_comma
csharp_space_after_comma = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_after_dot
csharp_space_after_dot = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_after_keywords_in_control_flow_statements
csharp_space_after_keywords_in_control_flow_statements = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_after_semicolon_in_for_statement
csharp_space_after_semicolon_in_for_statement = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_around_binary_operators
csharp_space_around_binary_operators = before_and_after
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_before_colon_in_inheritance_clause
csharp_space_before_colon_in_inheritance_clause = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_before_comma
csharp_space_before_comma = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_before_dot
csharp_space_before_dot = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_before_open_square_brackets
csharp_space_before_open_square_brackets = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_before_semicolon_in_for_statement
csharp_space_before_semicolon_in_for_statement = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_between_empty_square_brackets
csharp_space_between_empty_square_brackets = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_between_method_call_empty_parameter_list_parentheses
csharp_space_between_method_call_empty_parameter_list_parentheses = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_between_method_call_name_and_opening_parenthesis
csharp_space_between_method_call_name_and_opening_parenthesis = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_between_method_call_parameter_list_parentheses
csharp_space_between_method_call_parameter_list_parentheses = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_between_method_declaration_empty_parameter_list_parentheses
csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_between_method_declaration_name_and_open_parenthesis
csharp_space_between_method_declaration_name_and_open_parenthesis = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_between_method_declaration_parameter_list_parentheses
csharp_space_between_method_declaration_parameter_list_parentheses = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_between_parentheses
csharp_space_between_parentheses = none
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_space_between_square_brackets
csharp_space_between_square_brackets = false
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_expression_bodied_accessors
csharp_style_expression_bodied_accessors = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_expression_bodied_constructors
csharp_style_expression_bodied_constructors = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_expression_bodied_indexers
csharp_style_expression_bodied_indexers = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_expression_bodied_methods
csharp_style_expression_bodied_methods = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_expression_bodied_operators
csharp_style_expression_bodied_operators = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_expression_bodied_properties
csharp_style_expression_bodied_properties = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_inlined_variable_declaration
csharp_style_inlined_variable_declaration = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_pattern_matching_over_as_with_null_check
csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_pattern_matching_over_is_with_cast_check
csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_throw_expression
csharp_style_throw_expression = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_var_elsewhere
csharp_style_var_elsewhere = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_var_for_built_in_types
csharp_style_var_for_built_in_types = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_style_var_when_type_is_apparent
csharp_style_var_when_type_is_apparent = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_sort_system_directives_first
dotnet_sort_system_directives_first = true
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_style_coalesce_expression
dotnet_style_coalesce_expression = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_style_collection_initializer
dotnet_style_collection_initializer = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_style_explicit_tuple_names
dotnet_style_explicit_tuple_names = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_style_null_propagation
dotnet_style_null_propagation = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_style_object_initializer
dotnet_style_object_initializer = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_style_predefined_type_for_locals_parameters_members
dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_style_predefined_type_for_member_access
dotnet_style_predefined_type_for_member_access = true:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_style_qualification_for_event
dotnet_style_qualification_for_event = false:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_style_qualification_for_field
dotnet_style_qualification_for_field = false:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_style_qualification_for_method
dotnet_style_qualification_for_method = false:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#dotnet_style_qualification_for_property
dotnet_style_qualification_for_property = false:suggestion
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#end_of_line
end_of_line = lf
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#indent_size
indent_size = 4
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#indent_style
indent_style = space
# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#insert_final_newline
insert_final_newline = true
================================================
FILE: .gitattributes
================================================
###############################################################################
# Set default behavior to automatically normalize line endings.
###############################################################################
* text=auto
###############################################################################
# Set default behavior for command prompt diff.
#
# This is need for earlier builds of msysgit that does not have it on by
# default for csharp files.
# Note: This is only used by command line
###############################################################################
#*.cs diff=csharp
###############################################################################
# Set the merge driver for project and solution files
#
# Merging from the command prompt will add diff markers to the files if there
# are conflicts (Merging from VS is not affected by the settings below, in VS
# the diff markers are never inserted). Diff markers may cause the following
# file extensions to fail to load in VS. An alternative would be to treat
# these files as binary and thus will always conflict and require user
# intervention with every merge. To do so, just uncomment the entries below
###############################################################################
#*.sln merge=binary
#*.csproj merge=binary
#*.vbproj merge=binary
#*.vcxproj merge=binary
#*.vcproj merge=binary
#*.dbproj merge=binary
#*.fsproj merge=binary
#*.lsproj merge=binary
#*.wixproj merge=binary
#*.modelproj merge=binary
#*.sqlproj merge=binary
#*.wwaproj merge=binary
###############################################################################
# behavior for image files
#
# image files are treated as binary by default.
###############################################################################
#*.jpg binary
#*.png binary
#*.gif binary
###############################################################################
# diff behavior for common document formats
#
# Convert binary document formats to text before diffing them. This feature
# is only available from the command line. Turn it on by uncommenting the
# entries below.
###############################################################################
#*.doc diff=astextplain
#*.DOC diff=astextplain
#*.docx diff=astextplain
#*.DOCX diff=astextplain
#*.dot diff=astextplain
#*.DOT diff=astextplain
#*.pdf diff=astextplain
#*.PDF diff=astextplain
#*.rtf diff=astextplain
#*.RTF diff=astextplain
================================================
FILE: .github/FUNDING.yml
================================================
# These are supported funding model platforms.
github: [louthy]
patreon: louthy
ko_fi: louthy
================================================
FILE: .gitignore
================================================
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
# User-specific files
*.suo
*.user
*.sln.docstates
**.idea
*.iml
# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
x64/
build/
bld/
[Bb]in/
[Oo]bj/
lib/
.vs/
# Roslyn cache directories
*.ide/
# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*
#NUNIT
*.VisualState.xml
TestResult.xml
# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c
*_i.c
*_p.c
*_i.h
*.ilk
*.meta
*.obj
*.pch
*.pdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc
*.lock.json
# Chutzpah Test files
_Chutzpah*
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opensdf
*.sdf
*.cachefile
# Visual Studio profiler
*.psess
*.vsp
*.vspx
# TFS 2012 Local Workspace
$tf/
# Guidance Automation Toolkit
*.gpState
# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user
# JustCode is a .NET coding addin-in
.JustCode
# TeamCity is a build add-in
_TeamCity*
# DotCover is a Code Coverage Tool
*.dotCover
# NCrunch
_NCrunch_*
.*crunch*.local.xml
# MightyMoose
*.mm.*
AutoTest.Net/
# Web workbench (sass)
.sass-cache/
# Installshield output folder
[Ee]xpress/
# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html
# Click-Once directory
publish/
# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
## TODO: Comment the next line if you want to checkin your
## web deploy settings but do note that will include unencrypted
## passwords
#*.pubxml
# NuGet Packages Directory
packages/*
## TODO: If the tool you use requires repositories.config
## uncomment the next line
#!packages/repositories.config
# Enable "build/" folder in the NuGet Packages folder since
# NuGet packages use it for MSBuild targets.
# This line needs to be after the ignore of the build folder
# (and the packages folder if the line above has been uncommented)
!packages/build/
# Windows Azure Build Output
csx/
*.build.csdef
# Windows Store app package directory
AppPackages/
# Others
sql/
*.Cache
ClientBin/
[Ss]tyle[Cc]op.*
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.pfx
*.publishsettings
node_modules/
bower_components/
# RIA/Silverlight projects
Generated_Code/
# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
# SQL Server files
*.mdf
*.ldf
# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings
# Microsoft Fakes
FakesAssemblies/
# LightSwitch generated files
GeneratedArtifacts/
_Pvt_Extensions/
ModelManifest.xml
/SettingsParser.playlist
/Parsec Tests.playlist
/LanguageExt.Tests/LanguageExt.Tests.nuget.props
/.idea/.idea.language-ext
# Benchmark artifacts
BenchmarkDotNet.Artifacts/
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at p.louth@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
[homepage]: http://contributor-covenant.org
[version]: http://contributor-covenant.org/version/1/4/
================================================
FILE: CONTRIBUTING.md
================================================
## How to contribute to language-ext
#### **Did you find a bug?**
* **Ensure the bug was not already reported** by searching on GitHub under [Issues](https://github.com/louthy/language-ext/issues).
* If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/louthy/language-ext/issues/new). Be sure to include a **title and clear description**, as much relevant information as possible, and a **code sample** or an **executable test case** demonstrating the expected behavior that is not occurring.
#### **Did you write a patch that fixes a bug?**
* Open a new GitHub pull request with the patch.
* Ensure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable.
#### **Do you intend to add a new feature or change an existing one?**
* First suggest your change in the [language-ext issues page](https://github.com/louthy/language-ext/issues).
* There are no fixed rules on what should and shouldn't be in this library, but some features are more valuable than others, and some require long-term maintenance that outweighs the value of the feature. So please get sign-off from the project leader (Paul Louth) before putting in an excessive amount of work.
#### **Do you have questions about the source code?**
* Ask any question about how to use language-ext in the [language-ext issues page](https://github.com/louthy/language-ext/issues).
#### **Do you want to contribute to the language-ext documentation?**
This is very welcome:
* The APi documentation is generated from the source code - please make sure you use back-tick markdown code-blocks within `<summary>...</summary>` and other XmlDoc sections for variable, method, or type-names and code-examples. If unclear, ask on the [language-ext issues page](https://github.com/louthy/language-ext/issues)
* The [language-ext wiki](https://github.com/louthy/language-ext/wiki) is always crying out for general usage examples. If you want to talk about a larger subject that is enabled by language-ext (like parsing for example), then clear it first on the [language-ext issues page](https://github.com/louthy/language-ext/issues).
Thanks! :heart: :heart: :heart:
Paul Louth
================================================
FILE: LICENSE.md
================================================
The MIT License (MIT)
Copyright (c) 2014-2025 Paul Louth
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: LanguageExt.Benchmarks/HashMapAddBenchmarks.cs
================================================
using System.Collections.Generic;
using System.Collections.Immutable;
using BenchmarkDotNet.Attributes;
using LanguageExt.ClassInstances;
using LanguageExt.Traits;
using Sasa.Collections;
using static LanguageExt.Prelude;
namespace LanguageExt.Benchmarks
{
[RPlotExporter, RankColumn]
[GenericTypeArguments(typeof(int), typeof(OrdInt))]
[GenericTypeArguments(typeof(string), typeof(OrdString))]
public class HashMapAddBenchmarks<T, TOrd>
where TOrd : Ord<T>
{
[Params(100, 1000, 10000, 100000)]
public int N;
Dictionary<T, T> values;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateDictionary<T, T>(N);
}
[Benchmark]
public ImmutableDictionary<T, T> SysColImmutableDictionary()
{
var map = ImmutableDictionary.Create<T, T>();
foreach (var kvp in values)
{
map = map.Add(kvp.Key, kvp.Value);
}
return map;
}
[Benchmark]
public ImmutableSortedDictionary<T, T> SysColImmutableSortedDictionary()
{
var map = ImmutableSortedDictionary.Create<T, T>();
foreach (var kvp in values)
{
map = map.Add(kvp.Key, kvp.Value);
}
return map;
}
[Benchmark]
public Trie<T, T> SasaTrie()
{
var map = Trie<T, T>.Empty;
foreach (var kvp in values)
{
map = map.Add(kvp.Key, kvp.Value);
}
return map;
}
[Benchmark]
public Dictionary<T, T> SysColDictionary()
{
var map = new Dictionary<T, T>();
foreach (var kvp in values)
{
map.Add(kvp.Key, kvp.Value);
}
return map;
}
[Benchmark]
public HashMap<TOrd, T, T> LangExtHashMap()
{
var map = HashMap<TOrd, T, T>();
foreach (var kvp in values)
{
map = map.Add(kvp.Key, kvp.Value);
}
return map;
}
[Benchmark]
public Map<TOrd, T, T> LangExtMap()
{
var map = Map<TOrd, T, T>();
foreach (var kvp in values)
{
map = map.Add(kvp.Key, kvp.Value);
}
return map;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/HashMapContainsKeyBenchmarks.cs
================================================
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using BenchmarkDotNet.Attributes;
using LanguageExt.ClassInstances;
using LanguageExt.Traits;
using Sasa.Collections;
namespace LanguageExt.Benchmarks
{
[RPlotExporter, RankColumn]
[GenericTypeArguments(typeof(int), typeof(OrdInt))]
[GenericTypeArguments(typeof(string), typeof(OrdString))]
public class HashMapContainsKeyBenchmarks<T, TOrd>
where TOrd : Ord<T>
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] keys;
ImmutableDictionary<T, T> immutableMap;
ImmutableSortedDictionary<T, T> immutableSortedMap;
Dictionary<T, T> dictionary;
HashMap<TOrd, T, T> hashMap;
Map<TOrd, T, T> map;
Trie<T, T> sasaTrie;
[GlobalSetup]
public void Setup()
{
var values = ValuesGenerator.Default.GenerateDictionary<T, T>(N);
keys = values.Keys.ToArray();
sasaTrie = ValuesGenerator.SasaTrieSetup(values);
immutableMap = ValuesGenerator.SysColImmutableDictionarySetup(values);
immutableSortedMap = ValuesGenerator.SysColImmutableSortedDictionarySetup(values);
dictionary = ValuesGenerator.SysColDictionarySetup(values);
hashMap = ValuesGenerator.LangExtHashMapSetup<T, TOrd>(values);
map = ValuesGenerator.LangExtMapSetup<T, TOrd>(values);
}
[Benchmark]
public bool SysColImmutableDictionary()
{
var result = true;
foreach (var key in keys)
{
result &= immutableMap.ContainsKey(key);
}
return result;
}
[Benchmark]
public bool SasaTrie()
{
var result = true;
foreach (var key in keys)
{
result &= sasaTrie.ContainsKey(key);
}
return result;
}
[Benchmark]
public bool SysColImmutableSortedDictionary()
{
var result = true;
foreach (var key in keys)
{
result &= immutableSortedMap.ContainsKey(key);
}
return result;
}
[Benchmark]
public bool SysColDictionary()
{
var result = true;
foreach (var key in keys)
{
result &= dictionary.ContainsKey(key);
}
return result;
}
[Benchmark]
public bool LangExtHashMap()
{
var result = true;
foreach (var key in keys)
{
result &= hashMap.ContainsKey(key);
}
return result;
}
[Benchmark]
public bool LangExtMap()
{
var result = true;
foreach (var key in keys)
{
result &= map.ContainsKey(key);
}
return result;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/HashMapIterateBenchmarks.cs
================================================
using System.Collections.Generic;
using System.Collections.Immutable;
using BenchmarkDotNet.Attributes;
using LanguageExt.ClassInstances;
using LanguageExt.Traits;
using Sasa.Collections;
namespace LanguageExt.Benchmarks
{
[RPlotExporter, RankColumn]
[GenericTypeArguments(typeof(int), typeof(OrdInt))]
[GenericTypeArguments(typeof(string), typeof(OrdString))]
public class HashMapIterateBenchmarks<T, TOrd>
where TOrd : Ord<T>
{
[Params(100, 1000, 10000, 100000)]
public int N;
ImmutableDictionary<T, T> immutableMap;
ImmutableSortedDictionary<T, T> immutableSortedMap;
Dictionary<T, T> dictionary;
HashMap<TOrd, T, T> hashMap;
Map<TOrd, T, T> map;
Trie<T, T> sasaTrie;
[GlobalSetup]
public void Setup()
{
var values = ValuesGenerator.Default.GenerateDictionary<T, T>(N);
sasaTrie = ValuesGenerator.SasaTrieSetup(values);
immutableMap = ValuesGenerator.SysColImmutableDictionarySetup(values);
immutableSortedMap = ValuesGenerator.SysColImmutableSortedDictionarySetup(values);
dictionary = ValuesGenerator.SysColDictionarySetup(values);
hashMap = ValuesGenerator.LangExtHashMapSetup<T, TOrd>(values);
map = ValuesGenerator.LangExtMapSetup<T, TOrd>(values);
}
[Benchmark]
public T SysColImmutableDictionary()
{
T result = default;
var collection = immutableMap;
foreach (var item in collection)
{
result = item.Value;
}
return result;
}
[Benchmark]
public T SysColImmutableSortedDictionary()
{
T result = default;
var collection = immutableSortedMap;
foreach (var item in collection)
{
result = item.Value;
}
return result;
}
[Benchmark]
public T SasaTrie()
{
T result = default;
var collection = sasaTrie;
foreach (var item in collection)
{
result = item.Value;
}
return result;
}
[Benchmark]
public T SysColDictionary()
{
T result = default;
var collection = dictionary;
foreach (var item in collection)
{
result = item.Value;
}
return result;
}
[Benchmark]
public T LangExtHashMap()
{
T result = default;
var collection = hashMap;
foreach (var item in collection)
{
result = item.Value;
}
return result;
}
[Benchmark]
public T LangExtMap()
{
T result = default;
var collection = map;
foreach (var item in collection)
{
result = item.Value;
}
return result;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/HashMapRandomRemovalBenchmarks.cs
================================================
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using BenchmarkDotNet.Attributes;
using LanguageExt.ClassInstances;
using LanguageExt.Traits;
using Sasa.Collections;
namespace LanguageExt.Benchmarks
{
[RPlotExporter, RankColumn]
[GenericTypeArguments(typeof(int), typeof(OrdInt))]
[GenericTypeArguments(typeof(string), typeof(OrdString))]
public class HashMapRandomRemovalBenchmarks<T, TOrd>
where TOrd : Ord<T>
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] keys;
ImmutableDictionary<T, T> immutableMap;
ImmutableSortedDictionary<T, T> immutableSortedMap;
Dictionary<T, T> dictionary;
HashMap<TOrd, T, T> hashMap;
Map<TOrd, T, T> map;
Trie<T, T> sasaTrie;
[GlobalSetup]
public void Setup()
{
var values = ValuesGenerator.Default.GenerateDictionary<T, T>(N);
keys = values.Keys.ToArray();
sasaTrie = ValuesGenerator.SasaTrieSetup(values);
immutableMap = ValuesGenerator.SysColImmutableDictionarySetup(values);
immutableSortedMap = ValuesGenerator.SysColImmutableSortedDictionarySetup(values);
dictionary = ValuesGenerator.SysColDictionarySetup(values);
hashMap = ValuesGenerator.LangExtHashMapSetup<T, TOrd>(values);
map = ValuesGenerator.LangExtMapSetup<T, TOrd>(values);
}
[Benchmark]
public bool SysColImmutableDictionary()
{
var localImmutableMap = immutableMap;
foreach (var key in keys)
{
localImmutableMap = localImmutableMap.Remove(key);
}
return localImmutableMap.IsEmpty;
}
[Benchmark]
public bool SysColImmutableSortedDictionary()
{
var localSortedMap = immutableSortedMap;
foreach (var key in keys)
{
localSortedMap = localSortedMap.Remove(key);
}
return localSortedMap.IsEmpty;
}
[Benchmark]
public bool SasaTrie()
{
var localImmutableMap = sasaTrie;
foreach (var key in keys)
{
localImmutableMap = localImmutableMap.Remove(key);
}
return localImmutableMap.IsEmpty();
}
[Benchmark]
public bool SysColDictionary()
{
// NB! no local variable - mutating field instance
foreach (var key in keys)
{
dictionary.Remove(key);
}
return dictionary.Count == 0;
}
[Benchmark]
public bool LangExtHashMap()
{
var localHashMap = hashMap;
foreach (var key in keys)
{
localHashMap = localHashMap.Remove(key);
}
return localHashMap.IsEmpty;
}
[Benchmark]
public bool LangExtMap()
{
var localMap = map;
foreach (var key in keys)
{
localMap = localMap.Remove(key);
}
return localMap.IsEmpty;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/HashSetAddBenchmarks.cs
================================================
using System.Collections.Immutable;
using BenchmarkDotNet.Attributes;
using LanguageExt.ClassInstances;
using LanguageExt.Traits;
using static LanguageExt.Prelude;
namespace LanguageExt.Benchmarks
{
[RPlotExporter, RankColumn]
[GenericTypeArguments(typeof(int), typeof(OrdInt))]
[GenericTypeArguments(typeof(string), typeof(OrdString))]
public class HashSetAddBenchmarks<T, TOrd>
where TOrd : Ord<T>
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues<T>(N);
}
[Benchmark]
public ImmutableHashSet<T> SysColImmutableHashSet()
{
var set = ImmutableHashSet.Create<T>();
foreach (var value in values)
{
set = set.Add(value);
}
return set;
}
[Benchmark]
public ImmutableSortedSet<T> SysColImmutableSortedSet()
{
var set = ImmutableSortedSet.Create<T>();
foreach (var value in values)
{
set = set.Add(value);
}
return set;
}
[Benchmark]
public System.Collections.Generic.HashSet<T> SysColHashSet()
{
var set = new System.Collections.Generic.HashSet<T>();
foreach (var value in values)
{
set.Add(value);
}
return set;
}
[Benchmark]
public HashSet<TOrd, T> LangExtHashSet()
{
var set = HashSet<TOrd, T>();
foreach (var value in values)
{
set = set.Add(value);
}
return set;
}
[Benchmark]
public Set<TOrd, T> LangExtSet()
{
var set = Set<TOrd, T>();
foreach (var value in values)
{
set = set.Add(value);
}
return set;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/HashSetContainsBenchmarks.cs
================================================
using System.Collections.Immutable;
using BenchmarkDotNet.Attributes;
using LanguageExt.ClassInstances;
using LanguageExt.Traits;
namespace LanguageExt.Benchmarks
{
[RPlotExporter, RankColumn]
[GenericTypeArguments(typeof(int), typeof(OrdInt))]
[GenericTypeArguments(typeof(string), typeof(OrdString))]
public class HashSetContainsBenchmarks<T, TOrd>
where TOrd : Ord<T>
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
ImmutableHashSet<T> immutableHashSet;
ImmutableSortedSet<T> immutableSortedSet;
System.Collections.Generic.HashSet<T> sysHashSet;
HashSet<TOrd, T> hashSet;
Set<TOrd, T> set;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues<T>(N);
immutableHashSet = ValuesGenerator.SysColImmutableHashSetSetup(values);
immutableSortedSet = ValuesGenerator.SysColImmutableSortedSetSetup(values);
sysHashSet = ValuesGenerator.SysColHashSetSetup(values);
hashSet = ValuesGenerator.LangExtHashSetSetup<T, TOrd>(values);
set = ValuesGenerator.LangExtSetSetup<T, TOrd>(values);
}
[Benchmark]
public bool SysColImmutableHashSet()
{
var result = true;
foreach (var value in values)
{
result &= immutableHashSet.Contains(value);
}
return result;
}
[Benchmark]
public bool SysColImmutableSortedSet()
{
var result = true;
foreach (var value in values)
{
result &= immutableSortedSet.Contains(value);
}
return result;
}
[Benchmark]
public bool SysColHashSet()
{
var result = true;
foreach (var value in values)
{
result &= sysHashSet.Contains(value);
}
return result;
}
[Benchmark]
public bool LangExtHashSet()
{
var result = true;
foreach (var value in values)
{
result &= hashSet.Contains(value);
}
return result;
}
[Benchmark]
public bool LangExtSet()
{
var result = true;
foreach (var value in values)
{
result &= set.Contains(value);
}
return result;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/HashSetIterationBenchmarks.cs
================================================
using System.Collections.Immutable;
using BenchmarkDotNet.Attributes;
using LanguageExt.ClassInstances;
using LanguageExt.Traits;
namespace LanguageExt.Benchmarks
{
[RPlotExporter, RankColumn]
[GenericTypeArguments(typeof(int), typeof(OrdInt))]
[GenericTypeArguments(typeof(string), typeof(OrdString))]
public class HashSetIterationBenchmarks<T, TOrd>
where TOrd : Ord<T>
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
ImmutableHashSet<T> immutableHashSet;
ImmutableSortedSet<T> immutableSortedSet;
System.Collections.Generic.HashSet<T> sysHashSet;
HashSet<TOrd, T> hashSet;
Set<TOrd, T> set;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues<T>(N);
immutableHashSet = ValuesGenerator.SysColImmutableHashSetSetup(values);
immutableSortedSet = ValuesGenerator.SysColImmutableSortedSetSetup(values);
sysHashSet = ValuesGenerator.SysColHashSetSetup(values);
hashSet = ValuesGenerator.LangExtHashSetSetup<T, TOrd>(values);
set = ValuesGenerator.LangExtSetSetup<T, TOrd>(values);
}
[Benchmark]
public T SysColImmutableHashSet()
{
T result = default;
var collection = immutableHashSet;
foreach (var item in collection)
{
result = item;
}
return result;
}
[Benchmark]
public T SysColImmutableSortedSet()
{
T result = default;
var collection = immutableSortedSet;
foreach (var item in collection)
{
result = item;
}
return result;
}
[Benchmark]
public T SysColHashSet()
{
T result = default;
var collection = sysHashSet;
foreach (var item in collection)
{
result = item;
}
return result;
}
[Benchmark]
public T LangExtHashSet()
{
T result = default;
var collection = hashSet;
foreach (var item in collection)
{
result = item;
}
return result;
}
[Benchmark]
public T LangExtSet()
{
T result = default;
var collection = set;
foreach (var item in collection)
{
result = item;
}
return result;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/HashSetRandomRemovalBenchmarks.cs
================================================
using System.Collections.Immutable;
using BenchmarkDotNet.Attributes;
using LanguageExt.ClassInstances;
using LanguageExt.Traits;
namespace LanguageExt.Benchmarks
{
[RPlotExporter, RankColumn]
[GenericTypeArguments(typeof(int), typeof(OrdInt))]
[GenericTypeArguments(typeof(string), typeof(OrdString))]
public class HashSetRandomRemovalBenchmarks<T, TOrd>
where TOrd : Ord<T>
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
ImmutableHashSet<T> immutableSet;
ImmutableSortedSet<T> immutableSortedSet;
System.Collections.Generic.HashSet<T> sysHashSet;
HashSet<TOrd, T> hashSet;
Set<TOrd, T> set;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues<T>(N);
immutableSet = ValuesGenerator.SysColImmutableHashSetSetup(values);
immutableSortedSet = ValuesGenerator.SysColImmutableSortedSetSetup(values);
sysHashSet = ValuesGenerator.SysColHashSetSetup(values);
hashSet = ValuesGenerator.LangExtHashSetSetup<T, TOrd>(values);
set = ValuesGenerator.LangExtSetSetup<T, TOrd>(values);
}
[Benchmark]
public bool SysColImmutableHashSet()
{
var localImmutableSet = immutableSet;
foreach (var value in values)
{
localImmutableSet = localImmutableSet.Remove(value);
}
return localImmutableSet.IsEmpty;
}
[Benchmark]
public bool SysColImmutableSortedSet()
{
var localImmutableSortedSet = immutableSortedSet;
foreach (var value in values)
{
localImmutableSortedSet = localImmutableSortedSet.Remove(value);
}
return localImmutableSortedSet.IsEmpty;
}
[Benchmark]
public bool SysColHashSet()
{
// NB! no local variable - mutating field instance
foreach (var value in values)
{
sysHashSet.Remove(value);
}
return sysHashSet.Count == 0;
}
[Benchmark]
public bool LangExtHashSet()
{
var localHashSet = hashSet;
foreach (var value in values)
{
localHashSet = localHashSet.Remove(value);
}
return localHashSet.IsEmpty;
}
[Benchmark]
public bool LangExtSet()
{
var localSet = set;
foreach (var value in values)
{
localSet = localSet.Remove(value);
}
return localSet.IsEmpty;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/LanguageExt.Benchmarks.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net10.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="BenchmarkDotNet" Version="0.13.5" />
<PackageReference Include="Sasa.Collections" Version="1.0.0-RC4" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\LanguageExt.Core\LanguageExt.Core.csproj" />
</ItemGroup>
</Project>
================================================
FILE: LanguageExt.Benchmarks/ListAddBenchmarks.cs
================================================
using System.Collections.Generic;
using System.Collections.Immutable;
using BenchmarkDotNet.Attributes;
using LanguageExt.ClassInstances;
using LanguageExt.Traits;
using static LanguageExt.Prelude;
namespace LanguageExt.Benchmarks
{
[RPlotExporter, RankColumn]
[GenericTypeArguments(typeof(int), typeof(OrdInt))]
[GenericTypeArguments(typeof(string), typeof(OrdString))]
public class ListAddBenchmarks<T, TOrd>
where TOrd : Ord<T>
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues<T>(N);
}
[Benchmark]
public ImmutableList<T> SysColImmutableList()
{
var collection = ImmutableList.Create<T>();
foreach (var value in values)
{
collection = collection.Add(value);
}
return collection;
}
[Benchmark]
public Lst<T> LangExtLst()
{
var collection = List<T>();
foreach (var value in values)
{
collection = collection.Add(value);
}
return collection;
}
[Benchmark]
public Seq<T> LangExtSeq()
{
var collection = Seq<T>();
foreach (var value in values)
{
collection = collection.Add(value);
}
return collection;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/ListIterationBenchmarks.cs
================================================
using System.Collections.Immutable;
using BenchmarkDotNet.Attributes;
using LanguageExt.ClassInstances;
using LanguageExt.Traits;
using static LanguageExt.Prelude;
namespace LanguageExt.Benchmarks
{
[RPlotExporter, RankColumn]
[GenericTypeArguments(typeof(int), typeof(OrdInt))]
[GenericTypeArguments(typeof(string), typeof(OrdString))]
public class ListIterationBenchmarks<T, TOrd>
where TOrd : Ord<T>
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
ImmutableList<T> immutableList;
Lst<T> lst;
Seq<T> seq;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues<T>(N);
immutableList = ImmutableList.CreateRange(ValuesGenerator.Default.GenerateUniqueValues<T>(N));
lst = ValuesGenerator.Default.GenerateUniqueValues<T>(N).AsIterable().ToLst();
seq = toSeq(ValuesGenerator.Default.GenerateUniqueValues<T>(N)).Strict();
}
[Benchmark]
public T SysColImmutableList()
{
T result = default;
var collection = immutableList;
foreach (var item in collection)
{
result = item;
}
return result;
}
[Benchmark]
public T LangExtLst()
{
T result = default;
var collection = lst;
foreach (var item in collection)
{
result = item;
}
return result;
}
[Benchmark]
public T LangExtSeq()
{
T result = default;
var collection = seq;
foreach (var item in collection)
{
result = item;
}
return result;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/Program.cs
================================================
using BenchmarkDotNet.Running;
namespace LanguageExt.Benchmarks
{
class Program
{
static void Main(string[] args) =>
BenchmarkSwitcher
.FromAssembly(typeof(Program).Assembly)
.Run(args);
}
}
================================================
FILE: LanguageExt.Benchmarks/ValuesGenerator.MapSetup.cs
================================================
using System.Collections.Generic;
using System.Collections.Immutable;
using LanguageExt.Traits;
using Sasa.Collections;
using static LanguageExt.Prelude;
namespace LanguageExt.Benchmarks
{
internal partial class ValuesGenerator
{
public static Trie<T, T> SasaTrieSetup<T>(Dictionary<T, T> values)
{
var trie = Trie<T, T>.Empty;
foreach (var kvp in values)
{
trie = trie.Add(kvp.Key, kvp.Value);
}
return trie;
}
public static ImmutableDictionary<T, T> SysColImmutableDictionarySetup<T>(Dictionary<T, T> values)
{
var immutableMap = ImmutableDictionary.Create<T, T>();
foreach (var kvp in values)
{
immutableMap = immutableMap.Add(kvp.Key, kvp.Value);
}
return immutableMap;
}
public static ImmutableSortedDictionary<T, T> SysColImmutableSortedDictionarySetup<T>(Dictionary<T, T> values)
{
var immutableMap = ImmutableSortedDictionary.Create<T, T>();
foreach (var kvp in values)
{
immutableMap = immutableMap.Add(kvp.Key, kvp.Value);
}
return immutableMap;
}
public static Dictionary<T, T> SysColDictionarySetup<T>(Dictionary<T, T> values)
{
var dictionary = new Dictionary<T, T>();
foreach (var kvp in values)
{
dictionary.Add(kvp.Key, kvp.Value);
}
return dictionary;
}
public static HashMap<TEq, T, T> LangExtHashMapSetup<T, TEq>(Dictionary<T, T> values)
where TEq : Eq<T>
{
var hashMap = HashMap<TEq, T, T>();
foreach (var kvp in values)
{
hashMap = hashMap.Add(kvp.Key, kvp.Value);
}
return hashMap;
}
public static Map<TOrd, T, T> LangExtMapSetup<T, TOrd>(Dictionary<T, T> values)
where TOrd : Ord<T>
{
var hashMap = Map<TOrd, T, T>();
foreach (var kvp in values)
{
hashMap = hashMap.Add(kvp.Key, kvp.Value);
}
return hashMap;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/ValuesGenerator.SetSetup.cs
================================================
using System.Collections.Immutable;
using LanguageExt.Traits;
using static LanguageExt.Prelude;
namespace LanguageExt.Benchmarks
{
internal partial class ValuesGenerator
{
public static ImmutableHashSet<T> SysColImmutableHashSetSetup<T>(T[] values)
{
var immutableSet = ImmutableHashSet.Create<T>();
foreach (var value in values)
{
immutableSet = immutableSet.Add(value);
}
return immutableSet;
}
public static ImmutableSortedSet<T> SysColImmutableSortedSetSetup<T>(T[] values)
{
var immutableSet = ImmutableSortedSet.Create<T>();
foreach (var value in values)
{
immutableSet = immutableSet.Add(value);
}
return immutableSet;
}
public static System.Collections.Generic.HashSet<T> SysColHashSetSetup<T>(T[] values)
{
var hashSet = new System.Collections.Generic.HashSet<T>();
foreach (var value in values)
{
hashSet.Add(value);
}
return hashSet;
}
public static HashSet<TEq, T> LangExtHashSetSetup<T, TEq>(T[] values)
where TEq : Eq<T>
{
var hashSet = HashSet<TEq, T>();
foreach (var value in values)
{
hashSet = hashSet.Add(value);
}
return hashSet;
}
public static Set<TOrd, T> LangExtSetSetup<T, TOrd>(T[] values)
where TOrd : Ord<T>
{
var set = Set<TOrd, T>();
foreach (var value in values)
{
set = set.Add(value);
}
return set;
}
}
}
================================================
FILE: LanguageExt.Benchmarks/ValuesGenerator.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace LanguageExt.Benchmarks
{
internal partial class ValuesGenerator
{
public static readonly ValuesGenerator Default = new ValuesGenerator(12345);
readonly int randSeed;
public ValuesGenerator(int seed)
{
randSeed = seed;
}
public Dictionary<TKey, TValue> GenerateDictionary<TKey, TValue>(int count)
{
var rand = new Random(randSeed);
var dict = new Dictionary<TKey, TValue>(count);
while (dict.Count < count)
{
dict[GenerateValue<TKey>(rand)] = GenerateValue<TValue>(rand);
}
return dict;
}
public T[] GenerateUniqueValues<T>(int count)
{
var rand = new Random(randSeed);
var set = new System.Collections.Generic.HashSet<T>(count);
while (set.Count < count)
{
set.Add(GenerateValue<T>(rand));
}
return set.ToArray();
}
private T GenerateValue<T>(Random rand)
{
if (typeof(T) == typeof(int))
{
return (T)(object)rand.Next();
}
if (typeof(T) == typeof(string))
{
return (T)(object)GenerateString(rand, 1, 50);
}
throw new NotSupportedException($"Generating value of type {typeof(T)} is not supported");
}
private string GenerateString(Random rand, int minLength, int maxLength)
{
var length = rand.Next(minLength, maxLength);
var sb = new StringBuilder(length);
for (var i = 0; i < length; i++)
{
switch (rand.Next(0, 3))
{
case 0:
sb.Append((char)rand.Next('0', '9'));
break;
case 1:
sb.Append((char)rand.Next('A', 'Z'));
break;
default:
sb.Append((char)rand.Next('a', 'z'));
break;
}
}
return sb.ToString();
}
}
}
================================================
FILE: LanguageExt.Core/Catch.cs
================================================
using System;
using LanguageExt.Traits;
namespace LanguageExt;
/// <summary>
/// Used by `@catch`, `@exceptional`, `@expected` to represent the catching of errors
/// </summary>
public readonly record struct CatchM<E, M, A>(Func<E, bool> Match, Func<E, K<M, A>> Action)
where M : Fallible<E, M>
{
public K<M, A> Run(E error, K<M, A> otherwise) =>
Match(error) ? Action(error) : otherwise;
}
public static class CatchMExtensions
{
extension<E, M, A>(CatchM<E, M, A> self)
where M : Functor<M>, Fallible<E, M>
{
public CatchM<E, M, B> Map<B>(Func<A, B> f) =>
new(self.Match, e => self.Action(e).Map(f));
}
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqArr.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using static LanguageExt.Prelude;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Array equality
/// </summary>
public struct EqArr<EqA, A> : Eq<Arr<A>> where EqA : Eq<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Arr<A> x, Arr<A> y)
{
if (x.Count != y.Count) return false;
var xiter = x.GetEnumerator();
var yiter = y.GetEnumerator();
while (xiter.MoveNext() && yiter.MoveNext())
{
if (!equals<EqA, A>(xiter.Current, yiter.Current)) return false;
}
return true;
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Arr<A> x) =>
HashableArr<A>.GetHashCode(x);
}
/// <summary>
/// Array equality
/// </summary>
public struct EqArr<A> : Eq<Arr<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Arr<A> x, Arr<A> y) =>
EqArr<EqDefault<A>, A>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Arr<A> x) =>
HashableArr<HashableDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqArray.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using static LanguageExt.Prelude;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Array equality
/// </summary>
public struct EqArray<EqA, A> : Eq<A[]> where EqA : Eq<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(A[] x, A[] y)
{
if (x.Length != y.Length) return false;
for (var i = 0; i < x.Length; i++)
{
if (!equals<EqA, A>(x[i], y[i])) return false;
}
return true;
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(A[] x) =>
HashableArray<EqA, A>.GetHashCode(x);
}
/// <summary>
/// Array equality
/// </summary>
public struct EqArray<A> : Eq<A[]>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(A[] x, A[] y) =>
EqArray<EqDefault<A>, A>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(A[] x) =>
HashableArray<HashableDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqBigInt.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Integer equality
/// </summary>
public struct EqBigInt : Eq<bigint>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(bigint a, bigint b) =>
a == b;
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(bigint x) =>
HashableBigInt.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqBool.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Boolean equality
/// </summary>
public struct EqBool : Eq<bool>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(bool a, bool b) =>
a == b;
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(bool x) =>
HashableBool.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqChar.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Char equality
/// </summary>
public struct EqChar : Eq<char>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(char a, char b) =>
a == b;
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(char x) =>
HashableChar.GetHashCode(x);
}
/// <summary>
/// Char equality (ordinal, ignore case)
/// </summary>
public struct EqCharOrdinalIgnoreCase : Eq<char>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="a">The left hand side of the equality operation</param>
/// <param name="b">The right hand side of the equality operation</param>
/// <returns>True if a and b are equal</returns>
[Pure]
public static bool Equals(char a, char b)
{
if (a >= 'a' && a <= 'z') a = (char)(a - 0x20);
if (b >= 'a' && b <= 'z') b = (char)(b - 0x20);
return a == b;
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(char x) =>
HashableCharOrdinalIgnoreCase.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqCompositions.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
public struct EqCompositions<A> : Eq<Compositions<A>>
where A : Monoid<A>
{
[Pure]
public static bool Equals(Compositions<A> x, Compositions<A> y) =>
x == y;
[Pure]
public static int GetHashCode(Compositions<A> x) =>
HashableCompositions<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqDateTime.cs
================================================
using LanguageExt.Traits;
using System;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// DateTime equality
/// </summary>
public struct EqDateTime : Eq<DateTime>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(DateTime a, DateTime b) =>
a == b;
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(DateTime x) =>
HashableDateTime.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqDecimal.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using System.Threading.Tasks;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Floating point equality
/// </summary>
public struct EqDecimal : Eq<decimal>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(decimal a, decimal b) =>
a == b;
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(decimal x) =>
HashableDecimal.GetHashCode(x);
[Pure]
public static Task<bool> EqualsAsync(decimal x, decimal y) =>
Equals(x, y).AsTask();
[Pure]
public static Task<int> GetHashCodeAsync(decimal x) =>
GetHashCode(x).AsTask();
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqDefault.cs
================================================
using LanguageExt.Traits;
using static LanguageExt.Prelude;
using System;
using System.Diagnostics.Contracts;
using LanguageExt.Traits.Resolve;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Finds an appropriate Eq from the loaded assemblies, if one can't be found then it
/// falls back to the standard .NET EqualityComparer〈A〉.Default.Equals(a,b) method to
/// provide equality testing.
/// </summary>
public readonly struct EqDefault<A> : Eq<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(A a, A b)
{
if (a is null) return b is null;
if (b is null) return false;
if (ReferenceEquals(a, b)) return true;
return EqResolve<A>.Equals(a, b);
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(A x) =>
HashableDefault<A>.GetHashCode(x);
}
/// <summary>
/// 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.
/// </summary>
public static class EqDefault<A, B>
{
static readonly Func<A, B, bool> Eq;
static EqDefault()
{
Eq = typeof(A).FullName == typeof(B).FullName
? (x, y) => y is A y1 && EqDefault<A>.Equals(x, y1)
: (_, _) => false;
}
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(A a, B b)
{
if (isnull(a)) return isnull(b);
if (isnull(b)) return false;
if (ReferenceEquals(a, b)) return true;
return Eq(a, b);
}
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqDouble.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances
{
/// <summary>
/// Floating point equality
/// </summary>
public struct EqDouble : Eq<double>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(double a, double b) =>
a.Equals(b);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(double x) =>
HashableDouble.GetHashCode(x);
}
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqEdit.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances
{
/// <summary>
/// Equality instance for `Patch` `Edit`
/// </summary>
public struct EqEdit<EqA, A> : Eq<Edit<EqA, A>> where EqA : Eq<A>
{
[Pure]
public static bool Equals(Edit<EqA, A> x, Edit<EqA, A> y) =>
x == y;
[Pure]
public static int GetHashCode(Edit<EqA, A> x) =>
HashableEdit<EqA, A>.GetHashCode(x);
}
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqEither.cs
================================================
using System.Diagnostics.Contracts;
using System.Threading.Tasks;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances
{
/// <summary>
/// Either type hashing
/// </summary>
public struct EqEither<EqL, EqR, L, R> : Eq<Either<L, R>>
where EqL : Eq<L>
where EqR : Eq<R>
{
/// <summary>
/// Equality test
/// </summary>
[Pure]
public static bool Equals(Either<L, R> x, Either<L, R> y) =>
x.Equals<EqL, EqR>(y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Either<L, R> x) =>
HashableEither<EqL, EqR, L, R>.GetHashCode(x);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static Task<int> GetHashCodeAsync(Either<L, R> x) =>
GetHashCode(x).AsTask();
/// <summary>
/// Equality test
/// </summary>
[Pure]
public static Task<bool> EqualsAsync(Either<L, R> x, Either<L, R> y) =>
Equals(x, y).AsTask();
}
/// <summary>
/// Either type hashing
/// </summary>
public struct EqEither<L, R> : Eq<Either<L, R>>
{
/// <summary>
/// Equality test
/// </summary>
[Pure]
public static bool Equals(Either<L, R> x, Either<L, R> y) =>
EqEither<EqDefault<L>, EqDefault<R>, L, R>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Either<L, R> x) =>
HashableEither<HashableDefault<L>, HashableDefault<R>, L, R>.GetHashCode(x);
}
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqEnumerable.cs
================================================
using LanguageExt.Traits;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqEnumerable<EQ, A> : Eq<IEnumerable<A>>
where EQ : Eq<A>
{
/// <summary>
/// Equality check
/// </summary>
[Pure]
public static bool Equals(IEnumerable<A> x, IEnumerable<A> y)
{
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
while (true)
{
var a = enumx.MoveNext();
var b = enumy.MoveNext();
if (a != b) return false;
if (!a && !b) return true;
if (!EQ.Equals(enumx.Current, enumy.Current)) return false;
}
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(IEnumerable<A> x) =>
HashableEnumerable<EQ, A>.GetHashCode(x);
}
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqEnumerable<A> : Eq<IEnumerable<A>>
{
/// <summary>
/// Equality check
/// </summary>
[Pure]
public static bool Equals(IEnumerable<A> x, IEnumerable<A> y) =>
EqEnumerable<EqDefault<A>, A>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(IEnumerable<A> x) =>
HashableEnumerable<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqException.cs
================================================
using System;
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
public struct EqException : Eq<Exception>
{
[Pure]
public static int GetHashCode(Exception x) =>
HashableException.GetHashCode(x);
[Pure]
public static bool Equals(Exception x, Exception y) =>
x.GetType() == y.GetType();
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqFloat.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Floating point equality
/// </summary>
public struct EqFloat : Eq<float>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(float a, float b) =>
a.Equals(b);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(float x) =>
HashableFloat.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqGuid.cs
================================================
using System;
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Guid equality
/// </summary>
public struct EqGuid : Eq<Guid>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Guid a, Guid b) =>
a == b;
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Guid x) =>
HashableGuid.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqHashSet.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// HashSet equality
/// </summary>
public struct EqHashSet<EQ, A> : Eq<HashSet<A>> where EQ : Eq<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(HashSet<A> x, HashSet<A> y)
{
if (x.Count != y.Count) return false;
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
for (var i = 0; i < x.Count; i++)
{
enumx.MoveNext();
enumy.MoveNext();
if (!EQ.Equals(enumx.Current, enumy.Current)) return false;
}
return true;
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(HashSet<A> x) =>
HashableHashSet<EQ, A>.GetHashCode(x);
}
/// <summary>
/// HashSet equality
/// </summary>
public struct EqHashSet<A> : Eq<HashSet<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(HashSet<A> x, HashSet<A> y) =>
EqHashSet<EqDefault<A>, A>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(HashSet<A> x) =>
HashableHashSet<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqIdentity.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Identity equality
/// </summary>
public struct EqIdentity<A> : Eq<Identity<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Identity<A> a, Identity<A> b) =>
a == b;
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Identity<A> x) =>
HashableIdentity<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqInt.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Integer equality
/// </summary>
public struct EqInt : Eq<int>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(int a, int b) =>
a == b;
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(int x) =>
HashableInt.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqIterable.cs
================================================
using LanguageExt.Traits;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqIterable<EQ, A> : Eq<Iterable<A>>
where EQ : Eq<A>
{
/// <summary>
/// Equality check
/// </summary>
[Pure]
public static bool Equals(Iterable<A> x, Iterable<A> y)
{
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
while (true)
{
var a = enumx.MoveNext();
var b = enumy.MoveNext();
if (a != b) return false;
if (!a && !b) return true;
if (!EQ.Equals(enumx.Current, enumy.Current)) return false;
}
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Iterable<A> x) =>
HashableIterable<EQ, A>.GetHashCode(x);
}
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqIterable<A> : Eq<Iterable<A>>
{
/// <summary>
/// Equality check
/// </summary>
[Pure]
public static bool Equals(Iterable<A> x, Iterable<A> y) =>
EqIterable<EqDefault<A>, A>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Iterable<A> x) =>
HashableIterable<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqLong.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Integer equality
/// </summary>
public struct EqLong : Eq<long>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(long a, long b) =>
a == b;
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(long x) =>
HashableLong.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqLst.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqLst<EQ, A> : Eq<Lst<A>> where EQ : Eq<A>
{
[Pure]
public static bool Equals(Lst<A> x, Lst<A> y)
{
if (x.Count != y.Count) return false;
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
var count = x.Count;
for (var i = 0; i < count; i++)
{
enumx.MoveNext();
enumy.MoveNext();
if (!EQ.Equals(enumx.Current, enumy.Current)) return false;
}
return true;
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Lst<A> x) =>
HashableLst<EQ, A>.GetHashCode(x);
}
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqLst<A> : Eq<Lst<A>>
{
[Pure]
public static bool Equals(Lst<A> x, Lst<A> y) =>
EqLst<EqDefault<A>, A>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Lst<A> x) =>
HashableLst<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqMap.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
public struct EqMap<K, V> : Eq<Map<K, V>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if `x` and `y` are equal</returns>
[Pure]
public static bool Equals(Map<K, V> x, Map<K, V> y) =>
x.Equals(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of `x`</returns>
[Pure]
public static int GetHashCode(Map<K, V> x) =>
HashableMap<K, V>.GetHashCode(x);
}
public struct EqMap<OrdK, K, V> : Eq<Map<OrdK, K, V>>
where OrdK : Ord<K>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if `x` and `y` are equal</returns>
[Pure]
public static bool Equals(Map<OrdK, K, V> x, Map<OrdK, K, V> y) =>
x.Equals(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of `x`</returns>
[Pure]
public static int GetHashCode(Map<OrdK, K, V> x) =>
HashableMap<OrdK, K, V>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqOption.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Option type equality
/// </summary>
public struct EqOption<A> : Eq<Option<A>>
{
[Pure]
public static bool Equals(Option<A> x, Option<A> y) =>
x.Equals(y);
[Pure]
public static int GetHashCode(Option<A> x) =>
HashableOption<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqPatch.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality instance for `Patch`
/// </summary>
public struct EqPatch<EqA, A> : Eq<Patch<EqA, A>> where EqA : Eq<A>
{
[Pure]
public static bool Equals(Patch<EqA, A> x, Patch<EqA, A> y) =>
x == y;
[Pure]
public static int GetHashCode(Patch<EqA, A> x) =>
HashablePatch<EqA, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqQue.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using System.Threading.Tasks;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqQue<EQ, A> : Eq<Que<A>> where EQ : Eq<A>
{
[Pure]
public static bool Equals(Que<A> x, Que<A> y)
{
if (x.Count != y.Count) return false;
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
var count = x.Count;
for (var i = 0; i < count; i++)
{
enumx.MoveNext();
enumy.MoveNext();
if (!EQ.Equals(enumx.Current, enumy.Current)) return false;
}
return true;
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Que<A> x) =>
HashableQue<EQ, A>.GetHashCode(x);
}
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqQue<A> : Eq<Que<A>>
{
[Pure]
public static bool Equals(Que<A> x, Que<A> y) =>
EqQue<EqDefault<A>, A>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Que<A> x) =>
HashableQue<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqRecord.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality class instance for all record types
/// </summary>
/// <typeparam name="A">Record type</typeparam>
public struct EqRecord<A> : Eq<A> where A : Record<A>
{
[Pure]
public static bool Equals(A x, A y) =>
RecordType<A>.EqualityTyped(x, y);
[Pure]
public static int GetHashCode(A x) =>
HashableRecord<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqSeq.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqSeq<EqA, A> : Eq<Seq<A>>
where EqA : Eq<A>
{
/// <summary>
/// Equality check
/// </summary>
[Pure]
public static bool Equals(Seq<A> x, Seq<A> y)
{
if (x.Count != y.Count) return false;
while (true)
{
var a = x.IsEmpty;
var b = y.IsEmpty;
if (a != b) return false;
if (a && b) return true;
if (!EqA.Equals((A)x.Head,(A)y.Head)) return false;
x = x.Tail;
y = y.Tail;
}
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Seq<A> x) =>
HashableSeq<EqA, A>.GetHashCode(x);
}
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqSeq<A> : Eq<Seq<A>>
{
/// <summary>
/// Equality check
/// </summary>
[Pure]
public static bool Equals(Seq<A> x, Seq<A> y) =>
EqSeq<EqDefault<A>, A>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Seq<A> x) =>
HashableSeq<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqSet.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Set〈T〉 equality
/// </summary>
public struct EqSet<EQ, A> : Eq<Set<A>> where EQ : Eq<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Set<A> x, Set<A> y)
{
if (x.Count != y.Count) return false;
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
for (var i = 0; i < x.Count; i++)
{
enumx.MoveNext();
enumy.MoveNext();
if (!EQ.Equals(enumx.Current, enumy.Current)) return false;
}
return true;
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Set<A> x) =>
HashableSet<EQ, A>.GetHashCode(x);
}
/// <summary>
/// Set〈T〉 equality
/// </summary>
public struct EqSet<A> : Eq<Set<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Set<A> x, Set<A> y) =>
EqSet<EqDefault<A>, A>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Set<A> x) =>
HashableSet<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqShort.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Integer equality
/// </summary>
public struct EqShort : Eq<short>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(short a, short b) =>
a == b;
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(short x) =>
HashableShort.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqStck.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqStck<EQ, A> : Eq<Stck<A>> where EQ : Eq<A>
{
[Pure]
public static bool Equals(Stck<A> x, Stck<A> y)
{
if (x.Count != y.Count) return false;
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
var count = x.Count;
for (var i = 0; i < count; i++)
{
enumx.MoveNext();
enumy.MoveNext();
if (!EQ.Equals(enumx.Current, enumy.Current)) return false;
}
return true;
}
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Stck<A> x) =>
HashableStck<EQ, A>.GetHashCode(x);
}
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
public struct EqStck<A> : Eq<Stck<A>>
{
[Pure]
public static bool Equals(Stck<A> x, Stck<A> y) =>
EqStck<EqDefault<A>, A>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Stck<A> x) =>
HashableStck<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqString.cs
================================================
using System;
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// String equality
/// </summary>
public struct EqString : Eq<string>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="a">The left hand side of the equality operation</param>
/// <param name="b">The right hand side of the equality operation</param>
/// <returns>True if a and b are equal</returns>
[Pure]
public static bool Equals(string a, string b) =>
a == b;
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(string x) =>
HashableString.GetHashCode(x);
}
/// <summary>
/// String equality (invariant culture)
/// </summary>
public struct EqStringInvariantCulture : Eq<string>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="a">The left hand side of the equality operation</param>
/// <param name="b">The right hand side of the equality operation</param>
/// <returns>True if a and b are equal</returns>
[Pure]
public static bool Equals(string a, string b) =>
StringComparer.InvariantCulture.Equals(a, b);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(string x) =>
HashableStringInvariantCulture.GetHashCode(x);
}
/// <summary>
/// String equality (invariant culture, ignore case)
/// </summary>
public struct EqStringInvariantCultureIgnoreCase : Eq<string>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="a">The left hand side of the equality operation</param>
/// <param name="b">The right hand side of the equality operation</param>
/// <returns>True if a and b are equal</returns>
[Pure]
public static bool Equals(string a, string b) =>
StringComparer.InvariantCultureIgnoreCase.Equals(a, b);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(string x) =>
HashableStringInvariantCultureIgnoreCase.GetHashCode(x);
}
/// <summary>
/// String equality (ordinal, ignore case)
/// </summary>
public struct EqStringOrdinalIgnoreCase : Eq<string>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="a">The left hand side of the equality operation</param>
/// <param name="b">The right hand side of the equality operation</param>
/// <returns>True if a and b are equal</returns>
[Pure]
public static bool Equals(string a, string b) =>
StringComparer.OrdinalIgnoreCase.Equals(a, b);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(string x) =>
HashableStringOrdinalIgnoreCase.GetHashCode(x);
}
/// <summary>
/// String equality (ordinal)
/// </summary>
public struct EqStringOrdinal : Eq<string>
{
public static readonly EqStringOrdinal Inst = default;
/// <summary>
/// Equality test
/// </summary>
/// <param name="a">The left hand side of the equality operation</param>
/// <param name="b">The right hand side of the equality operation</param>
/// <returns>True if a and b are equal</returns>
[Pure]
public static bool Equals(string a, string b) =>
StringComparer.Ordinal.Equals(a, b);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(string x) =>
HashableStringOrdinal.GetHashCode(x);
}
/// <summary>
/// String equality (current culture, ignore case)
/// </summary>
public struct EqStringCurrentCultureIgnoreCase : Eq<string>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="a">The left hand side of the equality operation</param>
/// <param name="b">The right hand side of the equality operation</param>
/// <returns>True if a and b are equal</returns>
[Pure]
public static bool Equals(string a, string b) =>
StringComparer.CurrentCultureIgnoreCase.Equals(a, b);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(string x) =>
HashableStringCurrentCultureIgnoreCase.GetHashCode(x);
}
/// <summary>
/// String equality (current culture)
/// </summary>
public struct EqStringCurrentCulture : Eq<string>
{
public static readonly EqStringCurrentCulture Inst = default;
/// <summary>
/// Equality test
/// </summary>
/// <param name="a">The left hand side of the equality operation</param>
/// <param name="b">The right hand side of the equality operation</param>
/// <returns>True if a and b are equal</returns>
[Pure]
public static bool Equals(string a, string b) =>
StringComparer.CurrentCulture.Equals(a, b);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(string x) =>
HashableStringCurrentCulture.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqTask.cs
================================================
using System;
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
using System.Threading.Tasks;
namespace LanguageExt.ClassInstances;
public struct EqTask<A> : Eq<Task<A>>
{
[Pure]
public static bool Equals(Task<A> x, Task<A> y) =>
x.Id == y.Id;
[Pure]
public static int GetHashCode(Task<A> x) =>
HashableTask<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqTrue.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Always returns true for equality checks
/// </summary>
public struct EqTrue<A> : Eq<A>
{
[Pure]
public static bool Equals(A x, A y) =>
true;
[Pure]
public static int GetHashCode(A x) =>
EqDefault<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqTuple2.cs
================================================
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
public struct EqTuple2<EqA, EqB, A, B> : Eq<(A, B)>
where EqA : Eq<A>
where EqB : Eq<B>
{
public static int GetHashCode((A, B) pair) =>
FNV32.Next(EqA.GetHashCode(pair.Item1),
EqB.GetHashCode(pair.Item2));
public static bool Equals((A, B) x, (A, B) y) =>
EqA.Equals(x.Item1, y.Item1) &&
EqB.Equals(x.Item2, y.Item2);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqTypeInfo.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
using System.Reflection;
namespace LanguageExt.ClassInstances;
public struct EqTypeInfo : Eq<TypeInfo>
{
[Pure]
public static bool Equals(TypeInfo x, TypeInfo y) =>
x.Equals(y);
[Pure]
public static int GetHashCode(TypeInfo x) =>
HashableTypeInfo.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableArr.cs
================================================
using System.Diagnostics.Contracts;
using static LanguageExt.Prelude;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Array hash
/// </summary>
public struct HashableArr<HashA, A> : Hashable<Arr<A>> where HashA : Hashable<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Arr<A> x) =>
hash<HashA, A>(x);
}
/// <summary>
/// Array hash
/// </summary>
public struct HashableArr<A> : Hashable<Arr<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Arr<A> x) =>
HashableArr<HashableDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableArray.cs
================================================
using System.Diagnostics.Contracts;
using static LanguageExt.Prelude;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Array hash
/// </summary>
public struct HashableArray<HashA, A> : Hashable<A[]> where HashA : Hashable<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(A[] x) =>
hash<HashA, A>(x);
}
/// <summary>
/// Array hash
/// </summary>
public struct HashableArray<A> : Hashable<A[]>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(A[] x) =>
HashableArray<HashableDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableBigInt.cs
================================================
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// bigint hash
/// </summary>
public struct HashableBigInt : Hashable<bigint>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(bigint x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableBool.cs
================================================
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Boolean hash
/// </summary>
public struct HashableBool : Hashable<bool>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(bool x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableChar.cs
================================================
using System.Diagnostics.Contracts;
using System.Threading.Tasks;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Char hash
/// </summary>
public struct HashableChar : Hashable<char>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(char x) =>
x.GetHashCode();
}
/// <summary>
/// Char hash (ordinal, ignore case)
/// </summary>
public struct HashableCharOrdinalIgnoreCase : Hashable<char>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(char x) =>
x is >= 'a' and <= 'z' ? x - 0x20 : x;
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableCompositions.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
public struct HashableCompositions<A> : Hashable<Compositions<A>>
where A : Monoid<A>
{
[Pure]
public static int GetHashCode(Compositions<A> x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableDateTime.cs
================================================
using System;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// DateTime hash
/// </summary>
public struct HashableDateTime : Hashable<DateTime>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(DateTime x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableDecimal.cs
================================================
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Floating point hash
/// </summary>
public struct HashableDecimal : Hashable<decimal>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(decimal x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableDefault.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits.Resolve;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Finds an appropriate Hashable from the loaded assemblies, if one can't be found then it
/// falls back to the standard .NET Object.GetHashCode() method to provide a hash-code.
/// </summary>
public struct HashableDefault<A> : Hashable<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(A x) =>
HashableResolve<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableDouble.cs
================================================
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Floating point hash
/// </summary>
public struct HashableDouble : Hashable<double>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(double x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableEdit.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Hash for `Patch` `Edit`
/// </summary>
public struct HashableEdit<EqA, A> : Hashable<Edit<EqA, A>> where EqA : Eq<A>
{
[Pure]
public static int GetHashCode(Edit<EqA, A> x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableEither.cs
================================================
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Either type hashing
/// </summary>
public readonly struct HashableEither<HashableL, HashableR, L, R> : Hashable<Either<L, R>>
where HashableL : Hashable<L>
where HashableR : Hashable<R>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Either<L, R> x) =>
x switch
{
Either<L, R>.Right => HashableR.GetHashCode(x.RightValue),
Either<L, R>.Left => HashableL.GetHashCode(x.LeftValue),
_ => 0
};
}
/// <summary>
/// Either type hashing
/// </summary>
public readonly struct HashableEither<L, R> : Hashable<Either<L, R>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Either<L, R> x) =>
HashableEither<HashableDefault<L>, HashableDefault<R>, L, R>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableEnumerable.cs
================================================
using static LanguageExt.Prelude;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Enumerable hashing
/// </summary>
public struct HashableEnumerable<HashA, A> : Hashable<IEnumerable<A>>
where HashA : Hashable<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(IEnumerable<A> x) =>
hash<HashA, A>(x);
}
/// <summary>
/// Enumerable hashing
/// </summary>
public struct HashableEnumerable<A> : Hashable<IEnumerable<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(IEnumerable<A> x) =>
HashableEnumerable<HashableDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableException.cs
================================================
using System;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
public struct HashableException : Hashable<Exception>
{
[Pure]
public static int GetHashCode(Exception x) =>
x.GetType().GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableFloat.cs
================================================
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Floating point hash
/// </summary>
public struct HashableFloat : Hashable<float>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(float x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableGuid.cs
================================================
using System;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Guid hash
/// </summary>
public struct HashableGuid : Hashable<Guid>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Guid x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableHashSet.cs
================================================
using System.Diagnostics.Contracts;
using static LanguageExt.Prelude;
namespace LanguageExt.ClassInstances;
/// <summary>
/// HashSet hash
/// </summary>
public struct HashableHashSet<HashA, A> : Hashable<HashSet<A>> where HashA : Hashable<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(HashSet<A> x) =>
hash<HashA, A>(x);
}
/// <summary>
/// HashSet hash
/// </summary>
public struct HashableHashSet<A> : Hashable<HashSet<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(HashSet<A> x) =>
HashableHashSet<HashableDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableIdentity.cs
================================================
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Identity hashing
/// </summary>
public struct HashableIdentity<A> : Hashable<Identity<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Identity<A> x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableInt.cs
================================================
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Integer hash
/// </summary>
public struct HashableInt : Hashable<int>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(int x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableIterable.cs
================================================
using static LanguageExt.Prelude;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Iterable hashing
/// </summary>
public struct HashableIterable<HashA, A> : Hashable<Iterable<A>>
where HashA : Hashable<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Iterable<A> x) =>
hash<HashA, A>(x);
}
/// <summary>
/// Iterable hashing
/// </summary>
public struct HashableIterable<A> : Hashable<Iterable<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Iterable<A> x) =>
HashableIterable<HashableDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableLong.cs
================================================
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Integer hash
/// </summary>
public struct HashableLong : Hashable<long>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(long x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableLst.cs
================================================
using static LanguageExt.Prelude;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Lst hash
/// </summary>
public struct HashableLst<HashA, A> : Hashable<Lst<A>> where HashA : Hashable<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Lst<A> x) =>
hash<HashA, A>(x);
}
/// <summary>
/// Lst hash
/// </summary>
public struct HashableLst<A> : Hashable<Lst<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Lst<A> x) =>
HashableLst<HashableDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableMap.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
public struct HashableMap<K, V> : Hashable<Map<K, V>>
{
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of `x`</returns>
[Pure]
public static int GetHashCode(Map<K, V> x) =>
x.GetHashCode();
}
public struct HashableMap<OrdK, K, V> : Hashable<Map<OrdK, K, V>>
where OrdK : Ord<K>
{
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of `x`</returns>
[Pure]
public static int GetHashCode(Map<OrdK, K, V> x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableOption.cs
================================================
namespace LanguageExt.ClassInstances;
/// <summary>
/// Option type equality
/// </summary>
public struct HashableOption<A> : Hashable<Option<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
public static int GetHashCode(Option<A> x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashablePair.cs
================================================
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
namespace LanguageExt;
public struct HashablePair<HashA, HashB, A, B> : Hashable<(A, B)>
where HashA : Hashable<A>
where HashB : Hashable<B>
{
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode((A, B) pair) =>
(HashB.GetHashCode(pair.Item2) ^
(HashA.GetHashCode(pair.Item1) ^ FNV32.OffsetBasis) * FNV32.Prime) * FNV32.Prime;
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashablePatch.cs
================================================
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Hash for `Patch`
/// </summary>
public struct HashablePatch<EqA, A> : Hashable<Patch<EqA, A>> where EqA : Eq<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode(Patch<EqA, A> x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableQue.cs
================================================
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Queue hashing
/// </summary>
public struct HashableQue<HashA, A> : Hashable<Que<A>> where HashA : Hashable<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Que<A> x) =>
Prelude.hash<HashA, A>(x);
}
/// <summary>
/// Queue hashing
/// </summary>
public struct HashableQue<A> : Hashable<Que<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Que<A> x) =>
HashableQue<EqDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableRecord.cs
================================================
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Hash for all record types
/// </summary>
/// <typeparam name="A">Record type</typeparam>
public struct HashableRecord<A> : Hashable<A> where A : Record<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode(A x) =>
RecordType<A>.Hash(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableSeq.cs
================================================
using static LanguageExt.Prelude;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Seq hashing
/// </summary>
public struct HashableSeq<HashA, A> : Hashable<Seq<A>>
where HashA : Hashable<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Seq<A> x) =>
hash<HashA, A>(x);
}
/// <summary>
/// Seq hashing
/// </summary>
public struct HashableSeq<A> : Hashable<Seq<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Seq<A> x) =>
HashableSeq<HashableDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableSet.cs
================================================
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Set〈T〉 hashing
/// </summary>
public struct HashableSet<HashA, A> : Hashable<Set<A>> where HashA : Hashable<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Set<A> x) =>
Prelude.hash<HashA, A>(x);
}
/// <summary>
/// Set〈T〉 hashing
/// </summary>
public struct HashableSet<A> : Hashable<Set<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Set<A> x) =>
HashableSet<HashableDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableShort.cs
================================================
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Integer hashing
/// </summary>
public struct HashableShort : Hashable<short>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(short x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableStck.cs
================================================
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Stack hashing
/// </summary>
public struct HashableStck<HashA, A> : Hashable<Stck<A>> where HashA : Hashable<A>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Stck<A> x) =>
Prelude.hash<HashA, A>(x);
}
/// <summary>
/// Stack hashing
/// </summary>
public struct HashableStck<A> : Hashable<Stck<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Stck<A> x) =>
HashableStck<HashableDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableString.cs
================================================
using System;
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
namespace LanguageExt.ClassInstances;
/// <summary>
/// String hashing
/// </summary>
public struct HashableString : Hashable<string>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode(string x) =>
x == null ? 0 : x.GetHashCode();
}
/// <summary>
/// String hashing (invariant culture)
/// </summary>
public struct HashableStringInvariantCulture : Hashable<string>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode(string x) =>
StringComparer.InvariantCulture.GetHashCode(x);
}
/// <summary>
/// String hashing (invariant culture, ignore case)
/// </summary>
public struct HashableStringInvariantCultureIgnoreCase : Hashable<string>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode(string x) =>
x.IsNull() ? 0 : StringComparer.InvariantCultureIgnoreCase.GetHashCode(x);
}
/// <summary>
/// String equality (ordinal, ignore case)
/// </summary>
public struct HashableStringOrdinalIgnoreCase : Hashable<string>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode(string x) =>
x.IsNull() ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(x);
}
/// <summary>
/// String equality (ordinal)
/// </summary>
public struct HashableStringOrdinal : Hashable<string>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode(string x) =>
x.IsNull() ? 0 : StringComparer.Ordinal.GetHashCode(x);
}
/// <summary>
/// String equality (current culture, ignore case)
/// </summary>
public struct HashableStringCurrentCultureIgnoreCase : Hashable<string>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode(string x) =>
x.IsNull() ? 0 : StringComparer.CurrentCultureIgnoreCase.GetHashCode(x);
}
/// <summary>
/// String equality (current culture)
/// </summary>
public struct HashableStringCurrentCulture : Hashable<string>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode(string x) =>
x.IsNull() ? 0 : StringComparer.CurrentCulture.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableTask.cs
================================================
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
namespace LanguageExt.ClassInstances;
public struct HashableTask<A> : Hashable<Task<A>>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode(Task<A> x) =>
x.Id.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableTuple.cs
================================================
namespace LanguageExt.ClassInstances;
public struct HashableTuple<HashA, HashB, A, B> : Hashable<(A, B)>
where HashA : Hashable<A>
where HashB : Hashable<B>
{
public static int GetHashCode((A, B) pair) =>
FNV32.Next(HashA.GetHashCode(pair.Item1),
HashB.GetHashCode(pair.Item2));
}
================================================
FILE: LanguageExt.Core/Class Instances/Hashable/HashableTypeInfo.cs
================================================
using System.Diagnostics.Contracts;
using System.Reflection;
using System.Runtime.CompilerServices;
namespace LanguageExt.ClassInstances;
public struct HashableTypeInfo : Hashable<TypeInfo>
{
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetHashCode(TypeInfo x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Monoid/Addition.cs
================================================
/*
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using static LanguageExt.Trait;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Numbers form a monoid under addition.
/// </summary>
/// <typeparam name="A">The type of the number being added.</typeparam>
public struct Addition<NUM, A> : Monoid<A> where NUM : Num<A>
{
[Pure]
public static A Append(A x, A y) =>
plus<NUM, A>(x, y);
[Pure]
public static A Empty =>
fromInteger<NUM, A>(0);
}
*/
================================================
FILE: LanguageExt.Core/Class Instances/Monoid/All.cs
================================================
/*
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Booleans form a monoid under disjunctions.
/// </summary>
public struct All : Monoid<bool>, Bool<bool>
{
[Pure]
public static bool Append(bool x, bool y) => x && y;
[Pure]
public static bool Empty => true;
[Pure]
public static bool And(bool a, bool b) =>
TBool.And(a, b);
[Pure]
public static bool BiCondition(bool a, bool b) =>
TBool.BiCondition(a, b);
[Pure]
public static bool False() => false;
[Pure]
public static bool Implies(bool a, bool b) =>
TBool.Implies(a, b);
[Pure]
public static bool Not(bool a) =>
TBool.Not(a);
[Pure]
public static bool Or(bool a, bool b) =>
TBool.Or(a, b);
[Pure]
public static bool True() =>
true;
[Pure]
public static bool XOr(bool a, bool b) =>
TBool.XOr(a, b);
}
*/
================================================
FILE: LanguageExt.Core/Class Instances/Monoid/Any.cs
================================================
/*
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Booleans form a monoid under conjunction.
/// </summary>
public struct Any : Monoid<bool>, Bool<bool>
{
[Pure]
public static bool Append(bool x, bool y) => x || y;
[Pure]
public static bool Empty => false;
[Pure]
public static bool And(bool a, bool b) =>
TBool.And(a, b);
[Pure]
public static bool BiCondition(bool a, bool b) =>
TBool.BiCondition(a, b);
[Pure]
public static bool False() => false;
[Pure]
public static bool Implies(bool a, bool b) =>
TBool.Implies(a, b);
[Pure]
public static bool Not(bool a) =>
TBool.Not(a);
[Pure]
public static bool Or(bool a, bool b) =>
TBool.Or(a, b);
[Pure]
public static bool True() =>
true;
[Pure]
public static bool XOr(bool a, bool b) =>
TBool.XOr(a, b);
}
*/
================================================
FILE: LanguageExt.Core/Class Instances/Monoid/MError.cs
================================================
/*
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using LanguageExt.Common;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Error monoid
/// </summary>
public readonly struct MError : Monoid<Error>
{
[Pure]
public static Error Append(Error x, Error y) => x + y;
[Pure]
public static Error Empty => Errors.None;
}
*/
================================================
FILE: LanguageExt.Core/Class Instances/Monoid/MUnit.cs
================================================
/*
using LanguageExt.Traits;
using static LanguageExt.Prelude;
namespace LanguageExt.ClassInstances;
public struct MUnit : Monoid<Unit>
{
public static Unit Append(Unit x, Unit y) =>
unit;
public static Unit Empty =>
unit;
}
*/
================================================
FILE: LanguageExt.Core/Class Instances/Monoid/Product.cs
================================================
/*
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using static LanguageExt.Trait;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Numbers form a monoid under addition.
/// </summary>
/// <typeparam name="A">The type of the number being added.</typeparam>
public struct Product<NUM, A> : Monoid<A> where NUM : Num<A>
{
public static readonly Product<NUM, A> Inst = default;
[Pure]
public static A Append(A x, A y) =>
product<NUM, A>(x, y);
[Pure]
public static A Empty =>
fromInteger<NUM, A>(1);
}
*/
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdArr.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdArr<OrdA, A> : Ord<Arr<A>>
where OrdA : Ord<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Arr<A> x, Arr<A> y) =>
EqArr<OrdA, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Arr<A> mx, Arr<A> my)
{
var cmp = mx.Count.CompareTo(my.Count);
if (cmp == 0)
{
var xiter = mx.GetEnumerator();
var yiter = my.GetEnumerator();
while(xiter.MoveNext() && yiter.MoveNext())
{
cmp = OrdA.Compare(xiter.Current, yiter.Current);
if (cmp != 0) return cmp;
}
return 0;
}
else
{
return cmp;
}
}
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Arr<A> x) =>
x.GetHashCode();
}
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdArr<A> : Ord<Arr<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Arr<A> x, Arr<A> y) =>
EqArr<A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Arr<A> mx, Arr<A> my) =>
OrdArr<OrdDefault<A>, A>.Compare(mx, my);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Arr<A> x) =>
OrdArr<OrdDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdArray.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using static LanguageExt.Prelude;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdArray<OrdA, A> : Ord<A[]>
where OrdA : Ord<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(A[] x, A[] y) =>
EqArray<OrdA, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(A[] mx, A[] my)
{
if (ReferenceEquals(mx, my)) return 0;
if (ReferenceEquals(mx, null)) return -1;
if (ReferenceEquals(my, null)) return 1;
var cmp = mx.Length.CompareTo(my.Length);
if (cmp == 0)
{
for(var i = 0; i < mx.Length; i++)
{
cmp = OrdA.Compare(mx[i], my[i]);
if (cmp != 0) return cmp;
}
return 0;
}
else
{
return cmp;
}
}
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(A[] x) =>
hash(x);
}
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdArray<A> : Ord<A[]>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(A[] x, A[] y) =>
EqArray<A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(A[] mx, A[] my) =>
OrdArray<OrdDefault<A>, A>.Compare(mx, my);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(A[] x) =>
OrdArray<OrdDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdBigInt.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdBigInt : Ord<bigint>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(bigint x, bigint y) =>
x == y;
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
///
/// if x less than y : -1
///
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(bigint x, bigint y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(bigint x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdBool.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdBool : Ord<bool>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(bool x, bool y) =>
x == y;
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
///
/// if x less than y : -1
///
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(bool x, bool y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(bool x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdChar.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdChar : Ord<char>
{
public static readonly OrdChar Inst = default(OrdChar);
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(char x, char y) =>
x == y;
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
///
/// if x less than y : -1
///
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(char x, char y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(char x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdDateTime.cs
================================================
using System;
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdDateTime : Ord<DateTime>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(DateTime x, DateTime y) =>
x == y;
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
///
/// if x less than y : -1
///
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(DateTime x, DateTime y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(DateTime x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdDecimal.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdDecimal : Ord<decimal>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(decimal x, decimal y) =>
x == y;
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
///
/// if x less than y : -1
///
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(decimal x, decimal y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(decimal x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdDefault.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using LanguageExt.Traits.Resolve;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Uses the standard .NET Comparer〈A〉.Default.Compare(a,b) method to
/// provide equality testing.
/// </summary>
public struct OrdDefault<A> : Ord<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static int Compare(A x, A y) =>
OrdResolve<A>.Compare(x, y);
[Pure]
public static bool Equals(A x, A y) =>
EqDefault<A>.Equals(x, y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(A x) =>
EqDefault<A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdDouble.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdDouble : Ord<double>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(double x, double y) =>
x.Equals(y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
///
/// if x less than y : -1
///
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(double x, double y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(double x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdEither.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Either type hashing
/// </summary>
public struct OrdEither<OrdL, OrdR, L, R> : Ord<Either<L, R>>
where OrdL : Ord<L>
where OrdR : Ord<R>
{
/// <summary>
/// Ordering test
/// </summary>
[Pure]
public static int Compare(Either<L, R> x, Either<L, R> y) =>
x.CompareTo<OrdL, OrdR>(y);
/// <summary>
/// Equality test
/// </summary>
[Pure]
public static bool Equals(Either<L, R> x, Either<L, R> y) =>
EqEither<OrdL, OrdR, L, R>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Either<L, R> x) =>
HashableEither<OrdL, OrdR, L, R>.GetHashCode(x);
}
/// <summary>
/// Either type hashing
/// </summary>
public struct OrdEither<L, R> : Ord<Either<L, R>>
{
/// <summary>
/// Ordering test
/// </summary>
[Pure]
public static int Compare(Either<L, R> x, Either<L, R> y) =>
OrdEither<OrdDefault<L>, OrdDefault<R>, L, R>.Compare(x, y);
/// <summary>
/// Equality test
/// </summary>
[Pure]
public static bool Equals(Either<L, R> x, Either<L, R> y) =>
EqEither<EqDefault<L>, EqDefault<R>, L, R>.Equals(x, y);
/// <summary>
/// Get hash code of the value
/// </summary>
/// <param name="x">Value to get the hash code of</param>
/// <returns>The hash code of x</returns>
[Pure]
public static int GetHashCode(Either<L, R> x) =>
HashableEither<HashableDefault<L>, HashableDefault<R>, L, R>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdEnumerable.cs
================================================
using LanguageExt.Traits;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
using static LanguageExt.Prelude;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdEnumerable<OrdA, A> : Ord<IEnumerable<A>>
where OrdA : Ord<A>
{
public static readonly OrdEnumerable<OrdA, A> Inst = default(OrdEnumerable<OrdA, A>);
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(IEnumerable<A> x, IEnumerable<A> y) =>
EqEnumerable<OrdA, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(IEnumerable<A> x, IEnumerable<A> y)
{
if (ReferenceEquals(x, y)) return 0;
if (ReferenceEquals(x, null)) return -1;
if (ReferenceEquals(y, null)) return 1;
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
while (true)
{
bool r1 = enumx.MoveNext();
bool r2 = enumy.MoveNext();
if (!r1 && !r2) return 0;
if (!r1) return -1;
if (!r2) return 1;
var cmp = OrdA.Compare(enumx.Current, enumy.Current);
if (cmp != 0) return cmp;
}
}
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(IEnumerable<A> x) =>
hash(x);
}
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdEnumerable<A> : Ord<IEnumerable<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(IEnumerable<A> x, IEnumerable<A> y) =>
OrdEnumerable<OrdDefault<A>, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(IEnumerable<A> x, IEnumerable<A> y) =>
OrdEnumerable<OrdDefault<A>, A>.Compare(x, y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(IEnumerable<A> x) =>
OrdEnumerable<OrdDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdException.cs
================================================
using System;
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
public struct OrdException : Ord<Exception>
{
[Pure]
public static int GetHashCode(Exception x) =>
HashableException.GetHashCode(x);
[Pure]
public static bool Equals(Exception x, Exception y) =>
EqException.Equals(x, y);
[Pure]
public static int Compare(Exception x, Exception y)
{
if (ReferenceEquals(x, y)) return 0;
if (ReferenceEquals(x, null)) return -1;
if (ReferenceEquals(y, null)) return 1;
return string.Compare(x.GetType().FullName, y.Message.GetType().FullName, StringComparison.Ordinal);
}
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdFloat.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdFloat : Ord<float>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(float x, float y) =>
x.Equals(y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
///
/// if x less than y : -1
///
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(float x, float y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(float x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdGuid.cs
================================================
using System;
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdGuid : Ord<Guid>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Guid x, Guid y) =>
x == y;
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
///
/// if x less than y : -1
///
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Guid x, Guid y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Guid x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdHashSet.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using static LanguageExt.Prelude;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdHashSet<OrdA, A> : Ord<HashSet<A>>
where OrdA : Ord<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(HashSet<A> x, HashSet<A> y) =>
EqHashSet<OrdA, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(HashSet<A> x, HashSet<A> y)
{
if (x.Count > y.Count) return 1;
if (x.Count < y.Count) return -1;
var sa = toSet(x);
var sb = toSet(y);
using var iterA = sa.GetEnumerator();
using var iterB = sb.GetEnumerator();
while (iterA.MoveNext() && iterB.MoveNext())
{
var cmp = OrdA.Compare(iterA.Current, iterB.Current);
if (cmp != 0) return cmp;
}
return 0;
}
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(HashSet<A> x) =>
x.GetHashCode();
}
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdHashSet<A> : Ord<HashSet<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(HashSet<A> x, HashSet<A> y) =>
OrdHashSet<OrdDefault<A>, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(HashSet<A> x, HashSet<A> y) =>
OrdHashSet<OrdDefault<A>, A>.Compare(x, y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(HashSet<A> x) =>
OrdHashSet<OrdDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdInt.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdInt : Ord<int>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(int x, int y) =>
x == y;
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
///
/// if x less than y : -1
///
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(int x, int y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(int x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdIterable.cs
================================================
using LanguageExt.Traits;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
using static LanguageExt.Prelude;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdIterable<OrdA, A> : Ord<Iterable<A>>
where OrdA : Ord<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Iterable<A> x, Iterable<A> y) =>
EqIterable<OrdA, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Iterable<A> x, Iterable<A> y)
{
if (ReferenceEquals(x, y)) return 0;
if (ReferenceEquals(x, null)) return -1;
if (ReferenceEquals(y, null)) return 1;
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
while (true)
{
bool r1 = enumx.MoveNext();
bool r2 = enumy.MoveNext();
if (!r1 && !r2) return 0;
if (!r1) return -1;
if (!r2) return 1;
var cmp = OrdA.Compare(enumx.Current, enumy.Current);
if (cmp != 0) return cmp;
}
}
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Iterable<A> x) =>
hash(x);
}
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdIterable<A> : Ord<Iterable<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Iterable<A> x, Iterable<A> y) =>
OrdIterable<OrdDefault<A>, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Iterable<A> x, Iterable<A> y) =>
OrdIterable<OrdDefault<A>, A>.Compare(x, y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Iterable<A> x) =>
OrdIterable<OrdDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdLong.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdLong : Ord<long>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(long x, long y) =>
x == y;
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
///
/// if x less than y : -1
///
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(long x, long y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(long x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdLst.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdLst<OrdA, A> : Ord<Lst<A>>
where OrdA : Ord<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Lst<A> x, Lst<A> y) =>
EqLst<OrdA, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Lst<A> mx, Lst<A> my)
{
var cmp = mx.Count.CompareTo(my.Count);
if (cmp == 0)
{
using var xiter = mx.GetEnumerator();
using var yiter = my.GetEnumerator();
while (xiter.MoveNext() && yiter.MoveNext())
{
cmp = OrdA.Compare(xiter.Current, yiter.Current);
if (cmp != 0) return cmp;
}
return 0;
}
else
{
return cmp;
}
}
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Lst<A> x) =>
x.GetHashCode();
}
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdLst<A> : Ord<Lst<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Lst<A> x, Lst<A> y) =>
OrdLst<OrdDefault<A>, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Lst<A> x, Lst<A> y) =>
OrdLst<OrdDefault<A>, A>.Compare(x, y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Lst<A> x) =>
OrdLst<OrdDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdMap.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdMap<OrdK, K, V> : Ord<Map<OrdK, K, V>>
where OrdK : Ord<K>
{
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if `x` greater than `y` : `1`
/// if `x` less than `y` : `-1`
/// if `x` equals `y` : `0`
/// </returns>
[Pure]
public static int Compare(Map<OrdK, K, V> x, Map<OrdK, K, V> y) =>
x.CompareTo(y);
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if `x` and `y` are equal</returns>
[Pure]
public static bool Equals(Map<OrdK, K, V> x, Map<OrdK, K, V> y) =>
x.Equals(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of `x`</returns>
[Pure]
public static int GetHashCode(Map<OrdK, K, V> x) =>
x.GetHashCode();
}
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdMap<K, V> : Ord<Map<K, V>>
{
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if `x` greater than `y` : `1`
/// if `x` less than `y` : `-1`
/// if `x` equals `y` : `0`
/// </returns>
[Pure]
public static int Compare(Map<K, V> x, Map<K, V> y) =>
x.CompareTo(y);
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if `x` and `y` are equal</returns>
[Pure]
public static bool Equals(Map<K, V> x, Map<K, V> y) =>
x.Equals(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of `x`</returns>
[Pure]
public static int GetHashCode(Map<K, V> x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdOption.cs
================================================
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
public struct OrdOption<OrdA, A> : Ord<Option<A>>
where OrdA : Ord<A>
{
[Pure]
public static int Compare(Option<A> x, Option<A> y) =>
x.CompareTo<OrdA>(y);
[Pure]
public static bool Equals(Option<A> x, Option<A> y) =>
x.Equals<OrdA>(y);
[Pure]
public static int GetHashCode(Option<A> x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdQue.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdQue<OrdA, A> : Ord<Que<A>>
where OrdA : Ord<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Que<A> x, Que<A> y) =>
EqQue<OrdA, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Que<A> x, Que<A> y)
{
var cmp = x.Count.CompareTo(y.Count);
if (cmp == 0)
{
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
var count = x.Count;
for (var i = 0; i < count; i++)
{
enumx.MoveNext();
enumy.MoveNext();
cmp = OrdA.Compare(enumx.Current, enumy.Current);
if (cmp != 0) return cmp;
}
return 0;
}
else
{
return cmp;
}
}
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Que<A> x) =>
x.GetHashCode();
}
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdQue<A> : Ord<Que<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Que<A> x, Que<A> y) =>
OrdQue<OrdDefault<A>, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Que<A> x, Que<A> y) =>
OrdQue<OrdDefault<A>, A>.Compare(x, y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Que<A> x) =>
OrdQue<OrdDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdRecord.cs
================================================
using System.Diagnostics.Contracts;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Ordering class instance for all record types
/// </summary>
/// <typeparam name="A">Record type</typeparam>
public struct OrdRecord<A> : Ord<A> where A : Record<A>
{
[Pure]
public static int Compare(A x, A y) =>
RecordType<A>.Compare(x, y);
[Pure]
public static bool Equals(A x, A y) =>
RecordType<A>.EqualityTyped(x, y);
[Pure]
public static int GetHashCode(A x) =>
RecordType<A>.Hash(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdSeq.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using static LanguageExt.Prelude;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdSeq<OrdA, A> : Ord<Seq<A>>
where OrdA : Ord<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Seq<A> x, Seq<A> y) =>
EqSeq<OrdA, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Seq<A> x, Seq<A> y)
{
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
while(true)
{
var r1 = enumx.MoveNext();
var r2 = enumy.MoveNext();
if (!r1 && !r2) return 0;
if (!r1) return -1;
if (!r2) return 1;
var cmp = OrdA.Compare(enumx.Current, enumy.Current);
if (cmp != 0) return cmp;
}
}
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Seq<A> x) =>
hash(x);
}
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdSeq<A> : Ord<Seq<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Seq<A> x, Seq<A> y) =>
OrdSeq<OrdDefault<A>, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Seq<A> x, Seq<A> y) =>
OrdSeq<OrdDefault<A>, A>.Compare(x, y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Seq<A> x) =>
OrdSeq<OrdDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdSet.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdSet<OrdA, A> : Ord<Set<A>>
where OrdA : Ord<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Set<A> x, Set<A> y) =>
EqSet<OrdA, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Set<A> x, Set<A> y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Set<A> x) =>
x.GetHashCode();
}
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdSet<A> : Ord<Set<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Set<A> x, Set<A> y) =>
OrdSet<OrdDefault<A>, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Set<A> x, Set<A> y) =>
OrdSet<OrdDefault<A>, A>.Compare(x, y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Set<A> x) =>
OrdSet<OrdDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdShort.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdShort : Ord<short>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(short x, short y) =>
x == y;
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
///
/// if x less than y : -1
///
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(short x, short y) =>
x.CompareTo(y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(short x) =>
x.GetHashCode();
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdStck.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
namespace LanguageExt.ClassInstances;
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdStck<OrdA, A> : Ord<Stck<A>>
where OrdA : Ord<A>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Stck<A> x, Stck<A> y) =>
EqStck<OrdA, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Stck<A> x, Stck<A> y)
{
var cmp = x.Count.CompareTo(y.Count);
if (cmp == 0)
{
using var enumx = x.GetEnumerator();
using var enumy = y.GetEnumerator();
var count = x.Count;
for (int i = 0; i < count; i++)
{
enumx.MoveNext();
enumy.MoveNext();
cmp = OrdA.Compare(enumx.Current, enumy.Current);
if (cmp != 0) return cmp;
}
return 0;
}
else
{
return cmp;
}
}
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Stck<A> x) =>
x.GetHashCode();
}
/// <summary>
/// Equality and ordering
/// </summary>
public struct OrdStck<A> : Ord<Stck<A>>
{
/// <summary>
/// Equality test
/// </summary>
/// <param name="x">The left hand side of the equality operation</param>
/// <param name="y">The right hand side of the equality operation</param>
/// <returns>True if x and y are equal</returns>
[Pure]
public static bool Equals(Stck<A> x, Stck<A> y) =>
OrdStck<OrdDefault<A>, A>.Equals(x, y);
/// <summary>
/// Compare two values
/// </summary>
/// <param name="x">Left hand side of the compare operation</param>
/// <param name="y">Right hand side of the compare operation</param>
/// <returns>
/// if x greater than y : 1
/// if x less than y : -1
/// if x equals y : 0
/// </returns>
[Pure]
public static int Compare(Stck<A> x, Stck<A> y) =>
OrdStck<OrdDefault<A>, A>.Compare(x, y);
/// <summary>
/// Get the hash-code of the provided value
/// </summary>
/// <returns>Hash code of x</returns>
[Pure]
public static int GetHashCode(Stck<A> x) =>
OrdStck<OrdDefault<A>, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Ord/OrdString.cs
================================================
using System;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances;
/// <summary>
/// String comparison
/// </summary>
public struct OrdString : O
gitextract_5rnkpet5/
├── .editorconfig
├── .gitattributes
├── .github/
│ └── FUNDING.yml
├── .gitignore
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE.md
├── LanguageExt.Benchmarks/
│ ├── HashMapAddBenchmarks.cs
│ ├── HashMapContainsKeyBenchmarks.cs
│ ├── HashMapIterateBenchmarks.cs
│ ├── HashMapRandomRemovalBenchmarks.cs
│ ├── HashSetAddBenchmarks.cs
│ ├── HashSetContainsBenchmarks.cs
│ ├── HashSetIterationBenchmarks.cs
│ ├── HashSetRandomRemovalBenchmarks.cs
│ ├── LanguageExt.Benchmarks.csproj
│ ├── ListAddBenchmarks.cs
│ ├── ListIterationBenchmarks.cs
│ ├── Program.cs
│ ├── ValuesGenerator.MapSetup.cs
│ ├── ValuesGenerator.SetSetup.cs
│ └── ValuesGenerator.cs
├── LanguageExt.Core/
│ ├── Catch.cs
│ ├── Class Instances/
│ │ ├── Eq/
│ │ │ ├── EqArr.cs
│ │ │ ├── EqArray.cs
│ │ │ ├── EqBigInt.cs
│ │ │ ├── EqBool.cs
│ │ │ ├── EqChar.cs
│ │ │ ├── EqCompositions.cs
│ │ │ ├── EqDateTime.cs
│ │ │ ├── EqDecimal.cs
│ │ │ ├── EqDefault.cs
│ │ │ ├── EqDouble.cs
│ │ │ ├── EqEdit.cs
│ │ │ ├── EqEither.cs
│ │ │ ├── EqEnumerable.cs
│ │ │ ├── EqException.cs
│ │ │ ├── EqFloat.cs
│ │ │ ├── EqGuid.cs
│ │ │ ├── EqHashSet.cs
│ │ │ ├── EqIdentity.cs
│ │ │ ├── EqInt.cs
│ │ │ ├── EqIterable.cs
│ │ │ ├── EqLong.cs
│ │ │ ├── EqLst.cs
│ │ │ ├── EqMap.cs
│ │ │ ├── EqOption.cs
│ │ │ ├── EqPatch.cs
│ │ │ ├── EqQue.cs
│ │ │ ├── EqRecord.cs
│ │ │ ├── EqSeq.cs
│ │ │ ├── EqSet.cs
│ │ │ ├── EqShort.cs
│ │ │ ├── EqStck.cs
│ │ │ ├── EqString.cs
│ │ │ ├── EqTask.cs
│ │ │ ├── EqTrue.cs
│ │ │ ├── EqTuple2.cs
│ │ │ └── EqTypeInfo.cs
│ │ ├── Hashable/
│ │ │ ├── HashableArr.cs
│ │ │ ├── HashableArray.cs
│ │ │ ├── HashableBigInt.cs
│ │ │ ├── HashableBool.cs
│ │ │ ├── HashableChar.cs
│ │ │ ├── HashableCompositions.cs
│ │ │ ├── HashableDateTime.cs
│ │ │ ├── HashableDecimal.cs
│ │ │ ├── HashableDefault.cs
│ │ │ ├── HashableDouble.cs
│ │ │ ├── HashableEdit.cs
│ │ │ ├── HashableEither.cs
│ │ │ ├── HashableEnumerable.cs
│ │ │ ├── HashableException.cs
│ │ │ ├── HashableFloat.cs
│ │ │ ├── HashableGuid.cs
│ │ │ ├── HashableHashSet.cs
│ │ │ ├── HashableIdentity.cs
│ │ │ ├── HashableInt.cs
│ │ │ ├── HashableIterable.cs
│ │ │ ├── HashableLong.cs
│ │ │ ├── HashableLst.cs
│ │ │ ├── HashableMap.cs
│ │ │ ├── HashableOption.cs
│ │ │ ├── HashablePair.cs
│ │ │ ├── HashablePatch.cs
│ │ │ ├── HashableQue.cs
│ │ │ ├── HashableRecord.cs
│ │ │ ├── HashableSeq.cs
│ │ │ ├── HashableSet.cs
│ │ │ ├── HashableShort.cs
│ │ │ ├── HashableStck.cs
│ │ │ ├── HashableString.cs
│ │ │ ├── HashableTask.cs
│ │ │ ├── HashableTuple.cs
│ │ │ └── HashableTypeInfo.cs
│ │ ├── Monoid/
│ │ │ ├── Addition.cs
│ │ │ ├── All.cs
│ │ │ ├── Any.cs
│ │ │ ├── MError.cs
│ │ │ ├── MUnit.cs
│ │ │ └── Product.cs
│ │ ├── Ord/
│ │ │ ├── OrdArr.cs
│ │ │ ├── OrdArray.cs
│ │ │ ├── OrdBigInt.cs
│ │ │ ├── OrdBool.cs
│ │ │ ├── OrdChar.cs
│ │ │ ├── OrdDateTime.cs
│ │ │ ├── OrdDecimal.cs
│ │ │ ├── OrdDefault.cs
│ │ │ ├── OrdDouble.cs
│ │ │ ├── OrdEither.cs
│ │ │ ├── OrdEnumerable.cs
│ │ │ ├── OrdException.cs
│ │ │ ├── OrdFloat.cs
│ │ │ ├── OrdGuid.cs
│ │ │ ├── OrdHashSet.cs
│ │ │ ├── OrdInt.cs
│ │ │ ├── OrdIterable.cs
│ │ │ ├── OrdLong.cs
│ │ │ ├── OrdLst.cs
│ │ │ ├── OrdMap.cs
│ │ │ ├── OrdOption.cs
│ │ │ ├── OrdQue.cs
│ │ │ ├── OrdRecord.cs
│ │ │ ├── OrdSeq.cs
│ │ │ ├── OrdSet.cs
│ │ │ ├── OrdShort.cs
│ │ │ ├── OrdStck.cs
│ │ │ ├── OrdString.cs
│ │ │ ├── OrdTask.cs
│ │ │ ├── OrdTrue.cs
│ │ │ ├── OrdTupleFirst.cs
│ │ │ └── OrdTypeInfo.cs
│ │ ├── README.md
│ │ ├── TBigInt.cs
│ │ ├── TBool.cs
│ │ ├── TBoolBool.cs
│ │ ├── TChar.cs
│ │ ├── TDecimal.cs
│ │ ├── TDouble.cs
│ │ ├── TFloat.cs
│ │ ├── TInt.cs
│ │ ├── TLong.cs
│ │ ├── TNumericChar.cs
│ │ ├── TShort.cs
│ │ └── TString.cs
│ ├── Combinators.cs
│ ├── Comment Alternatives.cs
│ ├── Common/
│ │ ├── Error.cs
│ │ ├── ErrorCodes.cs
│ │ ├── ErrorException.cs
│ │ ├── Errors.cs
│ │ ├── Exceptions.cs
│ │ └── README.md
│ ├── Concurrency/
│ │ ├── Async/
│ │ │ ├── Async.Module.cs
│ │ │ └── AsyncEnumerable/
│ │ │ ├── AsyncEnumberable.Extensions.cs
│ │ │ └── AsyncEnumberable.LINQ.Extensions.cs
│ │ ├── Atom/
│ │ │ ├── Atom.Metadata.cs
│ │ │ ├── Atom.cs
│ │ │ ├── AtomChangedEvent.cs
│ │ │ └── README.md
│ │ ├── AtomHashMap/
│ │ │ ├── AtomHashMap.Eq.cs
│ │ │ ├── AtomHashMap.Module.Eq.cs
│ │ │ ├── AtomHashMap.Module.cs
│ │ │ ├── AtomHashMap.cs
│ │ │ └── Events.cs
│ │ ├── AtomQue/
│ │ │ ├── AtomQue.Extensions.cs
│ │ │ ├── AtomQue.Trait.Implementation.cs
│ │ │ └── AtomQue.cs
│ │ ├── AtomSeq/
│ │ │ └── AtomSeq.cs
│ │ ├── Conflict.cs
│ │ ├── Prelude.Concurrency.cs
│ │ ├── README.md
│ │ ├── STM/
│ │ │ ├── CommuteRef.cs
│ │ │ ├── Isolation.cs
│ │ │ ├── Ref.cs
│ │ │ └── STM.cs
│ │ ├── Signals/
│ │ │ ├── CountdownSignal.cs
│ │ │ ├── Signal.Module.cs
│ │ │ └── Signal.cs
│ │ ├── Task/
│ │ │ ├── Task.Extensions.cs
│ │ │ ├── Task.Prelude.cs
│ │ │ └── Tasks.cs
│ │ ├── ValueTask/
│ │ │ ├── ValueTask.Extensions.cs
│ │ │ ├── ValueTask.Prelude.cs
│ │ │ └── ValueTasks.cs
│ │ ├── VectorClock/
│ │ │ ├── Relation.cs
│ │ │ ├── VectorClock.A.cs
│ │ │ ├── VectorClock.OrdA.NumB.A.B.cs
│ │ │ └── VectorClock.cs
│ │ ├── VersionHashMap/
│ │ │ ├── VersionHashMap.ConflictV.K.V.cs
│ │ │ ├── VersionHashMap.ConflictV.OrdActor.EqK.Actor.K.V.cs
│ │ │ └── VersionHashMap.K.V.cs
│ │ └── VersionVector/
│ │ ├── Version.cs
│ │ └── VersionVector.cs
│ ├── DataTypes/
│ │ ├── BigInt/
│ │ │ └── BigInt.cs
│ │ ├── Change/
│ │ │ ├── Change.cs
│ │ │ ├── EntryAdded.cs
│ │ │ ├── EntryMapped.cs
│ │ │ ├── EntryRemoved.cs
│ │ │ └── NoChange.cs
│ │ ├── Compositions/
│ │ │ ├── Compositions.Extensions.cs
│ │ │ ├── Compositions.Module.cs
│ │ │ ├── Compositions.cs
│ │ │ └── FoldCompositions.cs
│ │ ├── Fail/
│ │ │ ├── Fail.Extensions.cs
│ │ │ └── Fail.cs
│ │ ├── Loop/
│ │ │ ├── Loop.Extensions.cs
│ │ │ ├── Loop.Prelude.cs
│ │ │ └── Loop.cs
│ │ ├── Lower/
│ │ │ └── Lower.cs
│ │ ├── MapPatch/
│ │ │ └── HashMapPatch.cs
│ │ ├── Next/
│ │ │ ├── Next.Module.cs
│ │ │ └── Next.cs
│ │ ├── Patch/
│ │ │ ├── Edit.cs
│ │ │ ├── Patch.Internal.cs
│ │ │ ├── Patch.Module.cs
│ │ │ ├── Patch.cs
│ │ │ └── PatchParams.cs
│ │ ├── Pure/
│ │ │ ├── Pure.Extensions.cs
│ │ │ └── Pure.cs
│ │ ├── README.md
│ │ ├── Range/
│ │ │ ├── Range.Extensions.cs
│ │ │ ├── Range.Module.cs
│ │ │ ├── Range.Monad.cs
│ │ │ └── Range.cs
│ │ ├── Ratio/
│ │ │ └── Ratio.cs
│ │ ├── Record/
│ │ │ ├── Attributes.cs
│ │ │ ├── Record.cs
│ │ │ ├── RecordType.cs
│ │ │ ├── RecordTypeIgnoreBase.cs
│ │ │ └── TypeInfoExt.cs
│ │ ├── SpanArray/
│ │ │ └── SpanArray.cs
│ │ ├── StringM/
│ │ │ ├── OrdString.cs
│ │ │ ├── StringM.Ord.cs
│ │ │ ├── StringM.Trait.cs
│ │ │ └── StringM.cs
│ │ ├── Unit/
│ │ │ ├── Unit.Prelude.cs
│ │ │ └── Unit.cs
│ │ └── ValueTuple/
│ │ ├── Tuple1/
│ │ │ ├── ValueTuple1.Extensions.cs
│ │ │ └── ValueTuple1.Prelude.cs
│ │ ├── Tuple2/
│ │ │ ├── ValueTuple2.Extensions.cs
│ │ │ └── ValueTuple2.Prelude.cs
│ │ ├── Tuple3/
│ │ │ ├── ValueTuple3.Extensions.cs
│ │ │ └── ValueTuple3.Prelude.cs
│ │ ├── Tuple4/
│ │ │ ├── ValueTuple4.Extensions.cs
│ │ │ └── ValueTuple4.Prelude.cs
│ │ ├── Tuple5/
│ │ │ ├── ValueTuple5.Extensions.cs
│ │ │ └── ValueTuple5.Prelude.cs
│ │ ├── Tuple6/
│ │ │ ├── ValueTuple6.Extensions.cs
│ │ │ └── ValueTuple6.Prelude.cs
│ │ └── Tuple7/
│ │ ├── ValueTuple7.Extensions.cs
│ │ └── ValueTuple7.Prelude.cs
│ ├── Deriving/
│ │ ├── Alternative.cs
│ │ ├── Applicative.cs
│ │ ├── Choice.cs
│ │ ├── Cofunctor.cs
│ │ ├── Decidable.cs
│ │ ├── Divisible.cs
│ │ ├── Fallible.cs
│ │ ├── Final.cs
│ │ ├── Foldable.cs
│ │ ├── Functor.cs
│ │ ├── Maybe/
│ │ │ ├── MonadIO.cs
│ │ │ └── MonadUnliftIO.cs
│ │ ├── Monad.cs
│ │ ├── MonadIO.cs
│ │ ├── MonadT.cs
│ │ ├── MonadUnliftIO.cs
│ │ ├── MonoidK.cs
│ │ ├── Readable.cs
│ │ ├── SemigroupK.cs
│ │ ├── Stateful.cs
│ │ ├── Traversable.cs
│ │ └── Writable.cs
│ ├── Effects/
│ │ ├── Eff/
│ │ │ ├── Eff no runtime/
│ │ │ │ ├── Eff.Module.cs
│ │ │ │ ├── Eff.Monad.cs
│ │ │ │ ├── Eff.cs
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Eff.Extensions.MapApply.cs
│ │ │ │ │ ├── Eff.Extensions.cs
│ │ │ │ │ └── Eff.Guard.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Eff.Operators.Applicative.cs
│ │ │ │ │ ├── Eff.Operators.Choice.cs
│ │ │ │ │ ├── Eff.Operators.Fallible.cs
│ │ │ │ │ ├── Eff.Operators.Final.cs
│ │ │ │ │ ├── Eff.Operators.Functor.cs
│ │ │ │ │ ├── Eff.Operators.Monad.cs
│ │ │ │ │ └── Eff.Operators.cs
│ │ │ │ └── Prelude/
│ │ │ │ ├── Eff.Prelude.cs
│ │ │ │ └── Eff.Prelude.mapapply.cs
│ │ │ └── Eff with runtime/
│ │ │ ├── Eff.Module.cs
│ │ │ ├── Eff.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── Eff.Extensions.MapApply.cs
│ │ │ │ ├── Eff.Extensions.cs
│ │ │ │ └── Eff.Guard.cs
│ │ │ ├── Operators/
│ │ │ │ ├── Eff.Operators.Applicative.cs
│ │ │ │ ├── Eff.Operators.Choice.cs
│ │ │ │ ├── Eff.Operators.Fallible.cs
│ │ │ │ ├── Eff.Operators.Final.cs
│ │ │ │ ├── Eff.Operators.Functor.cs
│ │ │ │ ├── Eff.Operators.Monad.cs
│ │ │ │ └── Eff.Operators.cs
│ │ │ └── Prelude/
│ │ │ ├── Eff.Prelude.cs
│ │ │ └── Eff.Prelude.mapapply.cs
│ │ ├── IO/
│ │ │ ├── DSL/
│ │ │ │ ├── IOAction.cs
│ │ │ │ ├── IOActions.cs
│ │ │ │ ├── IOActionsAsync.cs
│ │ │ │ ├── IOApply.cs
│ │ │ │ ├── IOBind.cs
│ │ │ │ ├── IOBindAsync.cs
│ │ │ │ ├── IOBindMap.cs
│ │ │ │ ├── IOCatch.cs
│ │ │ │ ├── IOCatchPop.cs
│ │ │ │ ├── IOEmpty.cs
│ │ │ │ ├── IOFail.cs
│ │ │ │ ├── IOFinal.cs
│ │ │ │ ├── IOFold.cs
│ │ │ │ ├── IOFoldUntil.cs
│ │ │ │ ├── IOFoldWhile.cs
│ │ │ │ ├── IOLiftAsync.cs
│ │ │ │ ├── IOLiftSync.cs
│ │ │ │ ├── IOLocal2.cs
│ │ │ │ ├── IOMap.cs
│ │ │ │ ├── IOPure.cs
│ │ │ │ ├── IOPureAsync.cs
│ │ │ │ ├── IOTail.cs
│ │ │ │ ├── IOTimeout.cs
│ │ │ │ ├── IOToken.cs
│ │ │ │ ├── IOUninterruptible.cs
│ │ │ │ ├── IOUse.cs
│ │ │ │ ├── InvokeAsync.cs
│ │ │ │ ├── InvokeAsyncIO.cs
│ │ │ │ ├── InvokeSync.cs
│ │ │ │ └── InvokeSyncIO.cs
│ │ │ ├── EnvIO.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── IO.Extensions.MapApply.cs
│ │ │ │ ├── IO.Extensions.cs
│ │ │ │ └── IO.Guard.cs
│ │ │ ├── ForkIO.cs
│ │ │ ├── IO.Module.cs
│ │ │ ├── IO.Monad.cs
│ │ │ ├── IO.cs
│ │ │ ├── Operators/
│ │ │ │ ├── IO.Operators.Applicative.cs
│ │ │ │ ├── IO.Operators.Choice.cs
│ │ │ │ ├── IO.Operators.Fallible.cs
│ │ │ │ ├── IO.Operators.Final.cs
│ │ │ │ ├── IO.Operators.Functor.cs
│ │ │ │ ├── IO.Operators.Monad.cs
│ │ │ │ └── IO.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ ├── IO.Prelude.Concurreny.cs
│ │ │ │ ├── IO.Prelude.cs
│ │ │ │ └── IO.Prelude.mapapply.cs
│ │ │ └── Resources.cs
│ │ ├── MinRT.cs
│ │ ├── Prelude.cs
│ │ ├── README.md
│ │ └── Schedule/
│ │ ├── Duration.cs
│ │ ├── Schedule.Constructors.cs
│ │ ├── Schedule.DSL.cs
│ │ ├── Schedule.Extensions.cs
│ │ ├── Schedule.Prelude.cs
│ │ ├── Schedule.cs
│ │ ├── ScheduleTransformer.cs
│ │ └── SingletonRandom.cs
│ ├── Exceptions/
│ │ └── Exceptions.cs
│ ├── Extensions/
│ │ ├── ActionObservable.cs
│ │ ├── Compose.cs
│ │ ├── FuncExtensions.cs
│ │ ├── ObjectExt.cs
│ │ ├── ObservableExt.cs
│ │ ├── Query.cs
│ │ ├── TryOutExt.cs
│ │ └── UnsafeValueAccess.cs
│ ├── Guard.cs
│ ├── Immutable Collections/
│ │ ├── Arr/
│ │ │ ├── Arr.Module.cs
│ │ │ ├── Arr.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── Arr.Extensions.MapApply.cs
│ │ │ │ └── Arr.Extensions.cs
│ │ │ ├── Operators/
│ │ │ │ └── Arr.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Arr.Prelude.mapapply.cs
│ │ │ └── Trait/
│ │ │ └── Arr.TraitImpl.cs
│ │ ├── BiMap/
│ │ │ └── BiMap.cs
│ │ ├── HashMap/
│ │ │ ├── HashMap.Eq.cs
│ │ │ ├── HashMap.Extensions.Eq.cs
│ │ │ ├── HashMap.Extensions.MapApply.cs
│ │ │ ├── HashMap.Extensions.cs
│ │ │ ├── HashMap.Module.Eq.cs
│ │ │ ├── HashMap.Module.cs
│ │ │ ├── HashMap.Prelude.mapapply.cs
│ │ │ ├── HashMap.Trait.Implementations.Eq.cs
│ │ │ ├── HashMap.Trait.Implementations.cs
│ │ │ └── HashMap.cs
│ │ ├── HashSet/
│ │ │ ├── Extensions/
│ │ │ │ ├── HashSet.Extensions.MapApply.cs
│ │ │ │ └── HashSet.Extensions.cs
│ │ │ ├── HashSet.Eq.cs
│ │ │ ├── HashSet.Module.Eq.cs
│ │ │ ├── HashSet.Module.cs
│ │ │ ├── HashSet.cs
│ │ │ ├── Operators/
│ │ │ │ └── HashSet.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── HashSet.Prelude.mapapply.cs
│ │ │ └── Trait/
│ │ │ └── HashSet.TraitImpl.cs
│ │ ├── Iterable/
│ │ │ ├── DSL/
│ │ │ │ ├── Iterable.Add.cs
│ │ │ │ ├── Iterable.AsyncEnumerable.cs
│ │ │ │ ├── Iterable.Cast.cs
│ │ │ │ ├── Iterable.Concat.cs
│ │ │ │ ├── Iterable.Enumerable.cs
│ │ │ │ ├── Iterable.Nil.cs
│ │ │ │ ├── Iterable.Singleton.cs
│ │ │ │ ├── Iterable.SingletonIO.cs
│ │ │ │ ├── Iterable.Strict.cs
│ │ │ │ └── Iterable.Zip.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── Iterable.Extensions.MapApply.cs
│ │ │ │ └── Iterable.Extensions.cs
│ │ │ ├── Iterable.Module.cs
│ │ │ ├── Iterable.cs
│ │ │ ├── Operators/
│ │ │ │ └── Iterable.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Iterable.Prelude.mapapply.cs
│ │ │ └── Trait/
│ │ │ └── Iterable.TraitImpl.cs
│ │ ├── IterableNE/
│ │ │ ├── Extensions/
│ │ │ │ ├── IterableNE.Extensions.MapApply.cs
│ │ │ │ └── IterableNE.Extensions.cs
│ │ │ ├── IterableNE.Module.cs
│ │ │ ├── IterableNE.cs
│ │ │ ├── Operators/
│ │ │ │ └── IterableNE.Operators.cs
│ │ │ └── Trait/
│ │ │ └── IterableNE.TraitImpl.cs
│ │ ├── Iterator/
│ │ │ ├── DSL/
│ │ │ │ ├── Iterator.Cons.cs
│ │ │ │ ├── Iterator.ConsFirst.cs
│ │ │ │ ├── Iterator.ConsValue.cs
│ │ │ │ ├── Iterator.ConsValueEnum.cs
│ │ │ │ ├── Iterator.ConsValueLazy.cs
│ │ │ │ └── Iterator.Nil.cs
│ │ │ ├── Extensions/
│ │ │ │ └── Iterator.Extensions.cs
│ │ │ ├── Iterator.Module.cs
│ │ │ ├── Iterator.cs
│ │ │ ├── Operators/
│ │ │ │ └── Iterator.Operators.cs
│ │ │ ├── README.md
│ │ │ └── Trait/
│ │ │ └── Iterator.TraitImpl.cs
│ │ ├── IteratorAsync/
│ │ │ ├── DSL/
│ │ │ │ ├── IteratorAsync.Cons.cs
│ │ │ │ ├── IteratorAsync.ConsFirst.cs
│ │ │ │ ├── IteratorAsync.ConsValue.cs
│ │ │ │ ├── IteratorAsync.ConsValueEnum.cs
│ │ │ │ ├── IteratorAsync.ConsValueLazy.cs
│ │ │ │ └── IteratorAsync.Nil.cs
│ │ │ ├── Extensions/
│ │ │ │ └── IteratorAsync.Extensions.cs
│ │ │ ├── IteratorAsync.Module.cs
│ │ │ ├── IteratorAsync.cs
│ │ │ ├── Operators/
│ │ │ │ └── IteratorAsync.Operators.cs
│ │ │ ├── README.md
│ │ │ └── Trait/
│ │ │ └── IteratorAsync.TraitImpl.cs
│ │ ├── List/
│ │ │ ├── Extensions/
│ │ │ │ ├── Lst.Extensions.MapApply.cs
│ │ │ │ └── Lst.Extensions.cs
│ │ │ ├── Internal/
│ │ │ │ └── Lst.Internal.cs
│ │ │ ├── ListInfo.cs
│ │ │ ├── Lst.Module.cs
│ │ │ ├── Lst.cs
│ │ │ ├── Operators/
│ │ │ │ └── Lst.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Lst.Prelude.mapapply.cs
│ │ │ └── Trait/
│ │ │ └── Lst.TraitImpl.cs
│ │ ├── Map/
│ │ │ ├── Map.EnumeratorK.cs
│ │ │ ├── Map.EnumeratorKV.cs
│ │ │ ├── Map.EnumeratorV.cs
│ │ │ ├── Map.Extensions.MapApply.cs
│ │ │ ├── Map.Extensions.Ord.cs
│ │ │ ├── Map.Extensions.cs
│ │ │ ├── Map.Internal.cs
│ │ │ ├── Map.Module.Ord.cs
│ │ │ ├── Map.Module.cs
│ │ │ ├── Map.Ord.cs
│ │ │ ├── Map.Prelude.mapapply.cs
│ │ │ ├── Map.Trait.Implementations.cs
│ │ │ └── Map.cs
│ │ ├── Prelude.Collections.cs
│ │ ├── Queue/
│ │ │ ├── Que.Internal.cs
│ │ │ ├── Que.cs
│ │ │ └── Queue.Module.cs
│ │ ├── README.md
│ │ ├── Seq/
│ │ │ ├── DSL/
│ │ │ │ ├── Enum.cs
│ │ │ │ ├── ISeqInternal.cs
│ │ │ │ ├── SeqConcat.cs
│ │ │ │ ├── SeqEmptyInternal.cs
│ │ │ │ ├── SeqLazy.cs
│ │ │ │ └── SeqStrict.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── Seq.Extensions.MapApply.cs
│ │ │ │ └── Seq.Extensions.cs
│ │ │ ├── Operators/
│ │ │ │ └── Seq.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Seq.Prelude.mapapply.cs
│ │ │ ├── Seq.Module.cs
│ │ │ ├── Seq.cs
│ │ │ ├── SeqEmpty.cs
│ │ │ ├── SeqLoan.cs
│ │ │ └── Trait/
│ │ │ └── Seq.TraitImpl.cs
│ │ ├── Set/
│ │ │ ├── Extensions/
│ │ │ │ ├── Set.Extensions.MapApply.cs
│ │ │ │ └── Set.Extensions.cs
│ │ │ ├── Internal/
│ │ │ │ └── Set.Internal.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Set.Prelude.mapapply.cs
│ │ │ ├── Set.Module.cs
│ │ │ ├── Set.Ord.Module.cs
│ │ │ ├── Set.Ord.cs
│ │ │ ├── Set.cs
│ │ │ └── Trait/
│ │ │ └── Set.TraitImpl.cs
│ │ ├── Stack/
│ │ │ ├── Stack.Extensions.cs
│ │ │ ├── Stack.Module.cs
│ │ │ ├── Stck.Internal.cs
│ │ │ └── Stck.cs
│ │ ├── TrackingHashMap/
│ │ │ ├── TrackingHashMap.Eq.cs
│ │ │ ├── TrackingHashMap.Extensions.Eq.cs
│ │ │ ├── TrackingHashMap.Extensions.cs
│ │ │ ├── TrackingHashMap.Module.Eq.cs
│ │ │ ├── TrackingHashMap.Module.cs
│ │ │ └── TrackingHashMap.cs
│ │ ├── TrieMap/
│ │ │ └── TrieMap.cs
│ │ └── TrieSet/
│ │ └── TrieSet.cs
│ ├── LanguageExt.Core.csproj
│ ├── Lens/
│ │ ├── Lens.Operators.cs
│ │ ├── Lens.cs
│ │ ├── LensAB.cs
│ │ ├── Prelude.Lens.cs
│ │ └── README.md
│ ├── Memo/
│ │ ├── Extensions/
│ │ │ └── Memo.Extensions.cs
│ │ ├── Memo.F.cs
│ │ ├── Memo.Module.cs
│ │ ├── Memo.cs
│ │ ├── Operators/
│ │ │ └── Memo.Operators.cs
│ │ └── Prelude.Memoize.cs
│ ├── Monads/
│ │ ├── Alternative Monads/
│ │ │ ├── ChronicleT/
│ │ │ │ ├── ChronicleT.Module.2.cs
│ │ │ │ ├── ChronicleT.Module.cs
│ │ │ │ ├── ChronicleT.cs
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── ChronicleT.Extensions.cs
│ │ │ │ │ └── ChronicleT.Guard.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── ChronicleT.Operators.Applicative.cs
│ │ │ │ │ ├── ChronicleT.Operators.Choice.cs
│ │ │ │ │ ├── ChronicleT.Operators.Fallible.cs
│ │ │ │ │ ├── ChronicleT.Operators.Final.cs
│ │ │ │ │ ├── ChronicleT.Operators.Functor.cs
│ │ │ │ │ ├── ChronicleT.Operators.Monad.cs
│ │ │ │ │ ├── ChronicleT.Operators.SemigroupK.cs
│ │ │ │ │ └── ChronicleT.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── ChronicleT.Prelude.cs
│ │ │ │ └── Trait/
│ │ │ │ ├── ChronicleT.TraitImpl.2.cs
│ │ │ │ └── ChronicleT.TraitImpl.cs
│ │ │ ├── Either/
│ │ │ │ ├── Either.Left.cs
│ │ │ │ ├── Either.Module.cs
│ │ │ │ ├── Either.Right.cs
│ │ │ │ ├── Either.cs
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Either.Extensions.Apply.cs
│ │ │ │ │ ├── Either.Extensions.Map.cs
│ │ │ │ │ ├── Either.Extensions.cs
│ │ │ │ │ └── Either.Guard.cs
│ │ │ │ ├── IEither.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Either.Operators.Applicative.cs
│ │ │ │ │ ├── Either.Operators.Choice.cs
│ │ │ │ │ ├── Either.Operators.Fallible.cs
│ │ │ │ │ ├── Either.Operators.Functor.cs
│ │ │ │ │ ├── Either.Operators.Monad.cs
│ │ │ │ │ └── Either.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ ├── Either.Prelude.cs
│ │ │ │ │ └── Either.Prelude.mapapply.cs
│ │ │ │ ├── README.md
│ │ │ │ └── Trait/
│ │ │ │ ├── Either.TraitImpl.2.cs
│ │ │ │ └── Either.TraitImpl.cs
│ │ │ ├── EitherT/
│ │ │ │ ├── EitherT.Module.cs
│ │ │ │ ├── EitherT.cs
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── EitherT.Extensions.Apply.cs
│ │ │ │ │ ├── EitherT.Extensions.Map.cs
│ │ │ │ │ ├── EitherT.Extensions.cs
│ │ │ │ │ └── EitherT.Guard.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── EitherT.Operators.Applicative.cs
│ │ │ │ │ ├── EitherT.Operators.Choice.cs
│ │ │ │ │ ├── EitherT.Operators.Fallible.cs
│ │ │ │ │ ├── EitherT.Operators.Final.cs
│ │ │ │ │ ├── EitherT.Operators.Functor.cs
│ │ │ │ │ ├── EitherT.Operators.Monad.cs
│ │ │ │ │ ├── EitherT.Operators.SemigroupK.cs
│ │ │ │ │ └── EitherT.Operators.cs
│ │ │ │ └── Trait/
│ │ │ │ ├── EitherT.TraitImpl.2.cs
│ │ │ │ └── EitherT.TraitImpl.cs
│ │ │ ├── Fin/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Fin.Extensions.Apply.cs
│ │ │ │ │ ├── Fin.Extensions.Map.cs
│ │ │ │ │ ├── Fin.Extensions.cs
│ │ │ │ │ └── Fin.Guard.cs
│ │ │ │ ├── Fin.Fail.cs
│ │ │ │ ├── Fin.Module.cs
│ │ │ │ ├── Fin.Succ.cs
│ │ │ │ ├── Fin.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Fin.Operators.Applicative.cs
│ │ │ │ │ ├── Fin.Operators.Choice.cs
│ │ │ │ │ ├── Fin.Operators.Fallible.cs
│ │ │ │ │ ├── Fin.Operators.Functor.cs
│ │ │ │ │ ├── Fin.Operators.Monad.cs
│ │ │ │ │ ├── Fin.Operators.SemigroupK.cs
│ │ │ │ │ └── Fin.Operators.cs
│ │ │ │ ├── README.md
│ │ │ │ └── Trait/
│ │ │ │ └── Fin.TraitImpl.cs
│ │ │ ├── FinT/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── FinT.Extensions.Apply.cs
│ │ │ │ │ ├── FinT.Extensions.Map.cs
│ │ │ │ │ ├── FinT.Extensions.cs
│ │ │ │ │ └── FinT.Guard.cs
│ │ │ │ ├── FinT.Module.cs
│ │ │ │ ├── FinT.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── FinT.Operators.Applicative.cs
│ │ │ │ │ ├── FinT.Operators.Choice.cs
│ │ │ │ │ ├── FinT.Operators.Fallible.cs
│ │ │ │ │ ├── FinT.Operators.Final.cs
│ │ │ │ │ ├── FinT.Operators.Functor.cs
│ │ │ │ │ ├── FinT.Operators.Monad.cs
│ │ │ │ │ ├── FinT.Operators.SemigroupK.cs
│ │ │ │ │ └── FinT.Operators.cs
│ │ │ │ └── Trait/
│ │ │ │ └── FinT.TraitImpl.cs
│ │ │ ├── Nullable/
│ │ │ │ ├── Nullable.Prelude.cs
│ │ │ │ └── README.md
│ │ │ ├── Option/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Option.Extensions.MapApply.cs
│ │ │ │ │ └── Option.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Option.Operators.Applicative.cs
│ │ │ │ │ ├── Option.Operators.Choice.cs
│ │ │ │ │ ├── Option.Operators.Fallible.cs
│ │ │ │ │ ├── Option.Operators.Functor.cs
│ │ │ │ │ ├── Option.Operators.Monad.cs
│ │ │ │ │ └── Option.Operators.cs
│ │ │ │ ├── Option.Module.cs
│ │ │ │ ├── Option.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ ├── Option.Prelude.cs
│ │ │ │ │ └── Option.Prelude.mapapply.cs
│ │ │ │ ├── README.md
│ │ │ │ ├── Shared/
│ │ │ │ │ ├── IOptional.cs
│ │ │ │ │ ├── SomeContext.cs
│ │ │ │ │ └── SomeUnitContext.cs
│ │ │ │ └── Trait/
│ │ │ │ └── Option.TraitImpl.cs
│ │ │ ├── OptionT/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── OptionT.Extensions.MapApply.cs
│ │ │ │ │ └── OptionT.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── OptionT.Operators.Applicative.cs
│ │ │ │ │ ├── OptionT.Operators.Choice.cs
│ │ │ │ │ ├── OptionT.Operators.Fallible.cs
│ │ │ │ │ ├── OptionT.Operators.Final.cs
│ │ │ │ │ ├── OptionT.Operators.Functor.cs
│ │ │ │ │ ├── OptionT.Operators.Monad.cs
│ │ │ │ │ ├── OptionT.Operators.SemigroupK.cs
│ │ │ │ │ └── OptionT.Operators.cs
│ │ │ │ ├── OptionT.Module.cs
│ │ │ │ ├── OptionT.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── OptionT.Prelude.mapapply.cs
│ │ │ │ └── Trait/
│ │ │ │ └── OptionT.TraitImpl.cs
│ │ │ ├── README.md
│ │ │ ├── These/
│ │ │ │ ├── Extensions/
│ │ │ │ │ └── These.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── These.Operators.Functor.cs
│ │ │ │ │ ├── These.Operators.SemigroupK.cs
│ │ │ │ │ └── These.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── These.Prelude.cs
│ │ │ │ ├── These.Both.cs
│ │ │ │ ├── These.Module.cs
│ │ │ │ ├── These.That.cs
│ │ │ │ ├── These.This.cs
│ │ │ │ ├── These.cs
│ │ │ │ └── Trait/
│ │ │ │ └── These.TraitImpl.cs
│ │ │ ├── Try/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Try.Extensions.MapApply.cs
│ │ │ │ │ └── Try.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Try.Operators.Applicative.cs
│ │ │ │ │ ├── Try.Operators.Choice.cs
│ │ │ │ │ ├── Try.Operators.Fallible.cs
│ │ │ │ │ ├── Try.Operators.Final.cs
│ │ │ │ │ ├── Try.Operators.Functor.cs
│ │ │ │ │ ├── Try.Operators.Monad.cs
│ │ │ │ │ └── Try.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── Try.Prelude.mapapply.cs
│ │ │ │ ├── Trait/
│ │ │ │ │ └── Try.TraitImpl.cs
│ │ │ │ ├── Try.Module.cs
│ │ │ │ └── Try.cs
│ │ │ ├── TryT/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── TryT.Extensions.MapApply.cs
│ │ │ │ │ └── TryT.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── TryT.Operators.Applicative.cs
│ │ │ │ │ ├── TryT.Operators.Choice.cs
│ │ │ │ │ ├── TryT.Operators.Fallible.cs
│ │ │ │ │ ├── TryT.Operators.Functor.cs
│ │ │ │ │ ├── TryT.Operators.Monad.cs
│ │ │ │ │ └── TryT.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── TryT.Prelude.mapapply.cs
│ │ │ │ ├── Trait/
│ │ │ │ │ └── TryT.TraitImpl.cs
│ │ │ │ ├── TryT.Module.cs
│ │ │ │ └── TryT.cs
│ │ │ ├── Validation/
│ │ │ │ ├── Extensions/
│ │ │ │ │ ├── Validation.Extensions.Apply.cs
│ │ │ │ │ ├── Validation.Extensions.Map.cs
│ │ │ │ │ ├── Validation.Extensions.cs
│ │ │ │ │ └── Validation.Guard.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Validation.Operators.Applicative.cs
│ │ │ │ │ ├── Validation.Operators.Choice.cs
│ │ │ │ │ ├── Validation.Operators.Combine.cs
│ │ │ │ │ ├── Validation.Operators.CombineSeq.cs
│ │ │ │ │ ├── Validation.Operators.Fallible.cs
│ │ │ │ │ ├── Validation.Operators.Functor.cs
│ │ │ │ │ ├── Validation.Operators.Monad.cs
│ │ │ │ │ └── Validation.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ ├── Validation.Prelude.apply.cs
│ │ │ │ │ ├── Validation.Prelude.cs
│ │ │ │ │ └── Validation.Prelude.map.cs
│ │ │ │ ├── Trait/
│ │ │ │ │ ├── Validation.TraitImpl.2.cs
│ │ │ │ │ └── Validation.TraitImpl.cs
│ │ │ │ ├── Validation.Fail.cs
│ │ │ │ ├── Validation.Module.cs
│ │ │ │ ├── Validation.Success.cs
│ │ │ │ └── Validation.cs
│ │ │ └── ValidationT/
│ │ │ ├── Extensions/
│ │ │ │ ├── ValidationT.Extensions.Apply.cs
│ │ │ │ ├── ValidationT.Extensions.Map.cs
│ │ │ │ ├── ValidationT.Extensions.cs
│ │ │ │ └── ValidationT.Guard.cs
│ │ │ ├── Operators/
│ │ │ │ ├── ValidationT.Operators.Applicative.cs
│ │ │ │ ├── ValidationT.Operators.Choice.cs
│ │ │ │ ├── ValidationT.Operators.Combine.cs
│ │ │ │ ├── ValidationT.Operators.Fallible.cs
│ │ │ │ ├── ValidationT.Operators.Functor.cs
│ │ │ │ ├── ValidationT.Operators.Monad.cs
│ │ │ │ └── ValidationT.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── ValidationT.Prelude.mapapply.cs
│ │ │ ├── Trait/
│ │ │ │ ├── ValidationT.TraitImpl.2.cs
│ │ │ │ └── ValidationT.TraitImpl.cs
│ │ │ ├── ValidationT.Module.cs
│ │ │ └── ValidationT.cs
│ │ ├── ContT/
│ │ │ ├── ContT.Module.cs
│ │ │ ├── ContT.cs
│ │ │ └── README.md
│ │ ├── Free/
│ │ │ ├── Extensions/
│ │ │ │ ├── Free.Extensions.MapApply.cs
│ │ │ │ └── Free.Extensions.cs
│ │ │ ├── Free.Module.cs
│ │ │ ├── Free.cs
│ │ │ ├── Operators/
│ │ │ │ ├── Free.Operators.Applicative.cs
│ │ │ │ ├── Free.Operators.Functor.cs
│ │ │ │ ├── Free.Operators.Monad.cs
│ │ │ │ └── Free.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Free.Prelude.mapapply.cs
│ │ │ └── Trait/
│ │ │ └── Free.TraitImpl.cs
│ │ ├── Identity/
│ │ │ ├── Extensions/
│ │ │ │ └── Identity.Extensions.cs
│ │ │ ├── Identity.Module.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Operators/
│ │ │ │ └── Identity.Operators.cs
│ │ │ └── Trait/
│ │ │ └── Identity.TraitImpl.cs
│ │ ├── IdentityT/
│ │ │ ├── IdentityT.Extensions.cs
│ │ │ ├── IdentityT.Module.cs
│ │ │ ├── IdentityT.Monad.cs
│ │ │ └── IdentityT.cs
│ │ ├── Lifting/
│ │ │ ├── Lift.Extensions.cs
│ │ │ ├── Lift.Prelude.cs
│ │ │ └── Lift.cs
│ │ ├── Monadic conditionals/
│ │ │ ├── Prelude.guard.cs
│ │ │ ├── Prelude.guardnot.cs
│ │ │ ├── Prelude.iff.cs
│ │ │ ├── Prelude.unless.cs
│ │ │ ├── Prelude.when.cs
│ │ │ └── README.md
│ │ ├── Prelude.cs
│ │ ├── README.md
│ │ ├── State and Environment Monads/
│ │ │ ├── RWS/
│ │ │ │ └── RWST/
│ │ │ │ ├── Extensions/
│ │ │ │ │ └── RWST.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── RWST.Operators.Applicative.cs
│ │ │ │ │ ├── RWST.Operators.Choice.cs
│ │ │ │ │ ├── RWST.Operators.Fallible.cs
│ │ │ │ │ ├── RWST.Operators.Final.cs
│ │ │ │ │ ├── RWST.Operators.Functor.cs
│ │ │ │ │ ├── RWST.Operators.Monad.cs
│ │ │ │ │ ├── RWST.Operators.SemigroupK.cs
│ │ │ │ │ └── RWST.Operators.cs
│ │ │ │ ├── RWST.Module.cs
│ │ │ │ ├── RWST.cs
│ │ │ │ └── Trait/
│ │ │ │ └── RWST.TraitImpl.cs
│ │ │ ├── Reader/
│ │ │ │ ├── Ask.cs
│ │ │ │ ├── Reader/
│ │ │ │ │ ├── Extensions/
│ │ │ │ │ │ └── Reader.Extensions.cs
│ │ │ │ │ ├── Operators/
│ │ │ │ │ │ ├── Reader.Operators.Applicative.cs
│ │ │ │ │ │ ├── Reader.Operators.Functor.cs
│ │ │ │ │ │ ├── Reader.Operators.Monad.cs
│ │ │ │ │ │ └── Reader.Operators.cs
│ │ │ │ │ ├── Reader.Module.cs
│ │ │ │ │ ├── Reader.cs
│ │ │ │ │ └── Trait/
│ │ │ │ │ └── Reader.TraitImpl.cs
│ │ │ │ └── ReaderT/
│ │ │ │ ├── Extensions/
│ │ │ │ │ └── ReaderT.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── ReaderT.Operators.Applicative.cs
│ │ │ │ │ ├── ReaderT.Operators.Choice.cs
│ │ │ │ │ ├── ReaderT.Operators.Fallible.cs
│ │ │ │ │ ├── ReaderT.Operators.Final.cs
│ │ │ │ │ ├── ReaderT.Operators.Functor.cs
│ │ │ │ │ ├── ReaderT.Operators.Monad.cs
│ │ │ │ │ ├── ReaderT.Operators.SemigroupK.cs
│ │ │ │ │ └── ReaderT.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── ReaderT.Prelude.mapapply.cs
│ │ │ │ ├── ReaderT.Module.cs
│ │ │ │ ├── ReaderT.cs
│ │ │ │ └── Trait/
│ │ │ │ └── ReaderT.TraitImpl.cs
│ │ │ ├── State/
│ │ │ │ ├── PutGet.cs
│ │ │ │ ├── State/
│ │ │ │ │ ├── Extensions/
│ │ │ │ │ │ └── State.Extensions.cs
│ │ │ │ │ ├── Operators/
│ │ │ │ │ │ ├── State.Operators.Applicative.cs
│ │ │ │ │ │ ├── State.Operators.Functor.cs
│ │ │ │ │ │ ├── State.Operators.Monad.cs
│ │ │ │ │ │ └── State.Operators.cs
│ │ │ │ │ ├── State.Module.cs
│ │ │ │ │ ├── State.cs
│ │ │ │ │ └── Trait/
│ │ │ │ │ └── State.TraitImpl.cs
│ │ │ │ └── StateT/
│ │ │ │ ├── Extensions/
│ │ │ │ │ └── StateT.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── StateT.Operators.Applicative.cs
│ │ │ │ │ ├── StateT.Operators.Choice.cs
│ │ │ │ │ ├── StateT.Operators.Fallible.cs
│ │ │ │ │ ├── StateT.Operators.Final.cs
│ │ │ │ │ ├── StateT.Operators.Functor.cs
│ │ │ │ │ ├── StateT.Operators.Monad.cs
│ │ │ │ │ ├── StateT.Operators.SemigroupK.cs
│ │ │ │ │ └── StateT.Operators.cs
│ │ │ │ ├── StateT.Module.cs
│ │ │ │ ├── StateT.cs
│ │ │ │ └── Trait/
│ │ │ │ └── StateT.TraitImpl.cs
│ │ │ └── Writer/
│ │ │ ├── Tell.cs
│ │ │ ├── Writer/
│ │ │ │ ├── Extensions/
│ │ │ │ │ └── Writer.Extensions.cs
│ │ │ │ ├── Operators/
│ │ │ │ │ ├── Writer.Operators.Applicative.cs
│ │ │ │ │ ├── Writer.Operators.Functor.cs
│ │ │ │ │ ├── Writer.Operators.Monad.cs
│ │ │ │ │ └── Writer.Operators.cs
│ │ │ │ ├── Prelude/
│ │ │ │ │ └── Writer.Prelude.cs
│ │ │ │ ├── Trait/
│ │ │ │ │ └── Writer.TraitImpl.cs
│ │ │ │ ├── Writer.Module.cs
│ │ │ │ └── Writer.cs
│ │ │ └── WriterT/
│ │ │ ├── Extensions/
│ │ │ │ └── WriterT.Extensions.cs
│ │ │ ├── Operators/
│ │ │ │ ├── WriterT.Operators.Applicative.cs
│ │ │ │ ├── WriterT.Operators.Choice.cs
│ │ │ │ ├── WriterT.Operators.Fallible.cs
│ │ │ │ ├── WriterT.Operators.Final.cs
│ │ │ │ ├── WriterT.Operators.Functor.cs
│ │ │ │ ├── WriterT.Operators.Monad.cs
│ │ │ │ ├── WriterT.Operators.SemigroupK.cs
│ │ │ │ └── WriterT.Operators.cs
│ │ │ ├── Trait/
│ │ │ │ └── WriterT.TraitImpl.cs
│ │ │ ├── WriterT.Module.cs
│ │ │ └── WriterT.cs
│ │ └── Trampoline/
│ │ └── Trampoline.cs
│ ├── Number.cs
│ ├── Obsolete and Deprecated/
│ │ ├── Change.cs
│ │ └── Fin.Prelude.cs
│ ├── Opt.cs
│ ├── Prelude/
│ │ ├── Currying and Partial Application/
│ │ │ ├── Prelude.Curry.cs
│ │ │ ├── Prelude.PartialApplication.cs
│ │ │ └── Prelude.Uncurry.cs
│ │ ├── Function argument flipping/
│ │ │ └── Prelude.Flip.cs
│ │ ├── Hash code functions/
│ │ │ └── Prelude.Hash.cs
│ │ ├── Lambda function inference/
│ │ │ └── Prelude.Func.cs
│ │ ├── Prelude.cs
│ │ ├── README.md
│ │ ├── Random/
│ │ │ └── Prelude.Random.cs
│ │ ├── Resources/
│ │ │ └── Prelude.Resources.cs
│ │ ├── Timer/
│ │ │ └── Prelude.Timer.cs
│ │ └── Value parsing/
│ │ └── Prelude.Parse.cs
│ ├── Pretty/
│ │ ├── Doc.cs
│ │ ├── DocAnn.cs
│ │ ├── DocStream.cs
│ │ ├── Doc_A.cs
│ │ ├── FastSpace.cs
│ │ ├── FittingPredicate.cs
│ │ ├── FlattenResult.cs
│ │ ├── Layout.cs
│ │ ├── LayoutOptions.cs
│ │ ├── LayoutPipeline.cs
│ │ └── PageWidth.cs
│ ├── Prism/
│ │ ├── Prelude_Prism.cs
│ │ ├── Prism.cs
│ │ ├── PrismAB.cs
│ │ └── README.md
│ ├── README.md
│ ├── README.nuget.md
│ ├── Traits/
│ │ ├── Alternative/
│ │ │ ├── Alternative.Extensions.cs
│ │ │ ├── Alternative.Laws.cs
│ │ │ ├── Alternative.Module.cs
│ │ │ ├── Alternative.Prelude.cs
│ │ │ ├── Alternative.Trait.cs
│ │ │ └── README.md
│ │ ├── Applicative/
│ │ │ ├── Act.cs
│ │ │ ├── Applicative.Laws.cs
│ │ │ ├── Applicative.Trait.cs
│ │ │ ├── Extensions/
│ │ │ │ ├── Applicative.Extensions.Action.cs
│ │ │ │ ├── Applicative.Extensions.Apply.cs
│ │ │ │ ├── Applicative.Extensions.ApplyM.cs
│ │ │ │ ├── Applicative.Extensions.Arithmetic.cs
│ │ │ │ ├── Applicative.Extensions.Lift.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Action.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Apply.Tuple.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Apply.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Arithmetic.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Lift.cs
│ │ │ │ ├── Applicative.Extensions.Memo.Zip.cs
│ │ │ │ ├── Applicative.Extensions.Zip.cs
│ │ │ │ └── Applicative.Extensions.cs
│ │ │ ├── Module/
│ │ │ │ ├── Applicative.Module.Action.cs
│ │ │ │ ├── Applicative.Module.Apply.cs
│ │ │ │ ├── Applicative.Module.ApplyM.cs
│ │ │ │ ├── Applicative.Module.Arithmetic.cs
│ │ │ │ ├── Applicative.Module.Lift.cs
│ │ │ │ ├── Applicative.Module.Memo.Action.cs
│ │ │ │ ├── Applicative.Module.Memo.Apply.cs
│ │ │ │ ├── Applicative.Module.Memo.ApplyM.cs
│ │ │ │ ├── Applicative.Module.Memo.Arithmetic.cs
│ │ │ │ ├── Applicative.Module.Memo.Lift.cs
│ │ │ │ ├── Applicative.Module.Zip.cs
│ │ │ │ └── Applicative.Module.cs
│ │ │ ├── Operators/
│ │ │ │ ├── Applicative.Memo.Operators.cs
│ │ │ │ └── Applicative.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Applicative.Prelude.cs
│ │ │ └── README.md
│ │ ├── Arithmetic/
│ │ │ ├── Arithmetic.Prelude.cs
│ │ │ └── Arithmetic.cs
│ │ ├── Biapplicative/
│ │ │ └── Biapplicative.Trait.cs
│ │ ├── Bifunctor/
│ │ │ ├── Bifunctor.Extensions.cs
│ │ │ ├── Bifunctor.Module.cs
│ │ │ └── Bifunctor.Trait.cs
│ │ ├── Bimonad/
│ │ │ ├── Bimonad.Extensions.cs
│ │ │ ├── Bimonad.Module.cs
│ │ │ └── Bimonad.Trait.cs
│ │ ├── Bool/
│ │ │ └── Bool.cs
│ │ ├── Choice/
│ │ │ ├── Choice.Laws.cs
│ │ │ ├── Choice.Module.cs
│ │ │ ├── Choice.Trait.cs
│ │ │ ├── Extensions/
│ │ │ │ └── Choice.Extensions.cs
│ │ │ ├── Operators/
│ │ │ │ └── Choice.Operators.cs
│ │ │ ├── Prelude/
│ │ │ │ └── Choice.Prelude.cs
│ │ │ └── README.md
│ │ ├── Chronicaler/
│ │ │ ├── Chronicaler.Extensions.cs
│ │ │ ├── Chronicaler.Module.cs
│ │ │ └── Chronicaler.Trait.cs
│ │ ├── Cofunctor/
│ │ │ ├── Cofunctor.Extensions.cs
│ │ │ ├── Cofunctor.Module.cs
│ │ │ ├── Cofunctor.Prelude.cs
│ │ │ └── Cofunctor.Trait.cs
│ │ ├── Const/
│ │ │ └── Const.cs
│ │ ├── Coproduct/
│ │ │ ├── Coproduct.Extensions.cs
│ │ │ ├── Coproduct.Module.cs
│ │ │ └── Coproduct.Trait.cs
│ │ ├── CoproductCons/
│ │ │ ├── CoproductCons.Module.cs
│ │ │ └── CoproductCons.Trait.cs
│ │ ├── CoproductK/
│ │ │ ├── CoproductK.Extensions.cs
│ │ │ ├── CoproductK.Module.cs
│ │ │ └── CoproductK.Trait.cs
│ │ ├── Coreadable/
│ │ │ ├── Coreadable.Extensions.cs
│ │ │ ├── Coreadable.Module.cs
│ │ │ └── Coreadable.Trait.cs
│ │ ├── Decidable/
│ │ │ ├── Decidable.Module.cs
│ │ │ ├── Decidable.Prelude.cs
│ │ │ └── Decidable.Trait.cs
│ │ ├── Deriving/
│ │ │ └── Deriving.cs
│ │ ├── Divisible/
│ │ │ ├── Divisible.Module.cs
│ │ │ ├── Divisible.Prelude.cs
│ │ │ └── Divisible.Trait.cs
│ │ ├── Domain/
│ │ │ ├── Amount.cs
│ │ │ ├── DomainType.cs
│ │ │ ├── Identifier.cs
│ │ │ ├── Locus.cs
│ │ │ ├── README.md
│ │ │ └── VectorSpace.cs
│ │ ├── Eq/
│ │ │ ├── Eq.Extensions.cs
│ │ │ ├── Eq.Module.cs
│ │ │ ├── Eq.Prelude.cs
│ │ │ └── Eq.cs
│ │ ├── Fallible/
│ │ │ ├── Fallible.Extensions.Catch.E.cs
│ │ │ ├── Fallible.Extensions.Catch.cs
│ │ │ ├── Fallible.Extensions.Fails.E.cs
│ │ │ ├── Fallible.Extensions.Fails.cs
│ │ │ ├── Fallible.Extensions.Partition.E.cs
│ │ │ ├── Fallible.Extensions.Partition.cs
│ │ │ ├── Fallible.Extensions.Succs.E.cs
│ │ │ ├── Fallible.Extensions.Succs.cs
│ │ │ ├── Fallible.Guard.cs
│ │ │ ├── Fallible.Interface.cs
│ │ │ ├── Fallible.Module.cs
│ │ │ ├── Fallible.Operators.cs
│ │ │ ├── Fallible.Prelude.Catch.E.cs
│ │ │ ├── Fallible.Prelude.Catch.cs
│ │ │ ├── Fallible.Prelude.Fails.E.cs
│ │ │ ├── Fallible.Prelude.Fails.cs
│ │ │ ├── Fallible.Prelude.Partition.E.cs
│ │ │ ├── Fallible.Prelude.Partition.cs
│ │ │ ├── Fallible.Prelude.Succs.E.cs
│ │ │ ├── Fallible.Prelude.Succs.cs
│ │ │ ├── Fallible.Prelude.cs
│ │ │ └── Fallible.Trait.cs
│ │ ├── Final/
│ │ │ ├── Final.Extensions.cs
│ │ │ ├── Final.Module.cs
│ │ │ ├── Final.Operators.cs
│ │ │ ├── Final.Prelude.cs
│ │ │ ├── Final.Trait.cs
│ │ │ └── Finally.cs
│ │ ├── Floating/
│ │ │ ├── Floating.Prelude.cs
│ │ │ └── Floating.cs
│ │ ├── Foldable/
│ │ │ ├── Fold.Module.cs
│ │ │ ├── Fold.cs
│ │ │ ├── Foldable.Extensions.cs
│ │ │ ├── Foldable.ExtensionsT.cs
│ │ │ ├── Foldable.Module.cs
│ │ │ ├── Foldable.Prelude.cs
│ │ │ └── Foldable.Trait.cs
│ │ ├── Fraction/
│ │ │ ├── Fraction.Prelude.cs
│ │ │ └── Fraction.cs
│ │ ├── Functor/
│ │ │ ├── Extensions/
│ │ │ │ ├── Functor.Extensions.cs
│ │ │ │ ├── Functor.ExtensionsT.cs
│ │ │ │ └── Functor.MemoExtensions.cs
│ │ │ ├── Functor.Laws.cs
│ │ │ ├── Functor.Module.cs
│ │ │ ├── Functor.Trait.cs
│ │ │ ├── Operators/
│ │ │ │ ├── Functor.MemoOperators.cs
│ │ │ │ └── Functor.Operators.cs
│ │ │ └── Prelude/
│ │ │ └── Functor.Prelude.cs
│ │ ├── Has/
│ │ │ ├── Has.Trait.cs
│ │ │ └── Has.cs
│ │ ├── Hashable/
│ │ │ ├── Hashable.Module.cs
│ │ │ └── Hashable.Trait.cs
│ │ ├── Identifiable/
│ │ │ ├── Identifiable.Module.cs
│ │ │ ├── Identifiable.Operators.cs
│ │ │ ├── Identifiable.Prelude.cs
│ │ │ ├── Identifiable.cs
│ │ │ └── Label.cs
│ │ ├── Indexable/
│ │ │ └── Indexable.cs
│ │ ├── K.Extensions.cs
│ │ ├── K.cs
│ │ ├── Local/
│ │ │ ├── Local.Module.cs
│ │ │ └── Local.Trait.cs
│ │ ├── Maybe Traits/
│ │ │ ├── MonadIO/
│ │ │ │ └── MonadIO.Trait.cs
│ │ │ └── MonadUnliftIO/
│ │ │ ├── MonadUnliftIO.Extensions.cs
│ │ │ └── MonadUnliftIO.Trait.cs
│ │ ├── Monads/
│ │ │ ├── Monad/
│ │ │ │ ├── Monad.Extensions.cs
│ │ │ │ ├── Monad.ExtensionsT.cs
│ │ │ │ ├── Monad.Laws.cs
│ │ │ │ ├── Monad.Module.cs
│ │ │ │ ├── Monad.Operators.cs
│ │ │ │ └── Monad.Trait.cs
│ │ │ ├── MonadIO/
│ │ │ │ ├── MonadIO.Extensions.cs
│ │ │ │ ├── MonadIO.Module.cs
│ │ │ │ └── MonadIO.Trait.cs
│ │ │ ├── MonadT/
│ │ │ │ ├── MonadT.Extensions.cs
│ │ │ │ ├── MonadT.Module.cs
│ │ │ │ └── MonadT.Trait.cs
│ │ │ ├── MonadUnliftIO/
│ │ │ │ ├── MonadUnliftIO.Extensions.cs
│ │ │ │ ├── MonadUnliftIO.Module.cs
│ │ │ │ └── MonadUnliftIO.Trait.cs
│ │ │ └── README.md
│ │ ├── Monoid/
│ │ │ ├── Monoid.Instance.cs
│ │ │ ├── Monoid.Prelude.cs
│ │ │ └── Monoid.cs
│ │ ├── MonoidK/
│ │ │ ├── MonoidK.Extensions.cs
│ │ │ ├── MonoidK.Module.cs
│ │ │ ├── MonoidK.cs
│ │ │ └── README.md
│ │ ├── Mutates/
│ │ │ ├── Mutates.Module.cs
│ │ │ └── Mutates.Trait.cs
│ │ ├── Natural/
│ │ │ ├── CoNatural.Module.cs
│ │ │ ├── CoNatural.cs
│ │ │ ├── Natural.Module.cs
│ │ │ ├── Natural.cs
│ │ │ ├── NaturalEpi.cs
│ │ │ ├── NaturalIso.cs
│ │ │ ├── NaturalMono.cs
│ │ │ └── README.md
│ │ ├── Num/
│ │ │ ├── Num.Prelude.cs
│ │ │ └── Num.cs
│ │ ├── Ord/
│ │ │ ├── Ord.Module.cs
│ │ │ ├── Ord.Prelude.cs
│ │ │ ├── Ord.cs
│ │ │ └── OrdComparer.cs
│ │ ├── Predicate/
│ │ │ └── Predicate.cs
│ │ ├── README.md
│ │ ├── Range/
│ │ │ └── Range.Trait.cs
│ │ ├── Readable/
│ │ │ ├── Readable.Extensions.cs
│ │ │ ├── Readable.Module.cs
│ │ │ ├── Readable.Prelude.cs
│ │ │ └── Readable.Trait.cs
│ │ ├── Resolve/
│ │ │ ├── EqResolver.cs
│ │ │ ├── HashableResolver.cs
│ │ │ ├── OrdResolver.cs
│ │ │ └── Resolver.cs
│ │ ├── Semigroup/
│ │ │ ├── Semigroup.Instance.cs
│ │ │ ├── Semigroup.Module.cs
│ │ │ ├── Semigroup.Operators.cs
│ │ │ ├── Semigroup.Prelude.cs
│ │ │ └── Semigroup.cs
│ │ ├── SemigroupK/
│ │ │ ├── SemigroupK.Extensions.cs
│ │ │ ├── SemigroupK.Module.cs
│ │ │ ├── SemigroupK.Operators.cs
│ │ │ ├── SemigroupK.Prelude.cs
│ │ │ └── SemigroupK.cs
│ │ ├── Stateful/
│ │ │ ├── Stateful.Extensions.cs
│ │ │ ├── Stateful.Module.cs
│ │ │ └── Stateful.Trait.cs
│ │ ├── TokenStream/
│ │ │ ├── TokenStream.Module.cs
│ │ │ └── TokenStream.cs
│ │ ├── Trait.cs
│ │ ├── TraitAttribute.cs
│ │ ├── Traversable/
│ │ │ ├── README.md
│ │ │ ├── Traversable.Extensions.cs
│ │ │ ├── Traversable.Module.cs
│ │ │ └── Traversable.Trait.cs
│ │ └── Writable/
│ │ ├── Writable.Extensions.cs
│ │ ├── Writable.Module.cs
│ │ └── Writable.Trait.cs
│ ├── Units of Measure/
│ │ ├── Accel.cs
│ │ ├── Area.cs
│ │ ├── Length.cs
│ │ ├── Mass.cs
│ │ ├── Module.cs
│ │ ├── Temperature.cs
│ │ ├── Time.cs
│ │ ├── TimeSq.cs
│ │ ├── Velocity.cs
│ │ └── VelocitySq.cs
│ ├── Utility/
│ │ ├── AsyncEnumerableEx.cs
│ │ ├── Box.cs
│ │ ├── Check.cs
│ │ ├── CollectionFormat.cs
│ │ ├── Disposable.cs
│ │ ├── EnumerableOptimal.cs
│ │ ├── Fnv.cs
│ │ ├── IL.cs
│ │ ├── Inter.cs
│ │ ├── Pool.cs
│ │ ├── ReferenceEqualityComparer.cs
│ │ ├── Reflect.cs
│ │ ├── SysInfo.cs
│ │ ├── TaskExt.cs
│ │ └── WaitAsync.cs
│ └── Void.cs
├── LanguageExt.FSharp/
│ ├── LanguageExt.FSharp.csproj
│ ├── Prelude.cs
│ └── README.nuget.md
├── LanguageExt.Megaparsec/
│ ├── Delegates.cs
│ ├── ErrorFancy/
│ │ ├── ErrorFancy.Module.cs
│ │ └── ErrorFancy.cs
│ ├── ErrorItem/
│ │ ├── ErrorItem.Extensions.cs
│ │ ├── ErrorItem.Module.cs
│ │ ├── ErrorItem.cs
│ │ └── ExpectedErrors.cs
│ ├── Hints/
│ │ ├── Hints.Module.cs
│ │ └── Hints.cs
│ ├── LanguageExt.Megaparsec.csproj
│ ├── LineText.cs
│ ├── ModuleT/
│ │ ├── Expr.cs
│ │ ├── Failure.cs
│ │ ├── Lexer.cs
│ │ ├── Prim.cs
│ │ ├── State.cs
│ │ ├── Text.cs
│ │ └── Token.cs
│ ├── MonadParsecT/
│ │ ├── MonadParsecT.Module.cs
│ │ └── MonadParsecT.cs
│ ├── Operator.cs
│ ├── PString.cs
│ ├── ParseError/
│ │ ├── ParseError.Module.cs
│ │ └── ParseError.cs
│ ├── ParsecT/
│ │ ├── DSL/
│ │ │ ├── Apply.cs
│ │ │ ├── Bind.cs
│ │ │ ├── Catch.cs
│ │ │ ├── Choose.cs
│ │ │ ├── DSL.cs
│ │ │ ├── EOF.cs
│ │ │ ├── Empty.cs
│ │ │ ├── Error.cs
│ │ │ ├── Fail.cs
│ │ │ ├── Label.cs
│ │ │ ├── Lift.cs
│ │ │ ├── LookAhead.cs
│ │ │ ├── MTransLift.cs
│ │ │ ├── Map.cs
│ │ │ ├── NoneOf.cs
│ │ │ ├── NotFollowedBy.cs
│ │ │ ├── Observing.cs
│ │ │ ├── OneOf.cs
│ │ │ ├── Pure.cs
│ │ │ ├── Reader.cs
│ │ │ ├── State.cs
│ │ │ ├── Take.cs
│ │ │ ├── TakeWhile.cs
│ │ │ ├── TakeWhile1.cs
│ │ │ ├── Token.cs
│ │ │ ├── Tokens.cs
│ │ │ ├── Try.cs
│ │ │ └── WithRecovery.cs
│ │ ├── Extensions/
│ │ │ └── ParsecTExtensions.cs
│ │ ├── ParsecT.cs
│ │ └── Trait/
│ │ └── ParsecT.TraitImpl.cs
│ ├── Pos.cs
│ ├── PosState.cs
│ ├── Reach.cs
│ ├── Reply/
│ │ ├── Extensions/
│ │ │ └── Reply.Extensions.cs
│ │ ├── Reply.Module.cs
│ │ ├── Reply.cs
│ │ └── Trait/
│ │ └── Reply.TraitImpl.cs
│ ├── Result/
│ │ ├── Extensions/
│ │ │ └── Result.Extensions.cs
│ │ ├── Result.Module.cs
│ │ ├── Result.cs
│ │ └── Trait/
│ │ └── Result.TraitImpl.cs
│ ├── SourcePos.cs
│ └── State.cs
├── LanguageExt.Parsec/
│ ├── Common.cs
│ ├── Exceptions.cs
│ ├── GenLanguageDef.cs
│ ├── GenTokenParser.cs
│ ├── GenTokenParser2.cs
│ ├── Language.cs
│ ├── LanguageExt.Parsec.csproj
│ ├── OperatorIOs.cs
│ ├── Operators.cs
│ ├── PString.cs
│ ├── PStringIO.cs
│ ├── Parsec.Internal.cs
│ ├── ParsecIO.Internal.cs
│ ├── Parser.cs
│ ├── ParserError.cs
│ ├── ParserIO.cs
│ ├── ParserIOs/
│ │ ├── Expr.cs
│ │ ├── Indent.cs
│ │ ├── Item.cs
│ │ └── Prim.cs
│ ├── ParserResult.cs
│ ├── ParserResultIO.cs
│ ├── Parsers/
│ │ ├── Char.cs
│ │ ├── Expr.cs
│ │ ├── Indent.cs
│ │ ├── Prim.cs
│ │ ├── Token.cs
│ │ └── Token2.cs
│ ├── Pipes.cs
│ ├── Pos.cs
│ ├── README.nuget.md
│ ├── Reply.cs
│ ├── ReplyIO.cs
│ ├── Sidedness.cs
│ └── StringAndCollectionExt.cs
├── LanguageExt.Rx/
│ ├── Atom.Extensions.cs
│ ├── Cast.cs
│ ├── Check.cs
│ ├── Eff.Extensions.cs
│ ├── Either.Extensions.cs
│ ├── EitherUnsafe.Extensions.cs
│ ├── LanguageExt.Rx.csproj
│ ├── Option.Extensions.cs
│ ├── PreludeRx.cs
│ ├── README.nuget.md
│ └── Validation.Extensions.cs
├── LanguageExt.Streaming/
│ ├── Buffer.cs
│ ├── Conduit/
│ │ ├── Conduit.Extensions.cs
│ │ ├── Conduit.Module.cs
│ │ ├── Conduit.TraitImpl.cs
│ │ ├── Conduit.cs
│ │ └── Internal/
│ │ └── Conduit.ABC.cs
│ ├── ConduitT/
│ │ ├── ConduitT.Extensions.cs
│ │ ├── ConduitT.Module.cs
│ │ ├── ConduitT.TraitImpl.cs
│ │ ├── ConduitT.cs
│ │ └── Internal/
│ │ └── ConduitT.ABC.cs
│ ├── Event/
│ │ ├── Event.Module.cs
│ │ └── Event.cs
│ ├── LanguageExt.Streaming.csproj
│ ├── Pipes/
│ │ ├── Consumer/
│ │ │ ├── Consumer.Extensions.cs
│ │ │ ├── Consumer.Module.cs
│ │ │ ├── Consumer.Monad.cs
│ │ │ ├── Consumer.Operators.cs
│ │ │ └── Consumer.cs
│ │ ├── ConsumerT/
│ │ │ ├── ConsumerT.Extensions.cs
│ │ │ ├── ConsumerT.Module.cs
│ │ │ ├── ConsumerT.Monad.cs
│ │ │ ├── ConsumerT.Operators.cs
│ │ │ └── ConsumerT.cs
│ │ ├── Effect/
│ │ │ ├── Effect.Extensions.cs
│ │ │ ├── Effect.Module.cs
│ │ │ ├── Effect.Monad.cs
│ │ │ ├── Effect.Operators.cs
│ │ │ └── Effect.cs
│ │ ├── EffectT/
│ │ │ ├── EffectT.Extensions.cs
│ │ │ ├── EffectT.Module.cs
│ │ │ ├── EffectT.Monad.cs
│ │ │ ├── EffectT.Operators.cs
│ │ │ └── EffectT.cs
│ │ ├── Pipe/
│ │ │ ├── Pipe.Extensions.cs
│ │ │ ├── Pipe.Module.cs
│ │ │ ├── Pipe.Monad.cs
│ │ │ ├── Pipe.Operators.cs
│ │ │ └── Pipe.cs
│ │ ├── PipeT/
│ │ │ ├── PipeT.Cached.cs
│ │ │ ├── PipeT.DSL.cs
│ │ │ ├── PipeT.Extensions.cs
│ │ │ ├── PipeT.Module.cs
│ │ │ ├── PipeT.Monad.cs
│ │ │ ├── PipeT.Operators.cs
│ │ │ └── PipeT.cs
│ │ ├── Producer/
│ │ │ ├── Producer.Extensions.cs
│ │ │ ├── Producer.Module.cs
│ │ │ ├── Producer.Monad.cs
│ │ │ ├── Producer.Operators.cs
│ │ │ └── Producer.cs
│ │ ├── ProducerT/
│ │ │ ├── ProducerT.Extensions.cs
│ │ │ ├── ProducerT.Module.cs
│ │ │ ├── ProducerT.Monad.cs
│ │ │ ├── ProducerT.Operators.cs
│ │ │ └── ProducerT.cs
│ │ └── README.md
│ ├── README.md
│ ├── README.nuget.md
│ ├── Sink/
│ │ ├── DSL/
│ │ │ ├── SinkChoose.cs
│ │ │ ├── SinkCombine.cs
│ │ │ ├── SinkContraMap.cs
│ │ │ ├── SinkContraMapT.cs
│ │ │ ├── SinkEmpty.cs
│ │ │ ├── SinkVoid.cs
│ │ │ └── SinkWriter.cs
│ │ ├── Sink.CoFunctor.cs
│ │ ├── Sink.Extensions.cs
│ │ ├── Sink.Module.cs
│ │ └── Sink.cs
│ ├── SinkT/
│ │ ├── DSL/
│ │ │ ├── SinkChoose.cs
│ │ │ ├── SinkCombine.cs
│ │ │ ├── SinkContraMap.cs
│ │ │ ├── SinkContraMapT.cs
│ │ │ ├── SinkEmpty.cs
│ │ │ ├── SinkVoid.cs
│ │ │ └── SinkWriter.cs
│ │ ├── SinkT.CoFunctor.cs
│ │ ├── SinkT.Extensions.cs
│ │ ├── SinkT.Module.cs
│ │ └── SinkT.cs
│ ├── Source/
│ │ ├── Extensions/
│ │ │ ├── Source.Extensions.cs
│ │ │ └── Source.Reducers.cs
│ │ ├── Operators/
│ │ │ ├── Source.Operators.Applicative.cs
│ │ │ ├── Source.Operators.Choice.cs
│ │ │ ├── Source.Operators.Combine.cs
│ │ │ ├── Source.Operators.Functor.cs
│ │ │ ├── Source.Operators.Monad.cs
│ │ │ ├── Source.Operators.Zip.cs
│ │ │ └── Source.Operators.cs
│ │ ├── Source.Module.cs
│ │ ├── Source.cs
│ │ └── Trait/
│ │ └── Source.TraitImpl.cs
│ ├── SourceT/
│ │ ├── DSL/
│ │ │ ├── ApplySourceT.cs
│ │ │ ├── BindSourceT.cs
│ │ │ ├── ChooseSourceT.cs
│ │ │ ├── CombineSourceT.cs
│ │ │ ├── DoneSourceT.cs
│ │ │ ├── EmptySourceT.cs
│ │ │ ├── FilterSourceT.cs
│ │ │ ├── FoldUntilSourceT.cs
│ │ │ ├── FoldWhileSourceT.cs
│ │ │ ├── FoldablePureSourceT.cs
│ │ │ ├── FoldableSourceT.cs
│ │ │ ├── ForeverSourceT.cs
│ │ │ ├── IteratorAsyncSourceT.cs
│ │ │ ├── IteratorSyncSourceT.cs
│ │ │ ├── LiftSourceT.cs
│ │ │ ├── MapIOSourceT.cs
│ │ │ ├── MapSourceT.cs
│ │ │ ├── MultiListenerPureSourceT.cs
│ │ │ ├── MultiListenerSourceT.cs
│ │ │ ├── ObservablePureSourceT.cs
│ │ │ ├── ObservableSourceT.cs
│ │ │ ├── PureSourceT.cs
│ │ │ ├── Reader2SourceT.cs
│ │ │ ├── Reader3SourceT.cs
│ │ │ ├── Reader4SourceT.cs
│ │ │ ├── SourcePureSourceT.cs
│ │ │ ├── SourceSourceT.cs
│ │ │ ├── TakeForSourceT.cs
│ │ │ ├── TakeSourceT.cs
│ │ │ ├── ToIOSourceT.cs
│ │ │ ├── TransformSourceT.cs
│ │ │ ├── Zip2SourceT.cs
│ │ │ ├── Zip3SourceT.cs
│ │ │ └── Zip4SourceT.cs
│ │ ├── Extensions/
│ │ │ ├── SourceT.Combinators.cs
│ │ │ ├── SourceT.Extensions.cs
│ │ │ └── SourceT.Reducers.cs
│ │ ├── Operators/
│ │ │ ├── SourceT.Operators.Applicative.cs
│ │ │ ├── SourceT.Operators.Choice.cs
│ │ │ ├── SourceT.Operators.Combine.cs
│ │ │ ├── SourceT.Operators.Functor.cs
│ │ │ ├── SourceT.Operators.Monad.cs
│ │ │ ├── SourceT.Operators.Zip.cs
│ │ │ └── SourceT.Operators.cs
│ │ ├── SourceT.Module.cs
│ │ ├── SourceT.cs
│ │ └── Trait/
│ │ └── SourceT.TraitImpl.cs
│ └── Transducers/
│ ├── Reduced.cs
│ ├── ReducedM.cs
│ ├── Reducer.cs
│ ├── ReducerIO.cs
│ ├── ReducerM.cs
│ ├── Transducer/
│ │ ├── DSL/
│ │ │ ├── BindTransducer.cs
│ │ │ ├── ComposeTransducer.cs
│ │ │ ├── ConstTransducer.cs
│ │ │ ├── FilterTransducer.cs
│ │ │ ├── FoldUntilTransducer.cs
│ │ │ ├── FoldWhileTransducer.cs
│ │ │ ├── IdentityTransducer.cs
│ │ │ ├── MapTransducer.cs
│ │ │ ├── SelectManyTransducer.cs
│ │ │ ├── SkipTransducer.cs
│ │ │ └── TakeTransducer.cs
│ │ ├── TransduceFrom.TraitImpl.cs
│ │ ├── TransduceTo.TraitImpl.cs
│ │ ├── Transducer.Extensions.cs
│ │ ├── Transducer.Module.cs
│ │ └── Transducer.cs
│ └── TransducerM/
│ ├── DSL/
│ │ ├── BindTransducer.cs
│ │ ├── ComposeTransducer.cs
│ │ ├── ConstTransducer.cs
│ │ ├── FilterTransducer.cs
│ │ ├── FoldUntilTransducer.cs
│ │ ├── FoldWhileTransducer.cs
│ │ ├── IdentityTransducer.cs
│ │ ├── MapTransducer.cs
│ │ ├── SelectManyTransducer.cs
│ │ ├── SkipTransducer.cs
│ │ └── TakeTransducer.cs
│ ├── TransduceFromM.TraitImpl.cs
│ ├── TransduceToM.TraitImpl.cs
│ ├── TransducerM.Extensions.cs
│ ├── TransducerM.Module.cs
│ └── TransducerM.cs
├── LanguageExt.Sys/
│ ├── ActivityEnv.cs
│ ├── EffOpt.cs
│ ├── LanguageExt.Sys.csproj
│ ├── Live/
│ │ ├── Implementations/
│ │ │ ├── ActivitySourceIO.cs
│ │ │ ├── ConsoleIO.cs
│ │ │ ├── DirectoryIO.cs
│ │ │ ├── EncodingIO.cs
│ │ │ ├── EnvironmentIO.cs
│ │ │ ├── FileIO.cs
│ │ │ ├── TextReadIO.cs
│ │ │ └── TimeIO.cs
│ │ └── Runtime.cs
│ ├── MemoryConsole.cs
│ ├── MemorySystemEnvironment.cs
│ ├── README.nuget.md
│ ├── Sys/
│ │ ├── Console.Eff.cs
│ │ ├── Console.cs
│ │ ├── Diag/
│ │ │ ├── Activity.Eff.cs
│ │ │ └── Activity.cs
│ │ ├── Encoding.Eff.cs
│ │ ├── Encoding.cs
│ │ ├── Environment.Eff.cs
│ │ ├── Environment.cs
│ │ ├── IO/
│ │ │ ├── Directory.Eff.cs
│ │ │ ├── Directory.cs
│ │ │ ├── File.Eff.cs
│ │ │ ├── File.cs
│ │ │ ├── Stream.cs
│ │ │ ├── TextRead.Eff.cs
│ │ │ └── TextRead.cs
│ │ ├── Time.Eff.cs
│ │ └── Time.cs
│ ├── Test/
│ │ ├── Implementations/
│ │ │ ├── ConsoleIO.cs
│ │ │ ├── DirectoryIO.cs
│ │ │ ├── EnvironmentIO.cs
│ │ │ ├── FileIO.cs
│ │ │ ├── TestTimeSpec.cs
│ │ │ ├── TextReadIO.cs
│ │ │ └── TimeIO.cs
│ │ └── Runtime.cs
│ └── Traits/
│ ├── ActivitySourceIO.cs
│ ├── ConsoleIO.cs
│ ├── DirectoryIO.cs
│ ├── EncodingIO.cs
│ ├── EnvironmentIO.cs
│ ├── FileIO.cs
│ ├── SysIO.cs
│ ├── TextReadIO.cs
│ └── TimeIO.cs
├── LanguageExt.Tests/
│ ├── AffTests.cs
│ ├── ArrayTests.cs
│ ├── AtomHashMapEqTests.cs
│ ├── AtomHashMapTests.cs
│ ├── AtomTests.cs
│ ├── ChoiceTests.cs
│ ├── CollectionOrderingTests.cs
│ ├── CollectionToStringTests.cs
│ ├── CombinatorsTests.cs
│ ├── CompositionTests.cs
│ ├── DefaultValueChecks/
│ │ ├── AbstractDefaultValueCheckTests.cs
│ │ ├── isDefaultPreludeTests.cs
│ │ └── notDefaultPreludeTests.cs
│ ├── DelayTests.cs
│ ├── DistinctTests.cs
│ ├── Divisible.cs
│ ├── EitherApply.cs
│ ├── EitherCoalesceTests.cs
│ ├── EitherTests.cs
│ ├── EnumerableTTests.cs
│ ├── EqualityTests.cs
│ ├── ErrorTests.cs
│ ├── FSharp/
│ │ └── FSharpTests.cs
│ ├── FunTests.cs
│ ├── GlobalSuppressions.cs
│ ├── GlobalUsings.cs
│ ├── HashMapTests.cs
│ ├── HashSetTests.cs
│ ├── IOTests/
│ │ ├── ApplyTests.cs
│ │ ├── FoldTests.cs
│ │ ├── GeneralTests.cs
│ │ ├── MapFailTests.cs
│ │ ├── RepeatTests.cs
│ │ ├── RetryTests.cs
│ │ └── TailRecursionTests.cs
│ ├── IssuesTests.cs
│ ├── IteratorTests/
│ │ └── IteratorTests.cs
│ ├── LanguageExt.Tests.csproj
│ ├── LensTests.cs
│ ├── LinqTests.cs
│ ├── ListMatchingTests.cs
│ ├── ListTests.cs
│ ├── MapTests.cs
│ ├── MemoImplTests.cs
│ ├── MemoryConsoleTests.cs
│ ├── MemoryFSTests.cs
│ ├── MonadTests.cs
│ ├── Multiplicable.cs
│ ├── NullChecks/
│ │ ├── AbstractNullCheckTests.cs
│ │ ├── IsNullExtensionTests.cs
│ │ ├── isnullPreludeTests.cs
│ │ └── notnullPreludeTests.cs
│ ├── OptionApply.cs
│ ├── OptionCoalesceTests.cs
│ ├── OptionLazy.cs
│ ├── OptionTTests.cs
│ ├── OptionTests.cs
│ ├── OptionUnsafeApply.cs
│ ├── ParsecIOTests.cs
│ ├── ParsecTests.cs
│ ├── Parsing/
│ │ ├── AbstractParseTPrecisionIntervalTests.cs
│ │ ├── AbstractParseTSignedPrecisionIntervalTests.cs
│ │ ├── AbstractParseTTests.cs
│ │ ├── AbstractParseTUnsignedPrecisionIntervalTests.cs
│ │ ├── parseBoolTests.cs
│ │ ├── parseByteTests.cs
│ │ ├── parseCharTests.cs
│ │ ├── parseDateTimeOffsetTests.cs
│ │ ├── parseDateTimeTests.cs
│ │ ├── parseDecimalTests.cs
│ │ ├── parseDoubleTests.cs
│ │ ├── parseEnumTests.cs
│ │ ├── parseFloatTests.cs
│ │ ├── parseGuidTests.cs
│ │ ├── parseIntTests.cs
│ │ ├── parseLongTests.cs
│ │ ├── parseSByteTests.cs
│ │ ├── parseShortTests.cs
│ │ ├── parseTimeSpanTests.cs
│ │ ├── parseUIntTests.cs
│ │ ├── parseULongTests.cs
│ │ └── parseUShortTests.cs
│ ├── PartialAndCurryingTests.cs
│ ├── PatchTests.cs
│ ├── PipesTests.cs
│ ├── PrismTests.cs
│ ├── QueryTests.cs
│ ├── QueueTests.cs
│ ├── RangeTests.cs
│ ├── Read-Me.cs
│ ├── RecordIgnoreBaseTests.cs
│ ├── RecordTests.cs
│ ├── RecordTypesTest.cs
│ ├── RefTest.cs
│ ├── ReflectTests.cs
│ ├── ScheduleTest/
│ │ ├── EffTests1.cs
│ │ ├── PositiveDurationTests.cs
│ │ └── ScheduleTests.cs
│ ├── SeqTypes/
│ │ ├── Seq.Arr.Tests.cs
│ │ ├── Seq.Cons.Tests.cs
│ │ ├── Seq.Enumerable.Tests.cs
│ │ ├── Seq.IList.Tests.cs
│ │ ├── Seq.Lazy.Tests.cs
│ │ ├── Seq.Lst.Tests.cs
│ │ ├── Seq.Module.Tests.cs
│ │ ├── SeqListTests.cs
│ │ └── SeqTests.cs
│ ├── SerialisationTests.cs
│ ├── SetTests.cs
│ ├── StackTests.cs
│ ├── Streaming/
│ │ ├── Source.Tests.cs
│ │ └── SourceT.Tests.cs
│ ├── Sys/
│ │ ├── Diag/
│ │ │ └── ActivityTests.cs
│ │ └── IO/
│ │ └── DirectoryTests.cs
│ ├── TESTING.cs
│ ├── TrackingHashMapTests.cs
│ ├── TraitTests/
│ │ ├── AlternativeLawTests.cs
│ │ ├── ApplicativeLawTests.cs
│ │ ├── ChoiceLawTests.cs
│ │ ├── FoldableDefaultsTests.cs
│ │ ├── FunctorLawTests.cs
│ │ └── MonadLawsTest.cs
│ ├── Transformer/
│ │ └── Traverse/
│ │ ├── Arr/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── Validation.cs
│ │ ├── Either/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── HashSet/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── IEnumerable/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ └── HashSet.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── Identity/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── Lst/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── Option/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ ├── SeqT/
│ │ │ ├── Collections/
│ │ │ │ ├── Arr.cs
│ │ │ │ ├── HashSet.cs
│ │ │ │ ├── IEnumerable.cs
│ │ │ │ ├── Lst.cs
│ │ │ │ ├── Seq.cs
│ │ │ │ └── Set.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ ├── Validation.cs
│ │ │ └── ValidationWithMonoid.cs
│ │ ├── SetT/
│ │ │ ├── Collections/
│ │ │ │ └── Arr.cs
│ │ │ └── Sync/
│ │ │ ├── Either.cs
│ │ │ ├── Identity.cs
│ │ │ ├── Option.cs
│ │ │ └── ValidationSeq.cs
│ │ └── Validation/
│ │ ├── Collections/
│ │ │ ├── Arr.cs
│ │ │ ├── HashSet.cs
│ │ │ ├── IEnumerable.cs
│ │ │ ├── Lst.cs
│ │ │ ├── Seq.cs
│ │ │ └── Set.cs
│ │ └── Sync/
│ │ ├── Either.cs
│ │ ├── Identity.cs
│ │ ├── Option.cs
│ │ └── ValidationSeq.cs
│ ├── TupleTests.cs
│ ├── UnionCustomJsonSerializerTests.cs
│ ├── UnionJsonSerializerTests.cs
│ ├── UnionTests.cs
│ ├── UnitsOfMeasureTests.cs
│ ├── ValidationTests.cs
│ ├── VectorClockTests.cs
│ ├── VersionHashMapTests.cs
│ └── WithTests.cs
├── LanguageExt.XUnitExt/
│ ├── EffExtensions.cs
│ ├── EitherExtensions.cs
│ ├── ErrorExtensions.cs
│ ├── FinExtensions.cs
│ ├── IOExtensions.cs
│ ├── LanguageExt.XUnitExt.csproj
│ ├── OptionExtensions.cs
│ ├── README.nuget.md
│ └── SourceExtensions.cs
├── Major Version Release Notes/
│ ├── Version 2/
│ │ ├── README.md
│ │ └── version-2-migration-notes.md
│ └── Version 5/
│ ├── Migration War Stories/
│ │ └── README.md
│ └── README.md
├── Performance.md
├── README.md
├── Samples/
│ ├── BlazorApp/
│ │ ├── BlazorApp.csproj
│ │ ├── Components/
│ │ │ ├── App.razor
│ │ │ ├── Layout/
│ │ │ │ ├── MainLayout.razor
│ │ │ │ ├── MainLayout.razor.css
│ │ │ │ ├── NavMenu.razor
│ │ │ │ └── NavMenu.razor.css
│ │ │ ├── Pages/
│ │ │ │ ├── Counter.razor
│ │ │ │ ├── Error.razor
│ │ │ │ ├── Home.razor
│ │ │ │ ├── Page.cs
│ │ │ │ └── Weather.razor
│ │ │ ├── Routes.razor
│ │ │ └── _Imports.razor
│ │ ├── Control/
│ │ │ └── Weather.cs
│ │ ├── Data/
│ │ │ └── WeatherForecast.cs
│ │ ├── Effects/
│ │ │ ├── AppRuntime.cs
│ │ │ ├── Impl/
│ │ │ │ └── RndImpl.cs
│ │ │ ├── Interfaces/
│ │ │ │ └── RndIO.cs
│ │ │ ├── Rnd.cs
│ │ │ ├── Runtime.cs
│ │ │ └── SafeErrorExtensions.cs
│ │ ├── Program.cs
│ │ ├── Properties/
│ │ │ └── launchSettings.json
│ │ ├── appsettings.Development.json
│ │ ├── appsettings.json
│ │ └── wwwroot/
│ │ └── app.css
│ ├── CardGame/
│ │ ├── Card.cs
│ │ ├── CardGame.csproj
│ │ ├── Console.cs
│ │ ├── Deck.cs
│ │ ├── Display.cs
│ │ ├── Game.Monad/
│ │ │ ├── Game.Extensions.cs
│ │ │ ├── Game.Module.cs
│ │ │ ├── Game.Monad.cs
│ │ │ └── Game.cs
│ │ ├── Game.cs
│ │ ├── GameState.cs
│ │ ├── Player.cs
│ │ ├── PlayerState.cs
│ │ ├── Players.cs
│ │ └── Program.cs
│ ├── CreditCardValidation/
│ │ ├── Control/
│ │ │ └── CreditCard.cs
│ │ ├── CreditCardValidation.csproj
│ │ ├── Data/
│ │ │ ├── Base12.cs
│ │ │ ├── CVV.cs
│ │ │ ├── CardNumber.cs
│ │ │ ├── CreditCardDetails.cs
│ │ │ ├── Expiry.cs
│ │ │ └── MonthSpan.cs
│ │ └── Program.cs
│ ├── DomainTypesExamples/
│ │ ├── Dimension.cs
│ │ ├── DomainTypesExamples.csproj
│ │ ├── Program.cs
│ │ ├── Time.cs
│ │ ├── TimeSpan.cs
│ │ └── Vector.cs
│ ├── EffectsExamples/
│ │ ├── EffectsExamples.csproj
│ │ ├── Examples/
│ │ │ ├── CancelExample.cs
│ │ │ ├── ErrorAndGuardExample.cs
│ │ │ ├── FoldTest.cs
│ │ │ ├── ForkCancelExample.cs
│ │ │ ├── QueueExample.cs
│ │ │ ├── RetryExample.cs
│ │ │ ├── TextFileChunkStreamExample.cs
│ │ │ ├── TextFileLineStreamExample.cs
│ │ │ ├── TimeExample.cs
│ │ │ └── TimeoutExample.cs
│ │ ├── Menu.cs
│ │ └── Program.cs
│ ├── IOExmples/
│ │ ├── IOExmples.csproj
│ │ └── Program.cs
│ ├── Newsletter/
│ │ ├── Newsletter/
│ │ │ ├── Command/
│ │ │ │ ├── Email.cs
│ │ │ │ ├── Members.cs
│ │ │ │ ├── Newsletter.cs
│ │ │ │ ├── Posts.cs
│ │ │ │ ├── Send.cs
│ │ │ │ └── Templates.cs
│ │ │ ├── Data/
│ │ │ │ ├── Letter.cs
│ │ │ │ ├── Members.cs
│ │ │ │ ├── Posts.cs
│ │ │ │ └── Templates.cs
│ │ │ ├── Effects/
│ │ │ │ ├── Config.cs
│ │ │ │ ├── Email.cs
│ │ │ │ ├── Image.cs
│ │ │ │ ├── Impl/
│ │ │ │ │ ├── Email.cs
│ │ │ │ │ ├── Image.cs
│ │ │ │ │ ├── Json.cs
│ │ │ │ │ └── Web.cs
│ │ │ │ ├── Json.cs
│ │ │ │ ├── Runtime.cs
│ │ │ │ ├── RuntimeEnv.cs
│ │ │ │ ├── Traits/
│ │ │ │ │ ├── EmailIO.cs
│ │ │ │ │ ├── ImageIO.cs
│ │ │ │ │ ├── JsonIO.cs
│ │ │ │ │ └── WebIO.cs
│ │ │ │ └── Web.cs
│ │ │ ├── GlobalUsings.cs
│ │ │ ├── JsonExtensions.cs
│ │ │ ├── Newsletter.csproj
│ │ │ ├── Newsletter.sln
│ │ │ ├── Program.cs
│ │ │ └── UI/
│ │ │ └── Display.cs
│ │ ├── README.md
│ │ ├── members-test/
│ │ │ └── members.2024-07-29.csv
│ │ └── templates/
│ │ ├── email.html
│ │ ├── email.txt
│ │ ├── recent-item.html
│ │ └── recent-item.txt
│ ├── PipesExamples/
│ │ ├── PipesExamples.csproj
│ │ └── Program.cs
│ ├── Streams/
│ │ ├── Console.cs
│ │ ├── CountForever.cs
│ │ ├── CountForeverAsync.cs
│ │ ├── Folding.cs
│ │ ├── Grouping.cs
│ │ ├── HeadsAndTails.cs
│ │ ├── Menu.cs
│ │ ├── Merging.cs
│ │ ├── OptionalItems.cs
│ │ ├── Program.cs
│ │ ├── RecursionIO.cs
│ │ ├── SourceStream.cs
│ │ ├── Streams.csproj
│ │ ├── SumOfSquares.cs
│ │ └── Zipping.cs
│ ├── TestBed/
│ │ ├── ApplicativeTest.cs
│ │ ├── AtomHashMapTests.cs
│ │ ├── AwaitAnyTest.cs
│ │ ├── BracketTest.cs
│ │ ├── FreeTests.cs
│ │ ├── Issues/
│ │ │ ├── Discussion1527.cs
│ │ │ ├── Issue1497.cs
│ │ │ └── IssueTests.cs
│ │ ├── PipesTest.cs
│ │ ├── Program.cs
│ │ ├── RWSTTests.cs
│ │ ├── RecurTests.cs
│ │ ├── ResourcesDiscussion1366.cs
│ │ ├── RobotExample.cs
│ │ ├── ScheduleTests.cs
│ │ ├── SeqConstructTests.cs
│ │ ├── SequenceParallelTest.cs
│ │ ├── SourceTTests.cs
│ │ ├── StateAsync.cs
│ │ ├── StateEff.cs
│ │ ├── TestBed.csproj
│ │ ├── TestCodeGen.cs
│ │ └── UseTest.cs
│ ├── TestBed.WPF/
│ │ ├── App.xaml
│ │ ├── App.xaml.cs
│ │ ├── AssemblyInfo.cs
│ │ ├── AtomIO.cs
│ │ ├── MainWindow.xaml
│ │ ├── MainWindow.xaml.cs
│ │ ├── TestBed.WPF.csproj
│ │ ├── WindowIO.cs
│ │ └── WindowRT.cs
│ ├── TestBed.Web/
│ │ ├── Program.cs
│ │ └── TestBed.Web.csproj
│ └── TestBed.Web.Runner/
│ ├── Program.cs
│ └── TestBed.Web.Runner.csproj
├── clean.sh
├── docs.sh
├── inc.bat
├── language-ext.sln
├── language-ext.sln.DotSettings
├── pack.bat
├── pack.sh
└── pjv/
└── LanguageExt.Core.3.1.9-beta.nuspec
Showing preview only (1,184K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (15344 symbols across 1700 files)
FILE: LanguageExt.Benchmarks/HashMapAddBenchmarks.cs
class HashMapAddBenchmarks (line 11) | [RPlotExporter, RankColumn]
method Setup (line 22) | [GlobalSetup]
method SysColImmutableDictionary (line 28) | [Benchmark]
method SysColImmutableSortedDictionary (line 40) | [Benchmark]
method SasaTrie (line 52) | [Benchmark]
method SysColDictionary (line 64) | [Benchmark]
method LangExtHashMap (line 76) | [Benchmark]
method LangExtMap (line 88) | [Benchmark]
FILE: LanguageExt.Benchmarks/HashMapContainsKeyBenchmarks.cs
class HashMapContainsKeyBenchmarks (line 11) | [RPlotExporter, RankColumn]
method Setup (line 29) | [GlobalSetup]
method SysColImmutableDictionary (line 43) | [Benchmark]
method SasaTrie (line 55) | [Benchmark]
method SysColImmutableSortedDictionary (line 67) | [Benchmark]
method SysColDictionary (line 79) | [Benchmark]
method LangExtHashMap (line 91) | [Benchmark]
method LangExtMap (line 103) | [Benchmark]
FILE: LanguageExt.Benchmarks/HashMapIterateBenchmarks.cs
class HashMapIterateBenchmarks (line 10) | [RPlotExporter, RankColumn]
method Setup (line 26) | [GlobalSetup]
method SysColImmutableDictionary (line 39) | [Benchmark]
method SysColImmutableSortedDictionary (line 53) | [Benchmark]
method SasaTrie (line 67) | [Benchmark]
method SysColDictionary (line 81) | [Benchmark]
method LangExtHashMap (line 95) | [Benchmark]
method LangExtMap (line 109) | [Benchmark]
FILE: LanguageExt.Benchmarks/HashMapRandomRemovalBenchmarks.cs
class HashMapRandomRemovalBenchmarks (line 11) | [RPlotExporter, RankColumn]
method Setup (line 29) | [GlobalSetup]
method SysColImmutableDictionary (line 43) | [Benchmark]
method SysColImmutableSortedDictionary (line 55) | [Benchmark]
method SasaTrie (line 68) | [Benchmark]
method SysColDictionary (line 80) | [Benchmark]
method LangExtHashMap (line 92) | [Benchmark]
method LangExtMap (line 104) | [Benchmark]
FILE: LanguageExt.Benchmarks/HashSetAddBenchmarks.cs
class HashSetAddBenchmarks (line 9) | [RPlotExporter, RankColumn]
method Setup (line 20) | [GlobalSetup]
method SysColImmutableHashSet (line 26) | [Benchmark]
method SysColImmutableSortedSet (line 38) | [Benchmark]
method SysColHashSet (line 50) | [Benchmark]
method LangExtHashSet (line 62) | [Benchmark]
method LangExtSet (line 74) | [Benchmark]
FILE: LanguageExt.Benchmarks/HashSetContainsBenchmarks.cs
class HashSetContainsBenchmarks (line 8) | [RPlotExporter, RankColumn]
method Setup (line 25) | [GlobalSetup]
method SysColImmutableHashSet (line 37) | [Benchmark]
method SysColImmutableSortedSet (line 49) | [Benchmark]
method SysColHashSet (line 61) | [Benchmark]
method LangExtHashSet (line 73) | [Benchmark]
method LangExtSet (line 85) | [Benchmark]
FILE: LanguageExt.Benchmarks/HashSetIterationBenchmarks.cs
class HashSetIterationBenchmarks (line 8) | [RPlotExporter, RankColumn]
method Setup (line 25) | [GlobalSetup]
method SysColImmutableHashSet (line 37) | [Benchmark]
method SysColImmutableSortedSet (line 51) | [Benchmark]
method SysColHashSet (line 65) | [Benchmark]
method LangExtHashSet (line 79) | [Benchmark]
method LangExtSet (line 93) | [Benchmark]
FILE: LanguageExt.Benchmarks/HashSetRandomRemovalBenchmarks.cs
class HashSetRandomRemovalBenchmarks (line 8) | [RPlotExporter, RankColumn]
method Setup (line 25) | [GlobalSetup]
method SysColImmutableHashSet (line 37) | [Benchmark]
method SysColImmutableSortedSet (line 49) | [Benchmark]
method SysColHashSet (line 61) | [Benchmark]
method LangExtHashSet (line 73) | [Benchmark]
method LangExtSet (line 85) | [Benchmark]
FILE: LanguageExt.Benchmarks/ListAddBenchmarks.cs
class ListAddBenchmarks (line 10) | [RPlotExporter, RankColumn]
method Setup (line 21) | [GlobalSetup]
method SysColImmutableList (line 27) | [Benchmark]
method LangExtLst (line 39) | [Benchmark]
method LangExtSeq (line 51) | [Benchmark]
FILE: LanguageExt.Benchmarks/ListIterationBenchmarks.cs
class ListIterationBenchmarks (line 9) | [RPlotExporter, RankColumn]
method Setup (line 23) | [GlobalSetup]
method SysColImmutableList (line 32) | [Benchmark]
method LangExtLst (line 46) | [Benchmark]
method LangExtSeq (line 60) | [Benchmark]
FILE: LanguageExt.Benchmarks/Program.cs
class Program (line 5) | class Program
method Main (line 7) | static void Main(string[] args) =>
FILE: LanguageExt.Benchmarks/ValuesGenerator.MapSetup.cs
class ValuesGenerator (line 9) | internal partial class ValuesGenerator
method SasaTrieSetup (line 11) | public static Trie<T, T> SasaTrieSetup<T>(Dictionary<T, T> values)
method SysColImmutableDictionarySetup (line 21) | public static ImmutableDictionary<T, T> SysColImmutableDictionarySetup...
method SysColImmutableSortedDictionarySetup (line 32) | public static ImmutableSortedDictionary<T, T> SysColImmutableSortedDic...
method SysColDictionarySetup (line 43) | public static Dictionary<T, T> SysColDictionarySetup<T>(Dictionary<T, ...
method LangExtHashMapSetup (line 54) | public static HashMap<TEq, T, T> LangExtHashMapSetup<T, TEq>(Dictionar...
method LangExtMapSetup (line 66) | public static Map<TOrd, T, T> LangExtMapSetup<T, TOrd>(Dictionary<T, T...
FILE: LanguageExt.Benchmarks/ValuesGenerator.SetSetup.cs
class ValuesGenerator (line 7) | internal partial class ValuesGenerator
method SysColImmutableHashSetSetup (line 9) | public static ImmutableHashSet<T> SysColImmutableHashSetSetup<T>(T[] v...
method SysColImmutableSortedSetSetup (line 20) | public static ImmutableSortedSet<T> SysColImmutableSortedSetSetup<T>(T...
method SysColHashSetSetup (line 31) | public static System.Collections.Generic.HashSet<T> SysColHashSetSetup...
method LangExtHashSetSetup (line 42) | public static HashSet<TEq, T> LangExtHashSetSetup<T, TEq>(T[] values)
method LangExtSetSetup (line 54) | public static Set<TOrd, T> LangExtSetSetup<T, TOrd>(T[] values)
FILE: LanguageExt.Benchmarks/ValuesGenerator.cs
class ValuesGenerator (line 8) | internal partial class ValuesGenerator
method ValuesGenerator (line 14) | public ValuesGenerator(int seed)
method GenerateDictionary (line 19) | public Dictionary<TKey, TValue> GenerateDictionary<TKey, TValue>(int c...
method GenerateUniqueValues (line 32) | public T[] GenerateUniqueValues<T>(int count)
method GenerateValue (line 45) | private T GenerateValue<T>(Random rand)
method GenerateString (line 60) | private string GenerateString(Random rand, int minLength, int maxLength)
FILE: LanguageExt.Core/Catch.cs
type CatchM (line 9) | public readonly record struct CatchM<E, M, A>(Func<E, bool> Match, Func<...
class CatchMExtensions (line 16) | public static class CatchMExtensions
method Map (line 21) | public CatchM<E, M, B> Map<B>(Func<A, B> f) =>
FILE: LanguageExt.Core/Class Instances/Eq/EqArr.cs
type EqArr (line 10) | public struct EqArr<EqA, A> : Eq<Arr<A>> where EqA : Eq<A>
method Equals (line 18) | [Pure]
method GetHashCode (line 37) | [Pure]
method Equals (line 53) | [Pure]
method GetHashCode (line 62) | [Pure]
type EqArr (line 45) | public struct EqArr<A> : Eq<Arr<A>>
method Equals (line 18) | [Pure]
method GetHashCode (line 37) | [Pure]
method Equals (line 53) | [Pure]
method GetHashCode (line 62) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqArray.cs
type EqArray (line 10) | public struct EqArray<EqA, A> : Eq<A[]> where EqA : Eq<A>
method Equals (line 18) | [Pure]
method GetHashCode (line 34) | [Pure]
method Equals (line 50) | [Pure]
method GetHashCode (line 59) | [Pure]
type EqArray (line 42) | public struct EqArray<A> : Eq<A[]>
method Equals (line 18) | [Pure]
method GetHashCode (line 34) | [Pure]
method Equals (line 50) | [Pure]
method GetHashCode (line 59) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqBigInt.cs
type EqBigInt (line 9) | public struct EqBigInt : Eq<bigint>
method Equals (line 17) | [Pure]
method GetHashCode (line 27) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqBool.cs
type EqBool (line 9) | public struct EqBool : Eq<bool>
method Equals (line 17) | [Pure]
method GetHashCode (line 26) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqChar.cs
type EqChar (line 9) | public struct EqChar : Eq<char>
method Equals (line 17) | [Pure]
method GetHashCode (line 27) | [Pure]
type EqCharOrdinalIgnoreCase (line 35) | public struct EqCharOrdinalIgnoreCase : Eq<char>
method Equals (line 43) | [Pure]
method GetHashCode (line 56) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqCompositions.cs
type EqCompositions (line 6) | public struct EqCompositions<A> : Eq<Compositions<A>>
method Equals (line 9) | [Pure]
method GetHashCode (line 13) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqDateTime.cs
type EqDateTime (line 10) | public struct EqDateTime : Eq<DateTime>
method Equals (line 18) | [Pure]
method GetHashCode (line 27) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqDecimal.cs
type EqDecimal (line 10) | public struct EqDecimal : Eq<decimal>
method Equals (line 18) | [Pure]
method GetHashCode (line 27) | [Pure]
method EqualsAsync (line 31) | [Pure]
method GetHashCodeAsync (line 35) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqDefault.cs
type EqDefault (line 14) | public readonly struct EqDefault<A> : Eq<A>
method Equals (line 22) | [Pure]
method GetHashCode (line 36) | [Pure]
method EqDefault (line 50) | static EqDefault()
method Equals (line 63) | [Pure]
class EqDefault (line 46) | public static class EqDefault<A, B>
method Equals (line 22) | [Pure]
method GetHashCode (line 36) | [Pure]
method EqDefault (line 50) | static EqDefault()
method Equals (line 63) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqDouble.cs
type EqDouble (line 9) | public struct EqDouble : Eq<double>
method Equals (line 17) | [Pure]
method GetHashCode (line 26) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqEdit.cs
type EqEdit (line 9) | public struct EqEdit<EqA, A> : Eq<Edit<EqA, A>> where EqA : Eq<A>
method Equals (line 11) | [Pure]
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqEither.cs
type EqEither (line 10) | public struct EqEither<EqL, EqR, L, R> : Eq<Either<L, R>>
method Equals (line 17) | [Pure]
method GetHashCode (line 27) | [Pure]
method GetHashCodeAsync (line 36) | [Pure]
method EqualsAsync (line 43) | [Pure]
method Equals (line 56) | [Pure]
method GetHashCode (line 65) | [Pure]
type EqEither (line 51) | public struct EqEither<L, R> : Eq<Either<L, R>>
method Equals (line 17) | [Pure]
method GetHashCode (line 27) | [Pure]
method GetHashCodeAsync (line 36) | [Pure]
method EqualsAsync (line 43) | [Pure]
method Equals (line 56) | [Pure]
method GetHashCode (line 65) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqEnumerable.cs
type EqEnumerable (line 13) | public struct EqEnumerable<EQ, A> : Eq<IEnumerable<A>>
method Equals (line 19) | [Pure]
method GetHashCode (line 39) | [Pure]
method Equals (line 55) | [Pure]
method GetHashCode (line 64) | [Pure]
type EqEnumerable (line 50) | public struct EqEnumerable<A> : Eq<IEnumerable<A>>
method Equals (line 19) | [Pure]
method GetHashCode (line 39) | [Pure]
method Equals (line 55) | [Pure]
method GetHashCode (line 64) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqException.cs
type EqException (line 7) | public struct EqException : Eq<Exception>
method GetHashCode (line 9) | [Pure]
method Equals (line 13) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqFloat.cs
type EqFloat (line 9) | public struct EqFloat : Eq<float>
method Equals (line 17) | [Pure]
method GetHashCode (line 26) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqGuid.cs
type EqGuid (line 10) | public struct EqGuid : Eq<Guid>
method Equals (line 18) | [Pure]
method GetHashCode (line 27) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqHashSet.cs
type EqHashSet (line 9) | public struct EqHashSet<EQ, A> : Eq<HashSet<A>> where EQ : Eq<A>
method Equals (line 17) | [Pure]
method GetHashCode (line 38) | [Pure]
method Equals (line 54) | [Pure]
method GetHashCode (line 63) | [Pure]
type EqHashSet (line 46) | public struct EqHashSet<A> : Eq<HashSet<A>>
method Equals (line 17) | [Pure]
method GetHashCode (line 38) | [Pure]
method Equals (line 54) | [Pure]
method GetHashCode (line 63) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqIdentity.cs
type EqIdentity (line 9) | public struct EqIdentity<A> : Eq<Identity<A>>
method Equals (line 17) | [Pure]
method GetHashCode (line 26) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqInt.cs
type EqInt (line 9) | public struct EqInt : Eq<int>
method Equals (line 17) | [Pure]
method GetHashCode (line 26) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqIterable.cs
type EqIterable (line 13) | public struct EqIterable<EQ, A> : Eq<Iterable<A>>
method Equals (line 19) | [Pure]
method GetHashCode (line 39) | [Pure]
method Equals (line 55) | [Pure]
method GetHashCode (line 64) | [Pure]
type EqIterable (line 50) | public struct EqIterable<A> : Eq<Iterable<A>>
method Equals (line 19) | [Pure]
method GetHashCode (line 39) | [Pure]
method Equals (line 55) | [Pure]
method GetHashCode (line 64) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqLong.cs
type EqLong (line 9) | public struct EqLong : Eq<long>
method Equals (line 17) | [Pure]
method GetHashCode (line 26) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqLst.cs
type EqLst (line 12) | public struct EqLst<EQ, A> : Eq<Lst<A>> where EQ : Eq<A>
method Equals (line 14) | [Pure]
method GetHashCode (line 37) | [Pure]
method Equals (line 50) | [Pure]
method GetHashCode (line 59) | [Pure]
type EqLst (line 48) | public struct EqLst<A> : Eq<Lst<A>>
method Equals (line 14) | [Pure]
method GetHashCode (line 37) | [Pure]
method Equals (line 50) | [Pure]
method GetHashCode (line 59) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqMap.cs
type EqMap (line 6) | public struct EqMap<K, V> : Eq<Map<K, V>>
method Equals (line 14) | [Pure]
method GetHashCode (line 22) | [Pure]
method Equals (line 36) | [Pure]
method GetHashCode (line 44) | [Pure]
type EqMap (line 27) | public struct EqMap<OrdK, K, V> : Eq<Map<OrdK, K, V>>
method Equals (line 14) | [Pure]
method GetHashCode (line 22) | [Pure]
method Equals (line 36) | [Pure]
method GetHashCode (line 44) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqOption.cs
type EqOption (line 9) | public struct EqOption<A> : Eq<Option<A>>
method Equals (line 11) | [Pure]
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqPatch.cs
type EqPatch (line 9) | public struct EqPatch<EqA, A> : Eq<Patch<EqA, A>> where EqA : Eq<A>
method Equals (line 11) | [Pure]
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqQue.cs
type EqQue (line 13) | public struct EqQue<EQ, A> : Eq<Que<A>> where EQ : Eq<A>
method Equals (line 15) | [Pure]
method GetHashCode (line 39) | [Pure]
method Equals (line 52) | [Pure]
method GetHashCode (line 61) | [Pure]
type EqQue (line 50) | public struct EqQue<A> : Eq<Que<A>>
method Equals (line 15) | [Pure]
method GetHashCode (line 39) | [Pure]
method Equals (line 52) | [Pure]
method GetHashCode (line 61) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqRecord.cs
type EqRecord (line 10) | public struct EqRecord<A> : Eq<A> where A : Record<A>
method Equals (line 12) | [Pure]
method GetHashCode (line 16) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqSeq.cs
type EqSeq (line 12) | public struct EqSeq<EqA, A> : Eq<Seq<A>>
method Equals (line 18) | [Pure]
method GetHashCode (line 41) | [Pure]
method Equals (line 57) | [Pure]
method GetHashCode (line 66) | [Pure]
type EqSeq (line 52) | public struct EqSeq<A> : Eq<Seq<A>>
method Equals (line 18) | [Pure]
method GetHashCode (line 41) | [Pure]
method Equals (line 57) | [Pure]
method GetHashCode (line 66) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqSet.cs
type EqSet (line 9) | public struct EqSet<EQ, A> : Eq<Set<A>> where EQ : Eq<A>
method Equals (line 17) | [Pure]
method GetHashCode (line 39) | [Pure]
method Equals (line 55) | [Pure]
method GetHashCode (line 64) | [Pure]
type EqSet (line 47) | public struct EqSet<A> : Eq<Set<A>>
method Equals (line 17) | [Pure]
method GetHashCode (line 39) | [Pure]
method Equals (line 55) | [Pure]
method GetHashCode (line 64) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqShort.cs
type EqShort (line 9) | public struct EqShort : Eq<short>
method Equals (line 17) | [Pure]
method GetHashCode (line 26) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqStck.cs
type EqStck (line 12) | public struct EqStck<EQ, A> : Eq<Stck<A>> where EQ : Eq<A>
method Equals (line 14) | [Pure]
method GetHashCode (line 37) | [Pure]
method Equals (line 50) | [Pure]
method GetHashCode (line 59) | [Pure]
type EqStck (line 48) | public struct EqStck<A> : Eq<Stck<A>>
method Equals (line 14) | [Pure]
method GetHashCode (line 37) | [Pure]
method Equals (line 50) | [Pure]
method GetHashCode (line 59) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqString.cs
type EqString (line 10) | public struct EqString : Eq<string>
method Equals (line 18) | [Pure]
method GetHashCode (line 27) | [Pure]
type EqStringInvariantCulture (line 35) | public struct EqStringInvariantCulture : Eq<string>
method Equals (line 43) | [Pure]
method GetHashCode (line 52) | [Pure]
type EqStringInvariantCultureIgnoreCase (line 60) | public struct EqStringInvariantCultureIgnoreCase : Eq<string>
method Equals (line 68) | [Pure]
method GetHashCode (line 77) | [Pure]
type EqStringOrdinalIgnoreCase (line 85) | public struct EqStringOrdinalIgnoreCase : Eq<string>
method Equals (line 93) | [Pure]
method GetHashCode (line 102) | [Pure]
type EqStringOrdinal (line 110) | public struct EqStringOrdinal : Eq<string>
method Equals (line 120) | [Pure]
method GetHashCode (line 129) | [Pure]
type EqStringCurrentCultureIgnoreCase (line 137) | public struct EqStringCurrentCultureIgnoreCase : Eq<string>
method Equals (line 145) | [Pure]
method GetHashCode (line 154) | [Pure]
type EqStringCurrentCulture (line 162) | public struct EqStringCurrentCulture : Eq<string>
method Equals (line 172) | [Pure]
method GetHashCode (line 181) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqTask.cs
type EqTask (line 8) | public struct EqTask<A> : Eq<Task<A>>
method Equals (line 10) | [Pure]
method GetHashCode (line 14) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqTrue.cs
type EqTrue (line 9) | public struct EqTrue<A> : Eq<A>
method Equals (line 11) | [Pure]
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Eq/EqTuple2.cs
type EqTuple2 (line 5) | public struct EqTuple2<EqA, EqB, A, B> : Eq<(A, B)>
method GetHashCode (line 9) | public static int GetHashCode((A, B) pair) =>
method Equals (line 13) | public static bool Equals((A, B) x, (A, B) y) =>
FILE: LanguageExt.Core/Class Instances/Eq/EqTypeInfo.cs
type EqTypeInfo (line 7) | public struct EqTypeInfo : Eq<TypeInfo>
method Equals (line 9) | [Pure]
method GetHashCode (line 13) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableArr.cs
type HashableArr (line 9) | public struct HashableArr<HashA, A> : Hashable<Arr<A>> where HashA : Has...
method GetHashCode (line 16) | [Pure]
method GetHashCode (line 31) | [Pure]
type HashableArr (line 24) | public struct HashableArr<A> : Hashable<Arr<A>>
method GetHashCode (line 16) | [Pure]
method GetHashCode (line 31) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableArray.cs
type HashableArray (line 9) | public struct HashableArray<HashA, A> : Hashable<A[]> where HashA : Hash...
method GetHashCode (line 16) | [Pure]
method GetHashCode (line 31) | [Pure]
type HashableArray (line 24) | public struct HashableArray<A> : Hashable<A[]>
method GetHashCode (line 16) | [Pure]
method GetHashCode (line 31) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableBigInt.cs
type HashableBigInt (line 8) | public struct HashableBigInt : Hashable<bigint>
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableBool.cs
type HashableBool (line 8) | public struct HashableBool : Hashable<bool>
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableChar.cs
type HashableChar (line 9) | public struct HashableChar : Hashable<char>
method GetHashCode (line 16) | [Pure]
type HashableCharOrdinalIgnoreCase (line 24) | public struct HashableCharOrdinalIgnoreCase : Hashable<char>
method GetHashCode (line 31) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableCompositions.cs
type HashableCompositions (line 6) | public struct HashableCompositions<A> : Hashable<Compositions<A>>
method GetHashCode (line 9) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableDateTime.cs
type HashableDateTime (line 9) | public struct HashableDateTime : Hashable<DateTime>
method GetHashCode (line 16) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableDecimal.cs
type HashableDecimal (line 8) | public struct HashableDecimal : Hashable<decimal>
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableDefault.cs
type HashableDefault (line 10) | public struct HashableDefault<A> : Hashable<A>
method GetHashCode (line 17) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableDouble.cs
type HashableDouble (line 8) | public struct HashableDouble : Hashable<double>
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableEdit.cs
type HashableEdit (line 9) | public struct HashableEdit<EqA, A> : Hashable<Edit<EqA, A>> where EqA : ...
method GetHashCode (line 11) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableEither.cs
type HashableEither (line 8) | public readonly struct HashableEither<HashableL, HashableR, L, R> : Hash...
method GetHashCode (line 17) | [Pure]
method GetHashCode (line 37) | [Pure]
type HashableEither (line 30) | public readonly struct HashableEither<L, R> : Hashable<Either<L, R>>
method GetHashCode (line 17) | [Pure]
method GetHashCode (line 37) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableEnumerable.cs
type HashableEnumerable (line 10) | public struct HashableEnumerable<HashA, A> : Hashable<IEnumerable<A>>
method GetHashCode (line 18) | [Pure]
method GetHashCode (line 33) | [Pure]
type HashableEnumerable (line 26) | public struct HashableEnumerable<A> : Hashable<IEnumerable<A>>
method GetHashCode (line 18) | [Pure]
method GetHashCode (line 33) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableException.cs
type HashableException (line 6) | public struct HashableException : Hashable<Exception>
method GetHashCode (line 8) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableFloat.cs
type HashableFloat (line 8) | public struct HashableFloat : Hashable<float>
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableGuid.cs
type HashableGuid (line 9) | public struct HashableGuid : Hashable<Guid>
method GetHashCode (line 16) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableHashSet.cs
type HashableHashSet (line 9) | public struct HashableHashSet<HashA, A> : Hashable<HashSet<A>> where Has...
method GetHashCode (line 16) | [Pure]
method GetHashCode (line 31) | [Pure]
type HashableHashSet (line 24) | public struct HashableHashSet<A> : Hashable<HashSet<A>>
method GetHashCode (line 16) | [Pure]
method GetHashCode (line 31) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableIdentity.cs
type HashableIdentity (line 8) | public struct HashableIdentity<A> : Hashable<Identity<A>>
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableInt.cs
type HashableInt (line 8) | public struct HashableInt : Hashable<int>
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableIterable.cs
type HashableIterable (line 10) | public struct HashableIterable<HashA, A> : Hashable<Iterable<A>>
method GetHashCode (line 18) | [Pure]
method GetHashCode (line 33) | [Pure]
type HashableIterable (line 26) | public struct HashableIterable<A> : Hashable<Iterable<A>>
method GetHashCode (line 18) | [Pure]
method GetHashCode (line 33) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableLong.cs
type HashableLong (line 8) | public struct HashableLong : Hashable<long>
method GetHashCode (line 15) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableLst.cs
type HashableLst (line 9) | public struct HashableLst<HashA, A> : Hashable<Lst<A>> where HashA : Has...
method GetHashCode (line 16) | [Pure]
method GetHashCode (line 31) | [Pure]
type HashableLst (line 24) | public struct HashableLst<A> : Hashable<Lst<A>>
method GetHashCode (line 16) | [Pure]
method GetHashCode (line 31) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableMap.cs
type HashableMap (line 6) | public struct HashableMap<K, V> : Hashable<Map<K, V>>
method GetHashCode (line 12) | [Pure]
method GetHashCode (line 24) | [Pure]
type HashableMap (line 17) | public struct HashableMap<OrdK, K, V> : Hashable<Map<OrdK, K, V>>
method GetHashCode (line 12) | [Pure]
method GetHashCode (line 24) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableOption.cs
type HashableOption (line 6) | public struct HashableOption<A> : Hashable<Option<A>>
method GetHashCode (line 13) | public static int GetHashCode(Option<A> x) =>
FILE: LanguageExt.Core/Class Instances/Hashable/HashablePair.cs
type HashablePair (line 6) | public struct HashablePair<HashA, HashB, A, B> : Hashable<(A, B)>
method GetHashCode (line 10) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashablePatch.cs
type HashablePatch (line 10) | public struct HashablePatch<EqA, A> : Hashable<Patch<EqA, A>> where EqA ...
method GetHashCode (line 17) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableQue.cs
type HashableQue (line 8) | public struct HashableQue<HashA, A> : Hashable<Que<A>> where HashA : Has...
method GetHashCode (line 15) | [Pure]
method GetHashCode (line 30) | [Pure]
type HashableQue (line 23) | public struct HashableQue<A> : Hashable<Que<A>>
method GetHashCode (line 15) | [Pure]
method GetHashCode (line 30) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableRecord.cs
type HashableRecord (line 10) | public struct HashableRecord<A> : Hashable<A> where A : Record<A>
method GetHashCode (line 17) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableSeq.cs
type HashableSeq (line 9) | public struct HashableSeq<HashA, A> : Hashable<Seq<A>>
method GetHashCode (line 17) | [Pure]
method GetHashCode (line 32) | [Pure]
type HashableSeq (line 25) | public struct HashableSeq<A> : Hashable<Seq<A>>
method GetHashCode (line 17) | [Pure]
method GetHashCode (line 32) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableSet.cs
type HashableSet (line 8) | public struct HashableSet<HashA, A> : Hashable<Set<A>> where HashA : Has...
method GetHashCode (line 15) | [Pure]
method GetHashCode (line 30) | [Pure]
type HashableSet (line 23) | public struct HashableSet<A> : Hashable<Set<A>>
method GetHashCode (line 15) | [Pure]
method GetHashCode (line 30) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableShort.cs
type HashableShort (line 9) | public struct HashableShort : Hashable<short>
method GetHashCode (line 16) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableStck.cs
type HashableStck (line 9) | public struct HashableStck<HashA, A> : Hashable<Stck<A>> where HashA : H...
method GetHashCode (line 16) | [Pure]
method GetHashCode (line 31) | [Pure]
type HashableStck (line 24) | public struct HashableStck<A> : Hashable<Stck<A>>
method GetHashCode (line 16) | [Pure]
method GetHashCode (line 31) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableString.cs
type HashableString (line 10) | public struct HashableString : Hashable<string>
method GetHashCode (line 17) | [Pure]
type HashableStringInvariantCulture (line 26) | public struct HashableStringInvariantCulture : Hashable<string>
method GetHashCode (line 33) | [Pure]
type HashableStringInvariantCultureIgnoreCase (line 43) | public struct HashableStringInvariantCultureIgnoreCase : Hashable<string>
method GetHashCode (line 50) | [Pure]
type HashableStringOrdinalIgnoreCase (line 59) | public struct HashableStringOrdinalIgnoreCase : Hashable<string>
method GetHashCode (line 66) | [Pure]
type HashableStringOrdinal (line 75) | public struct HashableStringOrdinal : Hashable<string>
method GetHashCode (line 82) | [Pure]
type HashableStringCurrentCultureIgnoreCase (line 91) | public struct HashableStringCurrentCultureIgnoreCase : Hashable<string>
method GetHashCode (line 98) | [Pure]
type HashableStringCurrentCulture (line 107) | public struct HashableStringCurrentCulture : Hashable<string>
method GetHashCode (line 114) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableTask.cs
type HashableTask (line 7) | public struct HashableTask<A> : Hashable<Task<A>>
method GetHashCode (line 14) | [Pure]
FILE: LanguageExt.Core/Class Instances/Hashable/HashableTuple.cs
type HashableTuple (line 3) | public struct HashableTuple<HashA, HashB, A, B> : Hashable<(A, B)>
method GetHashCode (line 7) | public static int GetHashCode((A, B) pair) =>
FILE: LanguageExt.Core/Class Instances/Hashable/HashableTypeInfo.cs
type HashableTypeInfo (line 7) | public struct HashableTypeInfo : Hashable<TypeInfo>
method GetHashCode (line 14) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdArr.cs
type OrdArr (line 9) | public struct OrdArr<OrdA, A> : Ord<Arr<A>>
method Equals (line 18) | [Pure]
method Compare (line 32) | [Pure]
method GetHashCode (line 57) | [Pure]
method Equals (line 73) | [Pure]
method Compare (line 87) | [Pure]
method GetHashCode (line 95) | [Pure]
type OrdArr (line 65) | public struct OrdArr<A> : Ord<Arr<A>>
method Equals (line 18) | [Pure]
method Compare (line 32) | [Pure]
method GetHashCode (line 57) | [Pure]
method Equals (line 73) | [Pure]
method Compare (line 87) | [Pure]
method GetHashCode (line 95) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdArray.cs
type OrdArray (line 10) | public struct OrdArray<OrdA, A> : Ord<A[]>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 60) | [Pure]
method Equals (line 76) | [Pure]
method Compare (line 90) | [Pure]
method GetHashCode (line 98) | [Pure]
type OrdArray (line 68) | public struct OrdArray<A> : Ord<A[]>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 60) | [Pure]
method Equals (line 76) | [Pure]
method Compare (line 90) | [Pure]
method GetHashCode (line 98) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdBigInt.cs
type OrdBigInt (line 9) | public struct OrdBigInt : Ord<bigint>
method Equals (line 17) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 41) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdBool.cs
type OrdBool (line 9) | public struct OrdBool : Ord<bool>
method Equals (line 17) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 41) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdChar.cs
type OrdChar (line 9) | public struct OrdChar : Ord<char>
method Equals (line 19) | [Pure]
method Compare (line 35) | [Pure]
method GetHashCode (line 43) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdDateTime.cs
type OrdDateTime (line 10) | public struct OrdDateTime : Ord<DateTime>
method Equals (line 18) | [Pure]
method Compare (line 34) | [Pure]
method GetHashCode (line 42) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdDecimal.cs
type OrdDecimal (line 9) | public struct OrdDecimal : Ord<decimal>
method Equals (line 17) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 41) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdDefault.cs
type OrdDefault (line 11) | public struct OrdDefault<A> : Ord<A>
method Compare (line 19) | [Pure]
method Equals (line 23) | [Pure]
method GetHashCode (line 31) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdDouble.cs
type OrdDouble (line 9) | public struct OrdDouble : Ord<double>
method Equals (line 17) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 41) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdEither.cs
type OrdEither (line 9) | public struct OrdEither<OrdL, OrdR, L, R> : Ord<Either<L, R>>
method Compare (line 16) | [Pure]
method Equals (line 23) | [Pure]
method GetHashCode (line 32) | [Pure]
method Compare (line 45) | [Pure]
method Equals (line 52) | [Pure]
method GetHashCode (line 61) | [Pure]
type OrdEither (line 40) | public struct OrdEither<L, R> : Ord<Either<L, R>>
method Compare (line 16) | [Pure]
method Equals (line 23) | [Pure]
method GetHashCode (line 32) | [Pure]
method Compare (line 45) | [Pure]
method Equals (line 52) | [Pure]
method GetHashCode (line 61) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdEnumerable.cs
type OrdEnumerable (line 12) | public struct OrdEnumerable<OrdA, A> : Ord<IEnumerable<A>>
method Equals (line 23) | [Pure]
method Compare (line 37) | [Pure]
method GetHashCode (line 64) | [Pure]
method Equals (line 80) | [Pure]
method Compare (line 94) | [Pure]
method GetHashCode (line 102) | [Pure]
type OrdEnumerable (line 72) | public struct OrdEnumerable<A> : Ord<IEnumerable<A>>
method Equals (line 23) | [Pure]
method Compare (line 37) | [Pure]
method GetHashCode (line 64) | [Pure]
method Equals (line 80) | [Pure]
method Compare (line 94) | [Pure]
method GetHashCode (line 102) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdException.cs
type OrdException (line 8) | public struct OrdException : Ord<Exception>
method GetHashCode (line 10) | [Pure]
method Equals (line 14) | [Pure]
method Compare (line 18) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdFloat.cs
type OrdFloat (line 9) | public struct OrdFloat : Ord<float>
method Equals (line 17) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 41) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdGuid.cs
type OrdGuid (line 10) | public struct OrdGuid : Ord<Guid>
method Equals (line 18) | [Pure]
method Compare (line 34) | [Pure]
method GetHashCode (line 42) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdHashSet.cs
type OrdHashSet (line 10) | public struct OrdHashSet<OrdA, A> : Ord<HashSet<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 55) | [Pure]
method Equals (line 71) | [Pure]
method Compare (line 85) | [Pure]
method GetHashCode (line 93) | [Pure]
type OrdHashSet (line 63) | public struct OrdHashSet<A> : Ord<HashSet<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 55) | [Pure]
method Equals (line 71) | [Pure]
method Compare (line 85) | [Pure]
method GetHashCode (line 93) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdInt.cs
type OrdInt (line 10) | public struct OrdInt : Ord<int>
method Equals (line 18) | [Pure]
method Compare (line 34) | [Pure]
method GetHashCode (line 42) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdIterable.cs
type OrdIterable (line 12) | public struct OrdIterable<OrdA, A> : Ord<Iterable<A>>
method Equals (line 21) | [Pure]
method Compare (line 35) | [Pure]
method GetHashCode (line 62) | [Pure]
method Equals (line 78) | [Pure]
method Compare (line 92) | [Pure]
method GetHashCode (line 100) | [Pure]
type OrdIterable (line 70) | public struct OrdIterable<A> : Ord<Iterable<A>>
method Equals (line 21) | [Pure]
method Compare (line 35) | [Pure]
method GetHashCode (line 62) | [Pure]
method Equals (line 78) | [Pure]
method Compare (line 92) | [Pure]
method GetHashCode (line 100) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdLong.cs
type OrdLong (line 10) | public struct OrdLong : Ord<long>
method Equals (line 18) | [Pure]
method Compare (line 34) | [Pure]
method GetHashCode (line 42) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdLst.cs
type OrdLst (line 10) | public struct OrdLst<OrdA, A> : Ord<Lst<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 58) | [Pure]
method Equals (line 74) | [Pure]
method Compare (line 88) | [Pure]
method GetHashCode (line 96) | [Pure]
type OrdLst (line 66) | public struct OrdLst<A> : Ord<Lst<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 58) | [Pure]
method Equals (line 74) | [Pure]
method Compare (line 88) | [Pure]
method GetHashCode (line 96) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdMap.cs
type OrdMap (line 9) | public struct OrdMap<OrdK, K, V> : Ord<Map<OrdK, K, V>>
method Compare (line 22) | [Pure]
method Equals (line 32) | [Pure]
method GetHashCode (line 40) | [Pure]
method Compare (line 60) | [Pure]
method Equals (line 70) | [Pure]
method GetHashCode (line 78) | [Pure]
type OrdMap (line 48) | public struct OrdMap<K, V> : Ord<Map<K, V>>
method Compare (line 22) | [Pure]
method Equals (line 32) | [Pure]
method GetHashCode (line 40) | [Pure]
method Compare (line 60) | [Pure]
method Equals (line 70) | [Pure]
method GetHashCode (line 78) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdOption.cs
type OrdOption (line 7) | public struct OrdOption<OrdA, A> : Ord<Option<A>>
method Compare (line 10) | [Pure]
method Equals (line 14) | [Pure]
method GetHashCode (line 18) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdQue.cs
type OrdQue (line 10) | public struct OrdQue<OrdA, A> : Ord<Que<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 62) | [Pure]
method Equals (line 78) | [Pure]
method Compare (line 92) | [Pure]
method GetHashCode (line 100) | [Pure]
type OrdQue (line 70) | public struct OrdQue<A> : Ord<Que<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 62) | [Pure]
method Equals (line 78) | [Pure]
method Compare (line 92) | [Pure]
method GetHashCode (line 100) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdRecord.cs
type OrdRecord (line 10) | public struct OrdRecord<A> : Ord<A> where A : Record<A>
method Compare (line 12) | [Pure]
method Equals (line 16) | [Pure]
method GetHashCode (line 20) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdSeq.cs
type OrdSeq (line 10) | public struct OrdSeq<OrdA, A> : Ord<Seq<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 56) | [Pure]
method Equals (line 72) | [Pure]
method Compare (line 86) | [Pure]
method GetHashCode (line 94) | [Pure]
type OrdSeq (line 64) | public struct OrdSeq<A> : Ord<Seq<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 56) | [Pure]
method Equals (line 72) | [Pure]
method Compare (line 86) | [Pure]
method GetHashCode (line 94) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdSet.cs
type OrdSet (line 10) | public struct OrdSet<OrdA, A> : Ord<Set<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 41) | [Pure]
method Equals (line 57) | [Pure]
method Compare (line 71) | [Pure]
method GetHashCode (line 79) | [Pure]
type OrdSet (line 49) | public struct OrdSet<A> : Ord<Set<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 41) | [Pure]
method Equals (line 57) | [Pure]
method Compare (line 71) | [Pure]
method GetHashCode (line 79) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdShort.cs
type OrdShort (line 9) | public struct OrdShort : Ord<short>
method Equals (line 17) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 41) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdStck.cs
type OrdStck (line 10) | public struct OrdStck<OrdA, A> : Ord<Stck<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 62) | [Pure]
method Equals (line 78) | [Pure]
method Compare (line 92) | [Pure]
method GetHashCode (line 100) | [Pure]
type OrdStck (line 70) | public struct OrdStck<A> : Ord<Stck<A>>
method Equals (line 19) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 62) | [Pure]
method Equals (line 78) | [Pure]
method Compare (line 92) | [Pure]
method GetHashCode (line 100) | [Pure]
FILE: LanguageExt.Core/Class Instances/Ord/OrdString.cs
type OrdString (line 9) | public struct OrdString : Ord<string>
method Compare (line 21) | public static int Compare(string a, string b) =>
method Equals (line 30) | public static bool Equals(string a, string b) =>
method GetHashCode (line 37) | public static int GetHashCode(string x) =>
type OrdStringOrdinalIgnoreCase (line 44) | public struct OrdStringOrdinalIgnoreCase : Ord<string>
method Compare (line 56) | public static int Compare(string a, string b) =>
method Equals (line 65) | public static bool Equals(string a, string b) =>
method GetHashCode (line 72) | public static int GetHashCode(string x) =>
type OrdStringOrdinal (line 79) | public struct OrdStringOrdinal : Ord<string>
method Compare (line 91) | public static int Compare(string a, string b) =>
method Equals (line 100) | public static bool Equals(string a, string b) =>
method GetHashCode (line 107) | public static int GetHashCode(string x) =>
type OrdStringCurrentCultureIgnoreCase (line 114) | public struct OrdStringCurrentCultureIgnoreCase : Ord<string>
method Compare (line 126) | public static int Compare(string a, string b) =>
method Equals (line 135) | public static bool Equals(string a, string b) =>
method GetHashCode (line 142) | public static int GetHashCode(string x) =>
type OrdStringCurrentCulture (line 149) | public struct OrdStringCurrentCulture : Ord<string>
method Compare (line 161) | public static int Compare(string a, string b) =>
method Equals (line 170) | public static bool Equals(string a, string b) =>
method GetHashCode (line 177) | public static int GetHashCode(string x) =>
FILE: LanguageExt.Core/Class Instances/Ord/OrdTask.cs
type OrdTask (line 6) | public struct OrdTask<A> : Ord<Task<A>>
method Compare (line 8) | public static int Compare(Task<A> x, Task<A> y) =>
method Equals (line 11) | public static bool Equals(Task<A> x, Task<A> y) =>
method GetHashCode (line 14) | public static int GetHashCode(Task<A> x) =>
FILE: LanguageExt.Core/Class Instances/Ord/OrdTrue.cs
type OrdTrue (line 8) | public struct OrdTrue<A> : Ord<A>
method Compare (line 10) | public static int Compare(A x, A y) =>
method Equals (line 13) | public static bool Equals(A x, A y) =>
method GetHashCode (line 16) | public static int GetHashCode(A x) =>
FILE: LanguageExt.Core/Class Instances/Ord/OrdTupleFirst.cs
type OrdTupleFirst (line 10) | public struct OrdTupleFirst<OrdA, A, B> : Ord<ValueTuple<A, B>> where Or...
method Compare (line 12) | public static int Compare((A, B) x, (A, B) y) =>
method Equals (line 15) | public static bool Equals((A, B) x, (A, B) y) =>
method GetHashCode (line 18) | public static int GetHashCode((A, B) x) =>
FILE: LanguageExt.Core/Class Instances/Ord/OrdTypeInfo.cs
type OrdTypeInfo (line 7) | public struct OrdTypeInfo : Ord<TypeInfo>
method Compare (line 9) | public static int Compare(TypeInfo x, TypeInfo y) =>
method Equals (line 12) | public static bool Equals(TypeInfo x, TypeInfo y) =>
method GetHashCode (line 15) | public static int GetHashCode(TypeInfo x) =>
FILE: LanguageExt.Core/Class Instances/TBigInt.cs
type TBigInt (line 9) | public struct TBigInt : Num<bigint>, Bool<bigint>
method Equals (line 17) | [Pure]
method Compare (line 33) | [Pure]
method Add (line 43) | [Pure]
method Subtract (line 53) | [Pure]
method Multiply (line 63) | [Pure]
method Divide (line 73) | [Pure]
method Abs (line 82) | [Pure]
method Signum (line 93) | [Pure]
method FromInteger (line 104) | [Pure]
method FromDecimal (line 113) | [Pure]
method FromFloat (line 122) | [Pure]
method FromDouble (line 131) | [Pure]
method Negate (line 147) | [Pure]
method Append (line 156) | [Pure]
method GetHashCode (line 164) | [Pure]
method True (line 172) | [Pure]
method False (line 180) | [Pure]
method And (line 188) | [Pure]
method Or (line 196) | [Pure]
method Not (line 204) | [Pure]
method XOr (line 212) | [Pure]
method Implies (line 220) | [Pure]
method BiCondition (line 230) | [Pure]
FILE: LanguageExt.Core/Class Instances/TBool.cs
type TBool (line 13) | public struct TBool : Ord<bool>, Bool<bool>
method And (line 19) | [Pure]
method Compare (line 35) | public static int Compare(bool x, bool y) =>
method Equals (line 44) | [Pure]
method False (line 52) | [Pure]
method GetHashCode (line 60) | [Pure]
method Not (line 68) | [Pure]
method Or (line 76) | [Pure]
method True (line 84) | [Pure]
method XOr (line 92) | [Pure]
method Implies (line 100) | [Pure]
method BiCondition (line 109) | [Pure]
FILE: LanguageExt.Core/Class Instances/TBoolBool.cs
type TBoolBool (line 13) | public struct TBoolBool : Ord<(bool, bool)>, Bool<(bool, bool)>
method And (line 19) | [Pure]
method Compare (line 36) | public static int Compare((bool, bool) x, (bool, bool) y) =>
method Equals (line 45) | [Pure]
method False (line 53) | [Pure]
method GetHashCode (line 61) | [Pure]
method Not (line 69) | [Pure]
method Or (line 77) | [Pure]
method True (line 86) | [Pure]
method XOr (line 94) | [Pure]
method Implies (line 103) | [Pure]
method BiCondition (line 113) | [Pure]
FILE: LanguageExt.Core/Class Instances/TChar.cs
type TChar (line 9) | public struct TChar : Ord<char>, Arithmetic<char>
method Equals (line 17) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 41) | [Pure]
method Add (line 45) | [Pure]
method Subtract (line 49) | [Pure]
method Multiply (line 53) | [Pure]
method Negate (line 57) | [Pure]
FILE: LanguageExt.Core/Class Instances/TDecimal.cs
type TDecimal (line 7) | public struct TDecimal : Floating<decimal>
method Equals (line 15) | [Pure]
method Compare (line 30) | [Pure]
method Add (line 40) | [Pure]
method Subtract (line 49) | [Pure]
method Multiply (line 58) | [Pure]
method Divide (line 67) | [Pure]
method Abs (line 76) | [Pure]
method Signum (line 84) | [Pure]
method FromInteger (line 93) | [Pure]
method FromDecimal (line 102) | [Pure]
method FromFloat (line 111) | [Pure]
method FromDouble (line 120) | [Pure]
method FromRational (line 128) | [Pure]
method Pi (line 136) | [Pure]
method Exp (line 145) | [Pure]
method Sqrt (line 154) | [Pure]
method Log (line 165) | [Pure]
method Pow (line 174) | [Pure]
method LogBase (line 184) | [Pure]
method Sin (line 193) | [Pure]
method Cos (line 202) | [Pure]
method Tan (line 211) | [Pure]
method Asin (line 220) | [Pure]
method Acos (line 229) | [Pure]
method Atan (line 238) | [Pure]
method Sinh (line 247) | [Pure]
method Cosh (line 256) | [Pure]
method Tanh (line 267) | [Pure]
method Asinh (line 275) | [Pure]
method Acosh (line 285) | [Pure]
method Atanh (line 295) | [Pure]
method Negate (line 304) | [Pure]
method GetHashCode (line 312) | [Pure]
FILE: LanguageExt.Core/Class Instances/TDouble.cs
type TDouble (line 7) | public struct TDouble : Floating<double>
method Equals (line 15) | [Pure]
method Compare (line 31) | [Pure]
method Add (line 41) | [Pure]
method Subtract (line 51) | [Pure]
method Multiply (line 61) | [Pure]
method Divide (line 71) | [Pure]
method Abs (line 80) | [Pure]
method Signum (line 89) | [Pure]
method FromInteger (line 98) | [Pure]
method FromDecimal (line 107) | [Pure]
method FromFloat (line 116) | [Pure]
method FromDouble (line 125) | [Pure]
method FromRational (line 134) | [Pure]
method Pi (line 142) | [Pure]
method Exp (line 151) | [Pure]
method Sqrt (line 160) | [Pure]
method Log (line 171) | [Pure]
method Pow (line 180) | [Pure]
method LogBase (line 190) | [Pure]
method Sin (line 199) | [Pure]
method Cos (line 208) | [Pure]
method Tan (line 217) | [Pure]
method Asin (line 226) | [Pure]
method Acos (line 235) | [Pure]
method Atan (line 244) | [Pure]
method Sinh (line 253) | [Pure]
method Cosh (line 262) | [Pure]
method Tanh (line 273) | [Pure]
method Asinh (line 281) | [Pure]
method Acosh (line 291) | [Pure]
method Atanh (line 301) | [Pure]
method Negate (line 310) | [Pure]
method GetHashCode (line 318) | [Pure]
FILE: LanguageExt.Core/Class Instances/TFloat.cs
type TFloat (line 7) | public struct TFloat : Floating<float>
method Equals (line 15) | [Pure]
method Compare (line 31) | [Pure]
method Add (line 41) | [Pure]
method Subtract (line 50) | [Pure]
method Multiply (line 60) | [Pure]
method Divide (line 69) | [Pure]
method Abs (line 78) | [Pure]
method Signum (line 86) | [Pure]
method FromInteger (line 94) | [Pure]
method FromDecimal (line 102) | [Pure]
method FromFloat (line 110) | [Pure]
method FromDouble (line 118) | [Pure]
method FromRational (line 126) | [Pure]
method Pi (line 133) | [Pure]
method Exp (line 141) | [Pure]
method Sqrt (line 149) | [Pure]
method Log (line 159) | [Pure]
method Pow (line 167) | [Pure]
method LogBase (line 176) | [Pure]
method Sin (line 184) | [Pure]
method Cos (line 192) | [Pure]
method Tan (line 200) | [Pure]
method Asin (line 208) | [Pure]
method Acos (line 216) | [Pure]
method Atan (line 224) | [Pure]
method Sinh (line 232) | [Pure]
method Cosh (line 240) | [Pure]
method Tanh (line 250) | [Pure]
method Asinh (line 257) | [Pure]
method Acosh (line 266) | [Pure]
method Atanh (line 275) | [Pure]
method Negate (line 283) | [Pure]
method GetHashCode (line 290) | [Pure]
FILE: LanguageExt.Core/Class Instances/TInt.cs
type TInt (line 10) | public struct TInt : Num<int>, Bool<int>
method Equals (line 18) | [Pure]
method Compare (line 34) | [Pure]
method Add (line 44) | [Pure]
method Subtract (line 54) | [Pure]
method Multiply (line 64) | [Pure]
method Divide (line 74) | [Pure]
method Abs (line 83) | [Pure]
method Signum (line 92) | [Pure]
method FromInteger (line 101) | [Pure]
method FromDecimal (line 110) | [Pure]
method FromFloat (line 119) | [Pure]
method FromDouble (line 128) | [Pure]
method Negate (line 137) | [Pure]
method GetHashCode (line 144) | [Pure]
method True (line 152) | [Pure]
method False (line 160) | [Pure]
method And (line 168) | [Pure]
method Or (line 176) | [Pure]
method Not (line 184) | [Pure]
method XOr (line 192) | [Pure]
method Implies (line 200) | [Pure]
method BiCondition (line 210) | [Pure]
FILE: LanguageExt.Core/Class Instances/TLong.cs
type TLong (line 10) | public struct TLong : Num<long>, Bool<long>
method Equals (line 18) | [Pure]
method Compare (line 34) | [Pure]
method Add (line 44) | [Pure]
method Subtract (line 54) | [Pure]
method Multiply (line 64) | [Pure]
method Divide (line 74) | [Pure]
method Abs (line 83) | [Pure]
method Signum (line 92) | [Pure]
method FromInteger (line 101) | [Pure]
method FromDecimal (line 110) | [Pure]
method FromFloat (line 119) | [Pure]
method FromDouble (line 128) | [Pure]
method Negate (line 137) | [Pure]
method GetHashCode (line 144) | [Pure]
method True (line 152) | [Pure]
method False (line 160) | [Pure]
method And (line 168) | [Pure]
method Or (line 176) | [Pure]
method Not (line 184) | [Pure]
method XOr (line 192) | [Pure]
method Implies (line 200) | [Pure]
method BiCondition (line 210) | [Pure]
FILE: LanguageExt.Core/Class Instances/TNumericChar.cs
type TNumericChar (line 9) | public struct TNumericChar : Num<char>
method Equals (line 17) | [Pure]
method Compare (line 33) | [Pure]
method GetHashCode (line 41) | [Pure]
method Add (line 45) | [Pure]
method Subtract (line 49) | [Pure]
method Multiply (line 53) | [Pure]
method Negate (line 57) | [Pure]
method CharToInt (line 61) | static int CharToInt(int x) =>
method Abs (line 66) | public static char Abs(char x) =>
method Signum (line 69) | public static char Signum(char x) =>
method FromInteger (line 72) | public static char FromInteger(int x) =>
method FromDecimal (line 75) | public static char FromDecimal(decimal x) =>
method FromFloat (line 78) | public static char FromFloat(float x) =>
method FromDouble (line 81) | public static char FromDouble(double x) =>
method Divide (line 84) | public static char Divide(char x, char y) =>
FILE: LanguageExt.Core/Class Instances/TShort.cs
type TShort (line 10) | public struct TShort : Num<short>, Bool<short>
method Equals (line 18) | [Pure]
method Compare (line 34) | [Pure]
method Add (line 44) | [Pure]
method Subtract (line 54) | [Pure]
method Multiply (line 64) | [Pure]
method Divide (line 74) | [Pure]
method Abs (line 83) | [Pure]
method Signum (line 92) | [Pure]
method FromInteger (line 101) | [Pure]
method FromDecimal (line 110) | [Pure]
method FromFloat (line 119) | [Pure]
method FromDouble (line 128) | [Pure]
method Negate (line 137) | [Pure]
method GetHashCode (line 144) | [Pure]
method True (line 152) | [Pure]
method False (line 160) | [Pure]
method And (line 168) | [Pure]
method Or (line 176) | [Pure]
method Not (line 184) | [Pure]
method XOr (line 192) | [Pure]
method Implies (line 200) | [Pure]
method BiCondition (line 210) | [Pure]
FILE: LanguageExt.Core/Class Instances/TString.cs
type TString (line 6) | public struct TString : Ord<string>
method Equals (line 14) | [Pure]
method Compare (line 30) | [Pure]
method GetHashCode (line 38) | [Pure]
type TStringOrdinalIgnoreCase (line 43) | public struct TStringOrdinalIgnoreCase : Ord<string>
method Equals (line 51) | [Pure]
method Compare (line 67) | [Pure]
method GetHashCode (line 75) | [Pure]
type TStringOrdinal (line 80) | public struct TStringOrdinal : Ord<string>
method Equals (line 88) | [Pure]
method Compare (line 104) | [Pure]
method GetHashCode (line 112) | [Pure]
type TStringCurrentCultureIgnoreCase (line 117) | public struct TStringCurrentCultureIgnoreCase : Ord<string>
method Equals (line 125) | [Pure]
method Compare (line 141) | [Pure]
method GetHashCode (line 149) | [Pure]
type TStringCurrentCulture (line 154) | public struct TStringCurrentCulture : Ord<string>
method Equals (line 162) | [Pure]
method Compare (line 178) | [Pure]
method GetHashCode (line 186) | [Pure]
FILE: LanguageExt.Core/Combinators.cs
class CombinatorsDynamic (line 6) | public static class CombinatorsDynamic
class Combinators (line 66) | public static class Combinators<A>
method I (line 137) | public static A I<A>(A x) => x;
method K (line 142) | public static Func<B, A> K<A, B>(A x) => (B y) => x;
method M (line 147) | public static Func<A, A> M<A>(Func<A, A> x) =>
method T (line 153) | public static Func<Func<A, B>, B> T<A, B>(A x) => (Func<A, B> y) =>
method Q (line 159) | public static Func<Func<B, C>, Func<A, C>> Q<A, B, C>(Func<A, B> x) =>...
method S (line 165) | public static Func<Func<A, B>, Func<A, C>> S<A, B, C>(Func<A, B, C> x)...
class Combinators (line 84) | public static class Combinators<A, B>
method I (line 137) | public static A I<A>(A x) => x;
method K (line 142) | public static Func<B, A> K<A, B>(A x) => (B y) => x;
method M (line 147) | public static Func<A, A> M<A>(Func<A, A> x) =>
method T (line 153) | public static Func<Func<A, B>, B> T<A, B>(A x) => (Func<A, B> y) =>
method Q (line 159) | public static Func<Func<B, C>, Func<A, C>> Q<A, B, C>(Func<A, B> x) =>...
method S (line 165) | public static Func<Func<A, B>, Func<A, C>> S<A, B, C>(Func<A, B, C> x)...
class Combinators (line 103) | public static class Combinators<A, B, C>
method I (line 137) | public static A I<A>(A x) => x;
method K (line 142) | public static Func<B, A> K<A, B>(A x) => (B y) => x;
method M (line 147) | public static Func<A, A> M<A>(Func<A, A> x) =>
method T (line 153) | public static Func<Func<A, B>, B> T<A, B>(A x) => (Func<A, B> y) =>
method Q (line 159) | public static Func<Func<B, C>, Func<A, C>> Q<A, B, C>(Func<A, B> x) =>...
method S (line 165) | public static Func<Func<A, B>, Func<A, C>> S<A, B, C>(Func<A, B, C> x)...
class Combinators (line 132) | public static class Combinators
method I (line 137) | public static A I<A>(A x) => x;
method K (line 142) | public static Func<B, A> K<A, B>(A x) => (B y) => x;
method M (line 147) | public static Func<A, A> M<A>(Func<A, A> x) =>
method T (line 153) | public static Func<Func<A, B>, B> T<A, B>(A x) => (Func<A, B> y) =>
method Q (line 159) | public static Func<Func<B, C>, Func<A, C>> Q<A, B, C>(Func<A, B> x) =>...
method S (line 165) | public static Func<Func<A, B>, Func<A, C>> S<A, B, C>(Func<A, B, C> x)...
FILE: LanguageExt.Core/Common/Error.cs
type Error (line 17) | [DataContract]
type Expected (line 435) | [DataContract]
type Exceptional (line 510) | [DataContract]
type BottomError (line 611) | [DataContract]
type ManyErrors (line 683) | [DataContract]
FILE: LanguageExt.Core/Common/ErrorCodes.cs
class ErrorCodes (line 3) | public static class ErrorCodes
FILE: LanguageExt.Core/Common/ErrorException.cs
class ErrorException (line 32) | public abstract class ErrorException : Exception, IEnumerable<ErrorExcep...
method ErrorException (line 34) | protected ErrorException(int code) =>
method ToError (line 52) | [Pure]
method Combine (line 79) | [Pure]
method GetEnumerator (line 94) | [Pure]
method GetEnumerator (line 100) | [Pure]
method ToString (line 106) | [Pure]
method New (line 115) | [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
method New (line 124) | [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
method New (line 132) | [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
method New (line 141) | [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
method New (line 151) | [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
method New (line 160) | [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
method Many (line 169) | [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
method Many (line 178) | [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
class ExpectedException (line 186) | public class ExpectedException(string message, int code, Option<ErrorExc...
method ToString (line 203) | [Pure]
method ToError (line 216) | [Pure]
method Combine (line 238) | [Pure]
class WrappedErrorExpectedException (line 249) | public sealed class WrappedErrorExpectedException(Error Error) :
method ToError (line 256) | public override Error ToError() =>
method ToString (line 262) | [Pure]
class ExceptionalException (line 271) | public class ExceptionalException : ErrorException
method ExceptionalException (line 273) | public ExceptionalException(Exception Exception) : base(Exception.HRes...
method ExceptionalException (line 280) | public ExceptionalException(string Message, int Code) : base(Code)
method ExceptionalException (line 286) | public ExceptionalException(string Message, Exception Exception) : bas...
method ToString (line 299) | [Pure]
method ToError (line 316) | public override Error ToError() =>
method Combine (line 341) | [Pure]
class WrappedErrorExceptionalException (line 352) | public sealed class WrappedErrorExceptionalException(Error Error) :
method ToError (line 359) | public override Error ToError() =>
method ToString (line 365) | [Pure]
class ManyExceptions (line 374) | public sealed class ManyExceptions(Seq<ErrorException> errors) : ErrorEx...
method ToError (line 396) | public override Error ToError() =>
method ToString (line 402) | [Pure]
method Combine (line 434) | [Pure]
method GetEnumerator (line 440) | [Pure]
class BottomException (line 450) | [Serializable]
method BottomException (line 456) | static BottomException() =>
method ToError (line 468) | public override Error ToError() =>
method Combine (line 471) | public override ErrorException Combine(ErrorException error) => throw ...
class ExceptionExtensions (line 474) | public static class ExceptionExtensions
method Rethrow (line 479) | public static Unit Rethrow(this Exception e)
method Rethrow (line 488) | public static R Rethrow<R>(this Exception e)
FILE: LanguageExt.Core/Common/Errors.cs
class Errors (line 3) | public static class Errors
method ParseError (line 47) | public static Error ParseError(string msg) => (ErrorCodes.ParseError, ...
FILE: LanguageExt.Core/Common/Exceptions.cs
class Exceptions (line 3) | public class Exceptions
method ParseError (line 43) | public static ExpectedException ParseError(string msg) => new (msg, Er...
FILE: LanguageExt.Core/Concurrency/Async/Async.Module.cs
class Async (line 32) | public static class Async
method await (line 43) | public static A await<A>(Task<A> operation)
method fork (line 75) | public static ForkIO<A> fork<A>(Func<A> operation, TimeSpan timeout = ...
method fork (line 89) | public static ForkIO<A> fork<A>(Func<Task<A>> operation, TimeSpan time...
FILE: LanguageExt.Core/Concurrency/Async/AsyncEnumerable/AsyncEnumberable.Extensions.cs
class AsyncEnumerableExtensions (line 6) | public static class AsyncEnumerableExtensions
method MapAsync (line 14) | public static async IAsyncEnumerable<B> MapAsync<A, B>(this IAsyncEnum...
method ApplyAsync (line 22) | public static async IAsyncEnumerable<B> ApplyAsync<A, B>(this IAsyncEn...
method BindAsync (line 34) | public static async IAsyncEnumerable<B> BindAsync<A, B>(this IAsyncEnu...
method FilterAsync (line 45) | public static async IAsyncEnumerable<A> FilterAsync<A>(
FILE: LanguageExt.Core/Concurrency/Async/AsyncEnumerable/AsyncEnumberable.LINQ.Extensions.cs
class AsyncEnumerableExtensions (line 8) | public static class AsyncEnumerableExtensions
method Select (line 12) | public async IAsyncEnumerable<B> Select<B>(Func<A, ValueTask<B>> f)
method SelectMany (line 20) | public async IAsyncEnumerable<B> SelectMany<B>(Func<A, IAsyncEnumerabl...
method SelectMany (line 31) | public async IAsyncEnumerable<C> SelectMany<B, C>(Func<A, IAsyncEnumer...
method Where (line 43) | public async IAsyncEnumerable<A> Where(Func<A, bool> f)
method Skip (line 51) | public async IAsyncEnumerable<A> Skip(int amount)
method Take (line 62) | public async IAsyncEnumerable<A> Take(int amount)
FILE: LanguageExt.Core/Concurrency/Atom/Atom.Metadata.cs
class Atom (line 31) | public sealed class Atom<M, A>
method Atom (line 42) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method New (line 56) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method New (line 68) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Swap (line 85) | public A Swap(Func<M, A, A> f)
method Swap (line 124) | public A Swap(Func<M, A, Option<A>> f)
method SwapIO (line 164) | public IO<A> SwapIO(Func<M, A, A> f) =>
method SwapIO (line 182) | public IO<A> SwapIO(Func<M, A, Option<A>> f) =>
method ToString (line 213) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method True (line 229) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
FILE: LanguageExt.Core/Concurrency/Atom/Atom.cs
class Atom (line 31) | public sealed class Atom<A>
method Atom (line 41) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method New (line 54) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method New (line 66) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Swap (line 83) | public A Swap(Func<A, A> f)
method SwapMaybe (line 122) | public A SwapMaybe(Func<A, Option<A>> f)
method SwapIO (line 161) | public IO<A> SwapIO(Func<A, A> f) =>
method SwapMaybeIO (line 179) | public IO<A> SwapMaybeIO(Func<A, Option<A>> f) =>
method True (line 222) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ToString (line 225) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
FILE: LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.Eq.cs
class AtomHashMap (line 23) | public class AtomHashMap<EqK, K, V> :
method AtomHashMap (line 42) | AtomHashMap(TrieMap<EqK, K, V> items) =>
method AtomHashMap (line 49) | internal AtomHashMap(HashMap<EqK, K, V> items) =>
method Swap (line 104) | public Unit Swap(Func<TrackingHashMap<EqK, K, V>, TrackingHashMap<EqK,...
method SwapInternal (line 131) | internal Unit SwapInternal(Func<TrieMap<EqK, K, V>, TrieMap<EqK, K, V>...
method SwapKey (line 162) | public Unit SwapKey(K key, Func<V, V> swap)
method SwapKey (line 208) | public Unit SwapKey(K key, Func<Option<V>, Option<V>> swap)
method Filter (line 256) | [Pure]
method FilterInPlace (line 268) | public Unit FilterInPlace(Func<V, bool> pred)
method Filter (line 294) | [Pure]
method FilterInPlace (line 305) | public Unit FilterInPlace(Func<K, V, bool> pred)
method MapInPlace (line 334) | public Unit MapInPlace(Func<V, V> f)
method Map (line 360) | public AtomHashMap<EqK, K, U> Map<U>(Func<K, V, U> f) =>
method Add (line 371) | public Unit Add(K key, V value)
method TryAdd (line 401) | public Unit TryAdd(K key, V value)
method AddOrUpdate (line 435) | public Unit AddOrUpdate(K key, V value)
method AddOrUpdate (line 467) | public Unit AddOrUpdate(K key, Func<V, V> Some, Func<V> None)
method AddOrUpdate (line 499) | public Unit AddOrUpdate(K key, Func<V, V> Some, V None)
method AddRange (line 528) | public Unit AddRange(IEnumerable<(K Key, V Value)> range)
method TryAddRange (line 559) | public Unit TryAddRange(IEnumerable<(K Key, V Value)> range)
method TryAddRange (line 594) | public Unit TryAddRange(IEnumerable<KeyValuePair<K, V>> range)
method AddOrUpdateRange (line 630) | public Unit AddOrUpdateRange(IEnumerable<(K Key, V Value)> range)
method AddOrUpdateRange (line 661) | public Unit AddOrUpdateRange(IEnumerable<KeyValuePair<K, V>> range)
method Remove (line 690) | public Unit Remove(K key)
method Find (line 721) | [Pure]
method FindSeq (line 730) | [Pure]
method Find (line 740) | [Pure]
method FindOrAdd (line 754) | public V FindOrAdd(K key, Func<V> None)
method FindOrAdd (line 784) | public V FindOrAdd(K key, V value)
method FindOrMaybeAdd (line 817) | public Option<V> FindOrMaybeAdd(K key, Func<Option<V>> None)
method FindOrMaybeAdd (line 847) | public Option<V> FindOrMaybeAdd(K key, Option<V> None)
method SetItem (line 877) | public Unit SetItem(K key, V value)
method SetItem (line 909) | public Unit SetItem(K key, Func<V, V> Some)
method TrySetItem (line 939) | public Unit TrySetItem(K key, V value)
method TrySetItem (line 976) | public Unit TrySetItem(K key, Func<V, V> Some)
method ContainsKey (line 1007) | [Pure]
method Contains (line 1016) | [Pure]
method Contains (line 1025) | [Pure]
method Contains (line 1034) | [Pure]
method Contains (line 1043) | [Pure]
method Clear (line 1050) | public Unit Clear()
method AddRange (line 1077) | public Unit AddRange(IEnumerable<KeyValuePair<K, V>> pairs)
method SetItems (line 1106) | public Unit SetItems(IEnumerable<KeyValuePair<K, V>> items)
method SetItems (line 1135) | public Unit SetItems(IEnumerable<(K Key, V Value)> items)
method TrySetItems (line 1164) | public Unit TrySetItems(IEnumerable<KeyValuePair<K, V>> items)
method TrySetItems (line 1197) | public Unit TrySetItems(IEnumerable<(K Key, V Value)> items)
method TrySetItems (line 1235) | public Unit TrySetItems(IEnumerable<K> keys, Func<V, V> Some)
method RemoveRange (line 1267) | public Unit RemoveRange(IEnumerable<K> keys)
method Contains (line 1300) | [Pure]
method ToHashMap (line 1322) | [Pure]
method GetEnumerator (line 1329) | public IEnumerator<(K Key, V Value)> GetEnumerator() =>
method GetEnumerator (line 1336) | IEnumerator IEnumerable.GetEnumerator() =>
method ToSeq (line 1340) | [Pure]
method ToString (line 1350) | [Pure]
method ToFullString (line 1357) | [Pure]
method ToFullArrayString (line 1364) | [Pure]
method AsIterable (line 1368) | [Pure]
method Append (line 1422) | public Unit Append(AtomHashMap<EqK, K, V> rhs)
method Append (line 1445) | public Unit Append(HashMap<EqK, K, V> rhs)
method Subtract (line 1468) | public Unit Subtract(AtomHashMap<EqK, K, V> rhs)
method Subtract (line 1491) | public Unit Subtract(HashMap<EqK, K, V> rhs)
method IsProperSubsetOf (line 1518) | [Pure]
method IsProperSubsetOf (line 1526) | [Pure]
method IsProperSupersetOf (line 1534) | [Pure]
method IsProperSupersetOf (line 1542) | [Pure]
method IsSubsetOf (line 1550) | [Pure]
method IsSubsetOf (line 1558) | [Pure]
method IsSubsetOf (line 1566) | [Pure]
method IsSupersetOf (line 1574) | [Pure]
method IsSupersetOf (line 1582) | [Pure]
method Intersect (line 1589) | public Unit Intersect(IEnumerable<K> rhs)
method Intersect (line 1615) | public Unit Intersect(IEnumerable<(K Key, V Value)> rhs)
method Intersect (line 1642) | public Unit Intersect(IEnumerable<(K Key, V Value)> rhs, WhenMatched<K...
method Intersect (line 1668) | public Unit Intersect(HashMap<EqK, K, V> rhs, WhenMatched<K, V, V, V> ...
method Overlaps (line 1693) | [Pure]
method Overlaps (line 1700) | [Pure]
method Except (line 1708) | public Unit Except(IEnumerable<K> rhs)
method Except (line 1735) | public Unit Except(IEnumerable<(K Key, V Value)> rhs)
method SymmetricExcept (line 1762) | public Unit SymmetricExcept(HashMap<EqK, K, V> rhs)
method SymmetricExcept (line 1788) | public Unit SymmetricExcept(IEnumerable<(K Key, V Value)> rhs)
method Union (line 1817) | public Unit Union(IEnumerable<(K, V)> rhs)
method Union (line 1848) | public Unit Union(IEnumerable<(K Key, V Value)> rhs, WhenMatched<K, V,...
method Union (line 1883) | public Unit Union<W>(IEnumerable<(K Key, W Value)> rhs, WhenMissing<K,...
method Equals (line 1910) | [Pure]
method Equals (line 1917) | [Pure]
method Equals (line 1924) | [Pure]
method EqualsKeys (line 1931) | [Pure]
method EqualsKeys (line 1938) | [Pure]
method GetHashCode (line 1942) | [Pure]
method Select (line 1950) | [Pure]
method Select (line 1958) | [Pure]
method Where (line 1967) | [Pure]
method Where (line 1977) | [Pure]
method ForAll (line 1987) | [Pure]
method ForAll (line 2002) | [Pure]
method ForAll (line 2011) | [Pure]
method Exists (line 2020) | public bool Exists(Func<K, V, bool> pred)
method Exists (line 2034) | [Pure]
method Exists (line 2043) | [Pure]
method Iter (line 2053) | public Unit Iter(Action<K, V> action)
method Iter (line 2068) | public Unit Iter(Action<V> action)
method Iter (line 2083) | public Unit Iter(Action<(K Key, V Value)> action)
method Iter (line 2098) | public Unit Iter(Action<KeyValuePair<K, V>> action)
method Fold (line 2114) | [Pure]
method Fold (line 2125) | [Pure]
method AnnounceChange (line 2129) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method AnnounceChanges (line 2138) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ToDictionary (line 2152) | [Pure]
method TryGetValue (line 2159) | [Pure]
method GetEnumerator (line 2175) | [Pure]
method ToReadOnlyDictionary (line 2187) | [Pure]
FILE: LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.Module.Eq.cs
class AtomHashMap (line 20) | public static partial class AtomHashMap
method ToAtom (line 22) | public static AtomHashMap<EqK, K, V> ToAtom<EqK, K, V>(this HashMap<Eq...
FILE: LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.Module.cs
class AtomHashMap (line 20) | public static partial class AtomHashMap
method ToAtom (line 22) | public static AtomHashMap<K, V> ToAtom<K, V>(this HashMap<K, V> self) =>
FILE: LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.cs
class AtomHashMap (line 24) | public class AtomHashMap<K, V> :
method AtomHashMap (line 42) | AtomHashMap(TrieMap<EqDefault<K>, K, V> items) =>
method AtomHashMap (line 49) | internal AtomHashMap(HashMap<K, V> items) =>
method Swap (line 104) | public Unit Swap(Func<TrackingHashMap<K, V>, TrackingHashMap<K, V>> swap)
method SwapKey (line 136) | public Unit SwapKey(K key, Func<V, V> swap)
method SwapKey (line 182) | public Unit SwapKey(K key, Func<Option<V>, Option<V>> swap)
method Filter (line 230) | [Pure]
method FilterInPlace (line 242) | public Unit FilterInPlace(Func<V, bool> pred)
method Filter (line 268) | [Pure]
method FilterInPlace (line 279) | public Unit FilterInPlace(Func<K, V, bool> pred)
method MapInPlace (line 308) | public Unit MapInPlace(Func<V, V> f)
method Map (line 334) | public AtomHashMap<K, U> Map<U>(Func<K, V, U> f) =>
method Add (line 345) | public Unit Add(K key, V value)
method TryAdd (line 375) | public Unit TryAdd(K key, V value)
method AddOrUpdate (line 409) | public Unit AddOrUpdate(K key, V value)
method AddOrUpdate (line 441) | public Unit AddOrUpdate(K key, Func<V, V> Some, Func<V> None)
method AddOrUpdate (line 473) | public Unit AddOrUpdate(K key, Func<V, V> Some, V None)
method AddRange (line 502) | public Unit AddRange(IEnumerable<(K Key, V Value)> range)
method TryAddRange (line 533) | public Unit TryAddRange(IEnumerable<(K Key, V Value)> range)
method TryAddRange (line 568) | public Unit TryAddRange(IEnumerable<KeyValuePair<K, V>> range)
method AddOrUpdateRange (line 604) | public Unit AddOrUpdateRange(IEnumerable<(K Key, V Value)> range)
method AddOrUpdateRange (line 635) | public Unit AddOrUpdateRange(IEnumerable<KeyValuePair<K, V>> range)
method Remove (line 664) | public Unit Remove(K key)
method Find (line 695) | [Pure]
method FindSeq (line 704) | [Pure]
method Find (line 714) | [Pure]
method FindOrAdd (line 728) | public V FindOrAdd(K key, Func<V> None)
method FindOrAdd (line 758) | public V FindOrAdd(K key, V value)
method FindOrMaybeAdd (line 791) | public Option<V> FindOrMaybeAdd(K key, Func<Option<V>> None)
method FindOrMaybeAdd (line 821) | public Option<V> FindOrMaybeAdd(K key, Option<V> None)
method SetItem (line 851) | public Unit SetItem(K key, V value)
method SetItem (line 883) | public Unit SetItem(K key, Func<V, V> Some)
method TrySetItem (line 913) | public Unit TrySetItem(K key, V value)
method TrySetItem (line 950) | public Unit TrySetItem(K key, Func<V, V> Some)
method ContainsKey (line 981) | [Pure]
method Contains (line 990) | [Pure]
method Contains (line 999) | [Pure]
method Contains (line 1008) | [Pure]
method Contains (line 1017) | [Pure]
method Clear (line 1024) | public Unit Clear()
method AddRange (line 1051) | public Unit AddRange(IEnumerable<KeyValuePair<K, V>> pairs)
method SetItems (line 1080) | public Unit SetItems(IEnumerable<KeyValuePair<K, V>> items)
method SetItems (line 1109) | public Unit SetItems(IEnumerable<(K Key, V Value)> items)
method TrySetItems (line 1138) | public Unit TrySetItems(IEnumerable<KeyValuePair<K, V>> items)
method TrySetItems (line 1171) | public Unit TrySetItems(IEnumerable<(K Key, V Value)> items)
method TrySetItems (line 1209) | public Unit TrySetItems(IEnumerable<K> keys, Func<V, V> Some)
method RemoveRange (line 1241) | public Unit RemoveRange(IEnumerable<K> keys)
method Contains (line 1274) | [Pure]
method ToDictionary (line 1296) | [Pure]
method ToHashMap (line 1304) | [Pure]
method GetEnumerator (line 1311) | public IEnumerator<(K Key, V Value)> GetEnumerator() =>
method GetEnumerator (line 1318) | IEnumerator IEnumerable.GetEnumerator() =>
method ToSeq (line 1322) | [Pure]
method ToString (line 1332) | [Pure]
method ToFullString (line 1339) | [Pure]
method ToFullArrayString (line 1346) | [Pure]
method AsIterable (line 1350) | [Pure]
method Append (line 1404) | public Unit Append(AtomHashMap<K, V> rhs)
method Append (line 1427) | public Unit Append(HashMap<K, V> rhs)
method Subtract (line 1450) | public Unit Subtract(AtomHashMap<K, V> rhs)
method Subtract (line 1473) | public Unit Subtract(HashMap<K, V> rhs)
method IsProperSubsetOf (line 1500) | [Pure]
method IsProperSubsetOf (line 1508) | [Pure]
method IsProperSupersetOf (line 1516) | [Pure]
method IsProperSupersetOf (line 1524) | [Pure]
method IsSubsetOf (line 1532) | [Pure]
method IsSubsetOf (line 1540) | [Pure]
method IsSubsetOf (line 1548) | [Pure]
method IsSupersetOf (line 1556) | [Pure]
method IsSupersetOf (line 1564) | [Pure]
method Intersect (line 1571) | public Unit Intersect(IEnumerable<K> rhs)
method Intersect (line 1597) | public Unit Intersect(IEnumerable<(K Key, V Value)> rhs)
method Intersect (line 1623) | public Unit Intersect(IEnumerable<(K Key, V Value)> rhs, WhenMatched<K...
method Intersect (line 1649) | public Unit Intersect(HashMap<K, V> rhs, WhenMatched<K, V, V, V> Merge)
method Overlaps (line 1674) | [Pure]
method Overlaps (line 1681) | [Pure]
method Except (line 1689) | public Unit Except(IEnumerable<K> rhs)
method Except (line 1716) | public Unit Except(IEnumerable<(K Key, V Value)> rhs)
method SymmetricExcept (line 1743) | public Unit SymmetricExcept(HashMap<K, V> rhs)
method SymmetricExcept (line 1769) | public Unit SymmetricExcept(IEnumerable<(K Key, V Value)> rhs)
method Union (line 1798) | public Unit Union(IEnumerable<(K, V)> rhs)
method Union (line 1829) | public Unit Union(IEnumerable<(K Key, V Value)> rhs, WhenMatched<K, V,...
method Union (line 1864) | public Unit Union<W>(IEnumerable<(K Key, W Value)> rhs, WhenMissing<K,...
method Equals (line 1891) | [Pure]
method Equals (line 1898) | [Pure]
method Equals (line 1905) | [Pure]
method EqualsKeys (line 1912) | [Pure]
method EqualsKeys (line 1919) | [Pure]
method GetHashCode (line 1923) | [Pure]
method Select (line 1931) | [Pure]
method Select (line 1939) | [Pure]
method Where (line 1948) | [Pure]
method Where (line 1958) | [Pure]
method ForAll (line 1968) | [Pure]
method ForAll (line 1983) | [Pure]
method ForAll (line 1992) | [Pure]
method Exists (line 2001) | public bool Exists(Func<K, V, bool> pred)
method Exists (line 2015) | [Pure]
method Exists (line 2024) | [Pure]
method Exists (line 2033) | [Pure]
method Iter (line 2043) | public Unit Iter(Action<K, V> action)
method Iter (line 2058) | public Unit Iter(Action<V> action)
method Iter (line 2073) | public Unit Iter(Action<(K Key, V Value)> action)
method Iter (line 2088) | public Unit Iter(Action<KeyValuePair<K, V>> action)
method Fold (line 2104) | [Pure]
method Fold (line 2115) | [Pure]
method AnnounceChange (line 2119) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method AnnounceChanges (line 2128) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ToDictionary (line 2141) | [Pure]
method TryGetValue (line 2148) | [Pure]
method GetEnumerator (line 2164) | [Pure]
method ToReadOnlyDictionary (line 2177) | [Pure]
FILE: LanguageExt.Core/Concurrency/AtomQue/AtomQue.Extensions.cs
class AtomQueExtensions (line 13) | public static class AtomQueExtensions
method As (line 15) | public static AtomQue<A> As<A>(this K<AtomQue, A> ma) =>
FILE: LanguageExt.Core/Concurrency/AtomQue/AtomQue.Trait.Implementation.cs
class AtomQue (line 7) | public class AtomQue : Foldable<AtomQue>
method FoldWhile (line 9) | static S Foldable<AtomQue>.FoldWhile<A, S>(
method FoldBackWhile (line 23) | static S Foldable<AtomQue>.FoldBackWhile<A, S>(Func<S, Func<A, S>> f, ...
method FoldStep (line 33) | static Fold<A, S> Foldable<AtomQue>.FoldStep<A, S>(K<AtomQue, A> ta, S...
method FoldStepBack (line 43) | static Fold<A, S> Foldable<AtomQue>.FoldStepBack<A, S>(K<AtomQue, A> t...
FILE: LanguageExt.Core/Concurrency/AtomQue/AtomQue.cs
class AtomQue (line 35) | public class AtomQue<A> :
method AtomQue (line 45) | internal AtomQue() =>
method AtomQue (line 48) | internal AtomQue(IEnumerable<A> items) =>
method AtomQue (line 51) | internal AtomQue(Que<A> items) =>
method Do (line 60) | public Unit Do(Action<A> f)
method Clear (line 123) | public Unit Clear()
method Peek (line 153) | [Pure]
method Dequeue (line 166) | public Option<A> Dequeue()
method DequeueUnsafe (line 192) | public A DequeueUnsafe()
method Enqueue (line 217) | public Unit Enqueue(A value)
method ToSeq (line 236) | [Pure]
method AsIterable (line 240) | [Pure]
method GetEnumerator (line 244) | [Pure]
method GetEnumerator (line 249) | [Pure]
method Append (line 254) | [Pure]
method Append (line 280) | [Pure]
method GetHashCode (line 331) | [Pure]
method Equals (line 335) | [Pure]
method Equals (line 344) | [Pure]
method Equals (line 350) | [Pure]
FILE: LanguageExt.Core/Concurrency/AtomSeq/AtomSeq.cs
class AtomSeq (line 23) | public class AtomSeq<A> :
method AtomSeq (line 44) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method AtomSeq (line 50) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ToSeq (line 58) | [Pure]
method Deconstruct (line 79) | public void Deconstruct(out A head, out Seq<A> tail)
method SwapIO (line 103) | public IO<Unit> SwapIO(Func<Seq<A>, Seq<A>> swap) =>
method Swap (line 114) | public Unit Swap(Func<Seq<A>, Seq<A>> swap)
method SwapInternal (line 145) | internal Unit SwapInternal(Func<ISeqInternal<A>, ISeqInternal<A>> swap)
method Add (line 175) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Concat (line 201) | [Pure]
method Concat (line 221) | [Pure]
method Concat (line 240) | [Pure]
method Concat (line 259) | [Pure]
method Concat (line 278) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Concat (line 296) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Concat (line 315) | public Unit Concat(Seq<A> rhs)
method Cons (line 425) | internal Unit Cons(A value)
method HeadOrNone (line 474) | [Pure]
method LastOrNone (line 496) | [Pure]
method LastOrLeft (line 509) | [Pure]
method LastOrLeft (line 522) | [Pure]
method HeadOrLeft (line 538) | [Pure]
method HeadOrLeft (line 550) | [Pure]
method AsIterable (line 596) | [Pure]
method Match (line 608) | [Pure]
method Match (line 625) | [Pure]
method Match (line 647) | [Pure]
method Match (line 666) | [Pure]
method Iter (line 687) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Map (line 697) | [Pure]
method MapInPlace (line 719) | [Pure]
method Select (line 744) | [Pure]
method Bind (line 755) | [Pure]
method BindInPlace (line 780) | public Unit BindInPlace<B>(Func<A, Seq<A>> f)
method SelectMany (line 804) | [Pure]
method Filter (line 825) | [Pure]
method FilterInPlace (line 849) | public Unit FilterInPlace(Func<A, bool> f)
method Where (line 877) | [Pure]
method Fold (line 889) | [Pure]
method FoldBack (line 903) | [Pure]
method Exists (line 915) | [Pure]
method ForAll (line 929) | [Pure]
method Any (line 938) | [Pure]
method Intersperse (line 950) | [Pure]
method GetHashCode (line 979) | [Pure]
method CompareTo (line 984) | [Pure]
method ToString (line 1000) | [Pure]
method ToFullString (line 1009) | [Pure]
method ToFullArrayString (line 1016) | [Pure]
method Equals (line 1065) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Equals (line 1077) | [Pure]
method Equals (line 1085) | [Pure]
method Equals (line 1093) | [Pure]
method Equals (line 1125) | [Pure]
method Skip (line 1157) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Take (line 1184) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method TakeWhile (line 1217) | public Unit TakeWhile(Func<A, bool> pred)
method TakeWhile (line 1250) | public Unit TakeWhile(Func<A, int, bool> pred)
method CompareTo (line 1344) | [Pure]
method CompareTo (line 1351) | [Pure]
method CompareTo (line 1360) | [Pure]
method CompareTo (line 1385) | [Pure]
method Strict (line 1409) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method GetEnumerator (line 1413) | [Pure]
method GetEnumerator (line 1419) | [Pure]
method Cast (line 1425) | [Pure]
class AtomSeqExtensions (line 1430) | public static class AtomSeqExtensions
method LastOrInvalid (line 1435) | [Pure]
method HeadOrInvalid (line 1450) | [Pure]
method LastOrInvalid (line 1464) | [Pure]
method HeadOrInvalid (line 1479) | [Pure]
method LastOrInvalid (line 1493) | [Pure]
method HeadOrInvalid (line 1508) | [Pure]
FILE: LanguageExt.Core/Concurrency/Conflict.cs
type Conflict (line 7) | public interface Conflict<V>
method Resolve (line 9) | public static abstract (long TimeStamp, Option<V> Value) Resolve((long...
type LastWriteWins (line 16) | public struct LastWriteWins<V> : Conflict<V>
method Resolve (line 18) | public static (long TimeStamp, Option<V> Value) Resolve((long TimeStam...
type FirstWriteWins (line 28) | public struct FirstWriteWins<V> : Conflict<V>
method Resolve (line 30) | public static (long TimeStamp, Option<V> Value) Resolve((long TimeStam...
FILE: LanguageExt.Core/Concurrency/Prelude.Concurrency.cs
class Prelude (line 6) | public static partial class Prelude
method Ref (line 68) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method atomic (line 100) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method atomic (line 136) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method snapshot (line 149) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method snapshot (line 162) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method serial (line 193) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method serial (line 224) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method swap (line 235) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method commute (line 257) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Atom (line 283) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Atom (line 316) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Atom (line 343) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Atom (line 377) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method swap (line 394) | public static A swap<A>(Atom<A> ma, Func<A, A> f) =>
method swap (line 412) | public static A swap<A>(Atom<A> ma, Func<A, Option<A>> f) =>
method swap (line 428) | public static A swap<M, A>(Atom<M, A> ma, Func<M, A, A> f) =>
method swap (line 446) | public static A swap<M, A>(Atom<M, A> ma, Func<M, A, Option<A>> f) =>
FILE: LanguageExt.Core/Concurrency/STM/CommuteRef.cs
type CommuteRef (line 14) | public readonly struct CommuteRef<A>
method CommuteRef (line 16) | internal CommuteRef(Ref<A> r) => Ref = r;
method ToString (line 24) | public override string ToString() => Value?.ToString() ?? "[null]";
method GetHashCode (line 25) | public override int GetHashCode() => Value?.GetHashCode() ?? 0;
method Equals (line 26) | public override bool Equals(object? obj) => obj is A val && Equals(val);
method Equals (line 27) | public bool Equals(A other) => EqDefault<A>.Equals(other, Value);
method Swap (line 28) | public A Swap(Func<A, A> f) => Ref.Swap(f);
method SwapIO (line 29) | public IO<A> SwapIO(Func<A, A> f) => Ref.SwapIO(f);
method Commute (line 30) | public CommuteRef<A> Commute(Func<A, A> f) => Ref.Commute(f);
FILE: LanguageExt.Core/Concurrency/STM/Isolation.cs
type Isolation (line 10) | public enum Isolation
FILE: LanguageExt.Core/Concurrency/STM/Ref.cs
class Ref (line 16) | public sealed class Ref<A> : IEquatable<A>
method Ref (line 24) | internal Ref(long id) =>
method OnChange (line 35) | internal void OnChange(A value) =>
method ToString (line 79) | public override string ToString() =>
method GetHashCode (line 85) | public override int GetHashCode() =>
method Equals (line 91) | public override bool Equals(object? obj) =>
method Equals (line 97) | public bool Equals(A? other) =>
method Swap (line 106) | public A Swap(Func<A, A> f)
method SwapIO (line 119) | public IO<A> SwapIO(Func<A, A> f) =>
method Commute (line 145) | public CommuteRef<A> Commute(Func<A, A> f)
FILE: LanguageExt.Core/Concurrency/STM/STM.cs
class STM (line 17) | public static class STM
method STM (line 23) | static STM()
method OnChange (line 29) | static void OnChange(TrieMap<EqLong, long, Change<RefState>> patch)
method NewRef (line 43) | internal static Ref<A> NewRef<A>(A value, Func<A, bool>? validator = n...
method DoTransaction (line 56) | internal static R DoTransaction<R>(Func<R> op, Isolation isolation) =>
method DoTransaction (line 65) | internal static ValueTask<R> DoTransaction<R>(Func<ValueTask<R>> op, I...
method DoTransaction (line 74) | internal static Eff<R> DoTransaction<R>(Eff<R> op, Isolation isolation...
method DoTransaction (line 83) | internal static Eff<RT, R> DoTransaction<RT, R>(Eff<RT, R> op, Isolati...
method DoTransaction (line 92) | internal static R DoTransaction<R>(Func<CommuteRef<R>> op, Isolation i...
method RunTransaction (line 100) | static R RunTransaction<R>(Func<R> op, Isolation isolation)
method RunTransaction (line 133) | static Eff<RT, R> RunTransaction<RT, R>(Eff<RT, R> op, Isolation isola...
method RunTransaction (line 174) | static Eff<R> RunTransaction<R>(Eff<R> op, Isolation isolation) =>
method RunTransaction (line 212) | static async ValueTask<R> RunTransaction<R>(Func<ValueTask<R>> op, Iso...
method RunTransaction (line 245) | static R RunTransaction<R>(Func<CommuteRef<R>> op, Isolation isolation)
method ValidateAndCommit (line 277) | static R ValidateAndCommit<R>(Transaction t, Isolation isolation, R re...
method ValidateReads (line 310) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method CommitWrites (line 326) | static TrieMap<EqLong, long, RefState> CommitWrites(Transaction t, Tri...
method CommitCommutes (line 354) | static (TrieMap<EqLong, long, RefState>, R) CommitCommutes<R>(Transact...
method Read (line 388) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Write (line 398) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Commute (line 426) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Commute (line 454) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Commute (line 476) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Finalise (line 483) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method CastCommute (line 495) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
class Transaction (line 511) | class Transaction
method Transaction (line 523) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ReadValue (line 531) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method WriteValue (line 538) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Commute (line 557) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
type RefState (line 572) | abstract record RefState(long Version)
type RefState (line 584) | record RefState<A>(long Version, A Value, Func<A, bool>? Validator, Re...
FILE: LanguageExt.Core/Concurrency/Signals/CountdownSignal.cs
class CountdownSignal (line 11) | public class CountdownSignal<M>(CountdownEvent handle) : IDisposable
method Trigger (line 36) | public K<M, bool> Trigger() =>
method TriggerUnsafe (line 43) | public bool TriggerUnsafe() =>
method Trigger (line 53) | public K<M, bool> Trigger(int count) =>
method TriggerUnsafe (line 63) | public bool TriggerUnsafe(int count) =>
method Wait (line 70) | public K<M, Unit> Wait() =>
method Dispose (line 77) | public void Dispose() =>
FILE: LanguageExt.Core/Concurrency/Signals/Signal.Module.cs
class Signal (line 10) | public static class Signal
method autoReset (line 22) | public static K<M, Signal<M>> autoReset<M>(bool signaled = false)
method manualReset (line 35) | public static K<M, Signal<M>> manualReset<M>(bool signaled = false)
method countdown (line 44) | public static K<M, CountdownSignal<M>> countdown<M>(int count)
FILE: LanguageExt.Core/Concurrency/Signals/Signal.cs
class Signal (line 11) | public class Signal<M>(EventWaitHandle handle) : IDisposable
method Trigger (line 20) | public K<M, bool> Trigger() =>
method TriggerUnsafe (line 32) | public bool TriggerUnsafe() =>
method Wait (line 39) | public K<M, bool> Wait() =>
method Wait (line 46) | public K<M, bool> Wait(TimeSpan timeout) =>
method Wait (line 53) | public K<M, bool> Wait(int timeoutMilliseconds) =>
method Dispose (line 56) | public void Dispose() =>
FILE: LanguageExt.Core/Concurrency/Task/Task.Extensions.cs
class TaskExtensions (line 13) | public static class TaskExtensions
method CompletedSuccessfully (line 15) | public static bool CompletedSuccessfully<A>(this Task<A> ma) =>
method AsFailedTask (line 18) | [Pure]
method AsTask (line 29) | [Pure]
method ToRef (line 36) | [Pure]
method Flatten (line 43) | [Pure]
method Flatten (line 54) | [Pure]
method Select (line 66) | [Pure]
method Where (line 73) | [Pure]
method SelectMany (line 89) | [Pure]
method SelectMany (line 97) | [Pure]
method Count (line 110) | [Pure]
method Bind (line 127) | [Pure]
method Exists (line 135) | [Pure]
method ExistsAsync (line 143) | [Pure]
method ForAll (line 151) | [Pure]
method ForAllAsync (line 159) | [Pure]
method Filter (line 167) | [Pure]
method Fold (line 175) | [Pure]
method FoldAsync (line 183) | [Pure]
method Iter (line 190) | public static async Task<Unit> Iter<T>(this Task<T> self, Action<T> f)
method Do (line 202) | public static Task<A> Do<A>(this Task<A> ma, Action<A> f) =>
method Map (line 211) | [Pure]
method MapAsync (line 218) | [Pure]
method Join (line 222) | [Pure]
method GroupJoin (line 238) | [Pure]
method Plus (line 249) | [Pure]
method PlusFirst (line 262) | [Pure]
method Cast (line 266) | public static async Task<A> Cast<A>(this Task source)
method ToUnit (line 280) | public static async Task<Unit> ToUnit(this Task source)
method WindowMap (line 293) | internal static Task<IList<B>> WindowMap<A, B>(this IEnumerable<Task<A...
method WindowMap (line 303) | internal static async Task<IList<B>> WindowMap<A, B>(
FILE: LanguageExt.Core/Concurrency/Task/Task.Prelude.cs
class Prelude (line 11) | public static partial class Prelude
method TaskSucc (line 16) | [Pure]
method TaskFail (line 23) | [Pure]
method flatten (line 30) | [Pure]
method flatten (line 37) | [Pure]
method count (line 44) | [Pure]
method bind (line 51) | [Pure]
method exists (line 59) | [Pure]
method existsAsync (line 67) | [Pure]
method forall (line 75) | [Pure]
method forallAsync (line 83) | [Pure]
method filter (line 91) | [Pure]
method iter (line 98) | public static Task<Unit> iter<A>(Task<A> self, Action<A> f) =>
method map (line 104) | [Pure]
method mapAsync (line 111) | [Pure]
method plus (line 115) | [Pure]
method plusFirst (line 119) | [Pure]
method choice (line 130) | [Pure]
method choice (line 140) | [Pure]
method apply (line 163) | [Pure]
method apply (line 176) | [Pure]
method apply (line 187) | [Pure]
method apply (line 201) | [Pure]
method apply (line 214) | [Pure]
method apply (line 227) | [Pure]
method apply (line 237) | [Pure]
method apply (line 250) | [Pure]
FILE: LanguageExt.Core/Concurrency/Task/Tasks.cs
class Tasks (line 10) | internal static class Tasks
method ForAll (line 12) | [Pure]
method ForAll (line 19) | [Pure]
method Exists (line 26) | [Pure]
method Exists (line 33) | [Pure]
FILE: LanguageExt.Core/Concurrency/ValueTask/ValueTask.Extensions.cs
class ValueTaskExtensions (line 13) | public static class ValueTaskExtensions
method CompletedSuccessfully (line 15) | public static bool CompletedSuccessfully<A>(this ValueTask<A> ma) =>
method AsFailedValueTask (line 18) | [Pure]
method AsValueTask (line 25) | [Pure]
method ToValue (line 32) | [Pure]
method Flatten (line 39) | [Pure]
method Flatten (line 50) | [Pure]
method Select (line 62) | [Pure]
method Where (line 69) | [Pure]
method SelectMany (line 85) | [Pure]
method SelectMany (line 93) | [Pure]
method Count (line 106) | [Pure]
method Bind (line 123) | [Pure]
method Exists (line 131) | [Pure]
method ExistsAsync (line 139) | [Pure]
method ForAll (line 147) | [Pure]
method ForAllAsync (line 155) | [Pure]
method Filter (line 163) | [Pure]
method Fold (line 171) | [Pure]
method FoldAsync (line 179) | [Pure]
method Iter (line 186) | public static async ValueTask<Unit> Iter<T>(this ValueTask<T> self, Ac...
method Do (line 198) | public static ValueTask<A> Do<A>(this ValueTask<A> ma, Action<A> f) =>
method Map (line 207) | [Pure]
method MapAsync (line 214) | [Pure]
method Join (line 218) | [Pure]
method GroupJoin (line 233) | [Pure]
method Plus (line 244) | [Pure]
method PlusFirst (line 257) | [Pure]
method Cast (line 264) | public static ValueTask<A> Cast<A>(this ValueTask source) =>
method ToUnit (line 267) | public static async ValueTask<Unit> ToUnit(this ValueTask source)
method WindowIter (line 280) | public static ValueTask<Unit> WindowIter<A>(this IEnumerable<ValueTask...
method WindowIter (line 290) | public static async ValueTask<Unit> WindowIter<A>(this IEnumerable<Val...
method WindowMap (line 336) | internal static ValueTask<IList<B>> WindowMap<A, B>(
method WindowMap (line 349) | internal static async ValueTask<IList<B>> WindowMap<A, B>(
FILE: LanguageExt.Core/Concurrency/ValueTask/ValueTask.Prelude.cs
class Prelude (line 8) | public static partial class Prelude
method ValueTaskSucc (line 13) | [Pure]
method ValueTaskFail (line 20) | [Pure]
method flatten (line 27) | [Pure]
method flatten (line 34) | [Pure]
method count (line 41) | [Pure]
method bind (line 48) | [Pure]
method exists (line 56) | [Pure]
method existsAsync (line 64) | [Pure]
method forall (line 72) | [Pure]
method forallAsync (line 80) | [Pure]
method filter (line 88) | [Pure]
method iter (line 95) | public static ValueTask<Unit> iter<A>(ValueTask<A> self, Action<A> f) =>
method map (line 101) | [Pure]
method mapAsync (line 108) | [Pure]
method plus (line 112) | [Pure]
method plusFirst (line 116) | [Pure]
method choice (line 127) | [Pure]
method choice (line 137) | [Pure]
method apply (line 160) | [Pure]
method apply (line 173) | [Pure]
method apply (line 184) | [Pure]
method apply (line 198) | [Pure]
method apply (line 211) | [Pure]
method apply (line 224) | [Pure]
method apply (line 234) | [Pure]
method apply (line 247) | [Pure]
FILE: LanguageExt.Core/Concurrency/ValueTask/ValueTasks.cs
class ValueTasks (line 10) | internal static class ValueTasks
method ForAll (line 12) | [Pure]
method ForAll (line 19) | [Pure]
method Exists (line 26) | [Pure]
method Exists (line 33) | [Pure]
FILE: LanguageExt.Core/Concurrency/VectorClock/Relation.cs
type Relation (line 6) | public enum Relation
FILE: LanguageExt.Core/Concurrency/VectorClock/VectorClock.A.cs
type VectorClock (line 61) | public record VectorClock<A>(Seq<(A, long)> Entries)
FILE: LanguageExt.Core/Concurrency/VectorClock/VectorClock.OrdA.NumB.A.B.cs
type VectorClock (line 63) | public record VectorClock<OrdA, NumB, A, B>(Seq<(A, B)> Entries)
FILE: LanguageExt.Core/Concurrency/VectorClock/VectorClock.cs
class VectorClock (line 64) | public static class VectorClock
method Single (line 69) | public static VectorClock<A> Single<A>(A x, long y) where A : ICompara...
method Single (line 75) | public static VectorClock<OrdA, NumB, A, B> Single<OrdA, NumB, A, B>(A...
method fromList (line 83) | public static VectorClock<A> fromList<A>(Seq<(A x, long y)> list) wher...
method fromList (line 89) | public static VectorClock<OrdA, NumB, A, B> fromList<OrdA, NumB, A, B>...
method combine (line 105) | public static VectorClock<A> combine<A>(
method combine (line 122) | public static VectorClock<OrdA, NumB, A, B> combine<OrdA, NumB, A, B>(
method max (line 133) | public static VectorClock<A> max<A>(VectorClock<A> vc1, VectorClock<A>...
method max (line 140) | public static VectorClock<OrdA, NumB, A, B> max<OrdA, NumB, A, B>(Vect...
method relation (line 148) | public static Relation relation<A>(VectorClock<A> vc1, VectorClock<A> ...
method relation (line 155) | public static Relation relation<OrdA, NumB, A, B>(VectorClock<OrdA, Nu...
method causes (line 163) | public static bool causes<A>(VectorClock<A> vc1, VectorClock<A> vc2)
method causes (line 170) | public static bool causes<OrdA, NumB, A, B>(VectorClock<OrdA, NumB, A,...
method diff (line 179) | public static Option<VectorClock<A>> diff<A>(VectorClock<A> vc1, Vecto...
method diff (line 187) | public static Option<VectorClock<OrdA, NumB, A, B>> diff<OrdA, NumB, A...
FILE: LanguageExt.Core/Concurrency/VersionHashMap/VersionHashMap.ConflictV.K.V.cs
class VersionHashMap (line 29) | public class VersionHashMap<ConflictV, K, V> :
method VersionHashMap (line 49) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method SwapKey (line 103) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Update (line 120) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RemoveOlderThan (line 128) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RemoveOlderThan (line 136) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RemoveDeletedItemsOlderThan (line 144) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RemoveDeletedItemsOlderThan (line 152) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Find (line 161) | [Pure]
method FindVersion (line 171) | [Pure]
method ToHashMap (line 199) | [Pure]
method GetEnumerator (line 207) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method GetEnumerator (line 215) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ToSeq (line 220) | [Pure]
method ToString (line 231) | [Pure]
method ToFullString (line 239) | [Pure]
method ToFullArrayString (line 247) | [Pure]
method AsIterable (line 252) | [Pure]
method IsProperSubsetOf (line 261) | [Pure]
method IsProperSubsetOf (line 270) | [Pure]
method IsProperSupersetOf (line 279) | [Pure]
method IsProperSupersetOf (line 288) | [Pure]
method IsSubsetOf (line 297) | [Pure]
method IsSubsetOf (line 306) | [Pure]
method IsSubsetOf (line 315) | [Pure]
method IsSupersetOf (line 324) | [Pure]
method IsSupersetOf (line 333) | [Pure]
method Intersect (line 341) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Overlaps (line 348) | [Pure]
method Overlaps (line 356) | [Pure]
method Except (line 365) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Equals (line 372) | [Pure]
method Equals (line 380) | [Pure]
method GetHashCode (line 385) | [Pure]
method Where (line 395) | [Pure]
method Where (line 405) | [Pure]
method Filter (line 415) | [Pure]
method Filter (line 425) | [Pure]
method FilterInPlace (line 435) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method FilterInPlace (line 444) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ForAll (line 453) | [Pure]
method ForAll (line 463) | [Pure]
method ForAll (line 473) | [Pure]
method ForAll (line 483) | [Pure]
method Exists (line 493) | [Pure]
method Exists (line 503) | [Pure]
method Exists (line 513) | [Pure]
method Iter (line 524) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Iter (line 534) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Iter (line 544) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Iter (line 554) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Fold (line 565) | [Pure]
method Fold (line 577) | [Pure]
FILE: LanguageExt.Core/Concurrency/VersionHashMap/VersionHashMap.ConflictV.OrdActor.EqK.Actor.K.V.cs
class VersionHashMap (line 32) | public class VersionHashMap<ConflictV, OrdActor, EqK, Actor, K, V> :
method VersionHashMap (line 54) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method SwapKey (line 108) | public Unit SwapKey(K key, Func<Version<Actor, K, V>, Version<Actor, K...
method Update (line 153) | public Unit Update(Version<Actor, K, V> nversion)
method RemoveOlderThan (line 183) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RemoveOlderThan (line 191) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RemoveDeletedItemsOlderThan (line 199) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RemoveDeletedItemsOlderThan (line 207) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Find (line 216) | [Pure]
method FindVersion (line 226) | [Pure]
method ToHashMap (line 256) | [Pure]
method GetEnumerator (line 264) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method GetEnumerator (line 271) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ToSeq (line 275) | [Pure]
method ToString (line 286) | [Pure]
method ToFullString (line 294) | [Pure]
method ToFullArrayString (line 302) | [Pure]
method AsIterable (line 307) | [Pure]
method IsProperSubsetOf (line 316) | [Pure]
method IsProperSubsetOf (line 325) | [Pure]
method IsProperSupersetOf (line 334) | [Pure]
method IsProperSupersetOf (line 343) | [Pure]
method IsSubsetOf (line 352) | [Pure]
method IsSubsetOf (line 361) | [Pure]
method IsSubsetOf (line 370) | [Pure]
method IsSupersetOf (line 379) | [Pure]
method IsSupersetOf (line 388) | [Pure]
method Intersect (line 396) | public Unit Intersect(IEnumerable<K> rhs)
method Overlaps (line 418) | [Pure]
method Overlaps (line 426) | [Pure]
method Except (line 435) | public Unit Except(IEnumerable<K> rhs)
method Equals (line 457) | [Pure]
method Equals (line 465) | [Pure]
method GetHashCode (line 470) | [Pure]
method Where (line 480) | [Pure]
method Where (line 490) | [Pure]
method Filter (line 500) | [Pure]
method Filter (line 510) | [Pure]
method FilterInPlace (line 520) | public Unit FilterInPlace(Func<long, Option<V>, bool> pred)
method FilterInPlace (line 550) | public Unit FilterInPlace(Func<K, long, Option<V>, bool> pred)
method ForAll (line 580) | [Pure]
method ForAll (line 596) | [Pure]
method ForAll (line 606) | [Pure]
method ForAll (line 616) | [Pure]
method Exists (line 626) | [Pure]
method Exists (line 642) | [Pure]
method Exists (line 652) | [Pure]
method Iter (line 663) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Iter (line 679) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Iter (line 695) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Iter (line 711) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Fold (line 728) | [Pure]
method Fold (line 740) | [Pure]
FILE: LanguageExt.Core/Concurrency/VersionHashMap/VersionHashMap.K.V.cs
class VersionHashMap (line 29) | public class VersionHashMap<K, V> :
method VersionHashMap (line 48) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method SwapKey (line 102) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Update (line 119) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RemoveOlderThan (line 127) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RemoveOlderThan (line 135) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RemoveDeletedItemsOlderThan (line 143) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RemoveDeletedItemsOlderThan (line 151) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Find (line 160) | [Pure]
method FindVersion (line 170) | [Pure]
method ToHashMap (line 198) | [Pure]
method GetEnumerator (line 206) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method GetEnumerator (line 213) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ToSeq (line 217) | [Pure]
method ToString (line 228) | [Pure]
method ToFullString (line 236) | [Pure]
method ToFullArrayString (line 244) | [Pure]
method AsIterable (line 249) | [Pure]
method IsProperSubsetOf (line 258) | [Pure]
method IsProperSubsetOf (line 267) | [Pure]
method IsProperSupersetOf (line 276) | [Pure]
method IsProperSupersetOf (line 285) | [Pure]
method IsSubsetOf (line 294) | [Pure]
method IsSubsetOf (line 303) | [Pure]
method IsSubsetOf (line 312) | [Pure]
method IsSupersetOf (line 321) | [Pure]
method IsSupersetOf (line 330) | [Pure]
method Intersect (line 338) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Overlaps (line 345) | [Pure]
method Overlaps (line 353) | [Pure]
method Except (line 362) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Equals (line 369) | [Pure]
method Equals (line 377) | [Pure]
method GetHashCode (line 382) | [Pure]
method Where (line 392) | [Pure]
method Where (line 402) | [Pure]
method Filter (line 412) | [Pure]
method Filter (line 422) | [Pure]
method FilterInPlace (line 432) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method FilterInPlace (line 441) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ForAll (line 450) | [Pure]
method ForAll (line 460) | [Pure]
method ForAll (line 470) | [Pure]
method ForAll (line 480) | [Pure]
method Exists (line 490) | [Pure]
method Exists (line 500) | [Pure]
method Exists (line 510) | [Pure]
method Iter (line 521) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Iter (line 531) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Iter (line 541) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Iter (line 551) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Fold (line 562) | [Pure]
method Fold (line 574) | [Pure]
FILE: LanguageExt.Core/Concurrency/VersionVector/Version.cs
type Version (line 13) | public abstract record Version<Actor, K, V>(K Key)
method ToVersion (line 52) | public static Version<Actor, K, V> ToVersion<ConflictV, OrdActor, Acto...
method ToVector (line 59) | public static VersionVector<ConflictV, OrdActor, TLong, Actor, long, V...
class Version (line 50) | internal static class Version
method ToVersion (line 52) | public static Version<Actor, K, V> ToVersion<ConflictV, OrdActor, Acto...
method ToVector (line 59) | public static VersionVector<ConflictV, OrdActor, TLong, Actor, long, V...
type VersionSome (line 76) | internal abstract record VersionSome<Actor, K, V>(K Key, V value) : Vers...
type VersionNone (line 90) | internal abstract record VersionNone<Actor, K, V>(K Key) : Version<Actor...
type VersionNeverExistedVector (line 105) | internal record VersionNeverExistedVector<ConflictV, OrdActor, Actor, K,...
type VersionDeletedVector (line 136) | internal record VersionDeletedVector<ConflictV, OrdActor, Actor, K, V>(K...
type VersionValueVector (line 160) | internal record VersionValueVector<ConflictV, OrdActor, Actor, K, V>(K K...
FILE: LanguageExt.Core/Concurrency/VersionVector/VersionVector.cs
type VersionVector (line 16) | public record VersionVector<ConflictA, OrdActor, NumClock, Actor, Clock,...
type VersionVector (line 75) | public record VersionVector<ConflictA, Actor, A>(Option<A> Value, long T...
FILE: LanguageExt.Core/DataTypes/BigInt/BigInt.cs
type bigint (line 13) | public readonly struct bigint :
method bigint (line 26) | public bigint(BigInteger value) =>
method bigint (line 38) | public bigint(byte[] value)
method bigint (line 51) | public bigint(decimal value)
method bigint (line 65) | public bigint(double value)
method bigint (line 78) | public bigint(int value)
method bigint (line 91) | public bigint(long value)
method bigint (line 105) | public bigint(float value)
method bigint (line 118) | public bigint(uint value)
method bigint (line 131) | public bigint(ulong value)
method Abs (line 217) | public static bigint Abs(bigint value) =>
method Add (line 226) | public static bigint Add(bigint left, bigint right) =>
method Compare (line 238) | public static int Compare(bigint left, bigint right) =>
method Divide (line 255) | public static bigint Divide(bigint dividend, bigint divisor) =>
method DivRem (line 272) | public static (bigint Quotient, bigint Remainder) DivRem(bigint divide...
method GreatestCommonDivisor (line 291) | public static bigint GreatestCommonDivisor(bigint left, bigint right) =>
method Log (line 306) | public static double Log(bigint value) =>
method Log (line 323) | public static double Log(bigint value, double baseValue) =>
method Log10 (line 337) | public static double Log10(bigint value) =>
method Max (line 353) | public static bigint Max(bigint left, bigint right) =>
method Min (line 369) | public static bigint Min(bigint left, bigint right) =>
method ModPow (line 389) | public static bigint ModPow(bigint value, bigint exponent, bigint modu...
method Multiply (line 405) | public static bigint Multiply(bigint left, bigint right) =>
method Negate (line 418) | public static bigint Negate(bigint value) =>
method Parse (line 437) | public static bigint Parse(string value, NumberStyles style) =>
method Parse (line 455) | public static bigint Parse(string value, IFormatProvider provider) =>
method Parse (line 470) | public static bigint Parse(string value) =>
method Parse (line 492) | public static bigint Parse(string value, NumberStyles style, IFormatPr...
method Pow (line 509) | public static bigint Pow(bigint value, int exponent) =>
method Remainder (line 527) | public static bigint Remainder(bigint dividend, bigint divisor) =>
method Subtract (line 543) | public static bigint Subtract(bigint left, bigint right) =>
method TryParse (line 567) | public static Option<bigint> TryParse(string value, NumberStyles style...
method TryParse (line 584) | public static Option<bigint> TryParse(string value) =>
method CompareTo (line 603) | public int CompareTo(long other) =>
method CompareTo (line 621) | public int CompareTo(ulong other) =>
method CompareTo (line 639) | public int CompareTo(BigInteger other) =>
method CompareTo (line 657) | public int CompareTo(bigint other) =>
method Equals (line 672) | public bool Equals(long other) =>
method Equals (line 687) | public bool Equals(BigInteger other) =>
method Equals (line 702) | public bool Equals(bigint other) =>
method Equals (line 719) | public override bool Equals(object? obj) =>
method Equals (line 739) | public bool Equals(ulong other) =>
method GetHashCode (line 749) | public override int GetHashCode() =>
method CompareTo (line 752) | public int CompareTo(object? obj) =>
method ToByteArray (line 767) | public byte[] ToByteArray() =>
method ToString (line 777) | public override string ToString() =>
method ToString (line 793) | public string ToString(string format) =>
method ToString (line 809) | public string ToString(IFormatProvider provider) =>
method ToString (line 829) | public string ToString(string format, IFormatProvider provider) =>
method Combine (line 2128) | bigint Semigroup<bigint>.Combine(bigint y) =>
FILE: LanguageExt.Core/DataTypes/Change/Change.cs
class Change (line 11) | public abstract class Change<A> :
method HasMappedFrom (line 38) | public bool HasMappedFrom<FROM>() =>
method ToOption (line 49) | public Option<A> ToOption() =>
method Removed (line 65) | public static Change<A> Removed(A oldValue) => new EntryRemoved<A>(old...
method Added (line 70) | public static Change<A> Added(A value) => new EntryAdded<A>(value);
method Mapped (line 75) | public static Change<A> Mapped<FROM>(FROM oldValue, A value) => new En...
method Equals (line 80) | public override bool Equals(object? obj) =>
method Equals (line 86) | public abstract bool Equals(Change<A>? obj);
method GetHashCode (line 91) | public override int GetHashCode() => FNV32.OffsetBasis;
method Combine (line 93) | public Change<A> Combine(Change<A> y) =>
FILE: LanguageExt.Core/DataTypes/Change/EntryAdded.cs
class EntryAdded (line 10) | public sealed class EntryAdded<A> :
method EntryAdded (line 19) | internal EntryAdded(A value) =>
method Equals (line 22) | public override bool Equals(Change<A>? obj) =>
method Equals (line 25) | public bool Equals(EntryAdded<A>? rhs) =>
method GetHashCode (line 29) | public override int GetHashCode() =>
method Deconstruct (line 32) | public void Deconstruct(out A value) =>
method ToString (line 35) | public override string ToString() => $"+{Value}";
FILE: LanguageExt.Core/DataTypes/Change/EntryMapped.cs
type EntryMappedTo (line 10) | public interface EntryMappedTo<B>
method Deconstruct (line 20) | void Deconstruct(out B @to);
type EntryMappedFrom (line 27) | public interface EntryMappedFrom<A>
method Deconstruct (line 37) | void Deconstruct(out A @from);
class EntryMapped (line 43) | public sealed class EntryMapped<A, B> :
method EntryMapped (line 49) | internal EntryMapped(A @from, B to)
method Equals (line 65) | public override bool Equals(Change<B>? obj) =>
method Equals (line 68) | public bool Equals(EntryMapped<A, B>? rhs) =>
method GetHashCode (line 73) | public override int GetHashCode() =>
method ToString (line 78) | public override string ToString() => $"{From} -> {To}";
method Deconstruct (line 80) | public void Deconstruct(out B to) =>
method Deconstruct (line 83) | public void Deconstruct(out A @from) =>
method Deconstruct (line 86) | public void Deconstruct(out A @from, out B to)
FILE: LanguageExt.Core/DataTypes/Change/EntryRemoved.cs
class EntryRemoved (line 10) | public sealed class EntryRemoved<A> :
method EntryRemoved (line 19) | internal EntryRemoved(A oldValue) =>
method Equals (line 22) | public override bool Equals(Change<A>? obj) =>
method GetHashCode (line 25) | public override int GetHashCode() =>
method Equals (line 28) | public bool Equals(EntryRemoved<A>? rhs) =>
method Deconstruct (line 32) | public void Deconstruct(out A oldValue)
method ToString (line 37) | public override string ToString() => $"-{OldValue}";
FILE: LanguageExt.Core/DataTypes/Change/NoChange.cs
class NoChange (line 9) | public sealed class NoChange<A> :
method NoChange (line 18) | private NoChange()
method Equals (line 21) | public override bool Equals(Change<A>? obj) =>
method Equals (line 24) | public bool Equals(NoChange<A>? rhs) =>
method GetHashCode (line 27) | public override int GetHashCode() =>
method ToString (line 30) | public override string ToString() => $"No Change";
FILE: LanguageExt.Core/DataTypes/Compositions/Compositions.Extensions.cs
class CompositionsExt (line 4) | public static class CompositionsExt
method Cons (line 6) | public static Compositions<A> Cons<A>(this A a, Compositions<A> ma) wh...
FILE: LanguageExt.Core/DataTypes/Compositions/Compositions.Module.cs
class Compositions (line 8) | public static class Compositions
method wellFormed (line 13) | public static bool wellFormed<EqA, A>(Compositions<A> ca)
method skip (line 49) | public static Compositions<A> skip<A>(int amount, Compositions<A> comp...
method take (line 79) | public static Compositions<A> take<A>(int amount, Compositions<A> comp...
method takeComposed (line 109) | public static A takeComposed<A>(int amount, Compositions<A> compositio...
method splitAt (line 137) | public static (Compositions<A> taken, Compositions<A> skipped) splitAt...
method composed (line 144) | public static A composed<A>(Compositions<A> compositions)
method singleton (line 151) | public static Compositions<A> singleton<A>(A value)
method count (line 158) | public static int count<A>(Compositions<A> compositions)
method cons (line 165) | public static Compositions<A> cons<A>(A x, Compositions<A> xs)
method fromList (line 173) | public static Compositions<A> fromList<A>(IEnumerable<A> ma)
FILE: LanguageExt.Core/DataTypes/Compositions/Compositions.cs
type Compositions (line 24) | public struct Compositions<A> :
method Compositions (line 35) | internal Compositions(Seq<Node> tree)
method Combine (line 41) | public Compositions<A> Combine(Compositions<A> compy)
method WellFormed (line 78) | public bool WellFormed<EqA>()
method Skip (line 85) | public Compositions<A> Skip(int amount) =>
method Take (line 94) | public Compositions<A> Take(int amount) =>
method TakeComposed (line 101) | public A TakeComposed(int amount) =>
method SplitAt (line 107) | public (Compositions<A> taken, Compositions<A> skipped) SplitAt(int i) =>
method Composed (line 113) | public A Composed() =>
method Singleton (line 119) | public static Compositions<A> Singleton(A value) =>
method Count (line 125) | public int Count() =>
method FromList (line 132) | public static Compositions<A> FromList(IEnumerable<A> ma) =>
method Equals (line 138) | public bool Equals(Compositions<A> b) =>
method Equals (line 144) | public override bool Equals(object? obj) =>
method GetHashCode (line 163) | public override int GetHashCode() =>
method ToSeq (line 169) | public Seq<A> ToSeq() =>
method AsIterable (line 175) | public Iterable<A> AsIterable() =>
method GetEnumerator (line 181) | public IEnumerator<A> GetEnumerator() =>
method GetEnumerator (line 188) | IEnumerator IEnumerable.GetEnumerator() =>
class Node (line 192) | public class Node
method Node (line 198) | public Node(int size, Option<(Node, Node)> children, A value)
FILE: LanguageExt.Core/DataTypes/Compositions/FoldCompositions.cs
type FoldCompositions (line 7) | public struct FoldCompositions<A>
method FoldNode (line 10) | static S FoldNode<S>(S state, Func<S, A, S> f, Compositions<A>.Node node)
method FoldNodes (line 19) | static S FoldNodes<S>(S state, Func<S, A, S> f, Seq<Compositions<A>.No...
method FoldNodeBack (line 22) | static S FoldNodeBack<S>(S state, Func<S, A, S> f, Compositions<A>.Nod...
method FoldNodesBack (line 31) | static S FoldNodesBack<S>(S state, Func<S, A, S> f, Seq<Compositions<A...
method FoldMap (line 34) | internal static Seq<B> FoldMap<B>(Func<A, B> f, Seq<Compositions<A>.No...
method FoldMapBack (line 37) | internal static Seq<B> FoldMapBack<B>(Func<A, B> f, Seq<Compositions<A...
method Count (line 40) | public static Func<Unit, int> Count(Compositions<A> fa) => _ =>
method Fold (line 43) | public static Func<Unit, S> Fold<S>(Compositions<A> fa, S state, Func<...
method FoldBack (line 46) | public static Func<Unit, S> FoldBack<S>(Compositions<A> fa, S state, F...
FILE: LanguageExt.Core/DataTypes/Fail/Fail.Extensions.cs
class FailExtensions (line 7) | public static class FailExtensions
FILE: LanguageExt.Core/DataTypes/Fail/Fail.cs
type Fail (line 17) | public readonly record struct Fail<E>(E Value)
FILE: LanguageExt.Core/DataTypes/Loop/Loop.Extensions.cs
class LoopExtensions (line 6) | public static class LoopExtensions
FILE: LanguageExt.Core/DataTypes/Loop/Loop.Prelude.cs
class Prelude (line 6) | public static partial class Prelude
method Loop (line 8) | [Pure]
FILE: LanguageExt.Core/DataTypes/Loop/Loop.cs
type Loop (line 19) | public readonly record struct Loop<A>(A Value)
FILE: LanguageExt.Core/DataTypes/Lower/Lower.cs
type Lower (line 3) | public readonly record struct Lower;
FILE: LanguageExt.Core/DataTypes/MapPatch/HashMapPatch.cs
class HashMapPatch (line 16) | public sealed class HashMapPatch<K, V>
method HashMapPatch (line 24) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method HashMapPatch (line 35) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ToString (line 68) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method HashMapPatch (line 91) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method HashMapPatch (line 102) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ToString (line 135) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
class HashMapPatch (line 82) | public sealed class HashMapPatch<EqK, K, V>
method HashMapPatch (line 24) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method HashMapPatch (line 35) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ToString (line 68) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method HashMapPatch (line 91) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method HashMapPatch (line 102) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ToString (line 135) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
FILE: LanguageExt.Core/DataTypes/Next/Next.Module.cs
class Next (line 6) | public static class Next
method Loop (line 15) | public static Next<A, B> Loop<A, B>(A value) =>
method Done (line 25) | public static Next<A, B> Done<A, B>(B value) =>
FILE: LanguageExt.Core/DataTypes/Next/Next.cs
type Next (line 33) | public readonly struct Next<A, B>
method Next (line 41) | internal Next(int state, A left, B right)
method Match (line 51) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Map (line 59) | public Next<A, C> Map<C>(Func<B, C> f) =>
method ToEither (line 67) | public Either<A, B> ToEither() =>
FILE: LanguageExt.Core/DataTypes/Patch/Edit.cs
class Edit (line 17) | public abstract class Edit<EqA, A> : IEquatable<Edit<EqA, A>> where EqA ...
method Edit (line 25) | Edit(int position, A element)
method Index (line 34) | internal abstract Edit<EqA, A> Index(Func<int, int> f);
method MapOld (line 40) | public abstract Edit<EqA, A> MapOld(Func<A, A> f);
method MapNew (line 46) | public abstract Edit<EqA, A> MapNew(Func<A, A> f);
method Equals (line 51) | public override bool Equals(object? obj) =>
method GetHashCode (line 67) | public override int GetHashCode() =>
method Equals (line 73) | public bool Equals(Edit<EqA, A>? other) =>
class Insert (line 82) | public sealed class Insert : Edit<EqA, A>, IEquatable<Insert>
method Insert (line 84) | public Insert(int position, A element) : base(position, element) { }
method New (line 85) | public static Insert New(int position, A element) => new Insert(posi...
method ToString (line 86) | public override string ToString() => $"Insert({Position}, {Element})";
method Index (line 87) | internal override Edit<EqA, A> Index(Func<int, int> f) => new Insert...
method MapOld (line 88) | public override Edit<EqA, A> MapOld(Func<A, A> f) => this;
method MapNew (line 89) | public override Edit<EqA, A> MapNew(Func<A, A> f) => new Insert(Posi...
method Equals (line 90) | public bool Equals(Insert? other) => base.Equals(other);
method Equals (line 91) | public override bool Equals(object? obj) => obj is Insert ins && Equ...
method GetHashCode (line 94) | public override int GetHashCode() => (Position + 13) * (Element!.Get...
class Delete (line 100) | public sealed class Delete : Edit<EqA, A>, IEquatable<Delete>
method Delete (line 102) | public Delete(int position, A element) : base(position, element) { }
method New (line 103) | public static Delete New(int position, A element) => new Delete(posi...
method ToString (line 104) | public override string ToString() => $"Delete({Position}, {Element})";
method Index (line 105) | internal override Edit<EqA, A> Index(Func<int, int> f) => new Delete...
method MapOld (line 106) | public override Edit<EqA, A> MapOld(Func<A, A> f) => new Delete(Posi...
method MapNew (line 107) | public override Edit<EqA, A> MapNew(Func<A, A> f) => this;
method Equals (line 108) | public bool Equals(Delete? other) => base.Equals(other);
method Equals (line 109) | public override bool Equals(object? obj) => obj is Delete del && Equ...
method GetHashCode (line 112) | public override int GetHashCode() => (Position + 13) * (Element!.Get...
class Replace (line 118) | public sealed class Replace : Edit<EqA, A>, IEquatable<Replace>
method Replace (line 121) | public Replace(int position, A element, A replaceElement) : base(pos...
method New (line 123) | public static Replace New(int position, A element, A replaceElement)...
method ToString (line 124) | public override string ToString() => $"Replace({Position}, {Element}...
method Index (line 125) | internal override Edit<EqA, A> Index(Func<int, int> f) => new Replac...
method MapOld (line 126) | public override Edit<EqA, A> MapOld(Func<A, A> f) => new Replace(Pos...
method MapNew (line 127) | public override Edit<EqA, A> MapNew(Func<A, A> f) => new Replace(Pos...
method Equals (line 128) | public bool Equals(Replace? other) =>
method Equals (line 131) | public override bool Equals(object? obj) => obj is Replace repl && E...
method GetHashCode (line 134) | public override int GetHashCode() => (Position + 13) * (Element!.Get...
FILE: LanguageExt.Core/DataTypes/Patch/Patch.Internal.cs
class PatchInternal (line 9) | internal static class PatchInternal
method mapAccumR (line 11) | public static (A, Seq<C>) mapAccumR<A, B, C>(Func<A, B, (A, C)> f, A s...
method mapAccumL (line 19) | public static (A, Seq<C>) mapAccumL<A, B, C>(Func<A, B, (A, C)> f, A s...
method leastChanges (line 27) | public static (C, Seq<O>) leastChanges<OrdC, V, O, C>(PatchParams<V, O...
method quotRem (line 37) | static (int quot, int rem) quotRem(int x, int y) =>
method minimumBy (line 40) | static A minimumBy<A>(Func<A, A, int> compare, Lst<A> list) =>
method constructN (line 45) | static SpanArray<A> constructN<A>(int n, Func<SpanArray<A>, A> f)
method rawChanges (line 57) | public static SpanArray<(C, Seq<Option<O>>)> rawChanges<OrdC, V, O, C>...
FILE: LanguageExt.Core/DataTypes/Patch/Patch.Module.cs
class Patch (line 25) | public static class Patch
method unsafeFromSeq (line 31) | public static Patch<EqA, A> unsafeFromSeq<EqA, A>(Seq<Edit<EqA, A>> ed...
method fromSeq (line 38) | public static Patch<EqA, A> fromSeq<EqA, A>(Seq<Edit<EqA, A>> edits) w...
method normalise (line 48) | internal static Seq<Edit<EqA, A>> normalise<EqA, A>(Seq<Edit<EqA, A>> ...
method append (line 90) | public static Patch<EqA, A> append<EqA, A>(Patch<EqA, A> px, Patch<EqA...
method inverse (line 97) | public static Patch<EqA, A> inverse<EqA, A>(Patch<EqA, A> patch) where...
method applicable (line 115) | public static bool applicable<EqA, A>(Patch<EqA, A> pa, IEnumerable<A>...
method composable (line 137) | public static bool composable<EqA, A>(Patch<EqA, A> pa, Patch<EqA, A> ...
method parms (line 204) | static PatchParams<A, Edit<EqA, A>, MInt32> parms<EqA, A>() where EqA ...
method sizeChange (line 216) | public static int sizeChange<EqA, A>(Patch<EqA, A> patch) where EqA : ...
method apply (line 237) | public static Lst<A> apply<EqA, A>(Patch<EqA, A> patch, Lst<A> va) whe...
method apply (line 243) | public static Seq<A> apply<EqA, A>(Patch<EqA, A> patch, Seq<A> va) whe...
method apply (line 249) | public static Arr<A> apply<EqA, A>(Patch<EqA, A> patch, Arr<A> va) whe...
method apply (line 255) | public static A[] apply<EqA, A>(Patch<EqA, A> patch, A[] va) where EqA...
method apply (line 261) | public static SpanArray<A> apply<EqA, A>(Patch<EqA, A> patch, SpanArra...
method apply (line 267) | public static List<A> apply<EqA, A>(Patch<EqA, A> patch, List<A> va) w...
method apply (line 273) | public static Iterable<A> apply<EqA, A>(Patch<EqA, A> patch, IEnumerab...
method empty (line 340) | public static Patch<EqA, A> empty<EqA, A>() where EqA : Eq<A> =>
method ours (line 346) | public static A ours<A>(A x, A y) =>
method theirs (line 352) | public static A theirs<A>(A x, A y) =>
method transform (line 358) | public static (Patch<EqA, A> a, Patch<EqA, A> b) transform<EqA, A>(Pat...
method transformWith (line 374) | public static (Patch<EqA, A> a, Patch<EqA, A> b) transformWith<EqA, A>...
method diff (line 486) | public static Patch<EqA, A> diff<EqA, A>(IEnumerable<A> va, IEnumerabl...
type MInt32 (line 505) | internal readonly record struct MInt32(int Value) : Monoid<MInt32>, Or...
FILE: LanguageExt.Core/DataTypes/Patch/Patch.cs
type Patch (line 25) | public readonly struct Patch<EqA, A> :
method Patch (line 44) | internal Patch(Seq<Edit<EqA, A>> edits) =>
method Equals (line 50) | public bool Equals(Patch<EqA, A> mb) =>
method Equals (line 56) | public override bool Equals(object? obj) =>
method GetHashCode (line 85) | public override int GetHashCode() =>
method ToString (line 91) | public override string ToString() =>
method Applicable (line 98) | public bool Applicable(IEnumerable<A> document) =>
method Combine (line 105) | public Patch<EqA, A> Combine(Patch<EqA, A> mb)
method Inverse (line 193) | public Patch<EqA, A> Inverse() =>
method SizeChange (line 200) | public int SizeChange() =>
method Apply (line 206) | public Iterable<A> Apply(IEnumerable<A> va) =>
method Apply (line 212) | public Seq<A> Apply(Seq<A> va) =>
method Apply (line 218) | public Lst<A> Apply(Lst<A> va) =>
method Apply (line 224) | public SpanArray<A> Apply(SpanArray<A> va) =>
method Apply (line 230) | public Arr<A> Apply(Arr<A> va) =>
method Apply (line 236) | public A[] Apply(A[] va) =>
method Apply (line 242) | public List<A> Apply(List<A> va) =>
FILE: LanguageExt.Core/DataTypes/Patch/PatchParams.cs
class PatchParams (line 9) | internal class PatchParams<V, O, C>
method PatchParams (line 18) | public PatchParams(
FILE: LanguageExt.Core/DataTypes/Pure/Pure.Extensions.cs
class PureExtensions (line 6) | public static class PureExtensions
FILE: LanguageExt.Core/DataTypes/Pure/Pure.cs
type Pure (line 16) | public readonly record struct Pure<A>(A Value)
FILE: LanguageExt.Core/DataTypes/Range/Range.Extensions.cs
class RangeExtensions (line 7) | public static class RangeExtensions
method As (line 12) | public static Range<A> As<A>(this K<Range, A> ma) =>
method InRange (line 20) | [Pure]
method Overlaps (line 35) | [Pure]
FILE: LanguageExt.Core/DataTypes/Range/Range.Module.cs
class Range (line 7) | public partial class Range
method zero (line 12) | public static Range<A> zero<A>()
method fromMinMax (line 21) | [Pure]
method fromMinMax (line 37) | [Pure]
method fromCount (line 69) | [Pure]
method fromCount (line 82) | [Pure]
FILE: LanguageExt.Core/DataTypes/Range/Range.Monad.cs
class Range (line 7) | public partial class Range : Foldable<Range>
method FoldWhile (line 9) | static S Foldable<Range>.FoldWhile<A, S>(
method FoldBackWhile (line 23) | static S Foldable<Range>.FoldBackWhile<A, S>(
method FoldStep (line 37) | static Fold<A, S> Foldable<Range>.FoldStep<A, S>(K<Range, A> ta, S ini...
method FoldStepBack (line 48) | static Fold<A, S> Foldable<Range>.FoldStepBack<A, S>(K<Range, A> ta, S...
FILE: LanguageExt.Core/DataTypes/Range/Range.cs
type Range (line 13) | [Serializable]
FILE: LanguageExt.Core/DataTypes/Ratio/Ratio.cs
type Ratio (line 10) | public readonly struct Ratio<A>
method Ratio (line 22) | public Ratio(A num, A den)
FILE: LanguageExt.Core/DataTypes/Record/Attributes.cs
class EqAttribute (line 6) | public class NonRecordAttribute : Attribute;
method EqAttribute (line 20) | public EqAttribute(Type type)
class OrdAttribute (line 32) | public class OrdAttribute : Attribute
method OrdAttribute (line 34) | public OrdAttribute(Type type)
class HashableAttribute (line 46) | public class HashableAttribute : Attribute
method HashableAttribute (line 48) | public HashableAttribute(Type type)
FILE: LanguageExt.Core/DataTypes/Record/Record.cs
class Record (line 13) | [Serializable]
method Record (line 18) | protected Record() { }
method Record (line 20) | protected Record(SerializationInfo info, StreamingContext context) =>
method GetHashCode (line 41) | public override int GetHashCode() =>
method Equals (line 44) | public override bool Equals(object? obj) =>
method CompareTo (line 48) | public virtual int CompareTo(RECORDTYPE? other) =>
method Equals (line 51) | public virtual bool Equals(RECORDTYPE? other) =>
method ToString (line 54) | public override string ToString() =>
method GetObjectData (line 57) | public virtual void GetObjectData(SerializationInfo info, StreamingCon...
method CompareTo (line 60) | public int CompareTo(object? obj) =>
FILE: LanguageExt.Core/DataTypes/Record/RecordType.cs
class RecordType (line 11) | public static class RecordType<A>
method Equals (line 48) | [Obsolete("Don't use Equals - use either RecordType<A>.Equality or Rec...
class RecordTypeIncludeBase (line 53) | internal static class RecordTypeIncludeBase<A>
method RecordTypeIncludeBase (line 57) | static RecordTypeIncludeBase() =>
class RecordTypeHash (line 63) | internal static class RecordTypeHash<A>
method RecordTypeHash (line 67) | static RecordTypeHash() =>
class RecordTypeEquality (line 71) | internal static class RecordTypeEquality<A>
method RecordTypeEquality (line 75) | static RecordTypeEquality() =>
class RecordTypeEqualityTyped (line 79) | internal static class RecordTypeEqualityTyped<A>
method RecordTypeEqualityTyped (line 83) | static RecordTypeEqualityTyped() =>
class RecordTypeCompare (line 87) | internal static class RecordTypeCompare<A>
method RecordTypeCompare (line 91) | static RecordTypeCompare() =>
class RecordTypeToString (line 95) | internal static class RecordTypeToString<A>
method RecordTypeToString (line 99) | static RecordTypeToString() =>
class RecordTypeSetObjectData (line 103) | internal static class RecordTypeSetObjectData<A>
method RecordTypeSetObjectData (line 107) | static RecordTypeSetObjectData() =>
class RecordTypeGetObjectData (line 111) | internal static class RecordTypeGetObjectData<A>
method RecordTypeGetObjectData (line 115) | static RecordTypeGetObjectData() =>
FILE: LanguageExt.Core/DataTypes/Record/RecordTypeIgnoreBase.cs
class RecordTypeIgnoreBase (line 11) | public static class RecordTypeIgnoreBase<A>
method RecordTypeIgnoreBase (line 13) | static RecordTypeIgnoreBase()
method Equals (line 59) | [Obsolete("Don't use Equals - use either RecordType<A>.Equality or Rec...
FILE: LanguageExt.Core/DataTypes/Record/TypeInfoExt.cs
class TypeInfoAllMemberExtensions (line 7) | public static class TypeInfoAllMemberExtensions
method GetAllConstructors (line 9) | public static IEnumerable<ConstructorInfo> GetAllConstructors(this Typ...
method GetAllEvents (line 12) | public static IEnumerable<EventInfo> GetAllEvents(this TypeInfo typeIn...
method GetAllFields (line 15) | public static IEnumerable<FieldInfo> GetAllFields(this TypeInfo typeIn...
method GetAllMembers (line 18) | public static IEnumerable<MemberInfo> GetAllMembers(this TypeInfo type...
method GetAllMethods (line 21) | public static IEnumerable<MethodInfo> GetAllMethods(this TypeInfo type...
method GetAllNestedTypes (line 24) | public static IEnumerable<TypeInfo> GetAllNestedTypes(this TypeInfo ty...
method GetAllProperties (line 27) | public static IEnumerable<PropertyInfo> GetAllProperties(this TypeInfo...
method GetAll (line 30) | private static IEnumerable<T> GetAll<T>(TypeInfo typeInfo, Func<TypeIn...
FILE: LanguageExt.Core/DataTypes/SpanArray/SpanArray.cs
type SpanArray (line 22) | public readonly struct SpanArray<A> : IEnumerable<A>
method SpanArray (line 29) | SpanArray(A[] data, int index, int count)
method Elem (line 37) | public Option<A> Elem(int index) =>
method GetEnumerator (line 42) | public IEnumerator<A> GetEnumerator()
method New (line 62) | public static SpanArray<A> New(IEnumerable<A> sequence)
method New (line 68) | public static SpanArray<A> New(A[] data) =>
method New (line 71) | public static SpanArray<A> New(int n) =>
method Slice (line 74) | public SpanArray<A> Slice(int index, int count)
method Take (line 83) | public SpanArray<A> Take(int n) =>
method Skip (line 86) | public SpanArray<A> Skip(int n) =>
method GetEnumerator (line 98) | IEnumerator IEnumerable.GetEnumerator() =>
method UnsafeCopy (line 101) | public Unit UnsafeCopy(SpanArray<A> dest)
FILE: LanguageExt.Core/DataTypes/StringM/OrdString.cs
type HashableString (line 9) | public interface HashableString<STRING> : Hashable<STRING>
method GetHashCode (line 16) | static int Hashable<STRING>.GetHashCode(STRING x) =>
type EqString (line 20) | public interface EqString<STRING> : HashableString<STRING>, Eq<STRING>
method Equals (line 24) | static bool Eq<STRING>.Equals(STRING lhs, STRING rhs) =>
type OrdString (line 28) | public interface OrdString<STRING> : EqString<STRING>, Ord<STRING>
method Compare (line 33) | static int Ord<STRING>.Compare(STRING lhs, STRING rhs) =>
type OrdinalIgnoreCase (line 37) | public interface OrdinalIgnoreCase<STRING> : OrdString<STRING>
type Ordinal (line 46) | public interface Ordinal<STRING> : OrdString<STRING>
type CultureIgnoreCase (line 55) | public interface CultureIgnoreCase<STRING> : OrdString<STRING>
type Culture (line 64) | public interface Culture<STRING> : OrdString<STRING>
type InvariantIgnoreCase (line 73) | public interface InvariantIgnoreCase<STRING> : OrdString<STRING>
type InvariantCulture (line 82) | public interface InvariantCulture<STRING> : OrdString<STRING>
FILE: LanguageExt.Core/DataTypes/StringM/StringM.Ord.cs
type StringOrdinalM (line 6) | public readonly record struct StringOrdinalM(string Value) : StringM<Str...
type StringOrdinalIgnoreCaseM (line 28) | public readonly record struct StringOrdinalIgnoreCaseM(string Value) : S...
type StringCultureM (line 50) | public readonly record struct StringCultureM(string Value) : StringM<Str...
type StringCultureIgnoreCaseM (line 72) | public readonly record struct StringCultureIgnoreCaseM(string Value) : S...
type StringInvariantM (line 93) | public readonly record struct StringInvariantM(string Value) : StringM<S...
type StringInvariantIgnoreCaseM (line 114) | public readonly record struct StringInvariantIgnoreCaseM(string Value) :...
FILE: LanguageExt.Core/DataTypes/StringM/StringM.Trait.cs
type StringM (line 11) | public interface StringM<SELF> :
method Combine (line 29) | SELF Semigroup<SELF>.Combine(SELF rhs) =>
method ToString (line 46) | public string ToString() =>
method GetHashCode (line 49) | public int GetHashCode() =>
method Equals (line 52) | bool IEquatable<SELF>.Equals(SELF? rhs) =>
method CompareTo (line 55) | int IComparable<SELF>.CompareTo(SELF? rhs) =>
method Parse (line 60) | static SELF IParsable<SELF>.Parse(string s, IFormatProvider? provider) =>
method TryParse (line 63) | static bool IParsable<SELF>.TryParse(string? s, IFormatProvider? provi...
method Parse (line 69) | static SELF ISpanParsable<SELF>.Parse(ReadOnlySpan<char> s, IFormatPro...
method TryParse (line 76) | static bool ISpanParsable<SELF>.TryParse(ReadOnlySpan<char> s, IFormat...
FILE: LanguageExt.Core/DataTypes/StringM/StringM.cs
type StringM (line 10) | public readonly record struct StringM(string Value) : StringM<StringM>
FILE: LanguageExt.Core/DataTypes/Unit/Unit.Prelude.cs
class Prelude (line 5) | public static partial class Prelude
method ignore (line 18) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Ignore (line 27) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
FILE: LanguageExt.Core/DataTypes/Unit/Unit.cs
type Unit (line 10) | [Serializable]
method GetHashCode (line 15) | [Pure]
method Equals (line 19) | [Pure]
method ToString (line 23) | [Pure]
method Equals (line 27) | [Pure]
method Return (line 61) | [Pure]
method Return (line 70) | [Pure]
method CompareTo (line 76) | [Pure]
method Combine (line 80) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple1/ValueTuple1.Extensions.cs
class ValueTuple1Extensions (line 6) | public static class ValueTuple1Extensions
method Add (line 11) | [Pure]
method Contains (line 18) | [Pure]
method Map (line 26) | [Pure]
method Select (line 33) | [Pure]
method Iter (line 40) | public static Unit Iter<A>(this ValueTuple<A> self, Action<A> func)
method Fold (line 49) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple1/ValueTuple1.Prelude.cs
class Prelude (line 7) | public static partial class Prelude
method add (line 12) | [Pure]
method contains (line 19) | [Pure]
method map (line 27) | [Pure]
method iter (line 34) | public static Unit iter<A>(ValueTuple<A> self, Action<A> func)
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple2/ValueTuple2.Extensions.cs
class ValueTuple2Extensions (line 7) | public static class ValueTuple2Extensions
method Add (line 12) | [Pure]
method Head (line 19) | [Pure]
method Last (line 26) | [Pure]
method Tail (line 33) | [Pure]
method Map (line 40) | [Pure]
method Map (line 47) | [Pure]
method BiMap (line 54) | [Pure]
method MapFirst (line 61) | [Pure]
method MapSecond (line 68) | [Pure]
method Select (line 75) | [Pure]
method Iter (line 82) | public static Unit Iter<T1, T2>(this ValueTuple<T1, T2> self, Action<T...
method Iter (line 91) | public static Unit Iter<T1, T2>(this ValueTuple<T1, T2> self, Action<T...
method Fold (line 101) | [Pure]
method BiFold (line 108) | [Pure]
method BiFoldBack (line 115) | [Pure]
method Traverse (line 122) | [Pure]
method Traverse (line 132) | [Pure]
method Sequence (line 142) | [Pure]
method Traverse (line 151) | [Pure]
method Traverse (line 161) | [Pure]
method Sequence (line 171) | [Pure]
method Traverse (line 180) | [Pure]
method Traverse (line 190) | [Pure]
method Sequence (line 200) | [Pure]
method Traverse (line 209) | [Pure]
method Traverse (line 219) | [Pure]
method Sequence (line 229) | [Pure]
method Traverse (line 238) | [Pure]
method Traverse (line 248) | [Pure]
method Sequence (line 258) | [Pure]
method Traverse (line 267) | [Pure]
method Traverse (line 277) | [Pure]
method Sequence (line 287) | [Pure]
method Traverse (line 296) | [Pure]
method Traverse (line 303) | [Pure]
method Sequence (line 310) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple2/ValueTuple2.Prelude.cs
class Prelude (line 7) | public static partial class Prelude
method ad (line 12) | [Pure]
method head (line 19) | [Pure]
method last (line 26) | [Pure]
method tail (line 33) | [Pure]
method sum (line 40) | [Pure]
method product (line 48) | [Pure]
method contains (line 56) | [Pure]
method map (line 65) | [Pure]
method map (line 72) | [Pure]
method bimap (line 79) | [Pure]
method iter (line 86) | public static Unit iter<T1, T2>(ValueTuple<T1, T2> self, Action<T1> fi...
method iter (line 92) | public static Unit iter<T1, T2>(ValueTuple<T1, T2> self, Action<T1, T2...
method fold (line 101) | [Pure]
method bifold (line 108) | [Pure]
method bifoldBack (line 115) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple3/ValueTuple3.Extensions.cs
class ValueTuple3Extensions (line 6) | public static class ValueTuple3Extensions
method Add (line 11) | [Pure]
method Head (line 18) | [Pure]
method Last (line 25) | [Pure]
method Tail (line 32) | [Pure]
method Sum (line 39) | [Pure]
method Product (line 47) | [Pure]
method Contains (line 55) | [Pure]
method Map (line 65) | [Pure]
method Map (line 72) | [Pure]
method Map (line 79) | [Pure]
method MapFirst (line 86) | [Pure]
method MapSecond (line 93) | [Pure]
method MapThird (line 100) | [Pure]
method Select (line 107) | [Pure]
method Iter (line 114) | public static Unit Iter<T1, T2, T3>(this ValueTuple<T1, T2, T3> self, ...
method Iter (line 123) | public static Unit Iter<T1, T2, T3>(this ValueTuple<T1, T2, T3> self, ...
method Fold (line 134) | [Pure]
method TriFold (line 141) | [Pure]
method TriFoldBack (line 148) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple3/ValueTuple3.Prelude.cs
class Prelude (line 7) | public static partial class Prelude
method add (line 12) | [Pure]
method head (line 19) | [Pure]
method last (line 26) | [Pure]
method tail (line 33) | [Pure]
method sum (line 40) | [Pure]
method product (line 48) | [Pure]
method contains (line 56) | [Pure]
method map (line 66) | [Pure]
method map (line 73) | [Pure]
method trimap (line 80) | [Pure]
method mapFirst (line 87) | [Pure]
method mapSecond (line 94) | [Pure]
method mapThird (line 101) | [Pure]
method iter (line 108) | public static Unit iter<T1, T2, T3>(ValueTuple<T1, T2, T3> self, Actio...
method iter (line 117) | public static Unit iter<T1, T2, T3>(ValueTuple<T1, T2, T3> self, Actio...
method fold (line 128) | [Pure]
method trifold (line 135) | [Pure]
method trifoldBack (line 142) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple4/ValueTuple4.Extensions.cs
class ValueTuple4Extensions (line 6) | public static class ValueTuple4Extensions
method Add (line 11) | [Pure]
method Head (line 18) | [Pure]
method Last (line 25) | [Pure]
method Tail (line 32) | [Pure]
method Contains (line 39) | [Pure]
method Map (line 50) | [Pure]
method Map (line 57) | [Pure]
method Map (line 64) | [Pure]
method MapFirst (line 71) | [Pure]
method MapSecond (line 78) | [Pure]
method MapThird (line 85) | [Pure]
method MapFourth (line 92) | [Pure]
method Select (line 99) | [Pure]
method Iter (line 106) | public static Unit Iter<A, B, C, D>(this (A, B, C, D) self, Action<A, ...
method Iter (line 115) | public static Unit Iter<A, B, C, D>(this (A, B, C, D) self, Action<A> ...
method Fold (line 127) | [Pure]
method QuadFold (line 134) | [Pure]
method QuadFoldBack (line 141) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple4/ValueTuple4.Prelude.cs
class Prelude (line 7) | public static partial class Prelude
method add (line 12) | [Pure]
method head (line 19) | [Pure]
method last (line 26) | [Pure]
method tail (line 33) | [Pure]
method contains (line 40) | [Pure]
method map (line 51) | [Pure]
method map (line 58) | [Pure]
method map (line 65) | [Pure]
method mapFirst (line 72) | [Pure]
method mapSecond (line 79) | [Pure]
method mapThird (line 86) | [Pure]
method mapFourth (line 93) | [Pure]
method iter (line 100) | public static Unit iter<A, B, C, D>((A, B, C, D) self, Action<A, B, C,...
method iter (line 109) | public static Unit iter<A, B, C, D>((A, B, C, D) self, Action<A> first...
method fold (line 121) | [Pure]
method quadFold (line 128) | [Pure]
method quadFoldBack (line 135) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple5/ValueTuple5.Extensions.cs
class ValueTuple5Extensions (line 6) | public static class ValueTuple5Extensions
method Add (line 11) | [Pure]
method Head (line 18) | [Pure]
method Last (line 25) | [Pure]
method Tail (line 32) | [Pure]
method Contains (line 39) | [Pure]
method Map (line 51) | [Pure]
method Map (line 58) | [Pure]
method Map (line 65) | [Pure]
method MapFirst (line 72) | [Pure]
method MapSecond (line 79) | [Pure]
method MapThird (line 86) | [Pure]
method MapFourth (line 93) | [Pure]
method MapFifth (line 100) | [Pure]
method Select (line 107) | [Pure]
method Iter (line 114) | public static Unit Iter<A, B, C, D, E>(this (A, B, C, D, E) self, Acti...
method Iter (line 123) | public static Unit Iter<A, B, C, D, E>(this (A, B, C, D, E) self, Acti...
method Fold (line 136) | [Pure]
method QuintFold (line 143) | [Pure]
method QuintFoldBack (line 150) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple5/ValueTuple5.Prelude.cs
class Prelude (line 7) | public static partial class Prelude
method add (line 12) | [Pure]
method head (line 19) | [Pure]
method last (line 26) | [Pure]
method tail (line 33) | [Pure]
method contains (line 40) | [Pure]
method map (line 52) | [Pure]
method map (line 59) | [Pure]
method map (line 66) | [Pure]
method mapFirst (line 73) | [Pure]
method mapSecond (line 80) | [Pure]
method mapThird (line 87) | [Pure]
method mapFourth (line 94) | [Pure]
method mapFifth (line 101) | [Pure]
method iter (line 108) | public static Unit iter<A, B, C, D, E>((A, B, C, D, E) self, Action<A,...
method iter (line 117) | public static Unit iter<A, B, C, D, E>((A, B, C, D, E) self, Action<A>...
method fold (line 130) | [Pure]
method quintFold (line 137) | [Pure]
method quintFoldBack (line 144) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple6/ValueTuple6.Extensions.cs
class ValueTuple6Extensions (line 6) | public static class ValueTuple6Extensions
method Add (line 11) | [Pure]
method Head (line 18) | [Pure]
method Last (line 25) | [Pure]
method Tail (line 32) | [Pure]
method Contains (line 39) | [Pure]
method Map (line 52) | [Pure]
method Map (line 59) | [Pure]
method Map (line 66) | [Pure]
method MapFirst (line 73) | [Pure]
method MapSecond (line 80) | [Pure]
method MapThird (line 87) | [Pure]
method MapFourth (line 94) | [Pure]
method MapFifth (line 101) | [Pure]
method MapSixth (line 108) | [Pure]
method Select (line 115) | [Pure]
method Iter (line 122) | public static Unit Iter<A, B, C, D, E, F>(this (A, B, C, D, E, F) self...
method Iter (line 131) | public static Unit Iter<A, B, C, D, E, F>(this (A, B, C, D, E, F) self...
method Fold (line 145) | [Pure]
method SextFold (line 152) | [Pure]
method SextFoldBack (line 159) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple6/ValueTuple6.Prelude.cs
class Prelude (line 7) | public static partial class Prelude
method add (line 12) | [Pure]
method head (line 19) | [Pure]
method last (line 26) | [Pure]
method tail (line 33) | [Pure]
method contains (line 40) | [Pure]
method map (line 53) | [Pure]
method map (line 60) | [Pure]
method map (line 67) | [Pure]
method mapFirst (line 74) | [Pure]
method mapSecond (line 81) | [Pure]
method mapThird (line 88) | [Pure]
method mapFourth (line 95) | [Pure]
method mapFifth (line 102) | [Pure]
method mapSixth (line 109) | [Pure]
method iter (line 116) | public static Unit iter<A, B, C, D, E, F>((A, B, C, D, E, F) self, Act...
method iter (line 125) | public static Unit iter<A, B, C, D, E, F>((A, B, C, D, E, F) self, Act...
method fold (line 139) | [Pure]
method sextFold (line 146) | [Pure]
method sextFoldBack (line 153) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple7/ValueTuple7.Extensions.cs
class ValueTuple7Extensions (line 6) | public static class ValueTuple7Extensions
method Add (line 11) | [Pure]
method Head (line 18) | [Pure]
method Last (line 25) | [Pure]
method Tail (line 32) | [Pure]
method Contains (line 39) | [Pure]
method Map (line 53) | [Pure]
method Map (line 60) | [Pure]
method Map (line 67) | [Pure]
method MapFirst (line 74) | [Pure]
method MapSecond (line 81) | [Pure]
method MapThird (line 88) | [Pure]
method MapFourth (line 95) | [Pure]
method MapFifth (line 102) | [Pure]
method MapSixth (line 109) | [Pure]
method MapSeventh (line 116) | [Pure]
method Select (line 123) | [Pure]
method Iter (line 130) | public static Unit Iter<A, B, C, D, E, F, G>(this (A, B, C, D, E, F, G...
method Iter (line 139) | public static Unit Iter<A, B, C, D, E, F, G>(this (A, B, C, D, E, F, G...
method Fold (line 154) | [Pure]
method SeptFold (line 161) | [Pure]
method SeptFoldBack (line 168) | [Pure]
FILE: LanguageExt.Core/DataTypes/ValueTuple/Tuple7/ValueTuple7.Prelude.cs
class Prelude (line 7) | public static partial class Prelude
method add (line 12) | [Pure]
method head (line 19) | [Pure]
method last (line 26) | [Pure]
method tail (line 33) | [Pure]
method contains (line 40) | [Pure]
method map (line 54) | [Pure]
method map (line 61) | [Pure]
method map (line 68) | [Pure]
method mapFirst (line 75) | [Pure]
method mapSecond (line 82) | [Pure]
method mapThird (line 89) | [Pure]
method mapFourth (line 96) | [Pure]
method mapFifth (line 103) | [Pure]
method mapSixth (line 110) | [Pure]
method mapSeventh (line 117) | [Pure]
method iter (line 124) | public static Unit iter<A, B, C, D, E, F, G>((A, B, C, D, E, F, G) sel...
method iter (line 133) | public static Unit iter<A, B, C, D, E, F, G>((A, B, C, D, E, F, G) sel...
method fold (line 148) | [Pure]
method septFold (line 155) | [Pure]
method septFoldBack (line 162) | [Pure]
FILE: LanguageExt.Core/Deriving/Alternative.cs
class Deriving (line 5) | public static partial class Deriving
FILE: LanguageExt.Core/Deriving/Applicative.cs
class Deriving (line 6) | public static partial class Deriving
type Applicative (line 13) | public interface Applicative<Supertype, Subtype> :
method Pure (line 19) | static K<Supertype, A> Applicative<Supertype>.Pure<A>(A value) =>
method Action (line 22) | static K<Supertype, B> Applicative<Supertype>.Action<A, B>(K<Superty...
method Apply (line 25) | static K<Supertype, B> Applicative<Supertype>.Apply<A, B>(K<Supertyp...
method Apply (line 28) | static K<Supertype, B> Applicative<Supertype>.Apply<A, B>(K<Supertyp...
FILE: LanguageExt.Core/Deriving/Choice.cs
class Deriving (line 6) | public static partial class Deriving
type Choice (line 11) | public interface Choice<Supertype, Subtype> :
method Choose (line 27) | static K<Supertype, A> Choice<Supertype>.Choose<A>(K<Supertype, A> f...
method Choose (line 39) | static K<Supertype, A> Choice<Supertype>.Choose<A>(K<Supertype, A> f...
FILE: LanguageExt.Core/Deriving/Cofunctor.cs
class Deriving (line 6) | public static partial class Deriving
type Cofunctor (line 19) | public interface Cofunctor<Supertype, Subtype> :
method Comap (line 26) | static K<Supertype, A> Cofunctor<Supertype>.Comap<A, B>(Func<A, B> f...
FILE: LanguageExt.Core/Deriving/Decidable.cs
class Deriving (line 6) | public static partial class Deriving
type Decidable (line 15) | public interface Decidable<Supertype, Subtype> :
method Lose (line 21) | static K<Supertype, A> Decidable<Supertype>.Lose<A>(Func<A, Void> f) =>
method Route (line 24) | static K<Supertype, A> Decidable<Supertype>.Route<A, B, C>(
FILE: LanguageExt.Core/Deriving/Divisible.cs
class Deriving (line 6) | public static partial class Deriving
type Divisible (line 8) | public interface Divisible<Supertype, Subtype> :
method Divide (line 14) | static K<Supertype, A> Divisible<Supertype>.Divide<A, B, C>(
method Conquer (line 20) | static K<Supertype, A> Divisible<Supertype>.Conquer<A>() =>
FILE: LanguageExt.Core/Deriving/Fallible.cs
class Deriving (line 7) | public static partial class Deriving
type Fallible (line 12) | public interface Fallible<E, Supertype, Subtype> :
method Fail (line 27) | static K<Supertype, A> Traits.Fallible<E, Supertype>.Fail<A>(E error...
method Catch (line 41) | static K<Supertype, A> Traits.Fallible<E, Supertype>.Catch<A>(
FILE: LanguageExt.Core/Deriving/Final.cs
class Deriving (line 5) | public static partial class Deriving
type Final (line 10) | public interface Final<Supertype, Subtype> :
method Finally (line 23) | static K<Supertype, A> Final<Supertype>.Finally<X, A>(K<Supertype, A...
FILE: LanguageExt.Core/Deriving/Foldable.cs
class Deriving (line 6) | public static partial class Deriving
type Foldable (line 8) | public interface Foldable<Supertype, Subtype> :
method FoldWhile (line 19) | static S Foldable<Supertype>.FoldWhile<A, S>(
method FoldBackWhile (line 30) | static S Foldable<Supertype>.FoldBackWhile<A, S>(
method FoldMaybe (line 46) | static S Foldable<Supertype>.FoldMaybe<A, S>(
method FoldBackMaybe (line 61) | static S Foldable<Supertype>.FoldBackMaybe<A, S>(
method FoldWhileM (line 72) | static K<M, S> Foldable<Supertype>.FoldWhileM<A, M, S>(
method FoldBackWhileM (line 84) | static K<M, S> Foldable<Supertype>.FoldBackWhileM<A, M, S>(
method FoldUntil (line 95) | static S Foldable<Supertype>.FoldUntil<A, S>(
method FoldUntilM (line 107) | static K<M, S> Foldable<Supertype>.FoldUntilM<A, M, S>(
method FoldBackUntil (line 118) | static S Foldable<Supertype>.FoldBackUntil<A, S>(
method FoldBackUntilM (line 130) | static K<M, S> Foldable<Supertype>.FoldBackUntilM<A, M, S>(
method Fold (line 144) | static S Foldable<Supertype>.Fold<A, S>(Func<A, Func<S, S>> f, S ini...
method FoldM (line 154) | static K<M, S> Foldable<Supertype>.FoldM<A, M, S>(
method FoldBack (line 175) | static S Foldable<Supertype>.FoldBack<A, S>(Func<S, Func<A, S>> f, S...
method FoldBackM (line 193) | static K<M, S> Foldable<Supertype>.FoldBackM<A, M, S>(
method Fold (line 205) | static A Foldable<Supertype>.Fold<A>(K<Supertype, A> tm) =>
method FoldWhile (line 214) | static A Foldable<Supertype>.FoldWhile<A>(Func<(A State, A Value), b...
method FoldUntil (line 223) | static A Foldable<Supertype>.FoldUntil<A>(Func<(A State, A Value), b...
method FoldMap (line 232) | static B Foldable<Supertype>.FoldMap<A, B>(Func<A, B> f, K<Supertype...
method FoldMapWhile (line 241) | static B Foldable<Supertype>.FoldMapWhile<A, B>(
method FoldMapUntil (line 252) | static B Foldable<Supertype>.FoldMapUntil<A, B>(
method FoldMapBack (line 262) | static B Foldable<Supertype>.FoldMapBack<A, B>(Func<A, B> f, K<Super...
method FoldMapWhileBack (line 270) | static B Foldable<Supertype>.FoldMapWhileBack<A, B>(
method FoldMapUntilBack (line 280) | static B Foldable<Supertype>.FoldMapUntilBack<A, B>(Func<A, B> f, Fu...
method ToSeq (line 287) | static Seq<A> Foldable<Supertype>.ToSeq<A>(K<Supertype, A> ta) =>
method ToLst (line 293) | static Lst<A> Foldable<Supertype>.ToLst<A>(K<Supertype, A> ta) =>
method ToArr (line 299) | static Arr<A> Foldable<Supertype>.ToArr<A>(K<Supertype, A> ta) =>
method ToIterable (line 305) | static Iterable<A> Foldable<Supertype>.ToIterable<A>(K<Supertype, A>...
method IsEmpty (line 311) | static bool Foldable<Supertype>.IsEmpty<A>(K<Supertype, A> ta) =>
method Count (line 322) | static int Foldable<Supertype>.Count<A>(K<Supertype, A> ta) =>
method Exists (line 328) | static bool Foldable<Supertype>.Exists<A>(Func<A, bool> predicate, K...
method ForAll (line 334) | static bool Foldable<Supertype>.ForAll<A>(Func<A, bool> predicate, K...
method Contains (line 340) | static bool Foldable<Supertype>.Contains<EqA, A>(A value, K<Supertyp...
method Contains (line 346) | static bool Foldable<Supertype>.Contains<A>(A value, K<Supertype, A>...
method Find (line 352) | static Option<A> Foldable<Supertype>.Find<A>(Func<A, bool> predicate...
method FindBack (line 358) | static Option<A> Foldable<Supertype>.FindBack<A>(Func<A, bool> predi...
method FindAll (line 364) | static Iterable<A> Foldable<Supertype>.FindAll<A>(Func<A, bool> pred...
method FindAllBack (line 370) | static Iterable<A> Foldable<Supertype>.FindAllBack<A>(Func<A, bool> ...
method Sum (line 376) | static A Foldable<Supertype>.Sum<A>(K<Supertype, A> ta) =>
method Product (line 382) | static A Foldable<Supertype>.Product<A>(K<Supertype, A> ta) =>
method Head (line 388) | static Option<A> Foldable<Supertype>.Head<A>(K<Supertype, A> ta) =>
method Last (line 394) | static Option<A> Foldable<Supertype>.Last<A>(K<Supertype, A> ta) =>
method Iter (line 402) | static K<F, Unit> Foldable<Supertype>.Iter<F, A, B>(Func<A, K<F, B>>...
method Iter (line 410) | static Unit Foldable<Supertype>.Iter<A>(Action<A> f, K<Supertype, A>...
method Iter (line 418) | static Unit Foldable<Supertype>.Iter<A>(Action<int, A> f, K<Supertyp...
method Min (line 424) | static Option<A> Foldable<Supertype>.Min<OrdA, A>(K<Supertype, A> ta...
method Min (line 430) | static Option<A> Foldable<Supertype>.Min<A>(K<Supertype, A> ta) =>
method Max (line 436) | static Option<A> Foldable<Supertype>.Max<OrdA, A>(K<Supertype, A> ta...
method Max (line 442) | static Option<A> Foldable<Supertype>.Max<A>(K<Supertype, A> ta) =>
method Min (line 448) | static A Foldable<Supertype>.Min<OrdA, A>(K<Supertype, A> ta, A init...
method Min (line 454) | static A Foldable<Supertype>.Min<A>(K<Supertype, A> ta, A initialMin...
method Max (line 460) | static A Foldable<Supertype>.Max<OrdA, A>(K<Supertype, A> ta, A init...
method Max (line 466) | static A Foldable<Supertype>.Max<A>(K<Supertype, A> ta, A initialMax...
method Average (line 472) | static A Foldable<Supertype>.Average<A>(K<Supertype, A> ta) =>
method Average (line 478) | static B Foldable<Supertype>.Average<A, B>(Func<A, B> f, K<Supertype...
method At (line 484) | static Option<A> Foldable<Supertype>.At<A>(K<Supertype, A> ta, Index...
method Partition (line 494) | static (Seq<A> True, Seq<A> False) Foldable<Supertype>.Partition<A>(...
FILE: LanguageExt.Core/Deriving/Functor.cs
class Deriving (line 6) | public static partial class Deriving
type Functor (line 13) | public interface Functor<Supertype, Subtype> :
method Map (line 28) | static K<Supertype, B> Functor<Supertype>.Map<A, B>(Func<A, B> f, K<...
FILE: LanguageExt.Core/Deriving/Monad.cs
class Deriving (line 6) | public static partial class Deriving
type Monad (line 13) | public interface Monad<Supertype, Subtype> :
method Bind (line 27) | static K<Supertype, B> Monad<Supertype>.Bind<A, B>(K<Supertype, A> m...
method Flatten (line 30) | static K<Supertype, A> Monad<Supertype>.Flatten<A>(K<Supertype, K<Su...
method Recur (line 33) | static K<Supertype, B> Monad<Supertype>.Recur<A, B>(
FILE: LanguageExt.Core/Deriving/MonadIO.cs
class Deriving (line 7) | public static partial class Deriving
type MonadIO (line 14) | public interface MonadIO<Supertype, Subtype> :
method LiftIO (line 29) | static K<Supertype, A> Traits.MonadIO<Supertype>.LiftIO<A>(K<IO, A> ...
method LiftIO (line 41) | static K<Supertype, A> Traits.MonadIO<Supertype>.LiftIO<A>(IO<A> ma) =>
FILE: LanguageExt.Core/Deriving/MonadT.cs
class Deriving (line 5) | public static partial class Deriving
type MonadT (line 12) | public interface MonadT<Supertype, Subtype, out M> :
method Lift (line 19) | static K<Supertype, A> MonadT<Supertype, M>.Lift<A>(K<M, A> ma) =>
FILE: LanguageExt.Core/Deriving/MonadUnliftIO.cs
class Deriving (line 7) | public static partial class Deriving
type MonadUnliftIO (line 14) | public interface MonadUnliftIO<Supertype, Subtype> :
method ToIO (line 26) | static K<Supertype, IO<A>> Traits.MonadUnliftIO<Supertype>.ToIO<A>(K...
method MapIO (line 40) | static K<Supertype, B> Traits.MonadUnliftIO<Supertype>.MapIO<A, B>(K...
method LocalIO (line 56) | static K<Supertype, A> MonadUnliftIO<Supertype>.LocalIO<A>(K<Superty...
method PostIO (line 64) | static K<Supertype, A> MonadUnliftIO<Supertype>.PostIO<A>(K<Supertyp...
method TimeoutIO (line 70) | static K<Supertype, A> MonadUnliftIO<Supertype>.TimeoutIO<A>(K<Super...
method BracketIO (line 78) | static K<Supertype, A> MonadUnliftIO<Supertype>.BracketIO<A>(K<Super...
method BracketIO (line 89) | static K<Supertype, C> MonadUnliftIO<Supertype>.BracketIO<A, B, C>(
method BracketIO (line 104) | static K<Supertype, C> MonadUnliftIO<Supertype>.BracketIO<A, B, C>(
method RepeatIO (line 124) | static K<Supertype, A> MonadUnliftIO<Supertype>.RepeatIO<A>(K<Supert...
method RepeatIO (line 136) | static K<Supertype, A> MonadUnliftIO<Supertype>.RepeatIO<A>(
method RepeatWhileIO (line 150) | static K<Supertype, A> MonadUnliftIO<Supertype>.RepeatWhileIO<A>(
method RepeatWhileIO (line 165) | static K<Supertype, A> MonadUnliftIO<Supertype>.RepeatWhileIO<A>(
method RepeatUntilIO (line 180) | static K<Supertype, A> MonadUnliftIO<Supertype>.RepeatUntilIO<A>(
method RepeatUntilIO (line 195) | static K<Supertype, A> MonadUnliftIO<Supertype>.RepeatUntilIO<A>(
method RetryIO (line 217) | static K<Supertype, A> MonadUnliftIO<Supertype>.RetryIO<A>(K<Superty...
method RetryIO (line 231) | static K<Supertype, A> MonadUnliftIO<Supertype>.RetryIO<A>(
method RetryWhileIO (line 248) | static K<Supertype, A> MonadUnliftIO<Supertype>.RetryWhileIO<A>(
method RetryWhileIO (line 265) | static K<Supertype, A> MonadUnliftIO<Supertype>.RetryWhileIO<A>(
method RetryUntilIO (line 283) | static K<Supertype, A> MonadUnliftIO<Supertype>.RetryUntilIO<A>(
method RetryUntilIO (line 300) | static K<Supertype, A> MonadUnliftIO<Supertype>.RetryUntilIO<A>(
method FoldIO (line 311) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldIO<S, A>(
method FoldIO (line 318) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldIO<S, A>(
method FoldWhileIO (line 324) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldWhileIO<S, A>(
method FoldWhileIO (line 332) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldWhileIO<S, A>(
method FoldWhileIO (line 339) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldWhileIO<S, A>(
method FoldWhileIO (line 347) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldWhileIO<S, A>(
method FoldWhileIO (line 354) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldWhileIO<S, A>(
method FoldWhileIO (line 362) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldWhileIO<S, A>(
method FoldUntilIO (line 369) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldUntilIO<S, A>(
method FoldUntilIO (line 377) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldUntilIO<S, A>(
method FoldUntilIO (line 384) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldUntilIO<S, A>(
method FoldUntilIO (line 392) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldUntilIO<S, A>(
method FoldUntilIO (line 399) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldUntilIO<S, A>(
method FoldUntilIO (line 406) | static K<Supertype, S> MonadUnliftIO<Supertype>.FoldUntilIO<S, A>(
FILE: LanguageExt.Core/Deriving/MonoidK.cs
class Deriving (line 5) | public static partial class Deriving
type MonoidK (line 11) | public interface MonoidK<Supertype, Subtype> :
method Empty (line 20) | static K<Supertype, A> MonoidK<Supertype>.Empty<A>() =>
FILE: LanguageExt.Core/Deriving/Readable.cs
class Deriving (line 6) | public static partial class Deriving
type Readable (line 14) | public interface Readable<Supertype, Env, Subtype> :
method Asks (line 24) | static K<Supertype, A> Readable<Supertype, Env>.Asks<A>(Func<Env, A>...
method Local (line 27) | static K<Supertype, A> Readable<Supertype, Env>.Local<A>(Func<Env, E...
FILE: LanguageExt.Core/Deriving/SemigroupK.cs
class Deriving (line 5) | public static partial class Deriving
type SemigroupK (line 10) | public interface SemigroupK<Supertype, Subtype> :
method Combine (line 23) | static K<Supertype, A> SemigroupK<Supertype>.Combine<A>(K<Supertype,...
FILE: LanguageExt.Core/Deriving/Stateful.cs
class Deriving (line 6) | public static partial class Deriving
type Stateful (line 8) | public interface Stateful<Supertype, Subtype, S> :
method Put (line 15) | static K<Supertype, Unit> Stateful<Supertype, S>.Put(S value) =>
method Modify (line 18) | static K<Supertype, Unit> Stateful<Supertype, S>.Modify(Func<S, S> m...
method Gets (line 21) | static K<Supertype, A> Stateful<Supertype, S>.Gets<A>(Func<S, A> f) =>
FILE: LanguageExt.Core/Deriving/Traversable.cs
class Deriving (line 6) | public static partial class Deriving
type Traversable (line 16) | public interface Traversable<Supertype, Subtype> :
method Traverse (line 26) | static K<F, K<Supertype, B>> Traversable<Supertype>.Traverse<F, A, B...
method TraverseM (line 29) | static K<M, K<Supertype, B>> Traversable<Supertype>.TraverseM<M, A, ...
method Sequence (line 32) | static K<F, K<Supertype, A>> Traversable<Supertype>.Sequence<F, A>(K...
method SequenceM (line 35) | static K<F, K<Supertype, A>> Traversable<Supertype>.SequenceM<F, A>(...
method TraverseDefault (line 38) | static K<F, K<Supertype, B>> Traversable<Supertype>.TraverseDefault<...
FILE: LanguageExt.Core/Deriving/Writable.cs
class Deriving (line 6) | public static partial class Deriving
type Writable (line 8) | public interface Writable<Supertype, Subtype, W> :
method Tell (line 22) | static K<Supertype, Unit> Writable<Supertype, W>.Tell(W item) =>
method Listen (line 28) | static K<Supertype, (A Value, W Output)> Writable<Supertype, W>.List...
method Pass (line 39) | static K<Supertype, A> Writable<Supertype, W>.Pass<A>(K<Supertype, (...
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Eff.Module.cs
class Eff (line 10) | public partial class Eff
method Success (line 18) | [Pure, MethodImpl(Opt.Default)]
method Fail (line 28) | [Pure, MethodImpl(Opt.Default)]
method unit (line 35) | public static Eff<Unit> unit() =>
method localCancel (line 45) | public static Eff<A> localCancel<A>(Eff<A> ma) =>
method lift (line 56) | [Pure, MethodImpl(Opt.Default)]
method lift (line 63) | [Pure, MethodImpl(Opt.Default)]
method lift (line 70) | [Pure, MethodImpl(Opt.Default)]
method lift (line 77) | [Pure, MethodImpl(Opt.Default)]
method lift (line 84) | [Pure, MethodImpl(Opt.Default)]
method lift (line 91) | [Pure, MethodImpl(Opt.Default)]
method lift (line 98) | [Pure, MethodImpl(Opt.Default)]
method lift (line 105) | [Pure, MethodImpl(Opt.Default)]
method lift (line 112) | [Pure, MethodImpl(Opt.Default)]
method lift (line 119) | [Pure, MethodImpl(Opt.Default)]
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Eff.Monad.cs
class Eff (line 11) | public partial class Eff :
method Bind (line 21) | static K<Eff, B> Monad<Eff>.Bind<A, B>(K<Eff, A> ma, Func<A, K<Eff, B>...
method Recur (line 24) | static K<Eff, B> Monad<Eff>.Recur<A, B>(A value, Func<A, K<Eff, Next<A...
method Map (line 37) | static K<Eff, B> Functor<Eff>.Map<A, B>(Func<A, B> f, K<Eff, A> ma) =>
method Pure (line 40) | static K<Eff, A> Applicative<Eff>.Pure<A>(A value) =>
method Apply (line 43) | static K<Eff, B> Applicative<Eff>.Apply<A, B>(K<Eff, Func<A, B>> mf, K...
method Apply (line 46) | static K<Eff, B> Applicative<Eff>.Apply<A, B>(K<Eff, Func<A, B>> mf, M...
method Actions (line 49) | static K<Eff, A> Applicative<Eff>.Actions<A>(IterableNE<K<Eff, A>> fas...
method Empty (line 52) | static K<Eff, A> MonoidK<Eff>.Empty<A>() =>
method Empty (line 55) | static K<Eff, A> Alternative<Eff>.Empty<A>() =>
method Choose (line 58) | static K<Eff, A> Choice<Eff>.Choose<A>(K<Eff, A> ma, K<Eff, A> mb) =>
method Choose (line 61) | static K<Eff, A> Choice<Eff>.Choose<A>(K<Eff, A> ma, Memo<Eff, A> mb) =>
method Asks (line 64) | static K<Eff, A> Readable<Eff, MinRT>.Asks<A>(Func<MinRT, A> f) =>
method Local (line 67) | static K<Eff, A> Readable<Eff, MinRT>.Local<A>(Func<MinRT, MinRT> f, K...
method LiftIO (line 70) | static K<Eff, A> MonadIO<Eff>.LiftIO<A>(IO<A> ma) =>
method ToIO (line 73) | static K<Eff, IO<A>> MonadUnliftIO<Eff>.ToIO<A>(K<Eff, A> ma) =>
method MapIO (line 76) | static K<Eff, B> MonadUnliftIO<Eff>.MapIO<A, B>(K<Eff, A> ma, Func<IO<...
method Fail (line 79) | static K<Eff, A> Fallible<Error, Eff>.Fail<A>(Error error) =>
method Catch (line 82) | static K<Eff, A> Fallible<Error, Eff>.Catch<A>(
method Combine (line 87) | static K<Eff, A> SemigroupK<Eff>.Combine<A>(K<Eff, A> lhs, K<Eff, A> r...
method Finally (line 90) | static K<Eff, A> Final<Eff>.Finally<X, A>(K<Eff, A> fa, K<Eff, X> @fin...
method Transform (line 93) | static K<Eff<MinRT>, A> Natural<Eff, Eff<MinRT>>.Transform<A>(K<Eff, A...
method CoTransform (line 96) | static K<Eff, A> CoNatural<Eff, Eff<MinRT>>.CoTransform<A>(K<Eff<MinRT...
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Eff.cs
type Eff (line 19) | public record Eff<A>(Eff<MinRT, A> effect) :
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Extensions/Eff.Extensions.MapApply.cs
class EffExtensions (line 6) | public static partial class EffExtensions
method Map (line 18) | public static Eff<B> Map<A, B>(this Func<A, B> f, K<Eff, A> ma) =>
method Map (line 31) | public static Eff<B> Map<A, B>(this Func<A, B> f, Eff<A> ma) =>
method Action (line 37) | public static Eff<B> Action<A, B>(this Eff<A> ma, K<Eff, B> mb) =>
method Action (line 43) | public static Eff<B> Action<A, B>(this K<Eff, A> ma, K<Eff, B> mb) =>
method Apply (line 56) | public static Eff<B> Apply<A, B>(this Eff<Func<A, B>> mf, K<Eff, A> ma...
method Apply (line 69) | public static Eff<B> Apply<A, B>(this K<Eff, Func<A, B>> mf, K<Eff, A>...
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Extensions/Eff.Extensions.cs
class EffExtensions (line 13) | public static partial class EffExtensions
method As (line 18) | public static Eff<A> As<A>(this K<Eff, A> ma) =>
method As (line 24) | public static Eff<A> As<A>(this Eff<MinRT, A> ma) =>
method Run (line 38) | [Pure, MethodImpl(Opt.Default)]
method Run (line 48) | [Pure, MethodImpl(Opt.Default)]
method RunUnsafe (line 59) | [Pure, MethodImpl(Opt.Default)]
method RunUnsafe (line 70) | [Pure, MethodImpl(Opt.Default)]
method RunIO (line 77) | [Pure, MethodImpl(Opt.Default)]
method RunAsync (line 87) | [Pure, MethodImpl(Opt.Default)]
method RunAsync (line 97) | [Pure, MethodImpl(Opt.Default)]
method RunUnsafeAsync (line 108) | [Pure, MethodImpl(Opt.Default)]
method RunUnsafeAsync (line 119) | [Pure, MethodImpl(Opt.Default)]
method Flatten (line 138) | public static Eff<A> Flatten<A>(this K<Eff, K<Eff, A>> mma) =>
method Flatten (line 151) | public static Eff<A> Flatten<A>(this K<Eff, Eff<A>> mma) =>
method SelectMany (line 162) | public static Eff<D> SelectMany<A, B, C, D>(
method SelectMany (line 171) | public static Eff<D> SelectMany<A, B, C, D>(
method SelectMany (line 180) | public static Eff<E> SelectMany<A, B, C, D, E>(
method SelectMany (line 189) | public static Eff<E> SelectMany<A, B, C, D, E>(
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Extensions/Eff.Guard.cs
class EffGuardExtensions (line 7) | public static partial class EffGuardExtensions
method ToEff (line 12) | public static Eff<Unit> ToEff(this Guard<Error, Unit> guard) =>
method Bind (line 20) | public static Eff<B> Bind<B>(
method SelectMany (line 30) | public static Eff<C> SelectMany<B, C>(
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Operators/Eff.Operators.Applicative.cs
class EffExtensions (line 7) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Operators/Eff.Operators.Choice.cs
class EffExtensions (line 6) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Operators/Eff.Operators.Fallible.cs
class EffExtensions (line 6) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Operators/Eff.Operators.Final.cs
class EffExtensions (line 3) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Operators/Eff.Operators.Functor.cs
class EffExtensions (line 7) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Operators/Eff.Operators.Monad.cs
class EffExtensions (line 6) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Operators/Eff.Operators.cs
class EffExtensions (line 5) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Prelude/Eff.Prelude.cs
class Prelude (line 11) | public static partial class Prelude
method timeout (line 21) | [Pure]
method SuccessEff (line 32) | [Pure, MethodImpl(Opt.Default)]
method FailEff (line 42) | [Pure, MethodImpl(Opt.Default)]
method localCancel (line 64) | public static Eff<A> localCancel<A>(Eff<A> ma) =>
method flatten (line 90) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 102) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 109) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 116) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 123) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 130) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 137) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 144) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 151) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 158) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 165) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 172) | [Pure, MethodImpl(Opt.Default)]
method map (line 186) | [Pure, MethodImpl(Opt.Default)]
method mapFail (line 195) | [Pure, MethodImpl(Opt.Default)]
method bimap (line 211) | [Pure, MethodImpl(Opt.Default)]
method match (line 226) | [Pure, MethodImpl(Opt.Default)]
method ifFail (line 235) | [Pure, MethodImpl(Opt.Default)]
method ifFailEff (line 244) | [Pure, MethodImpl(Opt.Default)]
method filter (line 258) | [Pure, MethodImpl(Opt.Default)]
FILE: LanguageExt.Core/Effects/Eff/Eff no runtime/Prelude/Eff.Prelude.mapapply.cs
class Prelude (line 6) | public static partial class Prelude
method map (line 18) | public static Eff<B> map<A, B>(Func<A, B> f, K<Eff, A> ma) =>
method action (line 24) | public static Eff<B> action<A, B>(K<Eff, A> ma, K<Eff, B> mb) =>
method apply (line 37) | public static Eff<B> apply<A, B>(K<Eff, Func<A, B>> mf, K<Eff, A> ma) =>
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Eff.Module.cs
class Eff (line 10) | public partial class Eff
method Success (line 18) | [Pure, MethodImpl(Opt.Default)]
method Fail (line 28) | [Pure, MethodImpl(Opt.Default)]
method unit (line 35) | public static Eff<RT, Unit> unit<RT>() =>
method runtime (line 46) | [Pure, MethodImpl(Opt.Default)]
method getState (line 53) | [Pure, MethodImpl(Opt.Default)]
method localCancel (line 64) | public static Eff<RT, A> localCancel<RT, A>(Eff<RT, A> ma) =>
method local (line 73) | [Pure, MethodImpl(Opt.Default)]
method lift (line 92) | [Pure, MethodImpl(Opt.Default)]
method lift (line 99) | [Pure, MethodImpl(Opt.Default)]
method lift (line 106) | [Pure, MethodImpl(Opt.Default)]
method lift (line 113) | [Pure, MethodImpl(Opt.Default)]
method lift (line 120) | [Pure, MethodImpl(Opt.Default)]
method lift (line 127) | [Pure, MethodImpl(Opt.Default)]
method lift (line 134) | [Pure, MethodImpl(Opt.Default)]
method lift (line 141) | [Pure, MethodImpl(Opt.Default)]
method lift (line 148) | [Pure, MethodImpl(Opt.Default)]
method lift (line 155) | [Pure, MethodImpl(Opt.Default)]
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Eff.cs
type Eff (line 16) | public record Eff<RT, A>(ReaderT<RT, IO, A> effect) :
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Extensions/Eff.Extensions.MapApply.cs
class EffExtensions (line 6) | public static partial class EffExtensions
method Map (line 18) | public static Eff<RT, B> Map<RT, A, B>(this Func<A, B> f, K<Eff<RT>, ...
method Map (line 31) | public static Eff<RT, B> Map<RT, A, B>(this Func<A, B> f, Eff<RT, A> m...
method Action (line 37) | public static Eff<RT, B> Action<RT, A, B>(
method Apply (line 52) | public static Eff<RT, B> Apply<RT, A, B>(this Eff<RT, Func<A, B>> mf, ...
method Apply (line 65) | public static Eff<RT, B> Apply<RT, A, B>(this K<Eff<RT>, Func<A, B>> m...
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Extensions/Eff.Extensions.cs
class EffExtensions (line 9) | public static partial class EffExtensions
method As (line 16) | public Eff<RT, A> As() =>
method Run (line 25) | [Pure, MethodImpl(Opt.Default)]
method Run (line 35) | [Pure, MethodImpl(Opt.Default)]
method RunUnsafe (line 55) | [Pure, MethodImpl(Opt.Default)]
method RunUnsafe (line 66) | [Pure, MethodImpl(Opt.Default)]
method RunIO (line 73) | [Pure, MethodImpl(Opt.Default)]
method RunAsync (line 83) | [Pure, MethodImpl(Opt.Default)]
method RunAsync (line 102) | [Pure, MethodImpl(Opt.Default)]
method RunUnsafeAsync (line 122) | [Pure, MethodImpl(Opt.Default)]
method RunUnsafeAsync (line 133) | [Pure, MethodImpl(Opt.Default)]
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Extensions/Eff.Guard.cs
class EffExtensions (line 7) | public static partial class EffExtensions
method ToEff (line 12) | public static Eff<RT, Unit> ToEff<RT>(this Guard<Error, Unit> guard) =>
method Bind (line 20) | public static Eff<RT, B> Bind<RT, B>(
method SelectMany (line 30) | public static Eff<RT, C> SelectMany<RT, B, C>(
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Operators/Eff.Operators.Applicative.cs
class EffExtensions (line 7) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Operators/Eff.Operators.Choice.cs
class EffExtensions (line 6) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Operators/Eff.Operators.Fallible.cs
class EffExtensions (line 6) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Operators/Eff.Operators.Final.cs
class EffExtensions (line 3) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Operators/Eff.Operators.Functor.cs
class EffExtensions (line 7) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Operators/Eff.Operators.Monad.cs
class EffExtensions (line 6) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Operators/Eff.Operators.cs
class EffExtensions (line 5) | public static partial class EffExtensions
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Prelude/Eff.Prelude.cs
class Prelude (line 9) | public static partial class Prelude
method SuccessEff (line 17) | [Pure, MethodImpl(Opt.Default)]
method FailEff (line 27) | [Pure, MethodImpl(Opt.Default)]
method runtime (line 39) | [Pure, MethodImpl(Opt.Default)]
method getState (line 46) | [Pure, MethodImpl(Opt.Default)]
method localCancel (line 57) | public static Eff<RT, A> localCancel<RT, A>(Eff<RT, A> ma) =>
method localEff (line 66) | [Pure, MethodImpl(Opt.Default)]
method flatten (line 93) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 105) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 112) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 119) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 126) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 133) | [Pure, MethodImpl(Opt.Default)]
method liftEff (line 140) | [Pure, MethodImpl(Opt.Default)]
method map (line 155) | [Pure, MethodImpl(Opt.Default)]
method mapFail (line 164) | [Pure, MethodImpl(Opt.Default)]
method bimap (line 180) | [Pure, MethodImpl(Opt.Default)]
method match (line 195) | [Pure, MethodImpl(Opt.Default)]
method ifFail (line 204) | [Pure, MethodImpl(Opt.Default)]
method ifFailEff (line 213) | [Pure, MethodImpl(Opt.Default)]
method filter (line 227) | [Pure, MethodImpl(Opt.Default)]
FILE: LanguageExt.Core/Effects/Eff/Eff with runtime/Prelude/Eff.Prelude.mapapply.cs
class Prelude (line 6) | public static partial class Prelude
method map (line 18) | public static Eff<RT, B> map<RT, A, B>(Func<A, B> f, K<Eff<RT>, A> ma...
method action (line 24) | public static Eff<RT, B> action<RT, A, B>(K<Eff<RT>, A> ma, K<Eff<RT>,...
method apply (line 37) | public static Eff<RT, B> apply<RT, A, B>(K<Eff<RT>, Func<A, B>> mf, K<...
FILE: LanguageExt.Core/Effects/IO/DSL/IOAction.cs
type IOAction (line 7) | record IOAction<A, B, C>(K<IO, A> Fa, K<IO, B> Fb, Func<B, IO<C>> Next) ...
type IOActionAsync (line 32) | record IOActionAsync<A, B, C>(ValueTask<A> Fa, K<IO, B> Fb, Func<B, IO<C...
type IOActionLazy (line 50) | record IOActionLazy<A, B, C>(K<IO, A> Fa, Memo<IO, B> Fb, Func<B, IO<C>>...
type IOActionLazyAsync (line 75) | record IOActionLazyAsync<A, B, C>(ValueTask<A> Fa, Memo<IO, B> Fb, Func<...
FILE: LanguageExt.Core/Effects/IO/DSL/IOActions.cs
type IOActions (line 8) | record IOActions<A, B>(IterableNE<K<IO, A>> Fas, Func<A, IO<B>> Next) : ...
type IOActions2 (line 35) | record IOActions2<A, B>(Iterator<K<IO, A>> Fas, Func<A, IO<B>> Next) : I...
type IOActionsSync (line 62) | record IOActionsSync<A, B>(A Value, Iterator<K<IO, A>> Fas, Func<A, IO<B...
type IOActionsAsync (line 86) | record IOActionsAsync<A, B>(ValueTask<A> Value, Iterator<K<IO, A>> Fas, ...
FILE: LanguageExt.Core/Effects/IO/DSL/IOActionsAsync.cs
type IOAsyncActions (line 9) | record IOAsyncActions<A, B>(IteratorAsync<K<IO, A>> Fas, Func<A, IO<B>> ...
FILE: LanguageExt.Core/Effects/IO/DSL/IOApply.cs
type IOApply (line 7) | record IOApply<A, B, C>(K<IO, Func<A, B>> Ff, K<IO, A> Fa, Func<B, K<IO,...
type IOApplyFunctionAsync (line 37) | record IOApplyFunctionAsync<A, B, C>(ValueTask<Func<A, B>> Ff, ValueTask...
FILE: LanguageExt.Core/Effects/IO/DSL/IOBind.cs
type IOBind (line 7) | record IOBind<A, B>(A Value, Func<A, K<IO, B>> F) : InvokeSyncIO<B>
FILE: LanguageExt.Core/Effects/IO/DSL/IOBindAsync.cs
type IOBindAsync (line 7) | record IOBindAsync<A, B>(ValueTask<A> Value, Func<A, K<IO, B>> F) : Invo...
type IOBindBindAsync (line 25) | record IOBindBindAsync<A, B, C>(ValueTask<A> Value, Func<A, K<IO, B>> F,...
type IOBindMapAsync (line 43) | record IOBindMapAsync<A, B, C>(ValueTask<A> Value, Func<A, K<IO, B>> F, ...
type IOBindAsync2 (line 61) | record IOBindAsync2<A, B>(ValueTask<A> Value, Func<A, ValueTask<K<IO, B>...
type IOBindBindAsync2 (line 79) | record IOBindBindAsync2<A, B, C>(ValueTask<A> Value, Func<A, ValueTask<K...
type IOBindBindSync2 (line 97) | record IOBindBindSync2<A, B, C>(ValueTask<A> Value, Func<A, ValueTask<K<...
FILE: LanguageExt.Core/Effects/IO/DSL/IOBindMap.cs
type IOBindMap (line 7) | record IOBindMap<A, B, C>(A Value, Func<A, K<IO, B>> Ff, Func<B, C> Fg) ...
type IOBindBind (line 25) | record IOBindBind<A, B, C>(A Value, Func<A, K<IO, B>> Ff, Func<B, K<IO, ...
type IOBindBindMap (line 43) | record IOBindBindMap<A, B, C, D>(A Value, Func<A, K<IO, B>> Ff, Func<B, ...
type IOBindBindMapBind (line 61) | record IOBindBindMapBind<A, B, C, D, E>(A Value, Func<A, K<IO, B>> Ff, F...
type IOBindMap (line 79) | record IOBindMap<A, B, C, D>(A Value, Func<A, K<IO, B>> Ff, Func<B, C> F...
type IOBindMap2 (line 97) | record IOBindMap2<A, B, C, D>(A Value, Func<A, K<IO, B>> Ff, Func<B, C> ...
FILE: LanguageExt.Core/Effects/IO/DSL/IOCatch.cs
type IOCatch (line 14) | public abstract record IOCatch<A> : IO<A>
type IOCatch (line 32) | record IOCatch<X, A>(
FILE: LanguageExt.Core/Effects/IO/DSL/IOCatchPop.cs
type IOCatchPop (line 7) | record IOCatchPop<A>(IO<A> Next) : IO<A>
FILE: LanguageExt.Core/Effects/IO/DSL/IOEmpty.cs
type IOEmpty (line 9) | record IOEmpty<A> : InvokeSync<A>
type IOEmptyAsync (line 142) | record IOEmptyAsync<X, A>(K<IO, X> RunFirst) : InvokeAsync<A>
FILE: LanguageExt.Core/Effects/IO/DSL/IOFail.cs
type IOFail (line 8) | record IOFail<A>(Error Value) : InvokeSync<A>
FILE: LanguageExt.Core/Effects/IO/DSL/IOFinal.cs
type IOFinal (line 7) | record IOFinal<X, A, B>(K<IO, A> Fa, K<IO, X> Final, Func<A, K<IO, B>> N...
type IOFinalAsync (line 44) | record IOFinalAsync<X, A, B>(ValueTask<A> Fa, K<IO, X> Final, Func<A, K<...
FILE: LanguageExt.Core/Effects/IO/DSL/IOFold.cs
type IOFold (line 9) | record IOFold<S, A, B>(
type IOFoldingInitialAsync (line 48) | record IOFoldingInitialAsync<S, A, B>(
type IOFoldingAsync (line 88) | record IOFoldingAsync<S, A, B>(
type IOFoldingSync (line 124) | record IOFoldingSync<S, A, B>(
FILE: LanguageExt.Core/Effects/IO/DSL/IOFoldUntil.cs
type IOFoldUntil (line 9) | record IOFoldUntil<S, A, B>(
type IOFoldingUntilInitialAsync (line 51) | record IOFoldingUntilInitialAsync<S, A, B>(
type IOFoldingUntilAsync (line 98) | record IOFoldingUntilAsync<S, A, B>(
type IOFoldingUntilSync (line 137) | record IOFoldingUntilSync<S, A, B>(
FILE: LanguageExt.Core/Effects/IO/DSL/IOFoldWhile.cs
type IOFoldWhile (line 9) | record IOFoldWhile<S, A, B>(
type IOFoldingWhileInitialAsync (line 54) | record IOFoldingWhileInitialAsync<S, A, B>(
type IOFoldingWhileAsync (line 104) | record IOFoldingWhileAsync<S, A, B>(
type IOFoldingWhileSync (line 146) | record IOFoldingWhileSync<S, A, B>(
FILE: LanguageExt.Core/Effects/IO/DSL/IOLiftAsync.cs
type IOLiftAsync (line 7) | record IOLiftAsync<A, B>(Func<EnvIO, Task<A>> F, Func<A, K<IO, B>> Next)...
type IOLiftVAsync (line 25) | record IOLiftVAsync<A, B>(Func<EnvIO, ValueTask<A>> F, Func<A, K<IO, B>>...
FILE: LanguageExt.Core/Effects/IO/DSL/IOLiftSync.cs
type IOLiftSync (line 7) | record IOLiftSync<A, B>(Func<EnvIO, A> F, Func<A, K<IO, B>> Next) : Invo...
FILE: LanguageExt.Core/Effects/IO/DSL/IOLocal2.cs
type IOLocal (line 7) | record IOLocal<X, A>(Func<EnvIO, EnvIO> MapEnvIO, K<IO, X> Operation, Fu...
type IOLocalOnFailOnly (line 28) | record IOLocalOnFailOnly<X, A>(Func<EnvIO, EnvIO> MapEnvIO, K<IO, X> Ope...
FILE: LanguageExt.Core/Effects/IO/DSL/IOMap.cs
type IOMap (line 7) | record IOMap<A, B, C>(Func<A, B> Ff, IO<A> Fa, Func<B, K<IO, C>> Next) :...
type IOPureMap (line 30) | record IOPureMap<A, B, C>(Func<A, B> Ff, A Fa, Func<B, K<IO, C>> Next) :...
type IOPureMapAsync (line 48) | record IOPureMapAsync<A, B, C>(Func<A, B> Ff, ValueTask<A> Fa, Func<B, K...
FILE: LanguageExt.Core/Effects/IO/DSL/IOPure.cs
type IOPure (line 7) | record IOPure<A>(A Value) : InvokeSync<A>
FILE: LanguageExt.Core/Effects/IO/DSL/IOPureAsync.cs
type IOPureAsync (line 7) | record IOPureAsync<A>(ValueTask<A> Value) : InvokeAsync<A>
FILE: LanguageExt.Core/Effects/IO/DSL/IOTail.cs
type IOTail (line 7) | record IOTail<A>(IO<A> Tail) : IO<A>
FILE: LanguageExt.Core/Effects/IO/DSL/IOTimeout.cs
type IOTimeout (line 7) | record IOTimeout<A, B>(IO<A> Fa, TimeSpan TimeLimit, Func<A, K<IO, B>> N...
FILE: LanguageExt.Core/Effects/IO/DSL/IOToken.cs
type IOToken (line 8) | record IOToken<A>(Func<CancellationToken, IO<A>> Next) : InvokeSyncIO<A>
type IOTokenMap (line 23) | record IOTokenMap<A, B>(Func<CancellationToken, IO<A>> Next, Func<A, B> ...
type IOTokenBi
Condensed preview — 1863 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (8,470K chars).
[
{
"path": ".editorconfig",
"chars": 9766,
"preview": "root = true\n\n[*.cs]\n# http://kent-boogaart.com/blog/editorconfig-reference-for-c-developers#csharp_indent_block_contents"
},
{
"path": ".gitattributes",
"chars": 2518,
"preview": "###############################################################################\n# Set default behavior to automatically "
},
{
"path": ".github/FUNDING.yml",
"chars": 95,
"preview": "# These are supported funding model platforms.\n\ngithub: [louthy]\npatreon: louthy\nko_fi: louthy\n"
},
{
"path": ".gitignore",
"chars": 3034,
"preview": "## Ignore Visual Studio temporary files, build results, and\n## files generated by popular Visual Studio add-ons.\n\n# User"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 3214,
"preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
},
{
"path": "CONTRIBUTING.md",
"chars": 2242,
"preview": "## How to contribute to language-ext\n\n#### **Did you find a bug?**\n\n* **Ensure the bug was not already reported** by sea"
},
{
"path": "LICENSE.md",
"chars": 1082,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2014-2025 Paul Louth\n\nPermission is hereby granted, free of charge, to any person o"
},
{
"path": "LanguageExt.Benchmarks/HashMapAddBenchmarks.cs",
"chars": 2490,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing BenchmarkDotNet.Attributes;\nusing LanguageE"
},
{
"path": "LanguageExt.Benchmarks/HashMapContainsKeyBenchmarks.cs",
"chars": 3038,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing BenchmarkDotNet.Attribut"
},
{
"path": "LanguageExt.Benchmarks/HashMapIterateBenchmarks.cs",
"chars": 3128,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing BenchmarkDotNet.Attributes;\nusing LanguageE"
},
{
"path": "LanguageExt.Benchmarks/HashMapRandomRemovalBenchmarks.cs",
"chars": 3255,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing BenchmarkDotNet.Attribut"
},
{
"path": "LanguageExt.Benchmarks/HashSetAddBenchmarks.cs",
"chars": 2070,
"preview": "using System.Collections.Immutable;\nusing BenchmarkDotNet.Attributes;\nusing LanguageExt.ClassInstances;\nusing LanguageE"
},
{
"path": "LanguageExt.Benchmarks/HashSetContainsBenchmarks.cs",
"chars": 2564,
"preview": "using System.Collections.Immutable;\nusing BenchmarkDotNet.Attributes;\nusing LanguageExt.ClassInstances;\nusing LanguageE"
},
{
"path": "LanguageExt.Benchmarks/HashSetIterationBenchmarks.cs",
"chars": 2665,
"preview": "using System.Collections.Immutable;\nusing BenchmarkDotNet.Attributes;\nusing LanguageExt.ClassInstances;\nusing LanguageE"
},
{
"path": "LanguageExt.Benchmarks/HashSetRandomRemovalBenchmarks.cs",
"chars": 2764,
"preview": "using System.Collections.Immutable;\nusing BenchmarkDotNet.Attributes;\nusing LanguageExt.ClassInstances;\nusing LanguageE"
},
{
"path": "LanguageExt.Benchmarks/LanguageExt.Benchmarks.csproj",
"chars": 443,
"preview": "<Project Sdk=\"Microsoft.NET.Sdk\">\n\n <PropertyGroup>\n <OutputType>Exe</OutputType>\n <TargetFramework>net10.0</Targ"
},
{
"path": "LanguageExt.Benchmarks/ListAddBenchmarks.cs",
"chars": 1545,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing BenchmarkDotNet.Attributes;\nusing LanguageE"
},
{
"path": "LanguageExt.Benchmarks/ListIterationBenchmarks.cs",
"chars": 1866,
"preview": "using System.Collections.Immutable;\nusing BenchmarkDotNet.Attributes;\nusing LanguageExt.ClassInstances;\nusing LanguageE"
},
{
"path": "LanguageExt.Benchmarks/Program.cs",
"chars": 257,
"preview": "using BenchmarkDotNet.Running;\n\nnamespace LanguageExt.Benchmarks\n{\n class Program\n {\n static void Main(str"
},
{
"path": "LanguageExt.Benchmarks/ValuesGenerator.MapSetup.cs",
"chars": 2294,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing LanguageExt.Traits;\nusing Sasa.Collections;"
},
{
"path": "LanguageExt.Benchmarks/ValuesGenerator.SetSetup.cs",
"chars": 1785,
"preview": "using System.Collections.Immutable;\nusing LanguageExt.Traits;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt."
},
{
"path": "LanguageExt.Benchmarks/ValuesGenerator.cs",
"chars": 2301,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace LanguageExt.Benchmarks"
},
{
"path": "LanguageExt.Core/Catch.cs",
"chars": 665,
"preview": "using System;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt;\n\n/// <summary>\n/// Used by `@catch`, `@exceptional`, `@e"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqArr.cs",
"chars": 1925,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt."
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqArray.cs",
"chars": 1811,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt."
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqBigInt.cs",
"chars": 819,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqBool.cs",
"chars": 808,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqChar.cs",
"chars": 1690,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqCompositions.cs",
"chars": 399,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\npublic struct EqC"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqDateTime.cs",
"chars": 847,
"preview": "using LanguageExt.Traits;\nusing System;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqDecimal.cs",
"chars": 1079,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing System.Threading.Tasks;\n\nnamespace LanguageExt.Clas"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqDefault.cs",
"chars": 2249,
"preview": "using LanguageExt.Traits;\nusing static LanguageExt.Prelude;\nusing System;\nusing System.Diagnostics.Contracts;\nusing Lan"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqDouble.cs",
"chars": 924,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances\n{\n /// <summary>"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqEdit.cs",
"chars": 496,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances\n{\n /// <summary>"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqEither.cs",
"chars": 2104,
"preview": "using System.Diagnostics.Contracts;\nusing System.Threading.Tasks;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.Clas"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqEnumerable.cs",
"chars": 2048,
"preview": "using LanguageExt.Traits;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt."
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqException.cs",
"chars": 372,
"preview": "using System;\nusing System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\npubl"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqFloat.cs",
"chars": 824,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqGuid.cs",
"chars": 819,
"preview": "using System;\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqHashSet.cs",
"chars": 1985,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqIdentity.cs",
"chars": 851,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqInt.cs",
"chars": 802,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqIterable.cs",
"chars": 2014,
"preview": "using LanguageExt.Traits;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt."
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqLong.cs",
"chars": 806,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqLst.cs",
"chars": 1814,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqMap.cs",
"chars": 1446,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\npublic struct EqM"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqOption.cs",
"chars": 398,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqPatch.cs",
"chars": 445,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqQue.cs",
"chars": 1844,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing System.Threading.Tasks;\n\nnamespace LanguageExt.Clas"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqRecord.cs",
"chars": 480,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqSeq.cs",
"chars": 1898,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqSet.cs",
"chars": 1932,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqShort.cs",
"chars": 812,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqStck.cs",
"chars": 1826,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqString.cs",
"chars": 5835,
"preview": "using System;\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqTask.cs",
"chars": 377,
"preview": "using System;\nusing System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\nusing System.Threading.Tasks;\n\nnamespace La"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqTrue.cs",
"chars": 371,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqTuple2.cs",
"chars": 446,
"preview": "using LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\npublic struct EqTuple2<EqA, EqB, A, B> : Eq<(A, B)>\n "
},
{
"path": "LanguageExt.Core/Class Instances/Eq/EqTypeInfo.cs",
"chars": 363,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\nusing System.Reflection;\n\nnamespace LanguageExt.ClassInst"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableArr.cs",
"chars": 899,
"preview": "using System.Diagnostics.Contracts;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summ"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableArray.cs",
"chars": 893,
"preview": "using System.Diagnostics.Contracts;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summ"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableBigInt.cs",
"chars": 437,
"preview": "using System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// bigint hash\n/// </summary"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableBool.cs",
"chars": 432,
"preview": "using System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Boolean hash\n/// </summar"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableChar.cs",
"chars": 874,
"preview": "using System.Diagnostics.Contracts;\nusing System.Threading.Tasks;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableCompositions.cs",
"chars": 289,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\npublic struct Has"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableDateTime.cs",
"chars": 459,
"preview": "using System;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// DateTime ha"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableDecimal.cs",
"chars": 448,
"preview": "using System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Floating point hash\n/// <"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableDefault.cs",
"chars": 647,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits.Resolve;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summ"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableDouble.cs",
"chars": 445,
"preview": "using System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Floating point hash\n/// <"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableEdit.cs",
"chars": 332,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableEither.cs",
"chars": 1213,
"preview": "using System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Either type hashing\n/// <"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableEnumerable.cs",
"chars": 1006,
"preview": "using static LanguageExt.Prelude;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\n\nnamespace Lang"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableException.cs",
"chars": 244,
"preview": "using System;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\npublic struct HashableExceptio"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableFloat.cs",
"chars": 442,
"preview": "using System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Floating point hash\n/// <"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableGuid.cs",
"chars": 443,
"preview": "using System;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Guid hash\n/"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableHashSet.cs",
"chars": 931,
"preview": "using System.Diagnostics.Contracts;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summ"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableIdentity.cs",
"chars": 457,
"preview": "using System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Identity hashing\n/// </su"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableInt.cs",
"chars": 429,
"preview": "using System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Integer hash\n/// </summar"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableIterable.cs",
"chars": 984,
"preview": "using static LanguageExt.Prelude;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\n\nnamespace Lang"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableLong.cs",
"chars": 432,
"preview": "using System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Integer hash\n/// </summar"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableLst.cs",
"chars": 896,
"preview": "using static LanguageExt.Prelude;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summ"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableMap.cs",
"chars": 692,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\npublic struct Has"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableOption.cs",
"chars": 407,
"preview": "namespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Option type equality\n/// </summary>\npublic struct HashableOpti"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashablePair.cs",
"chars": 480,
"preview": "using System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\n\nnamespace LanguageExt;\n\npublic struct Hasha"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashablePatch.cs",
"chars": 602,
"preview": "using System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\nusing LanguageExt.Traits;\n\nnamespace Languag"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableQue.cs",
"chars": 873,
"preview": "using System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Queue hashing\n/// </summa"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableRecord.cs",
"chars": 612,
"preview": "using System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\n\nnamespace LanguageExt.ClassInstances;\n\n/// "
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableSeq.cs",
"chars": 905,
"preview": "using static LanguageExt.Prelude;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summ"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableSet.cs",
"chars": 881,
"preview": "using System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Set〈T〉 hashing\n/// </summ"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableShort.cs",
"chars": 477,
"preview": "using System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\n\nnamespace LanguageExt.ClassInstances;\n\n/// "
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableStck.cs",
"chars": 925,
"preview": "using System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\n\nnamespace LanguageExt.ClassInstances;\n\n/// "
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableString.cs",
"chars": 3617,
"preview": "using System;\nusing System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\n\nnamespace LanguageExt.ClassIn"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableTask.cs",
"chars": 522,
"preview": "using System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\nusing System.Threading.Tasks;\n\nnamespace Lan"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableTuple.cs",
"chars": 322,
"preview": "namespace LanguageExt.ClassInstances;\n\npublic struct HashableTuple<HashA, HashB, A, B> : Hashable<(A, B)>\n where Hash"
},
{
"path": "LanguageExt.Core/Class Instances/Hashable/HashableTypeInfo.cs",
"chars": 517,
"preview": "using System.Diagnostics.Contracts;\nusing System.Reflection;\nusing System.Runtime.CompilerServices;\n\nnamespace Language"
},
{
"path": "LanguageExt.Core/Class Instances/Monoid/Addition.cs",
"chars": 502,
"preview": "/*\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing static LanguageExt.Trait;\n\nnamespace LanguageExt"
},
{
"path": "LanguageExt.Core/Class Instances/Monoid/All.cs",
"chars": 973,
"preview": "/*\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n"
},
{
"path": "LanguageExt.Core/Class Instances/Monoid/Any.cs",
"chars": 973,
"preview": "/*\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n"
},
{
"path": "LanguageExt.Core/Class Instances/Monoid/MError.cs",
"chars": 359,
"preview": "/*\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing LanguageExt.Common;\n\nnamespace LanguageExt.Class"
},
{
"path": "LanguageExt.Core/Class Instances/Monoid/MUnit.cs",
"chars": 256,
"preview": "/*\nusing LanguageExt.Traits;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt.ClassInstances;\n\npublic struct MU"
},
{
"path": "LanguageExt.Core/Class Instances/Monoid/Product.cs",
"chars": 564,
"preview": "/*\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing static LanguageExt.Trait;\n\nnamespace LanguageExt"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdArr.cs",
"chars": 2832,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdArray.cs",
"chars": 2870,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt."
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdBigInt.cs",
"chars": 1208,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdBool.cs",
"chars": 1194,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdChar.cs",
"chars": 1255,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdDateTime.cs",
"chars": 1236,
"preview": "using System;\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdDecimal.cs",
"chars": 1215,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdDefault.cs",
"chars": 974,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing LanguageExt.Traits.Resolve;\n\nnamespace LanguageExt."
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdDouble.cs",
"chars": 1213,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdEither.cs",
"chars": 1788,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdEnumerable.cs",
"chars": 3282,
"preview": "using LanguageExt.Traits;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nusing System.Runtime.Co"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdException.cs",
"chars": 742,
"preview": "using System;\nusing System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\nusing LanguageExt.Traits;\n\nname"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdFloat.cs",
"chars": 1206,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdGuid.cs",
"chars": 1208,
"preview": "using System;\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdHashSet.cs",
"chars": 2942,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt."
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdInt.cs",
"chars": 1226,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\n\nnamespace Languag"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdIterable.cs",
"chars": 3143,
"preview": "using LanguageExt.Traits;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nusing System.Runtime.Co"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdLong.cs",
"chars": 1233,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\n\nnamespace Languag"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdLst.cs",
"chars": 2896,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\n\nnamespace Languag"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdMap.cs",
"chars": 2444,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdOption.cs",
"chars": 505,
"preview": "using System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\nusing LanguageExt.Traits;\n\nnamespace Languag"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdQue.cs",
"chars": 2979,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\n\nnamespace Languag"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdRecord.cs",
"chars": 563,
"preview": "using System.Diagnostics.Contracts;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdSeq.cs",
"chars": 2834,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt."
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdSet.cs",
"chars": 2447,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\n\nnamespace Languag"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdShort.cs",
"chars": 1201,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdStck.cs",
"chars": 2997,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServices;\n\nnamespace Languag"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdString.cs",
"chars": 5876,
"preview": "using System;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// String comparison\n///"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdTask.cs",
"chars": 403,
"preview": "using LanguageExt.Traits;\nusing System.Threading.Tasks;\n\nnamespace LanguageExt.ClassInstances;\n\npublic struct OrdTask<A"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdTrue.cs",
"chars": 390,
"preview": "using LanguageExt.Traits;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Always returns true for equality ch"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdTupleFirst.cs",
"chars": 569,
"preview": "using LanguageExt.Traits;\nusing System;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n/// Ord instance for a pa"
},
{
"path": "LanguageExt.Core/Class Instances/Ord/OrdTypeInfo.cs",
"chars": 463,
"preview": "using System;\nusing LanguageExt.Traits;\nusing System.Reflection;\n\nnamespace LanguageExt.ClassInstances;\n\npublic struct "
},
{
"path": "LanguageExt.Core/Class Instances/README.md",
"chars": 1091,
"preview": "__If you're new to this library or functional-programming this is almost certainly not the place to start browsing!__\n\nC"
},
{
"path": "LanguageExt.Core/Class Instances/TBigInt.cs",
"chars": 6970,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/TBool.cs",
"chars": 3146,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/TBoolBool.cs",
"chars": 3662,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/TChar.cs",
"chars": 1529,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/TDecimal.cs",
"chars": 10566,
"preview": "using System;\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\npub"
},
{
"path": "LanguageExt.Core/Class Instances/TDouble.cs",
"chars": 10308,
"preview": "using System;\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\npub"
},
{
"path": "LanguageExt.Core/Class Instances/TFloat.cs",
"chars": 10125,
"preview": "using System;\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\npub"
},
{
"path": "LanguageExt.Core/Class Instances/TInt.cs",
"chars": 6210,
"preview": "using System;\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n///"
},
{
"path": "LanguageExt.Core/Class Instances/TLong.cs",
"chars": 6261,
"preview": "using System;\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n///"
},
{
"path": "LanguageExt.Core/Class Instances/TNumericChar.cs",
"chars": 2183,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n/// <summary>\n///"
},
{
"path": "LanguageExt.Core/Class Instances/TShort.cs",
"chars": 6408,
"preview": "using System;\nusing LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\n///"
},
{
"path": "LanguageExt.Core/Class Instances/TString.cs",
"chars": 5713,
"preview": "using LanguageExt.Traits;\nusing System.Diagnostics.Contracts;\n\nnamespace LanguageExt.ClassInstances;\n\npublic struct TSt"
},
{
"path": "LanguageExt.Core/Combinators.cs",
"chars": 5596,
"preview": "using System;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt\n{\n public static class CombinatorsDynamic\n "
},
{
"path": "LanguageExt.Core/Comment Alternatives.cs",
"chars": 315,
"preview": "namespace LanguageExt.Core;\n\n/// <summary>\n/// Certain characters don't work in the XML comments, so we use these altern"
},
{
"path": "LanguageExt.Core/Common/Error.cs",
"chars": 27685,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nusing System.Runtime.CompilerServic"
},
{
"path": "LanguageExt.Core/Common/ErrorCodes.cs",
"chars": 2409,
"preview": "namespace LanguageExt.Common;\n\npublic static class ErrorCodes\n{\n /// <summary>\n /// An error that indicates a valu"
},
{
"path": "LanguageExt.Core/Common/ErrorException.cs",
"chars": 14662,
"preview": "using System;\nusing System.Collections;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nusing Sys"
},
{
"path": "LanguageExt.Core/Common/Errors.cs",
"chars": 4571,
"preview": "namespace LanguageExt.Common;\n\npublic static class Errors\n{\n /// <summary>\n /// An error state without any error "
},
{
"path": "LanguageExt.Core/Common/Exceptions.cs",
"chars": 2346,
"preview": "namespace LanguageExt.Common;\n\npublic class Exceptions\n{\n /// <summary>\n /// An error state without any error valu"
},
{
"path": "LanguageExt.Core/Common/README.md",
"chars": 3766,
"preview": "## `Error`\n\nThe `Error` type works like a discriminated-union, it is an `abstract record` type with many sub-cases\n(whic"
},
{
"path": "LanguageExt.Core/Concurrency/Async/Async.Module.cs",
"chars": 4312,
"preview": "using System;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing LanguageExt.Common;\n\nnamespace LanguageExt.Asy"
},
{
"path": "LanguageExt.Core/Concurrency/Async/AsyncEnumerable/AsyncEnumberable.Extensions.cs",
"chars": 1376,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace LanguageExt;\n\npublic static class AsyncEnumerableExtensions\n{"
},
{
"path": "LanguageExt.Core/Concurrency/Async/AsyncEnumerable/AsyncEnumberable.LINQ.Extensions.cs",
"chars": 1866,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Threading.Tasks;\nusing LanguageExt.Traits;\n\nnamespace Langu"
},
{
"path": "LanguageExt.Core/Concurrency/Atom/Atom.Metadata.cs",
"chars": 8950,
"preview": "using System;\nusing System.Runtime.CompilerServices;\nusing System.Threading;\nusing static LanguageExt.Prelude;\n\nnamespa"
},
{
"path": "LanguageExt.Core/Concurrency/Atom/Atom.cs",
"chars": 8762,
"preview": "using System;\nusing System.Runtime.CompilerServices;\nusing System.Threading;\nusing static LanguageExt.Prelude;\n\nnamespa"
},
{
"path": "LanguageExt.Core/Concurrency/Atom/AtomChangedEvent.cs",
"chars": 288,
"preview": "namespace LanguageExt;\n\n/// <summary>\n/// Announces Atom change events\n/// </summary>\n/// <remarks>\n/// See the [concur"
},
{
"path": "LanguageExt.Core/Concurrency/Atom/README.md",
"chars": 917,
"preview": "Atoms provide a way to manage shared, synchronous, independent state without locks. You can use them to wrap up immutab"
},
{
"path": "LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.Eq.cs",
"chars": 78436,
"preview": "using System;\nusing System.Collections;\nusing System.Collections.Generic;\nusing System.ComponentModel;\nusing System.Diag"
},
{
"path": "LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.Module.Eq.cs",
"chars": 895,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing LanguageExt;\nusing static LanguageExt.Prelude;"
},
{
"path": "LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.Module.cs",
"chars": 857,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing LanguageExt;\nusing static LanguageExt.Prelude;"
},
{
"path": "LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.cs",
"chars": 78259,
"preview": "#pragma warning disable CS0693 // Type parameter has the same name as the type parameter from outer type\nusing System;\nu"
},
{
"path": "LanguageExt.Core/Concurrency/AtomHashMap/Events.cs",
"chars": 743,
"preview": "using LanguageExt.Traits;\n\nnamespace LanguageExt\n{\n /// <summary>\n /// Event sent from the `AtomHashMap` type whe"
},
{
"path": "LanguageExt.Core/Concurrency/AtomQue/AtomQue.Extensions.cs",
"chars": 420,
"preview": "using System;\nusing System.Threading;\nusing System.Collections;\nusing System.Collections.Generic;\nusing static Language"
},
{
"path": "LanguageExt.Core/Concurrency/AtomQue/AtomQue.Trait.Implementation.cs",
"chars": 1529,
"preview": "using System;\nusing System.Linq;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt;\n\npublic class AtomQue : Foldable<Ato"
},
{
"path": "LanguageExt.Core/Concurrency/AtomQue/AtomQue.cs",
"chars": 9560,
"preview": "using System;\nusing System.Threading;\nusing System.Collections;\nusing System.Collections.Generic;\nusing static Language"
},
{
"path": "LanguageExt.Core/Concurrency/AtomSeq/AtomSeq.cs",
"chars": 48241,
"preview": "using System;\nusing System.Collections;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nusing Syst"
},
{
"path": "LanguageExt.Core/Concurrency/Conflict.cs",
"chars": 1273,
"preview": "namespace LanguageExt;\n\n/// <summary>\n/// Trait that defines how to deal with a conflict between two values\n/// </summar"
},
{
"path": "LanguageExt.Core/Concurrency/Prelude.Concurrency.cs",
"chars": 22692,
"preview": "using System;\nusing System.Runtime.CompilerServices;\n\nnamespace LanguageExt;\n\npublic static partial class Prelude\n{\n "
},
{
"path": "LanguageExt.Core/Concurrency/README.md",
"chars": 1079,
"preview": "We prefer to work with immutable types in functional-programming. However, it's not always possible, and sometimes we\nn"
},
{
"path": "LanguageExt.Core/Concurrency/STM/CommuteRef.cs",
"chars": 1207,
"preview": "using System;\nusing LanguageExt.ClassInstances;\n\nnamespace LanguageExt;\n\n/// <summary>\n/// A proxy for `Ref`, returned "
},
{
"path": "LanguageExt.Core/Concurrency/STM/Isolation.cs",
"chars": 1760,
"preview": "namespace LanguageExt;\n\n/// <summary>\n/// `sync` transaction isolation level. Used to enforce ACI properties\n/// of AC"
},
{
"path": "LanguageExt.Core/Concurrency/STM/Ref.cs",
"chars": 4180,
"preview": "using System;\nusing System.Threading.Tasks;\nusing LanguageExt.ClassInstances;\nusing static LanguageExt.Prelude;\n\nnamesp"
},
{
"path": "LanguageExt.Core/Concurrency/STM/STM.cs",
"chars": 20826,
"preview": "using System;\nusing System.Runtime.CompilerServices;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Langua"
},
{
"path": "LanguageExt.Core/Concurrency/Signals/CountdownSignal.cs",
"chars": 2449,
"preview": "using System;\nusing System.Threading;\nusing LanguageExt.Traits;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt"
},
{
"path": "LanguageExt.Core/Concurrency/Signals/Signal.Module.cs",
"chars": 2300,
"preview": "using System.Threading;\nusing LanguageExt.Traits;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt;\n\n/// <summar"
},
{
"path": "LanguageExt.Core/Concurrency/Signals/Signal.cs",
"chars": 1620,
"preview": "using System;\nusing System.Threading;\nusing LanguageExt.Traits;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt"
},
{
"path": "LanguageExt.Core/Concurrency/Task/Task.Extensions.cs",
"chars": 13830,
"preview": "using LanguageExt.ClassInstances;\nusing System;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nu"
},
{
"path": "LanguageExt.Core/Concurrency/Task/Task.Prelude.cs",
"chars": 8298,
"preview": "using LanguageExt;\nusing LanguageExt.ClassInstances;\nusing System;\nusing System.Diagnostics.Contracts;\nusing System.Thr"
},
{
"path": "LanguageExt.Core/Concurrency/Task/Tasks.cs",
"chars": 1377,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nusing System.Threading;\nusing Syste"
},
{
"path": "LanguageExt.Core/Concurrency/ValueTask/ValueTask.Extensions.cs",
"chars": 12983,
"preview": "using LanguageExt.ClassInstances;\nusing System;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nu"
},
{
"path": "LanguageExt.Core/Concurrency/ValueTask/ValueTask.Prelude.cs",
"chars": 8659,
"preview": "using System;\nusing System.Diagnostics.Contracts;\nusing System.Threading.Tasks;\nusing LanguageExt.Common;\n\nnamespace La"
},
{
"path": "LanguageExt.Core/Concurrency/ValueTask/ValueTasks.cs",
"chars": 1422,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nusing System.Threading;\nusing Syste"
},
{
"path": "LanguageExt.Core/Concurrency/VectorClock/Relation.cs",
"chars": 217,
"preview": "namespace LanguageExt\n{\n /// <summary>\n /// The relations two vector clocks may find themselves in.\n /// </summ"
},
{
"path": "LanguageExt.Core/Concurrency/VectorClock/VectorClock.A.cs",
"chars": 13726,
"preview": "using System;\nusing System.Collections.Generic;\nusing LanguageExt.ClassInstances;\nusing static LanguageExt.Prelude;\n\nnam"
},
{
"path": "LanguageExt.Core/Concurrency/VectorClock/VectorClock.OrdA.NumB.A.B.cs",
"chars": 13956,
"preview": "using System;\nusing System.Collections.Generic;\nusing LanguageExt.ClassInstances;\nusing LanguageExt.Traits;\nusing static"
},
{
"path": "LanguageExt.Core/Concurrency/VectorClock/VectorClock.cs",
"chars": 8167,
"preview": "#nullable enable\nusing System;\nusing System.Collections.Generic;\nusing LanguageExt.ClassInstances;\nusing LanguageExt.Tra"
},
{
"path": "LanguageExt.Core/Concurrency/VersionHashMap/VersionHashMap.ConflictV.K.V.cs",
"chars": 21788,
"preview": "using System;\nusing System.Collections;\nusing LanguageExt.ClassInstances;\nusing System.Collections.Generic;\nusing System"
},
{
"path": "LanguageExt.Core/Concurrency/VersionHashMap/VersionHashMap.ConflictV.OrdActor.EqK.Actor.K.V.cs",
"chars": 27199,
"preview": "using System;\nusing System.Threading;\nusing System.Collections;\nusing LanguageExt.Traits;\nusing static LanguageExt.Prelu"
},
{
"path": "LanguageExt.Core/Concurrency/VersionHashMap/VersionHashMap.K.V.cs",
"chars": 23534,
"preview": "using System;\nusing System.Collections;\nusing LanguageExt.ClassInstances;\nusing System.Collections.Generic;\nusing System"
},
{
"path": "LanguageExt.Core/Concurrency/VersionVector/Version.cs",
"chars": 7562,
"preview": "using System;\nusing LanguageExt.Traits;\nusing static LanguageExt.Prelude;\nusing LanguageExt.ClassInstances;\n\nnamespace L"
},
{
"path": "LanguageExt.Core/Concurrency/VersionVector/VersionVector.cs",
"chars": 5515,
"preview": "using System;\nusing LanguageExt.Traits;\n\nnamespace LanguageExt;\n\n/// <summary>\n/// Version vector. Container of an opti"
},
{
"path": "LanguageExt.Core/DataTypes/BigInt/BigInt.cs",
"chars": 63917,
"preview": "using System;\nusing System.Globalization;\nusing System.Numerics;\nusing LanguageExt.Traits;\nusing static LanguageExt.Pre"
},
{
"path": "LanguageExt.Core/DataTypes/Change/Change.cs",
"chars": 3315,
"preview": "using System;\nusing LanguageExt.Traits;\nusing static LanguageExt.Prelude;\n\nnamespace LanguageExt;\n\n/// <summary>\n/// Re"
},
{
"path": "LanguageExt.Core/DataTypes/Change/EntryAdded.cs",
"chars": 878,
"preview": "using System;\nusing LanguageExt.ClassInstances;\n\nnamespace LanguageExt;\n\n/// <summary>\n/// Entry added to a collection\n"
},
{
"path": "LanguageExt.Core/DataTypes/Change/EntryMapped.cs",
"chars": 2046,
"preview": "using System;\nusing LanguageExt.ClassInstances;\n\nnamespace LanguageExt;\n\n/// <summary>\n/// Existing entry updated to th"
},
{
"path": "LanguageExt.Core/DataTypes/Change/EntryRemoved.cs",
"chars": 941,
"preview": "using System;\nusing LanguageExt.ClassInstances;\n\nnamespace LanguageExt;\n\n/// <summary>\n/// Existing entry removed \n/// "
}
]
// ... and 1663 more files (download for full content)
About this extraction
This page contains the full source code of the louthy/language-ext GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1863 files (7.7 MB), approximately 2.1M tokens, and a symbol index with 15344 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.