Assuming you meant "everything need to happen client-side."

For what you're describing you don't need any libraries, but Klipse might do what you want out of the box: https://github.com/viebel/klipse

Also, you might want to send follow-up questions to #clojurescript.

Yes, I meant "everything happen client side." Thanks for inferring that. 🙂. Sure, will move to cljs.

Not sure that there's much in the way of a future specific style. I think the idea behind the future is to 'lift' threading, etc into nice clojury value-orientation so that all you need to follow are your general style, best practice, etc guidelines

there are plenty of values from pr-str that are not parsible as edn

(eg. Exception, Object, arrays)

(pr-str (new Object))
=> "#object[java.lang.Object 0x45463dad \"java.lang.Object@45463dad\"]"

speaking of transit - it does seem to handle 1/2 in a way that cljs could handle

(cmd)user=> (def baos (java.io.ByteArrayOutputStream. 4096))
#'user/baos
(ins)user=> (cognitect.transit/write (cognitect.transit/writer baos :json) 1/2)
nil
(ins)user=> (.toString baos)
"[\"~#ratio\",[\"~n1\",\"~n2\"]]"

So probably I will need to handle with

{:handlers {"n"     (fn [v] (parse-bigint v))
            "f"     (fn [v] (parse-bigdec v))
            "ratio" (fn [v] (parse-ratio v))}}

But how about edn spec? Is Ratio a clojure special syntax or it's from edn ?

have you tested? I would assume if clj transit generates #ratio, that cljs transit would read it

That's an interesting question - I was surprised to see that cljs couldn't handle 1/2

(str (transit/read (transit/reader :json) "[\"~#ratio\",[\"~n1\",\"~n2\"]]"))
=>
"[TaggedValue: ratio, [#object[Transit$TaggedValue [TaggedValue: n, 1]] #object[Transit$TaggedValue [TaggedValue: n, 2]]]]"
(pr-str (transit/read (transit/reader :json) "[\"~#ratio\",[\"~n1\",\"~n2\"]]"))
=>
"#object[Transit$TaggedValue [TaggedValue: ratio, [#object[Transit$TaggedValue [TaggedValue: n, 1]] #object[Transit$TaggedValue [TaggedValue: n, 2]]]]]"

fascinating

(Imagine that you expect a number and just (str "My number is: " my-number)

(transit/read (transit/reader :json {:handlers {"ratio" (fn [[k v]]
                                                          (/ (js/parseInt (.-rep k)) (js/parseInt (.-rep v))))}})
              "[\"~#ratio\",[\"~n1\",\"~n2\"]]")

you can also do some protocol stuff. But then you always need to use your IToString/->str and it need to be extended to bigint, bigdec, ratio...

smells like a multimethod almost...

I'm surprised this isn't sorted already, frankly

I had a problem with bigint few months ago. My application simply stopped working because a number get too big and clojure turns it into bigint

To be clear, I am talking about things that you could stop doing today (or could be enforced by a linter), not stuff that would need changes to the language. I.e. if you don't like S-expressions, that doesn't qualify.

none? :)

might be a better question for reddit or clojureverse, as it will probably get lost in the conversation here

So let's talk about the ns form... :p

I don't see a lot of things that I would stop doing; I do see a lot of things than you can abuse (e.g dynamic Vars, lazyness, eval, macros...)

As an example I was thinking of stuff like structs

Or the mentioned implied :refer :all (@U06GS6P1N?)

You are probably right, @U0BAS2E13

I have stopped using dynamic vars. When I need thread local state, I use java.lang.ThreadLocal, it's simpler and faster.

I'd say the use of use, or an abuse of :refer :all. Can't think of anything else

Or, maybe declare also, but there are exceptions

I’ve been using clojure for 10 years and have honestly tried my best to think of something… and I can’t really think of anything… structs are basically deprecated; simply because there’s a better mechanism these days but they still work fine…. :use as an ns form is also basically deprecated, and :refer :all can be an anti pattern but sometimes it’s totally warranted. declare is definitely ok too; but it should only be used where you can’t restructure forms to break a mutual dependency. So the only two things I can really think of is calling realized? on anything other than future/`promise`, e.g. a lazy-seq. And I guess also #= reader eval, but that also has a few uses. So I think that just leaves us with a few standard Lisp aphorisms, like “eval is evil” (except where you need it — e.g. to implement a REPL), and don’t abuse macros 🙂

I think we’ll fix the realized? thing btw

and #= is officially not public so you shouldn’t use it anyways :)

😀

I have often wondered what Rich’s biggest regrets about clojure might be… what he’d do differently if he could go back and do it again. I’m guessing putting protocols at the bottom would be quite high on that list (but he fixed that in clojurescript, right? 🙂)

open sourcing it?

just kidding ha ha! :)

lmao it’s funny you mentioned that… I almost said that too!

“Clojure would be great if it wasn’t for our **ing users” 😉

One has to wonder how many times you folk at Cognitect say this 😉

Clojure was always made to be shared. There’s no point in putting years of work into something just for yourself.

Of course, I’m just being facetious; we’re all very much in debt to your generosity!

proxy has the wierd implicit this. Not a "don't" use, but definitely a wart.

Sure, clojure isn’t perfect… but I’d probably call the imperfections blemishes rather than warts, as they’re usually not that ugly. if we’re talking blemishes there are a few but nothing major… e.g. inability to add docstrings in defrecord (because there’s no var for them), then sometimes you need to define a new constructor for them so you may want to mark the implicit constructor private (which you can do with alter-meta!) so people don’t use it rather your one etc… I also wish spec had docstrings too… though hopefully that’s coming.

I would be surprised if the docs for Formatter don't make it explicit

user=> (doc format)
-------------------------
clojure.core/format
([fmt & args])
  Formats a string using java.lang.String.format, see java.util.Formatter for format
  string syntax
nil

from the doc for Formatter:

The number of digits in the result for the fractional part of m or a is equal to the precision. If the precision is not specified then the default value is 6. If the precision is less than the number of digits which would appear after the decimal point in the string returned by Float.toString(float) or Double.toString(double) respectively, then the value will be rounded using the round half up algorithm. Otherwise, zeros may be appended to reach the precision. For a canonical representation of the value, use Float.toString(float) or Double.toString(double) as appropriate.

https://docs.oracle.com/javase/7/docs/api/java/util/Formatter.html

:thumbsup:

A minimal self contained example would be more helpful.

Because there isn't any difference b/w cancelled and approved response, why not just do

(s/def ::ResultCode #{"0" "1"})
(s/def ::emv-response (s/and int? even?))
(s/def ::swipe-response (s/and int? odd?))
(s/def ::response (s/keys :req [::ResultCode (or ::emv-response ::swipe-response)]))
; Generate some responses
(gen/sample (s/gen ::response))