Using ->* for function bind rather than >>=.

schlangster · schlangster · commit 860e3442b439 · 2014-03-11T03:00:26.000+01:00
Revisited InputPack code, using proper types now.
diff --git a/include/react/Signal.h b/include/react/Signal.h
@@ -481,17 +481,17 @@ template
 >
 struct InputPack
 {
-	std::tuple<RSignal<D, TValues> ...> Data;
+	std::tuple<const RSignal<D, TValues>& ...> Data;
 
 	template <typename TFirstValue, typename TSecondValue>
 	InputPack(const RSignal<D,TFirstValue>& first, const RSignal<D,TSecondValue>& second) :
-		Data(std::make_tuple(first, second))
+		Data(std::tie(first, second))
 	{
 	}
 
 	template <typename ... TCurValues, typename TAppendValue>
 	InputPack(const InputPack<D, TCurValues ...>& curArgs, const RSignal<D,TAppendValue>& newArg) :
-		Data(std::tuple_cat(curArgs.Data, std::make_tuple(newArg)))
+		Data(std::tuple_cat(curArgs.Data, std::tie(newArg)))
 	{
 	}
 };
@@ -533,15 +533,15 @@ REACT_IMPL_BEGIN
 template
 <
 	typename D,
-	typename TFunc,
+	typename F,
 	typename ... TValues
 >
 struct ApplyHelper
 {
-	static inline auto MakeSignal(const TFunc& func, const RSignal<D,TValues>& ... args)
-		-> decltype(D::MakeSignal(func, args ...))
+	static inline auto MakeSignal(F&& func, const RSignal<D,TValues>& ... args)
+		-> decltype(D::MakeSignal(std::forward<F>(func), args ...))
 	{
-		return D::MakeSignal(func, args ...);
+		return D::MakeSignal(std::forward<F>(func), args ...);
 	}
 };
 
@@ -550,34 +550,34 @@ REACT_IMPL_END
 REACT_BEGIN
 
 ////////////////////////////////////////////////////////////////////////////////////////
-/// operator>>= overload to connect inputs to a function and return the resulting node.
+/// operator->* overload to connect inputs to a function and return the resulting node.
 ////////////////////////////////////////////////////////////////////////////////////////
 // Single input
 template
 <
 	typename D,
-	typename TFunc,
+	typename F,
 	typename TValue
 >
-inline auto operator>>=(const RSignal<D,TValue>& inputNode, TFunc func)
-	-> decltype(D::MakeSignal(func, inputNode))
+inline auto operator->*(const RSignal<D,TValue>& inputNode, F&& func)
+	-> decltype(D::MakeSignal(std::forward<F>(func), inputNode))
 {
-	return D::MakeSignal(func, inputNode);
+	return D::MakeSignal(std::forward<F>(func), inputNode);
 }
 
 // Multiple inputs
 template
 <
 	typename D,
-	typename TFunc,
+	typename F,
 	typename ... TValues
 >
