https://cljs.github.io/api/cljs.core/#setBANG interesting... api reference for cljs doesn't mention this arity

Hm, right. It's in the impl though, and it's maintained. Perhaps it should be mentioned in the docs as well.

yeah, it should be) that would safe me many keystrokes 😄

Hi. Can't help with your question, but for future reference, please start topics in a single message. Slack allows using a thread to add extra details or edit the original post where Shift+Enter can add a new line without sending the message.

https://github.com/plumatic/schema-generators/blob/master/src/schema_generators/generators.cljc#L217-L219 sample function takes argument k to limit number of returned samples.

It seems that sample works on the top level, when you yourself call it. But I think OP needs to generate, say, a map where a value for a particular key is a collection with fewer than 100 items.

I want to generate ~300 (or more) samples. Sometimes it creates more that 99 descriptions and throws runtime exception.

Couldn't satisfy such-that predicate after 10 tries.

At least with spec, you can attach a custom generator to a spec. Perhaps the same can be done here.

maybe… I will have a look.

I wouldn't try to copy exactly what the java code is doing

what you pass to deployVerticle just needs to implement the Verticle interface

https://github.com/vertx-clojure/vertx/blob/master/src/vertx/core.clj is old and marked as alpha, but may be useful to see how they interact with vertx without doing all the weird stuff java examples do in the name of brevity

this core.clj, looks complicated, for now i want to extend AbstractVerticle and override its start() method

i am reading a vert.x book, and trying the code

then use proxy

i tried that also, but start wasnt called at all

but maybe i did something wrong

should it be called?

vertx.deployVerticle(new HelloVerticle());

the docs you are looking at are out of date

start takes an argument, and an exception is being thrown, but on a different thread and is communicated back via the promise like object that deploy returns

% clj -Sdeps '{:deps {io.vertx/vertx-core {:mvn/version "4.5.1"}}}'
Clojure 1.11.1
(def vertx (io.vertx.core.Vertx/vertx))

(.deployVerticle vertx
                 (proxy [io.vertx.core.AbstractVerticle] []
                   (start [_]
                     (println "hello world"))))
#'user/vertx
user=> user=> hello world
#object[io.vertx.core.impl.future.Mapping 0xef1695a "Future{unresolved}"]
user=>

on AbstractVerticle class not the Verticle interface, there is a start method without argument, the java code that i sended is working ok

but proxy overrides by name only

so overriding start via proxy will override and start methods regardless of arg count

i was using it like start [] without argument, because it has 2 start methods one without and one with a Promise

start [] nothing was called

https://vertx.io/docs/apidocs/io/vertx/core/AbstractVerticle.html

the implementation of AbstractVerticle is likely the 1 arg start method is calling the 0 arg start method

but with proxy when you provide a start method, that method overrides all the start methods on the class

so Vertx was calling it with 1 arg and it was throwing an error because the start on the proxy can only take 0 args

but that was happening on another thread and being communicated back to the main thread via the promise like thing that deploy returns, which I doubt you were looking at very hard when proxy didn't work

so you need something like (start ([] ...) ([p] (proxy-super this start p)) , but I forget the exact usage details of proxy-super, and something to keep in mind is proxy-super is not threadsafe, all of which is why I suggest (and I bet why the nascent clojure library there) biting the bullet and using the interface instead

it is just (proxy-super start p)

but that might not call your start override correctly

% clj -Sdeps '{:deps {io.vertx/vertx-core {:mvn/version "4.5.1"}}}'
Clojure 1.11.1
user=> (def vertx (io.vertx.core.Vertx/vertx))
#'user/vertx
user=> 
(deftype V [^:volatile-mutable vertx
            ^:volatile-mutable context
            start
            stop]
  io.vertx.core.Verticle
  (getVertx [_] vertx)
  (init [_ v c]
    (set! vertx v)
    (set! context c))
  (start [_ p]
    (start vertx context p))
  (stop [_ p]
    (stop vertx context p)))
user.V
user=> 
(.deployVerticle vertx
                 (->V
                  nil
                  nil
                  (fn [vertx context p]
                    (println "start")
                    (.complete p))
                  (fn [vertx context p]
                    (println "stop")
                    (.complete p))))
start
#object[io.vertx.core.impl.future.Mapping 0x6ab4ba9f "Future{unresolved}"]
user=> (.close vertx)
stop
#object[io.vertx.core.impl.future.PromiseImpl 0x30e6a763 "Future{unresolved}"]
user=> 

thank you for helping me, this with the 2 start methods, with 1 arg it worked, but still i cant make the java code to work

AbstractVerticle i want to extend, just to follow the java code , while reading the book, deftype i never used it in past

i think i just need to find books that explain those java things from clojure very good, because they are complicated

i am still trying to make it work

Dealing with abstract classes is going to be a real uphill battle

package ch2;

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Vertx;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloVerticle extends AbstractVerticle {
    private final Logger logger = LoggerFactory.getLogger(HelloVerticle.class);
    private long counter = 1;

    @Override
    public void start() {
        Vertx vertx= super.getVertx();
        System.out.println(this.toString());
        vertx.setPeriodic(5000, id -> {("tick");});
        vertx.createHttpServer()
                .requestHandler(req ->
                {
                  ("Request #{} from {}",
                              counter++,
                               req.remoteAddress().host());
                 req.response().end("Hello!");
                })
                .listen(8080);

        ("Open ");
    }

    public static void main(String[] args) {
       Vertx vertx = Vertx.vertx();
       vertx.deployVerticle(new HelloVerticle());
    }
}

this is all the code, that i want to write in clojure

its from book, learning vert.x , when reading a book , it helps to just write the same code in clojure, because i dont know vert.x yet, to think of alternative ways

none of that depends on anything in AbstractVerticle

you can see https://github.com/eclipse-vertx/vert.x/blob/master/src/main/java/io/vertx/core/AbstractVerticle.java does close to nothing

I think, in order to use the abstract base class correctly you'll need to use gen-class and aot compile, and then maybe use :exposes to avoid the two start methods having the same name, but not sure

or you can just not use the base class and do all that stuff right now in a live repl

thank you alot for helping me, i think for now i will use the java classes from java, and when i find a good tutorial on those i will retry, and yes i will start with gen-class that is the safest option, i tried many times, with gen-class

it worked now with the proxy, with 1 arg : ) thats important, progress, you helped me, something with those 2 start methods makes things complicated i guess, sometime i will see the gen-class and :exposes, thank you