updated Scala comments in scala/Function.scala

3 files changed, 77 insertions, 47 deletions

diff --git a/src/dbc/scala/dbc/result/Field.scala b/src/dbc/scala/dbc/result/Field.scala
index 5fc8be17ea..ff93cc1698 100644
--- a/src/dbc/scala/dbc/result/Field.scala
+++ b/src/dbc/scala/dbc/result/Field.scala
@@ -1,6 +1,6 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2006, LAMP/EPFL             **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2007, LAMP/EPFL             **
 **  __\ \/ /__/ __ |/ /__/ __ |                                         **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
@@ -9,55 +9,55 @@
 // $Id:Field.scala 6853 2006-03-20 16:58:47 +0100 (Mon, 20 Mar 2006) dubochet $
 
 
-package scala.dbc.result;
+package scala.dbc.result
 
 
-import scala.dbc.datatype._;
-import scala.dbc.value._;
+import scala.dbc.datatype._
+import scala.dbc.value._
 
 /** An ISO-9075:2003 (SQL) table field. */
 abstract class Field {
 
   /** The content (value) of the field. The type of this value is undefined,
-   * transformation into a useful type will be done by an automatic view
-   * function defined in the field object. */
-  def content: Value;
+   *  transformation into a useful type will be done by an automatic view
+   *  function defined in the field object.
+   */
+  def content: Value
 
   final def value[Type <: Value]: Type =
-    content.asInstanceOf[Type];
+    content.asInstanceOf[Type]
 
   final def exactNumericValue[NativeType] =
-    content.asInstanceOf[dbc.value.ExactNumeric[NativeType]];
+    content.asInstanceOf[dbc.value.ExactNumeric[NativeType]]
 
   final def approximateNumericValue[NativeType] =
-    content.asInstanceOf[dbc.value.ApproximateNumeric[NativeType]];
+    content.asInstanceOf[dbc.value.ApproximateNumeric[NativeType]]
 
   final def booleanValue =
-    content.asInstanceOf[dbc.value.Boolean];
+    content.asInstanceOf[dbc.value.Boolean]
 
   final def characterValue =
-    content.asInstanceOf[dbc.value.Character];
+    content.asInstanceOf[dbc.value.Character]
 
   final def characterLargeObjectValue =
-    content.asInstanceOf[dbc.value.CharacterLargeObject];
+    content.asInstanceOf[dbc.value.CharacterLargeObject]
 
   final def characterVaryingValue =
-    content.asInstanceOf[dbc.value.CharacterVarying];
+    content.asInstanceOf[dbc.value.CharacterVarying]
 
   final def unknownValue =
-    content.asInstanceOf[dbc.value.Unknown];
+    content.asInstanceOf[dbc.value.Unknown]
 
   /** The tuple that contains this field. */
-  def originatingTuple: Tuple;
+  def originatingTuple: Tuple
 
   /** The field metadata attached to this field. */
-  def metadata: FieldMetadata;
+  def metadata: FieldMetadata
 
 }
 
 object Field {
 
-  implicit def fieldToValue (field:Field): Value = field.content;
-
+  implicit def fieldToValue (field: Field): Value = field.content
 
 }
diff --git a/src/dbc/scala/dbc/result/FieldMetadata.scala b/src/dbc/scala/dbc/result/FieldMetadata.scala
index a3420eb7d6..3501bd3c79 100644
--- a/src/dbc/scala/dbc/result/FieldMetadata.scala
+++ b/src/dbc/scala/dbc/result/FieldMetadata.scala
@@ -1,6 +1,6 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2006, LAMP/EPFL             **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2007, LAMP/EPFL             **
 **  __\ \/ /__/ __ |/ /__/ __ |                                         **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
@@ -9,28 +9,32 @@
 // $Id:FieldMetadata.scala 6853 2006-03-20 16:58:47 +0100 (Mon, 20 Mar 2006) dubochet $
 
 
-package scala.dbc.result;
+package scala.dbc.result
 
 
-/** Informations attached to a field about its content and its relationship to the originating database. */
+/** The class <code>FieldMetadata</cocde> provides informations attached to
+ *  a field about its content and its relationship to the originating database.
+ */
 abstract class FieldMetadata {
 
   /** The name of the field. */
-  def name: String;
+  def name: String
 
   /** The index of the field in the tuple. */
-  def index: Int;
+  def index: Int
 
-  /** The expected type of the field. This information is used for automatic transformation of the field value into a usable type. */
-  def datatype: DataType;
+  /** The expected type of the field. This information is used for automatic
+   *  transformation of the field value into a usable type.
+   */
+  def datatype: DataType
 
   /** The name of the catalog in the database from which the field originates */
-  def catalog: String;
+  def catalog: String
 
   /** The name of the schema in the database from which the field originates */
-  def schema: String;
+  def schema: String
 
   /** The name of the table in the database from which the field originates */
-  def table: String;
+  def table: String
 
 }