-inline auto operator>>=(InputPack<D,TValues ...>& inputPack, TFunc func)
-	-> decltype(apply(REACT_IMPL::ApplyHelper<D, TFunc, TValues ...>
-		::MakeSignal, std::tuple_cat(std::make_tuple(func), inputPack.Data)))
+inline auto operator->*(const InputPack<D,TValues ...>& inputPack, F&& func)
+	-> decltype(apply(REACT_IMPL::ApplyHelper<D, F&&, TValues ...>
+		::MakeSignal, std::tuple_cat(std::forward_as_tuple(std::forward<F>(func)), inputPack.Data)))
 {
-	return apply(REACT_IMPL::ApplyHelper<D, TFunc, TValues ...>
-		::MakeSignal, std::tuple_cat(std::make_tuple(func), inputPack.Data));
+	return apply(REACT_IMPL::ApplyHelper<D, F&&, TValues ...>
+		::MakeSignal, std::tuple_cat(std::forward_as_tuple(std::forward<F>(func)), inputPack.Data));
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/benchmark/BenchmarkFanout.h b/src/benchmark/BenchmarkFanout.h
@@ -56,7 +56,7 @@ struct Benchmark_Fanout : public BenchmarkBase<D>
 
 		for (int i=0; i<params.N; i++)
 		{
-			auto t = in >>= f;
+			auto t = in ->* f;
 			nodes.push_back(t);
 		}
 
diff --git a/src/benchmark/BenchmarkGrid.h b/src/benchmark/BenchmarkGrid.h
@@ -64,21 +64,21 @@ class GridGraphGenerator
 
 				if (shouldGrow)
 				{
-					auto s = (*l) >>= Function1;
+					auto s = (*l) ->* Function1;
 					nextBuf->push_back(s);
 				}
 
 				while (r != curBuf->end())
 				{
-					auto s = (*l,*r) >>= Function2;
+					auto s = (*l,*r) ->* Function2;
 					nextBuf->push_back(s);
 					nodeCount++;
 					++l; ++r;
 				}
 
 				if (shouldGrow)
 				{
-					auto s = (*l) >>= Function1;
+					auto s = (*l) ->* Function1;
 					nextBuf->push_back(s);
 					nodeCount++;
 				}
diff --git a/src/benchmark/BenchmarkLifeSim.h b/src/benchmark/BenchmarkLifeSim.h
@@ -39,7 +39,7 @@ class Time : public ReactiveObject<D>
 	Signal<int>		TotalDays	= Iterate(0, NewDay, Incrementer<int>());
 	Signal<int>		DayOfYear	= TotalDays % 365;
 
-	Signal<Seasons>	Season = DayOfYear >>= [] (int day) {
+	Signal<Seasons>	Season = DayOfYear ->* [] (int day) {
 		return day < 180 ? Seasons::winter : Seasons::summer;
 	};
 };
@@ -60,12 +60,12 @@ class Region : public ReactiveObject<D>
 		return m == Migration::enter ? count + 1 : count - 1;
 	});
 
-	Signal<int>	FoodPerDay = theTime.Season >>= [] (Seasons season) {
+	Signal<int>	FoodPerDay = theTime.Season ->* [] (Seasons season) {
 		return season == Seasons::summer ? 20 : 10;
 	};
 
 	Signal<int>	FoodOutputPerDay =
-		(FoodPerDay, AnimalCount) >>= [] (int food, int count) {
+		(FoodPerDay, AnimalCount) ->* [] (int food, int count) {
 			return count > 0 ? food/count : 0;
 	};
 
@@ -169,7 +169,7 @@ class Animal : public ReactiveObject<D>
 				return CurrentRegion.Value()->Clamp(position);
 		});
 
-		NewRegion = (Position) >>= [this] (PositionT pos)
+		NewRegion = (Position) ->* [this] (PositionT pos)
 		{
 			return theWorld.GetRegion(pos);
 		};
diff --git a/src/benchmark/BenchmarkRandom.h b/src/benchmark/BenchmarkRandom.h
@@ -133,20 +133,20 @@ class RandomGraphGenerator
 
 					if (edgeCount == 2)
 					{
-						nodes[cur] = (nodes[kNode0], nodes[rNode1]) >>= f2;
+						nodes[cur] = (nodes[kNode0], nodes[rNode1]) ->* f2;
 					}
 					else if (edgeCount == 3)
 					{
-						nodes[cur] = (nodes[kNode0], nodes[rNode1], nodes[rNode2]) >>= f3;
+						nodes[cur] = (nodes[kNode0], nodes[rNode1], nodes[rNode2]) ->* f3;
 					}
 					else
 					{
-						nodes[cur] = (nodes[kNode0], nodes[rNode1], nodes[rNode2], nodes[rNode3]) >>= f4;
+						nodes[cur] = (nodes[kNode0], nodes[rNode1], nodes[rNode2], nodes[rNode3]) ->* f4;
 					}
 				}
 				else
 				{
-					nodes[cur] = nodes[cur-Width] >>= f1;
+					nodes[cur] = nodes[cur-Width] ->* f1;
 				}
 
 				cur++;
diff --git a/src/benchmark/BenchmarkSequence.h b/src/benchmark/BenchmarkSequence.h
@@ -56,7 +56,7 @@ struct Benchmark_Sequence : public BenchmarkBase<D>
 
 		MyHandle cur = in;
 		for (int i=0; i<params.N; i++)
-			cur = cur >>= f;
+			cur = cur ->* f;
 
 		initializing = false;
 
diff --git a/src/sandbox/Main.cpp b/src/sandbox/Main.cpp
@@ -51,7 +51,7 @@ void SignalExample2()
 	auto height = D::MakeVar(70);
 	auto depth = D::MakeVar(8);
 
