Nick Ivanych, [18.09.19 18:19]
"Если и хуже, то не сильно" ;-)

Nick Linker, [18.09.19 18:19]
[In reply to Yuriy Syrovetskiy]

λ> :t personId 
personId :: Person -> Int

(это если убрать одно из определений)
но если продолжить твой, Юрий, вариант, то будет так:

test :: IO ()
test = do
  let person = Person 123 "Holmes"
  let address = Address 33 "Baker street"
  let Person { personId = pid } = person
  putStrLn $ "pid = " <> show pid
  let newAddress = (address :: Address) { personId = 44 }
  putStrLn $ "newAddr = " <> show newAddress

это работает, теперь я вижу прогресс!

Nick Linker, [18.09.19 18:19]
раньше по-крайней мере я такого не припомню, чтобы работало

Зигохистоморфный Препроморфизм, [18.09.19 18:19]
[In reply to A64m AL256m qn[cores]]
так чем лучше?

Nick Linker, [18.09.19 18:20]
но строчка let newAddress = (address :: Address) { personId = 44 } чудесна

A64m AL256m qn[cores], [18.09.19 18:20]
[In reply to Зигохистоморфный Препроморфизм]
более развитый интерфейс. если просто как геттеры использовать - ничем не лучше.

Зигохистоморфный Препроморфизм, [18.09.19 18:20]
[In reply to A64m AL256m qn[cores]]
ну теже траверсы и линзы для рекордов есть в профункторной оптике

A64m AL256m qn[cores], [18.09.19 18:21]
[In reply to Nick Linker]
можно еще

let pid = personId (person :: Person)

весёлый кремовый торт, [18.09.19 18:21]
[In reply to Nick Linker]
let pid = person ^. #personId

Nick Linker, [18.09.19 18:22]
[In reply to A64m AL256m qn[cores]]
при этом 2-мя строчками выше написан биндинг для person и даже идиоту понятно, что у него тип Persion

Oleg ℕizhnik, [18.09.19 18:22]
.^person ^. < ##personId## >
мы так ранньше никнеймы писали с клановыми тегами

весёлый кремовый торт, [18.09.19 18:23]
ну вот не надо, не так много символов и читать их достаточно просто

A64m AL256m qn[cores], [18.09.19 18:23]
или

#personId person 

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

getField @"personId"

еще

Oleg ℕizhnik, [18.09.19 18:23]
[In reply to весёлый кремовый торт]
да, всего четыре символа

A64m AL256m qn[cores], [18.09.19 18:24]
[In reply to Nick Linker]
идиоту мож и понятно, но вывод типов это ломает везде где он есть

весёлый кремовый торт, [18.09.19 18:24]
[In reply to A64m AL256m qn[cores]]
из-за #personId person придётся не очень хороший инстанс IsLabel писать

A64m AL256m qn[cores], [18.09.19 18:24]
[In reply to весёлый кремовый торт]
да

Зигохистоморфный Препроморфизм, [18.09.19 18:24]
[In reply to A64m AL256m qn[cores]]
prop (SProxy :: _ "personId")

Nick Linker, [18.09.19 18:25]
[In reply to A64m AL256m qn[cores]]
жаль, увы. Но спасибо, наверное даже я обойдусь без линз на этот раз.

Oleg ℕizhnik, [18.09.19 18:25]
Надо дампнуть тред и скинуть в чат питонистов\жаваскриптёров\etc.

Oleg ℕizhnik, [18.09.19 18:25]
Хаскелисты придумывают способы написать object.property

Nick Ivanych, [18.09.19 18:26]
;-) ;-)

A64m AL256m qn[cores], [18.09.19 18:26]
[In reply to Oleg ℕizhnik]
чтоб не писать

foo >>> bar >>>> baz >>> quux >>>>>>>>>>>>

A64m AL256m qn[cores], [18.09.19 18:28]
[In reply to Nick Linker]
или еще

r @Person personId person

всего 1024 способа собирания из 256 частей

