{"action":"created","comment":{"url":"https://api.github.com/repos/dotnet/corefx/pulls/comments/59588652","id":59588652,"diff_hunk":"@@ -0,0 +1,1119 @@\n+﻿// Licensed to the .NET Foundation under one or more agreements.\n+// The .NET Foundation licenses this file to you under the MIT license.\n+// See the LICENSE file in the project root for more information.\n+\n+using System.Collections;\n+using System.Collections.Generic;\n+using System.Diagnostics;\n+using System.Text;\n+\n+namespace System\n+{\n+    /// <summary>\n+    /// Helper so we can call some tuple methods recursively without knowing the underlying types.\n+    /// </summary>\n+    internal interface ITupleInternal\n+    {\n+        int GetHashCode(IEqualityComparer comparer);\n+        int Size { get; }\n+    }\n+\n+    public struct ValueTuple : IEquatable<ValueTuple>, IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal\n+    {\n+        public override bool Equals(object obj)\n+        {\n+            return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default);\n+        }\n+\n+        public bool Equals(ValueTuple other)\n+        {\n+            return true;\n+        }\n+\n+        bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)\n+        {\n+            return other is ValueTuple;\n+        }\n+\n+        int IComparable.CompareTo(object obj)\n+        {\n+            return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);\n+        }\n+\n+        int IStructuralComparable.CompareTo(object other, IComparer comparer)\n+        {\n+            if (other == null) return 1;\n+\n+            if (!(other is ValueTuple))\n+            {\n+                throw new ArgumentException(SR.ArgumentException_ValueTupleIncorrectType, nameof(other));\n+            }\n+\n+            // Note that the result doesn't depend on comparer\n+            return 0;\n+        }\n+\n+        public override int GetHashCode()\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);\n+        }\n+\n+        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return comparer.GetHashCode();\n+        }\n+\n+        int ITupleInternal.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(comparer);\n+        }\n+\n+        public override string ToString()\n+        {\n+            return \"()\";\n+        }\n+\n+        int ITupleInternal.Size => 0;\n+\n+        public static ValueTuple Create() =>\n+            new ValueTuple();\n+\n+        public static ValueTuple<T1> Create<T1>(T1 item1) =>\n+            new ValueTuple<T1>(item1);\n+\n+        public static ValueTuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2) =>\n+            new ValueTuple<T1, T2>(item1, item2);\n+\n+        public static ValueTuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3) =>\n+            new ValueTuple<T1, T2, T3>(item1, item2, item3);\n+\n+        public static ValueTuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1 item1, T2 item2, T3 item3, T4 item4) =>\n+            new ValueTuple<T1, T2, T3, T4>(item1, item2, item3, item4);\n+\n+        public static ValueTuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) =>\n+            new ValueTuple<T1, T2, T3, T4, T5>(item1, item2, item3, item4, item5);\n+\n+        public static ValueTuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6) =>\n+            new ValueTuple<T1, T2, T3, T4, T5, T6>(item1, item2, item3, item4, item5, item6);\n+\n+        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7) =>\n+            new ValueTuple<T1, T2, T3, T4, T5, T6, T7>(item1, item2, item3, item4, item5, item6, item7);\n+\n+        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> Create<T1, T2, T3, T4, T5, T6, T7, TRest>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest) =>\n+            new ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>(item1, item2, item3, item4, item5, item6, item7, rest);\n+\n+        // From System.Web.Util.HashCodeCombiner\n+        internal static int CombineHashCodes(int h1, int h2)\n+        {\n+            return (((h1 << 5) + h1) ^ h2);\n+        }\n+\n+        internal static int CombineHashCodes(int h1, int h2, int h3)\n+        {\n+            return CombineHashCodes(CombineHashCodes(h1, h2), h3);\n+        }\n+\n+        internal static int CombineHashCodes(int h1, int h2, int h3, int h4)\n+        {\n+            return CombineHashCodes(CombineHashCodes(h1, h2), CombineHashCodes(h3, h4));\n+        }\n+\n+        internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5)\n+        {\n+            return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), h5);\n+        }\n+\n+        internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5, int h6)\n+        {\n+            return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), CombineHashCodes(h5, h6));\n+        }\n+\n+        internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5, int h6, int h7)\n+        {\n+            return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), CombineHashCodes(h5, h6, h7));\n+        }\n+\n+        internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5, int h6, int h7, int h8)\n+        {\n+            return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), CombineHashCodes(h5, h6, h7, h8));\n+        }\n+    }\n+\n+    public struct ValueTuple<T1> : IEquatable<ValueTuple<T1>>, IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal\n+    {\n+        public T1 Item1;\n+\n+        private static readonly EqualityComparer<T1> s_equality1 = EqualityComparer<T1>.Default;\n+        private static readonly Comparer<T1> s_comparer1 = Comparer<T1>.Default;\n+\n+        public ValueTuple(T1 item1)\n+        {\n+            Item1 = item1;\n+        }\n+\n+        public override bool Equals(object obj)\n+        {\n+            return obj is ValueTuple<T1> && Equals((ValueTuple<T1>)obj);\n+        }\n+\n+        public bool Equals(ValueTuple<T1> other)\n+        {\n+            return s_equality1.Equals(Item1, other.Item1);\n+        }\n+\n+        bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)\n+        {\n+            if (other == null || !(other is ValueTuple<T1>)) return false;\n+\n+            var objTuple = (ValueTuple<T1>)other;\n+\n+            return comparer.Equals(Item1, objTuple.Item1);\n+        }\n+\n+        int IComparable.CompareTo(object other)\n+        {\n+            if (other == null) return 1;\n+\n+            if (!(other is ValueTuple<T1>))\n+            {\n+                throw new ArgumentException(SR.ArgumentException_ValueTupleIncorrectType, nameof(other));\n+            }\n+\n+            var objTuple = (ValueTuple<T1>)other;\n+\n+            return s_comparer1.Compare(Item1, objTuple.Item1);\n+        }\n+\n+        int IStructuralComparable.CompareTo(object other, IComparer comparer)\n+        {\n+            if (other == null) return 1;\n+\n+            if (!(other is ValueTuple<T1>))\n+            {\n+                throw new ArgumentException(SR.ArgumentException_ValueTupleIncorrectType, nameof(other));\n+            }\n+\n+            var objTuple = (ValueTuple<T1>)other;\n+\n+            return comparer.Compare(Item1, objTuple.Item1);\n+        }\n+\n+        public override int GetHashCode()\n+        {\n+            return s_equality1.GetHashCode(Item1);\n+        }\n+\n+        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return comparer.GetHashCode(Item1);\n+        }\n+\n+        int ITupleInternal.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return comparer.GetHashCode(Item1);\n+        }\n+\n+        public override string ToString()\n+        {\n+            return \"(\" + Item1 + \")\";\n+        }\n+\n+        int ITupleInternal.Size => 1;\n+    }\n+\n+    /// <summary>\n+    /// Represents a 2-tuple, or pair.\n+    /// </summary>\n+    /// <typeparam name=\"T1\">The type of the tuple's first component.</typeparam>\n+    /// <typeparam name=\"T2\">The type of the tuple's second component.</typeparam>\n+    public struct ValueTuple<T1, T2> : IEquatable<ValueTuple<T1, T2>>, IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal\n+    {\n+        /// <summary>\n+        /// The current <seealso cref=\"ValueTuple{T1, T2}\"/> instance's first component.\n+        /// </summary>\n+        public T1 Item1;\n+\n+        /// <summary>\n+        /// The current <seealso cref=\"ValueTuple{T1, T2}\"/> instance's first component.\n+        /// </summary>\n+        public T2 Item2;\n+\n+        /// <summary>\n+        /// Initializes a new instance of the <seealso cref=\"ValueTuple{T1, T2}\"/> struct.\n+        /// </summary>\n+        /// <param name=\"item1\">The value of the tuple's first component.</param>\n+        /// <param name=\"item2\">The value of the tuple's second component.</param>\n+        public ValueTuple(T1 item1, T2 item2)\n+        {\n+            Item1 = item1;\n+            Item2 = item2;\n+        }\n+\n+        /// <summary>\n+        /// Returns a value that indicates whether the current <seealso cref=\"ValueTuple{T1, T2}\"/> instance is equal to a specified object.\n+        /// </summary>\n+        /// <param name=\"other\">The object to compare with this instance.</param>\n+        /// <returns><see langword=\"true\"/> if the current instance is equal to the specified object; otherwise, <see langword=\"false\"/>.</returns>\n+        ///\n+        /// <remarks>\n+        /// The <paramref name=\"other\"/> parameter is considered to be equal to the current instance under the following conditions:\n+        /// <list type=\"bullet\">\n+        ///     <item><description>It is a <seealso cref=\"ValueTuple{T1, T2}\"/> struct.</description></item>\n+        ///     <item><description>Its two components are of the same types as the current instance.</description></item>\n+        ///     <item><description>Its two components are equal to those of the current instance.Equality is determined by the default object equality comparer for each component.</description></item>\n+        /// </list>\n+        /// </remarks>\n+        public override bool Equals(object other)\n+        {\n+            return ((IStructuralEquatable)this).Equals(other, EqualityComparer<object>.Default); ;\n+        }\n+\n+        /// <summary>\n+        /// Returns a value that indicates whether the current <seealso cref=\"ValueTuple{T1, T2}\"/> instance is equal to a specified <seealso cref=\"ValueTuple{T1, T2}\"/>.\n+        /// </summary>\n+        /// <param name=\"other\">The object to compare with this instance.</param>\n+        /// <returns><see langword=\"true\"/> if the current instance is equal to the specified object; otherwise, <see langword=\"false\"/>.</returns>\n+        ///\n+        /// <remarks>\n+        /// The <paramref name=\"other\"/> parameter is considered to be equal to the current instance under the following conditions:\n+        /// <list type=\"bullet\">\n+        ///     <item><description>It is a <seealso cref=\"ValueTuple{T1, T2}\"/> struct.</description></item>\n+        ///     <item><description>Its two components are of the same types as the current instance.</description></item>\n+        ///     <item><description>Its two components are equal to those of the current instance.Equality is determined by the default object equality comparer for each component.</description></item>\n+        /// </list>\n+        /// </remarks>\n+        public bool Equals(ValueTuple<T1, T2> other)\n+        {\n+            return Equals(Item1, other.Item1) && Equals(Item2, other.Item2);\n+        }\n+\n+        /// <summary>\n+        /// Returns a value that indicates whether the current <seealso cref=\"ValueTuple{T1, T2}\"/> instance is equal to a specified object based on a specified comparison method.\n+        /// </summary>\n+        /// <param name=\"other\">The object to compare with this instance.</param>\n+        /// <param name=\"comparer\">An object that defines the method to use to evaluate whether the two objects are equal.</param>\n+        /// <returns><see langword=\"true\"/> if the current instance is equal to the specified object; otherwise, <see langword=\"false\"/>.</returns>\n+        ///\n+        /// <remarks>\n+        /// This member is an explicit interface member implementation. It can be used only when the\n+        ///  <seealso cref=\"ValueTuple{T1, T2}\"/> instance is cast to an <see cref=\"IStructuralEquatable\"/> interface.\n+        ///\n+        /// The <see cref=\"IEqualityComparer.Equals\"/> implementation is called only if <c>other</c> is not <see langword=\"null\"/>,\n+        ///  and if it can be successfully cast (in C#) or converted (in Visual Basic) to a <seealso cref=\"ValueTuple{T1, T2}\"/>\n+        ///  whose components are of the same types as the current instance. The IStructuralEquatable.Equals(Object, IEqualityComparer) method\n+        ///  first passes the <see cref=\"Item1\"/> values of the <seealso cref=\"ValueTuple{T1, T2}\"/> objects to be compared to the\n+        ///  <see cref=\"IEqualityComparer.Equals\"/> implementation. If this method call returns <see langword=\"true\"/>, the method is\n+        ///  called again and passed the <see cref=\"Item2\"/> values of the two <seealso cref=\"ValueTuple{T1, T2}\"/> instances.\n+        /// </remarks>\n+        bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)\n+        {\n+            if (other == null || !(other is ValueTuple<T1, T2>)) return false;\n+\n+            var objTuple = (ValueTuple<T1, T2>)other;\n+\n+            return comparer.Equals(Item1, objTuple.Item1) && comparer.Equals(Item2, objTuple.Item2);\n+        }\n+\n+        int IComparable.CompareTo(object obj)\n+        {\n+            return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);\n+        }\n+\n+        int IStructuralComparable.CompareTo(object other, IComparer comparer)\n+        {\n+            if (other == null) return 1;\n+\n+            if (!(other is ValueTuple<T1, T2>))\n+            {\n+                throw new ArgumentException(SR.ArgumentException_ValueTupleIncorrectType, nameof(other));\n+            }\n+\n+            var objTuple = (ValueTuple<T1, T2>)other;\n+\n+            int c = comparer.Compare(Item1, objTuple.Item1);\n+\n+            if (c != 0) return c;\n+\n+            return comparer.Compare(Item2, objTuple.Item2);\n+        }\n+\n+        /// <summary>\n+        /// Returns the hash code for the current <seealso cref=\"ValueTuple{T1, T2}\"/> instance.\n+        /// </summary>\n+        /// <returns>A 32-bit signed integer hash code.</returns>\n+        public override int GetHashCode()\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);\n+        }\n+\n+        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ValueTuple.CombineHashCodes(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2));\n+        }\n+\n+        int ITupleInternal.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(comparer);\n+        }\n+\n+        /// <summary>\n+        /// Returns a string that represents the value of this <seealso cref=\"ValueTuple{T1, T2}\"/> instance.\n+        /// </summary>\n+        /// <returns>The string representation of this <seealso cref=\"ValueTuple{T1, T2}\"/> instance.</returns>\n+        ///\n+        /// <remarks>\n+        /// The string returned by this method takes the form <c>(Item1, Item2)</c>,\n+        ///  where <c>Item1</c> and <c>Item2</c> represent the values of the <see cref=\"Item1\"/>\n+        ///  and <see cref=\"Item2\"/> properties. If either property value is <see langword=\"null\"/>,\n+        ///  it is represented as <see cref=\"String.Empty\"/>.\n+        /// </remarks>\n+        public override string ToString()\n+        {\n+            return \"(\" + Item1 + \", \" + Item2 + \")\";\n+        }\n+\n+        int ITupleInternal.Size => 2;\n+    }\n+\n+    public struct ValueTuple<T1, T2, T3> : IEquatable<ValueTuple<T1, T2, T3>>, IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal\n+    {\n+        public T1 Item1;\n+        public T2 Item2;\n+        public T3 Item3;\n+\n+        public ValueTuple(T1 item1, T2 item2, T3 item3)\n+        {\n+            Item1 = item1;\n+            Item2 = item2;\n+            Item3 = item3;\n+        }\n+\n+        public override bool Equals(object obj)\n+        {\n+            return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;\n+        }\n+\n+        public bool Equals(ValueTuple<T1, T2, T3> other)\n+        {\n+            return Equals(Item1, other.Item1) && Equals(Item2, other.Item2) && Equals(Item3, other.Item3);\n+        }\n+\n+        bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)\n+        {\n+            if (other == null || !(other is ValueTuple<T1, T2, T3>)) return false;\n+\n+            var objTuple = (ValueTuple<T1, T2, T3>)other;\n+\n+            return comparer.Equals(Item1, objTuple.Item1) && comparer.Equals(Item2, objTuple.Item2) && comparer.Equals(Item3, objTuple.Item3);\n+        }\n+\n+        int IComparable.CompareTo(object obj)\n+        {\n+            return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);\n+        }\n+\n+        int IStructuralComparable.CompareTo(object other, IComparer comparer)\n+        {\n+            if (other == null) return 1;\n+\n+            if (!(other is ValueTuple<T1, T2, T3>))\n+            {\n+                throw new ArgumentException(SR.ArgumentException_ValueTupleIncorrectType, nameof(other));\n+            }\n+\n+            var objTuple = (ValueTuple<T1, T2, T3>)other;\n+\n+            int c = comparer.Compare(Item1, objTuple.Item1);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item2, objTuple.Item2);\n+\n+            if (c != 0) return c;\n+\n+            return comparer.Compare(Item3, objTuple.Item3);\n+        }\n+\n+        public override int GetHashCode()\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);\n+        }\n+\n+        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ValueTuple.CombineHashCodes(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3));\n+        }\n+\n+        int ITupleInternal.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(comparer);\n+        }\n+\n+        public override string ToString()\n+        {\n+            return \"(\" + Item1 + \", \" + Item2 + \", \" + Item3 + \")\";\n+        }\n+\n+        int ITupleInternal.Size => 3;\n+    }\n+\n+    public struct ValueTuple<T1, T2, T3, T4> : IEquatable<ValueTuple<T1, T2, T3, T4>>, IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal\n+    {\n+        public T1 Item1;\n+        public T2 Item2;\n+        public T3 Item3;\n+        public T4 Item4;\n+\n+        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4)\n+        {\n+            Item1 = item1;\n+            Item2 = item2;\n+            Item3 = item3;\n+            Item4 = item4;\n+        }\n+\n+        public override bool Equals(object obj)\n+        {\n+            return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;\n+        }\n+\n+        public bool Equals(ValueTuple<T1, T2, T3, T4> other)\n+        {\n+            return Equals(Item1, other.Item1) && Equals(Item2, other.Item2) && Equals(Item3, other.Item3) &&\n+                Equals(Item4, other.Item4);\n+        }\n+\n+        bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)\n+        {\n+            if (other == null || !(other is ValueTuple<T1, T2, T3, T4>)) return false;\n+\n+            var objTuple = (ValueTuple<T1, T2, T3, T4>)other;\n+\n+            return comparer.Equals(Item1, objTuple.Item1) && comparer.Equals(Item2, objTuple.Item2) && comparer.Equals(Item3, objTuple.Item3) &&\n+                comparer.Equals(Item4, objTuple.Item4);\n+        }\n+\n+        int IComparable.CompareTo(object obj)\n+        {\n+            return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);\n+        }\n+\n+        int IStructuralComparable.CompareTo(object other, IComparer comparer)\n+        {\n+            if (other == null) return 1;\n+\n+            if (!(other is ValueTuple<T1, T2, T3, T4>))\n+            {\n+                throw new ArgumentException(SR.ArgumentException_ValueTupleIncorrectType, nameof(other));\n+            }\n+\n+            var objTuple = (ValueTuple<T1, T2, T3, T4>)other;\n+\n+            int c = comparer.Compare(Item1, objTuple.Item1);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item2, objTuple.Item2);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item3, objTuple.Item3);\n+\n+            if (c != 0) return c;\n+\n+            return comparer.Compare(Item4, objTuple.Item4);\n+        }\n+\n+        public override int GetHashCode()\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);\n+        }\n+\n+        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ValueTuple.CombineHashCodes(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3),\n+                                                comparer.GetHashCode(Item4));\n+        }\n+\n+        int ITupleInternal.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(comparer);\n+        }\n+\n+        public override string ToString()\n+        {\n+            return \"(\" + Item1 + \", \" + Item2 + \", \" + Item3 + \", \" + Item4 + \")\";\n+        }\n+\n+        int ITupleInternal.Size => 4;\n+    }\n+\n+    public struct ValueTuple<T1, T2, T3, T4, T5> : IEquatable<ValueTuple<T1, T2, T3, T4, T5>>, IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal\n+    {\n+        public T1 Item1;\n+        public T2 Item2;\n+        public T3 Item3;\n+        public T4 Item4;\n+        public T5 Item5;\n+\n+        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)\n+        {\n+            Item1 = item1;\n+            Item2 = item2;\n+            Item3 = item3;\n+            Item4 = item4;\n+            Item5 = item5;\n+        }\n+\n+        public override bool Equals(object obj)\n+        {\n+            return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;\n+        }\n+\n+        public bool Equals(ValueTuple<T1, T2, T3, T4, T5> other)\n+        {\n+            return Equals(Item1, other.Item1) && Equals(Item2, other.Item2) && Equals(Item3, other.Item3) &&\n+                Equals(Item4, other.Item4) && Equals(Item5, other.Item5);\n+        }\n+\n+        bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)\n+        {\n+            if (other == null || !(other is ValueTuple<T1, T2, T3, T4, T5>)) return false;\n+\n+            var objTuple = (ValueTuple<T1, T2, T3, T4, T5>)other;\n+\n+            return comparer.Equals(Item1, objTuple.Item1) && comparer.Equals(Item2, objTuple.Item2) && comparer.Equals(Item3, objTuple.Item3) &&\n+                comparer.Equals(Item4, objTuple.Item4) && comparer.Equals(Item5, objTuple.Item5);\n+        }\n+\n+        int IComparable.CompareTo(object obj)\n+        {\n+            return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);\n+        }\n+\n+        int IStructuralComparable.CompareTo(object other, IComparer comparer)\n+        {\n+            if (other == null) return 1;\n+\n+            if (!(other is ValueTuple<T1, T2, T3, T4, T5>))\n+            {\n+                throw new ArgumentException(SR.ArgumentException_ValueTupleIncorrectType, nameof(other));\n+            }\n+\n+            var objTuple = (ValueTuple<T1, T2, T3, T4, T5>)other;\n+\n+            int c = comparer.Compare(Item1, objTuple.Item1);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item2, objTuple.Item2);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item3, objTuple.Item3);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item4, objTuple.Item4);\n+\n+            if (c != 0) return c;\n+\n+            return comparer.Compare(Item5, objTuple.Item5);\n+        }\n+\n+        public override int GetHashCode()\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);\n+        }\n+\n+        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ValueTuple.CombineHashCodes(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3),\n+                                                comparer.GetHashCode(Item4), comparer.GetHashCode(Item5));\n+        }\n+\n+        int ITupleInternal.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(comparer);\n+        }\n+\n+        public override string ToString()\n+        {\n+            return \"(\" + Item1 + \", \" + Item2 + \", \" + Item3 + \", \" + Item4 + \", \" + Item5 + \")\";\n+        }\n+\n+        int ITupleInternal.Size => 5;\n+    }\n+\n+    public struct ValueTuple<T1, T2, T3, T4, T5, T6> : IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6>>, IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal\n+    {\n+        public T1 Item1;\n+        public T2 Item2;\n+        public T3 Item3;\n+        public T4 Item4;\n+        public T5 Item5;\n+        public T6 Item6;\n+\n+        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)\n+        {\n+            Item1 = item1;\n+            Item2 = item2;\n+            Item3 = item3;\n+            Item4 = item4;\n+            Item5 = item5;\n+            Item6 = item6;\n+        }\n+\n+        public override bool Equals(object obj)\n+        {\n+            return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;\n+        }\n+\n+        public bool Equals(ValueTuple<T1, T2, T3, T4, T5, T6> other)\n+        {\n+            return Equals(Item1, other.Item1) && Equals(Item2, other.Item2) && Equals(Item3, other.Item3) &&\n+                Equals(Item4, other.Item4) && Equals(Item5, other.Item5) && Equals(Item6, other.Item6);\n+        }\n+\n+        bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)\n+        {\n+            if (other == null || !(other is ValueTuple<T1, T2, T3, T4, T5, T6>)) return false;\n+\n+            var objTuple = (ValueTuple<T1, T2, T3, T4, T5, T6>)other;\n+\n+            return comparer.Equals(Item1, objTuple.Item1) && comparer.Equals(Item2, objTuple.Item2) && comparer.Equals(Item3, objTuple.Item3) &&\n+                comparer.Equals(Item4, objTuple.Item4) && comparer.Equals(Item5, objTuple.Item5) && comparer.Equals(Item6, objTuple.Item6);\n+        }\n+\n+        int IComparable.CompareTo(object obj)\n+        {\n+            return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);\n+        }\n+\n+        int IStructuralComparable.CompareTo(object other, IComparer comparer)\n+        {\n+            if (other == null) return 1;\n+\n+            if (!(other is ValueTuple<T1, T2, T3, T4, T5, T6>))\n+            {\n+                throw new ArgumentException(SR.ArgumentException_ValueTupleIncorrectType, nameof(other));\n+            }\n+\n+            var objTuple = (ValueTuple<T1, T2, T3, T4, T5, T6>)other;\n+\n+            int c = comparer.Compare(Item1, objTuple.Item1);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item2, objTuple.Item2);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item3, objTuple.Item3);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item4, objTuple.Item4);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item5, objTuple.Item5);\n+\n+            if (c != 0) return c;\n+\n+            return comparer.Compare(Item6, objTuple.Item6);\n+        }\n+\n+        public override int GetHashCode()\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);\n+        }\n+\n+        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ValueTuple.CombineHashCodes(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3),\n+                                                comparer.GetHashCode(Item4), comparer.GetHashCode(Item5), comparer.GetHashCode(Item6));\n+        }\n+\n+        int ITupleInternal.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(comparer);\n+        }\n+\n+        public override string ToString()\n+        {\n+            return \"(\" + Item1 + \", \" + Item2 + \", \" + Item3 + \", \" + Item4 + \", \" + Item5 + \", \" + Item6 + \")\";\n+        }\n+\n+        int ITupleInternal.Size => 6;\n+    }\n+\n+    public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7> : IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7>>, IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal\n+    {\n+        public T1 Item1;\n+        public T2 Item2;\n+        public T3 Item3;\n+        public T4 Item4;\n+        public T5 Item5;\n+        public T6 Item6;\n+        public T7 Item7;\n+\n+        public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)\n+        {\n+            Item1 = item1;\n+            Item2 = item2;\n+            Item3 = item3;\n+            Item4 = item4;\n+            Item5 = item5;\n+            Item6 = item6;\n+            Item7 = item7;\n+        }\n+\n+        public override bool Equals(object obj)\n+        {\n+            return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;\n+        }\n+\n+        public bool Equals(ValueTuple<T1, T2, T3, T4, T5, T6, T7> other)\n+        {\n+            return Equals(Item1, other.Item1) && Equals(Item2, other.Item2) && Equals(Item3, other.Item3) &&\n+                Equals(Item4, other.Item4) && Equals(Item5, other.Item5) && Equals(Item6, other.Item6) &&\n+                Equals(Item7, other.Item7);\n+        }\n+\n+        bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)\n+        {\n+            if (other == null || !(other is ValueTuple<T1, T2, T3, T4, T5, T6, T7>)) return false;\n+\n+            var objTuple = (ValueTuple<T1, T2, T3, T4, T5, T6, T7>)other;\n+\n+            return comparer.Equals(Item1, objTuple.Item1) && comparer.Equals(Item2, objTuple.Item2) && comparer.Equals(Item3, objTuple.Item3) &&\n+                comparer.Equals(Item4, objTuple.Item4) && comparer.Equals(Item5, objTuple.Item5) && comparer.Equals(Item6, objTuple.Item6) &&\n+                comparer.Equals(Item7, objTuple.Item7);\n+        }\n+\n+        int IComparable.CompareTo(object obj)\n+        {\n+            return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);\n+        }\n+\n+        int IStructuralComparable.CompareTo(object other, IComparer comparer)\n+        {\n+            if (other == null) return 1;\n+\n+            if (!(other is ValueTuple<T1, T2, T3, T4, T5, T6, T7>))\n+            {\n+                throw new ArgumentException(SR.ArgumentException_ValueTupleIncorrectType, nameof(other));\n+            }\n+\n+            var objTuple = (ValueTuple<T1, T2, T3, T4, T5, T6, T7>)other;\n+\n+            int c = comparer.Compare(Item1, objTuple.Item1);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item2, objTuple.Item2);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item3, objTuple.Item3);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item4, objTuple.Item4);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item5, objTuple.Item5);\n+\n+            if (c != 0) return c;\n+\n+            c = comparer.Compare(Item6, objTuple.Item6);\n+\n+            if (c != 0) return c;\n+\n+            return comparer.Compare(Item7, objTuple.Item7);\n+        }\n+\n+        public override int GetHashCode()\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);\n+        }\n+\n+        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ValueTuple.CombineHashCodes(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3),\n+                                                comparer.GetHashCode(Item4), comparer.GetHashCode(Item5), comparer.GetHashCode(Item6),\n+                                                comparer.GetHashCode(Item7));\n+        }\n+\n+        int ITupleInternal.GetHashCode(IEqualityComparer comparer)\n+        {\n+            return ((IStructuralEquatable)this).GetHashCode(comparer);\n+        }\n+\n+        public override string ToString()\n+        {\n+            return \"(\" + Item1 + \", \" + Item2 + \", \" + Item3 + \", \" + Item4 + \", \" + Item5 + \", \" + Item6 + \", \" + Item7 + \")\";\n+        }\n+\n+        int ITupleInternal.Size => 7;\n+    }\n+\n+    public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal\n+    {\n+        public T1 Item1;\n+        public T2 Item2;\n+        public T3 Item3;\n+        public T4 Item4;\n+        public T5 Item5;\n+        public T6 Item6;\n+        public T7 Item7;\n+        public TRest Rest;\n+\n+        private static readonly EqualityComparer<T1> s_equality1 = EqualityComparer<T1>.Default;\n+        private static readonly Comparer<T1> s_comparer1 = Comparer<T1>.Default;\n+        private static readonly EqualityComparer<T2> s_equality2 = EqualityComparer<T2>.Default;\n+        private static readonly Comparer<T2> s_comparer2 = Comparer<T2>.Default;\n+        private static readonly EqualityComparer<T3> s_equality3 = EqualityComparer<T3>.Default;\n+        private static readonly Comparer<T3> s_comparer3 = Comparer<T3>.Default;\n+        private static readonly EqualityComparer<T4> s_equality4 = EqualityComparer<T4>.Default;\n+        private static readonly Comparer<T4> s_comparer4 = Comparer<T4>.Default;\n+        private static readonly EqualityComparer<T5> s_equality5 = EqualityComparer<T5>.Default;\n+        private static readonly Comparer<T5> s_comparer5 = Comparer<T5>.Default;\n+        private static readonly EqualityComparer<T6> s_equality6 = EqualityComparer<T6>.Default;\n+        private static readonly Comparer<T6> s_comparer6 = Comparer<T6>.Default;\n+        private static readonly EqualityComparer<T7> s_equality7 = EqualityComparer<T7>.Default;\n+        private static readonly Comparer<T7> s_comparer7 = Comparer<T7>.Default;\n+        private static readonly EqualityComparer<TRest> s_equalityRest = EqualityComparer<TRest>.Default;\n+        private static readonly Comparer<TRest> s_comparerRest = Comparer<TRest>.Default;","path":"src/System.Tuples/src/System/ValueTuple/ValueTuple.cs","position":889,"original_position":889,"commit_id":"77248e5e8e55719dedbb07b9322e9c86106b1492","original_commit_id":"77248e5e8e55719dedbb07b9322e9c86106b1492","user":{"login":"jcouv","id":12466233,"avatar_url":"https://avatars.githubusercontent.com/u/12466233?v=3","gravatar_id":"","url":"https://api.github.com/users/jcouv","html_url":"https://github.com/jcouv","followers_url":"https://api.github.com/users/jcouv/followers","following_url":"https://api.github.com/users/jcouv/following{/other_user}","gists_url":"https://api.github.com/users/jcouv/gists{/gist_id}","starred_url":"https://api.github.com/users/jcouv/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/jcouv/subscriptions","organizations_url":"https://api.github.com/users/jcouv/orgs","repos_url":"https://api.github.com/users/jcouv/repos","events_url":"https://api.github.com/users/jcouv/events{/privacy}","received_events_url":"https://api.github.com/users/jcouv/received_events","type":"User","site_admin":false},"body":"Removed.","created_at":"2016-04-13T17:22:55Z","updated_at":"2016-04-13T17:22:55Z","html_url":"https://github.com/dotnet/corefx/pull/7663#discussion_r59588652","pull_request_url":"https://api.github.com/repos/dotnet/corefx/pulls/7663","_links":{"self":{"href":"https://api.github.com/repos/dotnet/corefx/pulls/comments/59588652"},"html":{"href":"https://github.com/dotnet/corefx/pull/7663#discussion_r59588652"},"pull_request":{"href":"https://api.github.com/repos/dotnet/corefx/pulls/7663"}}},"pull_request":{"url":"https://api.github.com/repos/dotnet/corefx/pulls/7663","id":66063573,"html_url":"https://github.com/dotnet/corefx/pull/7663","diff_url":"https://github.com/dotnet/corefx/pull/7663.diff","patch_url":"https://github.com/dotnet/corefx/pull/7663.patch","issue_url":"https://api.github.com/repos/dotnet/corefx/issues/7663","number":7663,"state":"open","locked":false,"title":"Adding System.Tuples","user":{"login":"jcouv","id":12466233,"avatar_url":"https://avatars.githubusercontent.com/u/12466233?v=3","gravatar_id":"","url":"https://api.github.com/users/jcouv","html_url":"https://github.com/jcouv","followers_url":"https://api.github.com/users/jcouv/followers","following_url":"https://api.github.com/users/jcouv/following{/other_user}","gists_url":"https://api.github.com/users/jcouv/gists{/gist_id}","starred_url":"https://api.github.com/users/jcouv/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/jcouv/subscriptions","organizations_url":"https://api.github.com/users/jcouv/orgs","repos_url":"https://api.github.com/users/jcouv/repos","events_url":"https://api.github.com/users/jcouv/events{/privacy}","received_events_url":"https://api.github.com/users/jcouv/received_events","type":"User","site_admin":false},"body":"Added the ValueTuple types that we are discussing for C# 7.\r\n\r\nThe code is based off [System.Tuple](http://referencesource.microsoft.com/#mscorlib/system/tuple.cs,9124c4bea9ab0199) and the tests are based off [TupleTests](https://github.com/dotnet/corefx/blob/cd5d2ea3080927b09022adf06745c1876217c3ca/src/System.Runtime/tests/System/Tuple.cs).\r\n\r\nA few open issues left:\r\n- The hash function is rather poor and needs further discussion.\r\n- I removed `[Serializable]` as it doesn't appear anywhere in corefx.\r\n- the solution and project are named after the package that we discussed `System.Tuples`, but should be probably renamed to `System.ValueTuples` when moved to shipping project.\r\n- Pattern matching may not need the `ITuple` interface after all, so I did no include it.\r\n- There is a small difference between `Tuple.ToString` and `ValueTuple.ToString`, where one prints `(1, ..., 7, (8, 9))`, but the latter prints `(1, ..., 7, 8, 9)`.\r\n- I included xml docs only on ValueTuple\\`2. \r\n\r\n@weshaggard for review.\r\n\r\nCC @dotnet/roslyn-compiler @tmat as FYI.","created_at":"2016-04-11T21:14:19Z","updated_at":"2016-04-13T17:22:55Z","closed_at":null,"merged_at":null,"merge_commit_sha":"d8d9738545c2286261a987305d7a4297bd9a4f45","assignee":null,"milestone":null,"commits_url":"https://api.github.com/repos/dotnet/corefx/pulls/7663/commits","review_comments_url":"https://api.github.com/repos/dotnet/corefx/pulls/7663/comments","review_comment_url":"https://api.github.com/repos/dotnet/corefx/pulls/comments{/number}","comments_url":"https://api.github.com/repos/dotnet/corefx/issues/7663/comments","statuses_url":"https://api.github.com/repos/dotnet/corefx/statuses/77248e5e8e55719dedbb07b9322e9c86106b1492","head":{"label":"jcouv:tuples","ref":"tuples","sha":"77248e5e8e55719dedbb07b9322e9c86106b1492","user":{"login":"jcouv","id":12466233,"avatar_url":"https://avatars.githubusercontent.com/u/12466233?v=3","gravatar_id":"","url":"https://api.github.com/users/jcouv","html_url":"https://github.com/jcouv","followers_url":"https://api.github.com/users/jcouv/followers","following_url":"https://api.github.com/users/jcouv/following{/other_user}","gists_url":"https://api.github.com/users/jcouv/gists{/gist_id}","starred_url":"https://api.github.com/users/jcouv/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/jcouv/subscriptions","organizations_url":"https://api.github.com/users/jcouv/orgs","repos_url":"https://api.github.com/users/jcouv/repos","events_url":"https://api.github.com/users/jcouv/events{/privacy}","received_events_url":"https://api.github.com/users/jcouv/received_events","type":"User","site_admin":false},"repo":{"id":55807182,"name":"corefx","full_name":"jcouv/corefx","owner":{"login":"jcouv","id":12466233,"avatar_url":"https://avatars.githubusercontent.com/u/12466233?v=3","gravatar_id":"","url":"https://api.github.com/users/jcouv","html_url":"https://github.com/jcouv","followers_url":"https://api.github.com/users/jcouv/followers","following_url":"https://api.github.com/users/jcouv/following{/other_user}","gists_url":"https://api.github.com/users/jcouv/gists{/gist_id}","starred_url":"https://api.github.com/users/jcouv/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/jcouv/subscriptions","organizations_url":"https://api.github.com/users/jcouv/orgs","repos_url":"https://api.github.com/users/jcouv/repos","events_url":"https://api.github.com/users/jcouv/events{/privacy}","received_events_url":"https://api.github.com/users/jcouv/received_events","type":"User","site_admin":false},"private":false,"html_url":"https://github.com/jcouv/corefx","description":"This repo contains the .NET Core foundational libraries, called CoreFX. It includes classes for collections, file systems, console, XML, async and many others.","fork":true,"url":"https://api.github.com/repos/jcouv/corefx","forks_url":"https://api.github.com/repos/jcouv/corefx/forks","keys_url":"https://api.github.com/repos/jcouv/corefx/keys{/key_id}","collaborators_url":"https://api.github.com/repos/jcouv/corefx/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/jcouv/corefx/teams","hooks_url":"https://api.github.com/repos/jcouv/corefx/hooks","issue_events_url":"https://api.github.com/repos/jcouv/corefx/issues/events{/number}","events_url":"https://api.github.com/repos/jcouv/corefx/events","assignees_url":"https://api.github.com/repos/jcouv/corefx/assignees{/user}","branches_url":"https://api.github.com/repos/jcouv/corefx/branches{/branch}","tags_url":"https://api.github.com/repos/jcouv/corefx/tags","blobs_url":"https://api.github.com/repos/jcouv/corefx/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/jcouv/corefx/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/jcouv/corefx/git/refs{/sha}","trees_url":"https://api.github.com/repos/jcouv/corefx/git/trees{/sha}","statuses_url":"https://api.github.com/repos/jcouv/corefx/statuses/{sha}","languages_url":"https://api.github.com/repos/jcouv/corefx/languages","stargazers_url":"https://api.github.com/repos/jcouv/corefx/stargazers","contributors_url":"https://api.github.com/repos/jcouv/corefx/contributors","subscribers_url":"https://api.github.com/repos/jcouv/corefx/subscribers","subscription_url":"https://api.github.com/repos/jcouv/corefx/subscription","commits_url":"https://api.github.com/repos/jcouv/corefx/commits{/sha}","git_commits_url":"https://api.github.com/repos/jcouv/corefx/git/commits{/sha}","comments_url":"https://api.github.com/repos/jcouv/corefx/comments{/number}","issue_comment_url":"https://api.github.com/repos/jcouv/corefx/issues/comments{/number}","contents_url":"https://api.github.com/repos/jcouv/corefx/contents/{+path}","compare_url":"https://api.github.com/repos/jcouv/corefx/compare/{base}...{head}","merges_url":"https://api.github.com/repos/jcouv/corefx/merges","archive_url":"https://api.github.com/repos/jcouv/corefx/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/jcouv/corefx/downloads","issues_url":"https://api.github.com/repos/jcouv/corefx/issues{/number}","pulls_url":"https://api.github.com/repos/jcouv/corefx/pulls{/number}","milestones_url":"https://api.github.com/repos/jcouv/corefx/milestones{/number}","notifications_url":"https://api.github.com/repos/jcouv/corefx/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/jcouv/corefx/labels{/name}","releases_url":"https://api.github.com/repos/jcouv/corefx/releases{/id}","deployments_url":"https://api.github.com/repos/jcouv/corefx/deployments","created_at":"2016-04-08T20:16:49Z","updated_at":"2016-04-08T20:17:12Z","pushed_at":"2016-04-12T20:01:17Z","git_url":"git://github.com/jcouv/corefx.git","ssh_url":"git@github.com:jcouv/corefx.git","clone_url":"https://github.com/jcouv/corefx.git","svn_url":"https://github.com/jcouv/corefx","homepage":"http://dotnet.github.io/","size":64311,"stargazers_count":0,"watchers_count":0,"language":"C#","has_issues":false,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":0,"mirror_url":null,"open_issues_count":0,"forks":0,"open_issues":0,"watchers":0,"default_branch":"master"}},"base":{"label":"dotnet:master","ref":"master","sha":"0039007006b6cb915f56e6bee4f153d4801c65bd","user":{"login":"dotnet","id":9141961,"avatar_url":"https://avatars.githubusercontent.com/u/9141961?v=3","gravatar_id":"","url":"https://api.github.com/users/dotnet","html_url":"https://github.com/dotnet","followers_url":"https://api.github.com/users/dotnet/followers","following_url":"https://api.github.com/users/dotnet/following{/other_user}","gists_url":"https://api.github.com/users/dotnet/gists{/gist_id}","starred_url":"https://api.github.com/users/dotnet/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/dotnet/subscriptions","organizations_url":"https://api.github.com/users/dotnet/orgs","repos_url":"https://api.github.com/users/dotnet/repos","events_url":"https://api.github.com/users/dotnet/events{/privacy}","received_events_url":"https://api.github.com/users/dotnet/received_events","type":"Organization","site_admin":false},"repo":{"id":26295345,"name":"corefx","full_name":"dotnet/corefx","owner":{"login":"dotnet","id":9141961,"avatar_url":"https://avatars.githubusercontent.com/u/9141961?v=3","gravatar_id":"","url":"https://api.github.com/users/dotnet","html_url":"https://github.com/dotnet","followers_url":"https://api.github.com/users/dotnet/followers","following_url":"https://api.github.com/users/dotnet/following{/other_user}","gists_url":"https://api.github.com/users/dotnet/gists{/gist_id}","starred_url":"https://api.github.com/users/dotnet/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/dotnet/subscriptions","organizations_url":"https://api.github.com/users/dotnet/orgs","repos_url":"https://api.github.com/users/dotnet/repos","events_url":"https://api.github.com/users/dotnet/events{/privacy}","received_events_url":"https://api.github.com/users/dotnet/received_events","type":"Organization","site_admin":false},"private":false,"html_url":"https://github.com/dotnet/corefx","description":"This repo contains the .NET Core foundational libraries, called CoreFX. It includes classes for collections, file systems, console, XML, async and many others.","fork":false,"url":"https://api.github.com/repos/dotnet/corefx","forks_url":"https://api.github.com/repos/dotnet/corefx/forks","keys_url":"https://api.github.com/repos/dotnet/corefx/keys{/key_id}","collaborators_url":"https://api.github.com/repos/dotnet/corefx/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/dotnet/corefx/teams","hooks_url":"https://api.github.com/repos/dotnet/corefx/hooks","issue_events_url":"https://api.github.com/repos/dotnet/corefx/issues/events{/number}","events_url":"https://api.github.com/repos/dotnet/corefx/events","assignees_url":"https://api.github.com/repos/dotnet/corefx/assignees{/user}","branches_url":"https://api.github.com/repos/dotnet/corefx/branches{/branch}","tags_url":"https://api.github.com/repos/dotnet/corefx/tags","blobs_url":"https://api.github.com/repos/dotnet/corefx/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/dotnet/corefx/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/dotnet/corefx/git/refs{/sha}","trees_url":"https://api.github.com/repos/dotnet/corefx/git/trees{/sha}","statuses_url":"https://api.github.com/repos/dotnet/corefx/statuses/{sha}","languages_url":"https://api.github.com/repos/dotnet/corefx/languages","stargazers_url":"https://api.github.com/repos/dotnet/corefx/stargazers","contributors_url":"https://api.github.com/repos/dotnet/corefx/contributors","subscribers_url":"https://api.github.com/repos/dotnet/corefx/subscribers","subscription_url":"https://api.github.com/repos/dotnet/corefx/subscription","commits_url":"https://api.github.com/repos/dotnet/corefx/commits{/sha}","git_commits_url":"https://api.github.com/repos/dotnet/corefx/git/commits{/sha}","comments_url":"https://api.github.com/repos/dotnet/corefx/comments{/number}","issue_comment_url":"https://api.github.com/repos/dotnet/corefx/issues/comments{/number}","contents_url":"https://api.github.com/repos/dotnet/corefx/contents/{+path}","compare_url":"https://api.github.com/repos/dotnet/corefx/compare/{base}...{head}","merges_url":"https://api.github.com/repos/dotnet/corefx/merges","archive_url":"https://api.github.com/repos/dotnet/corefx/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/dotnet/corefx/downloads","issues_url":"https://api.github.com/repos/dotnet/corefx/issues{/number}","pulls_url":"https://api.github.com/repos/dotnet/corefx/pulls{/number}","milestones_url":"https://api.github.com/repos/dotnet/corefx/milestones{/number}","notifications_url":"https://api.github.com/repos/dotnet/corefx/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/dotnet/corefx/labels{/name}","releases_url":"https://api.github.com/repos/dotnet/corefx/releases{/id}","deployments_url":"https://api.github.com/repos/dotnet/corefx/deployments","created_at":"2014-11-06T23:42:48Z","updated_at":"2016-04-13T15:41:26Z","pushed_at":"2016-04-13T17:21:03Z","git_url":"git://github.com/dotnet/corefx.git","ssh_url":"git@github.com:dotnet/corefx.git","clone_url":"https://github.com/dotnet/corefx.git","svn_url":"https://github.com/dotnet/corefx","homepage":"http://dotnet.github.io/","size":86579,"stargazers_count":9490,"watchers_count":9490,"language":"C#","has_issues":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":2248,"mirror_url":null,"open_issues_count":944,"forks":2248,"open_issues":944,"watchers":9490,"default_branch":"master"}},"_links":{"self":{"href":"https://api.github.com/repos/dotnet/corefx/pulls/7663"},"html":{"href":"https://github.com/dotnet/corefx/pull/7663"},"issue":{"href":"https://api.github.com/repos/dotnet/corefx/issues/7663"},"comments":{"href":"https://api.github.com/repos/dotnet/corefx/issues/7663/comments"},"review_comments":{"href":"https://api.github.com/repos/dotnet/corefx/pulls/7663/comments"},"review_comment":{"href":"https://api.github.com/repos/dotnet/corefx/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/dotnet/corefx/pulls/7663/commits"},"statuses":{"href":"https://api.github.com/repos/dotnet/corefx/statuses/77248e5e8e55719dedbb07b9322e9c86106b1492"}}}}