I used emacs' inferior python repl with python, but it definitely wasn't idiomatic. I ended up writing things in an odd style compared to others just so I could have a REPL based workflow. there's also some other things about python that don't really make a REPL based workflow easy.

I think it's definitely fair to say that the Clojure/Lisp REPL is unlike any other language's REPL.

Probably the closest equivalent is the JS console in a browser when running a single page app?

It's definitely the best live ecosystem that I've used a lot

I know people don't consider excel "real" programming, but it's got immutable values, a live environment, and reactive/flow based paradigm

True, true. My wife would probably agree with you as she's quite the Excel hound 🙂

I'm generally interested in the future of programming and I think there's a lot of room for something more flexible than excel, but with a similar approachability and learning curve

I thought Aurora looked very interesting, from Chris... <blank> the guy who created LightTable...

Chris Granger

old guy's brain forgets names

I am semi-luddite here, I am sure, but highlighted paren-matching and auto-indent via pressing the tab key are all I ever use that are "Lispy", even in Emacs. slurp/barf/etc. I consider nice-to-have, but beyond my inertia level to bother with 🙂

Yup. I use wrap-with-( (or [ or {) a lot more than slurp/barf but I do use those occasionally. And I use expand-selection a fair bit (for copy/cut/auto-indent).

I'd be very interested to see what editor features Rich and Stu use. I know they both favor a basic setup. I think both use inferior-mode and a plain REPL.

fine-grained iterative compilation

Yeah... and perhaps most importantly, totally under user control, rather than at the whim of the compiler's algorithm 🙂

This, precisely, is why I prefer per-file reloading in Python rather than "sending a function definition to a Python process", which the Python package for Emacs supports. Python doesn't delineate the unit of computation as clearly as Clojure

I would recommend using raw Lettuce or Jedis. No need to use a wrapper. You can follow the Java tutorials directly.

you are using symbol pair# generated in (fn [pair#] … form in the context of ~(first pair#) where it is unknown

simply replace ~(first pair#) with (first pair#)

Thanks @U04V4KLKC. I suppose this will give me the first element of the pair unevaluated, though, and I would like to evaluate it, so that I can filter (hence the keep) by truthy vals. How would I achieve that?

a pair could be ((and x y) (do-sideeffect)), like in conds

(in this case, wrapped in a list to keep them together)

coulde you give me an example of input for that macro?

(something (and false true) (prn "first") true (prn "second") nil (prn "third"))

In this case, I’d like to keep only (prn "second")

But since '(and false true) is a truthy val (a collection), I also keep that with the above code.

I was experimenting with something like a cond that ensure that exactly one predicate is truthy, which is why I’m trying to find all of the truthy predicates. I want to count them.

(defmacro something
  [& forms]
  `(let [pairs# (->> '~forms
                     (partition 2)
                     (keep (fn [pair#]
                             (when (eval (first pair#))
                               (second pair#))))
                     (into []))]
     pairs#))

(something (and false true) (prn "first") true (prn "second") nil (prn "third"))
=> [(prn "second")]

you can do this without eval - the key is to remove the side effecting part at expansion time

(defmacro something
  [& forms]
  `(count (filter identity
                  ~(mapv first (partition 2 forms)))))

@U051SS2EU cheers 🙂 Let’s say that something is like a cond that evaluates those right hand sides whose left hand sides are truthy - that is, all of the right hand sides, not just the first. What I wanted to do with the code above was to collect all of the right hand sides and then evaluate them sequentially. Being accustomed to fns and not macros, I just went ahead and used gensymed symbols as I would normal symbols, but I understand that it gets more involved in macros. How would you accomplish what I describe?

(ins)user=> (something (and 1 false) (println 1) false (pri
ntln 2) true (println 3))
3
nil

(defmacro something
  [& conditions-actions]
  (let [clauses (partition-all 2 conditions-actions)]
    (cons 'do
          (for [[condition action :as clause] clauses]
            (if (= 1 (count clause))
              condition
            `(when ~condition ~action))))))

maybe I still misunderstand - that will run all actions where condition is true

with some elaboration, it could error if two conditions were true, and run none of the clauses or only the first or only the last

the hard thing with macros (to me) is to internalize the fact they are just a data transform before compiling, and segregating what needs to be executed while compiling from what needs to be emitted - note how in this example I try to clarify the distinction by embedding pieces of quoted forms inside normal data ops

or perhaps doing that makes it worse LOL

I think what you are doing seems a sensible way to approach it, to isolate the part that is different from the rest.

I think I struggle with exactly what you are describing, separating the code transformation from the emitted code - and also, since I’m just starting out with macros, understanding when to stay on either side of the boundary when using specific functions/macros/reader macros.

The rules are quite simple, but just counterintuitive to humans in my experience. Something you quote becomes part of the compiled, something you don't quote instead generates the thing compiled.

alternatively, one could say that your macro generates the thing compiled, and the simplest version of that is to quote a list and return it to be compiled

simple, but difficult to grasp once you leave the simplest cases

Yeah, the simple cases clicked almost immediately, and it felt enticing. And then, once I started mixing syntax quote, unquoting and gensym, boom! Things stopped making sense 🙂

I mean, I believe I understand each of those things separately, but not entirely how they mix (and don’t mix) yet.

Thanks a lot @U051SS2EU, this helped me greatly! 🍻

I like this version, too, but I don’t understand why I don’t have to add # to the end of condition and action. They are, after all, nested inside a syntax-quoted form - but, of course, an unqote-spliced form, too, which I guess negates the outer syntax-quoting when it comes to requiring gensyming symbols?

(defmacro something
  [& conditions-actions]
  (let [clauses (partition-all 2 conditions-actions)]
    `(do ~@(for [[condition action] clauses]
             `(when ~condition ~action)))))

the for is not inside `, so needs no gensym

the @ plus ` do the same thing as the original cons and ', with more~ different verbosity

Yeah, it’s same same. Except that I don’t understand that detail. The for is inside ` from my perspective, just not directly inside.

the for uses ` repeatedly, but is not inside it

Maybe we’re talking past each other. There’s a (do which surrounds the for`. That looks like “inside” according to normal Clojure code conventions to me.

in my version there is no outside the for, and 'do` only quotes that single symbol

Yes, and that version I understand (well, actually I’m wondering why the quoted do does not shadow a (defn do that I create in the same namespace, but that’s a different matter)

But in my version, I do (heh) have a syntax quote surrounding the for.

Yet it does not require the destructuring symbols to be gensymed.

do does not exist, it's a compiler feature, if you had a var called do it would not get used in call position (don't make a var called do)

(ins)user=> do
Syntax error compiling at (REPL:0:0).
Unable to resolve symbol: do in this context

it is outside the ` again thanks to ~@

Another detail learned 🙂

(ins)user=> (def do +)
#'user/do
(ins)user=> (do 1 1)
1

that's why you should never call anything do

but yeah, my code does assume the reader knows do is special

Ah, so it was as I suspected - the unquoting negates the quoting. Sounds obvious when I write it out like that… But not when fiddling with gensymed symbols.

it's not just negation - it's like each ` pushes to a stack, and each ~ pops, and when you reach empty stack there's no quoting

I do not recommend writing code that requires keeping track of that stack :D

Good point!

I guess that’s why I liked your version as well, because it squished the stack manipulation close together for an easy overview, and isolated them to a leaf node, as well.

a compromise:

(cons `do (for [... ...] `(...)))

hehe. yeah

or even

(for [... (cons `[do] conditions-actions)] `(...))

(that requires my modification which allows either one or two element inputs in the iteration)

I liked that one, it was nice.

BTW, I avoid shadowing/replacing symbols used in Clojure core functions/macros/special whatevers myself, as well. I really dislike what I see some people do sometimes, like

(:refer-clojure :exclude [+ * and assert or cat def keys merge])

(That’s a cheeky stab at clojure.spec.alpha, by the way…)

… But I’ve seen other people do stuff like that, as well, and I don’t understand it. I know naming is one of the hard problems of programming, but is it hard enough to justify recycling names? 😄

Is it this one? https://github.com/stuarthalloway/presentations/wiki/REPL-Driven-Development

Running With Scissors? https://youtu.be/Qx0-pViyIDU There's stuff on 'Rich Comments' and tests at 20 mins in

"Running With Scissors?" is along the same lines, but the video I'm thinking of had a live coding portion (where the presenter was demonstrating live in a repl)

@UHK8B8STX hmm no it wasn't that one, like I said , I remember the video having a live demo of a buffer + repl as the presenter demonstrated their workflow.

That should be doable in one pass over the coll. Are you looking for quick as in a nice function in core, or quick as in execution time?

As for nice function in core, I don't have one off the top of my head, sorry.

just a proper functional way do it that won’t tear my hair out.

Ah, I guess I could reduce and do an early return when the current and last value match the same predicate.

Something like

(reduce 
  (fn [prev curr]
    (if (a-certain-symbol? prev)
      (if (= prev curr)
        (reduced false)
        curr)
      curr))
  (first coll)
  (rest coll))

Yes, exactly. 😄

(->> "ABBCCCCADTGGH" (partition-by identity) (map first)) ;; => (\A \B \C \A \D \T \G \H)

And I always forget about dedupe

So just (= (dedupe coll) coll) will tell you if there are consecutive dupes

Nice!

@U093SNDV5 wouldn’t that only work when comparing values by equality, not any pred, e.g. symbol?

(= (dedupe '[a b c]) '[a b c]) if adjacent symbols are not allowed, then this will not register that

Ok, this seems to work and I think it will be close to linear time, right?

(defn- non-adjacent
  "Return `coll` if no adjacent values satisfy `pred`."
  [pred coll]
  (reduce (fn [coll val]
            (if (and (pred val)
                     (pred (peek coll)))
              (reduced nil)
              (conj coll val)))
          (empty coll)
          coll))

(non-adjacent symbol? [1 'a 2 'b]) ;=> [1 a 2 b]
(non-adjacent symbol? [1 'a 'b 2]) ;=> nil

OK. I understood "Anyone have a quick way of determining that certain values are not adjacent in a coll" to mean that no two adjacent values in a sequence can be equal...

Slightly related: https://github.com/weavejester/medley/issues/47 It's more useful for parsing than validation

@U093SNDV5 yeah, re-reading my original question, it is a bit unclear what I meant. Sorry about that.

@U04V15CAJ so it’s like split-with, but can split into more than two collections? Seems useful.

yeah

@U4P4NREBY The split-when function is lazy btw, so you could short-cirtcuit when you find an error

(defn ok? [pred xs]
  (->> xs
       (partition-by pred)
       (some #(and (pred (first %)) (next %)))
       not))

how about this?

(defn ok?
  [pred xs]
  (empty? (filter #(apply pred %) (map vector xs (rest xs)))))

@U15RYEQPJ

(ok? symbol? ['a 'b])

Execution error (ArityException) at cuphic.core/ok?$fn (form-init9008355435483086642.clj:3).
Wrong number of args (2) passed to: clojure.core/symbol?

@U093SNDV5 that does seem to work.

yeah, it’d have to be (ok? #(and (symbol? %1) (symbol? %2)) ['a 'b])

if you only want that sort of thing you can do

(defn ok?
  [pred xs]
  (empty? (filter true? (map #(and (pred %1) (pred %2)) xs (rest xs)))))

hmm, what about something like (defn ok? [pred xs] (empty? (keep (partial apply pred) (partition 2 1 xs)))

oh, with the and construction above...

final answer

(defn ok?
  [pred xs]
  (->> xs
       (partition 2 1)
       (keep (fn [[x y]]
               (when (and (pred x)
                          (pred y))
                 ::not-ok)))
       (empty?)))
#'user/ok?
(ins)user=> (ok? even? [1 2 3 4])
true
(ins)user=> (ok? even? [1 2 2 3 4])
false

SICP hands down

The Little Schemer (goes with SICP)

The Little Schemer is my favourite book on just programming and thinking like a programmer. There’s also more in the series. A Philosophy of Software Design by John Ousterhout is a bit OO-focussed but is excellent (but also controversial - I’ve read a few articles attacking it - that’s maybe what makes it interesting!) Clojure-wise: Joy of Clojure. I received my copy after working professionally in Clojure for a year. But I enjoyed reading it nonetheless (selfish reason being that it confirmed that a few practices I was following independently were probably decent) I’d also recommend Elements of Clojure as a fun and short read. My main reason to recommend these books is that they all offer something a bit different from the standard tomes on programming languages and best practices.

How do you avoid using def not starting ig/init when load REPL and overwrite def value when reload ns? If this will be overwritten without halt before, then it wouldn’t work, because port will be blocked. Unless I don’t see obviously solution here it is still simpler for me, than playing with this issues.

It can be done alter-var-root but I would say this is simpler

If I want to manipulate the system in the REPL, I'll def it in a comment, just for use in the REPL. Reloading that namespace wouldn't overwrite it, because it's not in the code, it's in a comment.

For normal use, my -main sets up the system and passes it into the call chain -- so there are no globals.