ok, so if I got this right - comp given only transducers returns a transducer - comp given only functions does function composition - comp given a mixture of transducers and regular functions doesn't work

Now I don't understand why the code above with ->> works... I just saw it as doing the same as comp but in reverse.

because ->> is a macro, does it take the forms given to it and actually "physically" put the output of the previous line as the last argument in the next form?

sort of runs partial on all the forms?

Comp composes functions full stop

Transducers are functions that take and return reducing functions

->> is purely syntactic rewriting. There's no semantics involved. (->> (+ a b) (let [a 1 b 2])) => (let [a 1 b 2] (+ a b))

I need to remember that (= ((comp (partial map inc)) [1 2]) (->> [1 2] (map inc)))

comp with a single argument is identity

((partial f a) b) => (f a b) by definition

And as hiredman said @calle ((comp f g h) x) is (f (g (h x)))

I think it's this non-currying that's tripping me up

I'm so used to ((f a) b) being the same as (f a b)

that's basically the only way I use map

just want to shout out #practicalli. truly an amazing resource for getting up and running with ring + compojure

I think I'm going to use ->> a lot...

What I'm saying is that when I see (map my-fn) in a comp and in a ->> I need to remember that they mean completely different things.

->> is not comp but reversed.

thanks for clearing things up, see you later 🙂

I wanted to change the path that aot dumps to ... seems like it doesn't like the following -- any suggestions?

{:aliases {:aot {:extra-paths ["target/classes"]
                 :main-opts ["-e" "(set! *compile-path* \"target/classes\") (compile,')"]}}}

@johnjelinek Did you make sure target/classes exists before you run that?

ya, it throws an exception

What exception?

I think it doesn't like my \ in there

You probably need , instead of space in that string

See https://github.com/seancorfield/dot-clojure/blob/master/deps.edn#L57 for example

good deal

thanks!

"(set!,*compile-path*,\"target/classes\") (compile,')"

Does that work?

needs , between forms

but then that works, except -- the clojure.core stuff doesn't get into the directory

Ah yes. That too.

not sure why the clojure.core stuff is missing

it's already been compiled

nvm ... ran -A:aot again and it got it into the directory now

AOT is evil 🙂

(we do not use AOT at work ever)

unfortunately, I need it for my stuff

Sorry man. We rely on one library that has a single namespace AOT'd. Other than that, we avoid it at all costs.

I don't know how to transpose the following without aot:

package com.myorg;

import software.amazon.awscdk.core.Construct;
import software.amazon.awscdk.core.Duration;
import software.amazon.awscdk.core.Stack;
import software.amazon.awscdk.core.StackProps;
import software.amazon.awscdk.services.sqs.Queue;
import software.amazon.awscdk.services.sqs.QueueProps;

public class HelloStack extends Stack {
    public HelloStack(final Construct parent, final String id) {
        this(parent, id, null);
    }

    public HelloStack(final Construct parent, final String id, final StackProps props) {
        super(parent, id, props);

        Queue queue = new Queue(this, "MyFirstQueue", QueueProps.builder()
                .visibilityTimeout(Duration.seconds(300))
                .build());
    }
}

Concrete inheritance? Ugh 😞

To be fair, I haven't yet figured out how to transpose this in general, but I feel like my options are either proxy, reify, or gen-class

Why is AOT evil?

Others with more experience can give more full answers, but I believe the gist of it is that even experienced Clojure developers can have a difficult time diagnosing subtle problems that can occur in some situations when AOT is used.

e.g. .class files that were compiled from different versions of Clojure source code being used, leading to code execution behavior from source code that is not what you are looking at in your editor.

I am having the most frustrating experience with ring ... I have a compojure POST route, that just pprints the request from a client I wrote. My handler is

(def app  (-> routes  wrap-json-body wrap-reload))

how would i go about writing a macro that can be called like this:

(my-macro
  [+ 1 1]
  [str "hello " 123]
  [inc 5])

