Any idea how I can achieve this in Compojure:

(def app
  (-> (wrap-defaults (get-app-routes handler) site-defaults)

I beleive you’re missing a closing parens or 2

but other than that, what is get-app-routes?

I am not missing parens. I just omitted some middleware. get-app-routes looks like this for now:

(defn get-app-routes [handler]
  (defroutes app-routes
    (GET "/" [] "Hello")))

you don’t seem to use the handler, do you need to do something odd and dynamic?

The idea is to return different app-routes based on the hostname that I can get from the handler request object

aaaaahh.. I see..

I can’t think of any clear solution for this since I don’t understand the case very well. My last bit of advice is you might be able to get away with just using routes instead of defroutes because it doesn’t seem like you’ll use app-routes directly anyway.

maybe middleware might be the way, maybe just a conditional in the routes themselves. 😅 sorry I can’t be more useful, hope someone else can help.

Thanks, I guess I'll keep trying.

I finished my results of comparing Clojure, C, Python/Jython/Cython, Ruby/Jruby for the nth term of Fibonacci.

https://github.com/starchild33/algorithms/blob/master/README.md

Hi, I have a simple TTL cache built around an (atom {}) the logic that gets a value either finds an entry or gets a new one if the entry was missing or already expired (the loading of the entry involves a short Redis IO op). Dead simple. Now, I want to improve it and make it thread-safe. It is not not entirely thread safe because 2 threads can find a missing/expired entry and trigger a load (redis call) simultaneously. How would you recommend locking the IO per key? 1. (locking cache-key ...) comes to mind but is not so the Clojure way (also, I’ll have to maintain an additional map of locks) 2. maintaining a map of entry as ‘loading’ refs where every load from DB is a transaction on the corresponding ref. This also sounds overly complex. Any more inspirations?

Hello guys, is it possible to overwrite the functionality of default protected java method from clojure?

Hi guys, what do you use for queuing? Ideally redis-based?

I was checking farmhand but it's a bit buggy

@mping out of process queuing?

@ido yep

if you are looking at redis libraries i would recommend carmine

clojure.lang.PersistentQueue/EMPTY

that’s in-process ^

@ido carmine looks great, but I would need some kind of ui to check the data, as well as retries and such

I'm looking for something like sidekiq

is there a nicer way to write this:

(defmacro define-multiple [things]
  (into []
        (for [[k v] things]
          `(def ~(symbol (name k)) ~v))))

(define-multiple {:a 3 :b 2})

I don't think that's doing what you want

usually if you're emitting multiple top-level things, it's best to wrap it in a do

Is there a way in a Ring web app to get the hostname before defining Ring's handler?

if the result of (clojure.java.shell/sh "hostname") is correct, that would be one way to get it

you could also ensure that it's set in the environment or passed as an arg to -main

the server-name that you get in a ring request is from the value of the client sent Host header, and not your hostname

Yeah, I want to determine the subdomain the request is coming from before creating Ring's handler

basically "this is who the client thinks you are"

so without a client, you can't have that

It's for a SaaS system using subdomain but the company offers multiple products. For that reason, I need to set a different set of routes based on the subdomain.

I thought I could get it to work like this: (as-> handler x (wrap-defaults (get-routes x) site-defaults) but it turned out the routes are parsed on the startup only.

It doesn't matter what it is for though, right? You are asking to get the value of the host header, which is sent by clients each request, and can vary, before a request has been sent, which is impossible

What routing library are you using? Most of them can route base on the host header

I tried Compojure and bidi

bidi has subdomain facilities but they need to be hardcoded

You will have to hard code them

There are hundred if not thousands of them

I will need to ping the DB to see which app to use for the provided subdomain before creating the routes

You'll need you create a handler, which takes a request, hits the DB, looks up base on the host header, then generates the routes and applies them to the request

Basically stop def'ing routes as global(which is terrible any way), because you need to parameterize them

Def'ing routes as a global value (as seen in lots of docs and tutorials) means 1. Parameterizing your routes doesn't work 2. Your handlers have to globals too

When can I define them if not globally? That's all I saw in the docs like you mentioned.

Any bits of code I can refer to?

Use routes instead of defroutes

Ok, I will give that a try. Thanks.

when should I use partial rather than the #(func arg1 arg2 %) syntax?

that's the thing, I use the #() syntax all the time, and I'm not sure where I should use partial instead

I think people prefer to read the anonymous function version rather than the partial. but partial isn't out of place i don't think

#() looks cleaner to me

there is no should. I think someone mentioned that had the anonymous version been around earlier in Clojure's life partial might not have been made

partial is nice cuz it very plainly says, "i'm returning a function that is just waiting on final input"

#() to me says, "this is an anonymous function" and requires a different kind of parsing

partial feels like clojure's version of currying

My advice would be, don't use partial

oh? well, okay then!

which is not to say that people don't, and it's fine that they do, but #() is imo the Clojure way to do this

just my own opinion and it's ok for others to have their own preferences :)

What feels more "Clojure" to you about #()?

one thing a partial obscures the remaining calling convention whereas #(func %1 :foo %2) is clear that it expects two more args. Also, if you refactor the signature of the function partial might no longer be up to the task leading to needless churn in a diff. For instance, (defn foo [a b c]) you can use (partial foo a b) but if you change the signature to (defn foo [a c b]) you can no longer partial this application and you would have to switch to #(foo a % b) instead of just changing the position of the % and the b

Also #(func 1 2 %) compiles to a function directly whereas (partial func 1 2) compiles to a call (to partial) that returns a function. The performance difference is tiny -- I'm mentioning this more to highlight there is a runtime element to partial whereas the anonymous function is a compile-time expression.

(I'm one of those folks who still tends to use partial but I admit that I'm moving away from it...)

it has an elegance to me sometimes but i'm moving away from it as well.

partial also captures the var value instead of the var, so it can lead to surprising behavior when using dynamic vars for example

a poll: should you ever use a macro if you can use a function?

user=> (def ^:dynamic *a*)
#'user/*a*
user=> (def f (partial + *a*))
#'user/f
user=> (def g #(+ *a* %))
#'user/g
user=> (binding [*a* 1] (g 1))
2
user=> (binding [*a* 1] (f 1))
Execution error (ClassCastException) at user$eval164/invokeStatic (REPL:1).
clojure.lang.Var$Unbound cannot be cast to java.lang.Number

@gtzogana if it's convinent, yes, but you should also have the function version for when you want to use it in a higher-order context, or when the value needs to be resolved at runtime

what's the best reaction for "that's a good point i hadn't considered. thanks"

e.g. clojure has with-binding and with-binding*

one is a macro on top of the function

sometimes you need to use the function version when the binding map is built at runtime

but often it's not and the macro version is just less verbose to use

hmm, ok

Interesting points in favor of #(). Normally I favor partial because #(% ...) looks like someone swearing in a comic book But yeah looks like I should switch

if I have a lazy repeat in clojure, can I turn it into a lazy vector I can use with assoc?

vectors are not lazy -- they have a fixed length

is there an equivalent of assoc that can be done on a lazy seq?

what are you trying to achieve. often its best to take a step back and figure out if there's a better way

I'm trying to create a brainf**k interpreter, as an exercise. This is for the tape.

you could use map-indexed and something like

(let [index 3]
 (map-indexed (fn [i x]
                (if (= i index) :replaced-value x))
              (range 6)))
(0 1 2 :replaced-value 4 5)

use a map

a map is a better model for the tape

if you can drop your lazy requirement, which you probably can?

the lazy requirement is nonsensical

I don't really see how a map makes a better tape model than a vector when the tape is a sequence?

your current woe would be solved

a map allows for a sparse representation

the lazy thing was because I thought doing a lazy tape was elegent and solves the bf interpreter problem of running out of tape

e.g. with a map you can assoc a value in for 1e3 without needing a value in the map for everything between 0 and that

that actually makes more sense

thanks

Can you help me understand the difference between these two forms of generating a lazy sequence?

(defn evens-v1
  ([]
   (evens-v1 2))
  ([n]
   (lazy-seq (cons n (evens-v1 (+ n 2))))))

(defn evens-v2
  ([]
   (evens-v2 2))
  ([n]
   (cons n (lazy-seq (evens-v2 (+ n 2))))))

the boundary of laziness is lazy-seq, so you would say evens-v1 is slightly more lazy and evens-v2 is slightly more eager

so with evens-v1, when you call it returns a lazy seq, and when you call first or rest on it, the body of the lazy-seq call is executed and cached, and first or rest is called on it

with even-v2 when you call it, it cons's n on to the unforced lazy seq constructed by lazy-seq and returns that

the type of a lazy seq doesn't change, regardless of if it has been forced or not

Ok, so the difference is basically negligible but version 1 is truly lazy since v2 starts creating that sequence (albeit a single element of it) when you call it even before it is realized.

correct, the difference in this case is negligible, but it can be larger, it depends on the amount of computing required to construct that initial element

Thanks for the explanation!

I am not sure I have come across a case where it mattered a lot, but in general I try and hoist lazy-seq calls up as high as possible so they wrap as much of the function body as possible

That makes sense.

can someone help me with a bit complex regex/replace problem. I need anything that matches to be wrapped one way, anything that doesn’t match the other way, e.g.: if given string like: “Donec vitae dolor color or sotamayor” I want to highlight everything that matches “or”, basically I want it to become something like:

[:span "Donec vitae dol"
 [:span.h "or"] [:span "col"] [:span.h "or"] [:span " "] [:span.h "or"] [:span "sotamay"] [:span.h "or"]

matching part is relatively easy… but I can’t figure out how to replace things that do not match

@ag I'd be inclined to use the .find .end methods, each returns a numeric index you can use with subs

and then use cons and recursive calls (maybe with lazy-seq even)

take string, call .find get a start index, call .end get end index, cons two strings, then self-call

hmm… but why can’t it be two pass string/replace?

https://github.com/ztellman/automat could be useful

string/replace could be possible, but I think the self-call cons approach is easier to think about

so like if I want for example wrap anything that doesn’t match “or” and place it between “^” and “$”… :

(clojure.string/replace
 "Donec vitae dolor color sotamayor"
 #"(?!or)"
 #(str "^" %1 "$"))

I am not sure regex syntax is flexible enough for what you want

but a regex is a kind of finite state automata, and automat is a more flexible way to construct those

I am no regex wiz, but I think your issue is, regex is a character by character scan, and you are trying to say, chunk things in to groups that are not this two character sequence

but a regex would only match the character sequence at a time, so even if it did work, you would get lots of two character slices

which is actually almost what you get with your ^$ example

egret.run=> (re-split-seq "Donec vitae dolor color or sotamayor" #"or" (fn [x] [:span.h x]) (fn [x] [:span x]))
([:span "Donec vitae dol"] [:span.h "or"] [:span " col"] [:span.h "or"] [:span " "] [:span.h "or"] [:span " sotamay"] [:span.h "or"] [:span ""])

imperfect, but it's a start

(defn re-split-seq
  ([s re marked unmarked]
   (let [matcher (re-matcher re s)]
     (re-split-seq s re marked unmarked matcher 0)))
  ([s re marked unmarked matcher unmatched]
   (let [found? (.find matcher)
         start (when found? (.start matcher))
         end (when found? (.end matcher))]
     (if found?
       (cons (unmarked  (subs s unmatched start))
             (cons (marked (subs s start end))
                   (re-split-seq s re marked unmarked matcher end)))
       (list (unmarked (subs s unmatched)))))))

(or use java.util.Scanner)

I need it to work in Clojurescript (preferably)

use automat

in js you'd want .search (returns index of start of match) and .lastIndex

and you'd use a RegExp instead of matcher (I assume in cljs #"" is already a RegExp)

sorry guys… I got dragged into fixing an issue in an RC. Thank you all for your suggestions, I will try them! :spock-hand: @noisesmith @hiredman @dpsutton