diff --git a/CHANGELOG.txt b/CHANGELOG.txt
index 619f14e..428e5d9 100644
--- a/CHANGELOG.txt
+++ b/CHANGELOG.txt
@@ -1,8 +1,8 @@
 ------------------------------------------------------------------------------
-  qSharp 2.0.7 [TBA]
+  qSharp 2.1.0 [2014.10.01]
 ------------------------------------------------------------------------------
 
-  - Fix: validate lambda expression upon construction
+  - Redesigned lambdas and projections handling
 
 ------------------------------------------------------------------------------
   qSharp 2.0.6 [2014.09.11]
diff --git a/qSharp/qSharp.csproj b/qSharp/qSharp.csproj
index ef0aa57..470d6a1 100644
--- a/qSharp/qSharp.csproj
+++ b/qSharp/qSharp.csproj
@@ -59,6 +59,8 @@
     <Reference Include="System.Core" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="src\QProjection.cs" />
+    <Compile Include="src\QFunction.cs" />
     <Compile Include="src\QBasicConnection.cs" />
     <Compile Include="src\QCallbackConnection.cs" />
     <Compile Include="src\QMessage.cs" />
@@ -98,6 +100,7 @@
     <None Include="test\QCompressedExpressions.out" />
     <None Include="test\QExpressions.3.out" />
     <None Include="test\QExpressions.out" />
+    <None Include="test\QExpressionsFunctions.out" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/qSharp/src/QFunction.cs b/qSharp/src/QFunction.cs
new file mode 100644
index 0000000..538cbb6
--- /dev/null
+++ b/qSharp/src/QFunction.cs
@@ -0,0 +1,65 @@
+//
+//   Copyright (c) 2011-2014 Exxeleron GmbH
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+//
+
+using System;
+
+namespace qSharp
+{
+    /// <summary>
+    ///     Represents q function.
+    ///     
+    ///     Note that the QFunction instances cannot be serialized to IPC protocol.
+    /// </summary>
+    public class QFunction
+    {
+        private readonly byte qTypeCode;
+
+        /// <summary>
+        ///     Creates representation of q function with given q type code.
+        /// </summary>
+        protected QFunction(byte qTypeCode)
+        {
+            this.qTypeCode = qTypeCode;
+        }
+
+        /// <summary>
+        ///     Retrieve q type code connected with function.
+        /// </summary>
+        public byte QTypeCode
+        {
+            get { return qTypeCode; }
+        }
+
+
+        /// <summary>
+        ///     Returns a System.String that represents the current QFunction.
+        /// </summary>
+        /// <returns>A System.String that represents the current QFunction</returns>
+        public override string ToString()
+        {
+            return "QFunction#" + qTypeCode + "h";
+        }
+
+
+        /// <summary>
+        ///     Creates representation of q function with given q type code.
+        /// </summary>
+        internal static QFunction Create(byte qTypeCode)
+        {
+            return new QFunction(qTypeCode);
+        }
+    }
+}
\ No newline at end of file
diff --git a/qSharp/src/QLambda.cs b/qSharp/src/QLambda.cs
index 35ef3db..147e0dc 100644
--- a/qSharp/src/QLambda.cs
+++ b/qSharp/src/QLambda.cs
@@ -15,41 +15,43 @@
 //
 
 using System;
+using System.Text.RegularExpressions;
 
 namespace qSharp
 {
     /// <summary>
     ///     Represents a q lambda expression.
     /// </summary>
-    public sealed class QLambda
+    public sealed class QLambda : QFunction
     {
+        private const string LambdaRegex = @"\s*(k\))?\s*\{.*\}";
+
         private readonly string expression;
-        private readonly Array parameters;
 
         /// <summary>
-        ///     Creates new QLambda instance with given body and parameters.
-        ///     Note that expression is trimmed and required to be enclosed in { and } brackets.
+        ///     Creates new QLambda instance with given body. Note that expression is trimmed and required to be enclosed
+        ///     in { and } brackets.
         /// </summary>
-        public QLambda(string expression, Array parameters = null)
+        public QLambda(string expression)
+            : base((byte)QType.Lambda)
         {
             if (expression == null)
             {
                 throw new ArgumentException("Lambda expression cannot be null");
             }
             expression = expression.Trim();
-            
+
             if (expression.Length == 0)
             {
                 throw new ArgumentException("Lambda expression cannot be empty");
             }
 
-            if (expression[0] != '{' || expression[expression.Length - 1] != '}')
+            if (!Regex.IsMatch(expression, LambdaRegex, RegexOptions.Compiled))
             {
-                throw new ArgumentException("Lambda expression is expected to be enclosed in {} brackets");
+                throw new ArgumentException("Invalid lambda expresion: " + expression);
             }
 
             this.expression = expression;
-            this.parameters = parameters;
         }
 
         /// <summary>
@@ -60,14 +62,6 @@ public string Expression
             get { return expression; }
         }
 
-        /// <summary>
-        ///     Gets parameters of a q lambda expression.
-        /// </summary>
-        public Array Parameters
-        {
-            get { return parameters; }
-        }
-
         /// <summary>
         ///     Determines whether the specified System.Object is equal to the current QLambda.
         /// </summary>
@@ -86,7 +80,7 @@ public override bool Equals(Object obj)
                 return false;
             }
 