Ruby Developer
в Inkitt — первое в мире reader-powered издательство. Компания разрабатывает алгоритм прогнозирования новых бестселлеров на основе анализа поведения читателей.
150К-250К, удалённая работа.
Описание вакансии https://is.gd/PCI9fH
#ruby #ror #rubyonrails #developer #вакансия #remotework

A64m AL256m qn[cores]:
так что рекордовый пм бывает по чему-то объявленному только, рекорду или паттерн-синониму

но это не такая и проблема - с внешним объявлением и сигнатуры меньше будут и сам паттерн.

λeonid Onokhov:
внешнее объявление это сущность которую нужно подглядывать потому что ты забыл

A64m AL256m qn[cores]:
ИДЕ ПОДСКАЖЕТ

λeonid Onokhov:
Отличная шутка

что получилось в итоге?

из больших кусков:

& _2.content.xs %~ (Map.insertWith (<>)


(val ^. _2.content.xs.to(getEntities.concat.Map.elems))) -- я не осилил совет Юры

& _2.content.xs.ix(section) .~ concat vs

у меня есть 3 случая: применить функцию к зачению в мапе
2. применить функцию f :: [T.Text] -> [T.Text] к значеию если оно есть и обновить значение по ключу
3. применить функцию f :: Maybe [T.Text] -> [T.Text] к значению по ключу есть оно там или нет и обновить значение

Для начала, чууть переформулирую определение моноида, ближе к категорному.
Это объект-тип A вместе с двумя стрелками-функциями
1→A и AxA→A.
И выполняются соответствующие соотношения (умножение на единицу и ассоциативность, сам знаешь).
Для наглядности, из стоит нарисовать в виде диаграммы.
Комоноид, это моноид в op-категории, то есть, мы все эти стрелки должны развернуть.
И это A→1 (коединица) A→AxA (коумножение).
И в диаграмме, стрелки все наеборот, ессно.
Вот тут
https://ru.wikipedia.org/wiki/Моноид_(теория_категорий)
вместно тензорного произведения подставь обычное декартовое (т.е., произведение в Set) и получишь определение и диаграммы моноида, для комоноида надо перевернуть стрелки.
Получаем, что коумножение, это наоборот, разделение типа на составляющие, типа как разложение на множители.

Take a look at Optics By Example (@opticsbyexample): https://twitter.com/opticsbyexample?s=09

Вот чем Rust реально напрягает, так это немного деревянной системой типов за счёт отсутствия специализации и энфорса статического связывания.
Пишешь такой себе абстрактный код, наворачиваешь абстракции, всё хорошо, всё красиво, без лишних клонов, с заимствованием как надо, а потом в самом конце вся эта лабуда не сходится и не компилится, потому что conflict trait implementation для какого-то From/Into/AsRef/Borrow, и... сидишь у развалившегося корыта и чешешь репу часами 😕

В той же Гошне порешалось бы сразу через какой-то interface cast, ибо там в астрактном коде одна динамика. А тут приходится совсем нетривиальные хаки надумывать.

Постоянно на этом момент обжигаюсь.

All Algorithms implemented in Rust

https://github.com/TheAlgorithms/Rust

вот переделал без функции, кажется ничего не изменилось, но стало понятнее что я пытаюсь сделать
https://pastebin.com/h78MC1y8

https://github.com/carllerche/tokio-serde-json/blob/master/src/lib.rs
вот тут тоже без poll и ручного написания Stream и Sink не обошлось

Растишки переизобрели ReaderT: https://github.com/anp/moxie/blob/master/topo/src/lib.rs

https://gist.github.com/sopvop/4de6dcc3a5a4383600ec60ac235844c2 типа

https://t.iss.one/haskellru/211436
Maxim Koltsov:
Подскажите какие-нибудь статьи для понимания monad-control и штук около того?

Kirill Valyavin:
Если unlift годится, фпкомплитовские статьи есть вроде

Зигохистоморфный Препроморфизм:
https://lexi-lambda.github.io/blog/2019/09/07/demystifying-monadbasecontrol/

