[Rd] Contract Syntactic Sugar

ivo welch ivo.welch at gmail.com
Tue Feb 5 00:22:37 CET 2013

hi brian---interesting and very impressive.  is it possible to move
everything into one definition and/or to chain multiple conditions?

exponentiate(x, exponent) %::% data.frame : c(numeric,allpositive) :
integer  %as% {
  x %has% base  ## my invention, since this is not checked, and R is
not strict enough
  x$base %::% allpositive
  x$base ^ exponent

multiple creations as in your doc examples on the same function are a
recipe for errors for me.  it's also why I am not too fond of
TypeInfo.  chaining conditions in my c() is not important, as long as
I can define my own types (which can check multiple aspects at the
same time).  suggestion: in your doc example, can you define a
different type than an integer?  it's a little confusing.  how about
defining a strictly positive integer?


Ivo Welch (ivo.welch at gmail.com)
J. Fred Weston Professor of Finance
Anderson School at UCLA, C519
Director, UCLA Anderson Fink Center for Finance and Investments
Free Finance Textbook, http://book.ivo-welch.info/
Editor, Critical Finance Review, http://www.critical-finance-review.org/

On Mon, Feb 4, 2013 at 2:10 PM, Brian Lee Yung Rowe <rowe at muxspace.com> wrote:
> Ivo,
> You might be interested in my lambda.r package which provides syntax (using the %::% operator) for type constraints. Given a function with n arguments, the type constraint requires n + 1 types, as the last type listed is the return type. Lambda.r also provides syntax for specifying any arbitrary condition on the input arguments via the %when% operator. For your example below you could do the following:
> exponentiate(x, exponent) %::% data.frame : numeric : numeric
> exponentiate(x, exponent) %when% {
>   is.positive(x)
> } %as% {
>   x$base ^ exponent
> }
> You can see more examples in the package (available on CRAN) or in the source (https://github.com/muxspace/lambda.r).
> HTH,
> Brian
> On Feb 4, 2013, at 4:53 PM, ivo welch <ivo.welch at anderson.ucla.edu> wrote:
>> ## the following is a dream: add some sugar syntax to allow for
>> contracts with teeth (in and out checking)
>>> is.positive <- function(x) (all(x>0))
>>> exponentiate <- function( x ::is.data.frame , exponent ::is.numeric is.positive)  :: is.vector is.numeric  {
>>    x$base :: is.positive        ## error also if base does not exist
>> in x; may need some special IQ
>>    x$base^exponent
>> }
>> should be self-explanatory.  anything that has '::' means "run what is
>> before through all the functions after and barf if it is not true".
>> any other operator rather than :: or other syntax would be as
>> good---this is just illustratory.  in the end, this code should be
>> viewed by R as the same as
>>> exponentiate <- function( x, exponent ) {
>>    stopifnot( is.data.frame(x) )
>>    stopifnot( is.numeric(exponent) )
>>    stopifnot( is.positive(exponent) )
>>    stopifnot( exists("base", "x") )
>>    stopifnot( is.positive( x$base ) )
>>    return.value <- x$base^exponent
>>    stopifnot( is.vector(return.value) )
>>    stopifnot( is.numeric(return.value) )
>>    return.value
>> }
>> is this a feasible summer project for a student with a prospect of
>> inclusion of the completed code in the R core language itself if I pay
>> for the development time?  {or does better syntax already exist and I
>> am just ignorant (which I often am)?}
>> regards,
>> /iaw
>> ----
>> Ivo Welch (ivo.welch at gmail.com)
>> ______________________________________________
>> R-devel at r-project.org mailing list
>> https://stat.ethz.ch/mailman/listinfo/r-devel

More information about the R-devel mailing list