почему документация говно?

в смысле устарела?

или просто misleading

@qnikst это конечно полезнее

т.к. её подробно никто не писал она неконсистентная

в смысле прочитать то можно, но скорее всего это мало что даст

все плохо!

а будет бардак в голове

да

:/

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

если не пропадёт обещал поразбираться с документацией

сейчас попробую перечитать вопрос и ответить

книжка марлоу, которая про concurrency?

там вроде последняя глава только про CH

ну там очень хорошее описание

тем более что другие главы тоже полезны

давай я про задачу ещё спрошу, я не очень понял

что именно и где мы хотим запускать и делать

.. как быстрый ответ скорее всего что-то руками придётся писать, но не много

мы хотим чтобы у нас на node1 и node2 (для простоты пусть два) был стейт (или кэш). Мне надо чтобы стейт обновлялся и на обоих узлах при входящем событии (когерентность их между собой можно пока отложить). То есть первое что приходит в голову, это держать на каждом узле по процессу (или пулу процессов), которые получают эти события через receive или канал и обновляют стейт. С другой стороны, хочется пользоваться более высокоуровневыми вещами, типа call/spawn.

мда, сбивчиво

в новые процессы нужно передавать весь стейт или они могут как с ets или как его там работать?

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

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

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

тактак

смотри, на ноде делаешь процесс

используешь register и регистрируешь его на ней

Вечер в чат

http://haskellbook.com/ - кто-нибудь смотрел уже?

замыкание которое ты посылаешь на ноду - будет делать whereis, и общаться с этим процессм

ага

http://haskellbook.com/ - кто-нибудь смотрел уже?

норм книга, а аллен чудак на букву м (это моё личное мнение близк не принимать)

норм книга, а аллен чудак на букву м (это моё личное мнение близк не принимать)

Угу, спасибо

ага

далее, есть варианты

1. ты просто посылаешь этому процессы GetFoo, UpdateBar и какой-то честный протокол

это совсем безопасный вариант полностью в d-p

да, это первое что пришло в голову

2. ты посылаешь запрос ShareStateToMe Pid, и от отправляет тебе в ответ какую-нить IORef/STM, несериализованное значение

там в unsafe есть, и где-то в extras хэлперы

unsafe непедагогично

это не очень безопасно и один небольшой unsafe кусок будет

если тебе нужен большой и главное мутабельный стейт, то этот путь норм

дальше

а, понял, то есть внутри узла заставлять их общаться, пересылая ссылку, без сериализации?

есть совсем грязный вариант

угу

это если аккуратный вариант медленно или не работает (мутабельность)

ясно

и самый грязный: foo :: MVar MonoType {-# NOINLINE foo #-} foo = unsafePerformIO $ newMVar ""

но так лучше не делать :)

если только совсем уж приспичит

я думаю, пойду по варианту 1 :)

угу

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

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

один воркер со стейтом немасштабируется

то есть в реальности я не буду один процесс держать на узле для обновления стейта

в платформе вроде есть

но я бы сам написал

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

понятно, что просто round robin какой-нибудь и все

ну я не очень знаю задачу

так что сказать не могу

если что work-stealing делается просто

ERROR: S client not available

вроде у WT в блоге было

http://www.well-typed.com/blog/74/

если не ошибаюсь

о, круто, спасибо

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

спасибо

к. если что пиши

ага

Привет, что то туплю, посчитал бесконечный список чисел Фибоначчи, Prelude Control.Applicative> fib = 1:1:(map (\(x,y) -> x + y) $ zip fib (tail fib)) Prelude Control.Applicative> take 10 fib [1,1,2,3,5,8,13,21,34,55]

а теперь надо посчитать последовательность вида a[k] = a[k-1] + a[k-2] - 2a[k-3]

seq2 = 1:2:3:(map (\(n1,n2,n3) -> n2 + n3 - 2 * n1) $ zip3 seq1 (tail seq1) (tail $ tail seq1))

take 10 seq1 [1,2,3,1,1,-2,0,-3,2,-3]

четвертый элемент должен быть ( 3 + 2 - 2*1) = 3

но почему то 1

то есть получается у меня три списка [1,2,3] [2,3] [3] я их зипую получается [(1,2,3)], потом после map должно получится [3]

Prelude Control.Applicative> list = [1,2,3] Prelude Control.Applicative> tail list [2,3] Prelude Control.Applicative> tail $ tail list [3] Prelude Control.Applicative> zip3 list (tail list) (tail $ tail list) [(1,2,3)]

Prelude Control.Applicative> list2 = zip3 list (tail list) (tail $ tail list) Prelude Control.Applicative> map (\(n1,n2,n3) -> n2 + n3 - 2*n1) list2 [3]

то есть 3, верно

take 4 seq1 [1,2,3,1]

но тут дает 1

блин я идиот, надо было писать take 4 seq2

четвертый элемент верно вычисляет, но 5 нет, Prelude Control.Applicative> take 5 seq2 [1,2,3,3,0]

А чё ты без аккумулятора считаешь? ) там по заданию с ним надо делать ;)

А чё ты без аккумулятора считаешь? ) там по заданию с ним надо делать ;)

хочу так посчитать

через бесконечный список

seq2 = 1:2:3:(map (\(n1,n2,n3) -> n2 + n3 - 2 * n1) $ zip3 seq1 (tail seq1) (tail $ tail seq1))

У тебя тут функция называется seq2, но ты рекурсивно вызываешь seq1 три раза. Так надо? :)

У тебя тут функция называется seq2, но ты рекурсивно вызываешь seq1 три раза. Так надо? :)

вот это я дебил))

работает Prelude Control.Applicative> seq2 = 1:2:3:(map (\(n1,n2,n3) -> n2 + n3 - 2 * n1) $ zip3 seq2 (tail seq2) (tail $ tail seq2)) Prelude Control.Applicative> take 10 seq2 [1,2,3,3,2,-1,-5,-10,-13,-13] Prelude Control.Applicative> take 20 seq2 [1,2,3,3,2,-1,-5,-10,-13,-13,-6,7,27,46,59,51,18,-49,-133,-218]

^_^

дорешиваю то что в прошлом году не успел)

и самый грязный: foo :: MVar MonoType {-# NOINLINE foo #-} foo = unsafePerformIO $ newMVar ""

Как такие вставки делать?

` <- таким обрамить