Maxim Koltsov:
Спасибо

Apfelsinchen Ritter:
Мне кажется, что проще понять unliftio, а на основе этого знания MonadBaseControl. Снойман статейку на fpcomplete когда-то писал.
https://tech.fpcomplete.com/blog/2017/07/announcing-new-unliftio-library

Alexander Vershilov:
используй unliftio

или руками аналог сделать

Maxim Koltsov:
Ну знаешь, в некоторых либах прикручен MonadBase, MonadControl

А почему?

Alexander Vershilov:
Там просто используй его

MonadControl переусложнен из-за того, что там может быть разный base

В итоге инстансы писать действительно не просто после перерыва

Maxim Koltsov:
Ну, я вижу что его используют в библиотеках и хочется понимать :)

Denis Redozubov:
ну идея то простая

Alexander Vershilov:
Напиши 3 инстанса - поймёшь

Denis Redozubov:
был MonadIO m

Alexander Vershilov:
идея очень простая - собрать состояние и воссоздать стек внутри продолжения

Denis Redozubov:
отлепили IO от Monad и параметризовали по нему

ну это уже реализация

Alexander Vershilov:
Ну это идея за monad-control

отличающая его скажем от unliftio

ну часть, которая "автоматом" это отличие

λeonid Onokhov:
идея в том что-бы изнутрей m a выполнять FooT m b

а сам m a выполнять внутре FooT m a

Apfelsinchen Ritter:
Есть у нас стандартная функция

withBinaryFile :: FilePath -> IOMode -> (Handle -> IO a) -> IO a

А в проекте у нас есть вместо IO MonadIO, то есть

withBinaryFile' :: MonadIO m => FilePath -> IOMode -> (Handle -> m a) -> m a

unliftio дает нам возможность сделать вот так

withBinaryFile' :: MonadUnliftIO m => FilePath -> IOMode -> (Handle -> m a) -> m a
withBinaryFile' fp mode inner =
withRunInIO $ \runInIO ->
withBinaryFile
fp
mode
(\h -> runInIO (inner h))

Если для нашего m есть инстанс MonadUnliftIO.

Так делать приходиться поскольку есть проблема с позицией аргументов завернутых в m.

https://tech.fpcomplete.com/blog/2016/11/covariance-contravariance

Maxim Koltsov:
Ага, и это обычно бывает только для ридеров всяких

Apfelsinchen Ritter:
Вот для ридеров всяких unliftio и подходит, то есть, там где нет стэйта.

А там где нужен появляются monad-control, monad-base-control, которые могут и стэйт иметь.

Alexander Vershilov:
Ну это не то, чтобы точно

с unliftio или аналогами стейт никто иметь не запрещает

Apfelsinchen Ritter:
Но эти пакеты и более сложные в использовании.

Alexander Vershilov:
С другой стороны у monad-control стейт "чистый"

Apfelsinchen Ritter:
Это да. Тут уже на совести разработчика.

Alexander Vershilov:
И весьма неочевидно себя может вести в присутствии исключений, хотя в lifted-base аккуратненько всё сделано

Сразу скажу, &String тебе нужен примерно никогда

Потому из-за deref coercion на у &String доступен весь API &str, а единственное, что ты можешь сделать, что в это API не входит - это метод .capacity(). Знать ёмкость строки, не имея возможности её поменять, не имеет большого смысла

Эх, блин, прям разочарование года. 😞
Не выходит конфетка из раста - упёрлись видимо в лень разработчиков и фобию бампа мажорной версии. В итоге получим те-же грабли как и в языках с исключениями, когда эти исключения просто игнорятся и не обрабатываются. И это даже сложно будет отследить - толи это разработчик схалтурил и запилил дефолтную ветку, или это была необходимость для сохранения совместимости с новыми версиями другой библиотеки, где может появится новое значение в enum-е.

в чем проблема использовать failure? последний раз вручную написанные энамы видел год назад