is there a way for core.match to match all LISTs of length-3 where first element is 'foo ?

i.e. '(foo 2 3), '(foo (+ 2 3) 4)

match seems to dislike literal symbols in the lhs of match

@qqq:

user=> (match ['(foo 2 3)] [(['foo a b] :seq)] [a b])
[2 3]

is there a way to dissoc multiple keys in a nested map simultaneously?

@michaellindon (dissoc m :a :b :c :d)

@rauh does this work for a nested map? {:a {:b {:c 1}} :d 3}

:b and :c would be misses, if that were m. But they'd be dissoced anyway, since they hang off :a

For nested maps, keys may be duplicate. So you'd need to convey some structure.

ie, at what nesting location you mean by :b in {:a {:b {:c 1}} :b 3}

i found this to be quite a good solution

(postwalk #(if (map? %) (dissoc % :a :stuck_out_tongue: :c :d) %) my-map)

lol

I think specter can do something similar too

specter looks cool

@michaellindon Something I've started to use is this:

(postwalk #(cond-> %
             (map? %)
             (dissoc % :a :b :c :d))
          my-map)

@dominicm looks good, why do you use postwalk and not prewalk?

isnt it the case that postwalk does depth first traversal, so that you enter down into nested maps that would be dissoc'd anyway?

i started using prewalk instead of postwalk

both postwalk and prewalk are depth first, but prewalk updates values on the way down, and prewalk updates them on the way back up

because we use immutable data structures it's always necessary to walk back up again recreating the collection (with either)

ok thanks 🙂

@weavejester Hi! Just wanted to say a quick thank you for your help yesterday! Got my project working with a prototype to abstract the bottom DB layer, passing it through a function that returns the handler and with tests using mocked out db functions. Works great! Not added Component in yet as it seems to complex for my simple play project:) Thank you very much for your help yesterday!

@noisesmith @dominicm so here is an interesting example, I don't fully understand the differences between prewalk and postwalk, I will read up on them, but there is a difference when the key im dissoc'ing has a value that is very very large. See this for example:

