diff --git a/src/main/java/org/dvare/expression/BaseExpressionVisitor.java b/src/main/java/org/dvare/expression/BaseExpressionVisitor.java
new file mode 100644
index 0000000..d65eaad
--- /dev/null
+++ b/src/main/java/org/dvare/expression/BaseExpressionVisitor.java
@@ -0,0 +1,1083 @@
+package org.dvare.expression;
+
+import org.dvare.expression.datatype.*;
+import org.dvare.expression.literal.*;
+import org.dvare.expression.operation.*;
+import org.dvare.expression.operation.aggregation.*;
+import org.dvare.expression.operation.arithmetic.*;
+import org.dvare.expression.operation.flow.*;
+import org.dvare.expression.operation.list.*;
+import org.dvare.expression.operation.logical.And;
+import org.dvare.expression.operation.logical.Implies;
+import org.dvare.expression.operation.logical.Not;
+import org.dvare.expression.operation.logical.OR;
+import org.dvare.expression.operation.predefined.*;
+import org.dvare.expression.operation.relational.*;
+import org.dvare.expression.operation.utility.*;
+import org.dvare.expression.veriable.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class BaseExpressionVisitor implements ExpressionVisitor<Expression> {
+    @Override
+    public Expression visit(FunctionExpression f) {
+        var name = f.name.accept(this);
+        var n = new FunctionExpression(name, f.getBinding());
+        var nps = transformedList(f.getParameters());
+        n.setParameters(nps);
+        return n;
+    }
+
+    @Override
+    public Expression visit(NamedExpression n) {
+        return new NamedExpression(n.getName());
+    }
+
+    @Override
+    public Expression visit(BooleanExpression b) {
+        return new BooleanExpression(b.getName(), b.isValue());
+    }
+
+    @Override
+    public Expression visit(BooleanListType bl) {
+        return new BooleanListType();
+    }
+
+    @Override
+    public Expression visit(BooleanType b) {
+        return new BooleanType();
+    }
+
+    @Override
+    public Expression visit(DateListType dl) {
+        return new DateListType();
+    }
+
+    @Override
+    public Expression visit(DateTimeListType dtl) {
+        return new DateTimeListType();
+    }
+
+    @Override
+    public Expression visit(ListType l) {
+        return new ListType(l.getDataType());
+    }
+
+    @Override
+    public Expression visit(DateTimeType dt) {
+        return new DateTimeType();
+    }
+
+    @Override
+    public Expression visit(DateType d) {
+        return new DateType();
+    }
+
+    @Override
+    public Expression visit(FloatListType fl) {
+        return new FloatListType();
+    }
+
+    @Override
+    public Expression visit(FloatType f) {
+        return new FloatType();
+    }
+
+    @Override
+    public Expression visit(IntegerListType il) {
+        return new IntegerListType();
+    }
+
+    @Override
+    public Expression visit(IntegerType i) {
+        return new IntegerType();
+    }
+
+    @Override
+    public Expression visit(NullType n) {
+        return new NullType();
+    }
+
+    @Override
+    public Expression visit(PairListType pl) {
+        return new PairListType();
+    }
+
+    @Override
+    public Expression visit(PairType p) {
+        return new PairType();
+    }
+
+    @Override
+    public Expression visit(RegexType r) {
+        return new RegexType();
+    }
+
+    @Override
+    public Expression visit(SimpleDateListType sdl) {
+        return new SimpleDateListType();
+    }
+
+    @Override
+    public Expression visit(SimpleDateType sd) {
+        return new SimpleDateType();
+    }
+
+    @Override
+    public Expression visit(StringListType sl) {
+        return new StringListType();
+    }
+
+    @Override
+    public Expression visit(StringType s) {
+        return new StringType();
+    }
+
+    @Override
+    public Expression visit(TripleListType tl) {
+        return new TripleListType();
+    }
+
+    @Override
+    public Expression visit(TripleType t) {
+        return new TripleType();
+    }
+
+    @Override
+    public Expression visit(BooleanLiteral b) {
+        return new BooleanLiteral(b.getValue());
+    }
+
+    @Override
+    public Expression visit(DateLiteral d) {
+        return new DateLiteral(d.getValue());
+    }
+
+    @Override
+    public Expression visit(DateTimeLiteral dt) {
+        return new DateTimeLiteral(dt.getValue());
+    }
+
+    @Override
+    public Expression visit(FloatLiteral f) {
+        return new FloatLiteral(f.getValue());
+    }
+
+    @Override
+    public Expression visit(IntegerLiteral i) {
+        return new IntegerLiteral(i.getValue());
+    }
+
+    @Override
+    public Expression visit(ListLiteral l) {
+        var nl = new ArrayList<>(l.getValue());
+        return new ListLiteral(nl, l.getType());
+    }
+
+    @Override
+    public Expression visit(NullLiteral<?> n) {
+        return new NullLiteral<>();
+    }
+
+    @Override
+    public Expression visit(PairLiteral p) {
+        return new PairLiteral(p.getValue());
+    }
+
+    @Override
+    public Expression visit(RegexLiteral r) {
+        return new RegexLiteral(r.getValue());
+    }
+
+    @Override
+    public Expression visit(SimpleDateLiteral sd) {
+        return new SimpleDateLiteral(sd.getValue());
+    }
+
+    @Override
+    public Expression visit(StringLiteral s) {
+        return new StringLiteral(s.getValue());
+    }
+
+    @Override
+    public Expression visit(TripleLiteral t) {
+        return new TripleLiteral(t.getValue());
+    }
+
+    @Override
+    public Expression visit(BooleanVariable b) {
+        var n = new BooleanVariable(b.getName(), b.getValue());
+        n.setOperandType(b.getOperandType());
+        return n;
+    }
+
+    @Override
+    public Expression visit(DateTimeVariable dt) {
+        var n = new DateTimeVariable(dt.getName(), dt.getValue());
+        n.setOperandType(dt.getOperandType());
+        return n;
+    }
+
+    @Override
+    public Expression visit(DateVariable d) {
+        var n = new DateVariable(d.getName(), d.getValue());
+        n.setOperandType(d.getOperandType());
+        return n;
+    }
+
+    @Override
+    public Expression visit(FloatVariable f) {
+        var n = new FloatVariable(f.getName(), f.getValue());
+        n.setOperandType(f.getOperandType());
+        return n;
+    }
+
+    @Override
+    public Expression visit(IntegerVariable i) {
+        var n = new IntegerVariable(i.getName(), i.getValue());
+        n.setOperandType(i.getOperandType());
+        return n;
+    }
+
+    @Override
+    public Expression visit(ListVariable l) {
+        var n = new ListVariable(l.getName(), l.getType());
+        if (l.getValue() != null) {
+            n.setValue(new ArrayList<>(l.getValue()));
+        }
+        n.setOperandType(l.getOperandType());
+        return n;
+    }
+
+    @Override
+    public Expression visit(PairVariable p) {
+        var n = new PairVariable(p.getName(), p.getValue());
+        n.setOperandType(p.getOperandType());
+        return n;
+    }
+
+    @Override
+    public Expression visit(RegexVariable r) {
+        var n = new RegexVariable(r.getName(), r.getValue());
+        n.setOperandType(r.getOperandType());
+        return n;
+    }
+
+    @Override
+    public Expression visit(SimpleDateVariable sd) {
+        var n = new SimpleDateVariable(sd.getName(), sd.getValue());
+        n.setOperandType(sd.getOperandType());
+        return n;
+    }
+
+    @Override
+    public Expression visit(StringVariable s) {
+        var n = new StringVariable(s.getName(), s.getValue());
+        n.setOperandType(s.getOperandType());
+        return n;
+    }
+
+    @Override
+    public Expression visit(TripleVariable t) {
+        var n = new TripleVariable(t.getName(), t.getValue());
+        n.setOperandType(t.getOperandType());
+        return n;
+    }
+
+    @Override
+    public Expression visit(AssignOperationExpression a) {
+        var n = new AssignOperationExpression();
+        setLeftRightOperandNotNull(a, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(CompositeOperationExpression c) {
+        var nes = transformedList(c.getExpressions());
+        return new CompositeOperationExpression(nes);
+    }
+
+    @Override
+    public Expression visit(IterationOperationExpression i) {
+        var n = new IterationOperationExpression(i.getOperationType());
+        setIterationOperation(i, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ListLiteralOperationENDExpression lle) {
+        var n = new ListLiteralOperationENDExpression();
+        setLeftRightOperandNotNull(lle, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ListLiteralOperationExpression ll) {
+        var n = new ListLiteralOperationExpression();
+        setListLiteralOperation(ll, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Maximum m) {
+        var n = new Maximum();
+        setAggregationOperation(m, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Mean m) {
+        var n = new Mean();
+        setAggregationOperation(m, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Median m) {
+        var n = new Median();
+        setAggregationOperation(m, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Minimum m) {
+        var n = new Minimum();
+        setAggregationOperation(m, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Mode m) {
+        var n = new Mode();
+        setAggregationOperation(m, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Sum s) {
+        var n = new Sum();
+        setAggregationOperation(s, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Add a) {
+        var n = new Add();
+        setArithmeticOperation(a, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Divide d) {
+        var n = new Divide();
+        setArithmeticOperation(d, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Max m) {
+        var n = new Max();
+        setArithmeticOperation(m, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Min m) {
+        var n = new Min();
+        setArithmeticOperation(m, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Multiply m) {
+        var n = new Multiply();
+        setArithmeticOperation(m, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Power p) {
+        var n = new Power();
+        setArithmeticOperation(p, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Subtract s) {
+        var n = new Subtract();
+        setArithmeticOperation(s, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ELSE e) {
+        var n = new ELSE();
+        setConditionOperation(e, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ENDIF e) {
+        var n = new ENDIF();
+        setConditionOperation(e, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(IF i) {
+        var n = new IF();
+        setConditionOperation(i, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(TernaryOperation t) {
+        var n = new TernaryOperation();
+        setConditionOperation(t, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(THEN t) {
+        var n = new THEN();
+        setConditionOperation(t, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(CombinationExists ce) {
+        var n = new CombinationExists();
+        setMatch(ce, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(DistinctOperation d) {
+        var n = new DistinctOperation();
+        setLeftOperandNotNull(d, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(FilterOperation f) {
+        var n = new FilterOperation();
+        setAggregationOperation(f, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(First f) {
+        var n = new First();
+        setAggregationOperation(f, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(GetItem gi) {
+        var n = new GetItem();
+        setAggregationOperation(gi, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(HasItem hi) {
+        var n = new HasItem();
+        setAggregationOperation(hi, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(InsideCombination ic) {
+        var n = new InsideCombination();
+        setMatch(ic, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(InsideExistsCombination iec) {
+        var n = new InsideExistsCombination();
+        setMatch(iec, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(IsEmpty ie) {
+        var n = new IsEmpty();
+        setAggregationOperation(ie, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ItemPosition ip) {
+        var n = new ItemPosition();
+        setAggregationOperation(ip, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(KeysOperation k) {
+        var n = new KeysOperation();
+        setAggregationOperation(k, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Last l) {
+        var n = new Last();
+        setAggregationOperation(l, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(MapOperation m) {
+        var n = new MapOperation();
+        setAggregationOperation(m, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Match m) {
+        var n = new Match();
+        setMatch(m, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(MiddlesOperation m) {
+        var n = new MiddlesOperation();
+        setAggregationOperation(m, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(NotEmpty ne) {
+        var n = new NotEmpty();
+        setAggregationOperation(ne, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(PairOperation p) {
+        var n = new PairOperation();
+        setAggregationOperation(p, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(SizeOperation s) {
+        var n = new SizeOperation();
+        setAggregationOperation(s, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(SortOperation s) {
+        var n = new SortOperation();
+        setAggregationOperation(s, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(TripleOperation t) {
+        var n = new TripleOperation();
+        setAggregationOperation(t, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ValuesOperation v) {
+        var n = new ValuesOperation();
+        setAggregationOperation(v, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(And a) {
+        var n = new And();
+        setLeftRightOperandNotNull(a, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Implies i) {
+        var n = new Implies();
+        setLeftRightOperandNotNull(i, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Not n) {
+        var ne = new Not();
+        setRightOperandNotNull(n, ne);
+        return ne;
+    }
+
+    @Override
+    public Expression visit(OR o) {
+        var n = new OR();
+        setLeftRightOperandNotNull(o, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(AddDays ad) {
+        var n = new AddDays();
+        setChainOperation(ad, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(AddMonths am) {
+        var n = new AddMonths();
+        setChainOperation(am, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(AddYears ay) {
+        var n = new AddYears();
+        setChainOperation(ay, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Append a) {
+        var n = new Append();
+        setChainOperation(a, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Contains c) {
+        var n = new Contains();
+        setChainOperation(c, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(EndsWith ew) {
+        var n = new EndsWith();
+        setChainOperation(ew, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(GetYear gy) {
+        var n = new GetYear();
+        setChainOperation(gy, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Length l) {
+        var n = new Length();
+        setChainOperation(l, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Prepend p) {
+        var n = new Prepend();
+        setChainOperation(p, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(SetDay sd) {
+        var n = new SetDay();
+        setChainOperation(sd, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(SetMonth sm) {
+        var n = new SetMonth();
+        setChainOperation(sm, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(SetYear sy) {
+        var n = new SetYear();
+        setChainOperation(sy, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(StartsWith sw) {
+        var n = new StartsWith();
+        setChainOperation(sw, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(SubDays sd) {
+        var n = new SubDays();
+        setChainOperation(sd, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(SubMonths sm) {
+        var n = new SubMonths();
+        setChainOperation(sm, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(SubYears sy) {
+        var n = new SubYears();
+        setChainOperation(sy, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Substring s) {
+        var n = new Substring();
+        setChainOperation(s, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ToBoolean tb) {
+        var n = new ToBoolean();
+        setChainOperation(tb, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ToDate td) {
+        var n = new ToDate();
+        setChainOperation(td, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ToInteger ti) {
+        var n = new ToInteger();
+        setChainOperation(ti, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ToKey tk) {
+        var n = new ToKey();
+        setChainOperation(tk, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ToLeft tl) {
+        var n = new ToLeft();
+        setChainOperation(tl, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ToMiddle tm) {
+        var n = new ToMiddle();
+        setChainOperation(tm, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ToPair tp) {
+        var n = new ToPair();
+        setChainOperation(tp, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ToRight tr) {
+        var n = new ToRight();
+        setChainOperation(tr, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ToString ts) {
+        var n = new ToString();
+        setChainOperation(ts, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ToTriple tt) {
+        var n = new ToTriple();
+        setChainOperation(tt, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ToValue tv) {
+        var n = new ToValue();
+        setChainOperation(tv, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Trim t) {
+        var n = new Trim();
+        setChainOperation(t, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Between b) {
+        var n = new Between();
+        setRelationalOperator(b, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Equals e) {
+        var n = new Equals();
+        setRelationalOperator(e, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(GreaterEqual ge) {
+        var n = new GreaterEqual();
+        setRelationalOperator(ge, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(GreaterThan gt) {
+        var n = new GreaterThan();
+        setRelationalOperator(gt, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(In i) {
+        var n = new In();
+        setRelationalOperator(i, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(LessEqual le) {
+        var n = new LessEqual();
+        setRelationalOperator(le, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(LessThan lt) {
+        var n = new LessThan();
+        setRelationalOperator(lt, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(NotEquals ne) {
+        var n = new NotEquals();
+        setRelationalOperator(ne, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(NotIn ni) {
+        var n = new NotIn();
+        setRelationalOperator(ni, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(DateOperation d) {
+        var n = new DateOperation();
+        setLeftRightOperandNotNull(d, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(DateTimeOperation dt) {
+        var n = new DateTimeOperation();
+        setLeftRightOperandNotNull(dt, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(DefOperation d) {
+        var n = new DefOperation();
+        setLeftRightOperandNotNull(d, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(EndForAll efa) {
+        var n = new EndForAll();
+        setIterationOperation(efa, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(EndForEach efe) {
+        var n = new EndForEach();
+        setIterationOperation(efe, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ExpressionSeparator es) {
+        var n = new ExpressionSeparator();
+        setLeftRightOperandNotNull(es, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ForAll fa) {
+        var n = new ForAll();
+        setIterationOperation(fa, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(ForEach fe) {
+        var n = new ForEach();
+        setIterationOperation(fe, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Function f) {
+        var n = new Function();
+        setLeftRightOperandNotNull(f, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Invoke i) {
+        var n = new Invoke();
+        setLeftRightOperandNotNull(i, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(LeftPriority lp) {
+        var n = new LeftPriority();
+        setLeftRightOperandNotNull(lp, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(LetOperation l) {
+        var n = new LetOperation();
+        setLeftRightOperandNotNull(l, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(PrintOperation p) {
+        var n = new PrintOperation();
+        setLeftRightOperandNotNull(p, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(RightPriority rp) {
+        var n = new RightPriority();
+        setLeftRightOperandNotNull(rp, n);
+        return n;
+    }
+
+    @Override
+    public Expression visit(Today t) {
+        var n = new Today();
+        setLeftRightOperandNotNull(t, n);
+        return n;
+    }
+
+    protected void setLeftRightOperandNotNull(OperationExpression o, OperationExpression n) {
+        setLeftOperandNotNull(o, n);
+        setRightOperandNotNull(o, n);
+    }
+
+    protected void setLeftOperandNotNull(OperationExpression o, OperationExpression n) {
+        if (o.getLeftOperand() != null) {
+            n.setLeftOperand(o.getLeftOperand().accept(this));
+        }
+    }
+
+    protected void setRightOperandNotNull(OperationExpression o, OperationExpression n) {
+        if (o.getRightOperand() != null) {
+            n.setRightOperand(o.getRightOperand().accept(this));
+        }
+    }
+
+    protected void setListLiteralOperation(ListLiteralOperationExpression o, ListLiteralOperationExpression n) {
+        if (o.getRightListOperand() != null) {
+            var nrl = transformedList(o.getRightListOperand());
+            n.setRightListOperand(nrl);
+        }
+    }
+
+    protected void setAggregationOperation(AggregationOperationExpression o, AggregationOperationExpression n) {
+        setLeftOperandNotNull(o, n);
+        if (o.getRightListOperand() != null) {
+            var rls = transformedList(o.getRightListOperand());
+            n.setRightListOperand(rls);
+        }
+    }
+
+    protected void setArithmeticOperation(ArithmeticOperationExpression o, ArithmeticOperationExpression n) {
+        setLeftRightOperandNotNull(o, n);
+    }
+
+    protected void setConditionOperation(ConditionOperationExpression o, ConditionOperationExpression n) {
+        setLeftRightOperandNotNull(o, n);
+
+        if (o.getCondition() != null) {
+            n.setCondition(o.getCondition().accept(this));
+        }
+
+        if (o.getThenOperand() != null) {
+            n.setThenOperand(o.getThenOperand().accept(this));
+        }
+
+        if (o.getElseOperand() != null) {
+            n.setElseOperand(o.getElseOperand().accept(this));
+        }
+    }
+
+    protected void setMatch(Match o, Match n) {
+        if (o.getLeftListOperand() != null) {
+            var lls = transformedList(o.getLeftListOperand());
+            n.setLeftListOperand(lls);
+        }
+    }
+
+    protected void setChainOperation(ChainOperationExpression o, ChainOperationExpression n) {
+        setLeftOperandNotNull(o, n);
+        if (o.getRightListOperand() != null) {
+            var rls = transformedList(o.getRightListOperand());
+            n.setRightListOperand(rls);
+        }
+    }
+
+    protected void setRelationalOperator(RelationalOperationExpression o, RelationalOperationExpression n) {
+        setLeftRightOperandNotNull(o, n);
+    }
+
+    protected void setIterationOperation(IterationOperationExpression o, IterationOperationExpression n) {
+        if (o.getReferenceContext() != null) {
+            var rc = o.getReferenceContext().accept(this);
+            n.setReferenceContext(rc);
+        }
+        if (o.getDerivedContext() != null) {
+            var dc = o.getDerivedContext().accept(this);
+            n.setDerivedContext((NamedExpression) dc);
+        }
+        setLeftRightOperandNotNull(o, n);
+    }
+
+    protected List<Expression> transformedList(List<Expression> l) {
+        return l.stream()
+                .map(e -> e.accept(this))
+                .collect(Collectors.toList());
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/BooleanExpression.java b/src/main/java/org/dvare/expression/BooleanExpression.java
index 29f65c1..55241de 100644
--- a/src/main/java/org/dvare/expression/BooleanExpression.java
+++ b/src/main/java/org/dvare/expression/BooleanExpression.java
@@ -35,6 +35,10 @@ public LiteralExpression interpret(InstancesBinding instancesBinding) throws Int
         return new BooleanLiteral(value);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
     public String getName() {
         return name;
diff --git a/src/main/java/org/dvare/expression/Expression.java b/src/main/java/org/dvare/expression/Expression.java
index bf19daf..47c390e 100644
--- a/src/main/java/org/dvare/expression/Expression.java
+++ b/src/main/java/org/dvare/expression/Expression.java
@@ -15,6 +15,7 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new BooleanLiteral(false);
     }
 
+    public abstract <T> T accept(ExpressionVisitor<T> v);
 }
 
 
diff --git a/src/main/java/org/dvare/expression/ExpressionVisitor.java b/src/main/java/org/dvare/expression/ExpressionVisitor.java
new file mode 100644
index 0000000..dd07359
--- /dev/null
+++ b/src/main/java/org/dvare/expression/ExpressionVisitor.java
@@ -0,0 +1,193 @@
+package org.dvare.expression;
+
+import org.dvare.expression.datatype.*;
+import org.dvare.expression.literal.*;
+import org.dvare.expression.operation.*;
+import org.dvare.expression.operation.aggregation.*;
+import org.dvare.expression.operation.arithmetic.*;
+import org.dvare.expression.operation.flow.*;
+import org.dvare.expression.operation.list.*;
+import org.dvare.expression.operation.logical.And;
+import org.dvare.expression.operation.logical.Implies;
+import org.dvare.expression.operation.logical.Not;
+import org.dvare.expression.operation.logical.OR;
+import org.dvare.expression.operation.predefined.*;
+import org.dvare.expression.operation.relational.*;
+import org.dvare.expression.operation.utility.*;
+import org.dvare.expression.veriable.*;
+
+public interface ExpressionVisitor<T> {
+    // basic
+    T visit(FunctionExpression f);
+    T visit(NamedExpression n);
+    T visit(BooleanExpression b);
+
+    // datatype
+    T visit(BooleanListType bl);
+    T visit(BooleanType b);
+    T visit(DateListType dl);
+    T visit(DateTimeListType dtl);
+    T visit(ListType l);
+    T visit(DateTimeType dt);
+    T visit(DateType d);
+    T visit(FloatListType fl);
+    T visit(FloatType f);
+    T visit(IntegerListType il);
+    T visit(IntegerType i);
+    T visit(NullType n);
+    T visit(PairListType pl);
+    T visit(PairType p);
+    T visit(RegexType r);
+    T visit(SimpleDateListType sdl);
+    T visit(SimpleDateType sd);
+    T visit(StringListType sl);
+    T visit(StringType s);
+    T visit(TripleListType tl);
+    T visit(TripleType t);
+
+    // literal
+    T visit(BooleanLiteral b);
+    T visit(DateLiteral d);
+    T visit(DateTimeLiteral dt);
+    T visit(FloatLiteral f);
+    T visit(IntegerLiteral i);
+    T visit(ListLiteral l);
+    T visit(NullLiteral<?> n);
+    T visit(PairLiteral p);
+    T visit(RegexLiteral r);
+    T visit(SimpleDateLiteral sd);
+    T visit(StringLiteral s);
+    T visit(TripleLiteral t);
+
+    // variable
+    T visit(BooleanVariable b);
+    T visit(DateTimeVariable dt);
+    T visit(DateVariable d);
+    T visit(FloatVariable f);
+    T visit(IntegerVariable i);
+    T visit(ListVariable l);
+    T visit(PairVariable p);
+    T visit(RegexVariable r);
+    T visit(SimpleDateVariable sd);
+    T visit(StringVariable s);
+    T visit(TripleVariable t);
+
+    // operation
+    T visit(AssignOperationExpression a);
+    T visit(CompositeOperationExpression c);
+    T visit(IterationOperationExpression i);
+    T visit(ListLiteralOperationENDExpression lle);
+    T visit(ListLiteralOperationExpression ll);
+
+    // aggregation
+    T visit(Maximum m);
+    T visit(Mean m);
+    T visit(Median m);
+    T visit(Minimum m);
+    T visit(Mode m);
+    T visit(Sum s);
+
+    // arithmetic
+    T visit(Add a);
+    T visit(Divide d);
+    T visit(Max m);
+    T visit(Min m);
+    T visit(Multiply m);
+    T visit(Power p);
+    T visit(Subtract s);
+
+    // flow
+    T visit(ELSE e);
+    T visit(ENDIF e);
+    T visit(IF i);
+    T visit(TernaryOperation t);
+    T visit(THEN t);
+
+    // list
+    T visit(CombinationExists ce);
+    T visit(DistinctOperation d);
+    T visit(FilterOperation f);
+    T visit(First f);
+    T visit(GetItem gi);
+    T visit(HasItem hi);
+    T visit(InsideCombination ic);
+    T visit(InsideExistsCombination iec);
+    T visit(IsEmpty ie);
+    T visit(ItemPosition ip);
+    T visit(KeysOperation k);
+    T visit(Last l);
+    T visit(MapOperation m);
+    T visit(Match m);
+    T visit(MiddlesOperation m);
+    T visit(NotEmpty ne);
+    T visit(PairOperation p);
+    T visit(SizeOperation s);
+    T visit(SortOperation s);
+    T visit(TripleOperation t);
+    T visit(ValuesOperation v);
+
+    // logical
+    T visit(And a);
+    T visit(Implies i);
+    T visit(Not n);
+    T visit(OR o);
+
+    // predefined
+    T visit(AddDays ad);
+    T visit(AddMonths am);
+    T visit(AddYears ay);
+    T visit(Append a);
+    T visit(Contains c);
+    T visit(EndsWith ew);
+    T visit(GetYear gy);
+    T visit(Length l);
+    T visit(Prepend p);
+    T visit(SetDay sd);
+    T visit(SetMonth sm);
+    T visit(SetYear sy);
+    T visit(StartsWith sw);
+    T visit(SubDays sd);
+    T visit(SubMonths sm);
+    T visit(SubYears sy);
+    T visit(Substring s);
+    T visit(ToBoolean tb);
+    T visit(ToDate td);
+    T visit(ToInteger ti);
+    T visit(ToKey tk);
+    T visit(ToLeft tl);
+    T visit(ToMiddle tm);
+    T visit(ToPair tp);
+    T visit(ToRight tr);
+    T visit(ToString ts);
+    T visit(ToTriple tt);
+    T visit(ToValue tv);
+    T visit(Trim t);
+
+    // relational
+    T visit(Between b);
+    T visit(Equals e);
+    T visit(GreaterEqual ge);
+    T visit(GreaterThan gt);
+    T visit(In i);
+    T visit(LessEqual le);
+    T visit(LessThan lt);
+    T visit(NotEquals ne);
+    T visit(NotIn ni);
+
+    // utility
+    T visit(DateOperation d);
+    T visit(DateTimeOperation dt);
+    T visit(DefOperation d);
+    T visit(EndForAll efa);
+    T visit(EndForEach efe);
+    T visit(ExpressionSeparator es);
+    T visit(ForAll fa);
+    T visit(ForEach fe);
+    T visit(Function f);
+    T visit(Invoke i);
+    T visit(LeftPriority lp);
+    T visit(LetOperation l);
+    T visit(PrintOperation p);
+    T visit(RightPriority rp);
+    T visit(Today t);
+}
diff --git a/src/main/java/org/dvare/expression/FunctionExpression.java b/src/main/java/org/dvare/expression/FunctionExpression.java
index 9f3366e..e0f201d 100644
--- a/src/main/java/org/dvare/expression/FunctionExpression.java
+++ b/src/main/java/org/dvare/expression/FunctionExpression.java
@@ -61,5 +61,8 @@ public void setBinding(FunctionBinding binding) {
         this.binding = binding;
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/NamedExpression.java b/src/main/java/org/dvare/expression/NamedExpression.java
index 6b1ddbf..3b52c45 100644
--- a/src/main/java/org/dvare/expression/NamedExpression.java
+++ b/src/main/java/org/dvare/expression/NamedExpression.java
@@ -36,5 +36,8 @@ public void setName(String name) {
         this.name = name;
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/BooleanListType.java b/src/main/java/org/dvare/expression/datatype/BooleanListType.java
index c432bd5..f2f479b 100644
--- a/src/main/java/org/dvare/expression/datatype/BooleanListType.java
+++ b/src/main/java/org/dvare/expression/datatype/BooleanListType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
 import org.dvare.expression.operation.relational.NotEquals;
@@ -30,4 +31,9 @@ public boolean equal(LiteralExpression<?> left, LiteralExpression<?> right) {
     public boolean notEqual(LiteralExpression<?> left, LiteralExpression<?> right) {
         return super.notEqual(left, right);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/BooleanType.java b/src/main/java/org/dvare/expression/datatype/BooleanType.java
index 0f6c794..b4bc684 100644
--- a/src/main/java/org/dvare/expression/datatype/BooleanType.java
+++ b/src/main/java/org/dvare/expression/datatype/BooleanType.java
@@ -2,6 +2,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
 import org.dvare.expression.operation.relational.In;
@@ -76,4 +77,8 @@ private List<Boolean> buildIntegerBoolean(List<Object> tempValues) {
         return values;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/datatype/DateListType.java b/src/main/java/org/dvare/expression/datatype/DateListType.java
index d7a0dbb..8f28dcc 100644
--- a/src/main/java/org/dvare/expression/datatype/DateListType.java
+++ b/src/main/java/org/dvare/expression/datatype/DateListType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
@@ -40,4 +41,9 @@ public boolean equal(LiteralExpression<?> left, LiteralExpression<?> right) {
     public boolean notEqual(LiteralExpression<?> left, LiteralExpression<?> right) {
         return !equal(left, right);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/DateTimeListType.java b/src/main/java/org/dvare/expression/datatype/DateTimeListType.java
index d7dd8ba..0017d02 100644
--- a/src/main/java/org/dvare/expression/datatype/DateTimeListType.java
+++ b/src/main/java/org/dvare/expression/datatype/DateTimeListType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
@@ -40,4 +41,9 @@ public boolean equal(LiteralExpression<?> left, LiteralExpression<?> right) {
     public boolean notEqual(LiteralExpression<?> left, LiteralExpression<?> right) {
         return !equal(left, right);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/DateTimeType.java b/src/main/java/org/dvare/expression/datatype/DateTimeType.java
index 4c39c72..6b0e54a 100644
--- a/src/main/java/org/dvare/expression/datatype/DateTimeType.java
+++ b/src/main/java/org/dvare/expression/datatype/DateTimeType.java
@@ -2,6 +2,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.*;
 
@@ -104,4 +105,8 @@ public boolean between(LiteralExpression<?> left, LiteralExpression<?> right) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/DateType.java b/src/main/java/org/dvare/expression/datatype/DateType.java
index c531fd8..893c541 100644
--- a/src/main/java/org/dvare/expression/datatype/DateType.java
+++ b/src/main/java/org/dvare/expression/datatype/DateType.java
@@ -2,6 +2,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.arithmetic.Subtract;
 import org.dvare.expression.operation.relational.*;
@@ -135,4 +136,8 @@ public LocalDate sub(LiteralExpression<?> left, LiteralExpression<?> right) {
 
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/FloatListType.java b/src/main/java/org/dvare/expression/datatype/FloatListType.java
index 0cc7c8a..5e85e67 100644
--- a/src/main/java/org/dvare/expression/datatype/FloatListType.java
+++ b/src/main/java/org/dvare/expression/datatype/FloatListType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
 import org.dvare.expression.operation.relational.In;
@@ -80,4 +81,9 @@ private List<Float> buildFloatList(List<?> tempValues) {
         }
         return values;
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/FloatType.java b/src/main/java/org/dvare/expression/datatype/FloatType.java
index 408c4ad..3bda6b4 100644
--- a/src/main/java/org/dvare/expression/datatype/FloatType.java
+++ b/src/main/java/org/dvare/expression/datatype/FloatType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.aggregation.Maximum;
 import org.dvare.expression.operation.aggregation.Minimum;
@@ -234,6 +235,11 @@ private List<Float> buildFloatList(List<Object> tempValues) {
         }
         return values;
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
 
 
diff --git a/src/main/java/org/dvare/expression/datatype/IntegerListType.java b/src/main/java/org/dvare/expression/datatype/IntegerListType.java
index 2e6040b..314c988 100644
--- a/src/main/java/org/dvare/expression/datatype/IntegerListType.java
+++ b/src/main/java/org/dvare/expression/datatype/IntegerListType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
 import org.dvare.expression.operation.relational.In;
@@ -80,4 +81,9 @@ private List<Integer> buildIntegerList(List<?> tempValues) {
         }
         return values;
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/IntegerType.java b/src/main/java/org/dvare/expression/datatype/IntegerType.java
index 5641d51..1d47fd4 100644
--- a/src/main/java/org/dvare/expression/datatype/IntegerType.java
+++ b/src/main/java/org/dvare/expression/datatype/IntegerType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.aggregation.Maximum;
 import org.dvare.expression.operation.aggregation.Minimum;
@@ -234,4 +235,9 @@ private List<Integer> buildIntegerList(List<?> tempValues) {
         }
         return values;
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/ListType.java b/src/main/java/org/dvare/expression/datatype/ListType.java
index a0cd56b..cfc04b8 100644
--- a/src/main/java/org/dvare/expression/datatype/ListType.java
+++ b/src/main/java/org/dvare/expression/datatype/ListType.java
@@ -2,6 +2,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
@@ -68,5 +69,9 @@ public boolean notIn(LiteralExpression<?> left, LiteralExpression<?> right) {
         return !in(left, right);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
 
diff --git a/src/main/java/org/dvare/expression/datatype/NullType.java b/src/main/java/org/dvare/expression/datatype/NullType.java
index b460adf..a45c4ab 100644
--- a/src/main/java/org/dvare/expression/datatype/NullType.java
+++ b/src/main/java/org/dvare/expression/datatype/NullType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.NullLiteral;
@@ -107,4 +108,8 @@ public Object sub(LiteralExpression<?> left, LiteralExpression<?> right) {
         return null;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/PairListType.java b/src/main/java/org/dvare/expression/datatype/PairListType.java
index c3c91e7..feee13b 100644
--- a/src/main/java/org/dvare/expression/datatype/PairListType.java
+++ b/src/main/java/org/dvare/expression/datatype/PairListType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
 import org.dvare.expression.operation.relational.NotEquals;
@@ -30,4 +31,9 @@ public boolean equal(LiteralExpression<?> left, LiteralExpression<?> right) {
     public boolean notEqual(LiteralExpression<?> left, LiteralExpression<?> right) {
         return super.notEqual(left, right);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/PairType.java b/src/main/java/org/dvare/expression/datatype/PairType.java
index 236c353..8d68a3b 100644
--- a/src/main/java/org/dvare/expression/datatype/PairType.java
+++ b/src/main/java/org/dvare/expression/datatype/PairType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
 import org.dvare.expression.operation.relational.NotEquals;
@@ -38,4 +39,8 @@ public boolean notEqual(LiteralExpression<?> left, LiteralExpression<?> right) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/RegexType.java b/src/main/java/org/dvare/expression/datatype/RegexType.java
index a5d3e11..abd1e98 100644
--- a/src/main/java/org/dvare/expression/datatype/RegexType.java
+++ b/src/main/java/org/dvare/expression/datatype/RegexType.java
@@ -2,6 +2,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
 import org.dvare.expression.operation.relational.In;
@@ -76,4 +77,8 @@ public boolean notIn(LiteralExpression<?> left, LiteralExpression<?> right) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/datatype/SimpleDateListType.java b/src/main/java/org/dvare/expression/datatype/SimpleDateListType.java
index 702cc93..e66cf67 100644
--- a/src/main/java/org/dvare/expression/datatype/SimpleDateListType.java
+++ b/src/main/java/org/dvare/expression/datatype/SimpleDateListType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
@@ -40,4 +41,9 @@ public boolean equal(LiteralExpression<?> left, LiteralExpression<?> right) {
     public boolean notEqual(LiteralExpression<?> left, LiteralExpression<?> right) {
         return !equal(left, right);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/SimpleDateType.java b/src/main/java/org/dvare/expression/datatype/SimpleDateType.java
index 6a01750..5cef19a 100644
--- a/src/main/java/org/dvare/expression/datatype/SimpleDateType.java
+++ b/src/main/java/org/dvare/expression/datatype/SimpleDateType.java
@@ -2,6 +2,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.arithmetic.Subtract;
 import org.dvare.expression.operation.relational.*;
@@ -118,4 +119,8 @@ public Date sub(LiteralExpression<?> left, LiteralExpression<?> right) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/datatype/StringListType.java b/src/main/java/org/dvare/expression/datatype/StringListType.java
index 507e2f1..faddcab 100644
--- a/src/main/java/org/dvare/expression/datatype/StringListType.java
+++ b/src/main/java/org/dvare/expression/datatype/StringListType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
 import org.dvare.expression.operation.relational.In;
@@ -72,4 +73,9 @@ private List<String> buildStringList(List<?> tempValues) {
         }
         return values;
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/StringType.java b/src/main/java/org/dvare/expression/datatype/StringType.java
index 0214a40..06e347d 100644
--- a/src/main/java/org/dvare/expression/datatype/StringType.java
+++ b/src/main/java/org/dvare/expression/datatype/StringType.java
@@ -3,6 +3,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.*;
 import org.dvare.util.TrimString;
@@ -135,4 +136,8 @@ public boolean notIn(LiteralExpression<?> left, LiteralExpression<?> right) {
         return !in(left, right);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/TripleListType.java b/src/main/java/org/dvare/expression/datatype/TripleListType.java
index 44ca21a..425d9bc 100644
--- a/src/main/java/org/dvare/expression/datatype/TripleListType.java
+++ b/src/main/java/org/dvare/expression/datatype/TripleListType.java
@@ -2,6 +2,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
 import org.dvare.expression.operation.relational.NotEquals;
@@ -29,4 +30,9 @@ public boolean equal(LiteralExpression<?> left, LiteralExpression<?> right) {
     public boolean notEqual(LiteralExpression<?> left, LiteralExpression<?> right) {
         return super.notEqual(left, right);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/datatype/TripleType.java b/src/main/java/org/dvare/expression/datatype/TripleType.java
index 54b646a..a00e4d1 100644
--- a/src/main/java/org/dvare/expression/datatype/TripleType.java
+++ b/src/main/java/org/dvare/expression/datatype/TripleType.java
@@ -2,6 +2,7 @@
 
 import org.dvare.annotations.OperationMapping;
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.relational.Equals;
 import org.dvare.expression.operation.relational.NotEquals;
@@ -37,4 +38,8 @@ public boolean notEqual(LiteralExpression<?> left, LiteralExpression<?> right) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/BooleanLiteral.java b/src/main/java/org/dvare/expression/literal/BooleanLiteral.java
index 6d9962b..708c12f 100644
--- a/src/main/java/org/dvare/expression/literal/BooleanLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/BooleanLiteral.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.literal;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.BooleanType;
 
 public class BooleanLiteral extends LiteralExpression<Boolean> {
@@ -8,4 +9,9 @@ public class BooleanLiteral extends LiteralExpression<Boolean> {
     public BooleanLiteral(Boolean value) {
         super(value, BooleanType.class);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/DateLiteral.java b/src/main/java/org/dvare/expression/literal/DateLiteral.java
index a3f44b6..b9a0b84 100644
--- a/src/main/java/org/dvare/expression/literal/DateLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/DateLiteral.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.literal;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DateType;
 
 import java.time.LocalDate;
@@ -10,4 +11,9 @@ public class DateLiteral extends LiteralExpression<LocalDate> {
     public DateLiteral(LocalDate value) {
         super(value, DateType.class);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/DateTimeLiteral.java b/src/main/java/org/dvare/expression/literal/DateTimeLiteral.java
index 3014891..01e3284 100644
--- a/src/main/java/org/dvare/expression/literal/DateTimeLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/DateTimeLiteral.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.literal;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DateTimeType;
 
 import java.time.LocalDateTime;
@@ -11,4 +12,9 @@ public class DateTimeLiteral extends LiteralExpression<LocalDateTime> {
     public DateTimeLiteral(LocalDateTime value) {
         super(value, DateTimeType.class);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/FloatLiteral.java b/src/main/java/org/dvare/expression/literal/FloatLiteral.java
index 2d1f7ce..1a4b8bb 100644
--- a/src/main/java/org/dvare/expression/literal/FloatLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/FloatLiteral.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.literal;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.FloatType;
 
 public class FloatLiteral extends LiteralExpression<Float> {
@@ -9,4 +10,9 @@ public class FloatLiteral extends LiteralExpression<Float> {
     public FloatLiteral(Float value) {
         super(value, FloatType.class);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/IntegerLiteral.java b/src/main/java/org/dvare/expression/literal/IntegerLiteral.java
index eeca84a..2c10313 100644
--- a/src/main/java/org/dvare/expression/literal/IntegerLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/IntegerLiteral.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.literal;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.IntegerType;
 
 public class IntegerLiteral extends LiteralExpression<Integer> {
@@ -11,4 +12,8 @@ public IntegerLiteral(Integer value) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/ListLiteral.java b/src/main/java/org/dvare/expression/literal/ListLiteral.java
index 729dd8c..f3147a0 100644
--- a/src/main/java/org/dvare/expression/literal/ListLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/ListLiteral.java
@@ -2,6 +2,7 @@
 
 
 import org.dvare.annotations.Type;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.*;
 
 import java.util.List;
@@ -52,4 +53,8 @@ public Class<? extends DataTypeExpression> getListType() {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/NullLiteral.java b/src/main/java/org/dvare/expression/literal/NullLiteral.java
index 47b3dc4..4846337 100644
--- a/src/main/java/org/dvare/expression/literal/NullLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/NullLiteral.java
@@ -1,9 +1,15 @@
 package org.dvare.expression.literal;
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.NullType;
 
 public class NullLiteral<T> extends LiteralExpression<Object> {
     public NullLiteral() {
         super(null, NullType.class);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/PairLiteral.java b/src/main/java/org/dvare/expression/literal/PairLiteral.java
index 4bcff7c..df88497 100644
--- a/src/main/java/org/dvare/expression/literal/PairLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/PairLiteral.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.literal;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.PairType;
 import org.dvare.util.Pair;
 
@@ -10,4 +11,8 @@ public PairLiteral(Pair<?, ?> value) {
         super(value, PairType.class);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/RegexLiteral.java b/src/main/java/org/dvare/expression/literal/RegexLiteral.java
index 639cc19..8429c9e 100644
--- a/src/main/java/org/dvare/expression/literal/RegexLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/RegexLiteral.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.literal;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.RegexType;
 
 public class RegexLiteral extends LiteralExpression<String> {
@@ -8,4 +9,9 @@ public class RegexLiteral extends LiteralExpression<String> {
     public RegexLiteral(String value) {
         super(value, RegexType.class);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/SimpleDateLiteral.java b/src/main/java/org/dvare/expression/literal/SimpleDateLiteral.java
index 146b464..6d8b470 100644
--- a/src/main/java/org/dvare/expression/literal/SimpleDateLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/SimpleDateLiteral.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.literal;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.SimpleDateType;
 
 import java.util.Date;
@@ -10,4 +11,9 @@ public class SimpleDateLiteral extends LiteralExpression<Date> {
     public SimpleDateLiteral(Date value) {
         super(value, SimpleDateType.class);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/StringLiteral.java b/src/main/java/org/dvare/expression/literal/StringLiteral.java
index ef6c32d..0027190 100644
--- a/src/main/java/org/dvare/expression/literal/StringLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/StringLiteral.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.literal;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.StringType;
 
 public class StringLiteral extends LiteralExpression<String> {
@@ -9,4 +10,9 @@ public class StringLiteral extends LiteralExpression<String> {
     public StringLiteral(String value) {
         super(value, StringType.class);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/literal/TripleLiteral.java b/src/main/java/org/dvare/expression/literal/TripleLiteral.java
index 0a63968..1387296 100644
--- a/src/main/java/org/dvare/expression/literal/TripleLiteral.java
+++ b/src/main/java/org/dvare/expression/literal/TripleLiteral.java
@@ -1,5 +1,6 @@
 package org.dvare.expression.literal;
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.TripleType;
 import org.dvare.util.Triple;
 
@@ -9,4 +10,8 @@ public TripleLiteral(Triple<?, ?, ?> value) {
         super(value, TripleType.class);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/operation/AggregationOperationExpression.java b/src/main/java/org/dvare/expression/operation/AggregationOperationExpression.java
index 6098698..38b86cd 100644
--- a/src/main/java/org/dvare/expression/operation/AggregationOperationExpression.java
+++ b/src/main/java/org/dvare/expression/operation/AggregationOperationExpression.java
@@ -476,4 +476,8 @@ public String toString() {
     public List<Expression> getRightListOperand() {
         return rightOperand;
     }
+
+    public void setRightListOperand(List<Expression> rightOperand) {
+        this.rightOperand = rightOperand;
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/AssignOperationExpression.java b/src/main/java/org/dvare/expression/operation/AssignOperationExpression.java
index 92dce1c..fced891 100644
--- a/src/main/java/org/dvare/expression/operation/AssignOperationExpression.java
+++ b/src/main/java/org/dvare/expression/operation/AssignOperationExpression.java
@@ -12,6 +12,7 @@
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.exceptions.parser.IllegalPropertyException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.NullLiteral;
@@ -61,7 +62,7 @@ public Integer parse(String[] tokens, int pos, Stack<Expression> stack,
             }
 
 
-            if (!(this.leftOperand instanceof VariableExpression)) {
+            if (!(this.leftOperand instanceof VariableExpression || this.leftOperand instanceof DefOperation)) {
 
                 TokenType tokenType = findDataObject(leftString, contexts);
                 if (tokenType.type != null && contexts.getContext(tokenType.type) != null &&
@@ -140,6 +141,10 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         VariableExpression<?> variable;
         Expression left = this.leftOperand;
 
+        if (left instanceof DefOperation) {
+            left = ((DefOperation) left).leftOperand;
+        }
+
         if (left instanceof VariableExpression) {
             variable = (VariableExpression<?>) left;
 
@@ -179,6 +184,11 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
     private Object updateValue(Object aggregation, DataType dataType, VariableExpression<?> variableExpression, LiteralExpression<?> literalExpression) throws InterpretException {
         String variableName = variableExpression.getName();
         Object value = literalExpression.getValue();
diff --git a/src/main/java/org/dvare/expression/operation/ChainOperationExpression.java b/src/main/java/org/dvare/expression/operation/ChainOperationExpression.java
index 8bc11a9..6620156 100644
--- a/src/main/java/org/dvare/expression/operation/ChainOperationExpression.java
+++ b/src/main/java/org/dvare/expression/operation/ChainOperationExpression.java
@@ -30,7 +30,6 @@ public ChainOperationExpression(OperationType operationType) {
         super(operationType);
     }
 
-
     private int parseOperands(String[] tokens, int pos, Stack<Expression> stack, ContextsBinding contexts) throws ExpressionParseException {
 
         String token = tokens[pos - 1];
@@ -134,4 +133,12 @@ public String toString() {
         return toStringBuilder.toString();
     }
 
+    public List<Expression> getRightListOperand() {
+        return rightOperand;
+    }
+
+    public void setRightListOperand(List<Expression> rightOperand) {
+        this.rightOperand = rightOperand;
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/CompositeOperationExpression.java b/src/main/java/org/dvare/expression/operation/CompositeOperationExpression.java
index 4858978..2536cf6 100644
--- a/src/main/java/org/dvare/expression/operation/CompositeOperationExpression.java
+++ b/src/main/java/org/dvare/expression/operation/CompositeOperationExpression.java
@@ -3,6 +3,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 
 import java.util.ArrayList;
@@ -30,6 +31,15 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return result;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
+    public List<Expression> getExpressions() {
+        return expressions;
+    }
+
     @Override
     public String toString() {
         StringBuilder toStringBuilder = new StringBuilder();
diff --git a/src/main/java/org/dvare/expression/operation/ConditionOperationExpression.java b/src/main/java/org/dvare/expression/operation/ConditionOperationExpression.java
index 390b314..e106872 100644
--- a/src/main/java/org/dvare/expression/operation/ConditionOperationExpression.java
+++ b/src/main/java/org/dvare/expression/operation/ConditionOperationExpression.java
@@ -5,6 +5,7 @@
 import org.dvare.config.ConfigurationRegistry;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.operation.flow.ENDIF;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -25,7 +26,6 @@ public ConditionOperationExpression(OperationType operationType) {
         super(operationType);
     }
 
-
     @Override
     public Integer parse(String[] tokens, int pos, Stack<Expression> stack, ContextsBinding contexts) throws ExpressionParseException {
         pos = findNextExpression(tokens, pos + 1, stack, contexts);
@@ -35,20 +35,27 @@ public Integer parse(String[] tokens, int pos, Stack<Expression> stack, Contexts
 
     @Override
     public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> stack, ContextsBinding contexts) throws ExpressionParseException {
+        var oldPos = pos;
         ConfigurationRegistry configurationRegistry = ConfigurationRegistry.INSTANCE;
-        for (int i = pos; i < tokens.length; i++) {
-            OperationExpression op = configurationRegistry.getOperation(tokens[i]);
-            if (op != null) {
-
-                i = op.parse(tokens, i, stack, contexts);
-                return i;
+        for (; pos < tokens.length; pos++) {
+            var token = tokens[pos];
+            OperationExpression op = configurationRegistry.getOperation(token);
+            if (op instanceof ENDIF) {
+                checkSingleNonOperationExpression(tokens, oldPos, pos, stack, contexts);
+
+                if (stack.isEmpty()) {
+                    throw new ExpressionParseException("ENDIF not found");
+                }
+
+                return --pos;
+            } else if (op != null) {
+                pos = op.parse(tokens, pos, stack, contexts);
+                return pos;
             }
-
         }
-        return null;
+        return pos;
     }
 
-
     @Override
     public String toString() {
         StringBuilder toStringBuilder = new StringBuilder();
@@ -80,6 +87,11 @@ public String toString() {
             toStringBuilder.append(" ");
         }
 
+        if (operationType == OperationType.IF) {
+            toStringBuilder.append(OperationType.ENDIF.getTokens().get(0));
+            toStringBuilder.append(" ");
+        }
+
 
         if (rightOperand != null) {
             toStringBuilder.append(rightOperand.toString());
@@ -90,5 +102,28 @@ public String toString() {
         return toStringBuilder.toString();
     }
 
+    public Expression getCondition() {
+        return condition;
+    }
+
+    public void setCondition(Expression condition) {
+        this.condition = condition;
+    }
+
+    public Expression getThenOperand() {
+        return thenOperand;
+    }
+
+    public void setThenOperand(Expression thenOperand) {
+        this.thenOperand = thenOperand;
+    }
+
+    public Expression getElseOperand() {
+        return elseOperand;
+    }
+
+    public void setElseOperand(Expression elseOperand) {
+        this.elseOperand = elseOperand;
+    }
 
 }
diff --git a/src/main/java/org/dvare/expression/operation/IterationOperationExpression.java b/src/main/java/org/dvare/expression/operation/IterationOperationExpression.java
index 0d99c0d..698c746 100644
--- a/src/main/java/org/dvare/expression/operation/IterationOperationExpression.java
+++ b/src/main/java/org/dvare/expression/operation/IterationOperationExpression.java
@@ -5,6 +5,7 @@
 import org.dvare.config.ConfigurationRegistry;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.NamedExpression;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.utility.EndForAll;
@@ -152,4 +153,24 @@ public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> st
         throw new ExpressionParseException("Function Closing Bracket Not Found");
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
+    public Expression getReferenceContext() {
+        return referenceContext;
+    }
+
+    public void setReferenceContext(Expression referenceContext) {
+        this.referenceContext = referenceContext;
+    }
+
+    public NamedExpression getDerivedContext() {
+        return derivedContext;
+    }
+
+    public void setDerivedContext(NamedExpression derivedContext) {
+        this.derivedContext = derivedContext;
+    }
 }
diff --git a/src/main/java/org/dvare/expression/operation/ListLiteralOperationENDExpression.java b/src/main/java/org/dvare/expression/operation/ListLiteralOperationENDExpression.java
index f0b00d0..ebcec1b 100644
--- a/src/main/java/org/dvare/expression/operation/ListLiteralOperationENDExpression.java
+++ b/src/main/java/org/dvare/expression/operation/ListLiteralOperationENDExpression.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.model.ContextsBinding;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 
 import java.util.Stack;
 
@@ -24,4 +25,9 @@ public Integer parse(String[] tokens, int pos, Stack<Expression> stack, Contexts
     public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> stack, ContextsBinding contexts) throws ExpressionParseException {
         return pos;
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/operation/ListLiteralOperationExpression.java b/src/main/java/org/dvare/expression/operation/ListLiteralOperationExpression.java
index 07fafbe..8d70c3b 100644
--- a/src/main/java/org/dvare/expression/operation/ListLiteralOperationExpression.java
+++ b/src/main/java/org/dvare/expression/operation/ListLiteralOperationExpression.java
@@ -8,6 +8,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.DataTypeExpression;
 import org.dvare.expression.literal.ListLiteral;
@@ -168,6 +169,11 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return listLiteral;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
     public boolean isEmpty() {
         return rightOperand.isEmpty();
     }
@@ -199,6 +205,10 @@ public String toString() {
     public List<Expression> getRightListOperand() {
         return rightOperand;
     }
+
+    public void setRightListOperand(List<Expression> rightOperand) {
+        this.rightOperand = rightOperand;
+    }
 }
 
 
diff --git a/src/main/java/org/dvare/expression/operation/ListOperationExpression.java b/src/main/java/org/dvare/expression/operation/ListOperationExpression.java
index 527e0ff..851e4c3 100644
--- a/src/main/java/org/dvare/expression/operation/ListOperationExpression.java
+++ b/src/main/java/org/dvare/expression/operation/ListOperationExpression.java
@@ -24,7 +24,6 @@ public ListOperationExpression(OperationType operationType) {
         super(operationType);
     }
 
-
     protected List<?> includedFilter(Expression includeParam, InstancesBinding instancesBinding, List<?> values) throws InterpretException {
 
         if (includeParam instanceof LogicalOperationExpression) {
diff --git a/src/main/java/org/dvare/expression/operation/LogicalOperationExpression.java b/src/main/java/org/dvare/expression/operation/LogicalOperationExpression.java
index 7d50829..078cef6 100644
--- a/src/main/java/org/dvare/expression/operation/LogicalOperationExpression.java
+++ b/src/main/java/org/dvare/expression/operation/LogicalOperationExpression.java
@@ -5,7 +5,9 @@
 import org.dvare.config.ConfigurationRegistry;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.operation.flow.ELSE;
 import org.dvare.expression.operation.flow.ENDIF;
+import org.dvare.expression.operation.flow.THEN;
 import org.dvare.expression.operation.utility.EndForAll;
 import org.dvare.expression.operation.utility.RightPriority;
 import org.slf4j.Logger;
@@ -24,7 +26,6 @@ public LogicalOperationExpression(OperationType operationType) {
         super(operationType);
     }
 
-
     @Override
     public Integer parse(String[] tokens, int pos, Stack<Expression> stack, ContextsBinding contexts) throws ExpressionParseException {
         Expression left = stack.pop();
@@ -46,31 +47,34 @@ public Integer parse(String[] tokens, int pos, Stack<Expression> stack, Contexts
 
     @Override
     public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> stack, ContextsBinding contexts) throws ExpressionParseException {
+        var oldPos = pos;
         ConfigurationRegistry configurationRegistry = ConfigurationRegistry.INSTANCE;
         for (; pos < tokens.length; pos++) {
-            OperationExpression op = configurationRegistry.getOperation(tokens[pos]);
+            var token = tokens[pos];
+
+            OperationExpression op = configurationRegistry.getOperation(token);
             if (op != null) {
 
-                if (op instanceof RightPriority || op instanceof EndForAll || op instanceof ENDIF/* || (op instanceof AggregationOperationExpression && !stack.isEmpty())*/) {
+                if (op instanceof RightPriority || op instanceof EndForAll || op instanceof THEN || op instanceof ELSE | op instanceof ENDIF/* || (op instanceof AggregationOperationExpression && !stack.isEmpty())*/) {
+                    checkSingleNonOperationExpression(tokens, oldPos, pos, stack, contexts);
                     return pos - 1;
                 }
 
-
                 pos = op.parse(tokens, pos, stack, contexts);
 
-
                 if (pos + 1 < tokens.length) {
                     OperationExpression testOp = configurationRegistry.getOperation(tokens[pos + 1]);
                     if (testOp instanceof LogicalOperationExpression) {
                         return pos;
                     }
                 }
-
-
             }
         }
+
+        // reached end of the tokens and only one token was left that was not an OperationExpression
+        checkSingleNonOperationExpression(tokens, oldPos, pos, stack, contexts);
+
         return pos;
     }
 
-
-}
\ No newline at end of file
+}
diff --git a/src/main/java/org/dvare/expression/operation/OperationExpression.java b/src/main/java/org/dvare/expression/operation/OperationExpression.java
index 6ae46cc..1e0321d 100644
--- a/src/main/java/org/dvare/expression/operation/OperationExpression.java
+++ b/src/main/java/org/dvare/expression/operation/OperationExpression.java
@@ -122,6 +122,14 @@ protected Expression buildExpression(String token, ContextsBinding contextsBindi
         }
     }
 
+    protected void checkSingleNonOperationExpression(String[] tokens, int oldPos, int currentPos, Stack<Expression> stack, ContextsBinding contexts) throws IllegalPropertyException, IllegalValueException {
+        if (oldPos == currentPos - 1) {
+            var e = buildExpression(tokens[oldPos], contexts, oldPos, tokens);
+            if (e != null) {
+                stack.push(e);
+            }
+        }
+    }
 
     protected Object getValue(Object object, String name) throws IllegalPropertyValueException {
         return ValueFinder.findValue(name, object);
@@ -222,6 +230,22 @@ public List<String> getSymbols() {
         return this.operationType.getTokens();
     }
 
+    public OperationType getOperationType() {
+        return operationType;
+    }
+
+    public void setOperationType(OperationType operationType) {
+        this.operationType = operationType;
+    }
+
+    public Class<? extends DataTypeExpression> getDataTypeExpression() {
+        return dataTypeExpression;
+    }
+
+    public void setDataTypeExpression(Class<? extends DataTypeExpression> dataTypeExpression) {
+        this.dataTypeExpression = dataTypeExpression;
+    }
+
     protected enum Side {
         Left, Right;
     }
diff --git a/src/main/java/org/dvare/expression/operation/RelationalOperationExpression.java b/src/main/java/org/dvare/expression/operation/RelationalOperationExpression.java
index 0b4a5ed..a6a6000 100644
--- a/src/main/java/org/dvare/expression/operation/RelationalOperationExpression.java
+++ b/src/main/java/org/dvare/expression/operation/RelationalOperationExpression.java
@@ -295,6 +295,4 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding)
         }
         return new BooleanLiteral(false);
     }
-
-
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/aggregation/Maximum.java b/src/main/java/org/dvare/expression/operation/aggregation/Maximum.java
index af7b688..133f400 100644
--- a/src/main/java/org/dvare/expression/operation/aggregation/Maximum.java
+++ b/src/main/java/org/dvare/expression/operation/aggregation/Maximum.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.FloatLiteral;
 import org.dvare.expression.literal.IntegerLiteral;
@@ -51,4 +52,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
 
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/aggregation/Mean.java b/src/main/java/org/dvare/expression/operation/aggregation/Mean.java
index 47f943b..0273469 100644
--- a/src/main/java/org/dvare/expression/operation/aggregation/Mean.java
+++ b/src/main/java/org/dvare/expression/operation/aggregation/Mean.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.FloatType;
 import org.dvare.expression.datatype.IntegerType;
@@ -117,5 +118,10 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return leftExpression;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/aggregation/Median.java b/src/main/java/org/dvare/expression/operation/aggregation/Median.java
index 919c014..574d966 100644
--- a/src/main/java/org/dvare/expression/operation/aggregation/Median.java
+++ b/src/main/java/org/dvare/expression/operation/aggregation/Median.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.FloatType;
 import org.dvare.expression.datatype.IntegerType;
@@ -123,4 +124,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return leftExpression;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/aggregation/Minimum.java b/src/main/java/org/dvare/expression/operation/aggregation/Minimum.java
index 83b2b22..abcdbe9 100644
--- a/src/main/java/org/dvare/expression/operation/aggregation/Minimum.java
+++ b/src/main/java/org/dvare/expression/operation/aggregation/Minimum.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.FloatLiteral;
 import org.dvare.expression.literal.IntegerLiteral;
@@ -50,4 +51,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return super.interpret(instancesBinding);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/aggregation/Mode.java b/src/main/java/org/dvare/expression/operation/aggregation/Mode.java
index 036c317..7efd2d1 100644
--- a/src/main/java/org/dvare/expression/operation/aggregation/Mode.java
+++ b/src/main/java/org/dvare/expression/operation/aggregation/Mode.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.FloatType;
 import org.dvare.expression.datatype.IntegerType;
@@ -124,4 +125,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
 
         return leftExpression;
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/aggregation/Sum.java b/src/main/java/org/dvare/expression/operation/aggregation/Sum.java
index a43ec23..df51636 100644
--- a/src/main/java/org/dvare/expression/operation/aggregation/Sum.java
+++ b/src/main/java/org/dvare/expression/operation/aggregation/Sum.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -62,4 +63,9 @@ public LiteralExpression interpret(InstancesBinding instancesBinding) throws Int
         return super.interpret(instancesBinding);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/arithmetic/Add.java b/src/main/java/org/dvare/expression/operation/arithmetic/Add.java
index b02c433..f2abc8b 100644
--- a/src/main/java/org/dvare/expression/operation/arithmetic/Add.java
+++ b/src/main/java/org/dvare/expression/operation/arithmetic/Add.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.arithmetic;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.ArithmeticOperationExpression;
 import org.dvare.expression.operation.OperationType;
@@ -16,4 +17,8 @@ public Add() {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/arithmetic/Divide.java b/src/main/java/org/dvare/expression/operation/arithmetic/Divide.java
index f2e1cb2..0d574cc 100644
--- a/src/main/java/org/dvare/expression/operation/arithmetic/Divide.java
+++ b/src/main/java/org/dvare/expression/operation/arithmetic/Divide.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.arithmetic;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.ArithmeticOperationExpression;
 import org.dvare.expression.operation.OperationType;
@@ -16,4 +17,8 @@ public Divide() {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/arithmetic/Max.java b/src/main/java/org/dvare/expression/operation/arithmetic/Max.java
index 0cb47c4..9545476 100644
--- a/src/main/java/org/dvare/expression/operation/arithmetic/Max.java
+++ b/src/main/java/org/dvare/expression/operation/arithmetic/Max.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.arithmetic;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.ArithmeticOperationExpression;
 import org.dvare.expression.operation.OperationType;
@@ -16,4 +17,8 @@ public Max() {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/arithmetic/Min.java b/src/main/java/org/dvare/expression/operation/arithmetic/Min.java
index 94d857f..b805fe2 100644
--- a/src/main/java/org/dvare/expression/operation/arithmetic/Min.java
+++ b/src/main/java/org/dvare/expression/operation/arithmetic/Min.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.arithmetic;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.ArithmeticOperationExpression;
 import org.dvare.expression.operation.OperationType;
@@ -16,4 +17,8 @@ public Min() {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/arithmetic/Multiply.java b/src/main/java/org/dvare/expression/operation/arithmetic/Multiply.java
index 4155e6d..c1e91b2 100644
--- a/src/main/java/org/dvare/expression/operation/arithmetic/Multiply.java
+++ b/src/main/java/org/dvare/expression/operation/arithmetic/Multiply.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.arithmetic;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.ArithmeticOperationExpression;
 import org.dvare.expression.operation.OperationType;
@@ -16,4 +17,8 @@ public Multiply() {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/arithmetic/Power.java b/src/main/java/org/dvare/expression/operation/arithmetic/Power.java
index d2e7a1c..c47c977 100644
--- a/src/main/java/org/dvare/expression/operation/arithmetic/Power.java
+++ b/src/main/java/org/dvare/expression/operation/arithmetic/Power.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.arithmetic;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.ArithmeticOperationExpression;
 import org.dvare.expression.operation.OperationType;
@@ -16,4 +17,8 @@ public Power() {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/arithmetic/Subtract.java b/src/main/java/org/dvare/expression/operation/arithmetic/Subtract.java
index 1340458..96b5c4d 100644
--- a/src/main/java/org/dvare/expression/operation/arithmetic/Subtract.java
+++ b/src/main/java/org/dvare/expression/operation/arithmetic/Subtract.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.arithmetic;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.ArithmeticOperationExpression;
 import org.dvare.expression.operation.OperationType;
@@ -16,4 +17,8 @@ public Subtract() {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/flow/ELSE.java b/src/main/java/org/dvare/expression/operation/flow/ELSE.java
index a3b5799..99593cf 100644
--- a/src/main/java/org/dvare/expression/operation/flow/ELSE.java
+++ b/src/main/java/org/dvare/expression/operation/flow/ELSE.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.flow;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.operation.ConditionOperationExpression;
 import org.dvare.expression.operation.OperationType;
 
@@ -15,5 +16,9 @@ public ELSE() {
         super(OperationType.ELSE);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/flow/ENDIF.java b/src/main/java/org/dvare/expression/operation/flow/ENDIF.java
index 87a9d55..635a933 100644
--- a/src/main/java/org/dvare/expression/operation/flow/ENDIF.java
+++ b/src/main/java/org/dvare/expression/operation/flow/ENDIF.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.flow;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.operation.ConditionOperationExpression;
 import org.dvare.expression.operation.OperationType;
 
@@ -15,5 +16,9 @@ public ENDIF() {
         super(OperationType.ENDIF);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/flow/IF.java b/src/main/java/org/dvare/expression/operation/flow/IF.java
index 4e2f9cd..f2b53a9 100644
--- a/src/main/java/org/dvare/expression/operation/flow/IF.java
+++ b/src/main/java/org/dvare/expression/operation/flow/IF.java
@@ -7,6 +7,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.BooleanLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.ConditionOperationExpression;
@@ -47,8 +48,6 @@ public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> st
                     if (operation instanceof THEN) {
                         pos = operation.parse(tokens, pos, stack, contexts);
                         this.thenOperand = stack.pop();
-
-
                     } else if (operation instanceof ELSE) {
                         pos = operation.parse(tokens, pos, stack, contexts);
                         this.elseOperand = stack.pop();
@@ -56,7 +55,6 @@ public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> st
                         if (elseOperand instanceof ConditionOperationExpression) {
                             return pos;
                         }
-
                     } else if (operation instanceof ENDIF) {
                         return pos;
                     }
@@ -93,5 +91,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new BooleanLiteral(result);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/flow/THEN.java b/src/main/java/org/dvare/expression/operation/flow/THEN.java
index 3ba17f3..40f09c5 100644
--- a/src/main/java/org/dvare/expression/operation/flow/THEN.java
+++ b/src/main/java/org/dvare/expression/operation/flow/THEN.java
@@ -5,6 +5,7 @@
 import org.dvare.config.ConfigurationRegistry;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.operation.ConditionOperationExpression;
 import org.dvare.expression.operation.OperationExpression;
 import org.dvare.expression.operation.OperationType;
@@ -24,9 +25,11 @@ public THEN() {
 
     @Override
     public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> stack, ContextsBinding contexts) throws ExpressionParseException {
+        var oldPos = pos;
         ConfigurationRegistry configurationRegistry = ConfigurationRegistry.INSTANCE;
         for (; pos < tokens.length; pos++) {
-            OperationExpression op = configurationRegistry.getOperation(tokens[pos]);
+            var token = tokens[pos];
+            OperationExpression op = configurationRegistry.getOperation(token);
             /*if (op != null) {
 
                 pos = op.parse(tokens, pos, stack, contexts);
@@ -34,17 +37,23 @@ public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> st
             }*/
 
             if (op instanceof ELSE || op instanceof ENDIF) {
+                checkSingleNonOperationExpression(tokens, oldPos, pos, stack, contexts);
+
                 if (stack.isEmpty()) {
-                    throw new ExpressionParseException("ENDIF not found");
+                    throw new ExpressionParseException("ELSE or ENDIF not found");
                 }
+
                 return --pos;
             } else if (op != null) {
                 pos = op.parse(tokens, pos, stack, contexts);
             }
-
         }
-        return null;
+        return pos;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/flow/TernaryOperation.java b/src/main/java/org/dvare/expression/operation/flow/TernaryOperation.java
index e575a41..45eb786 100644
--- a/src/main/java/org/dvare/expression/operation/flow/TernaryOperation.java
+++ b/src/main/java/org/dvare/expression/operation/flow/TernaryOperation.java
@@ -8,6 +8,7 @@
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.exceptions.parser.IllegalPropertyException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.BooleanLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.*;
@@ -151,4 +152,9 @@ public String toString() {
 
         return toStringBuilder.toString();
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/operation/list/CombinationExists.java b/src/main/java/org/dvare/expression/operation/list/CombinationExists.java
index f8e2375..22a55fe 100644
--- a/src/main/java/org/dvare/expression/operation/list/CombinationExists.java
+++ b/src/main/java/org/dvare/expression/operation/list/CombinationExists.java
@@ -6,6 +6,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.OperationType;
@@ -76,5 +77,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return match(dataType, values, matchParams, false, true);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/DistinctOperation.java b/src/main/java/org/dvare/expression/operation/list/DistinctOperation.java
new file mode 100644
index 0000000..f28b7ef
--- /dev/null
+++ b/src/main/java/org/dvare/expression/operation/list/DistinctOperation.java
@@ -0,0 +1,46 @@
+package org.dvare.expression.operation.list;
+
+import org.dvare.annotations.Operation;
+import org.dvare.binding.data.InstancesBinding;
+import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
+import org.dvare.expression.literal.ListLiteral;
+import org.dvare.expression.literal.LiteralExpression;
+import org.dvare.expression.literal.NullLiteral;
+import org.dvare.expression.operation.ListOperationExpression;
+import org.dvare.expression.operation.OperationType;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author Christoph Laaber
+ * @since 2024-04-19
+ */
+@Operation(type = OperationType.DISTINCT)
+public class DistinctOperation extends ListOperationExpression {
+
+    public DistinctOperation() {
+        super(OperationType.DISTINCT);
+    }
+
+    @Override
+    public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws InterpretException {
+        List<?> values = extractValues(instancesBinding, leftOperand);
+
+        if (values != null) {
+            var distinctValues = values
+                    .stream()
+                    .distinct()
+                    .collect(Collectors.toList());
+            return new ListLiteral(distinctValues, dataTypeExpression);
+        }
+
+        return new NullLiteral<>();
+    }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+}
diff --git a/src/main/java/org/dvare/expression/operation/list/FilterOperation.java b/src/main/java/org/dvare/expression/operation/list/FilterOperation.java
index 614df35..46bdd1e 100644
--- a/src/main/java/org/dvare/expression/operation/list/FilterOperation.java
+++ b/src/main/java/org/dvare/expression/operation/list/FilterOperation.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.NullLiteral;
@@ -107,4 +108,9 @@ private List<?> toupleFilter(InstancesBinding instancesBinding,
         }
         return includedValues;
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/First.java b/src/main/java/org/dvare/expression/operation/list/First.java
index ea75800..99c20f9 100644
--- a/src/main/java/org/dvare/expression/operation/list/First.java
+++ b/src/main/java/org/dvare/expression/operation/list/First.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -37,5 +38,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/GetItem.java b/src/main/java/org/dvare/expression/operation/list/GetItem.java
index cd8d978..00b8231 100644
--- a/src/main/java/org/dvare/expression/operation/list/GetItem.java
+++ b/src/main/java/org/dvare/expression/operation/list/GetItem.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.IntegerLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -111,5 +112,9 @@ private LiteralExpression<?> buildItem(List<?> values, IntegerLiteral integerLit
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/HasItem.java b/src/main/java/org/dvare/expression/operation/list/HasItem.java
index 5b738ac..cf5ecfa 100644
--- a/src/main/java/org/dvare/expression/operation/list/HasItem.java
+++ b/src/main/java/org/dvare/expression/operation/list/HasItem.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.BooleanType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -102,4 +103,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return LiteralType.getLiteralExpression(false, BooleanType.class);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/InsideCombination.java b/src/main/java/org/dvare/expression/operation/list/InsideCombination.java
index e522b51..80f5880 100644
--- a/src/main/java/org/dvare/expression/operation/list/InsideCombination.java
+++ b/src/main/java/org/dvare/expression/operation/list/InsideCombination.java
@@ -6,6 +6,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.OperationType;
@@ -80,5 +81,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return match(dataType, values, matchParams, true, false);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/InsideExistsCombination.java b/src/main/java/org/dvare/expression/operation/list/InsideExistsCombination.java
index e5e08d4..1a3046e 100644
--- a/src/main/java/org/dvare/expression/operation/list/InsideExistsCombination.java
+++ b/src/main/java/org/dvare/expression/operation/list/InsideExistsCombination.java
@@ -6,6 +6,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.OperationType;
@@ -80,5 +81,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return match(dataType, values, matchParams, true, true);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/IsEmpty.java b/src/main/java/org/dvare/expression/operation/list/IsEmpty.java
index 1b22ea0..330e030 100644
--- a/src/main/java/org/dvare/expression/operation/list/IsEmpty.java
+++ b/src/main/java/org/dvare/expression/operation/list/IsEmpty.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.BooleanType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -38,5 +39,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return LiteralType.getLiteralExpression(true, BooleanType.class);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/ItemPosition.java b/src/main/java/org/dvare/expression/operation/list/ItemPosition.java
index 4fbb13c..905dbf6 100644
--- a/src/main/java/org/dvare/expression/operation/list/ItemPosition.java
+++ b/src/main/java/org/dvare/expression/operation/list/ItemPosition.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.IntegerType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -98,4 +99,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/KeysOperation.java b/src/main/java/org/dvare/expression/operation/list/KeysOperation.java
index e9526ae..effbafb 100644
--- a/src/main/java/org/dvare/expression/operation/list/KeysOperation.java
+++ b/src/main/java/org/dvare/expression/operation/list/KeysOperation.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
@@ -82,4 +83,9 @@ private List<Object> extractTripleKeys(List<?> triplesList) throws InterpretExce
         return pairKeys;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
diff --git a/src/main/java/org/dvare/expression/operation/list/Last.java b/src/main/java/org/dvare/expression/operation/list/Last.java
index b627acf..62a26a2 100644
--- a/src/main/java/org/dvare/expression/operation/list/Last.java
+++ b/src/main/java/org/dvare/expression/operation/list/Last.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -32,5 +33,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/MapOperation.java b/src/main/java/org/dvare/expression/operation/list/MapOperation.java
index 16999c7..5781200 100644
--- a/src/main/java/org/dvare/expression/operation/list/MapOperation.java
+++ b/src/main/java/org/dvare/expression/operation/list/MapOperation.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.NullLiteral;
@@ -107,5 +108,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/Match.java b/src/main/java/org/dvare/expression/operation/list/Match.java
index 85b4b46..2231da9 100644
--- a/src/main/java/org/dvare/expression/operation/list/Match.java
+++ b/src/main/java/org/dvare/expression/operation/list/Match.java
@@ -7,6 +7,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.BooleanType;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.*;
@@ -143,6 +144,11 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return match(dataType, values, matchParams, insideCombination, combinationExist);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 
     protected List<?> buildValues(InstancesBinding instancesBinding, Expression valueParam) throws InterpretException {
 
@@ -389,6 +395,14 @@ public String toString() {
         return toStringBuilder.toString();
     }
 
+    public List<Expression> getLeftListOperand() {
+        return leftOperand;
+    }
+
+    public void setLeftListOperand(List<Expression> leftOperand) {
+        this.leftOperand = leftOperand;
+    }
+
 
    /* public static void main(String[] args) throws Exception {
 
diff --git a/src/main/java/org/dvare/expression/operation/list/MiddlesOperation.java b/src/main/java/org/dvare/expression/operation/list/MiddlesOperation.java
index 15a2da1..3f7112a 100644
--- a/src/main/java/org/dvare/expression/operation/list/MiddlesOperation.java
+++ b/src/main/java/org/dvare/expression/operation/list/MiddlesOperation.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
@@ -59,4 +60,9 @@ private List<Object> extractPairKeys(List<?> triplesList) throws InterpretExcept
         return pairKeys;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
diff --git a/src/main/java/org/dvare/expression/operation/list/NotEmpty.java b/src/main/java/org/dvare/expression/operation/list/NotEmpty.java
index b382873..18cac25 100644
--- a/src/main/java/org/dvare/expression/operation/list/NotEmpty.java
+++ b/src/main/java/org/dvare/expression/operation/list/NotEmpty.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.BooleanType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -32,5 +33,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return LiteralType.getLiteralExpression(false, BooleanType.class);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/PairOperation.java b/src/main/java/org/dvare/expression/operation/list/PairOperation.java
index e5e6aa8..15da2db 100644
--- a/src/main/java/org/dvare/expression/operation/list/PairOperation.java
+++ b/src/main/java/org/dvare/expression/operation/list/PairOperation.java
@@ -6,6 +6,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.PairType;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
@@ -113,5 +114,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/SizeOperation.java b/src/main/java/org/dvare/expression/operation/list/SizeOperation.java
index 906556d..9016b93 100644
--- a/src/main/java/org/dvare/expression/operation/list/SizeOperation.java
+++ b/src/main/java/org/dvare/expression/operation/list/SizeOperation.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.IntegerType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -37,5 +38,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return LiteralType.getLiteralExpression(0, IntegerType.class);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/list/SortOperation.java b/src/main/java/org/dvare/expression/operation/list/SortOperation.java
index 40334f1..f1a821f 100644
--- a/src/main/java/org/dvare/expression/operation/list/SortOperation.java
+++ b/src/main/java/org/dvare/expression/operation/list/SortOperation.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.DataTypeExpression;
 import org.dvare.expression.literal.ListLiteral;
@@ -213,6 +214,11 @@ private int compare(Object o1, Object o2, DataType type) {
         return -1;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
     private static class ValueType {
         Class<? extends DataTypeExpression> type;
         Object value;
diff --git a/src/main/java/org/dvare/expression/operation/list/TripleOperation.java b/src/main/java/org/dvare/expression/operation/list/TripleOperation.java
index db5652b..4472fcf 100644
--- a/src/main/java/org/dvare/expression/operation/list/TripleOperation.java
+++ b/src/main/java/org/dvare/expression/operation/list/TripleOperation.java
@@ -6,6 +6,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.TripleType;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
@@ -115,5 +116,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
diff --git a/src/main/java/org/dvare/expression/operation/list/ValuesOperation.java b/src/main/java/org/dvare/expression/operation/list/ValuesOperation.java
index 6f577a6..5da0c76 100644
--- a/src/main/java/org/dvare/expression/operation/list/ValuesOperation.java
+++ b/src/main/java/org/dvare/expression/operation/list/ValuesOperation.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
@@ -95,4 +96,9 @@ private List<?> extractTripleValues(List<?> tripleList) {
         }
         return pairValues;
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/operation/logical/And.java b/src/main/java/org/dvare/expression/operation/logical/And.java
index f7ea60e..750dd37 100644
--- a/src/main/java/org/dvare/expression/operation/logical/And.java
+++ b/src/main/java/org/dvare/expression/operation/logical/And.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.BooleanLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.LogicalOperationExpression;
@@ -25,4 +26,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         Boolean right = toBoolean(rightOperand.interpret(instancesBinding));
         return new BooleanLiteral(left && right);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/logical/Implies.java b/src/main/java/org/dvare/expression/operation/logical/Implies.java
index b0ba390..6dd157d 100644
--- a/src/main/java/org/dvare/expression/operation/logical/Implies.java
+++ b/src/main/java/org/dvare/expression/operation/logical/Implies.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.BooleanLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.LogicalOperationExpression;
@@ -25,4 +26,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         boolean right = toBoolean(rightOperand.interpret(instancesBinding));
         return new BooleanLiteral((!left) | right);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/logical/Not.java b/src/main/java/org/dvare/expression/operation/logical/Not.java
index b82b309..a367fa8 100644
--- a/src/main/java/org/dvare/expression/operation/logical/Not.java
+++ b/src/main/java/org/dvare/expression/operation/logical/Not.java
@@ -6,6 +6,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.BooleanLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.LogicalOperationExpression;
@@ -38,5 +39,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new BooleanLiteral(!toBoolean(this.rightOperand.interpret(instancesBinding)));
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/logical/OR.java b/src/main/java/org/dvare/expression/operation/logical/OR.java
index ad89964..2d63e46 100644
--- a/src/main/java/org/dvare/expression/operation/logical/OR.java
+++ b/src/main/java/org/dvare/expression/operation/logical/OR.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.BooleanLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.LogicalOperationExpression;
@@ -25,4 +26,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         Boolean right = toBoolean(rightOperand.interpret(instancesBinding));
         return new BooleanLiteral(left || right);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/AddDays.java b/src/main/java/org/dvare/expression/operation/predefined/AddDays.java
index 332fbf8..5a53c33 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/AddDays.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/AddDays.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -83,4 +84,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/AddMonths.java b/src/main/java/org/dvare/expression/operation/predefined/AddMonths.java
index 5264dc0..5500c02 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/AddMonths.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/AddMonths.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -84,4 +85,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/AddYears.java b/src/main/java/org/dvare/expression/operation/predefined/AddYears.java
index 589f6b0..df8f408 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/AddYears.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/AddYears.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -85,4 +86,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/Append.java b/src/main/java/org/dvare/expression/operation/predefined/Append.java
index 6aebd37..0180400 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/Append.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/Append.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.StringType;
 import org.dvare.expression.literal.LiteralExpression;
@@ -46,5 +47,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/Contains.java b/src/main/java/org/dvare/expression/operation/predefined/Contains.java
index 28bc1e3..90a10c1 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/Contains.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/Contains.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.BooleanType;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.LiteralExpression;
@@ -46,4 +47,10 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
 
         return LiteralType.getLiteralExpression(false, BooleanType.class);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/EndsWith.java b/src/main/java/org/dvare/expression/operation/predefined/EndsWith.java
index 41066b8..0600102 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/EndsWith.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/EndsWith.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.BooleanType;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.LiteralExpression;
@@ -46,4 +47,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return LiteralType.getLiteralExpression(false, BooleanType.class);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/GetYear.java b/src/main/java/org/dvare/expression/operation/predefined/GetYear.java
index 46c7c25..15f1963 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/GetYear.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/GetYear.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.IntegerType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -76,4 +77,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/Length.java b/src/main/java/org/dvare/expression/operation/predefined/Length.java
index af3036e..150e9d6 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/Length.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/Length.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.IntegerType;
 import org.dvare.expression.literal.LiteralExpression;
@@ -39,5 +40,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/Prepend.java b/src/main/java/org/dvare/expression/operation/predefined/Prepend.java
index fa28c4b..2966282 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/Prepend.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/Prepend.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.StringType;
 import org.dvare.expression.literal.LiteralExpression;
@@ -46,4 +47,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/SetDay.java b/src/main/java/org/dvare/expression/operation/predefined/SetDay.java
index 9977b99..b9bf6f9 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/SetDay.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/SetDay.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -85,4 +86,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/SetMonth.java b/src/main/java/org/dvare/expression/operation/predefined/SetMonth.java
index d823481..2bbff45 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/SetMonth.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/SetMonth.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -84,4 +85,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/SetYear.java b/src/main/java/org/dvare/expression/operation/predefined/SetYear.java
index 9e1019d..7778c1f 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/SetYear.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/SetYear.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -83,4 +84,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/StartsWith.java b/src/main/java/org/dvare/expression/operation/predefined/StartsWith.java
index b3af129..6c4bd82 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/StartsWith.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/StartsWith.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.BooleanType;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.LiteralExpression;
@@ -46,4 +47,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return LiteralType.getLiteralExpression(false, BooleanType.class);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/SubDays.java b/src/main/java/org/dvare/expression/operation/predefined/SubDays.java
index e28ed44..6d00215 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/SubDays.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/SubDays.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -83,4 +84,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/SubMonths.java b/src/main/java/org/dvare/expression/operation/predefined/SubMonths.java
index 4acf651..11b569f 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/SubMonths.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/SubMonths.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -84,4 +85,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/SubYears.java b/src/main/java/org/dvare/expression/operation/predefined/SubYears.java
index 92e65b6..ae873ad 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/SubYears.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/SubYears.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -85,4 +86,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/Substring.java b/src/main/java/org/dvare/expression/operation/predefined/Substring.java
index b5a0c61..457ec6f 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/Substring.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/Substring.java
@@ -6,6 +6,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.StringType;
 import org.dvare.expression.literal.LiteralExpression;
@@ -94,5 +95,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/ToBoolean.java b/src/main/java/org/dvare/expression/operation/predefined/ToBoolean.java
index 0440056..fdec67b 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/ToBoolean.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/ToBoolean.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.BooleanType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -46,4 +47,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/ToDate.java b/src/main/java/org/dvare/expression/operation/predefined/ToDate.java
index 9b764c5..e7a20e9 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/ToDate.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/ToDate.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -66,4 +67,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/ToInteger.java b/src/main/java/org/dvare/expression/operation/predefined/ToInteger.java
index cc89d02..6ba80ef 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/ToInteger.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/ToInteger.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.IntegerType;
 import org.dvare.expression.literal.LiteralExpression;
@@ -74,4 +75,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
 
         return new NullLiteral<>();
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/ToKey.java b/src/main/java/org/dvare/expression/operation/predefined/ToKey.java
index 49891df..f06e0a4 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/ToKey.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/ToKey.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.IllegalValueException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -59,4 +60,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
diff --git a/src/main/java/org/dvare/expression/operation/predefined/ToLeft.java b/src/main/java/org/dvare/expression/operation/predefined/ToLeft.java
index 38837ad..0224015 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/ToLeft.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/ToLeft.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.IllegalValueException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -56,4 +57,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
diff --git a/src/main/java/org/dvare/expression/operation/predefined/ToMiddle.java b/src/main/java/org/dvare/expression/operation/predefined/ToMiddle.java
index 17ee0c8..5c71e58 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/ToMiddle.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/ToMiddle.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.IllegalValueException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -48,4 +49,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
diff --git a/src/main/java/org/dvare/expression/operation/predefined/ToPair.java b/src/main/java/org/dvare/expression/operation/predefined/ToPair.java
index 09bd9c0..2be51a3 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/ToPair.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/ToPair.java
@@ -6,6 +6,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.PairType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -57,5 +58,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/ToRight.java b/src/main/java/org/dvare/expression/operation/predefined/ToRight.java
index 69016d1..6504c88 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/ToRight.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/ToRight.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.IllegalValueException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -58,4 +59,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
diff --git a/src/main/java/org/dvare/expression/operation/predefined/ToString.java b/src/main/java/org/dvare/expression/operation/predefined/ToString.java
index dd91a76..56024d6 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/ToString.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/ToString.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.StringType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -49,4 +50,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/predefined/ToTriple.java b/src/main/java/org/dvare/expression/operation/predefined/ToTriple.java
index 785b3d5..f00dd6a 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/ToTriple.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/ToTriple.java
@@ -6,6 +6,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.TripleType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -56,5 +57,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
diff --git a/src/main/java/org/dvare/expression/operation/predefined/ToValue.java b/src/main/java/org/dvare/expression/operation/predefined/ToValue.java
index 25b8548..f22fac9 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/ToValue.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/ToValue.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.IllegalValueException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
 import org.dvare.expression.literal.NullLiteral;
@@ -56,4 +57,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
diff --git a/src/main/java/org/dvare/expression/operation/predefined/Trim.java b/src/main/java/org/dvare/expression/operation/predefined/Trim.java
index 126d581..61d4043 100644
--- a/src/main/java/org/dvare/expression/operation/predefined/Trim.java
+++ b/src/main/java/org/dvare/expression/operation/predefined/Trim.java
@@ -3,6 +3,7 @@
 import org.dvare.annotations.Operation;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.StringType;
 import org.dvare.expression.literal.LiteralExpression;
@@ -36,5 +37,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new NullLiteral<>();
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/relational/Between.java b/src/main/java/org/dvare/expression/operation/relational/Between.java
index ce7eaf9..8ce4324 100644
--- a/src/main/java/org/dvare/expression/operation/relational/Between.java
+++ b/src/main/java/org/dvare/expression/operation/relational/Between.java
@@ -5,6 +5,7 @@
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.exceptions.parser.IllegalOperationException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
@@ -38,7 +39,6 @@ public Integer parse(final String[] tokens, int pos, Stack<Expression> stack, Co
         throw new ExpressionParseException("Cannot assign literal to variable");
     }
 
-
     private void testBetweenOperation(String[] tokens, int pos) throws ExpressionParseException {
 
         Expression left = this.leftOperand;
@@ -85,4 +85,8 @@ private void testBetweenOperation(String[] tokens, int pos) throws ExpressionPar
 
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/relational/Equals.java b/src/main/java/org/dvare/expression/operation/relational/Equals.java
index b4292e7..4b6b2d7 100644
--- a/src/main/java/org/dvare/expression/operation/relational/Equals.java
+++ b/src/main/java/org/dvare/expression/operation/relational/Equals.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.relational;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.operation.OperationType;
 import org.dvare.expression.operation.RelationalOperationExpression;
 
@@ -14,5 +15,8 @@ public Equals() {
         super(OperationType.EQUAL);
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/relational/GreaterEqual.java b/src/main/java/org/dvare/expression/operation/relational/GreaterEqual.java
index ecb89dc..7666900 100644
--- a/src/main/java/org/dvare/expression/operation/relational/GreaterEqual.java
+++ b/src/main/java/org/dvare/expression/operation/relational/GreaterEqual.java
@@ -2,6 +2,7 @@
 
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.OperationType;
 import org.dvare.expression.operation.RelationalOperationExpression;
@@ -16,5 +17,8 @@ public GreaterEqual() {
         super(OperationType.GREATER_EQUAL);
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/relational/GreaterThan.java b/src/main/java/org/dvare/expression/operation/relational/GreaterThan.java
index ab9cdf5..7583441 100644
--- a/src/main/java/org/dvare/expression/operation/relational/GreaterThan.java
+++ b/src/main/java/org/dvare/expression/operation/relational/GreaterThan.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.relational;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.OperationType;
 import org.dvare.expression.operation.RelationalOperationExpression;
@@ -15,5 +16,8 @@ public GreaterThan() {
         super(OperationType.GREATER);
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/relational/In.java b/src/main/java/org/dvare/expression/operation/relational/In.java
index 55c9caa..8b7b4f7 100644
--- a/src/main/java/org/dvare/expression/operation/relational/In.java
+++ b/src/main/java/org/dvare/expression/operation/relational/In.java
@@ -5,6 +5,7 @@
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.exceptions.parser.IllegalOperationException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.ListLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.OperationType;
@@ -41,7 +42,6 @@ public Integer parse(final String[] tokens, int pos, Stack<Expression> stack, Co
         throw new ExpressionParseException("Cannot assign literal to variable");
     }
 
-
     private void testInOperation(String[] tokens, int pos) throws ExpressionParseException {
         /*Expression left = this.leftOperand;*/
         Expression right = this.rightOperand;
@@ -79,4 +79,9 @@ private void testInOperation(String[] tokens, int pos) throws ExpressionParseExc
             logger.debug("OperationExpression Call Expression : {}", getClass().getSimpleName());
         }
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/relational/LessEqual.java b/src/main/java/org/dvare/expression/operation/relational/LessEqual.java
index e29942b..e620e54 100644
--- a/src/main/java/org/dvare/expression/operation/relational/LessEqual.java
+++ b/src/main/java/org/dvare/expression/operation/relational/LessEqual.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.relational;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.OperationType;
 import org.dvare.expression.operation.RelationalOperationExpression;
@@ -15,5 +16,8 @@ public LessEqual() {
         super(OperationType.LESS_EQUAL);
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/relational/LessThan.java b/src/main/java/org/dvare/expression/operation/relational/LessThan.java
index 1e2a031..71794b1 100644
--- a/src/main/java/org/dvare/expression/operation/relational/LessThan.java
+++ b/src/main/java/org/dvare/expression/operation/relational/LessThan.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.relational;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.operation.OperationType;
 import org.dvare.expression.operation.RelationalOperationExpression;
@@ -15,5 +16,8 @@ public LessThan() {
         super(OperationType.LESS);
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/relational/NotEquals.java b/src/main/java/org/dvare/expression/operation/relational/NotEquals.java
index 91d0fd7..1dceb05 100644
--- a/src/main/java/org/dvare/expression/operation/relational/NotEquals.java
+++ b/src/main/java/org/dvare/expression/operation/relational/NotEquals.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.relational;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.operation.OperationType;
 import org.dvare.expression.operation.RelationalOperationExpression;
 
@@ -14,5 +15,8 @@ public NotEquals() {
         super(OperationType.NOT_EQUAL);
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/relational/NotIn.java b/src/main/java/org/dvare/expression/operation/relational/NotIn.java
index 655bbd4..9b5225d 100644
--- a/src/main/java/org/dvare/expression/operation/relational/NotIn.java
+++ b/src/main/java/org/dvare/expression/operation/relational/NotIn.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.relational;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.operation.OperationType;
 
 /**
@@ -12,4 +13,9 @@ public class NotIn extends In {
     public NotIn() {
         super(OperationType.NOT_IN);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/DateOperation.java b/src/main/java/org/dvare/expression/operation/utility/DateOperation.java
index c8ae052..6a24682 100644
--- a/src/main/java/org/dvare/expression/operation/utility/DateOperation.java
+++ b/src/main/java/org/dvare/expression/operation/utility/DateOperation.java
@@ -5,6 +5,7 @@
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.exceptions.parser.IllegalValueException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.NamedExpression;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.DateLiteral;
@@ -81,5 +82,9 @@ public Integer parse(String[] tokens, int pos, Stack<Expression> stack, Contexts
         return pos;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/DateTimeOperation.java b/src/main/java/org/dvare/expression/operation/utility/DateTimeOperation.java
index b8dcbe1..5413a36 100644
--- a/src/main/java/org/dvare/expression/operation/utility/DateTimeOperation.java
+++ b/src/main/java/org/dvare/expression/operation/utility/DateTimeOperation.java
@@ -6,6 +6,7 @@
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.exceptions.parser.IllegalValueException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.NamedExpression;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.DateTimeLiteral;
@@ -108,5 +109,9 @@ public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> st
         return null;
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/DefOperation.java b/src/main/java/org/dvare/expression/operation/utility/DefOperation.java
index 98d82ca..4f7cc5e 100644
--- a/src/main/java/org/dvare/expression/operation/utility/DefOperation.java
+++ b/src/main/java/org/dvare/expression/operation/utility/DefOperation.java
@@ -1,13 +1,20 @@
 package org.dvare.expression.operation.utility;
 
 import org.dvare.annotations.Operation;
+import org.dvare.annotations.Type;
+import org.dvare.binding.data.InstancesBinding;
 import org.dvare.binding.model.ContextsBinding;
 import org.dvare.binding.model.TypeBinding;
+import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
+import org.dvare.expression.datatype.DataTypeExpression;
+import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.OperationExpression;
 import org.dvare.expression.operation.OperationType;
+import org.dvare.expression.veriable.ListVariable;
 import org.dvare.expression.veriable.VariableExpression;
 import org.dvare.expression.veriable.VariableType;
 
@@ -30,6 +37,9 @@ public DefOperation() {
     public Integer parse(String[] tokens, int pos, Stack<Expression> stack, ContextsBinding contexts) throws ExpressionParseException {
         pos = findNextExpression(tokens, pos + 1, stack, contexts);
 
+        this.leftOperand = stack.pop();
+        stack.push(this);
+
         return pos;
     }
 
@@ -74,5 +84,54 @@ public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> st
         return pos;
     }
 
+    @Override
+    public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws InterpretException {
+        return leftOperand.interpret(instancesBinding);
+    }
+
+    @Override
+    public String toString() {
+        var sb = new StringBuilder();
+
+        sb.append(operationType.getTokens().get(0));
+        sb.append(" ");
+
+        if (leftOperand != null && leftOperand instanceof VariableExpression<?>) {
+            var ve = (VariableExpression<?>) leftOperand;
+
+            if (ve.getOperandType() != null) {
+                sb.append(ve.getOperandType());
+                sb.append(".");
+            }
+            sb.append(ve.getName());
+            sb.append(":");
+            sb.append(getDataType(ve));
+
+            sb.append(" ");
+        }
+
+        return sb.toString();
+    }
+
+    private DataType getDataType(VariableExpression<?> ve) {
+        Class<? extends DataTypeExpression> dataTypeExpressionClass;
+        if (ve instanceof ListVariable) {
+            dataTypeExpressionClass = ((ListVariable) ve).getListType();
+        } else {
+            dataTypeExpressionClass = (ve).getType();
+        }
+
+        if (dataTypeExpressionClass.isAnnotationPresent(Type.class)) {
+            Type type = dataTypeExpressionClass.getAnnotation(Type.class);
+            return type.dataType();
+        }
+
+        throw new IllegalArgumentException("VariableExpression does not contain a @Type annotated type or listType");
+    }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/EndForAll.java b/src/main/java/org/dvare/expression/operation/utility/EndForAll.java
index e8e56a3..49166f2 100644
--- a/src/main/java/org/dvare/expression/operation/utility/EndForAll.java
+++ b/src/main/java/org/dvare/expression/operation/utility/EndForAll.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.utility;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.operation.IterationOperationExpression;
 import org.dvare.expression.operation.OperationType;
 
@@ -15,5 +16,8 @@ public EndForAll() {
         super(OperationType.END_FORALL);
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/EndForEach.java b/src/main/java/org/dvare/expression/operation/utility/EndForEach.java
index 612299f..78b74f0 100644
--- a/src/main/java/org/dvare/expression/operation/utility/EndForEach.java
+++ b/src/main/java/org/dvare/expression/operation/utility/EndForEach.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.operation.utility;
 
 import org.dvare.annotations.Operation;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.operation.IterationOperationExpression;
 import org.dvare.expression.operation.OperationType;
 
@@ -15,4 +16,9 @@ public EndForEach() {
         super(OperationType.END_FOREACH);
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/ExpressionSeparator.java b/src/main/java/org/dvare/expression/operation/utility/ExpressionSeparator.java
index ab17060..566eae2 100644
--- a/src/main/java/org/dvare/expression/operation/utility/ExpressionSeparator.java
+++ b/src/main/java/org/dvare/expression/operation/utility/ExpressionSeparator.java
@@ -8,6 +8,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.OperationExpression;
@@ -71,7 +72,8 @@ public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> st
             OperationExpression op = configurationRegistry.getOperation(tokens[pos]);
             if (op != null) {
                 pos = op.parse(tokens, pos, stack, contexts);
-                if (!(stack.peek() instanceof VariableExpression)) {
+                var peek = stack.peek();
+                if (!(peek instanceof VariableExpression || peek instanceof DefOperation)) {
                     return pos;
                 }
 
@@ -89,5 +91,9 @@ public LiteralExpression interpret(InstancesBinding instancesBinding) throws Int
 
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/ForAll.java b/src/main/java/org/dvare/expression/operation/utility/ForAll.java
index cfc39ca..b26129c 100644
--- a/src/main/java/org/dvare/expression/operation/utility/ForAll.java
+++ b/src/main/java/org/dvare/expression/operation/utility/ForAll.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.DataRow;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.NamedExpression;
 import org.dvare.expression.datatype.BooleanType;
 import org.dvare.expression.literal.ListLiteral;
@@ -151,4 +152,9 @@ public String toString() {
 
 
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/ForEach.java b/src/main/java/org/dvare/expression/operation/utility/ForEach.java
index d3d1a6d..7c91cab 100644
--- a/src/main/java/org/dvare/expression/operation/utility/ForEach.java
+++ b/src/main/java/org/dvare/expression/operation/utility/ForEach.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.data.DataRow;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.NamedExpression;
 import org.dvare.expression.datatype.NullType;
 import org.dvare.expression.literal.ListLiteral;
@@ -127,5 +128,8 @@ else if (referenceContext instanceof VariableExpression) {
         return new NullLiteral<>();
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/operation/utility/Function.java b/src/main/java/org/dvare/expression/operation/utility/Function.java
index 94282d3..b4165fc 100644
--- a/src/main/java/org/dvare/expression/operation/utility/Function.java
+++ b/src/main/java/org/dvare/expression/operation/utility/Function.java
@@ -9,6 +9,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.FunctionExpression;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.DataTypeExpression;
@@ -148,6 +149,11 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
 
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 
     protected LiteralExpression<?> interpretFunction(InstancesBinding instancesBinding) throws InterpretException {
 
diff --git a/src/main/java/org/dvare/expression/operation/utility/Invoke.java b/src/main/java/org/dvare/expression/operation/utility/Invoke.java
index 83e4341..fba80e1 100644
--- a/src/main/java/org/dvare/expression/operation/utility/Invoke.java
+++ b/src/main/java/org/dvare/expression/operation/utility/Invoke.java
@@ -8,6 +8,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.FunctionExpression;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.datatype.DataTypeExpression;
@@ -195,5 +196,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
 
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/LeftPriority.java b/src/main/java/org/dvare/expression/operation/utility/LeftPriority.java
index fe7b7e6..d8ee521 100644
--- a/src/main/java/org/dvare/expression/operation/utility/LeftPriority.java
+++ b/src/main/java/org/dvare/expression/operation/utility/LeftPriority.java
@@ -1,10 +1,14 @@
 package org.dvare.expression.operation.utility;
 
 import org.dvare.annotations.Operation;
+import org.dvare.binding.data.InstancesBinding;
 import org.dvare.binding.model.ContextsBinding;
 import org.dvare.config.ConfigurationRegistry;
+import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
+import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.OperationExpression;
 import org.dvare.expression.operation.OperationType;
 
@@ -31,7 +35,11 @@ public Integer parse(String[] tokens, int pos, Stack<Expression> stack, Contexts
         }
 
         if (stack.peek().getClass().equals(RightPriority.class)) {
-            stack.pop();
+            // pop RightPriority
+            this.rightOperand = stack.pop();
+            // pop contents of parenthesis
+            this.leftOperand = stack.pop();
+            stack.push(this);
         }
 
         return pos;
@@ -61,4 +69,37 @@ public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> st
         }
         return pos;
     }
+
+    @Override
+    public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws InterpretException {
+        return interpretOperand(leftOperand, instancesBinding);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder toStringBuilder = new StringBuilder();
+
+        // left parenthesis
+        toStringBuilder.append(operationType.getTokens().get(0));
+        toStringBuilder.append(" ");
+
+        // parenthesis content
+        if (leftOperand != null) {
+            toStringBuilder.append(leftOperand.toString());
+            toStringBuilder.append(" ");
+        }
+
+        // right parenthesis
+        if (rightOperand != null) {
+            toStringBuilder.append(rightOperand.toString());
+            toStringBuilder.append(" ");
+        }
+
+        return toStringBuilder.toString();
+    }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/LetOperation.java b/src/main/java/org/dvare/expression/operation/utility/LetOperation.java
index 9b5c94d..ca3b055 100644
--- a/src/main/java/org/dvare/expression/operation/utility/LetOperation.java
+++ b/src/main/java/org/dvare/expression/operation/utility/LetOperation.java
@@ -8,6 +8,7 @@
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.exceptions.parser.IllegalPropertyException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.NamedExpression;
 import org.dvare.expression.datatype.DataType;
 import org.dvare.expression.literal.LiteralExpression;
@@ -137,5 +138,8 @@ public String toString() {
         return toStringBuilder.toString();
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/PrintOperation.java b/src/main/java/org/dvare/expression/operation/utility/PrintOperation.java
index fa4d616..08f637b 100644
--- a/src/main/java/org/dvare/expression/operation/utility/PrintOperation.java
+++ b/src/main/java/org/dvare/expression/operation/utility/PrintOperation.java
@@ -8,6 +8,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.NullLiteral;
 import org.dvare.expression.operation.OperationExpression;
@@ -114,4 +115,9 @@ public String toString() {
 
         return toStringBuilder.toString();
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/RightPriority.java b/src/main/java/org/dvare/expression/operation/utility/RightPriority.java
index 2acf45f..1f77418 100644
--- a/src/main/java/org/dvare/expression/operation/utility/RightPriority.java
+++ b/src/main/java/org/dvare/expression/operation/utility/RightPriority.java
@@ -4,6 +4,7 @@
 import org.dvare.binding.model.ContextsBinding;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.operation.OperationExpression;
 import org.dvare.expression.operation.OperationType;
 
@@ -28,4 +29,14 @@ public Integer parse(String[] tokens, int pos, Stack<Expression> stack, Contexts
     public Integer findNextExpression(String[] tokens, int pos, Stack<Expression> stack, ContextsBinding contexts) throws ExpressionParseException {
         return pos;
     }
+
+    @Override
+    public String toString() {
+        return operationType.getTokens().get(0);
+    }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/operation/utility/Today.java b/src/main/java/org/dvare/expression/operation/utility/Today.java
index 5ceb6ce..b3b8da0 100644
--- a/src/main/java/org/dvare/expression/operation/utility/Today.java
+++ b/src/main/java/org/dvare/expression/operation/utility/Today.java
@@ -7,6 +7,7 @@
 import org.dvare.exceptions.interpreter.InterpretException;
 import org.dvare.exceptions.parser.ExpressionParseException;
 import org.dvare.expression.Expression;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.literal.DateLiteral;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.operation.OperationExpression;
@@ -59,5 +60,8 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return new DateLiteral(date);
     }
 
-
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/veriable/BooleanVariable.java b/src/main/java/org/dvare/expression/veriable/BooleanVariable.java
index f285f85..bc336e9 100644
--- a/src/main/java/org/dvare/expression/veriable/BooleanVariable.java
+++ b/src/main/java/org/dvare/expression/veriable/BooleanVariable.java
@@ -5,6 +5,7 @@
  * @since 2016-06-30
  */
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.BooleanType;
 
 public class BooleanVariable extends VariableExpression<Boolean> {
@@ -20,4 +21,8 @@ public BooleanVariable(String name, Boolean value) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/veriable/DateTimeVariable.java b/src/main/java/org/dvare/expression/veriable/DateTimeVariable.java
index 9b4ff1f..d60aa3a 100644
--- a/src/main/java/org/dvare/expression/veriable/DateTimeVariable.java
+++ b/src/main/java/org/dvare/expression/veriable/DateTimeVariable.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.veriable;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DateTimeType;
 
 import java.time.LocalDateTime;
@@ -20,4 +21,8 @@ public DateTimeVariable(String name, LocalDateTime localDateTime) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/veriable/DateVariable.java b/src/main/java/org/dvare/expression/veriable/DateVariable.java
index 1f2cfae..278f36f 100644
--- a/src/main/java/org/dvare/expression/veriable/DateVariable.java
+++ b/src/main/java/org/dvare/expression/veriable/DateVariable.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.veriable;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.DateType;
 
 import java.time.LocalDate;
@@ -23,4 +24,8 @@ public DateVariable(String name, LocalDate localDate) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/veriable/FloatVariable.java b/src/main/java/org/dvare/expression/veriable/FloatVariable.java
index e177dc3..82c9a97 100644
--- a/src/main/java/org/dvare/expression/veriable/FloatVariable.java
+++ b/src/main/java/org/dvare/expression/veriable/FloatVariable.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.veriable;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.FloatType;
 
 /**
@@ -18,4 +19,9 @@ public FloatVariable(String name) {
     public FloatVariable(String name, Float value) {
         super(name, FloatType.class, value);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/veriable/IntegerVariable.java b/src/main/java/org/dvare/expression/veriable/IntegerVariable.java
index cb4ea13..7ec7c5e 100644
--- a/src/main/java/org/dvare/expression/veriable/IntegerVariable.java
+++ b/src/main/java/org/dvare/expression/veriable/IntegerVariable.java
@@ -1,5 +1,6 @@
 package org.dvare.expression.veriable;
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.IntegerType;
 
 /**
@@ -15,4 +16,9 @@ public IntegerVariable(String name) {
     public IntegerVariable(String name, Integer value) {
         super(name, IntegerType.class, value);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/veriable/ListVariable.java b/src/main/java/org/dvare/expression/veriable/ListVariable.java
index 880b032..d1ed411 100644
--- a/src/main/java/org/dvare/expression/veriable/ListVariable.java
+++ b/src/main/java/org/dvare/expression/veriable/ListVariable.java
@@ -4,6 +4,7 @@
 import org.dvare.annotations.Type;
 import org.dvare.binding.data.InstancesBinding;
 import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.*;
 import org.dvare.expression.literal.LiteralExpression;
 import org.dvare.expression.literal.LiteralType;
@@ -66,4 +67,9 @@ public LiteralExpression<?> interpret(InstancesBinding instancesBinding) throws
         return LiteralType.getLiteralExpression(value, getListType());
     }
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
+
 }
diff --git a/src/main/java/org/dvare/expression/veriable/PairVariable.java b/src/main/java/org/dvare/expression/veriable/PairVariable.java
index bea7d4a..e3c4209 100644
--- a/src/main/java/org/dvare/expression/veriable/PairVariable.java
+++ b/src/main/java/org/dvare/expression/veriable/PairVariable.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.veriable;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.PairType;
 import org.dvare.util.Pair;
 
@@ -20,4 +21,8 @@ public PairVariable(String name, Pair<?, ?> value) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/veriable/RegexVariable.java b/src/main/java/org/dvare/expression/veriable/RegexVariable.java
index 05f2c20..73870a1 100644
--- a/src/main/java/org/dvare/expression/veriable/RegexVariable.java
+++ b/src/main/java/org/dvare/expression/veriable/RegexVariable.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.veriable;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.RegexType;
 
 /**
@@ -16,4 +17,9 @@ public RegexVariable(String name) {
     public RegexVariable(String name, String value) {
         super(name, RegexType.class, value);
     }
+
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/org/dvare/expression/veriable/SimpleDateVariable.java b/src/main/java/org/dvare/expression/veriable/SimpleDateVariable.java
index 7d60db3..eb96142 100644
--- a/src/main/java/org/dvare/expression/veriable/SimpleDateVariable.java
+++ b/src/main/java/org/dvare/expression/veriable/SimpleDateVariable.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.veriable;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.SimpleDateType;
 
 import java.util.Date;
@@ -23,4 +24,8 @@ public SimpleDateVariable(String name, Date date) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/veriable/StringVariable.java b/src/main/java/org/dvare/expression/veriable/StringVariable.java
index f40c99d..edd43ef 100644
--- a/src/main/java/org/dvare/expression/veriable/StringVariable.java
+++ b/src/main/java/org/dvare/expression/veriable/StringVariable.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.veriable;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.StringType;
 
 /**
@@ -19,4 +20,8 @@ public StringVariable(String name, String value) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/veriable/TripleVariable.java b/src/main/java/org/dvare/expression/veriable/TripleVariable.java
index 72db53e..4981a18 100644
--- a/src/main/java/org/dvare/expression/veriable/TripleVariable.java
+++ b/src/main/java/org/dvare/expression/veriable/TripleVariable.java
@@ -1,6 +1,7 @@
 package org.dvare.expression.veriable;
 
 
+import org.dvare.expression.ExpressionVisitor;
 import org.dvare.expression.datatype.TripleType;
 import org.dvare.util.Triple;
 
@@ -20,4 +21,8 @@ public TripleVariable(String name, Triple<?, ?, ?> value) {
     }
 
 
+    @Override
+    public <T> T accept(ExpressionVisitor<T> v) {
+        return v.visit(this);
+    }
 }
diff --git a/src/main/java/org/dvare/expression/veriable/VariableExpression.java b/src/main/java/org/dvare/expression/veriable/VariableExpression.java
index bb513d9..0ce5184 100644
--- a/src/main/java/org/dvare/expression/veriable/VariableExpression.java
+++ b/src/main/java/org/dvare/expression/veriable/VariableExpression.java
@@ -87,4 +87,5 @@ public String getOperandType() {
     public void setOperandType(String operandType) {
         this.operandType = operandType;
     }
+
 }
diff --git a/src/test/java/org/dvare/test/BaseExpressionVisitorTest.java b/src/test/java/org/dvare/test/BaseExpressionVisitorTest.java
new file mode 100644
index 0000000..ebfdbca
--- /dev/null
+++ b/src/test/java/org/dvare/test/BaseExpressionVisitorTest.java
@@ -0,0 +1,1518 @@
+package org.dvare.test;
+
+import org.dvare.expression.*;
+import org.dvare.expression.datatype.*;
+import org.dvare.expression.literal.*;
+import org.dvare.expression.operation.*;
+import org.dvare.expression.operation.aggregation.*;
+import org.dvare.expression.operation.arithmetic.*;
+import org.dvare.expression.operation.flow.*;
+import org.dvare.expression.operation.list.*;
+import org.dvare.expression.operation.logical.And;
+import org.dvare.expression.operation.logical.Implies;
+import org.dvare.expression.operation.logical.Not;
+import org.dvare.expression.operation.logical.OR;
+import org.dvare.expression.operation.predefined.*;
+import org.dvare.expression.operation.relational.*;
+import org.dvare.expression.operation.utility.*;
+import org.dvare.expression.veriable.*;
+import org.dvare.util.Pair;
+import org.dvare.util.Triple;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationTargetException;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+public class BaseExpressionVisitorTest {
+    private final BaseExpressionVisitor v = new BaseExpressionVisitor();
+
+    @Test
+    public void visitFunctionExpression() {
+        var o = new FunctionExpression("Func1", null);
+        o.addParameter(new NamedExpression("S1"));
+        o.addParameter(new NamedExpression("I1"));
+
+        var e = o.accept(v);
+        Assertions.assertNotEquals(o, e);
+
+        Assertions.assertEquals(o.getClass(), e.getClass());
+        var n = (FunctionExpression) e;
+
+        Assertions.assertEquals(o.name.toString(), n.name.toString());
+        Assertions.assertEquals(o.getParameters().size(), n.getParameters().size());
+        for (var i = 0; i < o.getParameters().size(); i++) {
+            Assertions.assertEquals(o.getParameters().get(i).toString(), n.getParameters().get(i).toString());
+        }
+    }
+
+    @Test
+    public void visitNamedExpression() {
+        var o = new NamedExpression("name");
+        var e = o.accept(v);
+        Assertions.assertNotEquals(o, e);
+
+        Assertions.assertEquals(o.getClass(), e.getClass());
+        var n = (NamedExpression) e;
+
+        Assertions.assertEquals(o.getName(), n.getName());
+    }
+
+    private void visitBooleanExpression(boolean val) {
+        var o = new BooleanExpression("bn", val);
+        var e = o.accept(v);
+        Assertions.assertNotEquals(o, e);
+
+        Assertions.assertEquals(o.getClass(), e.getClass());
+        var n = (BooleanExpression) e;
+
+        Assertions.assertEquals(o.getName(), n.getName());
+        Assertions.assertEquals(o.isValue(), n.isValue());
+    }
+
+    @Test
+    public void visitBooleanExpression() {
+        visitBooleanExpression(true);
+        visitBooleanExpression(false);
+    }
+
+    private  <T extends DataTypeExpression> void visitDataTypeExpression(Class<T> clazz) {
+        try {
+            var o = clazz.getDeclaredConstructor().newInstance();
+            var e = o.accept(v);
+            Assertions.assertNotEquals(o, e);
+            Assertions.assertEquals(o.getClass(), e.getClass());
+            var n = clazz.cast(e);
+            Assertions.assertEquals(o.getDataType(), n.getDataType());
+        } catch (InstantiationException | InvocationTargetException | IllegalAccessException |
+                 NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    public void visitBooleanListType() {
+        visitDataTypeExpression(BooleanListType.class);
+    }
+
+    @Test
+    public void visitBooleanType() {
+        visitDataTypeExpression(BooleanType.class);
+    }
+
+    @Test
+    public void visitDateListType() {
+        visitDataTypeExpression(DateListType.class);
+    }
+
+    @Test
+    public void visitDateTimeListType() {
+        visitDataTypeExpression(DateTimeListType.class);
+    }
+
+    @Test
+    public void visitListType() {
+        visitDataTypeExpression(ListType.class);
+    }
+
+    @Test
+    public void visitDateTimeType() {
+        visitDataTypeExpression(DateTimeType.class);
+    }
+
+    @Test
+    public void visitDateType() {
+        visitDataTypeExpression(DateType.class);
+    }
+
+    @Test
+    public void visitFloatListType() {
+        visitDataTypeExpression(FloatListType.class);
+    }
+
+    @Test
+    public void visitFloatType() {
+        visitDataTypeExpression(FloatType.class);
+    }
+
+    @Test
+    public void visitIntegerListType() {
+        visitDataTypeExpression(IntegerListType.class);
+    }
+
+    @Test
+    public void visitIntegerType() {
+        visitDataTypeExpression(IntegerType.class);
+    }
+
+    @Test
+    public void visitNullType() {
+        visitDataTypeExpression(NullType.class);
+    }
+
+    @Test
+    public void visitPairListType() {
+        visitDataTypeExpression(PairListType.class);
+    }
+
+    @Test
+    public void visitPairType() {
+        visitDataTypeExpression(PairType.class);
+    }
+
+    @Test
+    public void visitRegexType() {
+        visitDataTypeExpression(RegexType.class);
+    }
+
+    @Test
+    public void visitSimpleDateListType() {
+        visitDataTypeExpression(SimpleDateListType.class);
+    }
+
+    @Test
+    public void visitSimpleDateType() {
+        visitDataTypeExpression(SimpleDateType.class);
+    }
+
+    @Test
+    public void visitStringListType() {
+        visitDataTypeExpression(StringListType.class);
+    }
+
+    @Test
+    public void visitStringType() {
+        visitDataTypeExpression(StringType.class);
+    }
+
+    @Test
+    public void visitTripleListType() {
+        visitDataTypeExpression(TripleListType.class);
+    }
+
+    @Test
+    public void visitTripleType() {
+        visitDataTypeExpression(TripleType.class);
+    }
+
+    private <T extends LiteralExpression<?>> T visitLiteralExpression(T o) {
+        var e = o.accept(v);
+        Assertions.assertNotEquals(o, e);
+        Assertions.assertEquals(o.getClass(), e.getClass());
+        @SuppressWarnings("unchecked") var n = (T) e;
+
+        Assertions.assertEquals(o.getType(), n.getType());
+        Assertions.assertEquals(o.getValue(), n.getValue());
+
+        Assertions.assertEquals(o.toString(), n.toString());
+
+        return n;
+    }
+
+    @Test
+    public void visitBooleanLiteral() {
+        visitLiteralExpression(new BooleanLiteral(true));
+        visitLiteralExpression(new BooleanLiteral(false));
+    }
+
+    @Test
+    public void visitDateLiteral() {
+        visitLiteralExpression(new DateLiteral(LocalDate.now()));
+    }
+
+    @Test
+    public void visitDateTimeLiteral() {
+        visitLiteralExpression(new DateTimeLiteral(LocalDateTime.now()));
+    }
+
+    @Test
+    public void visitFloatLiteral() {
+        visitLiteralExpression(new FloatLiteral(13.8F));
+    }
+
+    @Test
+    public void visitIntegerLiteral() {
+        visitLiteralExpression(new IntegerLiteral(43));
+    }
+
+    @Test
+    public void visitListLiteral() {
+        var l = List.of(0, 1, 2, 3);
+        var o = new ListLiteral(l, IntegerType.class);
+        var n = visitLiteralExpression(o);
+        Assertions.assertEquals(o.getListType(), n.getListType());
+        Assertions.assertEquals(o.getSize(), n.getSize());
+    }
+
+    @Test
+    public void visitNullLiteral() {
+        visitLiteralExpression(new NullLiteral<>());
+    }
+
+    @Test
+    public void visitPairLiteral() {
+        var o = new Pair.PairImpl<>("A", "B");
+        var n = visitLiteralExpression(new PairLiteral(o));
+        Assertions.assertEquals(o.left, n.getValue().getLeft());
+        Assertions.assertEquals(o.right, n.getValue().getRight());
+    }
+
+    @Test
+    public void visitRegexLiteral() {
+        visitLiteralExpression(new RegexLiteral("\\s+"));
+    }
+
+    @Test
+    public void visitSimpleDateLiteral() {
+        visitLiteralExpression(new SimpleDateLiteral(new Date()));
+    }
+
+    @Test
+    public void visitStringLiteral() {
+        visitLiteralExpression(new StringLiteral("abcdefg"));
+    }
+
+    @Test
+    public void visitTripleLiteral() {
+        var o = new Triple.TripleImpl<>("A", "B", "C");
+        var n = visitLiteralExpression(new TripleLiteral(o));
+        Assertions.assertEquals(o.left, n.getValue().getLeft());
+        Assertions.assertEquals(o.middle, n.getValue().getMiddle());
+        Assertions.assertEquals(o.right, n.getValue().getRight());
+    }
+
+    private <T extends VariableExpression<?>> T visitVariableExpression(T o) {
+        var e = o.accept(v);
+        Assertions.assertNotEquals(o, e);
+        Assertions.assertEquals(o.getClass(), e.getClass());
+        @SuppressWarnings("unchecked") var n = (T) e;
+
+        Assertions.assertEquals(o.getName(), n.getName());
+        Assertions.assertEquals(o.getType(), n.getType());
+        Assertions.assertEquals(o.getValue(), n.getValue());
+        Assertions.assertEquals(o.getOperandType(), n.getOperandType());
+
+        Assertions.assertEquals(o.toString(), n.toString());
+
+        return n;
+    }
+
+    @Test
+    public void visitBooleanVariable() {
+        visitVariableExpression(new BooleanVariable("b1", true));
+        visitVariableExpression(new BooleanVariable("b1", false));
+    }
+
+    @Test
+    public void visitDateTimeVariable() {
+        visitVariableExpression(new DateTimeVariable("dt", LocalDateTime.now()));
+    }
+
+    @Test
+    public void visitDateVariable() {
+        visitVariableExpression(new DateVariable("d", LocalDate.now()));
+    }
+
+    @Test
+    public void visitFloatVariable() {
+        visitVariableExpression(new FloatVariable("f", 0.123F));
+    }
+
+    @Test
+    public void visitIntegerVariable() {
+        visitVariableExpression(new IntegerVariable("i", 8213));
+    }
+
+    @Test
+    public void visitListVariable() {
+        var l = List.of(0, 1, 2, 3);
+        var o = new ListVariable("l", IntegerType.class);
+        o.setValue(l);
+        var n = visitVariableExpression(o);
+        Assertions.assertEquals(o.getListType(), n.getListType());
+        Assertions.assertEquals(o.getSize(), n.getSize());
+        for (var i = 0; i < l.size(); i++) {
+            Assertions.assertEquals(o.getValue().get(i), n.getValue().get(i));
+        }
+    }
+
+    @Test
+    public void visitPairVariable() {
+        var p = new Pair.PairImpl<>("A", "B");
+        var o = new PairVariable("o");
+        o.setValue(p);
+        var n = visitVariableExpression(o);
+        Assertions.assertEquals(o.getValue().getLeft(), n.getValue().getLeft());
+        Assertions.assertEquals(o.getValue().getRight(), n.getValue().getRight());
+    }
+
+    @Test
+    public void visitRegexVariable() {
+        visitVariableExpression(new RegexVariable("r", "\\s+"));
+    }
+
+    @Test
+    public void visitSimpleDateVariable() {
+        visitVariableExpression(new SimpleDateVariable("sd", new Date()));
+    }
+
+    @Test
+    public void visitStringVariable() {
+        visitVariableExpression(new StringVariable("s", "value"));
+    }
+
+    @Test
+    public void visitTripleVariable() {
+        var t = new Triple.TripleImpl<>("A", "B", "C");
+        var o = new TripleVariable("t");
+        o.setValue(t);
+        var n = visitVariableExpression(o);
+        Assertions.assertEquals(o.getValue().getLeft(), n.getValue().getLeft());
+        Assertions.assertEquals(o.getValue().getMiddle(), n.getValue().getMiddle());
+        Assertions.assertEquals(o.getValue().getRight(), n.getValue().getRight());
+    }
+
+
+    @Test
+    public void visitAssignOperationExpression() {
+        var ol = new StringVariable("s");
+        var or = new StringLiteral("value");
+        var o = new AssignOperationExpression();
+        o.setLeftOperand(ol);
+        o.setRightOperand(or);
+
+        var e = o.accept(v);
+        Assertions.assertNotEquals(o, e);
+
+        Assertions.assertEquals(o.getClass(), e.getClass());
+        var n = (AssignOperationExpression) e;
+
+        Assertions.assertEquals(o.getLeftOperand().getClass(), n.getLeftOperand().getClass());
+        Assertions.assertEquals(o.getRightOperand().getClass(), n.getRightOperand().getClass());
+
+        var nl = (StringVariable) n.getLeftOperand();
+        Assertions.assertEquals(ol.getName(), nl.getName());
+        Assertions.assertEquals(ol.getType(), nl.getType());
+        Assertions.assertEquals(ol.getValue(), nl.getValue());
+        Assertions.assertEquals(ol.getOperandType(), nl.getOperandType());
+
+        var nr = (StringLiteral) n.getRightOperand();
+        Assertions.assertEquals(or.getType(), nr.getType());
+        Assertions.assertEquals(or.getValue(), nr.getValue());
+
+        Assertions.assertEquals(o.toString(), n.toString());
+    }
+
+    @Test
+    public void visitCompositeOperationExpression() {
+        List<Expression> ol = List.of(new StringLiteral("A"), new StringLiteral("B"), new StringLiteral("C"));
+        var o = new CompositeOperationExpression(ol);
+
+        var e = o.accept(v);
+        Assertions.assertNotEquals(o, e);
+
+        Assertions.assertEquals(o.getClass(), e.getClass());
+        var n = (CompositeOperationExpression) e;
+
+        Assertions.assertEquals(o.getExpressions().size(), n.getExpressions().size());
+
+        for (var i = 0; i < o.getExpressions().size(); i++) {
+            var oe = o.getExpressions().get(i);
+            var ne = n.getExpressions().get(i);
+            Assertions.assertEquals(oe.getClass(), ne.getClass());
+
+            var os = (StringLiteral) oe;
+            var ns = (StringLiteral) ne;
+
+            Assertions.assertEquals(os.getType(), ns.getType());
+            Assertions.assertEquals(os.getValue(), ns.getValue());
+        }
+
+        Assertions.assertEquals(o.toString(), n.toString());
+    }
+
+    private <T extends IterationOperationExpression> T visitIterationOperationExpression(T o) {
+        o.setReferenceContext(new NamedExpression("ref"));
+        o.setDerivedContext(new NamedExpression("der"));
+        o.setLeftOperand(new PrintOperation());
+        o.setRightOperand(new PrintOperation());
+
+        var e = o.accept(v);
+        Assertions.assertNotEquals(o, e);
+
+        Assertions.assertEquals(o.getClass(), e.getClass());
+        @SuppressWarnings("unchecked") var n = (T) e;
+
+        Assertions.assertEquals(o.getOperationType(), n.getOperationType());
+        Assertions.assertEquals(o.getDerivedContext().getName(), n.getDerivedContext().getName());
+        Assertions.assertEquals(o.getReferenceContext().toString(), n.getReferenceContext().toString());
+
+        Assertions.assertEquals(o.getLeftOperand().getClass(), n.getLeftOperand().getClass());
+        Assertions.assertEquals(o.getRightOperand().getClass(), n.getRightOperand().getClass());
+
+        Assertions.assertEquals(o.toString(), n.toString());
+
+        return n;
+    }
+
+    @Test
+    public void visitIterationOperationExpression() {
+        var o = new IterationOperationExpression(OperationType.FORALL);
+        visitIterationOperationExpression(o);
+    }
+
+    @Test
+    public void visitListLiteralOperationENDExpression() {
+        var o = new ListLiteralOperationENDExpression();
+        var e = o.accept(v);
+        Assertions.assertNotEquals(o, e);
+        Assertions.assertEquals(o.getClass(), e.getClass());
+    }
+
+    @Test
+    public void visitListLiteralOperationExpression() {
+        var o = new ListLiteralOperationExpression();
+        List<Expression> ol = List.of(new StringLiteral("A"), new StringLiteral("B"), new StringLiteral("C"));
+        o.setRightListOperand(ol);
+
+        var e = o.accept(v);
+        Assertions.assertNotEquals(o, e);
+
+        Assertions.assertEquals(o.getClass(), e.getClass());
+        var n = (ListLiteralOperationExpression) e;
+
+        Assertions.assertEquals(o.getSize(), n.getSize());
+
+        for (var i = 0; i < o.getSize(); i++) {
+            var oe = o.getRightListOperand().get(i);
+            var ne = n.getRightListOperand().get(i);
+            Assertions.assertEquals(oe.getClass(), ne.getClass());
+
+            var os = (StringLiteral) oe;
+            var ns = (StringLiteral) ne;
+
+            Assertions.assertEquals(os.getType(), ns.getType());
+            Assertions.assertEquals(os.getValue(), ns.getValue());
+        }
+
+        Assertions.assertEquals(o.toString(), n.toString());
+    }
+
+    private <T extends AggregationOperationExpression> void visitAggregationOperationExpression(Class<T> clazz, int rightOperandSize) {
+        try {
+            var o = clazz.getDeclaredConstructor().newInstance();
+
+            var ole = new ListLiteralOperationExpression();
+            List<Expression> ol = List.of(new IntegerLiteral(1), new IntegerLiteral(2), new IntegerLiteral(3));
+            ole.setRightListOperand(ol);
+            o.setLeftOperand(ole);
+
+            if (rightOperandSize > 0) {
+                var l = new ArrayList<Expression>();
+                for (var i = 0; i < rightOperandSize; i++) {
+                    var e = new IntegerLiteral(i);
+                    l.add(e);
+                }
+                o.setRightListOperand(l);
+            }
+
+            var e = o.accept(v);
+            Assertions.assertNotEquals(o, e);
+            Assertions.assertEquals(o.getClass(), e.getClass());
+
+            var n = clazz.cast(e);
+            Assertions.assertEquals(o.getLeftOperand().getClass(), n.getLeftOperand().getClass());
+
+            // new left operand
+            var nlo = n.getLeftOperand();
+            Assertions.assertEquals(ole.getClass(), nlo.getClass());
+            var nle = (ListLiteralOperationExpression) nlo;
+            Assertions.assertEquals(ole.getSize(), nle.getSize());
+
+            for (var i = 0; i < ole.getSize(); i++) {
+                var oe = ole.getRightListOperand().get(i);
+                var ne = nle.getRightListOperand().get(i);
+                Assertions.assertEquals(oe.getClass(), ne.getClass());
+
+                var oi = (IntegerLiteral) oe;
+                var ni = (IntegerLiteral) ne;
+
+                Assertions.assertEquals(oi.getType(), ni.getType());
+                Assertions.assertEquals(oi.getValue(), ni.getValue());
+            }
+
+            // new right operand
+            var nro = n.getRightListOperand();
+            Assertions.assertEquals(rightOperandSize, o.getRightListOperand().size());
+            Assertions.assertEquals(o.getRightListOperand().size(), nro.size());
+
+            if (rightOperandSize > 0) {
+                var oro = o.getRightListOperand();
+
+                for (var i = 0; i < rightOperandSize; i++) {
+                    var ore = oro.get(i);
+                    var nre = nro.get(i);
+                    Assertions.assertEquals(ore.getClass(), nre.getClass());
+
+                    var orev = (IntegerLiteral) ore;
+                    var nrev = (IntegerLiteral) nre;
+                    Assertions.assertEquals(orev.getValue(), nrev.getValue());
+                }
+            }
+
+            Assertions.assertEquals(o.toString(), n.toString());
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    public void visitMaximum() {
+        visitAggregationOperationExpression(Maximum.class, 0);
+    }
+
+    @Test
+    public void visitMean() {
+        visitAggregationOperationExpression(Mean.class, 0);
+    }
+
+    @Test
+    public void visitMedian() {
+        visitAggregationOperationExpression(Median.class, 0);
+    }
+
+    @Test
+    public void visitMinimum() {
+        visitAggregationOperationExpression(Minimum.class, 0);
+    }
+
+    @Test
+    public void visitMode() {
+        visitAggregationOperationExpression(Mode.class, 0);
+    }
+
+    @Test
+    public void visitSum() {
+        visitAggregationOperationExpression(Sum.class, 0);
+    }
+
+    private <T extends ArithmeticOperationExpression> void visitArithmeticOperationExpression(Class<T> clazz) {
+        try {
+            var o = clazz.getDeclaredConstructor().newInstance();
+            var ol = new IntegerLiteral(3);
+            var or = new IntegerLiteral(2);
+            o.setLeftOperand(ol);
+            o.setRightOperand(or);
+
+            var e = o.accept(v);
+            Assertions.assertNotEquals(o, e);
+            Assertions.assertEquals(o.getClass(), e.getClass());
+
+            var n = clazz.cast(e);
+            Assertions.assertEquals(o.getLeftOperand().getClass(), n.getLeftOperand().getClass());
+
+            var nlo = n.getLeftOperand();
+            Assertions.assertEquals(ol.getClass(), nlo.getClass());
+            var nle = (IntegerLiteral) nlo;
+            Assertions.assertEquals(ol.getType(), nle.getType());
+            Assertions.assertEquals(ol.getValue(), nle.getValue());
+
+            var nro = n.getRightOperand();
+            Assertions.assertEquals(or.getClass(), nro.getClass());
+            var nre = (IntegerLiteral) nro;
+            Assertions.assertEquals(or.getType(), nre.getType());
+            Assertions.assertEquals(or.getValue(), nre.getValue());
+
+            Assertions.assertEquals(o.toString(), n.toString());
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    public void visitAdd() {
+        visitArithmeticOperationExpression(Add.class);
+    }
+
+    @Test
+    public void visitDivide() {
+        visitArithmeticOperationExpression(Divide.class);
+    }
+
+    @Test
+    public void visitMax() {
+        visitArithmeticOperationExpression(Max.class);
+    }
+
+    @Test
+    public void visitMin() {
+        visitArithmeticOperationExpression(Min.class);
+    }
+
+    @Test
+    public void visitMultiply() {
+        visitArithmeticOperationExpression(Multiply.class);
+    }
+
+    @Test
+    public void visitPower() {
+        visitArithmeticOperationExpression(Power.class);
+    }
+
+    @Test
+    public void visitSubtract() {
+        visitArithmeticOperationExpression(Subtract.class);
+    }
+
+    private <T extends ConditionOperationExpression> void visitConditionOperationExpression(Class<T> clazz) {
+        try {
+            var o = clazz.getDeclaredConstructor().newInstance();
+            var oc = new Equals();
+            oc.setLeftOperand(new IntegerVariable("I"));
+            oc.setRightOperand(new IntegerLiteral(5));
+            o.setCondition(oc);
+            var ot = new AssignOperationExpression();
+            ot.setLeftOperand(new IntegerVariable("J"));
+            ot.setRightOperand(new IntegerLiteral(1));
+            o.setThenOperand(ot);
+            var oe = new AssignOperationExpression();
+            oe.setLeftOperand(new IntegerVariable("J"));
+            oe.setRightOperand(new IntegerLiteral(2));
+            o.setElseOperand(oe);
+
+            var e = o.accept(v);
+            Assertions.assertNotEquals(o, e);
+            Assertions.assertEquals(o.getClass(), e.getClass());
+
+            var n = clazz.cast(e);
+
+            Assertions.assertEquals(o.toString(), n.toString());
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    public void visitELSE() {
+        visitConditionOperationExpression(ELSE.class);
+    }
+
+    @Test
+    public void visitENDIF() {
+        visitConditionOperationExpression(ENDIF.class);
+    }
+
+    @Test
+    public void visitIF() {
+        visitConditionOperationExpression(IF.class);
+    }
+
+    @Test
+    public void visitTernaryOperation() {
+        visitConditionOperationExpression(TernaryOperation.class);
+    }
+
+    @Test
+    public void visitTHEN() {
+        visitConditionOperationExpression(THEN.class);
+    }
+
+    private <T extends LiteralExpression<?>> void compareListLiterals(Expression ol, Expression nl, Class<T> elementClass) {
+        if (ol.getClass() != ListLiteral.class) {
+            Assertions.fail("ol is not a ListLiteral but " + ol.getClass());
+            return;
+        }
+        if (nl.getClass() != ListLiteral.class) {
+            Assertions.fail("nl is not a ListLiteral but " + nl.getClass());
+            return;
+        }
+
+        var l1 = (ListLiteral) ol;
+        var l2 = (ListLiteral) nl;
+
+        Assertions.assertEquals(l1.getListType(), l2.getListType());
+        Assertions.assertEquals(l1.getSize(), l2.getSize());
+
+        for (var i = 0; i < l1.getSize(); i++) {
+            var l1e = l1.getValue().get(i);
+            var l2e = l2.getValue().get(i);
+            Assertions.assertEquals(elementClass, l1e.getClass());
+            Assertions.assertEquals(l1e.getClass(), l2e.getClass());
+
+            var l1v = elementClass.cast(l1e);
+            var l2v = elementClass.cast(l2e);
+
+            Assertions.assertEquals(l1v.getType(), l2v.getType());
+            Assertions.assertEquals(l1v.getType(), l2v.getType());
+        }
+    }
+
+    private <T extends Match> void visitMatchClass(Class<T> clazz) {
+        try {
+            var o = clazz.getDeclaredConstructor().newInstance();
+            var ol1 = new ListLiteral(
+                    List.of(
+                            new IntegerLiteral(1),
+                            new IntegerLiteral(2),
+                            new IntegerLiteral(3)
+                    ),
+                    IntegerType.class
+            );
+            var ol2 = new ListLiteral(
+                    List.of(
+                            new IntegerLiteral(1),
+                            new IntegerLiteral(2),
+                            new IntegerLiteral(3)
+                    ),
+                    IntegerType.class
+            );
+            List<Expression> ol = List.of(ol1, ol2);
+            o.setLeftListOperand(ol);
+
+            var e = o.accept(v);
+            Assertions.assertNotEquals(o, e);
+            Assertions.assertEquals(o.getClass(), e.getClass());
+
+            var n = clazz.cast(e);
+
+            Assertions.assertEquals(o.getLeftListOperand().size(), n.getLeftListOperand().size());
+
+            var nl1e = n.getLeftListOperand().get(0);
+            Assertions.assertEquals(ol1.getClass(), nl1e.getClass());
+            var nl1 = (ListLiteral) nl1e;
+            compareListLiterals(ol1, nl1, IntegerLiteral.class);
+
+            var nl2e = n.getLeftListOperand().get(1);
+            Assertions.assertEquals(ol2.getClass(), nl2e.getClass());
+            var nl2 = (ListLiteral) nl2e;
+            compareListLiterals(ol2, nl2, IntegerLiteral.class);
+
+            Assertions.assertEquals(o.toString(), n.toString());
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private <T extends ListOperationExpression> void visitListOperationExpression(Class<T> clazz) {
+        try {
+            var o = clazz.getDeclaredConstructor().newInstance();
+            var ol = new ListLiteral(
+                    List.of(
+                            new IntegerLiteral(1),
+                            new IntegerLiteral(2),
+                            new IntegerLiteral(3)
+                    ),
+                    IntegerType.class
+            );
+
+            o.setLeftOperand(ol);
+            var or = new Equals();
+            var orlv = new IntegerVariable("I");
+            or.setLeftOperand(orlv);
+            var orrv = new IntegerVariable("J");
+            or.setRightOperand(orrv);
+            o.setRightListOperand(List.of(or));
+            o.setRightOperand(or);
+
+            var e = o.accept(v);
+            Assertions.assertNotEquals(o, e);
+            Assertions.assertEquals(o.getClass(), e.getClass());
+            var n = clazz.cast(e);
+
+            // new left operand
+            var nl = n.getLeftOperand();
+            compareListLiterals(ol, nl, IntegerLiteral.class);
+
+            // new right operand
+            var nrlo = n.getRightListOperand();
+            Assertions.assertEquals(o.getRightListOperand().size(), nrlo.size());
+            var nr = (Equals) (nrlo.get(0));
+            Assertions.assertEquals(or.getClass(), nr.getClass());
+
+            var nrl = nr.getLeftOperand();
+            Assertions.assertEquals(or.getLeftOperand().getClass(), nrl.getClass());
+            var nrlv = (IntegerVariable) nrl;
+            Assertions.assertEquals(orlv.getName(), nrlv.getName());
+
+            var nrr = nr.getRightOperand();
+            Assertions.assertEquals(or.getRightOperand().getClass(), nrr.getClass());
+            var nrrv = (IntegerVariable) nrr;
+            Assertions.assertEquals(orrv.getName(), nrrv.getName());
+
+            Assertions.assertEquals(o.toString(), n.toString());
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    public void visitCombinationExists() {
+        visitMatchClass(CombinationExists.class);
+    }
+
+    @Test
+    public void visitFilterOperation() {
+        visitListOperationExpression(FilterOperation.class);
+    }
+
+    @Test
+    public void visitFirst() {
+        visitAggregationOperationExpression(First.class, 0);
+    }
+
+    @Test
+    public void visitGetItem() {
+        visitAggregationOperationExpression(GetItem.class, 1);
+    }
+
+    @Test
+    public void visitHasItem() {
+        visitAggregationOperationExpression(HasItem.class, 1);
+    }
+
+    @Test
+    public void visitInsideCombination() {
+        visitMatchClass(InsideCombination.class);
+    }
+
+    @Test
+    public void visitInsideExistsCombination() {
+        visitMatchClass(InsideExistsCombination.class);
+    }
+
+    @Test
+    public void visitIsEmpty() {
+        visitAggregationOperationExpression(IsEmpty.class, 0);
+    }
+
+    @Test
+    public void visitItemPosition() {
+        visitAggregationOperationExpression(ItemPosition.class, 0);
+    }
+
+    @Test
+    public void visitKeysOperation() {
+        visitListOperationExpression(KeysOperation.class);
+    }
+
+    @Test
+    public void visitLast() {
+        visitAggregationOperationExpression(Last.class, 0);
+    }
+
+    @Test
+    public void visitMapOperation() {
+        visitListOperationExpression(MapOperation.class);
+    }
+
+    @Test
+    public void visitMatch() {
+        visitMatchClass(Match.class);
+    }
+
+    @Test
+    public void visitMiddlesOperation() {
+        visitListOperationExpression(MiddlesOperation.class);
+    }
+
+    @Test
+    public void visitNotEmpty() {
+        visitAggregationOperationExpression(NotEmpty.class, 0);
+    }
+
+    @Test
+    public void visitPairOperation() {
+        visitAggregationOperationExpression(PairOperation.class, 2);
+    }
+
+    @Test
+    public void visitSizeOperation() {
+        visitAggregationOperationExpression(SizeOperation.class, 0);
+    }
+
+    @Test
+    public void visitSortOperation() {
+        visitListOperationExpression(SortOperation.class);
+    }
+
+    @Test
+    public void visitTripleOperation() {
+        visitAggregationOperationExpression(TripleOperation.class, 3);
+    }
+
+    @Test
+    public void visitValuesOperation() {
+        visitListOperationExpression(ValuesOperation.class);
+    }
+
+    private <T extends LogicalOperationExpression> void visitLogicalOperationExpression(Class<T> clazz, boolean rightOnly) {
+        try {
+            var o = clazz.getDeclaredConstructor().newInstance();
+
+            var ol = new BooleanVariable("A");
+            if (!rightOnly) {
+                o.setLeftOperand(ol);
+            }
+            var or = new BooleanVariable("B");
+            o.setRightOperand(or);
+
+            var ne = o.accept(v);
+            Assertions.assertNotEquals(o, ne);
+            Assertions.assertEquals(o.getClass(), ne.getClass());
+
+            var n = clazz.cast(ne);
+
+            if (!rightOnly) {
+                var nle = n.getLeftOperand();
+                Assertions.assertEquals(ol.getClass(), nle.getClass());
+                var nl = (BooleanVariable) nle;
+                Assertions.assertEquals(ol.getName(), nl.getName());
+            }
+
+            var nre = n.getRightOperand();
+            Assertions.assertEquals(or.getClass(), nre.getClass());
+            var nr = (BooleanVariable) nre;
+            Assertions.assertEquals(or.getName(), nr.getName());
+
+            Assertions.assertEquals(o.toString(), n.toString());
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private <T extends LogicalOperationExpression> void visitLogicalOperationExpression(Class<T> clazz) {
+        visitLogicalOperationExpression(clazz, false);
+    }
+
+    @Test
+    public void visitAnd() {
+        visitLogicalOperationExpression(And.class);
+    }
+
+    @Test
+    public void visitImplies() {
+        visitLogicalOperationExpression(Implies.class);
+    }
+
+    @Test
+    public void visitNot() {
+        visitLogicalOperationExpression(Not.class, true);
+    }
+
+    @Test
+    public void visitOR() {
+        visitLogicalOperationExpression(OR.class);
+    }
+
+    private <E extends ChainOperationExpression, L extends VariableExpression<?>, R extends VariableExpression<?>> void visitChainOperationExpression(Class<E> expressionClass, Class<L> leftVariableClass, Class<R> rightVariableClass, int rightOperandSize) {
+        // precondition on rightVariableClass and rightOperandSize
+        Assertions.assertTrue(
+                !(rightVariableClass == null) && rightOperandSize > 0 || rightVariableClass == null && rightOperandSize == 0,
+                "Precondition violated: rightVariableClass=" + rightVariableClass + "; rightOperandSize=" + rightOperandSize
+        );
+
+        try {
+            var o = expressionClass.getDeclaredConstructor().newInstance();
+
+            var ol = leftVariableClass.getDeclaredConstructor(String.class).newInstance("T");
+            o.setLeftOperand(ol);
+            Assertions.assertEquals(leftVariableClass, o.getLeftOperand().getClass());
+
+            if (rightOperandSize > 0) {
+                var orl = new ArrayList<Expression>();
+                for (var i = 0; i < rightOperandSize; i++) {
+                    var or = rightVariableClass.getDeclaredConstructor(String.class).newInstance("A" + i);
+                    Assertions.assertEquals(rightVariableClass, or.getClass());
+                    orl.add(or);
+                    o.setRightListOperand(orl);
+                }
+                Assertions.assertEquals(rightOperandSize, orl.size());
+            }
+
+            var ne = o.accept(v);
+            Assertions.assertEquals(o.getClass(), ne.getClass());
+
+            var n = expressionClass.cast(ne);
+
+            var nlo = n.getLeftOperand();
+            Assertions.assertEquals(leftVariableClass, n.getLeftOperand().getClass());
+            Assertions.assertEquals(ol.getClass(), nlo.getClass());
+            var nl = leftVariableClass.cast(nlo);
+            Assertions.assertEquals(ol.getName(), nl.getName());
+
+            var nrl = n.getRightListOperand();
+            var orl = o.getRightListOperand();
+            Assertions.assertEquals(orl.size(), nrl.size());
+
+            if (rightOperandSize > 0) {
+                Assertions.assertEquals(rightOperandSize, nrl.size());
+                for (var i = 0; i < rightOperandSize; i++) {
+                    var nre = nrl.get(i);
+                    var ore = orl.get(i);
+                    Assertions.assertEquals(rightVariableClass, nre.getClass());
+                    Assertions.assertEquals(ore.getClass(), nre.getClass());
+
+                    var nr = rightVariableClass.cast(nre);
+                    var or = rightVariableClass.cast(ore);
+                    Assertions.assertEquals(or.getName(), nr.getName());
+                }
+            }
+
+            Assertions.assertEquals(o.toString(), n.toString());
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    public void visitAddDays() {
+        visitChainOperationExpression(AddDays.class, DateTimeVariable.class, DateTimeVariable.class, 1);
+    }
+
+    @Test
+    public void visitAddMonths() {
+        visitChainOperationExpression(AddMonths.class, DateTimeVariable.class, DateTimeVariable.class, 1);
+    }
+
+    @Test
+    public void visitAddYears() {
+        visitChainOperationExpression(AddYears.class, DateTimeVariable.class, DateTimeVariable.class, 1);
+    }
+
+    @Test
+    public void visitAppend() {
+        visitChainOperationExpression(Append.class, StringVariable.class, StringVariable.class, 1);
+    }
+
+    @Test
+    public void visitContains() {
+        visitChainOperationExpression(Contains.class, StringVariable.class, StringVariable.class, 1);
+    }
+
+    @Test
+    public void visitEndsWith() {
+        visitChainOperationExpression(EndsWith.class, StringVariable.class, StringVariable.class, 1);
+    }
+
+    @Test
+    public void visitGetYear() {
+        visitChainOperationExpression(GetYear.class, DateTimeVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitLength() {
+        visitChainOperationExpression(Length.class, StringVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitPrepend() {
+        visitChainOperationExpression(Prepend.class, StringVariable.class, StringVariable.class, 1);
+    }
+
+    @Test
+    public void visitSetDay() {
+        visitChainOperationExpression(SetDay.class, DateTimeVariable.class, DateTimeVariable.class, 1);
+    }
+
+    @Test
+    public void visitSetMonth() {
+        visitChainOperationExpression(SetMonth.class, DateTimeVariable.class, DateTimeVariable.class, 1);
+    }
+
+    @Test
+    public void visitSetYear() {
+        visitChainOperationExpression(SetYear.class, DateTimeVariable.class, DateTimeVariable.class, 1);
+    }
+
+    @Test
+    public void visitStartsWith() {
+        visitChainOperationExpression(StartsWith.class, StringVariable.class, StringVariable.class, 1);
+    }
+
+    @Test
+    public void visitSubDays() {
+        visitChainOperationExpression(SubDays.class, DateTimeVariable.class, DateTimeVariable.class, 1);
+    }
+
+    @Test
+    public void visitSubMonths() {
+        visitChainOperationExpression(SubMonths.class, DateTimeVariable.class, DateTimeVariable.class, 1);
+    }
+
+    @Test
+    public void visitSubYears() {
+        visitChainOperationExpression(SubYears.class, DateTimeVariable.class, DateTimeVariable.class, 1);
+    }
+
+    @Test
+    public void visitSubstring() {
+        visitChainOperationExpression(Substring.class, StringVariable.class, IntegerVariable.class, 2);
+    }
+
+    @Test
+    public void visitToBoolean() {
+        visitChainOperationExpression(ToBoolean.class, StringVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitToDate() {
+        visitChainOperationExpression(ToDate.class, StringVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitToInteger() {
+        visitChainOperationExpression(ToInteger.class, StringVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitToKey() {
+        visitChainOperationExpression(ToKey.class, PairVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitToLeft() {
+        visitChainOperationExpression(ToLeft.class, TripleVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitToMiddle() {
+        visitChainOperationExpression(ToMiddle.class, TripleVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitToPair() {
+        visitChainOperationExpression(ToPair.class, StringVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitToRight() {
+        visitChainOperationExpression(ToRight.class, TripleVariable.class, null,0);
+    }
+
+    @Test
+    public void visitToString() {
+        visitChainOperationExpression(ToString.class, DateTimeVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitToTriple() {
+        visitChainOperationExpression(ToTriple.class, StringVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitToValue() {
+        visitChainOperationExpression(ToValue.class, PairVariable.class, null, 0);
+    }
+
+    @Test
+    public void visitTrim() {
+        visitChainOperationExpression(Trim.class, StringVariable.class, null,0);
+    }
+
+    private <T extends RelationalOperationExpression> void visitPairRelationalOperationExpression(Class<T> clazz) {
+        try {
+            var o = clazz.getDeclaredConstructor().newInstance();
+            var ol = new IntegerVariable("L");
+            o.setLeftOperand(ol);
+            var or = new IntegerVariable("R");
+            o.setRightOperand(or);
+
+            var ne = o.accept(v);
+            Assertions.assertEquals(o.getClass(), ne.getClass());
+            var n = clazz.cast(ne);
+
+            var nle = n.getLeftOperand();
+            Assertions.assertEquals(ol.getClass(), nle.getClass());
+            var nl = (IntegerVariable) nle;
+            Assertions.assertEquals(ol.getName(), nl.getName());
+
+            var nre = n.getRightOperand();
+            Assertions.assertEquals(or.getClass(), nre.getClass());
+            var nr = (IntegerVariable) nre;
+            Assertions.assertEquals(or.getName(), nr.getName());
+
+            Assertions.assertEquals(o.toString(), n.toString());
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private <T extends RelationalOperationExpression> void visitListRelationalOperationExpression(Class<T> clazz) {
+        try {
+            var o = clazz.getDeclaredConstructor().newInstance();
+            var ol = new IntegerVariable("V");
+            o.setLeftOperand(ol);
+
+            var orl = new ListLiteral(
+                    List.of(
+                            new IntegerLiteral(1),
+                            new IntegerLiteral(10)
+                    ),
+                    IntegerType.class
+            );
+            o.setRightOperand(orl);
+
+            var ne = o.accept(v);
+            Assertions.assertEquals(o.getClass(), ne.getClass());
+            var n = clazz.cast(ne);
+
+            var nle = n.getLeftOperand();
+            Assertions.assertEquals(ol.getClass(), nle.getClass());
+            var nl = (IntegerVariable) nle;
+            Assertions.assertEquals(ol.getName(), nl.getName());
+
+            var nre = n.getRightOperand();
+            compareListLiterals(orl, nre, IntegerLiteral.class);
+
+            Assertions.assertEquals(o.toString(), n.toString());
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    public void visitBetween() {
+        visitListRelationalOperationExpression(Between.class);
+    }
+
+    @Test
+    public void visitEquals() {
+        visitPairRelationalOperationExpression(Equals.class);
+    }
+
+    @Test
+    public void visitGreaterEqual() {
+        visitPairRelationalOperationExpression(GreaterEqual.class);
+    }
+
+    @Test
+    public void visitGreaterThan() {
+        visitPairRelationalOperationExpression(GreaterThan.class);
+    }
+
+    @Test
+    public void visitIn() {
+        visitListRelationalOperationExpression(In.class);
+    }
+
+    @Test
+    public void visitLessEqual() {
+        visitPairRelationalOperationExpression(LessEqual.class);
+    }
+
+    @Test
+    public void visitLessThan() {
+        visitPairRelationalOperationExpression(LessThan.class);
+    }
+
+    @Test
+    public void visitNotEquals() {
+        visitPairRelationalOperationExpression(NotEquals.class);
+    }
+
+    @Test
+    public void visitNotIn() {
+        visitListRelationalOperationExpression(NotIn.class);
+    }
+
+    private <T extends OperationExpression> void visitOperationExpression(Class<T> clazz) {
+        try {
+            var o = clazz.getDeclaredConstructor().newInstance();
+
+            var ne = o.accept(v);
+            Assertions.assertEquals(o.getClass(), ne.getClass());
+            var n = clazz.cast(ne);
+
+            Assertions.assertEquals(o.toString(), n.toString());
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    public void visitDateOperation() {
+        visitOperationExpression(DateOperation.class);
+    }
+
+    @Test
+    public void visitDateTimeOperation() {
+        visitOperationExpression(DateTimeOperation.class);
+    }
+
+    private <T extends OperationExpression> T visitDefLetOperation(T o) {
+        var one = "self.V : IntegerType";
+        var ol = new NamedExpression(one);
+        o.setLeftOperand(ol);
+
+        var ne = o.accept(v);
+        Assertions.assertEquals(o.getClass(), ne.getClass());
+        @SuppressWarnings("unchecked") var n = (T) ne;
+        Assertions.assertEquals(ol.getClass(), n.getLeftOperand().getClass());
+
+        var nl = (NamedExpression) n.getLeftOperand();
+        Assertions.assertEquals(one, nl.getName());
+
+        return n;
+    }
+
+    @Test
+    public void visitDefOperation() {
+        var o = new DefOperation();
+        var n = visitDefLetOperation(o);
+        Assertions.assertEquals(o.toString(), n.toString());
+    }
+
+    @Test
+    public void visitEndForAll() {
+        visitIterationOperationExpression(new EndForAll());
+    }
+
+    @Test
+    public void visitEndForEach() {
+        visitIterationOperationExpression(new EndForEach());
+    }
+
+    @Test
+    public void visitExpressionSeparator() {
+        var ol = new BooleanVariable("B", true);
+        var or = new StringVariable("S", "val");
+        var o = new ExpressionSeparator();
+        o.setLeftOperand(ol);
+        o.setRightOperand(or);
+
+        var ne = o.accept(v);
+        Assertions.assertEquals(o.getClass(), ne.getClass());
+        var n = (ExpressionSeparator) ne;
+
+        var nle = n.getLeftOperand();
+        Assertions.assertEquals(ol.getClass(), nle.getClass());
+        var nl = (BooleanVariable) nle;
+        Assertions.assertEquals(ol.getName(), nl.getName());
+        Assertions.assertEquals(ol.getValue(), nl.getValue());
+        Assertions.assertEquals(ol.getType(), nl.getType());
+
+        var nre = n.getRightOperand();
+        Assertions.assertEquals(or.getClass(), nre.getClass());
+        var nr = (StringVariable) nre;
+        Assertions.assertEquals(or.getName(), nr.getName());
+        Assertions.assertEquals(or.getValue(), nr.getValue());
+        Assertions.assertEquals(or.getType(), nr.getType());
+
+        Assertions.assertEquals(o.toString(), n.toString());
+    }
+
+    @Test
+    public void visitForAll() {
+        visitIterationOperationExpression(new ForAll());
+    }
+
+    @Test
+    public void visitForEach() {
+        visitIterationOperationExpression(new ForEach());
+    }
+
+    private String trimCollapseWhiteSpace(String s) {
+        return s.trim().replaceAll("\\s+", " ");
+    }
+
+    private <T extends Function> void visitFunction(Class<T> clazz) {
+        try {
+            var f = clazz.getDeclaredConstructor().newInstance();
+
+            var fe = new FunctionExpression("Func1", null);
+            fe.addParameter(new NamedExpression("S1"));
+            fe.addParameter(new NamedExpression("I1"));
+            f.setLeftOperand(fe);
+
+            var e = f.accept(v);
+
+            Assertions.assertEquals(f.getClass(), e.getClass());
+            var fn = (Function) e;
+
+            Assertions.assertEquals(f.getOperationType(), fn.getOperationType());
+            Assertions.assertEquals(f.getDataTypeExpression(), fn.getDataTypeExpression());
+            Assertions.assertEquals(f.getLeftOperand().getClass(), fn.getLeftOperand().getClass());
+            Assertions.assertNull(f.getRightOperand());
+            Assertions.assertNull(fn.getRightOperand());
+
+            var fne = (FunctionExpression) fn.getLeftOperand();
+            Assertions.assertEquals(fe.name.toString(), fne.name.toString());
+            Assertions.assertEquals(fe.getParameters().size(), fne.getParameters().size());
+            for (var i = 0; i < fe.getParameters().size(); i++) {
+                Assertions.assertEquals(fe.getParameters().get(i).toString(), fne.getParameters().get(i).toString());
+            }
+
+            Assertions.assertEquals(f.toString(), trimCollapseWhiteSpace(fn.toString()));
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    public void visitFunction() {
+        visitFunction(Function.class);
+    }
+
+    @Test
+    public void visitInvoke() {
+        visitFunction(Invoke.class);
+    }
+
+    @Test
+    public void visitLeftPriority() {
+        visitOperationExpression(LeftPriority.class);
+    }
+
+    @Test
+    public void visitLetOperation() {
+        var o = new LetOperation();
+
+        var n = visitDefLetOperation(o);
+
+        var ove = o.getVariableExpression();
+
+        Assertions.assertEquals("V", ove.getName());
+        Assertions.assertEquals(IntegerType.class, ove.getType());
+        Assertions.assertEquals("tmp", ove.getOperandType());
+
+        var nve = n.getVariableExpression();
+        Assertions.assertEquals(ove.getName(), nve.getName());
+        Assertions.assertEquals(ove.getType(), nve.getType());
+        Assertions.assertEquals(ove.getOperandType(), nve.getOperandType());
+
+        Assertions.assertEquals(o.toString(), n.toString());
+    }
+
+    @Test
+    public void visitPrintOperation() {
+        var o = new PrintOperation();
+        var ol = new IntegerVariable("I");
+        o.setLeftOperand(ol);
+
+        var ne = o.accept(v);
+        Assertions.assertEquals(o.getClass(), ne.getClass());
+
+        var n = (PrintOperation) ne;
+        var nle = n.getLeftOperand();
+        Assertions.assertEquals(ol.getClass(), nle.getClass());
+        var nl = (IntegerVariable) nle;
+        Assertions.assertEquals(ol.getName(), nl.getName());
+
+        Assertions.assertEquals(o.toString(), n.toString());
+    }
+
+    @Test
+    public void visitRightPriority() {
+        visitOperationExpression(RightPriority.class);
+    }
+
+    @Test
+    public void visitToday() {
+        visitOperationExpression(Today.class);
+    }
+
+}
diff --git a/src/test/java/org/dvare/test/flow/FlowTest.java b/src/test/java/org/dvare/test/flow/FlowTest.java
index e9b0fee..206796b 100644
--- a/src/test/java/org/dvare/test/flow/FlowTest.java
+++ b/src/test/java/org/dvare/test/flow/FlowTest.java
@@ -309,6 +309,98 @@ public void localVariableIfElseTest() throws ExpressionParseException, Interpret
         Assertions.assertEquals(ValueFinder.findValue("A0", resultModel), 10);
     }
 
+    @Test
+    public void ifElseBooleanLiteralTest() throws ExpressionParseException, InterpretException {
+
+        RuleConfiguration factory = new RuleConfiguration();
+
+        Map<String, String> validationTypes = new HashMap<>();
+        validationTypes.put("V1", "IntegerType");
+
+        ContextsBinding contexts = new ContextsBinding();
+        contexts.addContext("data", ExpressionParser.translate(validationTypes));
+
+        Expression ruleExp = factory.getParser().fromString("" +
+                "IF data.V1 > 5 " +
+                "THEN true " +
+                "ELSE false " +
+                "ENDIF", contexts);
+
+        RuleBinding rule = new RuleBinding(ruleExp);
+
+        List<Object> dataSet = new ArrayList<>();
+        Map<String, Object> d1 = new HashMap<>();
+        d1.put("V1", 10);
+        dataSet.add(new DataRow(d1));
+
+
+        Map<String, Object> d2 = new HashMap<>();
+        d2.put("V1", 20);
+        dataSet.add(new DataRow(d2));
+
+        Map<String, Object> d3 = new HashMap<>();
+        d3.put("V1", 40);
+        dataSet.add(new DataRow(d3));
+
+        RuleEvaluator evaluator = factory.getEvaluator();
+        InstancesBinding instancesBinding = new InstancesBinding(new HashMap<>());
+        instancesBinding.addInstance("data", dataSet);
+
+        Object result = evaluator.evaluate(rule, instancesBinding);
+        Assertions.assertEquals(Boolean.class, result.getClass());
+
+        var booleanResult = (Boolean) result;
+        Assertions.assertTrue(booleanResult);
+    }
+
+    @Test
+    public void ifElseBooleanVariableTest() throws ExpressionParseException, InterpretException {
+
+        RuleConfiguration factory = new RuleConfiguration();
+
+        Map<String, String> validationTypes = new HashMap<>();
+        validationTypes.put("V1", "IntegerType");
+        validationTypes.put("V2", "BooleanType");
+
+        ContextsBinding contexts = new ContextsBinding();
+        contexts.addContext("data", ExpressionParser.translate(validationTypes));
+
+        Expression ruleExp = factory.getParser().fromString("" +
+                "IF data.V1 > 5 " +
+                "THEN data.V2 " +
+                "ELSE false " +
+                "ENDIF", contexts);
+
+        RuleBinding rule = new RuleBinding(ruleExp);
+
+        List<Object> dataSet = new ArrayList<>();
+        Map<String, Object> d1 = new HashMap<>();
+        d1.put("V1", 10);
+        d1.put("V2", true);
+        dataSet.add(new DataRow(d1));
+
+
+        Map<String, Object> d2 = new HashMap<>();
+        d2.put("V1", 20);
+        d1.put("V2", true);
+        dataSet.add(new DataRow(d2));
+
+        Map<String, Object> d3 = new HashMap<>();
+        d3.put("V1", 40);
+        d1.put("V2", true);
+        dataSet.add(new DataRow(d3));
+
+        RuleEvaluator evaluator = factory.getEvaluator();
+        InstancesBinding instancesBinding = new InstancesBinding(new HashMap<>());
+        instancesBinding.addInstance("data", dataSet);
+
+        Object result = evaluator.evaluate(rule, instancesBinding);
+        Assertions.assertEquals(Boolean.class, result.getClass());
+
+        var booleanResult = (Boolean) result;
+        Assertions.assertTrue(booleanResult);
+    }
+
 
     //@Test
     public void testApp11() throws ExpressionParseException, InterpretException {
diff --git a/src/test/java/org/dvare/test/list/DistinctOperationTest.java b/src/test/java/org/dvare/test/list/DistinctOperationTest.java
new file mode 100644
index 0000000..5338923
--- /dev/null
+++ b/src/test/java/org/dvare/test/list/DistinctOperationTest.java
@@ -0,0 +1,79 @@
+package org.dvare.test.list;
+
+import org.dvare.binding.data.InstancesBinding;
+import org.dvare.binding.model.ContextsBinding;
+import org.dvare.binding.rule.RuleBinding;
+import org.dvare.config.RuleConfiguration;
+import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.exceptions.parser.ExpressionParseException;
+import org.dvare.parser.ExpressionParser;
+import org.dvare.test.dataobjects.ListTestModel;
+import org.junit.jupiter.api.Test;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class DistinctOperationTest {
+
+    private void testDistinctOperation(List<String> input, List<String> expected) throws ExpressionParseException, InterpretException {
+        var factory = new RuleConfiguration();
+
+        var rule = "Variable1->distinct()";
+
+        var typeBinding = ExpressionParser.translate(ListTestModel.class);
+        var contexts = new ContextsBinding();
+        contexts.addContext("self", typeBinding);
+
+
+        var expression = factory.getParser().fromString(rule, contexts);
+
+        var ruleBinding = new RuleBinding(expression);
+
+        var dataSet = new ArrayList<ListTestModel>();
+
+        for (var i : input) {
+            ListTestModel v = new ListTestModel();
+            v.setVariable1(i);
+            dataSet.add(v);
+        }
+
+        var instancesBinding = new InstancesBinding();
+        instancesBinding.addInstance("self", dataSet);
+
+        var evaluator = factory.getEvaluator();
+        @SuppressWarnings("unchecked") var result = (List<String>) evaluator.evaluate(ruleBinding, instancesBinding);
+
+        assertEquals(expected.size(), result.size());
+
+        for (var i = 0; i < expected.size(); i++) {
+            var r = result.get(i);
+            var e = expected.get(i);
+            assertEquals(e, r);
+        }
+    }
+
+    @Test
+    public void testDistinctOperation() throws ExpressionParseException, InterpretException {
+        var params = List.of(
+                new AbstractMap.SimpleImmutableEntry<>(
+                        List.of("1", "1", "1", "1", "1"),
+                        List.of("1")
+                ),
+                new AbstractMap.SimpleImmutableEntry<>(
+                        List.of("1", "2", "3", "4", "5"),
+                        List.of("1", "2", "3", "4", "5")
+                ),
+                new AbstractMap.SimpleImmutableEntry<>(
+                        List.of("1", "1", "2", "2", "2", "3", "4", "4", "5"),
+                        List.of("1", "2", "3", "4", "5")
+                )
+        );
+
+        for (var p : params) {
+            testDistinctOperation(p.getKey(), p.getValue());
+        }
+    }
+}
diff --git a/src/test/java/org/dvare/test/logical/LogicalOperationExpressionTest.java b/src/test/java/org/dvare/test/logical/LogicalOperationExpressionTest.java
new file mode 100644
index 0000000..389cbda
--- /dev/null
+++ b/src/test/java/org/dvare/test/logical/LogicalOperationExpressionTest.java
@@ -0,0 +1,184 @@
+package org.dvare.test.logical;
+
+import org.dvare.binding.data.DataRow;
+import org.dvare.binding.data.InstancesBinding;
+import org.dvare.binding.model.ContextsBinding;
+import org.dvare.binding.rule.RuleBinding;
+import org.dvare.config.RuleConfiguration;
+import org.dvare.exceptions.interpreter.InterpretException;
+import org.dvare.exceptions.parser.ExpressionParseException;
+import org.dvare.parser.ExpressionParser;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class LogicalOperationExpressionTest {
+
+    public final String T = "true";
+    public final String F = "false";
+    public final String V1 = "V1";
+    public final String V2 = "V2";
+    public final String AND = "and";
+    public final String OR = "or";
+    public final String IMPLIES = "implies";
+    public final String NOT = "not";
+
+    static class Params {
+        public final String LEFT;
+        public final String OPERATOR;
+        public final String RIGHT;
+        public final boolean EXPECTED;
+
+        public final Boolean LEFT_VALUE;
+        public final Boolean RIGHT_VALUE;
+
+        public final String CONTEXT = "self";
+        public final String BOOLEAN_TYPE = "BooleanType";
+
+        public Params(String left, String operator, String right, boolean expected) {
+            this(left, null, operator, right, null, expected);
+        }
+
+        public Params(String left, Boolean leftValue, String operator, String right, Boolean rightValue, boolean expected) {
+            LEFT = left;
+            OPERATOR = operator;
+            RIGHT = right;
+            EXPECTED = expected;
+            LEFT_VALUE = leftValue;
+            RIGHT_VALUE = rightValue;
+        }
+    }
+
+    private void logicalParams(Params params) throws ExpressionParseException, InterpretException {
+        var factory = new RuleConfiguration();
+
+        ContextsBinding contexts = new ContextsBinding();
+        if (params.LEFT_VALUE != null && params.RIGHT_VALUE != null) {
+            contexts.addContext(params.CONTEXT, ExpressionParser.translate(String.format("%s:%s,%s:%s", params.LEFT, params.BOOLEAN_TYPE, params.RIGHT, params.BOOLEAN_TYPE)));
+        } else if (params.LEFT_VALUE != null) {
+            contexts.addContext(params.CONTEXT, ExpressionParser.translate(String.format("%s:%s", params.LEFT, params.BOOLEAN_TYPE)));
+        } else if (params.RIGHT_VALUE != null) {
+            contexts.addContext(params.CONTEXT, ExpressionParser.translate(String.format("%s:%s", params.RIGHT, params.BOOLEAN_TYPE)));
+        }
+
+        String ruleText;
+        if (params.LEFT == null) {
+            ruleText = String.format("%s %s", params.OPERATOR, params.RIGHT);
+        } else {
+            ruleText = String.format("%s %s %s", params.LEFT, params.OPERATOR, params.RIGHT);
+        }
+        var ruleExp = factory.getParser().fromString(ruleText, contexts);
+
+        var rule = new RuleBinding(ruleExp);
+
+        var evaluator = factory.getEvaluator();
+        var instancesBinding = new InstancesBinding(new HashMap<>());
+
+        List<Object> dataSet = new ArrayList<>();
+        Map<String, Object> d = new HashMap<>();
+
+        if (params.LEFT_VALUE != null) {
+            d.put(params.LEFT, params.LEFT_VALUE);
+        }
+
+        if (params.RIGHT_VALUE != null) {
+            d.put(params.RIGHT, params.RIGHT_VALUE);
+        }
+
+        dataSet.add(new DataRow(d));
+        instancesBinding.addInstance(params.CONTEXT, dataSet);
+
+        Object result = evaluator.evaluate(rule, instancesBinding);
+        Assertions.assertEquals(Boolean.class, result.getClass());
+
+        var booleanResult = (Boolean) result;
+        Assertions.assertEquals(params.EXPECTED, booleanResult, ruleText);
+    }
+
+    private void logicalParams(List<Params> params) throws ExpressionParseException, InterpretException {
+        for (var param : params) {
+            logicalParams(param);
+        }
+    }
+
+    @Test
+    public void literals() throws ExpressionParseException, InterpretException {
+        var params = List.of(
+                new Params(T, AND, T, true),
+                new Params(F, AND, T, false),
+                new Params(T, AND, F, false),
+                new Params(F, AND, F, false),
+                new Params(T, OR, T, true),
+                new Params(F, OR, T, true),
+                new Params(T, OR, F, true),
+                new Params(F, OR, F, false),
+                new Params(T, IMPLIES, T, true),
+                new Params(F, IMPLIES, T, true),
+                new Params(T, IMPLIES, F, false),
+                new Params(F, IMPLIES, F, true),
+                new Params(null, NOT, T, false),
+                new Params(null, NOT, F, true)
+        );
+
+        logicalParams(params);
+    }
+
+    @Test
+    public void variables() throws ExpressionParseException, InterpretException {
+        var params = List.of(
+                new Params(V1, true, AND, V2, true, true),
+                new Params(V1, true, AND, V2, false, false),
+                new Params(V1, false, AND, V2, true, false),
+                new Params(V1, false, AND, V2, false, false),
+                new Params(V1, true, OR, V2, true, true),
+                new Params(V1, false, OR, V2, true, true),
+                new Params(V1, true, OR, V2, false, true),
+                new Params(V1, false, OR, V2, false, false),
+                new Params(V1, true, IMPLIES, V2, true, true),
+                new Params(V1, false, IMPLIES, V2, true, true),
+                new Params(V1, true, IMPLIES, V2, false, false),
+                new Params(V1, false, IMPLIES, V2, false, true),
+                new Params(null, null, NOT, V1, true, false),
+                new Params(null, null, NOT, V2, false, true)
+        );
+
+        logicalParams(params);
+    }
+
+    @Test
+    public void literalsAndVariables() throws ExpressionParseException, InterpretException {
+        var params = List.of(
+                new Params(V1, true, AND, T, null, true),
+                new Params(V1, false, AND, T, null, false),
+                new Params(V1, true, AND, F, null, false),
+                new Params(V1, false, AND, F, null, false),
+                new Params(V1, true, OR, T, null, true),
+                new Params(V1, false, OR, T, null, true),
+                new Params(V1, true, OR, F, null, true),
+                new Params(V1, false, OR, F, null, false),
+                new Params(V1, true, IMPLIES, T, null, true),
+                new Params(V1, false, IMPLIES, T, null, true),
+                new Params(V1, true, IMPLIES, F, null, false),
+                new Params(V1, false, IMPLIES, F, null, true),
+
+                new Params(T, null, AND, V2, true, true),
+                new Params(F, null, AND, V2, true, false),
+                new Params(T, null, AND, V2, false, false),
+                new Params(F, null, AND, V2, false, false),
+                new Params(T, null, OR, V2, true, true),
+                new Params(F, null, OR, V2, true, true),
+                new Params(T, null, OR, V2, false, true),
+                new Params(F, null, OR, V2, false, false),
+                new Params(T, null, IMPLIES, V2, true, true),
+                new Params(F, null, IMPLIES, V2, true, true),
+                new Params(T, null, IMPLIES, V2, false, false),
+                new Params(F, null, IMPLIES, V2, false, true)
+        );
+
+        logicalParams(params);
+    }
+}