Seq1 to Seq

LanguageExt.Benchmarks/ListIterationBenchmarks.cs

@@ -26,7 +26,7 @@ public void Setup()
             values = ValuesGenerator.Default.GenerateUniqueValues<T>(N);
             immutableList = ImmutableList.CreateRange(ValuesGenerator.Default.GenerateUniqueValues<T>(N));
             lst = ValuesGenerator.Default.GenerateUniqueValues<T>(N).Freeze();
-            seq = Seq(ValuesGenerator.Default.GenerateUniqueValues<T>(N)).Strict();
+            seq = toSeq(ValuesGenerator.Default.GenerateUniqueValues<T>(N)).Strict();
         }
 
         [Benchmark]

LanguageExt.Core/ClassInstances/Monad/MValidationSeq.cs

@@ -109,11 +109,11 @@ err switch
             {
                 // Messy, but we're doing our best to recover an error rather than return Bottom
 
-                FAIL fail => Validation<FAIL, SUCCESS>.Fail(Seq1(fail)),
+                FAIL fail => Validation<FAIL, SUCCESS>.Fail(Seq(fail)),
                 Seq<FAIL> fails => Validation<FAIL, SUCCESS>.Fail(fails),
                 _ => Common.Error
                     .Convert<FAIL>(err)
-                    .Map(f => Validation<FAIL, SUCCESS>.Fail(Seq1(f)))
+                    .Map(f => Validation<FAIL, SUCCESS>.Fail(Seq(f)))
                     .IfNone(Validation<FAIL, SUCCESS>.Fail(Seq<FAIL>.Empty))
             };            
 

LanguageExt.Core/ClassInstances/Monoid/MCompositions.cs

@@ -11,7 +11,7 @@ public Compositions<A> Append(Compositions<A> compx, Compositions<A> compy)
             Seq<Compositions<A>.Node> go(Seq<Compositions<A>.Node> mx, Seq<Compositions<A>.Node> my)
             {
                 if (mx.IsEmpty) return my;
-                if (my.IsEmpty) return go(mx.Tail, Seq1(mx.Head));
+                if (my.IsEmpty) return go(mx.Tail, Seq(mx.Head));
 
                 var x = mx.Head;
                 var sx = mx.Head.Size;

LanguageExt.Core/Concurrency/AtomSeq/AtomSeq.cs

@@ -194,7 +194,7 @@ public Unit Add(A value)
             Arr<A> arr              => Concat(arr),
             Stck<A> stck            => Concat(stck),
             IReadOnlyList<A> rolist => Concat(rolist),
-            _                       => Concat(Seq(items))
+            _                       => Concat(toSeq(items))
         };
 
         /// <summary>
@@ -541,7 +541,7 @@ public Option<A> LastOrNone()
         {
             var xs = items;
             return xs.IsEmpty
-                       ? Validation<F, A>.Fail(Seq1(Fail))
+                       ? Validation<F, A>.Fail(Seq(Fail))
                        : Validation<F, A>.Success(xs.Last);
         }
 
@@ -554,7 +554,7 @@ public Option<A> LastOrNone()
         {
             var xs = items;
             return xs.IsEmpty
-                       ? Validation<F, A>.Fail(Seq1(Fail()))
+                       ? Validation<F, A>.Fail(Seq(Fail()))
                        : Validation<F, A>.Success(xs.Last);
         }
 

LanguageExt.Core/Concurrency/VectorClock/VectorClock.A.cs

@@ -80,7 +80,7 @@ public record VectorClock<A>(Seq<(A, long)> Entries)
         /// A vector clock with a single element
         /// </summary>
         public static VectorClock<A> Single(A x, long y) =>
-            fromList(Seq1((x, y)));
+            fromList(Seq((x, y)));
 
         /// <summary>
         /// Insert each entry in the list one at a time.
@@ -164,7 +164,7 @@ public VectorClock<A> Insert(A index, long value)
 
             Seq<(A, long)> go(Seq<(A, long)> entries) =>
                 entries.IsEmpty
