Hi everyone, I’m trying to do a very simple tutorial and I’m not sure why this is giving me a compile error. Sorry for the stupid question

(ns tutorial.core
  (:require [clojure.string :as str])
  (:gen-class))

(defn -main
  "I don't do a whole lot ... yet."
  [& args]
  (def str1 "This is a string")  
  (str/blank? str1)
)

This yields the error: Syntax error compiling at (core.clj:9:3). No such namespace: str

but this works:

(ns tutorial.core
  (:require [clojure.string :as str]) 
  (:gen-class))

(defn -main
  "I don't do a whole lot ... yet."
  [& args]
  (def str1 "This is my second string")  
  (clojure.string/blank? str1) 
  )

sorry for the stupid beginner question

an aside: def inside defn doesn't do what you probably think it does - it creates a new global at namespace scope

it doesn't create a binding that's local to that function

use a let instead (still as part of the aside)

for the error of str namespace not being found, there has to be something else going on, the code is correct aside from the def usage

so, thanks for that. Interestingly when I tried switching def to let, I got this: (let str1 "This is a string") => Syntax error macroexpanding clojure.core/let as core.clj:7:3).

(let [str1 "This is a string"] (str/blank? str1))

let has explicit scope based on its parens

is my clojure setup corrupted or something I wonder. I’m using VSCode and Calva on a mac

@greg024 I would assume more likely user error in the IDE, you can verify without any of the tooling by running clj path/to/file.clj in a terminal

ah sorry - that worked, but the other Unresolved namespace str. Are you missing a require? still persists

that sounds like some reset / error clearing is needed via your IDE UI

I assume there's a channel for Calva / vscode users here

#vscode

yep, this indeed does run fine (I’m using lein so I did lein run on the project):

(ns tutorial.core
  (:require [clojure.string :as str]) 
  (:gen-class))

(defn -main
  [& args]
  (println (str/blank? "str1"))
)

it must be something with my vscode setup. Thanks!

You likely are try to evaluate the definition of -main without having evaluated the ns declaration above

How do I load/require an in-memory namespace?

@lockdown- Not quite sure what you're asking. If a namespace has been required, it will be in memory. Do you mean "How do I reload a namespace from disk?"

