diff --git a/Underscore.Test/Collection/CreationTest.cs b/Underscore.Test/Collection/CreationTest.cs
index 77364e6..d2179bb 100644
Binary files a/Underscore.Test/Collection/CreationTest.cs and b/Underscore.Test/Collection/CreationTest.cs differ
diff --git a/Underscore.Test/Function/BooleanTest.cs b/Underscore.Test/Function/BooleanTest.cs
new file mode 100644
index 0000000..6086acd
--- /dev/null
+++ b/Underscore.Test/Function/BooleanTest.cs
@@ -0,0 +1,109 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Underscore.Function;
+
+namespace Underscore.Test.Function
+{
+    [TestClass]
+    public class BooleanTest
+    {
+        [TestMethod]
+        public void FunctionNegate()
+        {
+            var testing = new BooleanComponent();
+            var function = testing.Negate( () => true);
+
+            Assert.IsFalse(function());
+
+            var fn2 = testing.Negate(new Func<string, bool>(s => s == "s"));
+            Assert.IsTrue(fn2("l"));
+            Assert.IsFalse(fn2("s"));
+
+        }
+
+        [TestMethod]
+        public void FunctionOrPositive()
+        {
+            bool[] wasCalled = {false, false, false, false};
+            Func<string,string, bool>[] toCall =
+            {
+                (s,s2) => wasCalled[0] = s == "s1" && s2 == "s2",
+                (s,s2) => wasCalled[1] = s == "s1" && s2 == "s2",
+                (s,s2) => wasCalled[2] = s == "s1" && s2 == "s2",
+                (s,s2) => wasCalled[3] = s == "s1" && s2 == "s2"
+            };
+            var testing = new BooleanComponent();
+            var result = testing.Or(toCall);
+            Assert.IsTrue(result("s1","s2"));
+            Assert.IsTrue(wasCalled[0]);
+            Assert.IsFalse(wasCalled[1]);
+            Assert.IsFalse(wasCalled[2]);
+            Assert.IsFalse(wasCalled[3]);
+
+        }
+
+
+        [TestMethod]
+        public void FunctionOrNegative()
+        {
+            bool[] wasCalled = { true, true, true, true};
+            Func<string, string, bool>[] toCall =
+            {
+                (s,s2) => wasCalled[0] = s != "s1" && s2 != "s2",
+                (s,s2) => wasCalled[1] = s != "s1" && s2 != "s2",
+                (s,s2) => wasCalled[2] = s != "s1" && s2 != "s2",
+                (s,s2) => wasCalled[3] = s != "s1" && s2 != "s2"
+            };
+            var testing = new BooleanComponent();
+            var result = testing.Or(toCall);
+            Assert.IsFalse(result("s1", "s2"));
+            foreach (var b in wasCalled)
+            {
+                Assert.IsFalse(b);
+            }
+        }
+
+
+
+        [TestMethod]
+        public void FunctionAndPositive()
+        {
+            bool[] wasCalled = { false, false, false, false };
+            Func<string, string, bool>[] toCall =
+            {
+                (s,s2) => wasCalled[0] = s == "s1" && s2 == "s2",
+                (s,s2) => wasCalled[1] = s == "s1" && s2 == "s2",
+                (s,s2) => wasCalled[2] = s == "s1" && s2 == "s2",
+                (s,s2) => wasCalled[3] = s == "s1" && s2 == "s2"
+            };
+            var testing = new BooleanComponent();
+            var result = testing.And(toCall);
+            Assert.IsTrue(result("s1", "s2"));
+            foreach (var b in wasCalled)
+            {
+                Assert.IsTrue(b);
+            }
+        }
+
+
+        [TestMethod]
+        public void FunctionAndNegative()
+        {
+            bool[] wasCalled = { true, true, true, true };
+            Func<string, string, bool>[] toCall =
+            {
+                (s,s2) => wasCalled[0] = s != "s1" && s2 != "s2",
+                (s,s2) => wasCalled[1] = s == "s1" && s2 == "s2",
+                (s,s2) => wasCalled[2] = s == "s1" && s2 == "s2",
+                (s,s2) => wasCalled[3] = s == "s1" && s2 == "s2"
+            };
+            var testing = new BooleanComponent();
+            var result = testing.And(toCall);
+            Assert.IsFalse(result("s1", "s2"));
+            Assert.IsFalse(wasCalled[0]);
+
+            for(int i=1;i<wasCalled.Length;i++)
+                Assert.IsTrue(wasCalled[i]);
+        }
+    }
+}
diff --git a/Underscore.Test/List/ManipulateTest.cs b/Underscore.Test/List/ManipulateTest.cs
index a66de23..23020f6 100644
Binary files a/Underscore.Test/List/ManipulateTest.cs and b/Underscore.Test/List/ManipulateTest.cs differ
diff --git a/Underscore.Test/Module/FunctionTest.cs b/Underscore.Test/Module/FunctionTest.cs
index 31c7f90..053f30f 100644
--- a/Underscore.Test/Module/FunctionTest.cs
+++ b/Underscore.Test/Module/FunctionTest.cs
@@ -16,7 +16,8 @@ public void FunctionModuleCreateTest( )
                  new ComposeComponent( ),
                  new ConvertComponent(),
                  new SynchComponent( new CompactComponent(), new Underscore.Utility.CompactComponent(), new Underscore.Utility.MathComponent()),
