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 `...` 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
where TOrd : Ord
{
[Params(100, 1000, 10000, 100000)]
public int N;
Dictionary values;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateDictionary(N);
}
[Benchmark]
public ImmutableDictionary SysColImmutableDictionary()
{
var map = ImmutableDictionary.Create();
foreach (var kvp in values)
{
map = map.Add(kvp.Key, kvp.Value);
}
return map;
}
[Benchmark]
public ImmutableSortedDictionary SysColImmutableSortedDictionary()
{
var map = ImmutableSortedDictionary.Create();
foreach (var kvp in values)
{
map = map.Add(kvp.Key, kvp.Value);
}
return map;
}
[Benchmark]
public Trie SasaTrie()
{
var map = Trie.Empty;
foreach (var kvp in values)
{
map = map.Add(kvp.Key, kvp.Value);
}
return map;
}
[Benchmark]
public Dictionary SysColDictionary()
{
var map = new Dictionary();
foreach (var kvp in values)
{
map.Add(kvp.Key, kvp.Value);
}
return map;
}
[Benchmark]
public HashMap LangExtHashMap()
{
var map = HashMap();
foreach (var kvp in values)
{
map = map.Add(kvp.Key, kvp.Value);
}
return map;
}
[Benchmark]
public Map LangExtMap()
{
var map = Map();
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
where TOrd : Ord
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] keys;
ImmutableDictionary immutableMap;
ImmutableSortedDictionary immutableSortedMap;
Dictionary dictionary;
HashMap hashMap;
Map map;
Trie sasaTrie;
[GlobalSetup]
public void Setup()
{
var values = ValuesGenerator.Default.GenerateDictionary(N);
keys = values.Keys.ToArray();
sasaTrie = ValuesGenerator.SasaTrieSetup(values);
immutableMap = ValuesGenerator.SysColImmutableDictionarySetup(values);
immutableSortedMap = ValuesGenerator.SysColImmutableSortedDictionarySetup(values);
dictionary = ValuesGenerator.SysColDictionarySetup(values);
hashMap = ValuesGenerator.LangExtHashMapSetup(values);
map = ValuesGenerator.LangExtMapSetup(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
where TOrd : Ord
{
[Params(100, 1000, 10000, 100000)]
public int N;
ImmutableDictionary immutableMap;
ImmutableSortedDictionary immutableSortedMap;
Dictionary dictionary;
HashMap hashMap;
Map map;
Trie sasaTrie;
[GlobalSetup]
public void Setup()
{
var values = ValuesGenerator.Default.GenerateDictionary(N);
sasaTrie = ValuesGenerator.SasaTrieSetup(values);
immutableMap = ValuesGenerator.SysColImmutableDictionarySetup(values);
immutableSortedMap = ValuesGenerator.SysColImmutableSortedDictionarySetup(values);
dictionary = ValuesGenerator.SysColDictionarySetup(values);
hashMap = ValuesGenerator.LangExtHashMapSetup(values);
map = ValuesGenerator.LangExtMapSetup(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
where TOrd : Ord
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] keys;
ImmutableDictionary immutableMap;
ImmutableSortedDictionary immutableSortedMap;
Dictionary dictionary;
HashMap hashMap;
Map map;
Trie sasaTrie;
[GlobalSetup]
public void Setup()
{
var values = ValuesGenerator.Default.GenerateDictionary(N);
keys = values.Keys.ToArray();
sasaTrie = ValuesGenerator.SasaTrieSetup(values);
immutableMap = ValuesGenerator.SysColImmutableDictionarySetup(values);
immutableSortedMap = ValuesGenerator.SysColImmutableSortedDictionarySetup(values);
dictionary = ValuesGenerator.SysColDictionarySetup(values);
hashMap = ValuesGenerator.LangExtHashMapSetup(values);
map = ValuesGenerator.LangExtMapSetup(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
where TOrd : Ord
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues(N);
}
[Benchmark]
public ImmutableHashSet SysColImmutableHashSet()
{
var set = ImmutableHashSet.Create();
foreach (var value in values)
{
set = set.Add(value);
}
return set;
}
[Benchmark]
public ImmutableSortedSet SysColImmutableSortedSet()
{
var set = ImmutableSortedSet.Create();
foreach (var value in values)
{
set = set.Add(value);
}
return set;
}
[Benchmark]
public System.Collections.Generic.HashSet SysColHashSet()
{
var set = new System.Collections.Generic.HashSet();
foreach (var value in values)
{
set.Add(value);
}
return set;
}
[Benchmark]
public HashSet LangExtHashSet()
{
var set = HashSet();
foreach (var value in values)
{
set = set.Add(value);
}
return set;
}
[Benchmark]
public Set LangExtSet()
{
var set = Set();
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
where TOrd : Ord
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
ImmutableHashSet immutableHashSet;
ImmutableSortedSet immutableSortedSet;
System.Collections.Generic.HashSet sysHashSet;
HashSet hashSet;
Set set;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues(N);
immutableHashSet = ValuesGenerator.SysColImmutableHashSetSetup(values);
immutableSortedSet = ValuesGenerator.SysColImmutableSortedSetSetup(values);
sysHashSet = ValuesGenerator.SysColHashSetSetup(values);
hashSet = ValuesGenerator.LangExtHashSetSetup(values);
set = ValuesGenerator.LangExtSetSetup(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
where TOrd : Ord
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
ImmutableHashSet immutableHashSet;
ImmutableSortedSet immutableSortedSet;
System.Collections.Generic.HashSet sysHashSet;
HashSet hashSet;
Set set;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues(N);
immutableHashSet = ValuesGenerator.SysColImmutableHashSetSetup(values);
immutableSortedSet = ValuesGenerator.SysColImmutableSortedSetSetup(values);
sysHashSet = ValuesGenerator.SysColHashSetSetup(values);
hashSet = ValuesGenerator.LangExtHashSetSetup(values);
set = ValuesGenerator.LangExtSetSetup(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
where TOrd : Ord
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
ImmutableHashSet immutableSet;
ImmutableSortedSet immutableSortedSet;
System.Collections.Generic.HashSet sysHashSet;
HashSet hashSet;
Set set;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues(N);
immutableSet = ValuesGenerator.SysColImmutableHashSetSetup(values);
immutableSortedSet = ValuesGenerator.SysColImmutableSortedSetSetup(values);
sysHashSet = ValuesGenerator.SysColHashSetSetup(values);
hashSet = ValuesGenerator.LangExtHashSetSetup(values);
set = ValuesGenerator.LangExtSetSetup(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
================================================
Exe
net10.0
================================================
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
where TOrd : Ord
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues(N);
}
[Benchmark]
public ImmutableList SysColImmutableList()
{
var collection = ImmutableList.Create();
foreach (var value in values)
{
collection = collection.Add(value);
}
return collection;
}
[Benchmark]
public Lst LangExtLst()
{
var collection = List();
foreach (var value in values)
{
collection = collection.Add(value);
}
return collection;
}
[Benchmark]
public Seq LangExtSeq()
{
var collection = Seq();
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
where TOrd : Ord
{
[Params(100, 1000, 10000, 100000)]
public int N;
T[] values;
ImmutableList immutableList;
Lst lst;
Seq seq;
[GlobalSetup]
public void Setup()
{
values = ValuesGenerator.Default.GenerateUniqueValues(N);
immutableList = ImmutableList.CreateRange(ValuesGenerator.Default.GenerateUniqueValues(N));
lst = ValuesGenerator.Default.GenerateUniqueValues(N).AsIterable().ToLst();
seq = toSeq(ValuesGenerator.Default.GenerateUniqueValues(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 SasaTrieSetup(Dictionary values)
{
var trie = Trie.Empty;
foreach (var kvp in values)
{
trie = trie.Add(kvp.Key, kvp.Value);
}
return trie;
}
public static ImmutableDictionary SysColImmutableDictionarySetup(Dictionary values)
{
var immutableMap = ImmutableDictionary.Create();
foreach (var kvp in values)
{
immutableMap = immutableMap.Add(kvp.Key, kvp.Value);
}
return immutableMap;
}
public static ImmutableSortedDictionary SysColImmutableSortedDictionarySetup(Dictionary values)
{
var immutableMap = ImmutableSortedDictionary.Create();
foreach (var kvp in values)
{
immutableMap = immutableMap.Add(kvp.Key, kvp.Value);
}
return immutableMap;
}
public static Dictionary SysColDictionarySetup(Dictionary values)
{
var dictionary = new Dictionary();
foreach (var kvp in values)
{
dictionary.Add(kvp.Key, kvp.Value);
}
return dictionary;
}
public static HashMap LangExtHashMapSetup(Dictionary values)
where TEq : Eq
{
var hashMap = HashMap();
foreach (var kvp in values)
{
hashMap = hashMap.Add(kvp.Key, kvp.Value);
}
return hashMap;
}
public static Map LangExtMapSetup(Dictionary values)
where TOrd : Ord
{
var hashMap = Map();
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 SysColImmutableHashSetSetup(T[] values)
{
var immutableSet = ImmutableHashSet.Create();
foreach (var value in values)
{
immutableSet = immutableSet.Add(value);
}
return immutableSet;
}
public static ImmutableSortedSet SysColImmutableSortedSetSetup(T[] values)
{
var immutableSet = ImmutableSortedSet.Create();
foreach (var value in values)
{
immutableSet = immutableSet.Add(value);
}
return immutableSet;
}
public static System.Collections.Generic.HashSet SysColHashSetSetup(T[] values)
{
var hashSet = new System.Collections.Generic.HashSet();
foreach (var value in values)
{
hashSet.Add(value);
}
return hashSet;
}
public static HashSet LangExtHashSetSetup(T[] values)
where TEq : Eq
{
var hashSet = HashSet();
foreach (var value in values)
{
hashSet = hashSet.Add(value);
}
return hashSet;
}
public static Set LangExtSetSetup(T[] values)
where TOrd : Ord
{
var set = Set();
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 GenerateDictionary(int count)
{
var rand = new Random(randSeed);
var dict = new Dictionary(count);
while (dict.Count < count)
{
dict[GenerateValue(rand)] = GenerateValue(rand);
}
return dict;
}
public T[] GenerateUniqueValues(int count)
{
var rand = new Random(randSeed);
var set = new System.Collections.Generic.HashSet(count);
while (set.Count < count)
{
set.Add(GenerateValue(rand));
}
return set.ToArray();
}
private T GenerateValue(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;
///
/// Used by `@catch`, `@exceptional`, `@expected` to represent the catching of errors
///
public readonly record struct CatchM(Func Match, Func> Action)
where M : Fallible
{
public K Run(E error, K otherwise) =>
Match(error) ? Action(error) : otherwise;
}
public static class CatchMExtensions
{
extension(CatchM self)
where M : Functor, Fallible
{
public CatchM Map(Func 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;
///
/// Array equality
///
public struct EqArr : Eq> where EqA : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[Pure]
public static bool Equals(Arr x, Arr y)
{
if (x.Count != y.Count) return false;
var xiter = x.GetEnumerator();
var yiter = y.GetEnumerator();
while (xiter.MoveNext() && yiter.MoveNext())
{
if (!equals(xiter.Current, yiter.Current)) return false;
}
return true;
}
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static int GetHashCode(Arr x) =>
HashableArr.GetHashCode(x);
}
///
/// Array equality
///
public struct EqArr : Eq>
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[Pure]
public static bool Equals(Arr x, Arr y) =>
EqArr, A>.Equals(x, y);
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static int GetHashCode(Arr x) =>
HashableArr, 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;
///
/// Array equality
///
public struct EqArray : Eq where EqA : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[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(x[i], y[i])) return false;
}
return true;
}
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static int GetHashCode(A[] x) =>
HashableArray.GetHashCode(x);
}
///
/// Array equality
///
public struct EqArray : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[Pure]
public static bool Equals(A[] x, A[] y) =>
EqArray, A>.Equals(x, y);
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static int GetHashCode(A[] x) =>
HashableArray, A>.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqBigInt.cs
================================================
using LanguageExt.Traits;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
///
/// Integer equality
///
public struct EqBigInt : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[Pure]
public static bool Equals(bigint a, bigint b) =>
a == b;
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[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;
///
/// Boolean equality
///
public struct EqBool : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[Pure]
public static bool Equals(bool a, bool b) =>
a == b;
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[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;
///
/// Char equality
///
public struct EqChar : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[Pure]
public static bool Equals(char a, char b) =>
a == b;
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static int GetHashCode(char x) =>
HashableChar.GetHashCode(x);
}
///
/// Char equality (ordinal, ignore case)
///
public struct EqCharOrdinalIgnoreCase : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if a and b are equal
[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;
}
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[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 : Eq>
where A : Monoid
{
[Pure]
public static bool Equals(Compositions x, Compositions y) =>
x == y;
[Pure]
public static int GetHashCode(Compositions x) =>
HashableCompositions.GetHashCode(x);
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqDateTime.cs
================================================
using LanguageExt.Traits;
using System;
using System.Diagnostics.Contracts;
namespace LanguageExt.ClassInstances;
///
/// DateTime equality
///
public struct EqDateTime : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[Pure]
public static bool Equals(DateTime a, DateTime b) =>
a == b;
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[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;
///
/// Floating point equality
///
public struct EqDecimal : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[Pure]
public static bool Equals(decimal a, decimal b) =>
a == b;
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static int GetHashCode(decimal x) =>
HashableDecimal.GetHashCode(x);
[Pure]
public static Task EqualsAsync(decimal x, decimal y) =>
Equals(x, y).AsTask();
[Pure]
public static Task 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;
///
/// 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.
///
public readonly struct EqDefault : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[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.Equals(a, b);
}
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static int GetHashCode(A x) =>
HashableDefault.GetHashCode(x);
}
///
/// 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.
///
public static class EqDefault
{
static readonly Func Eq;
static EqDefault()
{
Eq = typeof(A).FullName == typeof(B).FullName
? (x, y) => y is A y1 && EqDefault.Equals(x, y1)
: (_, _) => false;
}
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[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
{
///
/// Floating point equality
///
public struct EqDouble : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[Pure]
public static bool Equals(double a, double b) =>
a.Equals(b);
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[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
{
///
/// Equality instance for `Patch` `Edit`
///
public struct EqEdit : Eq> where EqA : Eq
{
[Pure]
public static bool Equals(Edit x, Edit y) =>
x == y;
[Pure]
public static int GetHashCode(Edit x) =>
HashableEdit.GetHashCode(x);
}
}
================================================
FILE: LanguageExt.Core/Class Instances/Eq/EqEither.cs
================================================
using System.Diagnostics.Contracts;
using System.Threading.Tasks;
using LanguageExt.Traits;
namespace LanguageExt.ClassInstances
{
///
/// Either type hashing
///
public struct EqEither : Eq>
where EqL : Eq
where EqR : Eq
{
///
/// Equality test
///
[Pure]
public static bool Equals(Either x, Either y) =>
x.Equals(y);
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static int GetHashCode(Either x) =>
HashableEither.GetHashCode(x);
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static Task GetHashCodeAsync(Either x) =>
GetHashCode(x).AsTask();
///
/// Equality test
///
[Pure]
public static Task EqualsAsync(Either x, Either y) =>
Equals(x, y).AsTask();
}
///
/// Either type hashing
///
public struct EqEither : Eq>
{
///
/// Equality test
///
[Pure]
public static bool Equals(Either x, Either y) =>
EqEither, EqDefault, L, R>.Equals(x, y);
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static int GetHashCode(Either x) =>
HashableEither, HashableDefault, 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;
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
public struct EqEnumerable : Eq>
where EQ : Eq
{
///
/// Equality check
///
[Pure]
public static bool Equals(IEnumerable x, IEnumerable 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;
}
}
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static int GetHashCode(IEnumerable x) =>
HashableEnumerable.GetHashCode(x);
}
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
public struct EqEnumerable : Eq>
{
///
/// Equality check
///
[Pure]
public static bool Equals(IEnumerable x, IEnumerable y) =>
EqEnumerable, A>.Equals(x, y);
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[Pure]
public static int GetHashCode(IEnumerable x) =>
HashableEnumerable.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
{
[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;
///
/// Floating point equality
///
public struct EqFloat : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[Pure]
public static bool Equals(float a, float b) =>
a.Equals(b);
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[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;
///
/// Guid equality
///
public struct EqGuid : Eq
{
///
/// Equality test
///
/// The left hand side of the equality operation
/// The right hand side of the equality operation
/// True if x and y are equal
[Pure]
public static bool Equals(Guid a, Guid b) =>
a == b;
///
/// Get hash code of the value
///
/// Value to get the hash code of
/// The hash code of x
[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;
///
/// HashSet equality
///
public struct EqHashSet : Eq