probably not. what are you trying to do?

since channels can be supplied transducers, it seems unlikely that there would be a use case where you would use a channel within a transducer

i'm trying to write a transducer does a partition-all but with a timeout. For example if I have (def foo (chan n (partition-all-with-timeout 3)) and I push from 1 to 10 into the channel, I'd like to get 10 out from the channel after x ms.

there’s a way to tell a transducer to “complete” which* will cause a transducer like partition-all to flush its remaining contents

I would still have the timeout on the “outside” of the transducer and once the timeout triggers, get the transducer to complete and flush any remaining contents

Oh cool! I'll dabble with that. Thanks alot! I'm new to transducers 😅

(def foo (chan 5 (partition-all 3)))

(doseq [i (range 10)]
  (async/put! foo i))

(async/poll! foo)
;; [0 1 2]
(async/poll! foo)
;; [3 4 5]
(async/poll! foo)
;; [6 7 8]
(async/poll! foo)
;; nil

(async/close! foo)

(async/poll! foo)
;; [9]

this definitely isn’t the best example, but hopefully it helps

in this example, closing the channel will case the transducer to “complete”

so if closing the channel is appropriate, then you just do: (go (<! (timeout 5000)) (close! foo)) to close the channel after 5 seconds

also, async/poll! is usually not what you want to use. I’m just using it for this example so I don’t accidentally block my repl 😬

hehe cool! Thanks alot :thumbsup:

For any class that could be loaded, where you believe you have already installed a JAR defining that class somehow before? Or one that you may never have copied to your computer before?

If the latter, then Google searches for things like "java someClassX" can often give information about the class, methods in its API, etc.

including a full hierarchical package name like java.lang.foo.bar.ClassX

If you have an example class "X" that you are having difficulty with, you can mention it here and someone may be able to demonstrate the process.

Assume I have the jar in my deps.edn or project.clj and it's been setup

I want a Java equivalent to (apropos "cat")

Of course I can google, but that just adds friction to exploring a new java library

JAR files are typically copied into your $HOME/.m2 directory the first time you run a program like clj or lein that has the project as a dependency.

Java classes don't have the built-in documentation that Clojure namespaces and functions do.

Sure, but it should be possible to do something like "find all the classes that have 'Client' in their name"

It's because of that built-in documentation -- docstrings -- that stuff like apropos can work as it does.

For an individual JAR file, you can run a command like jar tvf some-file.jar to see a list of all classes defined within it

You could write a program (and probably someone has, but not difficult to write a bash script to do this) that looks for all JAR files in your $HOME/.m2 recursively and does jar tvf ... on each one

@U0CMVHBL2 that interrupts my REPL flow

If you haven't loaded the class, it won't be in memory. You could write something that scanned the classpath and looked inside every JAR file it found as well as any "loose" class files found on the classpath for a class name match.

Don't do it in the REPL, but in a terminal window

Or implement it in Clojure instead of as a bash script

@U2YUELSSF If you wanted to write such a thing, you'd be replicating part of what something like depstar does -- it reads the classpath and reads any JARs it finds there.

Interesting, maybe I can use that as a library

I figured this out, which basically works:

(defn classpropos [pattern]
  (run! (comp println
              (memfn getName))
        (into []
              (filter #(re-matches pattern (.getName %)))
              (.getAllClasses
                (ClassPath/from
                  (.getContextClassLoader
                    (Thread/currentThread)))))))

using: https://guava.dev/releases/17.0/api/docs/com/google/common/reflect/ClassPath.html

nice

Thanks, I think this'll work for now

I often use clj to follow along with documentation for Java libraries, but it's really annoying having to figure out where the classes come from because the docs assume your IDE will find the class for you

@U2YUELSSF Just checking: did you already try Clojure's javadoc function to locate docs for a given class?

@seancorfield doesn't that require knowing the fully qualified name?

Just to be clear, the point of apropos is to find symbols that contain a string: e.g.:

user=> (apropos "cat")
(clojure.core/cat clojure.core/concat clojure.core/lazy-cat clojure.core/mapcat clojure.core/replicate clojure.spec.alpha/cat clojure.spec.alpha/cat-impl clojure.spec.gen.alpha/cat)

I use it all the time in CL when I have a general idea what I want to do, but don't know the specific function that implements it.

Ah, OK. Just wanted to check your use case.

I hope I’m not being too pedantic, I tend to overexplain when I suspect someone is misunderstanding me.

The name apropos exists in Clojure, but it does not scan for Java class names, only Clojure Var names.

A lot of Java documentation I've seen not only doesn't tell you which packages things are in (and doesn't show the import statements) but it also doesn't tell you the Maven group/artifact IDs! 🙂 That means you can't even find the right thing to add to your project in the first place...

https://github.com/http-kit/http-kit you can try this one

http-kit iirc had issues with not supporting streaming properly, all body was buffered into memory

which is quite nasty

using :as :stream simply gives you https://github.com/http-kit/http-kit/blob/master/src/java/org/httpkit/BytesInputStream.java, which as you can see is basically byte array wrapper 😕

If you are doing web dev you can try this lib https://github.com/sunng87/ring-jetty9-adapter

thanks, but i'd like to have netty based solution

interesting, will definitely look into it

not being updated, has few nasty bugs

could you share those bugs you ran into? i was thinking of forking it and keeping it up to date

there's one recent issue reported by me

and netty is pretty old; netty got important update recently

Good point: it's just that I want to make dependency on Component truly optional, including gracefully handling requiring the my-lib.component namespace. Maybe I'm too protective of potential users ;-)

fwiw, there's prior art here in clojure.spec's use of test.check

There are also ways to construct Component-compatible things without actually requiring Component these days.

See https://github.com/seancorfield/next-jdbc/blob/master/src/next/jdbc/connection.clj#L249 for an example of a Component-compatible entity that is a safe no-op if Component isn't on your class path.

Oh that's neat - I forgot about the ability to implement protocols via metadata. I didn't think about using it that way - thanks!

this might help if you haven't looked at it yet https://github.com/clojure-emacs/clj-refactor.el

https://github.com/clojure-emacs/clj-refactor.el/wiki/cljr-rename-file-or-dir

my Melpa shows a discover-clj-refactor but not a clj-refactor