Rename Seq back to Seq1

louthy · Oct 21, 2021 · 0e6be6a · 0e6be6a
1 parent e904c1d
commit 0e6be6a
Show file tree

Hide file tree

Showing 36 changed files with 116 additions and 98 deletions.
diff --git a/LanguageExt.Core/Immutable Collections/Prelude_Collections.cs b/LanguageExt.Core/Immutable Collections/Prelude_Collections.cs
@@ -1099,17 +1099,24 @@ public static Seq<A> Seq<A>(A a, A b, A c, A d, A e, A f, A g, A h, params A[] t
             System.Array.Copy(tail, 0, arr, 12, tail.Length);
             return new Seq<A>(new SeqStrict<A>(arr, 4, 8 + tail.Length, 0, 0));
         }
-
+        
         /// <summary>
-        /// Construct a sequence from a nullable
-        ///     HasValue == true  : [x]
-        ///     HasValue == false : []
+        /// Construct a sequence from an Enumerable
+        /// Deals with `value == null` by returning `[]` and also memoizes the
+        /// items in the enumerable as they're being consumed.
         /// </summary>
         [Pure]
-        public static Seq<A> toSeq<A>(A? value) where A : struct =>
-            value == null 
-                ? Empty 
-                : LSeq.FromSingleValue(value.Value);
+        public static Seq<A> Seq<A>(IEnumerable<A> value) =>
+            value switch
+            {
+                null                => Empty,
+                Seq<A> seq          => seq,
+                Arr<A> arr          => LSeq.FromArray(arr.Value),
+                A[] array           => toSeq(array),
+                IList<A> list       => toSeq(list),
+                ICollection<A> coll => toSeq(coll),
+                _                   => new Seq<A>(value)
+            };
 
         /// <summary>
         /// Construct a sequence from an Enumerable
@@ -1128,7 +1135,18 @@ value switch
                 ICollection<A> coll => toSeq(coll),
                 _                   => new Seq<A>(value)
             };
-
+
+        /// <summary>
+        /// Construct a sequence from a nullable
+        ///     HasValue == true  : [x]
+        ///     HasValue == false : []
+        /// </summary>
+        [Pure]
+        public static Seq<A> toSeq<A>(A? value) where A : struct =>
+            value == null 
+                ? Empty 
+                : LSeq.FromSingleValue(value.Value);
+
         /// <summary>
         /// Construct a sequence from an array
         /// </summary>

diff --git a/LanguageExt.Tests/HashMapTests.cs b/LanguageExt.Tests/HashMapTests.cs
@@ -232,7 +232,7 @@ public void EqualsTest()
         public void FetchBack()
         {
             var init = Seq(69, 1477);
-            var rmv = Seq(69);
+            var rmv = Seq1(69);
 
             var map = toHashMap(init.Zip(Enumerable.Repeat(1, int.MaxValue)));
 

diff --git a/LanguageExt.Tests/IssuesTests.cs b/LanguageExt.Tests/IssuesTests.cs
@@ -76,8 +76,8 @@ static void EqPar()
         }
 
         static Writer<MSeq<string>, Seq<string>, Seq<int>> multWithLog(Seq<int> input) =>
-            from _ in Writer(0, Seq("Start"))
-            let c = input.Map(i => Writer(i * 10, Seq($"Number: {i}")))
+            from _ in Writer(0, Seq1("Start"))
+            let c = input.Map(i => Writer(i * 10, Seq1($"Number: {i}")))
             from r in c.Sequence()
             select r;
 
@@ -346,9 +346,9 @@ public void Test1()
 
             var mc = from x in ma
                      from y in mb
-                     from _1 in tell<MSeq<string>, Seq<string>>(Seq("Hello"))
-                     from _2 in tell<MSeq<string>, Seq<string>>(Seq("World"))
-                     from _3 in tell<MSeq<string>, Seq<string>>(Seq($"the result is {x + y}"))
+                     from _1 in tell<MSeq<string>, Seq<string>>(Seq1("Hello"))
+                     from _2 in tell<MSeq<string>, Seq<string>>(Seq1("World"))
+                     from _3 in tell<MSeq<string>, Seq<string>>(Seq1($"the result is {x + y}"))
                      select x + y;
 
             var r = mc();