-                    ? Seq1((index, value))
+                    ? Seq((index, value))
                     : entries.Head switch
                       {
                           (var x1, _) xy when lessThan<OrdDefault<A>, A>(x1, index) => xy.Cons(go(entries.Tail)),

LanguageExt.Core/Concurrency/VectorClock/VectorClock.OrdA.NumB.A.B.cs

@@ -84,7 +84,7 @@ public record VectorClock<OrdA, NumB, A, B>(Seq<(A, B)> Entries)
         /// A vector clock with a single element
         /// </summary>
         public static VectorClock<OrdA, NumB, A, B> Single(A x, B y) =>
-            fromList(Seq1((x, y)));
+            fromList(Seq((x, y)));
 
         /// <summary>
         /// Insert each entry in the list one at a time.
@@ -169,7 +169,7 @@ public Option<B> Lookup(A index)
 
             Seq<(A, B)> go(Seq<(A, B)> entries) =>
                 entries.IsEmpty
-                    ? Seq1((index, value))
+                    ? Seq((index, value))
                     : entries.Head switch
                       {
                           (var x1, _) xy when lessThan<OrdA, A>(x1, index) => xy.Cons(go(entries.Tail)),

LanguageExt.Core/Concurrency/VersionHashMap/VersionHashMap.ConflictV.OrdActor.EqK.Actor.K.V.cs

@@ -279,7 +279,7 @@ public IEnumerable<V> Values
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Seq<(K Key, V Value)> ToSeq() =>
-            Seq(AsEnumerable());
+            toSeq(AsEnumerable());
 
         /// <summary>
         /// Format the collection as `[(key: value), (key: value), (key: value), ...]`

LanguageExt.Core/DataTypes/Alternative Value Monads/Either/Either-Shared/EitherLeft.cs

@@ -90,11 +90,11 @@ public void GetObjectData(SerializationInfo info, StreamingContext context)
 
         [Pure]
         public Seq<L> ToSeq() =>
-            Seq1(Value);
+            Seq(Value);
 
         [Pure]
         public IEnumerable<L> AsEnumerable() =>
-            Seq1(Value).AsEnumerable();
+            Seq(Value).AsEnumerable();
 
         [Pure]
         public EitherUnsafe<L, R> ToEitherUnsafe<R>() =>

LanguageExt.Core/DataTypes/Alternative Value Monads/Either/Either-Shared/EitherRight.cs

@@ -131,7 +131,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context)
 
         [Pure]
         public Seq<R> ToSeq() =>
-            Seq1(Value);
+            Seq(Value);
 
         [Pure]
         public IEnumerable<R> AsEnumerable() =>

LanguageExt.Core/DataTypes/Alternative Value Monads/Either/EitherAsync/EitherAsync.cs

@@ -821,7 +821,7 @@ public async Task<Unit> MatchAsync(Func<R, Task> RightAsync, Func<L, Task> LeftA
         [Pure]
         public Task<Seq<R>> RightAsEnumerable() =>
             Match(
-                Right: r => Seq1(r),
+                Right: r => Seq(r),
                 Left: l => Seq<R>.Empty,
                 Bottom: () => Seq<R>.Empty);
 
@@ -833,7 +833,7 @@ public async Task<Unit> MatchAsync(Func<R, Task> RightAsync, Func<L, Task> LeftA
         public Task<Seq<L>> LeftAsEnumerable() =>
             Match(
                 Right: r => Seq<L>.Empty,
-                Left: l => Seq1(l),
+                Left: l => Seq(l),
                 Bottom: () => Seq<L>.Empty);
 
         [Pure]

LanguageExt.Core/DataTypes/Alternative Value Monads/Fin/Fin.cs

@@ -599,7 +599,7 @@ public Fin<A> Do(Action<A> Succ)
         [Pure, MethodImpl(Opt.Default)]
         public Seq<A> ToSeq() =>
             IsSucc
-                ? Seq1(Value)
+                ? Seq(Value)
                 : Empty;
 
         [Pure, MethodImpl(Opt.Default)]

LanguageExt.Core/DataTypes/Alternative Value Monads/Nullable/Nullable.Extensions.cs

@@ -33,7 +33,7 @@ public static class NullableExtensions
         /// <returns>Zero or One values, depending on HasValue</returns>
         [Pure]
         public static Seq<A> ToSeq<A>(this A? self) where A : struct =>
-            Seq(self);
+            toSeq(self);
 
         /// <summary>
         /// Convert NullableT to IEnumerableT (0..1 entries)
@@ -43,7 +43,7 @@ public static class NullableExtensions
         /// <returns>Zero or One enumerable values, depending on HasValue</returns>
         [Pure]
         public static Seq<T> AsEnumerable<T>(this T? self) where T : struct =>
-            Seq(self);
+            toSeq(self);
 
         /// <summary>
         /// Match the two states of the Nullable and return a non-null R.

LanguageExt.Core/DataTypes/Alternative Value Monads/Option/Option/Option.Extensions.cs

@@ -56,7 +56,7 @@ IEnumerable<A> ToSequence(Seq<Option<A>> items)
                 }
             }
         }
-        return Seq(ToSequence(self));
+        return toSeq(ToSequence(self));
     }
 
     /// <summary>

LanguageExt.Core/DataTypes/Alternative Value Monads/Option/Option/Option.cs

