From hugh@p@r@on@ge @ending from gm@il@com  Sat Sep  1 09:42:52 2018
From: hugh@p@r@on@ge @ending from gm@il@com (Hugh Parsonage)
Date: Sat, 1 Sep 2018 17:42:52 +1000
Subject: [Rd] ROBUSTNESS: x || y and x && y to give warning/error if
 length(x) != 1 or length(y) != 1
In-Reply-To: <0C3093D1-5FE0-4DCC-AFC0-CEA6FCBA4580@dans.knaw.nl>
References: <CAFDcVCSEqHvfhD358GD3Fgz6FjuOiMiYHswz+pyTnAEoV0CyZw@mail.gmail.com>
 <0C3093D1-5FE0-4DCC-AFC0-CEA6FCBA4580@dans.knaw.nl>
Message-ID: <CAJmOi+PAxdRgTevFHC8Fna-hbtgQLOMrEU+bGzwG5U_fwoB5Eg@mail.gmail.com>

I would add my support for the change.

>From a cursory survey of existing code, I'd say that usage like `class(x)
== 'y'` -- rather than inherits(x, 'y') or is.y -- is probably going to be
the major source of new warnings. So perhaps in the NEWS item it could be
noted as a clue for developers encountering nascent warnings.

Of course `if (class(x) == 'y')` already throws a warning, just not `if
(class(x) == 'y' && TRUE)`.



On Thu, 30 Aug 2018 at 21:09 Emil Bode <emil.bode at dans.knaw.nl> wrote:

> I have to disagree, I think one of the advantages of '||' (or &&) is the
> lazy evaluation, i.e. you can use the first condition to "not care" about
> the second (and stop errors from being thrown).
> So if I want to check if x is a length-one numeric with value a value
> between 0 and 1, I can do 'class(x)=='numeric' && length(x)==1 && x>0 &&
> x<1'.
> In your proposal, having x=c(1,2) would throw an error or multiple
> warnings.
> Also code that relies on the second argument not being evaluated would
> break, as we need to evaluate y in order to know length(y)
> There may be some benefit in checking for length(x) only, though that
> could also cause some false positives (e.g. 'x==-1 || length(x)==0' would
> be a bit ugly, but not necessarily wrong, same for someone too lazy to
> write x[1] instead of x).
>
> And I don?t really see the advantage. The casting to length one is (I
> think), a feature, not a bug. If I have/need a length one x, and a length
> one y, why not use '|' and '&'? I have to admit I only use them in
> if-statements, and if I need an error to be thrown when x and y are not
> length one, I can use the shorter versions and then the if throws a warning
> (or an error for a length-0 or NA result).
>
> I get it that for someone just starting in R, the differences between |
> and || can be confusing, but I guess that's just the price to pay for
> having a vectorized language.
>
> Best regards,
> Emil Bode
>
> Data-analyst
>
> +31 6 43 83 89 33
> emil.bode at dans.knaw.nl
>
> DANS: Netherlands Institute for Permanent Access to Digital Research
> Resources
> Anna van Saksenlaan 51 | 2593 HW Den Haag
> <https://maps.google.com/?q=Anna+van+Saksenlaan+51+%7C+2593+HW+Den+Haag&entry=gmail&source=g>
> | +31 70 349 44 50 | info at dans.knaw.nl <mailto:info at dans.kn> |
> dans.knaw.nl <applewebdata://71F677F0-6872-45F3-A6C4-4972BF87185B/
> www.dans.knaw.nl>
> DANS is an institute of the Dutch Academy KNAW <http://knaw.nl/nl> and
> funding organisation NWO <http://www.nwo.nl/>.
>
> ?On 29/08/2018, 05:03, "R-devel on behalf of Henrik Bengtsson" <
> r-devel-bounces at r-project.org on behalf of henrik.bengtsson at gmail.com>
> wrote:
>
>     # Issue
>
>     'x || y' performs 'x[1] || y' for length(x) > 1.  For instance (here
>     using R 3.5.1),
>
>     > c(TRUE, TRUE) || FALSE
>     [1] TRUE
>     > c(TRUE, FALSE) || FALSE
>     [1] TRUE
>     > c(TRUE, NA) || FALSE
>     [1] TRUE
>     > c(FALSE, TRUE) || FALSE
>     [1] FALSE
>
>     This property is symmetric in LHS and RHS (i.e. 'y || x' behaves the
>     same) and it also applies to 'x && y'.
>
>     Note also how the above truncation of 'x' is completely silent -
>     there's neither an error nor a warning being produced.
>
>
>     # Discussion/Suggestion
>
>     Using 'x || y' and 'x && y' with a non-scalar 'x' or 'y' is likely a
>     mistake.  Either the code is written assuming 'x' and 'y' are scalars,
>     or there is a coding error and vectorized versions 'x | y' and 'x & y'
>     were intended.  Should 'x || y' always be considered an mistake if
>     'length(x) != 1' or 'length(y) != 1'?  If so, should it be a warning
>     or an error?  For instance,
>     '''r
>     > x <- c(TRUE, TRUE)
>     > y <- FALSE
>     > x || y
>
>     Error in x || y : applying scalar operator || to non-scalar elements
>     Execution halted
>
>     What about the case where 'length(x) == 0' or 'length(y) == 0'?  Today
>     'x || y' returns 'NA' in such cases, e.g.
>
>     > logical(0) || c(FALSE, NA)
>     [1] NA
>     > logical(0) || logical(0)
>     [1] NA
>     > logical(0) && logical(0)
>     [1] NA
>
>     I don't know the background for this behavior, but I'm sure there is
>     an argument behind that one.  Maybe it's simply that '||' and '&&'
>     should always return a scalar logical and neither TRUE nor FALSE can
>     be returned.
>
>     /Henrik
>
>     PS. This is in the same vein as
>     https://mailman.stat.ethz.ch/pipermail/r-devel/2017-March/073817.html
>     - in R (>=3.4.0) we now get that if (1:2 == 1) ... is an error if
>     _R_CHECK_LENGTH_1_CONDITION_=true
>
>     ______________________________________________
>     R-devel at r-project.org mailing list
>     https://stat.ethz.ch/mailman/listinfo/r-devel
>
>
> ______________________________________________
> R-devel at r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel
>

	[[alternative HTML version deleted]]



[Rd] ROBUSTNESS: x || y and x && y to give warning/error if length(x) != 1 or length(y) != 1
Hugh Parsonage