what approach do people use for having the catch of an exception cause early termination?

How do you handle succession of I/O logic I/O logic I/O logic .... ? Logic is pure and the boundaries between I/O logic is made with data but can the code that "orchestrate" the I/O logic flow be made pure ?

@johan is it possible to push all the I/O to the perimeter in your case? i.e., load everything you need up front, then logic -> logic -> logic, then finally 'commit' at the end?

Then rather than each stage of logic resulting in I/O, it would result in a plan for I/O to be conducted later

This is often talked about as "functional core / imperative shell"

e.g., https://www.destroyallsoftware.com/screencasts/catalog/functional-core-imperative-shell

@johan178 I found using a Monadic lib like https://github.com/adambard/failjure is quite useful here. Specially the ok->>, try-all and attempt-all functions the lib provides

@toby924 I have been reading about "functional core / imperative shell" and what I don't understand is what goes into the imperative shell. Let's say I'm scrapping some data -> parsing -> more scrapping -> parsing -> validating -> save to db The functional core is all my parsing and validation logic, so everything else is part of the imperative shell ?

Yeah effectively

Push all the pieces that need I/O to the perimeter / boundary of the system

That's the imperative shell

Another way of looking at it is in terms of the hexagonal architecture / ports and adapters: https://dzone.com/articles/hexagonal-architecture-what-is-it-and-how-does-it

That talks about microservices but the principle is the same for other systems too

Thanks, I think my mental model of this kind of architecture is wrong, I struggle with the idea that during the lifespan of a "computation" the program will go back and forth from the functional core to the imperative shell

The goal is for it not to

@johan178 in your case, to achieve separation, you could have one subsystem do the scraping and then put that on a queue or a core.async channel that the parser can read, and the parser subsystem then puts its output on another queue/channel to another subsystem that saves to the db

now everything is separated and you are not going back and forth between “I/O <-> Not I/O” in the same place

I was listening to this episode of functional design in clojure https://clojuredesign.club/episode/024-you-are-here-but-why/ They propose to use two multi-method to handle the I/O and the logic, it sounds like what you are suggesting but without the Async part.

how come (binding [*out* nil] (.println System/out "oooo")) throws an NPE (in my Cider REPL at least)? *out* is not the same as System/out, is it?

it doesn’t NPE for me:

user=> (binding [*out* nil] (.println System/out "oooo"))
oooo
nil

here’s where *out* is defined btw: https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/RT.java#L183-L184

How do I construct a java.lang.reflect.Type for a generic type in Clojure? Java example gives the following: new TypeToken<Watch.Response<V1Namespace>>(){}.getType() (where TypeToken is com.google.gson.reflect.TypeToken.

Java interop question, how do I call a method that has a signature like foo(A arg, B... args) like in [AsynchronousFileChannel.open](https://docs.oracle.com/javase/7/docs/api/java/nio/channels/AsynchronousFileChannel.html#open(java.nio.file.Path,%20java.nio.file.OpenOption...))

Does anyone know how to execute commands with sudo using clojure.java.shell?