diff --git a/etc/overview.cayra b/etc/overview.cayra
new file mode 100644
index 000000000..5a2ef5547
Binary files /dev/null and b/etc/overview.cayra differ
diff --git a/src/main/java/com/mysema/query/grammar/Grammar.java b/src/main/java/com/mysema/query/grammar/Grammar.java
index 462980986..cc430bbc8 100644
--- a/src/main/java/com/mysema/query/grammar/Grammar.java
+++ b/src/main/java/com/mysema/query/grammar/Grammar.java
@@ -5,6 +5,10 @@
  */
 package com.mysema.query.grammar;
 
+import static com.mysema.query.grammar.Grammar._binOp;
+import static com.mysema.query.grammar.Grammar._terOp;
+import static com.mysema.query.grammar.Grammar._unOp;
+
 import java.util.Collection;
 
 import com.mysema.query.grammar.Ops.*;
@@ -92,6 +96,12 @@ public class Grammar {
         op.left = left;
         return op;
     }
+    
+    static <OP, RT extends OP> Operation<RT> _unOp(Op<OP> type) {
+        OperationNoArg<OP, RT> op = new OperationNoArg<OP, RT>();
+        op.operator = type;
+        return op;
+    }
 
     public static <A extends Number> ExprNoEntity<A> add(Expr<A> left, A right) {
         return _binOp(OpNumber.ADD, left, _const(right));
diff --git a/src/main/java/com/mysema/query/grammar/Types.java b/src/main/java/com/mysema/query/grammar/Types.java
index 0f1652167..fba40a4fa 100644
--- a/src/main/java/com/mysema/query/grammar/Types.java
+++ b/src/main/java/com/mysema/query/grammar/Types.java
@@ -59,13 +59,6 @@ public class Types {
                 
     }
     
-    public interface ExprNonFinal<D> extends Expr<D> {
-        public <B extends D> ExprBoolean eq(B right);        
-        public <B extends D> ExprBoolean eq(Expr<B> right);
-        public <B extends D> ExprBoolean ne(B right);
-        public <B extends D> ExprBoolean ne(Expr<B> right);
-    }
-    
     public interface ExprBoolean extends ExprNoEntity<Boolean>{ 
         ExprBoolean and(ExprBoolean right);
         ExprBoolean or(ExprBoolean right);
@@ -74,21 +67,28 @@ public class Types {
     /**
      * Reference to an entity
      */
-    public interface ExprEntity<D> extends Expr<D>{}  
+    public interface ExprEntity<D> extends Expr<D>{}
+    
+    public interface ExprNoEntity<D> extends ExprNonFinal<D>{
+        public Expr<D> as(String to);
+    }  
+    
+    public static abstract class ExprNoEntityImpl<D> extends ExprNonFinalImpl<D> implements ExprNoEntity<D>{
+        public Expr<D> as(String to){return Grammar.as(this, to);}
+    }
+            
+    public interface ExprNonFinal<D> extends Expr<D> {
+        public <B extends D> ExprBoolean eq(B right);        
+        public <B extends D> ExprBoolean eq(Expr<B> right);
+        public <B extends D> ExprBoolean ne(B right);
+        public <B extends D> ExprBoolean ne(Expr<B> right);
+    }
     
     static abstract class ExprNonFinalImpl<D> implements ExprNonFinal<D>{
         public <B extends D> ExprBoolean eq(B right){return Grammar.eq(this, right);}        
         public <B extends D> ExprBoolean eq(Expr<B> right){return Grammar.eq(this, right);}
         public <B extends D> ExprBoolean ne(B right){return Grammar.ne(this, right);}
         public <B extends D> ExprBoolean ne(Expr<B> right){return Grammar.ne(this, right);}
-    }
-            
-    public interface ExprNoEntity<D> extends ExprNonFinal<D>{
-        public Expr<D> as(String to);
-    }
-    
-    public static abstract class ExprNoEntityImpl<D> extends ExprNonFinalImpl<D> implements ExprNoEntity<D>{
-        public Expr<D> as(String to){return Grammar.as(this, to);}
     }  
     
     public abstract static class Operation<RT> extends ExprNoEntityImpl<RT> {
@@ -109,7 +109,11 @@ public class Types {
     public static class OperationBinaryBoolean<L,R> extends OperationBinary<Boolean,Boolean,L,R> 
         implements ExprBoolean {    
         public ExprBoolean and(ExprBoolean right) {return Grammar.and(this, right);}
-        public ExprBoolean or(ExprBoolean right) {return Grammar.and(this, right);}
+        public ExprBoolean or(ExprBoolean right) {return Grammar.or(this, right);}
+    }
+    
+    public static class OperationNoArg<OP,RT extends OP> extends Operation<RT>{
+        public Op<OP> operator; 
     }
     
     public static class OperationTertiary<OP,RT extends OP,F,S,T> extends Operation<RT>{
diff --git a/src/main/java/com/mysema/query/grammar/Visitor.java b/src/main/java/com/mysema/query/grammar/Visitor.java
index 4ca073aed..5d3b31b2a 100644
--- a/src/main/java/com/mysema/query/grammar/Visitor.java
+++ b/src/main/java/com/mysema/query/grammar/Visitor.java
@@ -60,18 +60,20 @@ public abstract class Visitor<T extends Visitor<T>> {
     
     protected abstract void visit(Alias<?> expr);
     
-    protected abstract void visit(AliasNoEntity<?> expr);
-    
     protected abstract void visit(AliasCollection<?> expr);
     
     protected abstract void visit(AliasEntity<?> expr);
     
+    protected abstract void visit(AliasNoEntity<?> expr);
+    
     protected abstract void visit(ConstantExpr<?> expr);
     
     protected abstract void visit(OperationBinary<?,?,?,?> expr);
     
     protected abstract void visit(OperationBinaryBoolean<?,?> expr);
     
+    protected abstract void visit(OperationNoArg<?,?> expr);
+    
     protected abstract void visit(OperationTertiary<?,?,?,?,?> expr);
     
     protected abstract void visit(OperationTertiaryBoolean<?,?,?> expr);
@@ -84,10 +86,10 @@ public abstract class Visitor<T extends Visitor<T>> {
     
     protected abstract void visit(PathBoolean expr);
     
-    protected abstract void visit(PathEntityCollection<?> expr);
-    
     protected abstract void visit(PathEntity<?> expr);
     
+    protected abstract void visit(PathEntityCollection<?> expr);
+    
     protected abstract void visit(PathNoEntity<?> expr);
     
 }