Unless I'm misunderstanding something, clojure spec (s/keys :req-un [::foo ::bar]) is a way to spec a map, but it operates under the assumption that the key name in the map matches the name of the spec definition

How would I go about spec'ing a map without that assumption?

I.E. I'd like the keys in my map to be :type and :text for example, but I'd like my spec to be defined as (s/def ::button-type ...) and (s/def ::button-text ...)

(s/keys :req-un [:button/type :button/text]) is close to what you want.

:req-un means unqualified keys.

So your map would have :type and :text and the key-specs for them could be :button/type and :button/text -- does that help @samueldev?

Kind of, what are my (s/def)s in this scenario? (s/def :button/type)? (omitted double ::?)

Yes.

::type is just shorthand for :this.namespace/type

So it's just a regular qualified keyword.

(for whatever this namespace is)

So you can have two maps with plain :text keys but different specs.

okay that did it! thanks @seancorfield. just for my understanding, I can still access this spec from another namespace, even if its unqualified?

here's the full code fyi that works now 🙂

(s/def :button/type #{:success :error :warn :neutral :default})
(s/def :button/text string?)

(s/def ::button-opts
  (s/keys :req-un [:button/type :button/text]))

(defn button [opts]
  (if-not (s/valid? ::button-opts opts)
    (do (js/console.error "Failed to render button; bad props" (s/explain-data ::button-opts opts)))
    (let [{:keys [text type]} opts
          styles (get-button-styles type)]
      [:button {:type "button"
                :style styles} text])))

The spec is named by the qualified keyword. So ::type would expand to :whatever.ns/type and be referred to that way, and :button/type is just another keyword.

okay makes sense :thumbsup:

Also ::foo/bar expands to whatever the alias foo refers to.

So if you have (:require [quux.thing :as foo]) then ::foo/bar means :quux.thing/bar

(and the same for aliases created via alias)

user=> (alias 'foo (create-ns 'quux.thing))
nil
user=> ::foo/bar
:quux.thing/bar
user=>

I also just discovered Orchestra, to allow me to define my function alongside the args + return specs in one spot

very convenient 🙂

now to make it work with clojurescript :thinking_face:

@samueldev i use orchestra + expound extensively -- defn+spec about half my functions, it's a great way to improve error checking

What is the idiomatic way to process a list of things with an f of side-effects, but grabbing the result? mapv feels like cheating.

I work on OpenCV code. Being based on C++ code, it implies a lot of “out” mutable parameters. An example, here edges is the result of applying “Canny” on src and must be instanciated before. (Imgproc/Canny src edges 100 500) I want to chain functions in a Clojure classic way.

(->> image
    convert-gray
    find-edges
    (draw-mat panel))

(defn find-edges [src]
    (let [edges (Mat.)]
        (Imgproc/Canny src edges 100 500)
        edges))

check doto

@reborg I did but doto put the variable in front of the given arguments or in my case it’s at second place. Do you suggest I write a macro doto-like ? I always forgot the macro solution.

I see @charles.fourdrignier. Indeed a macro is straightforward:

