How to use library functions in eval-ed code in Clojure (and Clojure SCI)

Question

I've got a Clojure file which I'm importing other library functions into with :require and :refer in the ns declaration.

I now want to eval some code in that namespace and have it call those libraries.

But when I call it, I get an "Unable to resolve symbol" for the referred function I'm trying to use.

I'm guessing I have to pass it explicitly in to the eval somehow but can't find any examples.

Second question. I'd ideally like to not use Clojure's ordinary eval at all but to run Babashka SCI. Is there a way to pass libraries from my Clojure environment into this?

Update. Code example.

(ns clj-ts.card-server
  [:require
  ...
  [patterning.layouts :refer [framed clock-rotate etc]]
  ...
  )

...


(defn one-pattern
  "Evaluate one pattern"
  [data]
  (let [pattern
        (try
          (eval (read-string data))
          (catch Exception e
            (let [sw (new java.io.StringWriter)
                  pw (new java.io.PrintWriter sw) ]
              (.printStackTrace e pw)
              (str "Exception :: " (.getMessage e) (-> sw .toString) ))) )
        ]
...
  )

Then when calling one-pattern with the following as the data argument

(let [a-round
        (fn [n lc fc]
          (clock-rotate
           n (std/poly
              0 0.5 0.4 n
              {:stroke lc
               :fill fc
               :stroke-weight 3})))
        
        ]
    (a-round 8 (p-color 140 220 180)  (p-color 190 255 200 100) )
    )

I get an error

Caused by: java.lang.RuntimeException: Unable to resolve symbol: clock-rotate in this context

Answer 1

I am able to eval a form that has a refer'ed function. As the following code demonstrates.

user> (join " " ["foo" "bar"])
Syntax error compiling at (*cider-repl Projects/example:localhost:59334(clj)*:43:7).
Unable to resolve symbol: join in this context
user> (require '[clojure.string :refer [join]])
nil
user> (join " " ["foo" "bar"])
"foo bar"
user> (eval (read-string "(join \" \" [\"foo\" \"bar\"])"))
"foo bar"
user> 

EDIT:

eval performs the evaluation in the context of the "current" namespace that is bound to *ns*. There are three ways I can think of to address your question - with examples below. I've tried to match what I think your code structure is.

Here are the contents of the file foo.clj that defines the eval function evalit and refers a library function (in this case join from clojure.string).

(ns myorg.example.foo
  (:require [clojure.string :refer [join]]))

(defn evalit [s]
  (eval (read-string s)))

We first load this myorg.example.foo namespace:

user> (require 'myorg.example.foo)
nil

First alternative: use the fully qualified symbol for the join as follows:

user> (myorg.example.foo/evalit "(clojure.string/join \" \" [\"boo\" \"baz\"])")
"boo baz"

Second alternative: Temporarily bind *ns* to the namespace that contains the refer'ed join. Note that in this case we can just use "join" rather than the fully qualified "clojure.string/join". But we still have to use the fully qualified symbol for evalit, since we are referencing it from a different namespace.

user> (binding [*ns* (find-ns 'myorg.example.foo)]
        (myorg.example.foo/evalit "(join \" \" [\"boo\" \"baz\"])"))
"boo baz"

Third alternative: Switch to the namespace with the refer'ed function.

user> (in-ns 'myorg.example.foo)
#namespace[myorg.example.foo]
myorg.example.foo> (evalit "(join \" \" [\"boo\" \"baz\"])")
"boo baz"

Here we can use the unqualified symbols since we are in the namespace with the definition and refer.

Answer 2

OK.

I ended up doing this with https://github.com/babashka/babashka SCI

In my file I basically took all the functions I had imported and put them into a new map like this

(def patterning-ns
  {'clojure.core
   {
    'clock-rotate clock-rotate
    'poly poly
    ...
   }
  }
)

Once the function names that got imported from elsewhere are in the map called patterning-ns (under the namespace name of clojure.core) then they are visible by default to any code eval-ed with

(sci/eval-string data {:namespaces patterning-ns })

Eg in

(defn one-pattern
  "Evaluate one pattern"
  [data]
  (try
    (let [
          pattern
          (sci/eval-string
           data
           {:namespaces patterning-ns })
          svg (make-svg 400 400 pattern)
          ]
       svg
       )
      )
    (catch java.lang.Exception e
      (let [sw (new java.io.StringWriter)
            pw (new java.io.PrintWriter sw) ]
        (.printStackTrace e pw)
        (println e)
        (str "Exception :: " (.getMessage e) (-> sw .toString) )) )))