@@ -522,7 +522,7 @@ public Option<A> Do(Action<A> f)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Seq<A> ToSeq() =>
             isSome
-                ? Seq1(Value)
+                ? Seq(Value)
                 : Empty;
 
         /// <summary>

LanguageExt.Core/DataTypes/Alternative Value Monads/Option/OptionUnsafe/OptionUnsafe.Extensions.cs

@@ -55,7 +55,7 @@ IEnumerable<A> ToSequence(Seq<OptionUnsafe<A>> items)
                 }
             }
         }
-        return Seq(ToSequence(self));
+        return toSeq(ToSequence(self));
     }
 
     /// <summary>

LanguageExt.Core/DataTypes/Alternative Value Monads/Option/OptionUnsafe/OptionUnsafe.cs

@@ -517,7 +517,7 @@ public OptionUnsafe<A> Do(Action<A> f)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Seq<A> ToSeq() =>
             isSome
-                ? Seq1(Value)
+                ? Seq(Value)
                 : Empty;
 
         /// <summary>

LanguageExt.Core/DataTypes/Alternative Value Monads/Some/Some.cs

@@ -65,7 +65,7 @@ public Some(IEnumerable<A> someValue)
         [Pure]
         public Seq<A> ToSeq() =>
             initialised
-                ? Seq1(value)
+                ? Seq(value)
                 : Empty;
 
         [Pure]

LanguageExt.Core/DataTypes/Alternative Value Monads/Validation/Validation.Prelude.cs

@@ -35,7 +35,7 @@ public static partial class Prelude
         /// <param name="value">Error value</param>
         /// <returns>Validation applicative</returns>
         public static Validation<ERROR, A> Fail<ERROR, A>(ERROR value) =>
-            Validation<ERROR, A>.Fail(Seq1(value));
+            Validation<ERROR, A>.Fail(Seq(value));
 
         /// <summary>
         /// Represents a failed operation

LanguageExt.Core/DataTypes/Alternative Value Monads/Validation/Validation.cs