-	auto volume = (width,height,depth) >>= [] (int w, int h, int d) {
+	auto volume = (width,height,depth) ->* [] (int w, int h, int d) {
 		return w * h * d;
 	};
 
@@ -142,8 +142,6 @@ class Person : public ReactiveObject<D>
 	Signal<int>		Health	= 100 - Age;
 	Signal<int>		Wisdom  = Age * Age / 100;
 
-	Signal<int>	Test;
-
 	// Note: Initializing them directly uses the same lambda for both signals...
 	// compiler bug?
 	Observer	wisdomObs;
diff --git a/src/test/SignalTest.h b/src/test/SignalTest.h
@@ -272,7 +272,7 @@ TYPED_TEST_P(SignalTest, FunctionBind1)
 	auto v2 = MyDomain::MakeVar(30);
 	auto v3 = MyDomain::MakeVar(10);
 
-	auto signal = (v1, v2, v3) >>= [=] (int a, int b, int c) -> int
+	auto signal = (v1, v2, v3) ->* [=] (int a, int b, int c) -> int
 	{
 		return a * b * c;
 	};
@@ -294,9 +294,9 @@ TYPED_TEST_P(SignalTest, FunctionBind2)
 	auto a = MyDomain::MakeVar(1);
 	auto b = MyDomain::MakeVar(1);
 	
-	auto c = ((a+b), (a+100)) >>= myfunc;
-	auto d = c >>= myfunc2;
-	auto e = (d,d) >>= myfunc3;
+	auto c = ((a+b), (a+100)) ->* myfunc;
+	auto d = c ->* myfunc2;
+	auto e = (d,d) ->* myfunc3;
 	auto f = -e + 100;
 
 	ASSERT_EQ(c(),103);
diff --git a/src/test/TransactionTest.h b/src/test/TransactionTest.h
@@ -170,22 +170,22 @@ TYPED_TEST_P(TransactionTest, Concurrent3)
 	};
 
 	auto n1 = MyDomain::MakeVar(1);
