Support splitting up struct method parameters into multiple input ports

doc/libraries_ref_guide/LibDoc/Prelude.tex

@@ -3531,17 +3531,6 @@ \subsubsection{Tuples}
 \end{tabular}
 \end{center}
 
-{\bf Examples}
-
-\begin{verbatim}
-   Tuple2#( Bool, int ) foo = tuple2( True, 25 );
-   Bool field1 = tpl_1( foo ); // this is value 1 in the list
-   int  field2 = tpl_2( foo ); // this is value 2 in the list
-   foo = tuple2( !field1, field2 );
-\end{verbatim}
-
-\paragraph{TupleSize}
-
 \te{TupleSize} provides a way to determine the number of elements in a tuple
 at the type level. The size is represented as a numeric type parameter.
 
@@ -3577,8 +3566,6 @@ \subsubsection{Tuples}
 \end{tabular}
 \end{center}
 
-\paragraph{AppendTuple}
-
 \te{AppendTuple} provides a way to join two tuples of arbitrary size into a single larger
 tuple, and to split a tuple back into two parts.
 
@@ -3591,7 +3578,7 @@ \subsubsection{Tuples}
 
 \begin{libverbatim}
    typeclass AppendTuple #(type a, type b, type c)
-      dependencies (a b determines c);
+      dependencies ((a, b) determines c);
       function c appendTuple(a x, b y);
       function Tuple2#(a, b) splitTuple(c x);
    endtypeclass
@@ -3627,6 +3614,11 @@ \subsubsection{Tuples}
 {\bf Examples}
 
 \begin{verbatim}
+   Tuple2#( Bool, int ) foo = tuple2( True, 25 );
+   Bool field1 = tpl_1( foo ); // this is value 1 in the list
+   int  field2 = tpl_2( foo ); // this is value 2 in the list
+   foo = tuple2( !field1, field2 );
+
    // Appending a 2-tuple and a 3-tuple to create a 5-tuple
    Tuple2#(Bool, Int#(8)) t1 = tuple2(True, 42);
    Tuple3#(String, Bit#(4), UInt#(16)) t2 = tuple3("test", 4'hA, 100);
@@ -3641,7 +3633,7 @@ \subsubsection{Tuples}
    Tuple2#(Tuple2#(Bool, Int#(8)), Tuple2#(String, Bit#(4))) parts =
       splitTuple(t4);
 
-   // Appending with unit type
+   // Appending with unit type (void)
    Tuple2#(Bool, Int#(8)) t5 = tuple2(False, 0);
    Tuple2#(Bool, Int#(8)) t6 = appendTuple(t5, ?);  // same as t5
    Tuple2#(Bool, Int#(8)) t7 = appendTuple(?, t5);  // same as t5
@@ -6319,12 +6311,59 @@ \subsubsection{Operations on Functions}
 \end{tabular}
 \end{center}
 
