Clojurians Log v2

Всем привет! Некоторое время назад наткнулся на канал Timothy Baldridge на ютубе с туториалами https://www.youtube.com/channel/UC6yONKYeoE2P3bsahDtsimg/videos Заинтересовался, но стоит денег 💸 Решил потратиться, купил, посмотрел, про core.logic понравилось, и про transduce Но ситуация с тем, что и эти видео платные, плюс, например, lambdaisland тоже работает по подписке — меня очень печалит. И так в кложу неофиты не приходят, так тут еще и туториалы платные, ужс какой-то. В тредике ссылка на Я.Диск, со всеми видео с канала, кому интересно, пользуйтесь!

https://yadi.sk/d/FLtrKRdy3PgM9P

на youtube есть 2 недели триала, или вроде того ну и как бы человек старался - можно поддержать

Ну кто хочет, пусть поддерживает. А кто не хочет -- пожалуйста, смотрите.

В тему видео курсов, есть еще такой ресурс: https://purelyfunctional.tv/courses/understanding-re-frame/

сколько там гигов?

Вот я не пойму, зачем распространять. Ты же нарушаешь соглашение. Тебя же никто не просил об этом. И деньги ты все равно не вернешь.

Из ложно понимаемого альтруизма.

боже, там 3.99 в месяц.

Странно, когда за курсы берут деньги в месяц. Дополнительные поборы тугодумов и занятых? 🙂

Нынче везде подписка, и в общем-то это правильно.

В налоговую когда приходишь к инспектору, он тебе тоже делает подписку на их газету.

Но там rent явление частое, поэтому для них это нормально.

а есть какой-нибудь приличный способ делать что-то вроде такого?

(with-conn 
  (fn [conn]
    (foo conn))

(with with-conn conn
  (foo conn))

это как способ прокидывания зависимостей?

не совсем

изначально я хочу делать после тестов rollback и в clojure.jdbc не получается сделать декоратор над datasource по этому пробрасывается функция with-conn

а, вот что тебе нужно

ну и бывает желание сделать что-то вроде руби блоков но тут уже руби головного мозга)

