Смотрите, какая штука: https://lwn.net/Articles/655437/ -- структуры данных Clojure на неё идеально ложатся.

@yogthos Из Closure Library тебе что-нибудь пригодилось? Или там только client-side штуки?

Отдельное спасибо Николаю за его упорство в развитии комьюнити и всем участникам хенгаута

>Когнитект куплен гуглом? оракл купил датомик, во былоб круто

За две недели все догадки уйдут за горизонт событий Слака.

Рич женился

Как, опять?

а он уже?

чорт, шутка не зашла

через две недели выйдет сюрвей просто и там кложаскрипт выстрелил 🙂

а просто кложу закрывают?

ага 🙂

(deftype RAtom [^:mutable state meta validator ^:mutable watches]
   IDeref
  (-deref [this]
    (notify-deref-watcher! this)
    state)

подскажите плиз начинающему , для чего ^:mutable

и почему -deref с черточкой

с черточкой, потому что

(defprotocol IDeref
  "Protocol for adding dereference functionality to a reference."
  (-deref [o]
    "Returns the value of the reference o."))

а почему там с черточкой - наверное по конвенции, типа "приватный", как в питоне и _

да , у меня вопрос именно почему изначально он приватный

(defn deref
  "Also reader macro: @var/@atom/@delay. Returns the
   most-recently-committed value of ref. When applied to a var
   or atom, returns its current state. When applied to a delay, forces
   it if not already forced. See also - realized?."
  [o]
  (-deref o))

ну он не приватный, это же не defn-

все я понял

спасибо

а ^:mutable ?

это 100% стилистическое, найти бы только обосновывание

если сильно захотеть то можно и так почитать 🙂 https://clojurians-log.clojureverse.org/clojure-russia/2017-01-10.html

The leading dash is a convention in two places:

- gen-class methods implemented by Clojure functions (e.g. -main)

- low-level method implementations of built-in protocols in ClojureScript

The dash has no special significance as far as the compiler is concerned, it's just part of the name.

подскажите плиз начинающему , для чего ^:mutable

подозреваю, что это хинт для транзиентов, но не нашел пока подтверждения

@andre

(deftype ES6Iterator [^:mutable s]
  Object
  (next [_]
    (if-not (nil? s)
      (let [x (first s)]
        (set! s (next s))
        #js {:value x :done false})
      #js {:value nil :done true})))

может это просто автор реагента делает для себя, (def ^{:private true :const true} cache-key "reagReactionCache")

вот такое есть например

кстати прикольно он хранит в js обеъкте функции кеш по этому ключу 🙂

(aset o cache-key (assoc m k r)) где о - (fn o [] ())`

подскажите, уважаемые, какой-нибудь нормальный способ делать из последовательности вида [A B B A A B A B]

разбивку

разбивку [[A] [B B A] [A} [B A] {B}]

другими словами, к элементу А присоединяются предшествующие элементы Б

reduce

можно примерчик?

хитрый какой

я думаю loop/recur + связку take-while #(= % A) take-while #(= % B)

с циклом и transient аккумулятором в енм я сделал, но как-то все это коряво

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

group-by не разбивает A A

или это partition-by точно не помню 🙂

в регексах будет что-то вроде

(B*A)(B)

ну потом пройдись еще раз и раздели листы где болше одного а

(reduce
  (fn [r i]
    (cond
      (not (seq r))
      (conj r [i])

      (and (seq r)
           (= :A (last (last r))))
      (conj r [i])

      :else
      (let [idx (-> r count dec)]
        (update r idx conj i))))
  []
  [:A :B :B :A :A :B :A :B])

[[:A] [:B :B :A] [:A] [:B :A] [:B]]

[:A :B :B :A :A :B :A :B :A :B :A :B :B :B :A :A :B]
->>
[[:A] [:B :B :A] [:A] [:B :A] [:B :A] [:B :A] [:B :B :B :A] [:A] [:B]]

хотелось бы для последовательностей

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

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

ты ж на векторах вопрос задал

кстати, да

может так и ловчее будет

хотя у меня через loop recur почти так же

можно сказать, я успокоился 🙂

спасибо за участие

а есть какой-нибудь алгоритм, чтобы посчтитать количество комбинаций монет дающих определенную сумму? 1. есть определенный пулл монет: [1 1 5 5 5 10 10 25 25 25 25 50] 2. есть число: x 3. нужно получить все комбинации монет из пула, в сумме дающие <= x

можно

(let [coins [1 1 5 5 5 10 10 25 25 25 25 50]
      x 26]
  (->> (range (count coins))
    (mapcat #(clojure.math.combinatorics/combinations coins (inc %)))
    (filter #(->> % (apply +) (>= x)))))

;;=> ((1) (5) (10) (25) (1 1) (1 5) (1 10) (1 25) (5 5) (5 10) (10 10) (1 1 5) (1 1 10) (1 5 5) (1 5 10) (1 10 10) (5 5 5) (5 5 10) (5 10 10) (1 1 5 5) (1 1 5 10) (1 1 10 10) (1 5 5 5) (1 5 5 10) (1 5 10 10) (5 5 5 10) (1 1 5 5 5) (1 1 5 5 10) (1 5 5 5 10))

а то если монет много, а x - маленький - куча вычислений зря

knapsack problem же, NP-полный.

Хотя нет, там есть вторая штука, которую нужно максимизировать, а здесь только все варианты перечислить.

@misha Просто перебором с мемоизацией. комбинации-монет[x, [1 1 5 5 5 10 10 25 25 25 25 50]] = [50]∗комбинации-монет[x-50, [1 1 5 5 5 10 10 25 25 25 25]] ∪ [25]∗комбинации-монет[x-25, [1 1 5 5 5 10 10 25 25 25]] ∪ [25]∗комбинации-монет[x-25, [1 1 5 5 5 10 10 25 25]] ∪ ... ∪ [1]∗комбинации-монет[x-1, [1]] ∪ [1]∗комбинации-монет[x-1, ∅]. Второй аргумент - это всегда subrange от начала до N, так что его можно закодировать числом. ∗ означает "прицепить префикс слева ко всем последовательностям справа".

кароче перехачивать clojure.math.combinatorics/combinations для поддержки мемоизации?

Комбинаций будет 2^N, а здесь меньше, и решается просто по алгоритму выше рекурсивной функцией.

ща перепишу, чтобы в глаза помещалось

Z[x, [a1 a2...aN]] = [aN]∗Z[x-aN, [a1 a2...aN-1]] ∪ [aN-1]∗Z[x-aN-1, [a1 a2...aN-2]] ∪ ... ∪ [a2]∗Z[x-a2, [a1]] ∪ [a1]∗Z[x-a1, ∅]

Идея очень простая: есть рюкзак размера N. Есть вещи. Мы берём вещь a1, и решаем задачу "есть рюкзак размера N-a1, как туда можно остальное поместить?", после чего приписываем к результату a1. После этого вещь a1 выкидываем, берём вещь a2, и решаем задачу "есть рюкзак размера N-a2, как туда можно остальное поместить?"...

слушай, а combinations не так сделаны? там правда только 1 длинны комбинации, значит оно не умеет переиспользовать длинне/короче посчитанные комбинации

https://github.com/clojure/math.combinatorics/blob/master/src/main/clojure/clojure/math/combinatorics.cljc#L177

Нет, combinations сделаны не так.

Это просто из комбинаторики следует 🙂

combinations - это решение той же задачи, где рюкзак бесконечного размера.

Поэтому они всегда выдадут 2^N вариантов.

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

Эээ. Как определяется длина?

а потом было бы еще круче, если бы посчитанное можно было бы подхачить дешевле полного пересчета, для нового пула

в моем случае есть вообще 3 измерения: ширина, вес, максимаьное количество

Тогда смотри выше определение Z. Если менять пул, то тогда сделать оптимизацию "второй аргумент - число" не получится, но мемоизированный результат можно использовать.

а не как с монетками - только 2: максимальное количество и вес

ок, а есть у этого какое-то название выделенное?

почитать

Это всё knapsack-like problems.

https://en.wikipedia.org/wiki/Knapsack_problem ?

Не в оригинальном виде, а какой-то вариант, да.

о, ништяк, спасибо

См. Multi-dimensional knapsack problem там в конце.

вообще, я так смотрю, что рюкзак-проблема - это именно подогнать комбинацию "под ответ", типа под заданную сумму

я вот выбираю между: "посчитать все комбинации, и потом кверить по хешмапам с результатами" и "считать каждый раз".

мне кажется, мне подходит первое гораздо больше. только вот пересчитывать дофига, и каждый раз, как только "пулл монет" изменяется

The target is to maximize the sum of the values of the items in the knapsack so that the sum of weights in each dimension {\displaystyle d} d does not exceed {\displaystyle W_{d}} W_{d}.

это типа "получить все комбинации удовлетворяющие что-то там, и потом самую четкую из них выбрать", да?

1. есть сет P = [1 2] 2. нужно получить все уникальные комбинации длинной 1- (count P) (без учета порядка [1 2] = [2 1]): [[1][2][1 2]] 3. можно ли получить комбинации для нового сета P1 = [1 1 2] дешевле, чем заново всё пересчитать? [[1][2][1 1][1 2][1 1 2]]

Можно, если заполнять мапу. [N [1 2]] -> #{#{1} #{2} #{1 2}}, [N [1]] -> #{#{1}}.

Тогда при подсчёте [1 1 2] можно взять уже готовое значение для [N [1 2]]

Мапа раздуется со временем, правда. Зато быстро будет.

ну тут без раздутия не обойтись, да.

Внутри сета не сеты, если можно повторять. Но это уже детали.

в целом динамическим программированием такие вещи хорошо оптимизируются обычно. вроде и императивщина и не кложа вей, но на fp тоже пишут dp

@dottedmag I think I used b64 serializer from it

@andmed функция Z выше с мемоизацией - это классический DP-алгоритм.

ну да.

скажем больше примитивный dp алгоритм

самая что ни на есть стейтная императивщина, которая проходит незамеченной потому как в core))

почему императивщина, когда это обычная свёртка?

Рекурсивная.

разве стейт в функции не хранится?

Технически - да, а фактически это всего лишь вычисление чистой функции Z(x, y).

Т.е. существенно умный компилятор (tm) такое может сам реализовать.

Кэширование результатов чистой функции - не императивщина, так как нет способа различить наличие и отсутствие кэша, кроме как по количеству тепла, выделенному компьютером при вычислении.

эм.. не уверен что понял что ты сказал)) но когда я смотрел алгоритмы DP то как раз обратил внимание по подходу это принцип противоположный FP: как раз вводится общий стейт для рекурсивной процедуры, как раз то от чего FP вроде как абстрагируется

Это один из возможных вариантов реализации.

Табличку нарисовать и заполнять её.

Но даже так -- это всего лишь мемоизация значений чистой функции.

Например, несколько потоков может эту табличку заполнять совместно, и ничего не сломается, пока каждая операция обновления ячейки атомарна.

Так что императивного ужаса – shared mutable state – не наблюдается.

Есть shared accreting state, а это совсем другое дело.

ну собственно несколько месяцев назад я сюда постил кложе код решающий задачу упаковки методом DP. жаль архива нет (его ведь нет?) посмотреть нельзя. но помню меня поразил он. потом гуглил автора: русский, сейчас в панасонике чтото-там волновое на функциональщине пишет.. во как

Есть архив: https://clojurians-log.clojureverse.org/clojure-russia/index.html

ой. спасибо тебе!

@nicola Clj->C: https://www.youtube.com/watch?v=yGko70hIEwk

Хаха, они делают суперкомпиляцию. Привет РЕФАЛу.

может через 2 недели как раз анонсируют CLJ <> C муахаха, вот будет тема. Хотя хз зачем :thinking_face:

Версии множатся 🙂

Был же проект clojurec

Типа даже компилилось под айос и под андроид было в планах

https://twitter.com/Clojurewest/status/821414313906814978

Ричу со Стю больше нечем нас порадовать

Ни приходилось сталкиваться с задачей сохранения позиции скроллирую в компонентах контейнера при переходе назад(по истории переход юзера)

?

Такой болезнью много аппов реактовских страдает

Что подсказывает, что придется писать ручками

>Такой болезнью много аппов страдает fixed

Clojure on Go VM

У Go есть VM?!

> Michael Nygard ‏@mtnygard Jan 16 > Oh man... cool stuff coming but I can't announce it for 2 weeks. Aargghh. > Michael Nygard ‏@mtnygard 6h6 hours ago > I’m having fun getting fitted for a kilt and jacket. All new to me.