-            return expression.Equals(l.expression) && Utils.ArrayEquals(parameters, l.parameters);
+            return expression.Equals(l.expression);
         }
 
         /// <summary>
@@ -101,7 +95,7 @@ public bool Equals(QLambda l)
                 return false;
             }
 
-            return expression.Equals(l.expression) && Utils.ArrayEquals(parameters, l.parameters);
+            return expression.Equals(l.expression);
         }
 
         /// <summary>
@@ -119,7 +113,7 @@ public override int GetHashCode()
         /// <returns>A System.String that represents the current QLambda</returns>
         public override string ToString()
         {
-            return "QLambda: " + expression + (parameters == null ? "" : Utils.ArrayToString(parameters));
+            return "QLambda: " + expression;
         }
     }
 }
\ No newline at end of file
diff --git a/qSharp/src/QProjection.cs b/qSharp/src/QProjection.cs
new file mode 100644
index 0000000..5b7b3ee
--- /dev/null
+++ b/qSharp/src/QProjection.cs
@@ -0,0 +1,99 @@
+//
+//   Copyright (c) 2011-2014 Exxeleron GmbH
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+//
+
+using System;
+
+namespace qSharp
+{
+    /// <summary>
+    ///     Represents a q projection.
+    /// </summary>
+    public sealed class QProjection : QFunction
+    {
+        private readonly Array parameters;
+
+        /// <summary>
+        ///     Creates new QProjection instance with given parameters.
+        /// </summary>
+        public QProjection(Array parameters)
+            : base((byte) QType.Projection)
+        {
+            this.parameters = parameters;
+        }
+
+        /// <summary>
+        ///     Gets parameters of a q lambda expression.
+        /// </summary>
+        public Array Parameters
+        {
+            get { return parameters; }
+        }
+
+        /// <summary>
+        ///     Determines whether the specified System.Object is equal to the current QProjection.
+        /// </summary>
+        /// <param name="obj">The System.Object to compare with the current QProjection.</param>
+        /// <returns>true if the specified System.Object is equal to the current QProjection; otherwise, false</returns>
+        public override bool Equals(Object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            var p = obj as QProjection;
+            if (p == null)
+            {
+                return false;
+            }
+
+            return Utils.ArrayEquals(parameters, p.parameters);
+        }
+
+        /// <summary>
+        ///     Determines whether the specified QProjection is equal to the current QProjection.
+        /// </summary>
+        /// <param name="l">The QProjection to compare with the current QProjection.</param>
+        /// <returns>true if the specified QProjection is equal to the current QProjection; otherwise, false</returns>
+        public bool Equals(QProjection p)
+        {
+            if (p == null)
+            {
+                return false;
+            }
+
+            return Utils.ArrayEquals(parameters, p.parameters);
+        }
+
+        /// <summary>
+        ///     Serves as a hash function for a QProjection type.
+        /// </summary>
+        /// <returns>A hash code for the current QProjection</returns>
+        public override int GetHashCode()
+        {
+            return parameters == null ? 0 : parameters.Length;
+        }
+
+        /// <summary>
+        ///     Returns a System.String that represents the current QLambda.
+        /// </summary>
+        /// <returns>A System.String that represents the current QLambda</returns>
+        public override string ToString()
+        {
+            return "QProjection: " + (parameters == null ? "<null>" : Utils.ArrayToString(parameters));
+        }
+    }
+}
\ No newline at end of file
diff --git a/qSharp/src/QReader.cs b/qSharp/src/QReader.cs
index 4710091..f8e3bc7 100644
--- a/qSharp/src/QReader.cs
+++ b/qSharp/src/QReader.cs
@@ -244,15 +244,21 @@ private object ReadObject()
                     return ReadList(qtype);
                 case QType.GeneralList:
                     return ReadGeneralList();
