Using macros to generate a name, from a value and bind another function to it, how to?

[llmII]

If one were to look over at jsys, one can see that the C code basically exports Janet function bindings under a system specific prefix. When one compiles it on their system, if their system is a *nix, it'll be sys/nix/$function but if they were on Windows (which in jsys is currently undefined at this time) it would be sys/windows/$function.

The idea is for there to be a sys.janet file that wraps the system specific functions and one big thing is when the sys.janet file loads it needs to check what OS it's under and then generate shortnames for the sys/$os/$function set.

The idea here was to have a macro we'll call def-with-sys and have it do something like the following:

(defmacro def-with-sys
 "bind _$name to sys/$os/$name"
  [name] ) # left undefined, I can pop a not working implementation later

(def names @[chdir fnctl fork chroot])
(each name names (def-with-sys name))
# result should be a _chdir bound to sys/nix/chdir on *nix or sys/windows/chdir on win32

The trouble I've ran into is how to get a macro to take a value, mutate it, then tell def to bind something to the value stored in a variable, where something should be a function.

One half working (but bad implementation) resulted in having to manually call the macro for each name:

(defn- with-sys-bound*
  [name]
  (let [os (match (os/which)
             :windows 'windows
             _        'nix)
        realname (if (= (type name) :tuple)
                   (last name)
                   name)]
    ~(def-
       ,(symbol "_" (string realname))
       ,(symbol "sys/" os "/" (string realname)))))

# TODO: figure out why this can't be used inside of an `each`
(defmacro- with-sys-bound
  "Assign a bound symbol to a locally bound symbol."
  [name]
  (with-sys-bound* ~,name))

(with-sys-bound chdir)
(with-sys-bound chown)
(with-sys-bound chroot)
(with-sys-bound dup2)
(with-sys-bound fork)
(with-sys-bound setegid)
(with-sys-bound seteuid)
(with-sys-bound setgid)
(with-sys-bound setuid)
(with-sys-bound setsid)
(with-sys-bound fcntl)
(with-sys-bound getpwnam)
(with-sys-bound getgrnam)

When I basically copied out the relevant into an REPL and played around with trying to get it to do something, I realized when doing each it was trying to bind "sys/os/binding" instead of "sys/os/$binding". I've sense attempted far more ways and none have ended up working with each but all were based around the assumption I'd be passing the macro quoted symbols, which I'm figuring out I probably shouldn't do (thanks @pepe). I'll update this as I go along but if anyone has any great ideas I'd definitely welcome the help!

Another one, that doesn't work with each, and doesn't accept quoted symbols:

(defmacro dws
  [name]
  (macex
  (let [os (match (os/which)
             :windows 'windows
             _        'nix)]
    ~(def ,(symbol "_" ~,name) ,(symbol "sys/" ~,os "/" ~,name)))))

[bakpakin]

Because it's a macro - it's behaving exactly as macros do. If you put a macro in a loop, it does not evaluate the macro Everytime though the loop, it evaluates once during compilation.

[bakpakin]

Starting from your first example, the easiest solution is to not make def-with-sys a macro, and instead programmatically add bindings to the environment. Functions like defglobal will do what you want.

[llmII]

Thanks, this actually is pretty great, but it does create exported symbols which originally I had planned against for this but works out. I planned to have a chdir and change-directory bound to the same function that would wrap the functionality and present a better interface (maybe not for chdir but for others). I'll just provide raw os-level calls and let the other names resolve to either the underlying OS call or changed up to provide a nicer interface.

[bakpakin]

Ok, guessing what you are trying to do, you can look at spork/path for a similar example.

https://github.com/janet-lang/spork/blob/master/spork/path.janet

[llmII]

This had basically exactly what I wanted!

[pepe]

I wanted to suggest path at the original issue, but your moods misled me :-D. Next time I will think more

[llmII]

Sorry bout that, I actually did end up making a macro for one use case based around it, and a few things based on it, the end result was:

# Definition from:
#   https://github.com/janet-lang/spork/blob/master/spork/path.janet
(defn- redef
  "Redef a value, keeping all metadata."
  [from to]
  (setdyn (symbol to) (dyn (symbol from))))

(defn- redef-
  "Redef a value, then set it private in it's metadata."
  [from to]
  (redef from to)
  (set ((dyn (symbol from)) :private) true))

(defn- redef+
  "Redef a value, then set it private in it's metadata."
  [from to]
  (redef from to)
  (set ((dyn (symbol from)) :private) false))

(defmacro- redef-symbol
  [from to]
  ~(redef+ ,(string from) ,to))

(defn- redef-multi*
  [from to]
  (match (length to)
    0   (redef+ from to)
    _   (each n to (redef+ (string from) n))))

(defmacro- redef-multi
  [from & to]
     (var i 0)
     (let [len        (length to)
           collecting @[]]
       (while (< i len)
         (array/push collecting (get to i))
         (++ i))
       ~(redef-multi* ,(string from) ',collecting)))

With my use being something like:

(redef-multi _chdir chdir change-directory)

Which will all end up in jsys, just have to do the documentation work for all the stuff in C first.

[pepe]

No worries, I went back to reread, and it made sense. I am looking forward to jsys!