Cleaned up flow_graph.

src/flow_graph.erl

@@ -67,25 +67,16 @@ split(N) -> #split{size=N}.
 merge(N) -> #merge{size=N}.
 
 switch(Switch, Map = [{_, Op1}|Rest]) ->
-    CheckIO = fun(Op, In, Out) ->
-		      case {similar_arity(in_arity(Op), In),
-			    similar_arity(out_arity(Op), Out)}
-		      of
-			  {false, _} -> throw(arity_mismatch);
-			  {_, false} -> throw(arity_mismatch);
-			  {I, O}     -> {I, O}
-		      end
-	      end,
     try
 	{I, O} = lists:foldl(
-		   fun({_, Op}, {In, Out}) -> CheckIO(Op, In, Out) end,
+		   fun({_, Op}, {In, Out}) -> known_op_arity(Op, In, Out) end,
 		   {in_arity(Op1), out_arity(Op1)}, Rest),
-	CheckIO(Switch, I, 1),
+	known_op_arity(Switch, I, 1),
 	{I, O}
     of
 	{In, Out} -> #switch{in=In, out=Out, switch=Switch, map=Map}
     catch
-	throw:arity_mismatch -> erlang:error(badarg, [Switch, Map])
+	error:function_clause -> erlang:error(badarg, [Switch, Map])
     end.
 
 loop(N, Op) ->
@@ -109,8 +100,7 @@ in_arity(#sequence{in=In}) -> In;
 in_arity(#split{})         -> 1;
 in_arity(#merge{size=N})   -> N;
 in_arity(#switch{in=In})   -> In;
-in_arity(#loop{in=In})     -> In;
-in_arity(Bad)              -> erlang:error(badarg, [Bad]).
+in_arity(#loop{in=In})     -> In.
 
 out_arity(#func{})            -> 1;
 out_arity(#value{})           -> 1;
@@ -122,8 +112,7 @@ out_arity(#sequence{out=Out}) -> Out;
 out_arity(#split{size=N})     -> N;
 out_arity(#merge{})           -> 1;
 out_arity(#switch{out=Out})   -> Out;
-out_arity(#loop{out=Out})     -> Out;
-out_arity(Bad)                -> erlang:error(badarg, [Bad]).
+out_arity(#loop{out=Out})     -> Out.
 
 flatten_arity([First|Rest]) ->
     lists:foldl(fun(Op, {In, Out}) ->
@@ -136,10 +125,12 @@ add_arity(unknown, _) -> unknown;
 add_arity(_, unknown) -> unknown;
 add_arity(N, M)       -> N + M.
 
-similar_arity(N, N)       -> N;
-similar_arity(unknown, N) -> N;
-similar_arity(N, unknown) -> N;
-similar_arity(_, _)       -> false.
+known_arity(N, N)       -> N;
+known_arity(unknown, N) -> N;
+known_arity(N, unknown) -> N.
+
+known_op_arity(Op, In, Out) ->
+    {known_arity(in_arity(Op), In), known_arity(out_arity(Op), Out)}.
 
 can_connect(Op1, Op2) ->
     case {out_arity(Op1), in_arity(Op2)} of