I mean a ns with no file, like after (create-ns 'foo)

Hmm, never seen anyone call create-ns to be honest, but you can just refer to its content via its name...

...so if you have added any Vars to it, you can just say foo/some-var to refer to some-var in that foo namespace.

You can also use alias to add a local alias to an in-memory namespace.

Example:

user=> (in-ns 'foo)
#object[clojure.lang.Namespace 0x1bb9aa43 "foo"]
foo=> (clojure.core/refer 'clojure.core)
nil
foo=> (defn bar [n] (* n n ))
#'foo/bar
foo=> (in-ns 'user)
#object[clojure.lang.Namespace 0x2e52fb3e "user"]
user=> (foo/bar 4)
16
user=> (alias 'f 'foo)
nil
user=> (f/bar 5)
25
user=>

@lockdown- Does that help?

yes, very much thanks, you cleared my confusion

If you use intern you can add things to your namespace created with create-ns, but have names resolved using whatever the current space is

ah, was looking for that, the idea was to create the ns without switching to it, hence create-ns instead of in-ns

Ah, yeah, I forgot about interning into other nses...

user=> (create-ns 'foo)
#object[clojure.lang.Namespace 0x1bb9aa43 "foo"]
user=> (intern 'foo 'bar (fn [n] (* n n )))
#'foo/bar
user=> (foo/bar 4)
16
user=> (alias 'f 'foo)
nil
user=> (f/bar 5)
25
user=>

Hi everyone, Can anyone help me with this? Why do I keep getting :

Reflection warning, stellar/single_runner/components/state/ref/transition.clj:140:3 - call to method submit on java.util.concurrent.ExecutorService can't be resolved (argument types: unknown).

(defn resp-handler
  [state db om
   ^java.util.concurrent.ExecutorService pool
   ^java.util.concurrent.ExecutorService db-pool]
  (async/go-loop []
    (try
      (let [cid (otocol/<-client-id om)]
        (when-let [{r-cid :client-id :as resp}
                   (async/<! (otocol/<-resp-ch om))]
          (if (= r-cid cid)
            (.submit
             ^java.util.concurrent.ExecutorService pool
             ^Callable (fn []
                         (handle-resp-on-start
                          state db om resp db-pool)))
            (.submit
             ^java.util.concurrent.ExecutorService db-pool
             ^Callable (fn []
                         (opdb/->response db resp))))))
      (catch Exception e
        (throw
         (ex-info "resp-handler"
                  {:cause e
                   :params {:state state}}))))
    (recur)))

those Callable type hints probably aren't getting applied

but if you pull them up to let locals and then type-hint the local reference, that will work

(let [handle-resp (fn [] (handle-resp-on-start ...))]
   ...
   (.submit pool ^Callable handle-resp))

the hints on pool in the .submit call shouldn't be needed - the hint at the top is sufficient there

Thanks a lot @alexmiller Why weren't the ^Callable type hints getting applied before ? Did it had something to do with fn form or is there sth I don't know ?

function objects in general don't have metadata

so that metadata doesn't have anywhere to go

Thanks @alexmiller

Hello! Is there any way to deprecate a single defmethod of a defmulti?

supposing there was, what benefit would it have? suppose foo is a defmethod that is deprecated. here x may or may not trigger the method that is deprecated (foo x) do you want some indication in your editor that it is deprecated?

I agree this sound weird. Callers of a multimethod shouldn't care about which dispatch branch was hit

if you want feedback in the program, you could tick a metric or emit a log that said "vestigial branch hit, rework the calling code"

Yeah, I think this is the goal. I'm forwarding a question that was asked in my organization. It's a multi dispatcher that returns a token, and a single dispatcher will be removed

assert or throw

or you can literally remove it

with remove-method

Yeah, but I think the point of deprecation is to give visual hint and time to everybody rework their code without a hard break. But what I'm seeing is that there is no way to do that

But thanks!

(if @filtered [records ^{:key "t"} true] [records ^{:key "f"} false]) i can't make refresh the records element when filtered is changed

btw my first attemp was [records @filtered]

this works fine but obviously far from ideal

(if @filtered 
            [:<> {:key "t"} [records true]] 
            [:<> {:key "f"} [records false]] )

@m373h4n I'm unsure what you're trying to achieve here. could you post some expected/desired output from that statement? your first example seems to be trying to add metadata to a boolean which I don't think you can do. your second example is creating a 3 element vector with the first element being the keyword :<> and the second element being a map

(defn showme [tf]
  (r/with-let
    [rfsubs tf] ;<<<<--- This doesn't change
    (if rfsubs [:p "TRUE"] [:p "FALSE"])))

(defn testi []
  (r/with-let [filtered (r/atom false)]
    [:<> 
     [:button {:on-click #(reset! filtered (not @filtered))} "CHANGE"]
     [showme @filtered]]
    ))

I made simple sample of my problem

when you click button it should show text TRUE or FALSE but it doesn't

right yes this is a reagent question, I don't know reagent sorry.

can you try it without the with-let bindings? just (defn showme [filtered?] (if filtered? [:p "True"] [:p "False"]))

then it works. but I need with-let in the real function. this was just demonstration of my problem

https://reactnavigation.org/docs/en/state-persistence.html

const persistNavigationState = async (navState) => {
  try {
    await AsyncStorage.setItem(persistenceKey, JSON.stringify(navState))
  } catch(err) {
    // handle the error according to your needs
  }
}
const loadNavigationState = async () => {
  const jsonString = await AsyncStorage.getItem(persistenceKey)
  return JSON.parse(jsonString)
}

const App = () => <AppNavigator persistNavigationState={persistNavigationState} loadNavigationState={loadNavigationState} />;

When await-for times out, what happens to the actions it was waiting on? Do they get to live out their natural lives?

yes

await (and await-for) is basically just a ping/pong to an agent. drop an action on their queue of actions to let me know when it is run

not even basically actually, looking at the implementation that is exactly how it is implemented

Looking for ways to replace in the string

[sql column name]

#{"[" "]" " "}