This is basically if.

exept of its first argument, whih is need to be a boolean value instead of predicate itself

no core functions or macros. Small enough to write your own one liner

Thaths why I'm asking - it's not a problem to write custom fn or macro, but I try to find existed ones first

Can’t think of any.

`fnil` comes close but doesn't work exactly like that (edit: nevermind, you want to replace the output)

fnil is good for checks on nil? but not on custom predicate. I just thought, that there shoul be a common pattern for such type of code in dynamic types world...

There are other ways to do type checking if that’s what you want.

Can you share them, please?

clojure.spec for one

And other spec related tools

such as malli or schema

What exactly are you trying to do, if I may ask?

I'm trying to find an usable way for checking & setting defaults to values, which are not of proposed types or nils

For a specific instance or as a pattern in general?

What woul be more short & readable

f.e. I can coerce val to string as (str val) and it makes nil as "" and 3 as "3" but it will keep [1 2 3] as "[1 2 3]" what can be undesireable

Can’t you simply have a map of undesirables mapping to their default values?

(def defaults {nil 42})

(defn make-default [x] (get defaults x x))

(make-default 42) ;; returns 42
(make-default nil) ;; returns 42

Let talk about this case:

{:a nil} => 0
{} => 0
{:a 3} => 3
{:a "3"} => 3
{:a ....} => 0

It's a more complex one, I know, we should parse a string to int, but it's just an example of one case when I want to use my check helper

(t (some-fn number? string?) val 0) like this

And yes, it may looks like "inline spec" from this point...

You can use custom predicates but that will quickly become unmanageable because you're not simply "removing undesirable values" nor parsing. You're describing a conversion process that (potentially) involves a significant amount of logic. Like I said in the other thread I really believe that you should use a library like https://github.com/noprompt/meander to unnest your data. For the coercions you can use something like https://github.com/exoscale/coax.

Thanks, I'l look on them and maybe really will try it!

This is basically if-not 😄

exept of its first argument, whih is need to be a boolean value instead of predicate itself

and 2 args instead of 3

Right. Might as well wrap it into your own fn. Can’t think of anything in core that does this

You can hack it

((fnil identity default) value) f.e. looks like one of the ways?

Is that better/more readable than (if (nil? val) default val)?

Are you looking for a way to not have to repeat val or is there more to it?