@@ -57,7 +57,7 @@ namespace LanguageExt
         /// </summary>
         public Validation(IEnumerable<ValidationData<MonoidFail, FAIL, SUCCESS>> validationData)
         {
-            var seq = Seq(validationData);
+            var seq = toSeq(validationData);
             if (seq.IsEmpty)
             {
                 this.state = Validation.StateType.Fail;

LanguageExt.Core/DataTypes/Alternative Value Monads/Validation/ValidationSeq.Extensions.cs

@@ -70,7 +70,7 @@ public static class ValidationSeqExtensions
         /// <returns>Enumerable of successes</returns>
         [Pure]
         public static Seq<S> Successes<F, S>(this Seq<Validation<F, S>> vs) =>
-            Seq(Successes(vs.AsEnumerable()));
+            toSeq(Successes(vs.AsEnumerable()));
 
         /// <summary>
         /// Extract only the failures 
@@ -81,7 +81,7 @@ public static class ValidationSeqExtensions
         /// <returns>Enumerable of failures</returns>
         [Pure]
         public static Seq<F> Fails<F, S>(this Seq<Validation<F, S>> vs) =>
-            Seq(Fails(vs.AsEnumerable()));
+            toSeq(Fails(vs.AsEnumerable()));
 
         /// <summary>
         /// Extract only the successes 

LanguageExt.Core/DataTypes/Alternative Value Monads/Validation/ValidationSeq.cs

@@ -55,7 +55,7 @@ namespace LanguageExt
         [Pure]
         public Validation(IEnumerable<ValidationData<FAIL, SUCCESS>> validationData)
         {
-            var seq = Seq(validationData);
+            var seq = toSeq(validationData);
             if (seq.IsEmpty)
             {
                 this.state = Validation.StateType.Fail;
@@ -192,7 +192,7 @@ state switch
         public static implicit operator Validation<FAIL, SUCCESS>(FAIL value) =>
             isnull(value)
                 ? throw new ValueIsNullException()
-                : Fail(Seq1(value));
+                : Fail(Seq(value));
 
         [Pure]
         public Validation<FAIL, SUCCESS> Disjunction<SUCCESSB>(Validation<FAIL, SUCCESSB> other)

LanguageExt.Core/DataTypes/Compositions/Compositions.Module.cs

@@ -94,7 +94,7 @@ Seq<Compositions<A>.Node> go(int n, Seq<Compositions<A>.Node> nodes)
                 else
                 {
                     return default(MCompositions<MonoidA, A>)
-                                .Append(new Compositions<A>(Seq1(x)), new Compositions<A>(go(n - s, ri)))
+                                .Append(new Compositions<A>(Seq(x)), new Compositions<A>(go(n - s, ri)))
                                 .Tree;
                 }
             }
@@ -148,7 +148,7 @@ public static (Compositions<A> taken, Compositions<A> skipped) splitAt<MonoidA,
         /// Construct a compositions list containing just one element.
         /// </summary>
         public static Compositions<A> singleton<A>(A value) =>
-            new Compositions<A>(Seq1(new Compositions<A>.Node(1, None, value)));
+            new Compositions<A>(Seq(new Compositions<A>.Node(1, None, value)));
 
         /// <summary>
         /// Get the number of elements in the compositions list, in `O(log n)` time.

LanguageExt.Core/DataTypes/Immutable Collections/Arr/Arr.cs

@@ -543,7 +543,7 @@ public Arr<A> SetItem(int index, A value)
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Seq<A> ToSeq() =>
-            Seq(this);
+            toSeq(this);
 
         /// <summary>
         /// Format the collection as `[a, b, c, ...]`

LanguageExt.Core/DataTypes/Immutable Collections/BiMap/BiMap.cs

@@ -346,7 +346,7 @@ public BiMap(IEnumerable<(A Left, B Right)> items) : this(items, true)
 
         [Pure]
         public Seq<(A Key, B Value)> ToSeq() =>
-            Prelude.Seq(this);
+            Prelude.toSeq(this);
 
         [Pure]
         public bool Equals(BiMap<A, B> y) =>

LanguageExt.Core/DataTypes/Immutable Collections/HashSet/HashSet.Eq.cs

@@ -393,7 +393,7 @@ IEnumerable<A> Yield(TrieSet<EqA, A> map, Func<A, bool> f)
 
         [Pure]
         public Seq<A> ToSeq() =>
-            Prelude.Seq(this);
+            toSeq(this);
 
         /// <summary>
         /// Format the collection as `[a, b, c, ...]`

LanguageExt.Core/DataTypes/Immutable Collections/HashSet/HashSet.cs

@@ -382,7 +382,7 @@ IEnumerable<A> Yield(TrieSet<EqDefault<A>, A> map, Func<A, bool> f)
 
         [Pure]
         public Seq<A> ToSeq() =>
-            Prelude.Seq(this);
+            toSeq(this);
 
         /// <summary>
         /// Format the collection as `[a, b, c, ...]`

LanguageExt.Core/DataTypes/Immutable Collections/List/Lst.Extensions.cs

@@ -29,19 +29,19 @@ public static class ListExtensions
     /// Converts an enumerable to a `Seq`
     /// </summary>
     public static Seq<A> ToSeq<A>(this IEnumerable<A> enumerable) =>
-        Seq(enumerable);
+        toSeq(enumerable);
 
     /// <summary>
     /// Converts an enumerable to a `Seq`
     /// </summary>
     public static Seq<A> ToSeq<A>(this IList<A> enumerable) =>
-        Seq(enumerable);
+        toSeq(enumerable);
 
     /// <summary>
     /// Converts an array to a `Seq`
     /// </summary>
     public static Seq<A> ToSeq<A>(this A[] array) =>
-        Seq(array);
+        toSeq(array);
 
     /// <summary>
     /// Concatenate two enumerables (Concat in LINQ)
@@ -64,7 +64,7 @@ public static class ListExtensions
     public static B Match<A, B>(this IEnumerable<A> list,
         Func<B> Empty,
         Func<Seq<A>, B> More) =>
-        Seq(list).Match(Empty, More);
+        toSeq(list).Match(Empty, More);
 
     /// <summary>
     /// List pattern matching
@@ -73,7 +73,7 @@ public static class ListExtensions
     public static B Match<A, B>(this IEnumerable<A> list,
         Func<B> Empty,
         Func<A, Seq<A>, B> More) =>
-        Seq(list).Match(Empty, More);
+        toSeq(list).Match(Empty, More);
 
     /// <summary>
     /// List pattern matching
@@ -83,7 +83,7 @@ public static class ListExtensions
         Func<R> Empty,
         Func<T, R> One,
         Func<T, Seq<T>, R> More ) =>
-        Seq(list).Match(Empty, One, More);
+        toSeq(list).Match(Empty, One, More);
 
     /// <summary>
     /// Get the item at the head (first) of the list
@@ -177,7 +177,7 @@ public static class ListExtensions
     [Pure]
     public static Validation<Fail, Success> LastOrInvalid<Fail, Success>(this IEnumerable<Success> list, Fail fail) =>
         list.Select(Validation<Fail, Success>.Success)
-            .DefaultIfEmpty(Validation<Fail, Success>.Fail(Seq1(fail)))
+            .DefaultIfEmpty(Validation<Fail, Success>.Fail(Seq(fail)))
             .LastOrDefault();
 
     /// <summary>