тебя интересует лисповкий или хаскелевский лет?

Ну я поставил тэг [haskell] - значит хаскелевский. На CL я привёл пример потому что там есть макросы с call by macro expansion соглашением о вызове но нет ленивых функций. В haskell есть ленивые функции c call-by-need стратегией - ими можно делать простенькие специальные формы вроде if (так же как в CL можно использовать макросы для предотвращения энергичного вычисления аргументов). Но в случае более сложных форм, вроде let ленивых функций уже не хватает:

let' var val form = (\ var -> form var) val

не работает - val is unbound. Т.е. нужны средства со стратегией вычисления call by macro-expansion, что-то вроде:

macro let' var val form = `((\ ,var -> ,form ,var) ,val)

Конечно дело не в самом let (это простейший пример), а в наличии неких средств выразительности.

См. Template Haskell

Смотрел, но большую часть не понял. Как написать что-нибудь аналогичное простому макросу?

Если без извратов, то только через явные лямбды, т.е.

let' x f = f x

main = 
  let' "foo" $ \x -> do
    putStrLn x
    let' "bar" $ \y -> do
      putStrLn $ x ++ y

Где достать циклодол?

Э-э-эм, форма? Let? Зачем? В чем сакральный смысл?

Э-э-эм, форма?

Да, вопрос такой - как определить форму со стратегией вычисления call by macro expansion.

IF можно определить как ленивую функцию. А LET уже не получается, нужно что-то вроде TH, но я не понял как его использовать.

Зачем? В чем сакральный смысл?

Работать с AST?

> Да, вопрос такой - как определить форму со стратегией вычисления call by macro expansion.

IF можно определить как ленивую функцию. А LET уже не получается, нужно что-то вроде TH, но я не понял как его использовать.

Считай, что let в haskell — примитив. Тот же core haskell, который в ghc используется, почти полностью состоит из лямбды, let и case of. Вопрос — зачем его выражать через что-то?

Вдобавок, то, что ты на CL написал будет работать для рекурсивных определений?

Если хочешь работать с AST программы, то тебе только Template Haskell и поможет, но радости от него в текущей его реализации никакой, ибо соотношение пользы для среднестатистичиской программы и траха мозга минимально. Так что проще забить, тем более что в хаскеле полно других средств для метапрограммирования.

я всё-таки не совсем понял, чем тебя стандартный let не устроил, или ты так, побаловаться решил? =)

Чисто ради развлечения.

module LetNoRec where

import Language.Haskell.TH
import Language.Haskell.TH.Syntax

letNoRec :: Q Exp -> Q Exp
letNoRec = fmap letPure

letPure :: Exp -> Exp
letPure (LetE ds e) = foldr letdecToLam e ds
letPure x = x

letdecToLam :: Dec -> Exp -> Exp
letdecToLam (ValD p (NormalB b) []) e = AppE (LamE [p] e) b

{-# LANGUAGE TemplateHaskell #-}
module Main where

import LetNoRec (letNoRec)
import Language.Haskell.TH

main :: IO ()
main = runQ (letNoRec [| let {x = 2; y = 2}  in x*y |]) >>= putStrLn.pprint

Вывод:

$ ./Main 
(\x_0 -> (\y_1 -> x_0 GHC.Num.* y_1) 2) 2

Понятное дело, что при:

main = (putStrLn . show) $(letNoRec [| let {x = 2; y = 2} in x*y |])

вывод 4.

P.S. И боже упаси кого-нибудь подумать, что я это серьезно :)

Ах, да, забыл ругалку добавить в letdecToLam.

letdecToLam :: Dec -> Exp -> Exp 
letdecToLam (ValD p (NormalB b) []) e = AppE (LamE [p] e) b 
letdecToLam d e = error "Unexpandable declaration in let-expression."

Что-нибудь в этом стиле.

как определить форму со стратегией вычисления call by macro expansion

зачем это делать в Haskell?

Работать с AST?

пиши на CL

> пиши на CL

поддерживаю

> пиши на CL

Тоже плюсую.

Считай, что let в haskell — примитив. Тот же core haskell, который в ghc используется, почти полностью состоит из лямбды, let и case of. Вопрос — зачем его выражать через что-то?

Я подумал - если я увижу как можно ввести простую специальную форму вроде let, то мне станет понятно как определять более сложные пользовательские специальные формы.

На самом деле я пытаюсь выдумать пример - когда бы это было нужно именно в Haskell и не могу :). Если брать вещи из CL, то для with-* макросов хватает ленивых функций, анафорические макросы теряют смысл, т.к. в Haskell нет такой ситуации как в CL: всё что не nil (False) - t (True). Вещи среднего уровня... как я понимаю, предполагается обходится базовыми конструкциями (никто не станет делать data* вместо data чтобы оно генерило какие-нибудь «сопряжённые» данные к данным? разве что генерация в Generics, но они как раз используют TH). Что касается сложных DSL то для них есть система типов. Короче не в коня формы все эти пользовательские специальные формы в Haskell ;)

Вдобавок, то, что ты на CL написал будет работать для рекурсивных определений?

Там let предназначен только для связывания значений в локальной области видимости, для функций отдельные макросы (flet - не рекурсивные, labels - (взаимо)рекурсивные). Как для let тот пример вполне хорош, даже более хорош чем что-либо ещё :)

зачем это делать в Haskell?

наверное, привычка.

пиши на CL

Ну на CL мне ничего не мешает писать :) Я спрашиваю не в контексте выбора языка, а в контексте изучения разных парадигм.

Вот у Харрисона в самом начале есть:

let x = s in t ≡ (λ x . t) s

(let z = 2 + 3 in z + z) = (λ z . z + z) (2 + 3) = (2 + 3) + (2 + 3) = 5 + 5 = 10

Это `≡' понимается как «средство введения синтаксической глазури поверх чистого лямбда исчисления». Тот макрос на CL выглядит слишком длино, но на самом деле это ровно то же что и запись выше, т.е., условно:

let (var val) form ≡ funcall (lambda var form) val

(квазицитирование спрятано)

При попытке записать:

ghci> let let' x s t = (\ x -> t) s
ghci> let' z 2 (z * z)
Not in scope: `z'

По моему кто-то темнит :) В Inroduction to FP либо `≡' работает по стратегии call by macro expansion, т.е спрятано квазицитирование, либо упущено представление символов (как переменных) в виде «синтаксической глазури поверх чистого лямбда исчисления».