(defmacro with-trx-test [& body]
  "Like with-trx, but rolls back the top-level transaction."
  `(conman/with-transaction [*db*]
     (jdbc/db-set-rollback-only! *db*)
     ~@body))

этот макрос откатит транзакцию по выходу, неважно был эксепшен или нет

пойду почитаю про db-set-rollback-only!

только замени conman/with-transaction на jdbc/with-db-transaction

https://github.com/funcool/clojure.jdbc/blob/master/src/jdbc/core.clj тут нет его

а тут есть https://clojure.github.io/java.jdbc/#clojure.java.jdbc/db-set-rollback-only!

понятно

как откатывать - не суть

(воскл. знак на конце — часть ссылки)

делают ли что-то вроде такого?

foo do |x|
  bar x
end

foo( x => {
  bar(x)
});

просто беда с выравниванием

(with-conn 
  (fn [conn]
    (foo conn))

конечно, ты можешь написать макрос, который делает (let) для какого-то символа, и тогда все тело внутри может на него ссылаться

это все понятно, что могу может что-то принятое есть?

что-то вроде with-open

но он тут не подходит

я не до конца пойму, что тебе нужно, но макросы вида (with-something <variable>) очень распространены

например, извлечь какие-то данные, забиндить их к переменной и выполнить код перед выходом из макроса

foo( x => {
  bar(x)
});

(foo (fn [x]
  (bar x))

а что делает этот код вообще?

да просто конструкция

var assert = require('assert');
describe('Array', function() {
  describe('#indexOf()', function() {
    it('should return -1 when the value is not present', function() {
      assert.equal(-1, [1,2,3].indexOf(4));
    });
  });
});

просто в js принято так делать, и отступы нормально выглядят

а в clojure так не принятно

и пример

(foo (fn [x]
  (bar x))

то есть все, что мы обсуждали — суть холивар из-за скобок?

как передать анонимную функию последним аргументом?

причем тут холивар?

из-за отступов

эм (foo (fn [x] (bar x)) и никаких проблем с отступами

да, а теперь там не один bar, а десяток

(foo (fn [x]
       (bar1 x)
       (bar2 x)
       (bar3 x)
       (bar4 x)))

(foo
 (fn [x]
   (bar1 x)
   (bar2 x)
   (bar3 x)
   (bar4 x)))

и теперь

foo(x => {
  bar1(x)
  bar2(x)
});

первые 2 ИМХО выглядят как-то не очень

(defn xx [x] ...)
(foo xx)

ну да)

я больше вариантнов не занаю по этому и спаришваю, может еще что-то есть

не пытаться заставить кложу выглядить как js|ruby?

согласен

но какая есть удобная альтернатива?

альтернатива чему?

(foo (fn [x]
       (bar1 x)
       (bar2 x)
       (bar3 x)
       (bar4 x)))

https://clojurians.slack.com/archives/C050HE28Y/p1510669774000176

чем не нравится?

разбивает логику

хз

ну условно

(let [body (fn [conn]
                    (foo1 conn)
                    (foo2 conn))]
   (transaction conn body))

и что не так?

у меня такого кода куча

понятно

(transaction conn #(do (foo1 %) (foo2 %)))

@kuzmin_m так лучше отформатировано ?

оно в длину растет

представь что их 10

(transaction conn #(do (foo1 %)
                       (foo2 %)
                       (foo3 %)
                       (foo4 %)
                       (foo5 %)
                       (foo6 %)))

отступы большие

т.е. не принято делать вот так

(transaction conn #(do 
  (foo1 %)
  (foo2 %)
  (foo3 %)
  ...
  (foo6 %)))

можно сделать макрос что бы было вот так

(with transaction conn
  (foo conn)
  ....
  (foo10 conn))

было

(transaction conn #(do (foo1 %)
                       (foo2 %)
                       (foo3 %)
                       (foo4 %)
                       (foo5 %)
                       (foo6 %)))

(with transaction conn
  (foo conn)
  ....
  (foo10 conn))

может уже есть такой макрос в какой-нибудь извесной либе, только называвается по другому и работает более clojure-way

есть же куча fn->, fn+>, ~>, +> и подобные штуки, которые похожи на ->

juxt?

(transaction conn (fn [tx]
                    (let [a (foo1 tx)
                          b (foo2 tx 123 "foo")
                          c (+ a b)
                          ...]
                      (foo10 tx c))))

тут идея в том, что тело может быть каким угодно

скорее всего тут или смириться или найти/написать макрос

вопрос в том, как обычно это делают

когда было много вызовов я ещё понимал что ты хочешь, а по этому нет

есть фунция transaction

она принимает коннект

и принимает коллбэк

в коллбэк передает транзакцию

после вызова коллбэка коммитит транзакцию

пример условный

может быть что угодно

а в коллбэке может быть все что угодно

@akond яснее?

или нет?

то есть для тебя главное закрыть транзакцию после отработки всех кишков?

давай абстракно

есть нечно, что принимает коллбэк

и это нечно что-то делает до и после вызова коллбека

в коллбэк передается какое-то занчение

одно

что-то типа обёртки?

(def wrapper [callback]
  (do1)
  (callback value)
  (do2))

(wrapper (fn [value]
           (do-something value)))
                                  

wrapper может еще какие-то аргументы принимать, до коллбэка

(wrapper 1 2 3 (fn ....))

т.е. в js|ruby это элементарно

в clojure выглядит страшно

может это как-то иначе делается?

вроде не страшно. как по мне.

doto

(def wrapper [callback]
  (do1)
  (callback value)
  (do2))

(wrapper (fn [value]
           (do-something value)))

и это do-something может быть из многих вызовов, с let и прочими конструкциями

вернее вместо do-something

Самое короткое, наверное, будет так

(transaction (db/req1) (db/req2))

да, жаль, что мы так и не дождались стрима из #attendify

стрима нет, на кложе проще писать, чем настроить стрим 🙂

А сегодня ивент был, да? :opieop:

угу, еще идет, до сих пор

должна быть запись

Вот слайды https://speakerdeck.com/kachayev/clojure-at-attendify-2nd-ed