So I think you might have a struggle related to a philosophical shift here. You seem to have assumptions about how your data structure should look like based on previous experiences with other languages that use structs/classes/SQL records as their primary compositional structure. The best explanation you can get about this is in the talk “The Value of Values” by Rich Hickey. This is where I think he introduced the term Place Oriented Programming or PLOP. --- So in specific terms you simply (!) don’t put keys into map that are not there for a given instance. Later when you get handed a map that may or may not have some keys in it, you use some way of branching (you have a lot of options here) and go from there. If you want to retrieve a value from a map that is not there it will evaluate to nil which is a falsy value. So putting a value into a map that holds nil makes little sense. Aside: Your use-case sounds like you’d want to use namespaced keywords. They give you a sense of global meaning across your application. Aside 2: There are libraries like spec, plumatic/schema and metosin/malli that provide a way to describe, test, validate the shape of your data. They have a notion of “keys in a map that may be in there and how they are used”

In any case my advice would be: focus more on the functions that operate on your data rather than putting the shape somewhere upfront (like you would do in Java). You can still start with defining some examples so you have a clearer picture in your mind (in a comment block). I personally often do this in cases like you described.

Thank you for your answers. I will go through the video you recommended and think abbout all you said, but still I have some question. Maybe I was not clear in my first text, my program is more like a library. A library which is making the process of creating sales order easier. And I need to have somehow defined "the list of all fields which are available" and the user of the library needs to have some way to see all the possible fields and in ideal situation to create from that definition some map which would be the subset of those fields if that makes sense. Is there some facility for this in clojure? Thanks again

How is decided which subset is used?

The user of the library will decide it, based on his requirement of which fields he needs to have populated in the sales order

for the time being i will implement this structure as a record. maybe with more experience I will have other insights. thanks again for trying to help

tons of fields with lots of nils is A-OK ✅

@U3ES97LAC that really depends on what you’re doing with it and what you’re expecting it to do. My instict is that there is some fundamental confusion. But maybe I’m just confused 😄

Yeah it does depend! I was just trying to answer the OP -- he's got a bunch of HTML forms and wants to be able to fill but a subset of them. I think it's A-OK to have lots of nils or "" empty strings as the values of your fields. It's kinda best to enumerate all the keys to a map when you start developing because once the maps are persisted to storage it becomes not-so-fun to add keys later ^_^

What is wrong with this one ?

If you really need to return false, then it looks good. Except I tend to keep the catch clause on one line. If you are satisfied with returning nil, then you can just do:

(try
  (sh/sh "foo")
  (catch Exception e))

I was going to return nil and then I thought he clojure way is to use booleans. I guess I was wrong?

I'm still relatively new to Clojure (a couple of years as a hobbyist), but I think that it's fine to return nil instead of forcing false.

Look up nil punning.

Someone over at #cider might be able to help you.

no, comp returns a function which is a composition of functions given as arguments. So if they are transducers its composition also will be transducer.

https://clojure.org/reference/transducers#_terminology here you can find a description of transducer including it’s signature

as per https://clojure.org/reference/transducers I see that

The following functions produce a transducer when the input collection is omitted: map cat mapcat filter remove take take-while take-nth drop drop-while replace partition-by partition-all keep keep-indexed map-indexed distinct interpose dedupe random-sample

what is the meaning of input collection is omitted ?

look at arities available for map function as an example: https://clojuredocs.org/clojure.core/map (map f) is an example when collection is omitted

so in the above screen shpt transducer is invoked by (transduce xform f coll) am I right?

which call left-to-right with a final call wher as comp calls right to left

yes, there are few functions that can invoke transducers: https://clojure.org/reference/transducers#_using_transducers transduce, eduction, into and sequence

technically, comp is a valid transducer, but that is purely accidental 🙂

comp doesn’t “call” anything. It is combining several function into one.

> technically, `comp` is a valid transducer, but that is purely accidental 🙂 yeah )

same as identity )

that helped @U04V4KLKC thanks

doesn’t look like working code

I removed some part, but wanted to understand about last 3 lines, that is as it is in code

<https://clojuredocs.org/clojure.core.async/%3C!!%7C<!!> is taking exactly one argument which is missing in your snippet also you could check the documentation to understand what it is doing https://www.braveclojure.com/core-async/ this link is also helpful

it was using threading macro ->> I apologise not adding it!

The point of async/merge is to merge many channels into one. The map in your code will return a sequence of channels (as the return value of async/thread is a channel that will contain the return value of whatever is in the body)

These channels will then be merged. The result is now a channel containing all the values from the async/thread s. To put these values into a single collection, we use async/reduce

But again, the return value of async/reduce is another channel. To get that final value out, we read from the channel using async/<!!

The difference between async/merge and async/reduce is that async/merge merges many channels into one channel, while async/reduce merges many values into one value

awesome

A common point of confusion is that async functions don't return the values, but channels that will contain the values

to get the value from chanel we need <!! right?

Yes, exactly

remeber that <!! is blocking operation so you can’t use it inside of go and go-loop blocks. This is extremely important because common suggestion for core.async is to avoid blocking at all cost )

Do you mean go-loop , not go-async ?

yes, thanks for noticing )

try this (proxy [Class$Subclass] … )

https://clojure.org/reference/java_interop#_class_access

yea doing package.Class$Subclass worked

You can use Clojure's format to get a string in the desired format.

(format "%.2f" (double (/ 47 13))) 
;; => "3.62"

hey jaco! 1. move the computation into the println and convert it to a double:

(println "Your shiny, new number is ..." (* 100 (double (/ number total)))))

(defn convert [total]
  (loop []
    (println "Your boring, old number is ...?")
    (let [v (read-line)]
      (if (= v "exit")
        (println "exiting")
        (do
          (let [number (Integer/parseInt v)]
            (println number)
            (println "Your shiny, new number is ..." (* 100 (double (/ number total)))))
          (recur))))))

Thank you, @U024X3V2YN4 and @U3L6TFEJF. That solved it! Awesome. 😁

Here's my take on explaining this: https://www.reddit.com/r/Clojure/comments/g5ysyn/code_as_data_beginner_oriented/

and we can manipulate Clojure code in the same way the clojure data:

(resolve (first '(+ 1 2))) 

@U7CAHM72M To be a bit pedantic, that snippet returns the var which contains the function that adds stuff. #'clojure.core/+ is the var, and to get the function out of that, we need to deref it: (deref #'clojure.core/+) This is what's happening, in-detail: The code:

(resolve (first '(+ 1 2))) 

(resolve (first (quote (+ 1 2))))