diff --git a/libwccl/CMakeLists.txt b/libwccl/CMakeLists.txt
index 00ed846ce422e14519469496d60f9b3a88e19aa8..2543ebe6f6a1dace4b5842b0c11b3e319d8a78fe 100644
--- a/libwccl/CMakeLists.txt
+++ b/libwccl/CMakeLists.txt
@@ -17,9 +17,10 @@ SET(libwccl_STAT_SRC
 	exception.cpp
 	main.cpp
 	ops/and.cpp
-	ops/or.cpp
+	ops/formatters.cpp
 	ops/logicalpredicate.cpp
     ops/nor.cpp
+	ops/or.cpp
 	ops/predicate.cpp
 	sentencecontext.cpp
 	values/bool.cpp
diff --git a/libwccl/ops/formatters.cpp b/libwccl/ops/formatters.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4adf2da37d6fa73e6cabf8dff028a2475cffa290
--- /dev/null
+++ b/libwccl/ops/formatters.cpp
@@ -0,0 +1,65 @@
+#include <libwccl/ops/formatters.h>
+
+namespace Wccl {
+
+// ------ UnaryFunctionFormatter -----
+
+std::string UnaryFunctionFormatter::to_raw_string(
+	const FunctionBase& f,
+	const FunctionBase& arg_expr,
+	const char* open_bracket,
+	const char* close_bracket)
+{
+	std::string s(f.raw_operator_name());
+	s.append(open_bracket);
+	s.append(arg_expr.to_raw_string());
+	s.append(close_bracket);
+	return s;
+}
+
+std::string UnaryFunctionFormatter::to_string(
+	const Corpus2::Tagset& tagset,
+	const FunctionBase& f,
+	const FunctionBase& arg_expr,
+	const char* open_bracket,
+	const char* close_bracket)
+{
+	std::string s(f.operator_name(tagset));
+	s.append(open_bracket);
+	s.append(arg_expr.to_string(tagset));
+	s.append(close_bracket);
+	return s;
+}
+
+// ----- BinaryFunctionFormatter ------
+
+std::string BinaryFunctionFormatter::to_string(
+	const Corpus2::Tagset& tagset,
+	const FunctionBase& f,
+	const FunctionBase& arg1_expr,
+	const FunctionBase& arg2_expr)
+{
+	std::string s(f.operator_name(tagset));
+	s.append("(");
+	s.append(arg1_expr.to_string(tagset));
+	s.append(", ");
+	s.append(arg2_expr.to_string(tagset));
+	s.append(")");
+	return s;
+}
+
+std::string BinaryFunctionFormatter::to_raw_string(
+	const FunctionBase& f,
+	const FunctionBase& arg1_expr,
+	const FunctionBase& arg2_expr)
+{
+	std::string s(f.raw_operator_name());
+	s.append("(");
+	s.append(arg1_expr.to_raw_string());
+	s.append(", ");
+	s.append(arg2_expr.to_raw_string());
+	s.append(")");
+	return s;
+}
+
+} /* end ns Wccl */
diff --git a/libwccl/ops/formatters.h b/libwccl/ops/formatters.h
new file mode 100644
index 0000000000000000000000000000000000000000..977994518e612b816a3621277534542e3229676a
--- /dev/null
+++ b/libwccl/ops/formatters.h
@@ -0,0 +1,77 @@
+#ifndef FORMATTERS_H
+#define FORMATTERS_H
+
+#include <boost/shared_ptr.hpp>
+
+#include <libcorpus2/tagset.h>
+
+#include <libwccl/ops/functions.h>
+
+namespace Wccl {
+
+/**
+ * Class that formats unary functions as string
+ */
+struct UnaryFunctionFormatter
+{
+    /** 
+	 * String representation of an unary function.
+	 * It is in form of
+     * operator_name(argument_expression_string)
+     * although the open and close brackets can be changed
+     * (some operators use [])
+     */
+	static std::string to_string(
+		const Corpus2::Tagset& tagset,
+		const FunctionBase& f,
+		const FunctionBase& arg_expr,
+		const char* open_bracket = "(",
+		const char* close_bracket = ")");
+
+    /** 
+	 * Raw string representation of an unary function.
+	 * Does not require tagset, may contain internal info
+	 * and/or be incomplete. It is in form of
+     * raw_operator_name(raw_argument_expression_string)
+     * although the open and close brackets can be changed
+     * (some operators use [])
+     */
+	static std::string to_raw_string(
+		const FunctionBase& f,
+		const FunctionBase& arg_expr,
+		const char* open_bracket = "(",
+		const char* close_bracket = ")");
+};
+
+/**
+ * Class that formats binary functions as string
+ */
+struct BinaryFunctionFormatter
+{
+    /** 
+	 * String representation of a binary function.
+	 * It is in form of
+     * operator_name(arg1_expr_string, arg2_expr_string)
+     */
+	static std::string to_string(
+		const Corpus2::Tagset& tagset,
+		const FunctionBase& f,
+		const FunctionBase& arg1_expr,
+		const FunctionBase& arg2_expr);
+
+    /** 
+	 * Raw string representation of a binary function.
+	 * Does not require tagset, may contain internal info
+	 * and/or be incomplete. It is in form of
+     * raw_op_name(raw_arg1_expr_string, raw_arg2_expr_string)
+     */
+	static std::string to_raw_string(
+		const FunctionBase& f,
+		const FunctionBase& arg1_expr,
+		const FunctionBase& arg2_expr);
+};
+
+} /* end ns Wccl */
+
+
+#endif // FORMATTERS_H
diff --git a/libwccl/ops/functions.h b/libwccl/ops/functions.h
index 7e4779af0af124bf8a12bb599a194cf4a152d4ba..0c56fb65282c8cd6a87ad5daf3dd735dd514b302 100644
--- a/libwccl/ops/functions.h
+++ b/libwccl/ops/functions.h
@@ -51,133 +51,6 @@ public:
 	}
 };
 
