I'm doing a project in cljs with reagent and I want to put a view in a folder called "views", if my core namespace is myapp.core what should the namespace of the views inside that folder be? myapp.views.someview ?

@seancorfield yes that is perfect. Sorry I did not word the question well. I want have Clojure get data, turn the data into a string that looks alot like a powershell script, then run the powershell script.

@wme.weeks OK, so the part you're stuck on is just running Powershell from Java/Clojure once you've produced the script?

@seancorfield Yes

Take a look at the clojure.java.shell/sh function: https://clojuredocs.org/clojure.java.shell/sh

I would expect you can run a command like "powershell" "scriptname" with that...?

Yes That is what I would like to do. thank you so much

(I don't use Powershell so I've no idea if that would work -- I only use WSL2 on Windows so everything is Linux for me)

Hey. Do any of you participate in any online Hangouts groups (or the like) meetups for Clojure/ClojureScript learning and practice? If so I'd like to participate 🙂

If there isn't one we oughta start one @rbowen

Hello, if looping through my data with a for is it possible to get the index of which item it is at the moment?

Is this a legitimate hack in CLJS that a record could have any method defined by defining them on Object without creating a protocol first?

(defrecord R1 []
  Object
  (f1 [this]
    (js/console.log "R1.f1")))

(.f1 (map->R1 {})) ;; prints "R1.f1"

I find this when reading shadow-cljs source code https://github.com/thheller/shadow-cljs/blob/1c1e35616b90d92b306f2909a6bf67a8c84243ee/src/main/shadow/cljs/devtools/client/shared.cljs#L307-L311

Can anyone help me with how I can refer to the original implementation of a function when I use with-redefs? I want to change the behaviour of a function, but only when the input matches a predicate. Otherwise I want to delegate to the original behaviour.

I've tried holding on to the original reference with (def orig-myfn (deref #'some-namespace/myfn)) and then calling (orig-myfn ...) from inside the definition I'm using to replace. But that didn't seem to work.

On the topic of with-redefs - what am I doing wrong here? I can’t seem to use redef with +/-

user=> (with-redefs [- +] (- 10 20))
-10
user=> (with-redefs [+ -] (+ 10 20))
30
user=> (with-redefs [map reduce] (map + (range 10)))
45 ;; okay

Certain functions in clojure core are handled specially

For performance

Thanks @ghadi - I looked at the source for +, -, map, reduce - is there something I can read more about to understand?

For example, I noticed use of reduc1 - does it come in the way?

There are some :inline annotations (which are not for public use) that replace calls to vars with calls to static methods on clojure.lang.RT

Like on some primitive math functions

Interesting - I’d have imagined they get bound to later in the execution - so, redef gets a chance to override. But, is this behaviour to be expected? I am still surprised and unclear.

OK, I think some of the issue I was seeing was that I was rebinding a multi-method. And foolishly only bindings one of the arities. That worked when I didn't have to refer to the original function, but doesn't work now. Not sure why. Anyway, using a variable arity function to override seem to do the trick. 🙂

Thanks @ghadi and @clojurians-slack100 for helping me out on that one.

I would categorically say that redeffing clojure.core is undefined behavior @jaju There are other things that confound redef (clojure.core is shipped direct linked), and redeffing clojure.core functions has the potential to break clojure itself

I am wrapping shell/sh in a function. Is there a way to pass in optional arguments. My issue is that shell/sh seems to only take strings outside of any data structure

if I understand you correctly, the solution is to use apply

(apply f [a b c]) and (apply f a [b c]) and (f a b c) all result in the same function call

Yeap I think you are right!

without the varargs you end up with a bunch of boilerplate collection building code

or silliness with partial

(I've dealt with this from coworkers who didn't realize apply was varargs)

On that same note, How should I define a function with defn if I have optional arguments? (defn optimise {a b & opts]) what should opts be ? a hashmap?

opts ends up being effectively a list

(ins)user=> (defn optimise [a b & opts] (println "opts is" opts))
#'user/optimise
(ins)user=> (optimise 1 2 3 4 5 6)
opts is (3 4 5 6)
nil

If have a list of named optional args is the & opts method a good one? or should just do (defn optimise [a b opts]) where i just put opts as {} if there are no optional args?

if you expect key/value pairs using a hash map instead of varargs is usually better

For context am wrapping a script with shell/sh and there are compulsory and optional arguments. And am thinking what is the best way to approach this

you can have a separate arg list for the case where no opts are provided

(defn foo
  ([x y] (foo x y {})
  ([x y opts] ....))

Right 😅 thanks I totally forgot about that

since this is #beginners - a useful idiom to know:

(merge {:a "default-a" :b "default-b"} opts)

the second arg overwrites any keys shared with the first arg

Also worth noting that as of Clojure 1.11 (in alpha right now), if you declare (defn foo [x y & {:as opts}] ...) then you can call this with either key/value arguments (foo 1 2 :bar 3 :quux 4) or a hash map (foo 1 2 {:bar 3 :quux 4}) (and even a mix of the two, with the hash map following any key/value arguments (foo 1 2 :bar 3 {:quux 4 :wibble 5})

(over time we will probably see more APIs declared this was, as opposed to [x y opts], once we have the flexibility to call them in "human style" -- key/value named arguments -- or in "program style" -- a hash map of arguments; you can already do this with the CLI with -X and the new -T options)

Anybody know how to format strings like printf in C? ... you know with the %d arguments... I only found the [goog.string :as gstring] which has a format function which lets me do exactly that... but is there something similar in clojure?

https://clojuredocs.org/clojure.core/format. or cl-format if you really want to go crazy. there’s several pages of docs for that one.

Or, yaknow, printf 😝 https://clojuredocs.org/clojure.core/printf

format and printf are both built on java's formatting, if you are using goog.string you don't have java stuff because you are writing clojurescript

Hello, what am I missing about this function?

(defn rapunzel [rpnzls]
 ([] (rapunzel "rapunzel"))
 ([rpnzls]
  (if (= rpnzls "rapunzel") 
   (println "let down your hair"))))

(defn rapunzel [rpnzls] ;; <<<------- what is this?
 ([] (rapunzel "rapunzel"))
 ([rpnzls]
  (if (= rpnzls "rapunzel") 
   (println "let down your hair"))))

Ohh haha

Thank you 😄!

For a research project I need to perform a long calculation (multiple hours) resulting in a large map (~ 50 million keys). My goal is to do the calculation only once on someone else's very powerful machine and somehow store the resulting value such that I can use the value on my own machine machine without having to wait those long hours ever again. The direction I went in is to make a second project where I assign the result of the long calculation to a var, AOT compile it and include the resulting jar as a dependency in my research project. To test this approach I did the following. In my to-be-compiled library project I have a src/lib/core.clj:

(ns lib.core)

(def x (do (println "calculating...")
           :foo))

Compiling lib.core...
calculating...

(ns research.core
  (:require [lib.core]))

When you AOT a namespace, it means that the compiler is going to write bytecode to disk. That bytecode contains the recipe for loading your namespace. It is not writing bytecode that represents the state of the namespace after the load.

What you want to do is compute your expensive thing, then serialize map to disk using something like EDN, JSON, or Transit.

or nippy, https://github.com/ptaoussanis/nippy