setting options only inside functions

-----Original Message-----
From: r-help-bounces at r-project.org
[mailto:r-help-bounces at r-project.org] On Behalf Of
luke-tierney at uiowa.edu
Sent: Friday, April 29, 2011 9:35 AM
To: Jonathan Daily
Cc: r-help at r-project.org; Hadley Wickham; Barry Rowlingson
Subject: Re: [R] setting options only inside functions

The Python solution does not extend, at least not cleanly, to things
like dev on/ dev off or to Hadley's locale example.  In any case if I
am reading the Python source correctly on how they handle user
interrupts this solution has the same non-robusness to user interrupts
issue that Bill's initial solution had.

As a basis I believe what we need is a mechanism that handles a
setup, an action, and a cleanup, with setup and cleanup occurring with
interrupts disablednand the action with interrupts enabled. Scheme's
dynamic wind is similar, though I don't believe the scheme standard
addresses interrupts and we don't need to worry about continuations,
but some of the issues are similar.  Probably we would want two
flavors, one in which the action has to be a function that takes as a
single argument the result produced by the setup code, and one in
which the action can be an argument expression that is then evaluated
at the appropriate place by laze evaluation.

This can be done at the R level except for the controlling of
interrupts (and possibly other asynchronous stuff)-- that would need a
new pair of primitives (suspendInterrupts/enableInterupts or something
like that).  There is something in the Haskell literature on this that
I have looked at a while back -- probably time to have another look.

Luke,

 A similar problem is that if optionsList contains an illegal
option then setting options(optionList) will commit changes
to .Options as it works it way down the optionList until it
hits the illegal option, when it throws an error.  Then the
following on.exit is never called (it wouldn't have the output
of options(optionList) to work on if it were called) and the
initial settings in optionList stick around forever.  E.g.,

 > withOptions <- function(optionList, expr) {

 +     oldOpt <- options(optionList)
 +     on.exit(options(oldOpt))
 +     expr
 + }

 > getOption("height")

 NULL

 > getOption("width")

 [1] 80

 > withOptions(list(height=10, width=-2), 666)

 Error in options(optionList) :
   invalid 'width' parameter, allowed 10...10000

 > getOption("height")

 [1] 10

 > getOption("width")

 [1] 80

I haven't checked to see if par() works in the same way - it
does in S+.

An ignoreInterrupts(expr) function would not help in that case.

Making options() (and par()) atomic operations would help, but that
may be a lot of work.

 options() might also warn but no change
.Options if there were an attempt to set an illegal option.

Bill Dunlap
Spotfire, TIBCO Software
wdunlap tibco.com

On Thu, 28 Apr 2011, Jonathan Daily wrote:

I would also love to see this implemented in R, as my

current solution

to the issue of doing tons of open/close, dev/dev.off, etc.

is to use

snippets in my IDE, and in the end I feel like it is a hack job. A
pythonic "with" function would also solve most of the

situations where

I have had to use awkward try or tryCatch calls. I would be

willing to

help with this project, even if it is just testing.

On Wed, Apr 27, 2011 at 5:43 PM, Barry Rowlingson
<b.rowlingson at lancaster.ac.uk> wrote:

but it's a little clumsy, because

with_connection(file("myfile.txt"), {do stuff...})

isn't very useful because you have no way to reference

the connection

that you're using. Ruby's blocks have arguments which

would require

big changes to R's syntax. ?One option would to use pronouns:

?Looking very much like python 'with' statements:

http://effbot.org/zone/python-with-statement.htm

?Implemented via the 'with' statement which can operate on anything
that has a __enter__ and an __exit__ method. Very neat.

Barry