require-r not working inside a function

[awb99]

(defn init-r []
  (println "configuring clojisr ..") 
  (require-r '[base :as base :refer [$ <- $<-]]
                  '[utils :as u]
                  '[stats :as stats]
                  '[graphics :as g]
                  '[datasets :refer :all])
    (base/options :width 120 :digits 7)
    (base/set-seed 11228899)
    (pdf-off))

(init-r)

When I have all the forms of this function direct in the namespace, then all works fine.
But if I wrap the initialization in a function to be more modular, then the r libraries
in require-r can no longer be found.

I am not sure if clj require works the same way or not.

[genmeblog]

require-r is regular function and should work, what error do you get?

[awb99]

It is working. But then later below I get errors that the namespaces are not defined.
The example is in: https://github.com/pink-gorilla/goldly/blob/master/profiles/demo/src/systems/r_telephone.clj

When I had it in a wrapper function, it would not work.

[genmeblog]

Maybe something with intern function which is used to create namespaces and functions?

[awb99]

I have no idea... Sorry. I just know that the code only works when is not in a function.
Also I think that I had to defined R variables via let. When I was using (defs macro) as
a standalone basis, then my functions were also not seeing the R variables.. But it might
be that this was an error in the defs macro. I dont know yet.

(defmacro defs
    [& bindings]
    {:pre [(even? (count bindings))]}
    `(do
       ~@(for [[sym init] (partition 2 bindings)]
           `(def ~sym ~init))))

[genmeblog]

I will test it soon. require-r should work from a function. defs macro should also work. Can you give me example of defs usage?

[genmeblog]

Ok, the main issue with you function is that base package is not available during function compilation. It's created in require-r. So function this function cannot work and can't even compile.

Below works on my setup

(defn init-r []
  (println "configuring clojisr ..") 
  (require-r '[base :as base :refer [$ <- $<-]]
             '[utils :as u]
             '[stats :as stats]
             '[graphics :as g]
             '[datasets :refer :all]))

(init-r)

(base/options :width 120 :digits 7)
;; => $width
;;    [1] 120
;;    $digits
;;    [1] 7

(base/set-seed 11228899)
;; => NULL

[awb99]

I have an idea:
Example:

(ns (:require [r.base]))
(base/options {})

What will happen here is that clojure analyzer will load the namespace and get the fuctions in it.
So there are two ways really:

1. Similar to Shadow-cljs that creates clojurescript Namespaces from package.json you add a r-clojsir.edn file that defines the r-dependencies of the project. You then could make a r-module-generator that will create a file for each library that contains all information that is available in a namespace. You then can use this generated data to create the namespace.

2. You skip Document how to install latest Rserve #1 and hook into the function resolver; and at compile time you resolve everything. So
   Say (r.base/options {}) resolves but also (r.base/typo-not-existing {}) would resolve. At execution time you then link it to the session.. and if you cannot establish a binding at that time, then you throw an exception.

[awb99]

I am sorry for being a dick here. But how you have the syntax now makes it very difficult to write helper functions / libraries that use R functions.

[genmeblog]

Ok, I leave it open. Yes, it's hard to write external helper functions since symbols are not available before requiring them in the live session.

Maybe something like cljsjs can be helpful here? But someone needs to maintain it. Also I'm not sure about different backends and differences between packages (renjin vs R)

[awb99]

I tested around a little bit. So require is tighty coupled with jars. No way to use require
without generating a jar first. I think in the long run, this is the best option. You generate
a jar file, and in the jar file you create functions/variables corresponding to the module
you have in R.

For the short term, I think this might work:
https://github.com/pink-junkjard/integrator/blob/master/src/demo/app.clj
https://github.com/pink-junkjard/integrator/blob/master/src/integrator/core.clj

So you essentially do not use requires at all, and define the ns completely dynamic. So
you would adapt integrator.core to read some edn fie that you generate when you discover an r module.

And then you can write a require-r macro that just redefines the functions you want to have
extracted. You might also use potemkin for this: https://github.com/ztellman/potemkin/blob/master/src/potemkin/namespaces.clj

Then all you need is one dynamic variable that is linked to the session, and then
essentially this variable is used in the generated functions.

[awb99]

lein run

starting..
initializating R..
calculating sin of  3.14
done!

[awb99]

starting..
initializating R..
calculating sin of 3.14
done!

[awb99]

defs usage.

(defs a 1
      b 2)

this is identical to

(def a 1)
(def b 2)