-/**
- * Abstract base class template for functional WCCL operators returning
- * a value of given type, while taking a single argument of selected type.
- * The argument is actually realised as a functional expression that returns
- * value of the specified type, per the unary function requirements.
- */
-template<class TArg, class TRet>
-class UnaryFunction : public Function<TRet> {
-public:
-	/**
-	 * Shared pointer type of expression that returns argument for
-	 * our unary function application
-	 */
-	typedef boost::shared_ptr<Function<TArg> > ArgExprPtr;
-
-	UnaryFunction(const ArgExprPtr& arg_expr)
-		: arg_expr_(arg_expr)
-	{
-		BOOST_ASSERT(arg_expr_);
-	}
-
-	/**
-	 * String representation of the unary function, realised by default
-	 * as "operator_name(argument_string)" (using open and close
-	 * brackets supplied by open_bracket() and close_bracket())
-	 */
-	virtual std::string to_string(const Corpus2::Tagset& tagset) const {
-		std::string returnValue(this->operator_name(tagset));
-		returnValue.append(open_bracket());
-		returnValue.append(arg_expr_->to_string(tagset));
-		returnValue.append(close_bracket());
-		return returnValue;
-	}
-	/**
-	 * String representation of the unary function, that does not
-	 * require tagset. May be incomplete and/or contain internal info.
-	 * Realised by default as "raw_operator_name(raw_argument_string)"
-	 * (using open and close brackets supplied by open_bracket()
-	 * and close_bracket())
-	 */
-	virtual std::string to_raw_string() const {
-		std::string returnValue(this->raw_operator_name());
-		returnValue.append(open_bracket());
-		returnValue.append(arg_expr_->to_raw_string());
-		returnValue.append(close_bracket());
-		return returnValue;
-	}
-protected:
-	const ArgExprPtr arg_expr_;
-
-	/**
-	 * Opening bracket to use in string representation.
-	 * By default it is "(", but some operators use "["
-	 */
-	virtual const char* open_bracket() {
-		return "(";
-	}
-	/**
-	 * Closing bracket to use in string representation.
-	 * By default it is ")", but some operators use "]"
-	 */
-	virtual const char* close_bracket() {
-		return ")";
-	}
-};
-
-/**
- * Abstract base class template for functional WCCL operators returning
- * a value of given type, while taking two arguments of selected types.
- * The arguments are actually realised as functions that return
- * value of a specified type, per the binary function requirements.
- */
-template<class TArg1, class TArg2, class TRet>
-class BinaryFunction : public Function<TRet> {
-public:
-	/**
-	 * Shared pointer type of expression that returns first argument for
-	 * our binary function application
-	 */
-	typedef boost::shared_ptr<Function<TArg1> > Arg1ExprPtr;
-	/**
-	 * Shared pointer type of expression that returns second argument for
-	 * our binary function application
-	 */
-	typedef boost::shared_ptr<Function<TArg2> > Arg2ExprPtr;
-
-	BinaryFunction(const Arg1ExprPtr& arg1_expr, const Arg2ExprPtr& arg2_expr)
-		: arg1_expr_(arg1_expr), arg2_expr_(arg2_expr)
-	{
-		BOOST_ASSERT(arg1_expr_);
-		BOOST_ASSERT(arg2_expr_);
-	}
-
-	/**
-	 * String representation of the binary function, realised by default
-	 * as "operator_name(arg1_string, arg2_string)"
-	 */
-	virtual std::string to_string(const Corpus2::Tagset& tagset) const {
-		std::string returnValue(this->operator_name(tagset));
-		returnValue.append("(");
-		returnValue.append(arg1_expr_->to_string(tagset));
-		returnValue.append(", ");
-		returnValue.append(arg2_expr_->to_string(tagset));
-		returnValue.append(")");
-		return returnValue;
-	}
-
-	/**
-	 * String representation of the binary function, that does not
-	 * require tagset. May be incomplete and/or contain internal info.
-	 * Realised by default as "raw_operator_name(raw_arg1_string, raw_arg2_string)"
-	 */
-	virtual std::string to_raw_string() const {
-		std::string returnValue(this->raw_operator_name());
-		returnValue.append("(");
-		returnValue.append(arg1_expr_->to_raw_string());
-		returnValue.append(", ");
-		returnValue.append(arg2_expr_->to_raw_string());
-		returnValue.append(")");
-		return returnValue;
-	}
-protected:
-	const Arg1ExprPtr arg1_expr_;
-	const Arg2ExprPtr arg2_expr_;
-
-};
-
 } /* end ns Wccl */
 
 #endif // FUNCTIONS_H