-                case QType.NullItem:
-                    reader.ReadSByte(); // ignore
-                    return null;
                 case QType.Error:
                     return ReadError();
                 case QType.Lambda:
-                    return ReadLambda();
-                case QType.LambdaPart:
-                    return ReadLambdaPart();
+                case QType.Projection:
+                case QType.UnaryPrimitiveFunc:
+                case QType.BinaryPrimitiveFunc:
+                case QType.TernaryOperatorFunc:
+                case QType.CompositionFunc:
+                case QType.AdverbFunc106:
+                case QType.AdverbFunc107:
+                case QType.AdverbFunc108:
+                case QType.AdverbFunc109:
+                case QType.AdverbFunc110:
+                case QType.AdverbFunc111:
+                    return ReadFunction(qtype);
                 case QType.Dictionary:
                     return ReadDictionary();
                 case QType.Table:
@@ -497,29 +503,53 @@ private object ReadError()
             throw new QException(ReadSymbol());
         }
 
-        private QLambda ReadLambda()
+        private QFunction ReadFunction(QType qtype)
         {
-            ReadSymbol();
-            var expression = (char[])ReadObject();
-            if (expression == null)
-            {
-                throw new QReaderException("Malformed lambda expression");
-            }
-            return new QLambda(new string(expression));
-        }
-
-        private QLambda ReadLambdaPart()
-        {
-            int length = reader.ReadInt32() - 1;
-            QLambda lambda = ReadLambda();
-            var parameters = new object[length];
-
-            for (int i = 0; i < length; i++)
+            switch (qtype)
             {
-                parameters[i] = ReadObject();
+                case QType.Lambda:
+                    {
+                        reader.ReadSymbol(encoding); // ignore context
+                        var expression = (char[])ReadObject();
+                        return new QLambda(new string(expression));
+                    }
+                case QType.Projection:
+                    {
+                        int length = reader.ReadInt32();
+                        var parameters = new object[length];
+                        for (int i = 0; i < length; i++)
+                        {
+                            parameters[i] = ReadObject();
+                        }
+                        return new QProjection(parameters);
+                    }
+                case QType.UnaryPrimitiveFunc:
+                    {
+                        var code = reader.ReadByte();
+                        return code == 0 ? null : QFunction.Create((byte)qtype);
+                    }
+                case QType.BinaryPrimitiveFunc:
+                case QType.TernaryOperatorFunc:
+                    {
+                        var code = reader.ReadByte(); // ignore
+                        return QFunction.Create((byte)qtype);
+                    }
+                case QType.CompositionFunc:
+                    {
+                        int length = reader.ReadInt32();
+                        var parameters = new object[length];
+                        for (int i = 0; i < length; i++)
+                        {
+                            parameters[i] = ReadObject();
+                        }
+                        return QFunction.Create((byte)qtype);
+                    }
+                default:
+                    {
+                        ReadObject(); // ignore
+                        return QFunction.Create((byte)qtype);
+                    }
             }
-
-            return new QLambda(lambda.Expression, parameters);
         }
 
         private object ReadDictionary()
diff --git a/qSharp/src/QType.cs b/qSharp/src/QType.cs
index accd175..b1b318c 100644
--- a/qSharp/src/QType.cs
+++ b/qSharp/src/QType.cs
@@ -63,11 +63,22 @@ public enum QType
         SecondList = 18,
         Time = -19,
         TimeList = 19,
-        Lambda = 100,
-        LambdaPart = 104,
         Table = 98,
         KeyedTable = 99,
         Dictionary = 99,
+        Lambda = 100,
+        LambdaPart = 104,
+        Projection = 104,
+        UnaryPrimitiveFunc = 101,
+        BinaryPrimitiveFunc = 102,
+        TernaryOperatorFunc = 103,
+        CompositionFunc = 105,
+        AdverbFunc106 = 106,
+        AdverbFunc107 = 107,
+        AdverbFunc108 = 108,
+        AdverbFunc109 = 109,
+        AdverbFunc110 = 110,
+        AdverbFunc111 = 111,
     }
 
     /// <summary>
@@ -117,6 +128,7 @@ public static class QTypes
                 {typeof (QTime), QType.Time},
                 {typeof (QTime[]), QType.TimeList},
                 {typeof (QLambda), QType.Lambda},