+\index{Curry@\te{Curry} (type class)}
+\index[typeclass]{Curry}
+\index{curryN@\te{curryN} (function)}
+\index[function]{Prelude!curryN}
+\index{uncurryN@\te{uncurryN} (function)}
+\index[function]{Prelude!uncurryN}
+
+The \te{Curry} typeclass generalizes the \te{curry} and \te{uncurry} functions
+to work with tuples of any size (not just Tuple2).
+
+\begin{libverbatim}
+typeclass Curry#(type f, type g)
+   dependencies (f determines g);
+      function g curryN(f x);
+      function f uncurryN(g x);
+endtypeclass
+\end{libverbatim}
+
+\begin{center}
+\begin{tabular}{|p{1 in}|p{4 in}|}
+\hline
+\te{curryN}&Converts an uncurried function (taking an N-tuple argument) into a curried
+function (taking N arguments one at a time). For example, \te{curryN} can convert a
+function taking \te{Tuple3\#(a,b,c)} into a function \te{a -> b -> c -> result}.\\
+\hline
+\te{uncurryN}&The inverse of \te{curryN}. Converts a curried function (taking N arguments
+one at a time) into an uncurried function (taking an N-tuple argument).\\
+\hline
+\end{tabular}
+\end{center}
+
 
 {\bf Examples}
 
 \begin{libverbatim}
  //using constFn to set the initial values of the registers in a list
    List#(Reg#(Resource)) items <- mapM( constFn(mkReg(initRes)),upto(1,numAdd) );
+
+ // Using curryN with a 3-tuple
+   function Int#(32) add3Tuple(Tuple3#(Int#(32), Int#(32), Int#(32)) t);
+      return tpl_1(t) + tpl_2(t) + tpl_3(t);
+   endfunction
+
+   let add3Curried = curryN(add3Tuple);
+   Int#(32) result = add3Curried(1)(2)(3);  // result = 6
+
+ // Using uncurryN
+   function Int#(32) add3(Int#(32) a, Int#(32) b, Int#(32) c);
+      return a + b + c;
+   endfunction
+
+   let add3Uncurried = uncurryN(add3);
+   Int#(32) result2 = add3Uncurried(tuple3(1, 2, 3));  // result2 = 6
 
    return(pack(map(compose(head0,toList),state)));
 

doc/libraries_ref_guide/LibDoc/Vector.tex

@@ -2273,8 +2273,6 @@ \subsubsection{Converting to and from Vectors}
 \hline
 \end{tabular}
 
-\paragraph{ConcatTuple}
-
 The \te{ConcatTuple} type class provides functions to convert between a Vector
 of tuples and a single flattened tuple. When you have a Vector where each
 element is a tuple (or can be viewed as a tuple), \te{concatTuple} flattens
@@ -2291,7 +2289,7 @@ \subsubsection{Converting to and from Vectors}
 
 \begin{libverbatim}
    typeclass ConcatTuple #(numeric type n, type a, type b)
-      dependencies (n a determines b);
+      dependencies ((n, a) determines b);
       function b concatTuple(Vector#(n, a) v);
       function Vector#(n, a) unconcatTuple(b x);
    endtypeclass
@@ -2301,7 +2299,7 @@ \subsubsection{Converting to and from Vectors}
 \begin{itemize}
 \item A vector of size 0 converts to/from the unit type \te{void}
 \item A vector of size 1 converts to/from a single element
-\item Larger vectors convert by flattening: each element is appended to
+\item Larger vectors convert by appending each element tuple to
 form a larger tuple
 \end{itemize}
 
@@ -2330,7 +2328,15 @@ \subsubsection{Converting to and from Vectors}
 \hline
 \end{tabular}
 
-{\bf Example - ConcatTuple}
+{\bf Examples - Lists}
+
+Convert the vector \te{my\_vector} to a list named \te{my\_list}.
+\begin{libverbatim}
+     Vector#(5,Int#(13)) my_vector;
+     List#(Int#(13)) my_list = toList(my_vector);
+\end{libverbatim}
+
+{\bf Examples - Tuples}
 
 Flatten a vector of 3 pairs (2-tuples) into a single 6-tuple:
 \begin{libverbatim}
@@ -2386,15 +2392,6 @@ \subsubsection{Converting to and from Vectors}
 \end{libverbatim}
 
 
-{\bf Example - Converting to and from Vectors}
-
-Convert the vector \te{my\_vector} to a list named \te{my\_list}.
-\begin{libverbatim}
-     Vector#(5,Int#(13)) my_vector;
-     List#(Int#(13)) my_list = toList(my_vector);
-\end{libverbatim}
-
-
 \subsubsection{ListN}
 
 \index{ListN@\te{ListN} (type)}

testsuite/bsc.lib/Prelude/CurryTypeClass.bs

@@ -0,0 +1,129 @@
+-----------------------------------------------------------------------
+-- Test for the Curry type class and curryN/uncurryN functions
+-----------------------------------------------------------------------
+
+package CurryTypeClass where
+
+import Vector
+
+-----------------------------------------------------------------------
+-- Test with Tuple2
+-----------------------------------------------------------------------
+
+add2Tuple :: (Int 32, Int 32) -> Int 32
+add2Tuple t = tpl_1 t + tpl_2 t
+
+add2 :: Int 32 -> Int 32 -> Int 32
+add2 a b = a + b
+
+testCurry2 :: Bool
+testCurry2 =
+   let curried :: Int 32 -> Int 32 -> Int 32
+       curried = curryN add2Tuple
+       result1 :: Int 32
+       result1 = curried 5 10
+       uncurried :: (Int 32, Int 32) -> Int 32
+       uncurried = uncurryN add2
+       result2 :: Int 32
+       result2 = uncurried (5, 10)
+   in result1 == 15 && result2 == 15
+
+
+-----------------------------------------------------------------------
+-- Test with Tuple3
+-----------------------------------------------------------------------
+
+add3Tuple :: (Int 32, Int 32, Int 32) -> Int 32
+add3Tuple t = tpl_1 t + tpl_2 t + tpl_3 t
+
+add3 :: Int 32 -> Int 32 -> Int 32 -> Int 32
+add3 a b c = a + b + c
+
+testCurry3 :: Bool
+testCurry3 =
+   let curried :: Int 32 -> Int 32 -> Int 32 -> Int 32
+       curried = curryN add3Tuple
+       result1 :: Int 32
+       result1 = curried 1 2 3
+       uncurried :: (Int 32, Int 32, Int 32) -> Int 32
+       uncurried = uncurryN add3
+       result2 :: Int 32
+       result2 = uncurried (1, 2, 3)
+   in result1 == 6 && result2 == 6
+
+
+-----------------------------------------------------------------------
+-- Test with Tuple4
+-----------------------------------------------------------------------
+
+add4Tuple :: (Int 32, Int 32, Int 32, Int 32) -> Int 32
+add4Tuple t = tpl_1 t + tpl_2 t + tpl_3 t + tpl_4 t
+
+add4 :: Int 32 -> Int 32 -> Int 32 -> Int 32 -> Int 32
+add4 a b c d = a + b + c + d
+
+testCurry4 :: Bool
+testCurry4 =
+   let curried :: Int 32 -> Int 32 -> Int 32 -> Int 32 -> Int 32
+       curried = curryN add4Tuple
+       result1 :: Int 32
+       result1 = curried 1 2 3 4
+       uncurried :: (Int 32, Int 32, Int 32, Int 32) -> Int 32
+       uncurried = uncurryN add4
+       result2 :: Int 32
+       result2 = uncurried (1, 2, 3, 4)
+   in result1 == 10 && result2 == 10
+
+
+-----------------------------------------------------------------------
+-- Test roundtrip: curryN . uncurryN = id and uncurryN . curryN = id
+-----------------------------------------------------------------------
+
+testRoundtrip :: Bool
+testRoundtrip =
+   -- Test that uncurrying then currying gets back the original behavior
+   let temp :: (Int 32, Int 32, Int 32) -> Int 32
+       temp = uncurryN add3
+       f1 :: Int 32 -> Int 32 -> Int 32 -> Int 32
+       f1 = curryN temp
+       result1 :: Int 32
+       result1 = f1 10 20 30
+       -- Test that currying then uncurrying gets back the original behavior
+       f2 :: (Int 32, Int 32, Int 32) -> Int 32
+       f2 = uncurryN (curryN add3Tuple)
+       result2 :: Int 32
+       result2 = f2 (10, 20, 30)
+   in result1 == 60 && result2 == 60
+
+
+-----------------------------------------------------------------------
+-- Test with unit tuple (special case)
+-----------------------------------------------------------------------
+
+fromUnitTuple :: () -> Int 32
+fromUnitTuple _ = 42
+
+testUnitTuple :: Bool
+testUnitTuple =
+   let curried :: Int 32
+       curried = curryN fromUnitTuple
+   in curried == 42
+
+
+-----------------------------------------------------------------------
+-- Module for testing
+-----------------------------------------------------------------------
+
+{-# verilog sysCurryTypeClass #-}
+sysCurryTypeClass :: Module Empty
+sysCurryTypeClass =
+   module
+      rules
+         "test": when True ==>
+            action
+               $display "Test Curry2: %b" testCurry2
+               $display "Test Curry3: %b" testCurry3
+               $display "Test Curry4: %b" testCurry4
+               $display "Test Roundtrip: %b" testRoundtrip
+               $display "Test Unit Tuple: %b" testUnitTuple
+               $finish 0

testsuite/bsc.lib/Prelude/Prelude.exp

@@ -8,3 +8,4 @@ compile_verilog_fail_no_internal_error Eq3
 test_c_veri_bs_modules TuplePack {}
 test_c_veri_bs_modules TupleSize {}
 test_c_veri_bs_modules AppendTuple {}
+test_c_veri_bs_modules CurryTypeClass {}

testsuite/bsc.lib/Prelude/sysCurryTypeClass.out.expected

@@ -0,0 +1,5 @@
+Test Curry2: 1
+Test Curry3: 1
+Test Curry4: 1
+Test Roundtrip: 1
+Test Unit Tuple: 1