A quasiquoter to help with calling R from ghc.

If the quasiquote assigns to variables hs_x and hs_y, the result type will be IO (Record '[LVPair "x" x, LVPair "y" y]). The types x and y have to be determined on the haskell side. Here is a complete example:

>>> :set -XQuasiQuotes -XDataKinds -XNoMonomorphismRestriction
>>> let x = [2 :: Double]
>>> let q = [r| hs_y <- 1 + hs_x; hs_z <- 2 |]

These labels could be generated by template haskell with $(makeLabels6 (words "y z"))

>>> let y = Label :: Label "y"
>>> let z = Label :: Label "z"

>>> do o <- q; print (o .!. y ++ o .!. z :: [Double])
[3.0,2.0]

Variables like ch_x ch_longVariableName inside the quasiquote generate references to x and longVariableName. These variables should have type Chan (a, b -> IO '()'). newChan can produce values of that type, but some versions with restricted types are provided:

do
 x <- newRChan
 longVariableName <- newRChan' (undefined :: Double)

The whole input to R is re-sent each time whenever a whole set of ch_ variables is available. examples/test4.hs has an a working example shows that keeping the same R-session open is much faster, but that results may be confusing since nothing explicitly says (besides this documentation here) that the same code is re-sent.

debugging

Write file that can be run to loading a quote into R interpreter (ie the same thing as readProcess R "--no-save" ...). For now it's pretty simple to just cd Rtmp and load/source things. also, return R's stdout stderr exitcode in the HList. This won't be practical for the Chan option since the stdout is getting consumed?

antiquote

doesn't do escapes, so a string '$( blah )' might end badly

more examples

conversion both ways etc.

read NULL as Maybe?

more datatypes

support things like ??, ...

call R functions as if they were defined in haskell

This can be achieved already by doing something like

x <- newRChan
[r| hs_f <- ch_x + 1 |]
let f :: Double -> IO Double
    f xVal = (.!. (Label :: Label "f")) `fmap` sendRcv x xVal

But perhaps something can be done to generate the above code from something much shorter like:

[r| hs_f <- function(x) x + 1 |]

Can this be made to work without looking at whether there is a function() after the <-?

call hs functions as if they were defined in R

Likewise, we might like values like f x = x + 1 to be callable from R (for example by defining a foreign export ccall f :: Int32 -> Int32), and dyn.load(something); .C(f, x=1L). Alternatively the R interpreter might have a way to communicate some other way.

use libR.so

there is a hR package which might allow usage similar to hslua (ie. calling individual R functions)

one drawback is that it uses lists for vectors...

@static analysis@ call something like codetools on the generated R code to infer result/argument types. Or perhaps translate R code into some constraints:

class RApp (x :: [*]) r

instance (UpcastNumR a b ~ r, UpcastNumR b a ~ r) => RApp [Proxy "+", a, b] r

type family UpcastNumR a b
type instance UpcastNumR Double Int = Double
type instance UpcastNumR Int Int = Int

the benefit here is that users could add their own RApp instances. On the other hand, perhaps using a separate constraint solver will be less confusing in terms of type errors (ie. failure to infer a type from R which will happen (features like do.call) should not complicate the types seen on the haskell side).

or run the code first with some dummy inputs (say vectors of length 10 or so), and assume those types will continue to be the same.

http://cran.r-project.org/web/packages/lambda.r/index.html