[Rd] as.missing

[Luke Tierney]

There are lot of subtle issues involved here. We should think through
carefuly exactly what semantics we want for missing value propagation
before making any changes.  Making usage easy at top level is
genearlly a good thing, but for usage within functions eliminating
error messages by making more automated choices may not be a good
thing--it may mask real mistakes.

There are also issues with the internal implementation if missing
arguments we ned to think carefuly about before exposing them at teh R
level.  The fact that internally there is a missing argument token
does not mean it is a good thing to expose that detail at the R level
(and it already is in call objects and creates some issues with
computing on the language.

Like I said, it's complicated, so let's not leap before we look
carefully.

Best,

luke

On Fri, 27 Oct 2006, Paul Gilbert wrote:

>

Peter Dalgaard wrote:

>Paul Gilbert <pgilbert at bank-banque-canada.ca> writes:
>
> 
>
>>Peter Dalgaard wrote:
>>
>> 
>>
>>>Paul Gilbert <pgilbert at bank-banque-canada.ca> writes:
>>>
>>>
>>> 
>>>
>>>>>I.e., when x is missing in g, and g calls f(3,x), f will use its
>>>>>default value for x.
>>>>>
>>>>> 
>>>>>
>>>>Yes, that is the behaviour I am looking for. That is, f  should do
>>>>what it normal would do if it were called with x missing.
>>>>
>>>> 
>>>>
>>>But if x has a default in g then that default should presumably be
>>>used?
>>> 
>>>
>>Yes.  The value of x in g would get passed to f, default or otherwise.
>>If that value is something that indicates x is missing, then it should
>>be treated as if it is missing in f. This means f should use its
>>default value, rather than throw an error saying x is missing.
>>
>> 
>>
>>>And what if x is given a value in the evaluation frame of g
>>>before it is used by f (which can happen, you know, even after the
>>>evaluation of f has begun)? Now imagine a longer chain of calls.
>>>
>>>I think what you're asking for is essentially dynamic scoping for
>>>missing arguments: you'd have to backtrack along the call chain to
>>>find the first instance where x is either given a value or has a
>>>default. This sounds messy.
>>>
>>> 
>>>
>>You understand this better than I do, but I don't think I am asking to
>>do this. Currently I think f  looks back too far and finds x is
>>missing and g does not have a default value for x, so it throws an
>>error.  Why can't f find its own default value for x?
>> 
>>
>
>Because it's being told to use the value of the argument instead. I
>think. 
>
>This stuff is treacherous. E.g. what would you expect from this?
>
>g <- function(x) {f <- function(y) {x <<- 1; y} ; f(x)}
>g()
>
> 
>
I'm confused.  Neither f nor g have a default here, so I don't think 
this is related to what I'm talking about. Currently, in your example, f 
find x with a value of 1, and I am not suggesting changing that. I'm 
only suggesting that if f finds x is missing, it should look at it's own 
default argument.
====================================================================================

La version française suit le texte anglais.

------------------------------------------------------------------------------------

This email may contain privileged and/or confidential inform...{{dropped}}

______________________________________________
R-devel at r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel

-- 
Luke Tierney
Chair, Statistics and Actuarial Science
Ralph E. Wareham Professor of Mathematical Sciences
University of Iowa                  Phone:             319-335-3386
Department of Statistics and        Fax:               319-335-3017
    Actuarial Science
241 Schaeffer Hall                  email:      luke at stat.uiowa.edu
Iowa City, IA 52242                 WWW:  http://www.stat.uiowa.edu