Hello,

(Yet another 'newbie'-question for anyone who has the patience)

Different sources (such as the documentation) says curried functions
are to prefer rather than functions using tuples, if speed is of any
concern anyway.

Before realizing this and as I'm used to the SML dialect, I
implemented a module for three-dimensional vectors using 'tupled'
functions first. Upon a question regarding speed I also got the
recommendation to use records instead of a variant with a single
constructor.

After making all the functions curried instead, and changing the
implementation to use records instead I measured the performance of
the two implementation and realized to my surprise that the old
version (the implementation using variants and tupled functions) was
faster (than the one using records and curried functions). So my
questions are:

1) Is this really correct? I tried the implementations on two different
   architectures and got the same result. One can ask if the test program
   wasn't 'good enough'.

2) Is it only a "religious" question to use single-valued variants
   instead of records (when defining a datatype) or has speed something
   to do with it? If the former case applies, which one should I use
   and why? Any other aspects?

3) BTW, what is the "best" way of writing pattern-matching functions,
   ie   [let f x = match ....] or [let f = function x -> ...]?
   (Maybe we're getting 'religious' here as well?)

I guess my code is not of interest so I'll exclude it but if someone
thinks it's relevant I can provide it.

Thanks in advance for any response to my somewhat basic questions...

best regards

Jens

--
--[ Jens Olsson ]-----------------------------------------------------
  [Address]            [Phone]                 [WWW]
  Djäknegatan 13, 1tr  Home: 018 -  24 88 77   jenso@csd.uu.se     
  754 23 Uppsala       Work: 018 - 471 76 85   www.csd.uu.se/~jenso
  SWEDEN               Cell: CEASED!!!         ICQ UID 8955231
---------------------------------[ CS student @ Uppsala University ]--