Contract Syntactic Sugar
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?
regards,
/iaw
----
Ivo Welch (ivo.welch at gmail.com)
http://www.ivo-welch.info/
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