diff --git a/src/library/scala/Function.scala b/src/library/scala/Function.scala
index 7e6e29b0f0..6f4c14ed55 100644
--- a/src/library/scala/Function.scala
+++ b/src/library/scala/Function.scala
@@ -1,56 +1,79 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+// $Id$
+
+
 package scala
 
 /** A module defining utility methods for higher-order functional programming.
+ *
+ *  @author  Martin Odersky
+ *  @version 1.0, 29/11/2006
  */
 object Function extends Application {
 
-  /** Given a sequence of functions f_1, ..., f_n, return the
-   *  function `f_1 andThen ... andThen f_n'.
-   *  @param fs    The given sequence of functions
+  /** Given a sequence of functions <code>f<sub>1</sub></code>, ...,
+   *  <code>f<sub>n</sub></code>, return the function <code>f<sub>1</sub>
+   *  andThen ... andThen f<sub>n</sub></code>.
+   *
+   *  @param fs The given sequence of functions
+   *  @return   ...
    */
   def chain[a](fs: Seq[a => a]): a => a = { x => (x /: fs) ((x, f) => f(x)) }
 
   /** Currying for functions of arity 2. This transforms a function
    *  of arity 2 into a a unary function returning another unary function.
+   *
+   *  @param f  ...
+   *  @return   ...
    */
-  def curried[a1, a2, b](f: (a1, a2) => b): a1 => a2 => b  =  {
+  def curried[a1, a2, b](f: (a1, a2) => b): a1 => a2 => b = {
     x1 => x2 => f(x1, x2)
   }
 
   /** Currying for functions of arity 3.
+   *
+   *  @param f  ...
+   *  @return   ...
    */
-  def curried[a1, a2, a3, b](f: (a1, a2, a3) => b): a1 => a2 => a3 => b  =  {
+  def curried[a1, a2, a3, b](f: (a1, a2, a3) => b): a1 => a2 => a3 => b = {
     x1 => x2 => x3 => f(x1, x2, x3)
   }
 
   /** Currying for functions of arity 4.
    */
-  def curried[a1, a2, a3, a4, b](f: (a1, a2, a3, a4) => b): a1 => a2 => a3 => a4 => b  =  {
+  def curried[a1, a2, a3, a4, b](f: (a1, a2, a3, a4) => b): a1 => a2 => a3 => a4 => b = {
     x1 => x2 => x3 => x4 => f(x1, x2, x3, x4)
   }
 
   /** Currying for functions of arity 5.
    */
-  def curried[a1, a2, a3, a4, a5, b](f: (a1, a2, a3, a4, a5) => b): a1 => a2 => a3 => a4 => a5 => b  =  {
+  def curried[a1, a2, a3, a4, a5, b](f: (a1, a2, a3, a4, a5) => b): a1 => a2 => a3 => a4 => a5 => b = {
     x1 => x2 => x3 => x4 => x5 => f(x1, x2, x3, x4, x5)
   }
 
   /** Uncurrying for functions of arity 2. This transforms a unary function
    *  returning another unary function into a function of arity 2.
    */
-  def uncurried[a1, a2, b](f: a1 => a2 => b): (a1, a2) => b  =  {
+  def uncurried[a1, a2, b](f: a1 => a2 => b): (a1, a2) => b = {
     (x1, x2) => f(x1)(x2)
   }
 
   /** Uncurrying for functions of arity 3.
    */
-  def uncurried[a1, a2, a3, b](f: a1 => a2 => a3 => b): (a1, a2, a3) => b  =  {
+  def uncurried[a1, a2, a3, b](f: a1 => a2 => a3 => b): (a1, a2, a3) => b = {
     (x1, x2, x3) => f(x1)(x2)(x3)
   }
 
   /** Uncurrying for functions of arity 4.
    */
-  def uncurried[a1, a2, a3, a4, b](f: a1 => a2 => a3 => a4 => b): (a1, a2, a3, a4) => b  =  {
+  def uncurried[a1, a2, a3, a4, b](f: a1 => a2 => a3 => a4 => b): (a1, a2, a3, a4) => b = {
     (x1, x2, x3, x4) => f(x1)(x2)(x3)(x4)
   }
 
@@ -62,57 +85,60 @@ object Function extends Application {
 
   /** Tupling for functions of arity 2. This transforms a function
    *  of arity 2 into a unary function that takes a pair of arguments.
+   *
+   *  @param f  ...
+   *  @return   ...
    */
-  def tupled[a1, a2, b](f: (a1, a2) => b): Tuple2[a1, a2] => b  =  {
+  def tupled[a1, a2, b](f: (a1, a2) => b): Tuple2[a1, a2] => b = {
     case Tuple2(x1, x2) => f(x1, x2)
   }
 
   /** Tupling for functions of arity 3. This transforms a function
    *  of arity 3 into a unary function that takes a triple of arguments.
    */
-  def tupled[a1, a2, a3, b](f: (a1, a2, a3) => b): Tuple3[a1, a2, a3] => b  =  {
+  def tupled[a1, a2, a3, b](f: (a1, a2, a3) => b): Tuple3[a1, a2, a3] => b = {
     case Tuple3(x1, x2, x3) => f(x1, x2, x3)
   }
 
   /** Tupling for functions of arity 4. This transforms a function
    *  of arity 4 into a unary function that takes a 4-tuple of arguments.
    */
-  def tupled[a1, a2, a3, a4, b](f: (a1, a2, a3, a4) => b): Tuple4[a1, a2, a3, a4] => b  =  {
+  def tupled[a1, a2, a3, a4, b](f: (a1, a2, a3, a4) => b): Tuple4[a1, a2, a3, a4] => b = {
     case Tuple4(x1, x2, x3, x4) => f(x1, x2, x3, x4)
   }
 
   /** Tupling for functions of arity 5. This transforms a function
    *  of arity 5 into a unary function that takes a 5-tuple of arguments.
    */
-  def tupled[a1, a2, a3, a4, a5, b](f: (a1, a2, a3, a4, a5) => b): Tuple5[a1, a2, a3, a4, a5] => b  =  {
+  def tupled[a1, a2, a3, a4, a5, b](f: (a1, a2, a3, a4, a5) => b): Tuple5[a1, a2, a3, a4, a5] => b = {
     case Tuple5(x1, x2, x3, x4, x5) => f(x1, x2, x3, x4, x5)
   }
 
   /** Un-tupling for functions of arity 2. This transforms a function taking
    *  a pair of arguments into a binary function which takes each argument separately.
    */
-  def untupled[a1, a2, b](f: Tuple2[a1, a2] => b): (a1, a2) => b  =  {
+  def untupled[a1, a2, b](f: Tuple2[a1, a2] => b): (a1, a2) => b = {
     (x1, x2) => f(Tuple2(x1, x2))
   }
 
   /** Un-tupling for functions of arity 3. This transforms a function taking
    *  a triple of arguments into a ternary function which takes each argument separately.
    */
-  def untupled[a1, a2, a3, b](f: Tuple3[a1, a2, a3] => b): (a1, a2, a3) => b  =  {
+  def untupled[a1, a2, a3, b](f: Tuple3[a1, a2, a3] => b): (a1, a2, a3) => b = {
     (x1, x2, x3) => f(Tuple3(x1, x2, x3))
   }
 
   /** Un-tupling for functions of arity 4. This transforms a function taking
    *  a 4-tuple of arguments into a function of arity 4 which takes each argument separately.
    */
-  def untupled[a1, a2, a3, a4, b](f: Tuple4[a1, a2, a3, a4] => b): (a1, a2, a3, a4) => b  =  {
+  def untupled[a1, a2, a3, a4, b](f: Tuple4[a1, a2, a3, a4] => b): (a1, a2, a3, a4) => b = {
     (x1, x2, x3, x4) => f(Tuple4(x1, x2, x3, x4))
   }
 
   /** Un-tupling for functions of arity 5. This transforms a function taking
    *  a 5-tuple of arguments into a function of arity 5 which takes each argument separately.
    */
-  def untupled[a1, a2, a3, a4, a5, b](f: Tuple5[a1, a2, a3, a4, a5] => b): (a1, a2, a3, a4, a5) => b  =  {
+  def untupled[a1, a2, a3, a4, a5, b](f: Tuple5[a1, a2, a3, a4, a5] => b): (a1, a2, a3, a4, a5) => b = {
     (x1, x2, x3, x4, x5) => f(Tuple5(x1, x2, x3, x4, x5))
   }
 }