Поскольку язык ленивый, можно разрешить рекурсию в значениях. Даже в FSharp это есть, в несколько ограниченном виде.

Рекурсию разрешить-то можно, но делается она несколько иначе. Через letrec. То есть, a, который справа, должен передаваться в контекст (как параметр), в котором живёт a, написанный слева. Это обязательно два разных a.

У меня все let-объявления являются letrec по умолчанию.

В том же хаскелле, let a = s ++ a объявит бесконечный список a из повторяющихся списков s

это какое-то мутное ООП? может, вспомнить классику? во Смолтоке для доступа ко своим полям есть особый синтаксис — ^a

Да. Но это будет сделано через оператор fix. Там связь происходит через тупл Чёрча, а не вот так банально, что взяли и приписали a одно и то же слева и справа. Слева от равно a - имя переменной (просто лексема), а справа - переданное через это a значение.

Нет, ООП тут и не пахнет. Мне просто нужны удобные записи в языке, так-то он функциональный. Я при помощи записей собираюсь делать модули. То есть, содержимое файла вычисляется в запись.

Ну, fix f = x where x = f x, что является определением fix как в хаскелле, та к и у меня. Не вижу смысла городить отдельную let rec-конструкцию. Как мне кажется, в ocaml/F# let rec есть только потому, что они не ленивые и порядок объявлений в let-блоке имеет значение.

У этого fix под капотом стандартный letrec, который называется where

Который называется "любые биндинги в хаскелле".

fix f =
  let x = f x
  in x

А так же

some p = do
  x <- p
  xs <- many p

many p = some p <|> return []

Я ж о реализации говорю, а не о синтаксисе

А. Я планирую делать интерпретатор на хаскелле, а уж там завернуть let в rec несложно

Да не важно, на чём делать. Важно, что в let a = a разный смысл в a. Первое вхождение - это имя, как у переменной в функции, а второе - это как значение, полученное через fix. И нужно это учитывать. Иначе трэшак начнётся, как в первых Лиспах

Опять же, сделать let = letrec было design decision.

Это синтаксис. Я говорю, что вам надо смотреть на реализацию letrec. Как называть - не существенно

Я вот забыл, где видел :( Может, у Кисилёва?

https://bitbucket.org/heimdell/lvm/src/11b43569b2ead1aeae4683bdea1ec5459135756e/Eval.fs#lines-163 - вот реализация рекурсивного let на FSharp, конкретно этот кусок позволяет значениям взаимно-рекурсивно ссылаться в контексте на самих себя. Если я понимаю о чём вы. Я на неё смотрел неоднократно, после того как её написал.

(это код интерпретатора с let = letrec)

То, что в ocaml делается через let rec foo = ... and bar = ... in ..., у меня делается через let

И все ограничения ocaml/F# касательно рекурсии (только если ссылка внутри функции, ленивого значения и т.п.) от того, что эти языки имеют жадную стратегию исполнения. Которая, кстати говоря, не позволяет делать безопасную eta-редукцию.