-	auto n2 = n1 >>= f_0;
-	auto n3 = ((n2, n1) >>= f_n) >>= f_0;
-	auto n4 = n3 >>= f_0;
-	auto n5 = ((((n4, n3) >>= f_n), n1) >>= f_n) >>= f_0;
-	auto n6 = n5 >>= f_0;
-	auto n7 = ((n6, n5) >>= f_n) >>= f_0;
-	auto n8 = n7 >>= f_0;
-	auto n9 = ((((((n8, n7) >>= f_n), n5) >>= f_n), n1) >>= f_n) >>= f_0;
-	auto n10 = n9 >>= f_0;
-	auto n11 = ((n10, n9) >>= f_n) >>= f_0;
-	auto n12 = n11 >>= f_0;
-	auto n13 = ((((n12, n11) >>= f_n), n9) >>= f_n) >>= f_0;
-	auto n14 = n13 >>= f_0;
-	auto n15 = ((n14, n13) >>= f_n) >>= f_0;
-	auto n16 = n15 >>= f_0;
-	auto n17 = ((((((n16, n15) >>= f_n), n13) >>= f_n), n9) >>= f_n)  >>= f_0;
+	auto n2 = n1 ->* f_0;
+	auto n3 = ((n2, n1) ->* f_n) ->* f_0;
+	auto n4 = n3 ->* f_0;
+	auto n5 = ((((n4, n3) ->* f_n), n1) ->* f_n) ->* f_0;
+	auto n6 = n5 ->* f_0;
+	auto n7 = ((n6, n5) ->* f_n) ->* f_0;
+	auto n8 = n7 ->* f_0;
+	auto n9 = ((((((n8, n7) ->* f_n), n5) ->* f_n), n1) ->* f_n) ->* f_0;
+	auto n10 = n9 ->* f_0;
+	auto n11 = ((n10, n9) ->* f_n) ->* f_0;
+	auto n12 = n11 ->* f_0;
+	auto n13 = ((((n12, n11) ->* f_n), n9) ->* f_n) ->* f_0;
+	auto n14 = n13 ->* f_0;
+	auto n15 = ((n14, n13) ->* f_n) ->* f_0;
+	auto n16 = n15 ->* f_0;
+	auto n17 = ((((((n16, n15) ->* f_n), n13) ->* f_n), n9) ->* f_n)  ->* f_0;
 
 	Observe(n17, [&] (int v)
 	{
@@ -239,7 +239,7 @@ TYPED_TEST_P(TransactionTest, Merging1)
 	};
 
 	auto n1 = MyDomain::MakeVar(1);
-	auto n2 = n1 >>= f;
+	auto n2 = n1 ->* f;
 
 	Observe(n2, [&] (int v)
 	{

Original file line number	Diff line number	Diff line change
`@@ -481,17 +481,17 @@ template`
`481`	`481`	`>`
`482`	`482`	`struct InputPack`
`483`	`483`	`{`
`484`		`- std::tuple<RSignal<D, TValues> ...> Data;`
	`484`	`+ std::tuple<const RSignal<D, TValues>& ...> Data;`
`485`	`485`
`486`	`486`	`template <typename TFirstValue, typename TSecondValue>`
`487`	`487`	`InputPack(const RSignal<D,TFirstValue>& first, const RSignal<D,TSecondValue>& second) :`
`488`		`- Data(std::make_tuple(first, second))`
	`488`	`+ Data(std::tie(first, second))`
`489`	`489`	`{`
`490`	`490`	`}`
`491`	`491`
`492`	`492`	`template <typename ... TCurValues, typename TAppendValue>`
`493`	`493`	`InputPack(const InputPack<D, TCurValues ...>& curArgs, const RSignal<D,TAppendValue>& newArg) :`
`494`		`- Data(std::tuple_cat(curArgs.Data, std::make_tuple(newArg)))`
	`494`	`+ Data(std::tuple_cat(curArgs.Data, std::tie(newArg)))`
`495`	`495`	`{`
`496`	`496`	`}`
`497`	`497`	`};`
`@@ -533,15 +533,15 @@ REACT_IMPL_BEGIN`
`533`	`533`	`template`
`534`	`534`	`<`
`535`	`535`	`typename D,`
`536`		`- typename TFunc,`
	`536`	`+ typename F,`
`537`	`537`	`typename ... TValues`
`538`	`538`	`>`
`539`	`539`	`struct ApplyHelper`
`540`	`540`	`{`
`541`		`- static inline auto MakeSignal(const TFunc& func, const RSignal<D,TValues>& ... args)`
`542`		`- -> decltype(D::MakeSignal(func, args ...))`
	`541`	`+ static inline auto MakeSignal(F&& func, const RSignal<D,TValues>& ... args)`
	`542`	`+ -> decltype(D::MakeSignal(std::forward<F>(func), args ...))`
`543`	`543`	`{`
`544`		`- return D::MakeSignal(func, args ...);`
	`544`	`+ return D::MakeSignal(std::forward<F>(func), args ...);`
`545`	`545`	`}`
`546`	`546`	`};`
`547`	`547`
`@@ -550,34 +550,34 @@ REACT_IMPL_END`
`550`	`550`	`REACT_BEGIN`
`551`	`551`
`552`	`552`	`////////////////////////////////////////////////////////////////////////////////////////`
`553`		`-/// operator>>= overload to connect inputs to a function and return the resulting node.`
	`553`	`+/// operator->* overload to connect inputs to a function and return the resulting node.`
`554`	`554`	`////////////////////////////////////////////////////////////////////////////////////////`
`555`	`555`	`// Single input`
`556`	`556`	`template`
`557`	`557`	`<`
`558`	`558`	`typename D,`
`559`		`- typename TFunc,`
	`559`	`+ typename F,`
`560`	`560`	`typename TValue`
`561`	`561`	`>`
`562`		`-inline auto operator>>=(const RSignal<D,TValue>& inputNode, TFunc func)`
`563`		`- -> decltype(D::MakeSignal(func, inputNode))`
	`562`	`+inline auto operator->*(const RSignal<D,TValue>& inputNode, F&& func)`
	`563`	`+ -> decltype(D::MakeSignal(std::forward<F>(func), inputNode))`
`564`	`564`	`{`
`565`		`- return D::MakeSignal(func, inputNode);`
	`565`	`+ return D::MakeSignal(std::forward<F>(func), inputNode);`
`566`	`566`	`}`
`567`	`567`
`568`	`568`	`// Multiple inputs`
`569`	`569`	`template`
`570`	`570`	`<`
`571`	`571`	`typename D,`
`572`		`- typename TFunc,`
	`572`	`+ typename F,`
`573`	`573`	`typename ... TValues`
`574`	`574`	`>`
`575`		`-inline auto operator>>=(InputPack<D,TValues ...>& inputPack, TFunc func)`
`576`		`- -> decltype(apply(REACT_IMPL::ApplyHelper<D, TFunc, TValues ...>`
`577`		`- ::MakeSignal, std::tuple_cat(std::make_tuple(func), inputPack.Data)))`
	`575`	`+inline auto operator->*(const InputPack<D,TValues ...>& inputPack, F&& func)`
	`576`	`+ -> decltype(apply(REACT_IMPL::ApplyHelper<D, F&&, TValues ...>`
	`577`	`+ ::MakeSignal, std::tuple_cat(std::forward_as_tuple(std::forward<F>(func)), inputPack.Data)))`
`578`	`578`	`{`
`579`		`- return apply(REACT_IMPL::ApplyHelper<D, TFunc, TValues ...>`
`580`		`- ::MakeSignal, std::tuple_cat(std::make_tuple(func), inputPack.Data));`
	`579`	`+ return apply(REACT_IMPL::ApplyHelper<D, F&&, TValues ...>`
	`580`	`+ ::MakeSignal, std::tuple_cat(std::forward_as_tuple(std::forward<F>(func)), inputPack.Data));`
`581`	`581`	`}`
`582`	`582`
`583`	`583`	`////////////////////////////////////////////////////////////////////////////////////////`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ struct Benchmark_Fanout : public BenchmarkBase<D>`
`56`	`56`
`57`	`57`	`for (int i=0; i<params.N; i++)`
`58`	`58`	`{`
`59`		`- auto t = in >>= f;`
	`59`	`+ auto t = in ->* f;`
`60`	`60`	`nodes.push_back(t);`
`61`	`61`	`}`
`62`	`62`
Original file line number	Diff line number	Diff line change
`@@ -64,21 +64,21 @@ class GridGraphGenerator`
`64`	`64`
`65`	`65`	`if (shouldGrow)`
`66`	`66`	`{`
`67`		`- auto s = (*l) >>= Function1;`
	`67`	`+ auto s = (l) -> Function1;`
`68`	`68`	`nextBuf->push_back(s);`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`while (r != curBuf->end())`
`72`	`72`	`{`
`73`		`- auto s = (l,r) >>= Function2;`
	`73`	`+ auto s = (l,r) ->* Function2;`
`74`	`74`	`nextBuf->push_back(s);`
`75`	`75`	`nodeCount++;`
`76`	`76`	`++l; ++r;`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`if (shouldGrow)`
`80`	`80`	`{`
`81`		`- auto s = (*l) >>= Function1;`
	`81`	`+ auto s = (l) -> Function1;`
`82`	`82`	`nextBuf->push_back(s);`
`83`	`83`	`nodeCount++;`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,20 +133,20 @@ class RandomGraphGenerator`
`133`	`133`
`134`	`134`	`if (edgeCount == 2)`
`135`	`135`	`{`
`136`		`- nodes[cur] = (nodes[kNode0], nodes[rNode1]) >>= f2;`
	`136`	`+ nodes[cur] = (nodes[kNode0], nodes[rNode1]) ->* f2;`
`137`	`137`	`}`
`138`	`138`	`else if (edgeCount == 3)`
`139`	`139`	`{`
`140`		`- nodes[cur] = (nodes[kNode0], nodes[rNode1], nodes[rNode2]) >>= f3;`
	`140`	`+ nodes[cur] = (nodes[kNode0], nodes[rNode1], nodes[rNode2]) ->* f3;`
`141`	`141`	`}`
`142`	`142`	`else`
`143`	`143`	`{`
`144`		`- nodes[cur] = (nodes[kNode0], nodes[rNode1], nodes[rNode2], nodes[rNode3]) >>= f4;`
	`144`	`+ nodes[cur] = (nodes[kNode0], nodes[rNode1], nodes[rNode2], nodes[rNode3]) ->* f4;`
`145`	`145`	`}`
`146`	`146`	`}`
`147`	`147`	`else`
`148`	`148`	`{`
`149`		`- nodes[cur] = nodes[cur-Width] >>= f1;`
	`149`	`+ nodes[cur] = nodes[cur-Width] ->* f1;`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`cur++;`