-                 new CacheComponent( new Underscore.Function.CompactComponent(), new Underscore.Utility.CompactComponent())
+                 new CacheComponent( new Underscore.Function.CompactComponent(), new Underscore.Utility.CompactComponent()),
+                 new BooleanComponent()
             );
         }
     }
diff --git a/Underscore.Test/Underscore.Test.csproj b/Underscore.Test/Underscore.Test.csproj
index 34e4ebb..b945cb2 100644
--- a/Underscore.Test/Underscore.Test.csproj
+++ b/Underscore.Test/Underscore.Test.csproj
@@ -50,7 +50,9 @@
     </When>
     <Otherwise>
       <ItemGroup>
-        <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework" />
+        <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework">
+          <Private>False</Private>
+        </Reference>
       </ItemGroup>
     </Otherwise>
   </Choose>
@@ -69,6 +71,7 @@
     <Compile Include="Function\SynchTest.cs" />
     <Compile Include="Function\PartialTest.cs" />
     <Compile Include="Function\SplitTest.cs" />
+    <Compile Include="Function\BooleanTest.cs" />
     <Compile Include="List\AggregateTest.cs" />
     <Compile Include="List\DelegateTest.cs" />
     <Compile Include="List\ManipulateTest.cs" />
diff --git a/Underscore.cs.sln b/Underscore.cs.sln
index be10bb0..f514ee3 100644
--- a/Underscore.cs.sln
+++ b/Underscore.cs.sln
@@ -1,12 +1,14 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
-VisualStudioVersion = 12.0.30723.0
+# Visual Studio 14
+VisualStudioVersion = 14.0.23107.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Underscore.cs", "Underscore.cs\Underscore.cs.csproj", "{946C4F0D-101A-46DB-8C41-C102D0947E99}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Underscore.Test", "Underscore.Test\Underscore.Test.csproj", "{D8C013CF-12B1-4743-9044-D92903510970}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PreformanceTest", "PreformanceTest\PreformanceTest.csproj", "{B34E3068-1596-4F2D-B1BA-39074E0B2661}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -21,6 +23,10 @@ Global
 		{D8C013CF-12B1-4743-9044-D92903510970}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D8C013CF-12B1-4743-9044-D92903510970}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D8C013CF-12B1-4743-9044-D92903510970}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B34E3068-1596-4F2D-B1BA-39074E0B2661}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B34E3068-1596-4F2D-B1BA-39074E0B2661}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B34E3068-1596-4F2D-B1BA-39074E0B2661}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B34E3068-1596-4F2D-B1BA-39074E0B2661}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/Underscore.cs/Collection/Contract/Creation.cs b/Underscore.cs/Collection/Contract/Creation.cs
index 741fd05..120b4bb 100644
--- a/Underscore.cs/Collection/Contract/Creation.cs
+++ b/Underscore.cs/Collection/Contract/Creation.cs
@@ -11,6 +11,9 @@ public interface ICreationComponent
         /// </summary>
         Func<IEnumerable<T>> Snapshot<T>( IEnumerable<T> collection );
 
+        IEnumerable<T> Extend<T>(IEnumerable<T> collection, int length);
 
+
+        IEnumerable<T> Infinite<T>(IEnumerable<T> collection);
     }
 }
diff --git a/Underscore.cs/Collection/Implementation/Creation.cs b/Underscore.cs/Collection/Implementation/Creation.cs
index 5a21be4..3d04d57 100644
--- a/Underscore.cs/Collection/Implementation/Creation.cs
+++ b/Underscore.cs/Collection/Implementation/Creation.cs
@@ -19,5 +19,46 @@ public Func<IEnumerable<T>> Snapshot<T>( IEnumerable<T> collection )
             return ( ) => new List<T>( tsnap );
         }
 
+        public IEnumerable<T> Extend<T>(IEnumerable<T> collection, int length)
+        {
+            using (var enmr = collection.GetEnumerator())
+            {
+                if(!enmr.MoveNext()) throw new ApplicationException("Cannot extend an empty collection");
+                yield return enmr.Current;
+                
+                //make i = 1 instead of zero to account for the first return.
+                for (int i = 1; i < length; i++)
+                {
+                    if (!enmr.MoveNext()) {  enmr.Reset();
+                        enmr.MoveNext();
+                    }
+
+                    yield return enmr.Current;
+
+                }
+            }
+        }
+
+        public IEnumerable<T> Infinite<T>(IEnumerable<T> collection)
+        {
+            using (var enmr = collection.GetEnumerator())
+            {
+                if (!enmr.MoveNext()) throw new ApplicationException("Cannot extend an empty collection");
+                yield return enmr.Current;
+
+                //make i = 1 instead of zero to account for the first return.
+                while(true)
+                {
+
+                    if (!enmr.MoveNext()) { enmr.Reset();
+                        enmr.MoveNext();
+                    }
+
+                    yield return enmr.Current;
+
+                }
+            }
+        }
+        
     }
 }