['(+ 1 1)
 '(str "hello " 123)
 '(inc 5)]

Now I have slurped my input-stream manually and it yields "{\"date-range\":{\"from\":\"2019-09-10\",\"to\":\"2019-09-19\"}}" which at least according to https://jsonlint.com/?code= is valid JSON. Still when I don't slurp it (so it is not gone) and use wrap-json-body it is nil. Also wrap-json-request works fine. Can anyone help me understand this?

it works, i just needed to remove that little ' in the last line to remove double-non-evaluation ;D thanks, person who removed his/her message ^^

@lkowarschick Why not just use a function?

(defn to-lists [& forms]
  (map (partial apply list) forms))

I removed it because I believe this is the easier solution 😉

that doesn't fully fulfill my requirements, as it results in the following:

(([clojure.core$_PLUS_ 294690511 "clojure.core$_PLUS_@11909ecf"] 1 1)
 ([clojure.core$str 439674431 "clojure.core$str@1a34e63f"]
  "hello "
  123)
 ([clojure.core$inc 1883794397 "clojure.core$inc@70486bdd"] 5))

the first solution works however ;D

I see, ok 🙂

(defmacro foo [& forms]
  (let [lists# (for [form# forms]
                 (list 'quote (apply list form#)))]
    `[~@lists#]))

:thumbsup:

I don't think the generation of special names is necessary here though as the code doesn't make its way in the macro at all

better be safe than sorry i guess ;D

i've got a function that can take any type of collection (it handles maps seperately, so were talking sets, lazySeq, list, vector, etc) it does stuff to that collection and should then return the modified version as the same type as it got it. how can i achieve this? map and such turn everything into a lazySeq, so i need to somehow (into (type input) output) my result.. (<- i know that doesn't work)

I recommend Specter for this, it is specifically designed to address this issue (changing the type of the container)

https://github.com/redplanetlabs/specter

really? do i actually need a additional dependency for that? then i'd rather just (cond) it on the type..

you don’t need it, it’s just an option that’s available 🙂

so is my simplest option to write this function

(defn map-keep-type [fun coll]
  (let [mapped (map fun coll)]
    (condp #(%1 %2) coll
      vector? (vec mapped)
      set? (set mapped)
      list? (apply list mapped)
      map? (zipmap (map first mapped) (map second mapped))
      seq? (seq mapped)
      mapped)))

something like that, except it doesn’t cover sorted-set, sorted-map etc

thats why i hoped there would be some kind of into that takes types and not empty collections...

nothing like that in clojure core afaik

Hey there, would anybody be willing to help meet out setting out Emacs with Cider? Completely new to this thing and encountering a bug...

@lkowarschick I’m also a beginner so take with a grain of salt but maybe this will work nicely for you?

user=> (defn map-keep-type [fun coll] (into (empty coll) (map fun coll)))
#'user/map-keep-type
user=> (map-keep-type #(+ % 1) [1 2 3])
[2 3 4]
user=> (map-keep-type #(+ % 1) #{1 2 3})
#{4 3 2}
user=> (map-keep-type #(+ % 1) '(1 2 3))
(4 3 2)

Only problem is that Lists will be backwards 😕

uhh i didn't know emptyexists, that shouuuld work (i'll reverse lists manually)... ill do some testing, thanks ;D

anyone saw this error recently? https://github.com/danielsz/meyvn/issues/5

I can't send my pacakge to Clojars

@jiyinyiyong some others with issues with clojars. perhaps related?

turned out they didn't figure out a solution. And the problem is not Meyvn specific.

@jiyinyiyong for what it's worth, my issue with Clojars was resolved

In Haskell we only need to type :t function_name on GHCI to see the type of output and inputs of this function. Can we do the same in Clojure’s repl? I only could do this with types like String, Long by (type 10) or (type "aa") but it doesn’t work with functions.

no

clojure doesn't have a static type system you can query type information from, what the type function returns is the runtime jvm type of a thing

you may want to use doc

On the cli, rebel-readline can do that. Other tools (Emacs CIDER, IntelliJ Cursive) can provide this

user=> (doc +)
-------------------------
clojure.core/+
([] [x] [x y] [x y & more])
  Returns the sum of nums. (+) returns 0. Does not auto-promote
  longs, will throw on overflow. See also: +'
nil
user=>

as @alexmiller suggests there are some extra tools that you can use that will do things like displaying arglists for functions as you type

Just searched rebel-readline on github and looks great. Thanks! And i love this (doc ) will help me a lot!