+                {typeof (QProjection), QType.Projection},
                 {typeof (QException), QType.Error},
                 {typeof (QDictionary), QType.Dictionary},
                 {typeof (QTable), QType.Table},
@@ -163,7 +175,7 @@ public static class QTypes
                 {QType.Time, typeof (QTime)},
                 {QType.TimeList, typeof (QTime[])},
                 {QType.Lambda, typeof (QLambda)},
-                {QType.LambdaPart, typeof (QLambda)},
+                {QType.Projection, typeof (QProjection)},
                 {QType.Error, typeof (Exception)},
             };
 
diff --git a/qSharp/src/QWriter.cs b/qSharp/src/QWriter.cs
index 25adc71..37a8b92 100644
--- a/qSharp/src/QWriter.cs
+++ b/qSharp/src/QWriter.cs
@@ -135,6 +135,9 @@ private void WriteObject(object obj)
                 case QType.Lambda:
                     WriteLambda(obj as QLambda);
                     return;
+                case QType.Projection:
+                    WriteProjection(obj as QProjection);
+                    return;
                 case QType.Error:
                     WriteError(obj as Exception);
                     return;
@@ -473,23 +476,18 @@ private void WriteNullItem()
 
         private void WriteLambda(QLambda l)
         {
-            if (l.Parameters == null || l.Parameters.Length == 0)
-            {
-                writer.Write((sbyte)QType.Lambda);
-                writer.Write((byte)0);
-                WriteString(l.Expression.ToCharArray());
-            }
-            else
+            writer.Write((sbyte)QType.Lambda);
+            writer.Write((byte)0);
+            WriteString(l.Expression.ToCharArray());
+        }
+
+        private void WriteProjection(QProjection p)
+        {
+            writer.Write((sbyte)QType.LambdaPart);
+            writer.Write(p.Parameters.Length);
+            foreach (object parameter in p.Parameters)
             {
-                writer.Write((sbyte)QType.LambdaPart);
-                writer.Write(l.Parameters.Length + 1);
-                writer.Write((sbyte)QType.Lambda);
-                writer.Write((byte)0);
-                WriteString(l.Expression.ToCharArray());
-                foreach (object p in l.Parameters)
-                {
-                    WriteObject(p);
-                }
+                WriteObject(parameter);
             }
         }
 
diff --git a/qSharp/src/Utils.cs b/qSharp/src/Utils.cs
index 0949ec3..e2c425f 100644
--- a/qSharp/src/Utils.cs
+++ b/qSharp/src/Utils.cs
@@ -81,7 +81,7 @@ internal static bool ArrayEquals(Array l, Array r)
                     continue;
                 }
 
-                if (lv == null || rv == null || lv.GetType() != rv.GetType())
+                if (lv == null || rv == null )
                 {
                     return false;
                 }
diff --git a/qSharp/test/QExpression.cs b/qSharp/test/QExpression.cs
index 1f4dcbd..94bcb61 100644
--- a/qSharp/test/QExpression.cs
+++ b/qSharp/test/QExpression.cs
@@ -122,7 +122,7 @@ internal class QExpressions
                             {"12:04:59.123 0Nt", new[] {new QTime(43499123), new QTime(int.MinValue)}},
                             {"::", null},
                             {"{x+y}", new QLambda("{x+y}")},
