newtype AppT m a 
    = AppT 
    { unAppT :: ReaderT YourStuff m a 
    } deriving (Functor, Applicative, Monad, etc)

vs

newtype AppM a = AppM (ReaderT WhateverBullshit IO a)

есть разница в этих двух ньютайпах?

parket:
@lonokhov не мог бы ты развить мысль, пожалуйста

λeonid Onokhov:
очень просто. не надо лепить трансформер где не надо

Автор взял лопату и зачерпнул...

Why Go and not Rust? | Loris Cro's Personal Blog
https://kristoff.it/blog/why-go-and-not-rust/

вот тут намекают что ооп хорошо кодатой https://ix.cs.uoregon.edu/~pdownen/publications/esop2019.pdf

а вообще классический пейпер это
https://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf Cook, "On Understanding Data Abstraction, Revisited"

Nick Linker, [18.09.19 17:46]
В хаскеле такое до сих пор невозможно что ли?

data Person  = Person  { personId :: Int, name :: String }
data Address = Address { personId :: Int, address :: String }

весёлый кремовый торт, [18.09.19 17:46]

{-# LANGUAGE DuplicateRecordFields #-}

Nick Linker, [18.09.19 17:47]
я тут ткнул DuplicateRecordFields, а оно не похоже, что работает

Nick Linker, [18.09.19 17:48]
сейчас пришлю сниппет

A64m AL256m qn[cores], [18.09.19 17:49]
а какая "работа" ожидается - tdnr?

Nick Linker, [18.09.19 17:55]

data Person  = Person  { personId :: Int, name :: String } deriving (Show)
data Address = Address { personId :: Int, address :: String } deriving (Show)

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

весёлый кремовый торт, [18.09.19 17:56]

let pid = personId person

вот на этой строчке ломается?

Nick Linker, [18.09.19 17:56]
я просто обычно линзы использовал, а тут смотрю, в последних GHC есть прогресс по рекордам

Nick Linker, [18.09.19 17:56]
[In reply to весёлый кремовый торт]
да

Nick Linker, [18.09.19 17:56]
ну потому что, очевидно, personId неоднозначный

Nick Linker, [18.09.19 17:57]
я понимаю, почему ошибка, но не понимаю, в чём прогресс тогда?

весёлый кремовый торт, [18.09.19 17:57]
в том, что в остальных случаях работает

весёлый кремовый торт, [18.09.19 17:58]
это проблема классно решена в Optics при помощи OverloadedLabels

A64m AL256m qn[cores], [18.09.19 17:59]
[In reply to Nick Linker]
это раширение DRF не для работы с функциями геттерами (которые аннотацией типов все равно можно заставить работать, но это неудобно) а для использования с ПМ, вайлдкардами или с лейблами

Nick Linker, [18.09.19 18:00]
[In reply to весёлый кремовый торт]
посмотрю, спасибо

Nick Linker, [18.09.19 18:00]
[In reply to A64m AL256m qn[cores]]
мех.
Вот уже GHC 8.8 на подходе, а счастья как не было, так и нет.

Nick Ivanych, [18.09.19 18:00]
[In reply to Nick Linker]
Оно же вышло уже.

A64m AL256m qn[cores], [18.09.19 18:01]
[In reply to Nick Linker]
TDNR - это щастье штоле? люто ненавидел, когда на емельне писал

Nick Linker, [18.09.19 18:01]
[In reply to A64m AL256m qn[cores]]
ну я и говорю, что нет

весёлый кремовый торт, [18.09.19 18:01]
tdnr?

A64m AL256m qn[cores], [18.09.19 18:02]
[In reply to Nick Linker]
так если его в принципе нет, какая разница какая версия на подходе n или n+1?

A64m AL256m qn[cores], [18.09.19 18:02]
[In reply to весёлый кремовый торт]
тайп директед нейм резолюшен

Yuriy Syrovetskiy, [18.09.19 18:09]
[In reply to Nick Linker]
почему вы ожидаете, что personId продолжит себя вести как функция?

Nick Linker, [18.09.19 18:09]
не, ну правда, вот эта тягомотина с рекордами тянется уже два десятилетия. При этом в пурсе как-то умудрились в первых версиях запилить вменяемое поведение.

Nick Ivanych, [18.09.19 18:10]
[In reply to Nick Linker]
Но они пожертвовали оператором точка!!

Nick Linker, [18.09.19 18:10]
[In reply to Yuriy Syrovetskiy]
понятия не имею, хаскель так приучил. В других местах я к полям обращаюсь как .personId

A64m AL256m qn[cores], [18.09.19 18:12]
[In reply to Nick Linker]
ну хаскель не один человек делает, а два человека - это уже три системы рекордов

Yuriy Syrovetskiy, [18.09.19 18:12]
[In reply to Nick Linker]
меня тот же Хаскель приучил иначе: let Person{personId = pid} = person

Yuriy Syrovetskiy, [18.09.19 18:13]
[In reply to Nick Ivanych]
а как же они композят?

весёлый кремовый торт, [18.09.19 18:13]
g <<< f

A64m AL256m qn[cores], [18.09.19 18:13]
[In reply to Nick Linker]
ну и дженерик-ленз лучше пурскриптовых рекордов (если анонимные не нужны)

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

весёлый кремовый торт, [18.09.19 18:18]
[In reply to A64m AL256m qn[cores]]
а optics не лучше generic-lens?

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

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