user=> (prewalk #(if (map? %) (dissoc % :a ) %) {:c {:a (iterate inc 1)}})
{:c {}}
user=> (postwalk #(if (map? %) (dissoc % :a ) %) {:c {:a (iterate inc 1)}})
[just hangs here indefinitely]

@nadejde You’re very welcome. Glad it’s working well for you!

@nadejde There’s a tool called Shrubbery that can make mocking protocols easier, btw.

@michaellindon yeah - because dissoc on the pre-walk avoids ever visiting the children

great, thats what i need

I think it's still depth first, you just short circuited it..

ok

have you ever implemented a branch and bound algorithm? I need to soon and this may come in handy. I need to traverse a tree, but not visit subtrees if a node doesnt satisfy a certain predicate

@weavejester yeah found the tool and will have a look at using it. First run just wanted to build it manually. Gets my understanding up some levels:) thank you

@michaellindon the way I remember it is the prefix (pre/post) tells you whether the node is visited before or after its children. postwalk visits each node after first visiting the children. The root node (top level map) will be the last thing processed. prewalk visits the node before the children. The top level map is the first thing processed. prewalk works for you because it lets you dissoc the children without first visiting them. postwalk would process all the child nodes before doing the dissoc on their parent and throwing them away.

And of course in your example above, postwalk will process every member of the infinite sequence produced by iterate before processing its parent node, thus the hang. Whereas prewalk never looks at it.

is there some switch that must be thrown to preserve quotation marks when printing a clojure form to a string?

pr-str

i have code that does this. it works, except when it doesn't, and i can't figure it out.

it has to do with a binding called *print-readably* and a multimethod called print-method

pr stands for print readable and that's what it does (as in, the form clojure can read again, if possible)

and pr-str returns the string that pr would print

prn is pr plus a newline

in a println, a string will not show with "" around it, inside a prn it will

ok, i'll bet print-readably is the culprit. my code works for namespaces obtained from the boot fileset, but not if i load the code using require. (this is metaprogramming, reading clojure code from namespaces and printing it to a clojurescript file.)

what do you use for the printing?

sth fairly goofy using interop with a stringwriter i think (ran screaming from my desk an hour ago so can't check). i copied it from somewhere. java io frightens me.

looking at using pprint/write with code-something whose name i forget.

pp/code-dispatch. no idea what that does, tho.

pprint should be printing things readably, it calls pr (via clojure.pprint/write-out)

wait, no, it's more complex than all that

yeah, actually i do use pprint. whether it preserves quotes seems to depend on how i load the namespaces, so i'm guessing boot fiddles with \print-readably\ or something.

but that's a dynamic var, it's setting while loading a namespace can't effect how you print unless you are printing while loading

it only effects string output, not how things are read

unless you are using pprint while reading the code too? that seems backward

boot have a fn that gets all the namespaces in the fileset. when i use that, all ok, so i'm just speculating that somehow that fn affects state. or i've inadvertently done so somehow.

and how are you getting this source code that you output via pprint?

i require the ns, then pluck out the vars to which i have added metadata, then print some of the metadata.

but that's not source unless you are attaching source code as metadata which is weird...

starts with a defcomponent macro that interns a var. it takes some clojure forms and prints them to a string, which it adds to the var metadate.

OK

kooky, but very useful.

so you have two possible points of failure: the thing that creates the string that goes on the metadata, and the thing that prints the metadata

for an example see https://github.com/miraj-project/demos/blob/master/hello-world/acme-widgets/src/clj/lib/acme/sweetness.clj

pretty sure its the bit that creates the metadata string. once it's created with escaped quotes printing it should always work, i would think.

anyway, thus is helpful, it gives me an idea of where to look.

@mobileink what's the second way you're getting/requiring the source? Is one version coming from a file and another coming as a string, created and consumed at runtime?

ok, so my boot task takes a --components arg, which is a set of symbols. #{} means all components, in which case i use boot core's fileset-namespaces to get all nss, which i then search. printing works for that. but if i pass a namespace (foo.bar) or a var sym (foo.bar/baz), i require the nss, and printing does not work.

also, i put in my namespaces a (println "loading foo.bar"). that gets printed when i pass #{}, but not when i pass #{'foo.bar}

perhaps fileset-namespaces is forcing a reload

if so, you could see what happens when you add a :reload arg to your requires?

i'll give that a try. seems odd that that would affect printing, tho.

it could be something that only operates correctly when the file is reloaded, due to some sneaky state issue

next step being to track down the tricky state issue, ideally

i'm using log4j, i wonder if that could have something to do with it.

when i require an ns by name, i can see the log msgs from defcomponent but not the println from the ns.

with fileset-namespaces i see both. strange. how i hate IO!

is there a convenient list of clojure state vars like print-readably somewhere?

+user=> (apropos #"^\*.*\*$")
(clojure.core/*agent* clojure.core/*allow-unresolved-vars* clojure.core/*assert* clojure.core/*clojure-version* clojure.core/*command-line-args* clojure.core/*compile-files* clojure.core/*compile-path* clojure.core/*compiler-options* clojure.core/*data-readers* clojure.core/*default-data-reader-fn* clojure.core/*err* clojure.core/*file* clojure.core/*flush-on-newline* clojure.core/*fn-loader* clojure.core/*in* clojure.core/*math-context* clojure.core/*ns* clojure.core/*out* clojure.core/*print-dup* clojure.core/*print-length* clojure.core/*print-level* clojure.core/*print-meta* clojure.core/*print-namespace-maps* clojure.core/*print-readably* clojure.core/*read-eval* clojure.core/*source-path* clojure.core/*suppress-read* clojure.core/*unchecked-math* clojure.core/*use-context-classloader* clojure.core/*verbose-defrecords* clojure.core/*warn-on-reflection* clojure.core.server/*session* clojure.java.browse/*open-url-script* clojure.java.javadoc/*core-java-api* clojure.java.javadoc/*feeling-lucky* clojure.java.javadoc/*feeling-lucky-url* clojure.java.javadoc/*local-javadocs* clojure.java.javadoc/*remote-javadocs* clojure.java.shell/*sh-dir* clojure.java.shell/*sh-env* clojure.pprint/*print-base* clojure.pprint/*print-miser-width* clojure.pprint/*print-pprint-dispatch* clojure.pprint/*print-pretty* clojure.pprint/*print-radix* clojure.pprint/*print-right-margin* clojure.pprint/*print-suppress-namespaces* clojure.spec/*coll-check-limit* clojure.spec/*coll-error-limit* clojure.spec/*compile-asserts* clojure.spec/*explain-out* clojure.spec/*fspec-iterations* clojure.spec/*recursion-limit*)

and if you are messing with *out* to output your string to file (eg with-out-str) I would not be surprised if this was swallowing printlns accidentally

(but not logging)

i feel much better now. spent about 3 hours this morning beating my head against this one.

alternate - maybe more accurate

+user=> (->> (all-ns) (map ns-publics) (mapcat vals) (filter (comp :dynamic meta)))
(#'clojure.core.server/*session* #'clojure.java.shell/*sh-dir* #'clojure.java.shell/*sh-env* #'clojure.java.browse/*open-url-script* #'clojure.pprint/*print-suppress-namespaces* #'clojure.pprint/*print-pretty* #'clojure.pprint/*print-pprint-dispatch* #'clojure.pprint/*print-radix* #'clojure.pprint/*print-miser-width* #'clojure.pprint/*print-right-margin* #'clojure.pprint/*print-base* #'clojure.core/*print-namespace-maps* #'clojure.core/pr #'clojure.core/*2 #'clojure.core/*verbose-defrecords* #'clojure.core/*print-level* #'clojure.core/*print-length* #'clojure.core/*default-data-reader-fn* #'clojure.core/*1 #'clojure.core/*data-readers* #'clojure.core/*e #'clojure.core/*clojure-version* #'clojure.core/*3 #'clojure.java.javadoc/*core-java-api* #'clojure.java.javadoc/*feeling-lucky-url* #'clojure.java.javadoc/*local-javadocs* #'clojure.java.javadoc/*remote-javadocs* #'clojure.java.javadoc/*feeling-lucky* #'clojure.spec/*recursion-limit* #'clojure.spec/*coll-error-limit* #'clojure.spec/*explain-out* #'clojure.spec/*fspec-iterations* #'clojure.spec/*coll-check-limit* #'clojure.spec/*compile-asserts*)

since oddly some earmuffed things are not dynamic

thanks. that should really be a list-globals or sth like that in core.

can anyone help me with plumatic Schema ? I do not really unterstand the conditional function ? I get a ConditionalSchema when I call the conditional function but this Schema acts not like a normal Schema. e.g.I can not use it as value in another Schema. Do I have another options when I want have a conditional sub shema for my base schema by an value of the base schema ?

I use conditional schemas inside other schemas

oh wait maybe I don't...

@leobm it should just work

+user=> (require '[schema.core :as s])
nil
+user=> (def C (s/conditional :a {:a String} :b {:b Number}))
#'user/C
+user=> (s/check C {:a "hi"})
nil
+user=> (s/check C {:a 1})
{:a (not (instance? java.lang.String 1))}
+user=> (s/check C {:b 1})
nil
+user=> (s/check C {:b "hi"})
{:b (not (instance? java.lang.Number "hi"))}
+user=> (def C2 {:m C})
#'user/C2
+user=> (s/check C2 {:m {:a "hi"}})
nil
+user=> (s/check C2 {:m {:a 1}})
{:m {:a (not (instance? java.lang.String 1))}}

#(constantly true) is a function that returns a function that returns true if called

maybe this isn't what you wanted?

(#(constantly true)) -> a function ((#(constantly true))) -> true

it was only for the test.. normally I want check a value from the base schema.

OK

I don't see what your example is doing that mine isn't

and mine works

are you sure you mean to be using defschema? I've literally never needed it, and I don't see what it adds to your code is shown

oh - never mind, it's just def plus some metadata

TIL

I want a conditional schema check by the type

when I change #(constantly true) to (constantly true) that error goes away in your example by the way

do you actually get this error with real code?

that second example only fails because :type needs to be on the address

but address doesn't allow :type

the conditional needs to check the thing it describes, not the parent of the thing

if the conditional is based on the :type of the person, the conditional should be in the person, not in the address

I usually handle things like this by having a base schema, with separate definitions that each assoc variant requirements to the schema data

and giving each one a distinct name

Sometimes I need to apply a series of ad-hoc functions in sucession to a value, I naturally use the threading macro for this, but it is kinda ugly

A better way?

(I intend to avoid ((fn [v] )) )

Of course I can define those macros in the namespace but they are only useful in that situation

Another example:

why not make those fns defns?

That would be the obvious solution indeed, but I didn't want to pollute the ns with good-only-for-this functions

alternatively, use as-> instead of ->

and then they don't even need to be fns

(as-> {} m (if-not ....) (if-not ...) (reduce ...))

since it's always named m, just eliminating the outer layers in the current code will work

Reading about as-> right now, looks like the solution

Yep, thank you 🙂

rewrites everything with as->

@joelsanchez https://clojuredocs.org/clojure.core/juxt

Also could be used

for what?

Pass the same variable to a sequence of functions?

Oh, I guess that doesn't thread the result though

that's not what is wanted here

right

rgr

disregard 🙂

juxt is nice but as-> is what I needed

yoooooo as-> is awesome

thank u for enlightening us

slowly humanity is discovering itself through clojure

I bumped into a following problem while using the component library - whenever a given component depends on another, the associated dependency in the system map does not release it's resources (i.e. is not stopped) on 'stop-system'. I would assume that both lifecycle methods work in the dependency order and call start / stop for each component and its dependencies in a tree traversal of the dependency graph. I haven't yet looked in detail, but I made a simple application that demonstrates the problem (call lein test to reproduce): https://github.com/fbielejec/component-app

@fbielejec

mkdir test/app && mv test/system_tests.clj test/app/

start doesn't change the input, it returns a new system

calling stop on the original asks it to stop something that was never started

on line three you create a running system with (start sys) but it goes out of scope and you never bind it

they are asking about the exact opposite

right, but what I'm saying is that line 3 has a bug, with a real system it would be a resource leak

and line 1 shows what real code does, and exposes the problem - that the system still has the resources in it that stop should have cleared up

Should their Handlers record null out both of the dependencies ?

(assoc this :handlers "still here" :database database)

(assoc this :handlers nil :database nil)