(defmacro doto-> [expr name & forms]
  `(let [~name ~expr] ~@forms ~name))

(doto-> (Mat.) %%
  (Imgproc/Canny src %% 100 500)
  (Imgproc/ConvertGray src %%))

There is also a little trick for doto

(doto (Math.)
  (#(Imgproc/Canny src % 100 500))
  (#(Imgproc/ConvertGray src %)))

@reborg @delaguardo Thanks !

In the context of https://www.reddit.com/r/Clojure/comments/63le75/clojure_and_graphql/ what about security (get data of different user) and alternatives?

I wish there was something like partial, but shorter in name and more like #() in terms allowing gaps. Something like (p* + 1 _ 3 _)

which would generate a function of two parameters

in scheme this is cut

#(+ 1 %1 3 %2) is nearly that

yeah but can't be nested

Also numbering arguments is kinda annoying

shouldn't be hard to implement cut, which is your idea with <> instead of _ to denote args

imho _ is misleading because idiomatically it means "I have to accept this input but I ignore it on purpose" in lisps

@roklenarcic maybe here you can find what you are looking for - https://github.com/rplevy/swiss-arrows

`-<>` in swiss-arrows plays a similar role, but for one value only. It is deprecated because clojure implemented the same thing (plus the ability to pick your placeholder) with the name as->

no - -<> does other weird things, never mind

you're right, -<> is a lot like as->

except it also has a default position

and the package offers some-<> as well

maybe it would be nice to have some-as-> in clojure.core as well

or as-some->

Suppose I have a map defined in a namespace :foo.bar/thing but I want to dynamically reference thing given only a keyword version :thing. So I need to convert :thing to :foo.bar/thing and be returned its value.

I know with functions this is done with a reader #' but I can’t seem to sort this for a plain-ol-def. I’ve tried something like <quote>:foo.bar/~(name :thing) as a naive first pass but that’s not the ticket

Where <quote> is a back-tic, don’t know how to escape those characters in slack.

Couldn’t you dispatch on a multimethod?

Hmmm that’s an idea. I was hoping to just pass around “paths” and dynamically look up these models (maps) where the namespace of the maps isn’t necessary to encode in the path.

Regardless of the design I’ve become a little curious how to dynmically resolve namespaces lin the same way a #' works for resolving fn vars

#' is used to access a var given symbol resolution (instead of resolving all the way to the value in the var, as is normal)

so for any foo/bar #'foo/bar gives you the var holding that value, instead of the value

and foo is looked up using the namespace aliases in effect

Given :thing how would you go about dynamically resolving :foo.bar/thing’s value ?

:foo.bar/thing has itself as a value

keywords are self-resolving, they never point to some other thing

do you want foo.bar/thing ?

Sorry, there is additional context above.. let me reframe the question

anyway, the simplest is (defn foo-bar [k] (keyword "foo.bar" (name k))

if you know it's in foo.bar

(that just gives you a keyword)

There exists def thing {:fizz "buzz"} in namespace :foo.bar given :thing I’d like to dynamically retrieve the value {:fizz "buzz"}

there is no :foo.bar namespace

namespaces don't get named by keywords

asking about keywords here is totally confusing the issue

Yes I’m aware of that.

The keyword is simply a reference in a path and I need to resolve it’s value which happens to exist elsewhere in the app (in another namespace)

I’m probably just doing a poor job framing the question, I’m not actually confused about how keywords are resolved or used.

user=> (resolve (symbol (name :clojure.string) (name :join)))
#'clojure.string/join

> in namespace :foo.bar made me think you didn't understand namespaces

I have a path in the shape of [:entity :attribute] and in this example would be [:thing :fizz] and I need to resolve that to the value "buzz" but the path is in namespace a and knows nothing about where thing is defined.

Oh interesting let me play with what you’ve provided.

this stuff is much easier when you don't try to treat namespaces as containers btw

Gah tell me about it! 😄

:a isn't a namespace!

you did it again

Yes sorry, fixed, it’s just a matter of muscle memory getting in the way

anyway, if you just put a hash-map in a def, this kind of lookup becomes much easier

especially if you start adding things at runtime, don't create new def from runtime input, add keys to a hashmap in an atom

a good rule of thumb is anything that uses resolve is hacky and halfway broken

Yeah I’m thinking instead of trying to force this to work I’m just going to backup and refactor this part of the app to get myself out of this corner.

I’m fairly sure I’ve still not adequately painted a picture of what I’m trying to solve here, which is a smell enough in itself.

If code can’t be easily described, it’s probably too complicated/broken and needs to be rethought anyway.

Anyway, thanks for giving it a go 🙂 much appreciated.

@hyankov In hindsight I think this is better: https://twitter.com/borkdude/status/1011164750523326465 No need for hybrids that way.

@borkdude Thanks, I remember the morning I saw this tweet. Playing in the REPL trying to disprove you (unsuccessfully) was a great start of the day 🙂

also it's good to remember how dumb form rewriting macros are - they really don't care what's in them

user=> (->> (+ a b) (let [a 10 b 32]))
42

(as-> [] % (conj % 33) (map inc %)) is cool to.

as-> is intended for use inside ->, not standalone 🙂

It seems within a defn, I can’t require something and then immediate use it, right?

not without hacky things like resolve

Figures. My use case is to be able to use the swing inspector as needed in the repl, without having the require left at the top level. Right now I’ve just put everything in a comment block and I require as a first step. I can live with it.

What are people's opinions on checked exceptions or enum-like result values

I am venturing into javaland

First time back in a while using clj instead of lein. Trying to do the CLJS quickstart but getting cp: PREFIX/example-deps.edn: No such file or directory. Any pointers? (set up on via from brew install clojure)

(can’t seem to find what’s looking for that example-deps.edn file, not sure what module/repo the call is coming from)

seems to be something up in the brew-installer itself: https://github.com/clojure/brew-install

Sounds weird. I have not heard anyone having issues. Did you brew doctor?

I would do that, then uninstall completely, then install again

in clojure, there’s a literal install_dir=PREFIX

That gets replaced during install

which seems like it was supposed to be gsubbed

yeah

hrmn

Or at least, when it works it does

haha

interesting, should be able to hack it, will post if I figure out why that didn’t get subbed

decent chance something is busted with my ruby/homebrew setup, hopefully not a problem for anybody else, sorry for the chaos/false alarm.