diff --git a/Underscore.cs/Function/Contract/Boolean.cs b/Underscore.cs/Function/Contract/Boolean.cs
new file mode 100644
index 0000000..452b2e7
--- /dev/null
+++ b/Underscore.cs/Function/Contract/Boolean.cs
@@ -0,0 +1,322 @@
+using System;
+
+// This code has been automatically generated
+// if you want to make changes make them on 
+// the corresponding the text template file
+// Boolean.tt
+namespace Underscore.Function
+{
+
+	public interface IBooleanComponent
+	{
+	
+		
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<bool> Negate( Func<bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, bool> Negate<T1>( Func<T1, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, bool> Negate<T1, T2>( Func<T1, T2, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, bool> Negate<T1, T2, T3>( Func<T1, T2, T3, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, bool> Negate<T1, T2, T3, T4>( Func<T1, T2, T3, T4, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, bool> Negate<T1, T2, T3, T4, T5>( Func<T1, T2, T3, T4, T5, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, bool> Negate<T1, T2, T3, T4, T5, T6>( Func<T1, T2, T3, T4, T5, T6, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, bool> Negate<T1, T2, T3, T4, T5, T6, T7>( Func<T1, T2, T3, T4, T5, T6, T7, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8>( Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> fn);
+
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> fn);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<bool> Or( params Func<bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, bool> Or<T1>( params Func<T1, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, bool> Or<T1, T2>( params Func<T1, T2, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, bool> Or<T1, T2, T3>( params Func<T1, T2, T3, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, bool> Or<T1, T2, T3, T4>( params Func<T1, T2, T3, T4, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, bool> Or<T1, T2, T3, T4, T5>( params Func<T1, T2, T3, T4, T5, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, bool> Or<T1, T2, T3, T4, T5, T6>( params Func<T1, T2, T3, T4, T5, T6, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, bool> Or<T1, T2, T3, T4, T5, T6, T7>( params Func<T1, T2, T3, T4, T5, T6, T7, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<bool> And( params Func<bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, bool> And<T1>( params Func<T1, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, bool> And<T1, T2>( params Func<T1, T2, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, bool> And<T1, T2, T3>( params Func<T1, T2, T3, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, bool> And<T1, T2, T3, T4>( params Func<T1, T2, T3, T4, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, bool> And<T1, T2, T3, T4, T5>( params Func<T1, T2, T3, T4, T5, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, bool> And<T1, T2, T3, T4, T5, T6>( params Func<T1, T2, T3, T4, T5, T6, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, bool> And<T1, T2, T3, T4, T5, T6, T7>( params Func<T1, T2, T3, T4, T5, T6, T7, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> And<T1, T2, T3, T4, T5, T6, T7, T8>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool>[] fns);
+
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool>[] fns);
+
+		
+	}
+
+}
\ No newline at end of file
diff --git a/Underscore.cs/Function/Contract/Boolean.tt b/Underscore.cs/Function/Contract/Boolean.tt
new file mode 100644
index 0000000..5740943
--- /dev/null
+++ b/Underscore.cs/Function/Contract/Boolean.tt
@@ -0,0 +1,83 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ import namespace="System.Linq" #>
+<#@ output extension=".cs" #>
+using System;
+
+// This code has been automatically generated
+// if you want to make changes make them on 
+// the corresponding the text template file
+// Boolean.tt
+namespace Underscore.Function
+{
+
+	public interface IBooleanComponent
+	{
+	
+<#
+
+    var typeArgs = Enumerable.Range(1, 16).Select(i => "T" + i).ToArray();
+
+
+    for (int i = 1; i < 18; i++)
+    {
+        var currTypeArgs = typeArgs.Take(i-1).ToArray();
+        var currTypeArgsString = string.Join(", ", currTypeArgs);
+        var fnRetType = string.Join(", ", currTypeArgs.Concat(new[]{"bool"}));
+        
+		if (!string.IsNullOrEmpty(currTypeArgsString)) 
+		currTypeArgsString = "<" + currTypeArgsString + ">";
+
+        #>
+		
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		Func<<#=fnRetType#>> Negate<#=currTypeArgsString#>( Func<<#=fnRetType#>> fn);
+
+		<#
+	}
+
+	for (int i = 1; i < 18; i++)
+    {
+        var currTypeArgs = typeArgs.Take(i-1).ToArray();
+        var currTypeArgsString = string.Join(", ", currTypeArgs);
+        var fnRetType = string.Join(", ", currTypeArgs.Concat(new[]{"bool"}));
+        
+		if (!string.IsNullOrEmpty(currTypeArgsString)) 
+		currTypeArgsString = "<" + currTypeArgsString + ">";
+
+        #>
+		
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		Func<<#=fnRetType#>> Or<#=currTypeArgsString#>( params Func<<#=fnRetType#>>[] fns);
+
+		<#
+	}
+
+	for (int i = 1; i < 18; i++)
+    {
+        var currTypeArgs = typeArgs.Take(i-1).ToArray();
+        var currTypeArgsString = string.Join(", ", currTypeArgs);
+        var fnRetType = string.Join(", ", currTypeArgs.Concat(new[]{"bool"}));
+        
+		if (!string.IsNullOrEmpty(currTypeArgsString)) 
+		currTypeArgsString = "<" + currTypeArgsString + ">";
+
+        #>
+		
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		Func<<#=fnRetType#>> And<#=currTypeArgsString#>( params Func<<#=fnRetType#>>[] fns);
+
+		<#
+	}
+#>
+
+	}
+
+}
\ No newline at end of file
diff --git a/Underscore.cs/Function/Implementation/Boolean.cs b/Underscore.cs/Function/Implementation/Boolean.cs
new file mode 100644
index 0000000..492f04e
--- /dev/null
+++ b/Underscore.cs/Function/Implementation/Boolean.cs
@@ -0,0 +1,476 @@
+using System;
+using System.Linq;
+
+// This code has been automatically generated
+// if you want to make changes make them on 
+// the corresponding the text template file
+// Boolean.tt
+namespace Underscore.Function
+{
+
+	public class BooleanComponent : IBooleanComponent
+	{
+	
+		
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<bool> Negate( Func<bool> fn)
+		{
+			return ()=>!fn();
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, bool> Negate<T1>( Func<T1, bool> fn)
+		{
+			return (a)=>!fn(a);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, bool> Negate<T1, T2>( Func<T1, T2, bool> fn)
+		{
+			return (a,b)=>!fn(a,b);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, bool> Negate<T1, T2, T3>( Func<T1, T2, T3, bool> fn)
+		{
+			return (a,b,c)=>!fn(a,b,c);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, bool> Negate<T1, T2, T3, T4>( Func<T1, T2, T3, T4, bool> fn)
+		{
+			return (a,b,c,d)=>!fn(a,b,c,d);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, bool> Negate<T1, T2, T3, T4, T5>( Func<T1, T2, T3, T4, T5, bool> fn)
+		{
+			return (a,b,c,d,e)=>!fn(a,b,c,d,e);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, bool> Negate<T1, T2, T3, T4, T5, T6>( Func<T1, T2, T3, T4, T5, T6, bool> fn)
+		{
+			return (a,b,c,d,e,f)=>!fn(a,b,c,d,e,f);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, bool> Negate<T1, T2, T3, T4, T5, T6, T7>( Func<T1, T2, T3, T4, T5, T6, T7, bool> fn)
+		{
+			return (a,b,c,d,e,f,g)=>!fn(a,b,c,d,e,f,g);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8>( Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> fn)
+		{
+			return (a,b,c,d,e,f,g,h)=>!fn(a,b,c,d,e,f,g,h);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> fn)
+		{
+			return (a,b,c,d,e,f,g,h,i)=>!fn(a,b,c,d,e,f,g,h,i);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> fn)
+		{
+			return (a,b,c,d,e,f,g,h,i,j)=>!fn(a,b,c,d,e,f,g,h,i,j);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> fn)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k)=>!fn(a,b,c,d,e,f,g,h,i,j,k);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> fn)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l)=>!fn(a,b,c,d,e,f,g,h,i,j,k,l);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> fn)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m)=>!fn(a,b,c,d,e,f,g,h,i,j,k,l,m);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> fn)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m,n)=>!fn(a,b,c,d,e,f,g,h,i,j,k,l,m,n);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> fn)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)=>!fn(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o);
+		}
+		
+				
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>( Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> fn)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)=>!fn(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<bool> Or( params Func<bool>[] fns)
+		{
+			return ()=>fns.Aggregate(false,(prev,current)=>prev || current());
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, bool> Or<T1>( params Func<T1, bool>[] fns)
+		{
+			return (a)=>fns.Aggregate(false,(prev,current)=>prev || current(a));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, bool> Or<T1, T2>( params Func<T1, T2, bool>[] fns)
+		{
+			return (a,b)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, bool> Or<T1, T2, T3>( params Func<T1, T2, T3, bool>[] fns)
+		{
+			return (a,b,c)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, bool> Or<T1, T2, T3, T4>( params Func<T1, T2, T3, T4, bool>[] fns)
+		{
+			return (a,b,c,d)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, bool> Or<T1, T2, T3, T4, T5>( params Func<T1, T2, T3, T4, T5, bool>[] fns)
+		{
+			return (a,b,c,d,e)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, bool> Or<T1, T2, T3, T4, T5, T6>( params Func<T1, T2, T3, T4, T5, T6, bool>[] fns)
+		{
+			return (a,b,c,d,e,f)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e,f));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, bool> Or<T1, T2, T3, T4, T5, T6, T7>( params Func<T1, T2, T3, T4, T5, T6, T7, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e,f,g));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e,f,g,h));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e,f,g,h,i));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e,f,g,h,i,j));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e,f,g,h,i,j,k));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e,f,g,h,i,j,k,l));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e,f,g,h,i,j,k,l,m));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m,n)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e,f,g,h,i,j,k,l,m,n));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)=>fns.Aggregate(false,(prev,current)=>prev || current(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<bool> And( params Func<bool>[] fns)
+		{
+			return ()=>fns.Aggregate(true,(prev,current)=>prev && current());
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, bool> And<T1>( params Func<T1, bool>[] fns)
+		{
+			return (a)=>fns.Aggregate(true,(prev,current)=>prev && current(a));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, bool> And<T1, T2>( params Func<T1, T2, bool>[] fns)
+		{
+			return (a,b)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, bool> And<T1, T2, T3>( params Func<T1, T2, T3, bool>[] fns)
+		{
+			return (a,b,c)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, bool> And<T1, T2, T3, T4>( params Func<T1, T2, T3, T4, bool>[] fns)
+		{
+			return (a,b,c,d)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, bool> And<T1, T2, T3, T4, T5>( params Func<T1, T2, T3, T4, T5, bool>[] fns)
+		{
+			return (a,b,c,d,e)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, bool> And<T1, T2, T3, T4, T5, T6>( params Func<T1, T2, T3, T4, T5, T6, bool>[] fns)
+		{
+			return (a,b,c,d,e,f)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e,f));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, bool> And<T1, T2, T3, T4, T5, T6, T7>( params Func<T1, T2, T3, T4, T5, T6, T7, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e,f,g));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> And<T1, T2, T3, T4, T5, T6, T7, T8>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e,f,g,h));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e,f,g,h,i));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e,f,g,h,i,j));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e,f,g,h,i,j,k));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e,f,g,h,i,j,k,l));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e,f,g,h,i,j,k,l,m));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m,n)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e,f,g,h,i,j,k,l,m,n));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o));
+		}
+		
+				
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>( params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool>[] fns)
+		{
+			return (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)=>fns.Aggregate(true,(prev,current)=>prev && current(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p));
+		}
+		
+		
+	}
+
+}
\ No newline at end of file
diff --git a/Underscore.cs/Function/Implementation/Boolean.tt b/Underscore.cs/Function/Implementation/Boolean.tt
new file mode 100644
index 0000000..01e8b86
--- /dev/null
+++ b/Underscore.cs/Function/Implementation/Boolean.tt
@@ -0,0 +1,96 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ output extension=".cs" #>
+using System;
+using System.Linq;
+
+// This code has been automatically generated
+// if you want to make changes make them on 
+// the corresponding the text template file
+// Boolean.tt
+namespace Underscore.Function
+{
+
+	public class BooleanComponent : IBooleanComponent
+	{
+	
+<#
+
+    const string argNames = "abcdefghijklmnopqrstuvwxyz";
+    var typeArgs = Enumerable.Range(1, 16).Select(i => "T" + i).ToArray();
+
+
+    for (int i = 1; i < 18; i++)
+    {
+        var currTypeArgs = typeArgs.Take(i-1).ToArray();
+        var currTypeArgsString = string.Join(", ", currTypeArgs);
+        var fnRetType = string.Join(", ", currTypeArgs.Concat(new[]{"bool"}));
+        var callStr = string.Join(",", argNames.Take(i-1).Select(a => a.ToString()));
+        if (!string.IsNullOrEmpty(currTypeArgsString)) currTypeArgsString = "<" + currTypeArgsString + ">";
+
+        #>
+		
+		/// <summary>
+		/// Negates the logic of the passed function
+		/// </summary>
+		public Func<<#=fnRetType#>> Negate<#=currTypeArgsString#>( Func<<#=fnRetType#>> fn)
+		{
+			return (<#=callStr#>)=>!fn(<#=callStr#>);
+		}
+		
+		<#
+	}
+
+
+	
+
+    for (int i = 1; i < 18; i++)
+    {
+        var currTypeArgs = typeArgs.Take(i-1).ToArray();
+        var currTypeArgsString = string.Join(", ", currTypeArgs);
+        var fnRetType = string.Join(", ", currTypeArgs.Concat(new[]{"bool"}));
+        var callStr = string.Join(",", argNames.Take(i-1).Select(a => a.ToString()));
+        if (!string.IsNullOrEmpty(currTypeArgsString)) currTypeArgsString = "<" + currTypeArgsString + ">";
+
+        #>
+		
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'or'ed together
+		/// </summary>
+		public Func<<#=fnRetType#>> Or<#=currTypeArgsString#>( params Func<<#=fnRetType#>>[] fns)
+		{
+			return (<#=callStr#>)=>fns.Aggregate(false,(prev,current)=>prev || current(<#=callStr#>));
+		}
+		
+		<#
+	}
+
+
+
+	
+    for (int i = 1; i < 18; i++)
+    {
+        var currTypeArgs = typeArgs.Take(i-1).ToArray();
+        var currTypeArgsString = string.Join(", ", currTypeArgs);
+        var fnRetType = string.Join(", ", currTypeArgs.Concat(new[]{"bool"}));
+        var callStr = string.Join(",", argNames.Take(i-1).Select(a => a.ToString()));
+        if (!string.IsNullOrEmpty(currTypeArgsString)) currTypeArgsString = "<" + currTypeArgsString + ">";
+
+        #>
+		
+		/// <summary>
+		/// Creates an aggregate function that is a result of the passed functions being called and being 'and'ed together
+		/// </summary>
+		public Func<<#=fnRetType#>> And<#=currTypeArgsString#>( params Func<<#=fnRetType#>>[] fns)
+		{
+			return (<#=callStr#>)=>fns.Aggregate(true,(prev,current)=>prev && current(<#=callStr#>));
+		}
+		
+		<#
+	}
+#>
+
+	}
+
+}
\ No newline at end of file
diff --git a/Underscore.cs/List/Contract/Manipulate.cs b/Underscore.cs/List/Contract/Manipulate.cs
index 832aaf1..04a6280 100644
--- a/Underscore.cs/List/Contract/Manipulate.cs
+++ b/Underscore.cs/List/Contract/Manipulate.cs
@@ -40,5 +40,9 @@ public interface IManipulateComponent
         /// Generates a random sample of items from the passed list
         /// </summary>
         IList<T> Sample<T>( IList<T> list, int size, bool unique );
+
+        IEnumerable<T> Extend<T>(IList<T> list, int size);
+
+        IEnumerable<T> Infinite<T>(IList<T> list);
     }
 }
diff --git a/Underscore.cs/List/Implementation/Manipulate.cs b/Underscore.cs/List/Implementation/Manipulate.cs
index aa05c31..83bfb35 100644
--- a/Underscore.cs/List/Implementation/Manipulate.cs
+++ b/Underscore.cs/List/Implementation/Manipulate.cs
@@ -158,6 +158,20 @@ public IList<T> Sample<T>( IList<T> list, int size, bool allUnique )
             return retv;
         }
 
