Writing a Lambda/API Gateway fn in Clojure, I need an adapter that translates requests into Ring request/response format: - locally I can just run Jetty+Ring - routing is done in the Ring handler (e.g. compojure) - on Lambda, I can set up an ANY route with path * that forwards all requests to the Ring adapter There are a few projects on github along those lines like https://github.com/indabamusic/ring-aws-api-gateway-lambda-adapter and https://sideshowcoder.com/2018/05/11/clojure-ring-api-gateway-lambda/ - can anyone recommend a project?

I think the portkey guys were working on this. I'm not sure about completion.

@dominicm I think portkey is far more ambitious than what I'm looking for (basically a few lines of code, https://github.com/mhjort/ring-apigw-lambda-proxy)

Does it make sense to use core.typed in 2018?

There might be use cases for it, but honestly... core.spec does this job really well, even better.

🙂

is there a high-order equivalent of or? I'd like to do something like (def invalid-number? (or* zero? neg?)) ... (remove invalid-number? numbers)

Ah, some-fn looks like it works in this context

One of my collegues has discovered transducers recently and now he tend to turn every simple map function into a combination of a map transducer and (into []) like this

(into [] (map fn) coll)
;;instead of
(map fn coll)

hello clojurians. where can I see the list of all available protocols?

You're lucky, I'm working on a project that exactly does what you want (hope I haven't missed anything extracting this snippet out of it).

https://twitter.com/leandrotk_/status/1056926515781345282

What library would people use these days for easily-configurable XML parsing and editing?

I know zippers allow editing, but xpath gives a really easy way to have runtime-configurable statements like "Find all of element X where it has a child element Y with attribute Z having value A". I want to then be able to say "and delete the node (X)"

I use clojure.data.xml for xml parsing / output, though I'm not doing any real heavy lifting.

Yeah, that's what we're using at the moment. But it really doesn't lend itself to runtime configuration of paths

With xpath you can do stuff like /elementA[/elementB/@attr = ("val1" "val2", "val3")] to find the relevant nodes

Something that would then let me just remove the found nodes would be great

With clojure.data.xml as far as I have found I have to manually build functions to do that sort of thing and it's not easy to make it configurable.

Do we have syntax for having arguments to a function as an additional vector?

(defn some-fn [a b c :as input-vector] ...)

For example, this works

(defn some-fn [& [a b c :as input-vector]] (println input-vector))

but allows more than 3 arguments.

Not that I can think of, built in. You can make one inside the function if you want, of course.

in other words, you want to enforce that the vector is exactly (or no more than?) length 3?

I had a function definition

(defn ->some-map
  ([a b c]
   ...)
  ([input-vector]
   (apply ->some-map input-vector)))

I need the input-vector inside the 3-arity function for logging.

You mean a function that takes either 3 separate arguments, or 1 that is a vector, without defining it as a multi-arity function, and with automatic checking that number of args is 1 or 3? No, I really don't think that is built in.

And some people might suggest you be cautious about introducing such "punning" in args your functions accept, lest you confuse yourself or library clients later, but I won't go far in that direction.

I don't want to get rid of the arity, I just need the vector inside the 3-arity function to log it without constructing one myself with the three arguments. Nevermind, it's not that important. It will make it trickier to read the definition.

there is no vector, so you will have to construct it if you want it

If your function took exactly 1 arg, and it was a vector with at least 3 elements, you could do destructuring for that 1 arg, but I don't think that will enforce exactly 3 elements in the vector, only at least 3.

it won't enforce at least 3 either, I don't think

user=> ((fn [[a b c]] [a b c]) [1])
[1 nil nil]
user=> 

& [a b c] will not enforce the length of the vector, no

user> (defn some-fn [& [a b c :as input-seq]]
                     (println input-seq))
#'user/some-fn
user> (some-fn 1 2 3 4)
(1 2 3 4)
nil
user> 

(isn't a vector either)

Right.

@seancorfield It looks like the generated API docs are out of date for clojure.core.cache - is that something you can update or is it part of some larger Clojure thing? Took me a while to figure out what was going on (the API docs don't have through-cache and I was going a little crazy trying to figure out where it came from 🙂 )

@shaun-mahood Technically it's a build infrastructure thing that's broken -- @alexmiller?

how to use :exclusions in deps.edn ?

@octo221: like so

com.cognitect/transit-clj {:mvn/version "0.8.300" :exclusions [org.javassist/javassist]}

@shaun-mahood @seancorfield yes, it’s somewhat manual right now. But just pushed update http://clojure.github.io/core.cache/

@alexmiller @seancorfield Thanks!

What's a good word for a function that, like juxt, accepts multiple functions and returns a single function that accepts a vector (or sequence, I guess) and invokes each input function on its correspondent element in the sequence/vector? I find this can come up a lot in data pipelines. unoptimized version basically being (fn [& funcs] (partial map (fn [f x] (f x)) funcs))

this is a common enough usecase I wouldn't be surprised if I missed it already existing somewhere in core, too

it's sort of an anti-juxt, lol

maybe like map-each

maybe a slightly nicer way to define it: (partial partial map (comp eval list))

no don't eval

that also won't work unless it's a macro or if the input is raw forms

(eval involves the compiler and classloading, and will be very surprising)

yeah it's fun to be able to (partial partial map) but eval is evil 😛

ah, I didn't know that! I'll look up more info on when (not) to use eval

I did consider a macro but it fails the "if you can do it without a macro, don't use a macro" test

The first rule of eval club is: never use eval 🙂

no macro necessary... you were close with the original code, but I think you should reexamine the semantics you want

oh? what's wrong with the original?

usually my input is maps, not sequences

but I want to augment the map with extra data that comes from applying a series of functions

I've found something similar to https://aphyr.github.io/tesser/tesser.core.html#var-facet useful a few times (but I've never actually used tesser)

{:firstname "Ghadi" :lastname "Shayban"}

;;;  :full-name (fn [m] (str (:firstname m) " " (:lastname m)))
;;;  .... more keys + functions

this is primarily for scenarios wherein you have functions that operate on one argument and you need to use them in a composition or transducer pipeline that needs to operate on tuples

I'm sure there's a haskellish word for it

facet is similar to the vector thing, but for maps

thanks. come to think of it I've seen this kind of thing called "project" before for map-like structures

but I think use-cases differ enough that there isn't a one-size-fits-all.

I'm surprised other people don't run into the usecase for mine more often - any time you're using pipelines that can only pass a single container and you're forced to instead give a vector or fixed sequence, basically

channels, transducer pipelines, composed core.reducer pipelines, etc

not that it's usually hard to just wrap the pre-exisitng one-arg function(s) manually, I just find it can hurt readability

reducers/tranducers is exactly what I've used facet for

yeah looking at tesser now, thanks

and yeah it's the same thing, just for positional stuff rather than keys

@hiredman ha, tesser actually probably would have improved the performance of the task I was doing that had this come up - though I did end up parallelizing it a bit with clojure.core.reducers/folder and some core.async stuff