diff --git a/LanguageExt.Tests/MapTests.cs b/LanguageExt.Tests/MapTests.cs
@@ -250,7 +250,7 @@ public void MapValuesTest()
         {
             var m = Map((1, 1), (2, 2), (3, 3), (4, 4), (5, 5));
 
-            var vs = Seq(m.Values);
+            var vs = toSeq(m.Values);
 
             Assert.True(vs.Head == 1);
             Assert.True(vs.Tail.Head == 2);
@@ -265,7 +265,7 @@ public void MapKeysTest()
         {
             var m = Map((1, 1), (2, 2), (3, 3), (4, 4), (5, 5));
 
-            var vs = Seq(m.Keys);
+            var vs = toSeq(m.Keys);
 
             Assert.True(vs.Head == 1);
             Assert.True(vs.Tail.Head == 2);

diff --git a/LanguageExt.Tests/MonadTests.cs b/LanguageExt.Tests/MonadTests.cs
@@ -36,8 +36,8 @@ public void WriterTest()
             (value, output, false);
 
         static Writer<MSeq<string>, Seq<string>, Seq<int>> multWithLog(Seq<int> input) =>
-            from _ in writer(0, Seq("Start"))
-            let c = input.Map(i => writer(i * 10, Seq($"Number: {i}")))
+            from _ in writer(0, Seq1("Start"))
+            let c = input.Map(i => writer(i * 10, Seq1($"Number: {i}")))
             from r in c.Sequence()
             select r;
 

diff --git a/LanguageExt.Tests/Seq.Arr.Tests.cs b/LanguageExt.Tests/Seq.Arr.Tests.cs
@@ -11,7 +11,7 @@ public void TestEmpty()
         {
             var arr = Arr.empty<int>();
 
-            var seq = Seq(arr);
+            var seq = toSeq(arr);
 
             Assert.True(seq.IsEmpty);
             Assert.True(seq.Tail.IsEmpty);

diff --git a/LanguageExt.Tests/Seq.Cons.Tests.cs b/LanguageExt.Tests/Seq.Cons.Tests.cs
@@ -11,7 +11,7 @@ public void TestEmpty()
         {
             var arr = Seq<int>.Empty;
 
-            var seq = Seq(arr);
+            var seq = Seq1(arr);
 
             Assert.True(seq.IsEmpty);
             Assert.True(seq.Tail.IsEmpty);

diff --git a/LanguageExt.Tests/Seq.Enumerable.Tests.cs b/LanguageExt.Tests/Seq.Enumerable.Tests.cs
@@ -26,7 +26,7 @@ public void TestEmpty()
         {
             var arr = EmptyList;
 
-            var seq = Seq(arr);
+            var seq = Seq1(arr);
 
             Assert.True(seq.IsEmpty);
             Assert.True(seq.Tail.IsEmpty);
@@ -61,7 +61,7 @@ public void TestOne()
         {
             var arr = OneItem;
 
-            var seq = Seq(arr);
+            var seq = toSeq(arr);
 
             Assert.True(seq.Head == 1);
             Assert.True(seq.Tail.IsEmpty);
@@ -100,7 +100,7 @@ public void TestMore()
         {
             var arr = FiveItems;
 
-            var seq = Seq(arr);
+            var seq = toSeq(arr);
 
             Assert.True(seq.Head == 1);
             Assert.True(seq.Tail.Head == 2);
@@ -185,7 +185,7 @@ public void FilterTest()
                        where x % 2 == 0
                        select x;
 
-            var expected = Seq(EvenItems);
+            var expected = toSeq(EvenItems);
 
             Assert.True(expected == seq2);
             Assert.True(expected == seq3);
@@ -195,20 +195,20 @@ public void FilterTest()
         [Fact]
         public void BindTest()
         {
-            var seq1 = Seq(TenHundred);
-            var seq2 = Seq(FiveItems);
+            var seq1 = toSeq(TenHundred);
+            var seq2 = toSeq(FiveItems);
 
             var seq3 = seq1.Bind(x => seq2.Map(y => x * y));
 
-            var expected = Seq(BoundItems);
+            var expected = toSeq(BoundItems);
 
             Assert.True(seq3 == expected);
         }
 
         [Fact]
         public void FoldTest1()
         {
-            var seq = Seq(FiveItems);
+            var seq = toSeq(FiveItems);
 
             var res1 = seq.Fold(1, (s, x) => s * x);
             var res2 = seq.FoldBack(1, (s, x) => s * x);
@@ -220,7 +220,7 @@ public void FoldTest1()
         [Fact]
         public void FoldTest2()
         {
-            var seq = Seq(abcdeStrs);
+            var seq = toSeq(abcdeStrs);
 
             var res1 = seq.Fold("", (s, x) => s + x);
             var res2 = seq.FoldBack("", (s, x) => s + x);

diff --git a/LanguageExt.Tests/Seq.IList.Tests.cs b/LanguageExt.Tests/Seq.IList.Tests.cs
@@ -10,9 +10,9 @@ public class SeqIListTests
         [Fact]
         public void TestEmpty()
         {
-            var arr = Seq(new List<int>());
+            var arr = toSeq(new List<int>());
 
-            var seq = Seq(arr);
+            var seq = toSeq(arr);
 
             Assert.True(seq.IsEmpty);
             Assert.True(seq.Tail.IsEmpty);
@@ -206,7 +206,7 @@ public void FoldTest1()
         [Fact]
         public void FoldTest2()
         {
-            var seq = Seq(new List<string>() { "a", "b", "c", "d", "e" });
+            var seq = toSeq(new List<string>() { "a", "b", "c", "d", "e" });
 
             var res1 = seq.Fold("", (s, x) => s + x);
             var res2 = seq.FoldBack("", (s, x) => s + x);

diff --git a/LanguageExt.Tests/Seq.Lst.Tests.cs b/LanguageExt.Tests/Seq.Lst.Tests.cs
@@ -11,7 +11,7 @@ public void TestEmpty()
         {
             var arr = List.empty<int>();
 
-            var seq = Seq(arr);
+            var seq = toSeq(arr);
 
             Assert.True(seq.IsEmpty);
             Assert.True(seq.Tail.IsEmpty);

diff --git a/LanguageExt.Tests/Seq.Module.Tests.cs b/LanguageExt.Tests/Seq.Module.Tests.cs
@@ -183,7 +183,7 @@ public void ParallelTests()
         {
             var sum = Range(1, 10000).Sum();
 
-            var seq = Seq(Range(1, 10000));
+            var seq = toSeq(Range(1, 10000));
 
             var tasks = new List<Task<int>>();
             foreach(var x in Range(1, 1000))

diff --git a/LanguageExt.Tests/SeqTests.cs b/LanguageExt.Tests/SeqTests.cs
@@ -14,16 +14,16 @@ public void ObjectExists()
         {
             var x = "test";
 
-            Assert.True(Seq(x).Count() == 1);
-            Assert.True(Seq(x).Head() == x);
+            Assert.True(toSeq(x).Count() == 1);
+            Assert.True(Seq1(x).Head() == x);
         }
 
         [Fact]
         public void ObjectNull()
         {
             string x = null;
 
-            Assert.True(Seq(x).Count() == 0);
+            Assert.True(toSeq(x).Count() == 0);
         }
 
         [Fact]
@@ -243,7 +243,7 @@ public void GetEnumeratorTest()
         [Fact]
         public void AddTest()
         {
-            var a = Seq("a");
+            var a = Seq1("a");
 
             var b = a.Add("b");
 
@@ -258,7 +258,7 @@ public void AddTest()
         [Fact]
         public void ConsTest()
         {
-            var a = Seq("a");
+            var a = Seq1("a");
 
             var b = "b".Cons(a);
 
@@ -284,14 +284,14 @@ public void InitStrictTest()
             Assert.True(sb == Seq(1, 2, 3, 4));
             Assert.True(sc == Seq(1, 2, 3));
             Assert.True(sd == Seq(1, 2));
-            Assert.True(se == Seq(1));
+            Assert.True(se == Seq1(1));
             Assert.True(sf == Empty);
         }
 
         [Fact]
         public void InitLazyTest()
         {
-            var sa = Seq(Range(1, 5));
+            var sa = toSeq(Range(1, 5));
 
             var sb = sa.Init;  // [1,2,3,4]
             var sc = sb.Init;  // [1,2,3]
@@ -302,14 +302,14 @@ public void InitLazyTest()
             Assert.True(sb == Seq(1, 2, 3, 4));
             Assert.True(sc == Seq(1, 2, 3));
             Assert.True(sd == Seq(1, 2));
-            Assert.True(se == Seq(1));
+            Assert.True(se == Seq1(1));
             Assert.True(sf == Empty);
         }
 
         [Fact]
         public void InitConcatTest()
         {
-            var sa = Seq(Range(1, 2)) + Seq(Range(3, 3));
+            var sa = toSeq(Range(1, 2)) + toSeq(Range(3, 3));
 
             var sb = sa.Init;  // [1,2,3,4]
             var sc = sb.Init;  // [1,2,3]
@@ -320,15 +320,15 @@ public void InitConcatTest()
             Assert.True(sb == Seq(1, 2, 3, 4));
             Assert.True(sc == Seq(1, 2, 3));
             Assert.True(sd == Seq(1, 2));
-            Assert.True(se == Seq(1));
+            Assert.True(se == Seq1(1));
             Assert.True(sf == Empty);
         }
 
         [Fact]
         public void HashTest()
         {
-            var s1 = Seq("test");
-            var s2 = Seq("test");
+            var s1 = Seq1("test");
+            var s2 = Seq1("test");
 
             Assert.True(s1.GetHashCode() == s2.GetHashCode());
         }
@@ -425,7 +425,7 @@ public void CheckItems()
             var xs = Seq<int>();
             Assert.True(xs.Count == 0);
 
-            xs = Seq<int>(0);
+            xs = Seq1<int>(0);
             Assert.True(xs.Count == 1);
             Assert.True(xs[0] == 0);
 

diff --git a/LanguageExt.Tests/SeqTypes/SeqListTests.cs b/LanguageExt.Tests/SeqTypes/SeqListTests.cs
@@ -9,24 +9,24 @@ public class SeqListTests
         [Fact]
         public void Take_ZeroFromNonempty_Empty()
         {
-            var seq = Seq(new List<int> { 0 });
+            var seq    = toSeq(new List<int> { 0 });
             var actual = seq.Take(0);
             Assert.Equal(actual, SeqEmpty.Default);
         }
 
         [Fact]
         public void Take_NegativeFromNonempty_Empty()
         {
-            var seq = Seq(new List<int> { 0 });
+            var seq    = toSeq(new List<int> { 0 });
             var actual = seq.Take(-1);
             Assert.Equal(actual, SeqEmpty.Default);
         }
 
         [Fact]
         public void Skip_NegativeFromNonempty_Unchanged()
         {
-            var expected = Seq(new List<int> { 0 });
-            var actual = expected.Skip(-1);
+            var expected = toSeq(new List<int> { 0 });
+            var actual   = expected.Skip(-1);
             Assert.Equal(actual, expected);
         }
 

diff --git a/LanguageExt.Tests/Transformer/Traverse/SeqT/Collections/IEnumerable.cs b/LanguageExt.Tests/Transformer/Traverse/SeqT/Collections/IEnumerable.cs
@@ -34,7 +34,7 @@ public void IEnumerableSeqCrossProduct()
                 Seq(2, 20),
                 Seq(2, 30));
 
-            Assert.True(mb.Map(Prelude.Seq) == mc.Map(Prelude.Seq));
+            Assert.True(mb.Map(Prelude.Seq1) == mc.Map(Prelude.Seq1));
         }
 
         [Fact]

diff --git a/LanguageExt.Tests/Transformer/Traverse/SeqT/Sync/Either.cs b/LanguageExt.Tests/Transformer/Traverse/SeqT/Sync/Either.cs
@@ -12,7 +12,7 @@ public void LeftIsSingletonLeft()
         {
             var ma = Left<Error, Seq<int>>(Error.New("alt"));
             var mb = ma.Sequence();
-            var mc = Seq(Left<Error, int>(Error.New("alt")));
+            var mc = Seq1(Left<Error, int>(Error.New("alt")));
 
             Assert.True(mb == mc);
         }

diff --git a/LanguageExt.Tests/Transformer/Traverse/SeqT/Sync/EitherUnsafe.cs b/LanguageExt.Tests/Transformer/Traverse/SeqT/Sync/EitherUnsafe.cs
@@ -12,7 +12,7 @@ public void LeftIsSingletonLeft()
         {
             var ma = LeftUnsafe<Error, Seq<int>>(Error.New("alt"));
             var mb = ma.Sequence();
-            var mc = Seq(LeftUnsafe<Error, int>(Error.New("alt")));
+            var mc = Seq1(LeftUnsafe<Error, int>(Error.New("alt")));
 
             Assert.True(mb == mc);
         }