-                            {"{x+y}[3]", new QLambda("{x+y}", new object[] {3})},
+                            {"{x+y}[3]", new QProjection( new object[]{new QLambda("{x+y}"), 3})},
                             {"(enlist `a)!(enlist 1)", new QDictionary(new[] {"a"}, new[] {1})},
                             {"1 2!`abc`cdefgh", new QDictionary(new[] {1, 2}, new[] {"abc", "cdefgh"})},
                             {
@@ -306,7 +306,7 @@ internal class QExpressions
                             {"12:04:59.123 0Nt", new[] {new QTime(43499123), new QTime(int.MinValue)}},
                             {"::", null},
                             {"{x+y}", new QLambda("{x+y}")},
-                            {"{x+y}[3]", new QLambda("{x+y}", new object[] {(long) 3})},
+                            {"{x+y}[3]", new QProjection( new object[] {new QLambda("{x+y}"), (long) 3})},
                             {"(enlist `a)!(enlist 1)", new QDictionary(new[] {"a"}, new long[] {1})},
                             {"1 2!`abc`cdefgh", new QDictionary(new long[] {1, 2}, new[] {"abc", "cdefgh"})},
                                                         {
diff --git a/qSharp/test/QExpressionsFunctions.out b/qSharp/test/QExpressionsFunctions.out
new file mode 100644
index 0000000..5b82c63
--- /dev/null
+++ b/qSharp/test/QExpressionsFunctions.out
@@ -0,0 +1,22 @@
+{x+y}[3]
+680200000064000A00050000007B782B797DF90300000000000000
+insert [1]
+6802000000661cf90100000000000000
+xbar
+6471000a00240000006b297b782a792064697620783a245b3136683d6162735b40785d3b226a2224783b785d7d
+not
+650f
+and
+6605
+md5
+68020000006610f9f1ffffffffffffff
+any
+6902000000651c6802000000660bf662
+save
+6a6471000a003c0000006b297b245b313d23703a605c3a2a7c605c3a783a2d3121783b7365745b783b2e202a705d3b2020207820303a2e682e74785b7020315d402e2a705d7d
+raze
+6b660c
+sums
+6c6601
+prev
+6d6600
\ No newline at end of file
diff --git a/qSharp/test/QReaderTest.cs b/qSharp/test/QReaderTest.cs
index 3f11881..aa2d029 100644
--- a/qSharp/test/QReaderTest.cs
+++ b/qSharp/test/QReaderTest.cs
@@ -14,6 +14,7 @@
 //   limitations under the License.
 //
 
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
@@ -21,6 +22,23 @@
 
 namespace qSharp.test
 {
+    internal class FunctionMock : QFunction
+    {
+        internal FunctionMock()
+            : base(0)
+        { }
+
+        public bool Equals(FunctionMock f)
+        {
+            return f is QFunction;
+        }
+
+        public override bool Equals(object o)
+        {
+            return o is QFunction;
+        }
+    }
+
     [TestFixture]
     internal class QReaderTest
     {
@@ -180,5 +198,66 @@ public void TestObjectDeserializationQ3()
                 }
             }
         }
+
+        [Test]
+        public void TestFunctionsDeserialization()
+        {
+            var expressions =
+                new QExpressions(new Dictionary<string, string> { { "q3", "..\\..\\test\\QExpressionsFunctions.out" } });
+            var reference = new Dictionary<string, object>
+            {
+                {"{x+y}[3]", new QProjection(new object[] { new QLambda("{x+y}"), 3L })},
+                {"insert [1]", new QProjection(new object[] { new FunctionMock(), 1L })},
+                {"xbar", new QLambda("k){x*y div x:$[16h=abs[@x];\"j\"$x;x]}")},
+                {"not", new FunctionMock()},
+                {"and", new FunctionMock()},
+                {"md5", new QProjection(new object[] { new FunctionMock(), -15L })},
+                {"any", new FunctionMock()},
+                {"save", new FunctionMock()},
+                {"raze", new FunctionMock()},
+                {"sums", new FunctionMock()},
+                {"prev", new FunctionMock()},
+            };
+           
+
+            foreach (string expr in expressions.GetExpressions("q3"))
+            {
+                var stream = new MemoryStream();
+                var writer = new BinaryWriter(stream);
+                var reader = new QReader(stream, Encoding.ASCII, QBasicConnection.DefaultMaxReadingChunk);
+
+                byte[] binaryExpr = expressions.GetBinaryExpression("q3", expr);
+                writer.Write((byte)1); // little endian
+                writer.Write((byte)0);
+                writer.Write((byte)0); // uncompressed
+                writer.Write((byte)0);
+                writer.Write(binaryExpr.Length + 8);
+                writer.Write(binaryExpr);
+                writer.Flush();
+                stream.Seek(0, SeekOrigin.Begin);
+
+                try
+                {
+                    object obj = reader.Read().Data;
+                    if (obj is QDictionary || obj is QTable || obj is QLambda || obj is QProjection || obj is QFunction)
+                    {
+                        // force usage of Equals method
+                        Assert.IsTrue(reference[expr].Equals(obj), "Deserialization failed for q expression: " + expr);
+                    }
+                    else
+                    {
+                        Assert.AreEqual(reference[expr], obj, "Deserialization failed for q expression: " + expr);
+                    }
+                }
+                catch (System.Exception e)
+                {
+                    Assert.Fail("Deserialization failed for q expression: " + expr + " caused by: " + e);
+                }
+                finally
+                {
+                    stream.Close();
+                }
+            }
+        }
     }
 }
\ No newline at end of file