Similar +-. The winner is (or val default) but it substitutes false (((

I'm looking for usable way to set defaults instead of nils in code

F.e. (:active {:id 1 :active nil} 42) => nil so I need a short wrapper to avoid nils

And yes, val can be a big form, so I'd like to type it once

1. I'd go one step back: Do you control what goes into the map? If so, try not to have nils before you build the map and then you'll be able to just (merge default-map m). No or/ifs anywhere. 2. If not, I'd just write (or (:active {:id 1 :active nil}) 42) - oh, or will replace false too though, right that's what you said 3. if you're absolutely sure that you don't need any of the nil vals you could remove those keys (this is risky though) and then do a merge with a default map

This is on of the cases, but I have to write stable backend code having input map from json, and frontend can either send nil values or does not send them as well. I can sanitize and delete all the nils (on all the nested levels!) before, but looks like it is overkill. I'm looking for simple & usable solution, standart one first

Right, I don't think there's much you can do in that case. You could write your own wrapper function and use it everywhere to protect your data from unwanted nils but I've actually been there and it's not pretty. However: > nested levels Have you considered transforming your data with something like https://github.com/noprompt/meander of https://github.com/healthsamurai/ironhide? As your project grows I suspect you'll have bigger problems if you have nils and nested data to handle.

I just entered new team & project, and don't know about input data transformation process yet, but I already see the hacks & tricks in the code and my first idea was to cleanup it as possible

the main problem is that callers must list trailing args (good for people) but calling functions (programs) often have stuff in a map. this lets those functions pass the data directly without needing to apply/spread the kwargs

you commonly run into this when trying to layer one kwarg function over another

yeah, if you've ever worked with a kwarg-only API and needed to programmatically choose which elements to add, you'll probably have made your own custom apply that first flattens an input map into a sequence before passing it to the function. Now that wrapper function need not exist except in codebases looking to support multiple clojure versions.

(let [s (vec " ▁▂▃▄▅▆▇█")
      walk (fn [n]
             (let [n (+ n (rand-nth [-1 1]))]
               (cond
                 (> 0 n) (+ n 2)
                 (<= (count s) n) (- n 2)
                 :else n)))]
  (->> (iterate walk 0)
       (map #(nth s %))
       (take 5000)
       (clojure.string/join))

(require '[clojure.string :as s])
(let [s " ▁▂▃▄▅▆▇█"
      w (fn [n]
          (let [n (+ n (rand-nth [-1 1]))]
            (cond
              (> 0 n) (+ n 2)
              (<= (count s) n) (- n 2)
              :else n)))]
  (->> (iterate w 0)
       (map #(nth s %))
       (take 5000)
       (s/join))

(apply str)

You can make w a #(...) function. Not sure if you've tried removing all the unnecessary whitespace. :)

maybe apply str instead of join

(let [s " ▁▂▃▄▅▆▇█"]
  (clojure.string/join
   (take
    5000
    (map
     #(.charAt s %)
     (iterate
      (fn [n]
        (let [n (+ n (rand-nth [-1 1]))]
          (if (> 0 n) (+ n 2) (if (<= (count s) n) (- n 2) n))))
      0)))))

237 chars

(let [s (vec " ▁▂▃▄▅▆▇█")]
  (clojure.string/join
   (take
    5000
    (map
     #(s %)
     (iterate
      (fn [n]
        (let [n (+ n (rand-nth [-1 1]))]
          (if (> 0 n) (+ n 2) (if (<= (count s) n) (- n 2) n))))
      0)))))

(let [s (vec " ▁▂▃▄▅▆▇█")]
  (clojure.string/join
   (take
    5000
    (map
     #(s %)
     (iterate
      #(let [n (+ % (rand-nth [-1 1]))]
        (if (> 0 n) (+ n 2) (if (<= (count s) n) (- n 2) n)))
      0)))))

(apply str (take 5000 (map #(nth (vec " ▁▂▃▄▅▆▇█") %) (iterate #(let [n (+ % (rand-nth [-1 1]))] (cond (> 0 n) (+ n 2) (<= 9 n) (- n 2) :else n)) 0))))

151

(apply str (take 5000 (map #((vec " ▁▂▃▄▅▆▇█") %) (iterate #(let [n (+ % (rand-nth [-1 1]))] (if (> 0 n) (+ n 2) (if (<= 9 n) (- n 2) n))) 0))))

:man-golfing:

Twitter truly brings out the worst in people.

(apply str (take 5000 (map #((vec " ▁▂▃▄▅▆▇█") %) (iterate #(let [n (+ % (rand-nth [-1 1]))] (cond (> 0 n) (+ n 2) (<= 9 n) (- n 2) 0 n)) 0))))

142!

(apply str (take 5000 (map #((vec " ▁▂▃▄▅▆▇█") %) (iterate #(let [n (+ % (rand-nth [-1 1]))] (+ n (if (> 0 n) 2 (if (<= 9 n) (- 2) 0)))) 0))))

but wait, there's more, we can get rid of whitespace!

@UK0810AQ2 Replace (- 2) with just -2. :)

(> 0 n) is neg? isn't it?

I guess that's bigger, nvm

(apply str(take 5000(map #((vec " ▁▂▃▄▅▆▇█")%)(iterate #(let[n(+ % (rand-nth[-1 1]))](+ n(if(> 0 n)2(if(<= 9 n)(- 2)0))))0))))

124!

(apply str(take 5000(map #((vec " ▁▂▃▄▅▆▇█")%)(iterate #(let[n(+ % (rand-nth[-1 1]))](+ n(if(> 0 n)2(if(<= 9 n)-2 0))))0))))

I think my work here is done :rolling_on_the_floor_laughing:

You can also replace ((vec ...)%)with (nth ...%) . Removes ().

right, you can take nth from string!

121 chars

(apply str(take 5000(map #(nth" ▁▂▃▄▅▆▇█"%)(iterate #(let[n(+ % (rand-nth[-1 1]))](+ n(if(> 0 n)2(if(<= 9 n)-2 0))))0))))

also condition returns either 1 or 7 or n

Alex is probably horrified at this point

(apply str (take 5000 (map #(nth " ▁▂▃▄▅▆▇█" %) (iterate #(let [n (+ % (rand-nth [-1 1]))] (cond (< n 0) 1 (> n 8) 7 0 n)) 0))))

@U1EP3BZ3Q Not equivalent since in your code the new value of n does not depend on the old value of n, except for one branch. In the original solution, all three branches depend on n.

I don't agree :)

if n >= 9 it has to be 9, then n-2 is 7, similarly for the other case

this is a non uniform correction for over/under flow

Ah, right, makes sense. The yuk factor grows incessantly.

How is that different from cross product when one direction is zero? 😛

(apply str (take 5e3 (map #(nth " ▁▂▃▄▅▆▇█" %) (iterate #(let [n (+ % (rand-nth [-1 1]))] (cond (< n 0) 1 (> n 8) 7 0 n)) 0))))

next up: port http://aem1k.com/world/

Here is bigger collection: https://www.ioccc.org/

yeah but how many are also quines?

who knows

we've been reducing the size of the current algorithm but what if we did something different, like using reduce to build up the string

Maybe, but here is the "102" chars version:

(apply str (take 5e3 (map #(nth " ▁▂▃▄▅▆▇█▇▆▅▄▃▂▁" (mod % 16)) (iterate #(+ % (rand-nth [-1 1])) 0))))

brilliant!!

I knew we could get rid of this condition

I was staring at the 8 characters trying to figure out how to make mod 8 not reset to 1

and of course the solution is to make it 16

if that makes sense

There is another way of removing the if mathematically

(defn foo [s z]
  (let [z (+ z (rand-nth [-1 1])) 
        z (+ z (* -2 (Math/floor (/ z (dec (count s))))))] 
    (int z)))

Yes, true. Don't forget that the goal is to make it shorter.

Yes, your solution is significantly more elegant.

I was just making the point that there is a mathematical solution to it 🙂

Clamping is always annoying. Of all the ifs that get your goat, clamping is probably one of the worst ones

What I like the most about your last solution is how by modifying the static input you got a more elegant expression

There’s now even space for clj -e or bb -e '' in that tweet. Impressive!

Amazing!

clj-kondo complains about 5e3 being a double, not a natural integer 🙂

@U1EP3BZ3Q mind if I post a (slightly modified version) of this on Twitter and mention you?

@U7PBP4UVA sure!!! don't forget about mentioning the rest of people from this thread, a lot of contribution to the final result

clj-kondo doesn't know the real hacking 🙂

https://twitter.com/orestis/status/1509553038268243976?s=20&t=7dRpv3LCfTpwItn6liaWaw

Haha, this thread is ridiculous. And I love it.

We were so preoccupied with if we could, we didn't stop to consider if we should.

Yes

Fantastic thread and go @U1EP3BZ3Q and clojure for getting this down to 102 chars! :punch:⛳Somewhat unintuitively I think code colfing actually tends to teach you things about both the language and the problem domain.

I think we can squeeze a little more out - a vector is a function, so (vec " ▁▂▃▄▅▆▇█▇▆▅▄▃▂▁") is equivalent to #(nth " ▁▂▃▄▅▆▇█▇▆▅▄▃▂▁" %) and 3 characters shorter. We just need to push the mod onto the iterate thus: (apply str (take 5e3 (map (vec " ▁▂▃▄▅▆▇█▇▆▅▄▃▂▁") (iterate #(mod (+ % (rand-nth [-1 1])) 16) 0)))) comes in at 99 characters.

Wow! :D

How does this different with clj -Stree works internally?

-Stree is run in your project classspath so the aliases are in effect

-Stree may eventually fade in prominence, the :deps tree continues to add more features

Thanks so much!