dynamic scope!

а можно простой простой пример?

чтобы как в древнелиспах было

foo = ?x + 1

там будет ?x который в динамическом скоупе

хм https://github.com/duairc/implicit-params

или например sort :: (?cmp => a -> a -> Ordering) => a -> a

будет сортировать той cmp которая в скоупе

динамическом

но они будут жить теперь в констрейнте типа https://wiki.haskell.org/Implicit_parameters

разница в том, что теперь явно не пишем cmp как параметер функции?

да

@A64m_qb0 а хороший пример с инстансами есть?

локальные инстансы на имплицитах, я сейчас вспомнил, поправили как баг

да

выложи потом рабочий гист)

с cmp пример в документации лежит

я в первый раз в жищнию их юзал

ясно! https://ocharles.org.uk/blog/posts/2014-12-11-implicit-params.html

чтобы как в древнелиспах было

в елиспе до сих пор так 🌚

=)

он не древнелисп разве?

elisp - страннолисп, лисп-в-себе

По моему не так чтобы уж совсем древнелисп, динозавром, может и видел, но трилобитов точно не застал

В Elisp нету лексического скоупинга. Этим он похож на первые лиспы. В остальном вполне себе нормальный (для лиспа) узкоспециализированный диалект.

https://markkarpov.com/post/short-bs-and-text.html

text-utf8 чисто haskell-ный или с icu?

А это, разве, не заброшенный эксперимент по портированию text на UTF8?

В Elisp нету лексического скоупинга. Этим он похож на первые лиспы. В остальном вполне себе нормальный (для лиспа) узкоспециализированный диалект.

А lexical-binding тогда что? Какой-то хак?

чот не пойму зачем это http://tech.frontrowed.com/2017/11/01/rhetoric-of-clojure-and-haskell/

А lexical-binding тогда что? Какой-то хак?

(let ((a 1)) (let ((f (lambda () (print a)))) (let ((a 2)) (funcall f)))) => 2

В имаксе динамический биндинг. А lexical-binding - статический.

@A64m_qb0 если это foldl в Черче https://hackage.haskell.org/package/foldl-1.3.3/docs/Control-Foldl.html#t:Fold то какой будет foldr в Черче? есть ли такая либа?

А lexical-binding тогда что? Какой-то хак?

С 24.1 можно для модуля включить лексический биндинг (вместо динамического) - той самой переменной lexical-binding

@A64m_qb0 если это foldl в Черче https://hackage.haskell.org/package/foldl-1.3.3/docs/Control-Foldl.html#t:Fold то какой будет foldr в Черче? есть ли такая либа?

А почему правая свёртка в church encoding должна выглядеть как-то по-другому? Тем более, что там 1 функцию надо модифицировать, чтобы она правую свёртку делала, а не левую (через правую). https://hackage.haskell.org/package/foldl-1.3.3/docs/src/Control-Foldl.html#fold

ну это понятно что в Fold поменять первый аргумент

@A64m_qb0 если это foldl в Черче https://hackage.haskell.org/package/foldl-1.3.3/docs/Control-Foldl.html#t:Fold то какой будет foldr в Черче? есть ли такая либа?

И это foldl', а не foldl

(x -> a -> x) => (a -> x -> x)

но может есть специфика?

вопрос как-то странно сформулирован, но я так понял. что требуется https://hackage.haskell.org/package/folds

1) Зачем? 2) я думаю, что лучше было бы в обоих свёртках иметь (a -> x -> x).

интересно можно сделать катаморфизм с поведением левой свертки?)

т.е. записать левую через правую? Да

она прямо в base так и написана

нет записать катаЛ через ката

1) Зачем? 2) я думаю, что лучше было бы в обоих свёртках иметь (a -> x -> x).

2) +

1) Зачем? 2) я думаю, что лучше было бы в обоих свёртках иметь (a -> x -> x).

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

Good luck in erlang

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

+1

Я каждый раз лезу в repl, чтобы понять, в каком порядке должны быть аргументы

Там же вся мнемоника в позиции аккумулятора

(((1 + 2) + 3) + 4) vs (1 + (2 + (3 + 4))) + то коммутативен, но не все же функции таковы

a -> x -> x предпочтительнее, так как многие операции имеют такую форму

Конечно нет

Map.insert

нет записать катаЛ через ката

не знаю

Когда у тебя все аргументы у функций закончились уже неделю назад и ты сделал import Data.Composition ((.:), (..:)), это становится неудобно

a -> x -> x предпочтительнее, так как многие операции имеют такую форму

А на что тебе боги flip даровали?!

На то, чтобы он торчал посреди моего кода, как шест в поле, очевидно

вот, нашел письмо от изобретателя рекордов на имплицитах https://mail.haskell.org/pipermail/haskell-cafe/2013-May/108334.html

Это то, что я называю чёрной магией. Я ещё видел, как люди упаковывали что угодно в (), а потом распаковывали

все-таки тут упаковывается как раз в то, что и предназначено для упаковывания таких вещей

Map.insert

> Map.insert :: Ord k => k -> a -> Map k a -> Map k a ~ a -> x -> x foldr (uncurry Map.insert) Map.empty kvPairs

foldl' же

Вопрос. Если где-то в скоупе появятся ещё несколько неявных параметров (?callStack, например), оно их тоже захватит и будет таскать с собой? Как это вообще физически - т.е., на уровне Core - работает?

foldl' же

А в этом случае придётся пихать flip. Который в не имеет отношения к логике программы в принципе, но занимает место и отвлекает глаз.

каким типом проаннотировать - то и захватит.

Т.е., в случает аннотации CallStack => оно будет таскать за собой ?callStack?

тип Rec параметризован захватываемыми имплицитами

А потом после распаковки, этот ?callStack перекроет - или, что лучше, просто окажется в поле зрения вызова, который печатает текущий стэк?

тут все как в этих примерах со списками обернутых интов, булов и прочего, где обертка, например, классом Show параметризуется

> data Record fields where > Rec :: fields => Record fields Т.е., здесь вместе с Rec будет таскаться пачка словарей? Я правильно понимаю, что ты не управляешь списком захвата при этом?

что значит "не управляешь"?

Т.е., оно захватит все имплиситы, которые будут в поле зрения

ну вот Box Show что, предполагается что в случае Box 42 захватит все словари для интеджера а не только Show?

А, да. У него же эти словари фиксированы в виде параметра типа. Не углядел.

ну и еще поведение на бесконечных списках у foldl и foldr разные

Я всё более склоняюсь к foldMap (uncurry Map.singlenton) kvPairs

из-за этого там и вывод типов не фонтан

Map.insert

почему, Map.insert тоже такой же

foldr (uncurry Map.insert) Map.empty [("a", 1), ("b", 2)] => fromList [("a",1),("b",2)]