+        public IEnumerable<T> Extend<T>(IList<T> list, int size)
+        {
+            for (int i = 0; i < size; i++)
+                yield return list[i%list.Count];
+        }
+
+        public IEnumerable<T> Infinite<T>(IList<T> list)
+        {
+            for(int i=0;;i++)
+            {
+                yield return list[i%list.Count];
+            }
+        }
+
         protected virtual void Dispose(bool disposing)
         {
             if (disposing)
diff --git a/Underscore.cs/Module/Collection.cs b/Underscore.cs/Module/Collection.cs
index caa5dc8..39cfb96 100644
--- a/Underscore.cs/Module/Collection.cs
+++ b/Underscore.cs/Module/Collection.cs
@@ -26,7 +26,17 @@ public Func<IEnumerable<T>> Snapshot<T>( IEnumerable<T> collection )
         {
             return _creator.Snapshot( collection );
         }
-        
+
+        public IEnumerable<T> Extend<T>(IEnumerable<T> collection, int length)
+        {
+            return _creator.Extend(collection, length);
+        }
+
+        public IEnumerable<T> Infinite<T>(IEnumerable<T> collection)
+        {
+            return _creator.Infinite(collection);
+        }
+
 
         public IEnumerable<IEnumerable<T>> Chunk<T>( IEnumerable<T> collection, int size )
         {
diff --git a/Underscore.cs/Module/Function.cs b/Underscore.cs/Module/Function.cs
index 8c3abb4..519671a 100644
--- a/Underscore.cs/Module/Function.cs
+++ b/Underscore.cs/Module/Function.cs
@@ -13,7 +13,8 @@ public class Function :
         IComposeComponent,
         ISynchComponent,
         IConvertComponent,
-        ICacheComponent
+        ICacheComponent,
+        IBooleanComponent
     {
 
         private readonly IComposeComponent _compose;
@@ -23,6 +24,7 @@ public class Function :
         private readonly IConvertComponent _convert;
         private readonly ISynchComponent _synch;
         private readonly ICacheComponent _cache;
+        private readonly IBooleanComponent _booleanComponent;
 
         public Function( 
             IBindComponent bind, 
@@ -31,7 +33,8 @@ public Function(
             IComposeComponent compose,
             IConvertComponent convert,
             ISynchComponent synch,
-            ICacheComponent cache) 
+            ICacheComponent cache,
+            IBooleanComponent boolComponent) 
         {
             _bind = bind;
             _partial = partial;
@@ -40,6 +43,7 @@ public Function(
             _synch = synch;
             _convert = convert;
             _cache = cache;
+            _booleanComponent = boolComponent;
         }
 
 
@@ -2006,5 +2010,260 @@ public Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg1
         {
             return _cache.Memoize(function);
         }
+
+        public Func<bool> Negate(Func<bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, bool> Negate<T1>(Func<T1, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, bool> Negate<T1, T2>(Func<T1, T2, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, bool> Negate<T1, T2, T3>(Func<T1, T2, T3, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, bool> Negate<T1, T2, T3, T4>(Func<T1, T2, T3, T4, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, bool> Negate<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, bool> Negate<T1, T2, T3, T4, T5, T6>(Func<T1, T2, T3, T4, T5, T6, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, bool> Negate<T1, T2, T3, T4, T5, T6, T7>(Func<T1, T2, T3, T4, T5, T6, T7, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8>(Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> Negate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> fn)
+        {
+            return _booleanComponent.Negate(fn);
+        }
+
+        public Func<bool> Or(params Func<bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, bool> Or<T1>(params Func<T1, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, bool> Or<T1, T2>(params Func<T1, T2, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, bool> Or<T1, T2, T3>(params Func<T1, T2, T3, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, bool> Or<T1, T2, T3, T4>(params Func<T1, T2, T3, T4, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, bool> Or<T1, T2, T3, T4, T5>(params Func<T1, T2, T3, T4, T5, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, bool> Or<T1, T2, T3, T4, T5, T6>(params Func<T1, T2, T3, T4, T5, T6, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, bool> Or<T1, T2, T3, T4, T5, T6, T7>(params Func<T1, T2, T3, T4, T5, T6, T7, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> Or<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool>[] fns)
+        {
+            return _booleanComponent.Or(fns);
+        }
+
+        public Func<bool> And(params Func<bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, bool> And<T1>(params Func<T1, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, bool> And<T1, T2>(params Func<T1, T2, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, bool> And<T1, T2, T3>(params Func<T1, T2, T3, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, bool> And<T1, T2, T3, T4>(params Func<T1, T2, T3, T4, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, bool> And<T1, T2, T3, T4, T5>(params Func<T1, T2, T3, T4, T5, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, bool> And<T1, T2, T3, T4, T5, T6>(params Func<T1, T2, T3, T4, T5, T6, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, bool> And<T1, T2, T3, T4, T5, T6, T7>(params Func<T1, T2, T3, T4, T5, T6, T7, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, bool> And<T1, T2, T3, T4, T5, T6, T7, T8>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
+
+        public Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool> And<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(params Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, bool>[] fns)
+        {
+            return _booleanComponent.And(fns);
+        }
     }
 }
diff --git a/Underscore.cs/Module/List.cs b/Underscore.cs/Module/List.cs
index aebdb98..9ae467c 100644
--- a/Underscore.cs/Module/List.cs
+++ b/Underscore.cs/Module/List.cs
@@ -71,6 +71,16 @@ public IList<T> Sample<T>( IList<T> list, int size, bool unique )
             return _manipulator.Sample( list, size, unique );
         }
 
+        public IEnumerable<T> Extend<T>(IList<T> list, int size)
+        {
+            return _manipulator.Extend(list, size);
+        }
+
+        public IEnumerable<T> Infinite<T>(IList<T> list)
+        {
+            return _manipulator.Infinite(list);
+        }
+
         public IList<T> Slice<T>( IList<T> list, int start, int end )
         {
             return _partitioner.Slice( list, start, end );
diff --git a/Underscore.cs/Object/Reflection/Implementation/Property.cs b/Underscore.cs/Object/Reflection/Implementation/Property.cs
index 5bfcf4e..6b906fa 100644
--- a/Underscore.cs/Object/Reflection/Implementation/Property.cs
+++ b/Underscore.cs/Object/Reflection/Implementation/Property.cs
@@ -11,6 +11,7 @@ public class PropertyComponent : IPropertyComponent
         private readonly Func<Type, IEnumerable<PropertyInfo>> _getValidProperties;
         private readonly Func<Type,Type, BindingFlags,IEnumerable<PropertyInfo>> _propertiesByType;
         private readonly Func<Type, BindingFlags, IEnumerable<PropertyInfo>> _getValidPropertiesWithBindingFlags;
+        private readonly Func<Type, string, BindingFlags,PropertyInfo> _getProperty; 
         private const BindingFlags defaultFlags = BindingFlags.Public | BindingFlags.Instance ;
 
         public PropertyComponent( ICacheComponent cacher )
@@ -29,6 +30,11 @@ public PropertyComponent( ICacheComponent cacher )
                 (tme, tprop, flags) =>
                     _getValidPropertiesWithBindingFlags(tme, flags).Where(a => a.PropertyType == tprop);
 
+            var tmpProp = _getProperty = (t, n, bf) => t.GetProperty(n,bf);
+
+            _getProperty = cacher.Memoize(tmpProp);
+
+
         }
 
 
@@ -52,7 +58,7 @@ public IEnumerable<PropertyInfo> All( object target )
 
         public IEnumerable<PropertyInfo> All(Type type)
         {
-            return Enumerate(type).ToList();
+            return Enumerate(type);
         }
 
         public IEnumerable<PropertyInfo> All(object target, BindingFlags flags)
@@ -72,9 +78,10 @@ public void SetValue<T>(object target, string name, T value, bool caseSensitive,
                 name = name.ToLower();
 
             var possible = OfType(target, typeof (T), flags);
-            if (possible.Any())
+            var propertyInfos = possible as PropertyInfo[] ?? possible.ToArray();
+            if (propertyInfos.Any())
             {
-                var assigning = possible.FirstOrDefault(a => (caseSensitive ? a.Name : a.Name.ToLower()) == name);
+                var assigning = propertyInfos.FirstOrDefault(a => (caseSensitive ? a.Name : a.Name.ToLower()) == name);
 
                 if (assigning != null)
                     assigning.SetValue(target, value);
@@ -245,7 +252,7 @@ private PropertyInfo PropertyCaseInsensitive(object target, string name, Binding
         private PropertyInfo PropertyCaseSensitive(object target, string name, BindingFlags flags = defaultFlags)
         {
 
-            return All(target, flags).FirstOrDefault(a => a.Name == name);
+            return _getProperty(target.GetType(), name,flags);
         }
 
 
diff --git a/Underscore.cs/Properties/AssemblyInfo.cs b/Underscore.cs/Properties/AssemblyInfo.cs
index 0a05688..5eb00a8 100644
--- a/Underscore.cs/Properties/AssemblyInfo.cs
+++ b/Underscore.cs/Properties/AssemblyInfo.cs
@@ -7,5 +7,5 @@
 [assembly: AssemblyCopyright("Copyright © 2014-2016 Chip Keyser")]
 [assembly: ComVisible(false)]
 [assembly: Guid("b96a9e7d-de48-4b0d-8397-d98a7a734880")]
-[assembly: AssemblyVersion("0.1.3.12")]
-[assembly: AssemblyFileVersion("0.1.3.12")]
+[assembly: AssemblyVersion("0.1.3.13")]
+[assembly: AssemblyFileVersion("0.1.3.13")]
diff --git a/Underscore.cs/Setup/Function.cs b/Underscore.cs/Setup/Function.cs
index 96020ce..92d41a2 100644
--- a/Underscore.cs/Setup/Function.cs
+++ b/Underscore.cs/Setup/Function.cs
@@ -16,6 +16,7 @@ public void Load(Kernel kernel )
             kernel.Register<ISynchComponent,SynchComponent>();
             kernel.Register<ICacheComponent , CacheComponent>();
             kernel.Register<ICompactComponent, CompactComponent>();
+            kernel.Register<IBooleanComponent,BooleanComponent>();
             kernel.Register<Module.Function>();
         }
     }
diff --git a/Underscore.cs/Underscore.cs.csproj b/Underscore.cs/Underscore.cs.csproj
index bf281fb..aecf39f 100644
--- a/Underscore.cs/Underscore.cs.csproj
+++ b/Underscore.cs/Underscore.cs.csproj
@@ -65,6 +65,11 @@
     <Compile Include="Collection\Implementation\Creation.cs" />
     <Compile Include="Collection\Implementation\Partition.cs" />
     <Compile Include="Function\Contract\Bind.cs" />
+    <Compile Include="Function\Contract\Boolean.cs">
+      <DependentUpon>Boolean.tt</DependentUpon>
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+    </Compile>
     <Compile Include="Function\Contract\Cache.cs" />
     <Compile Include="Function\Contract\Compact.cs" />
     <Compile Include="Function\Contract\Compose.cs" />
@@ -73,6 +78,11 @@
     <Compile Include="Function\Contract\Split.cs" />
     <Compile Include="Function\Contract\Synch.cs" />
     <Compile Include="Function\Implementation\Bind.cs" />
+    <Compile Include="Function\Implementation\Boolean.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Boolean.tt</DependentUpon>
+    </Compile>
     <Compile Include="Function\Implementation\Cache.cs" />
     <Compile Include="Function\Implementation\Compact.cs" />
     <Compile Include="Function\Implementation\Compose.cs" />
@@ -130,6 +140,16 @@
   <ItemGroup>
     <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="Function\Contract\Boolean.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Boolean.cs</LastGenOutput>
+    </Content>
+    <Content Include="Function\Implementation\Boolean.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Boolean.cs</LastGenOutput>
+    </Content>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
     <PostBuildEvent>