Очень не хватает сабжа. Например, в схеме нельзя так делать:

(define bar (map foo))

(bar '(1 5 7))

(define (f x y) (+ x y))

(define g (f 5))

 

Приходится писать так:

(define (bar lst) (map foo lst))

(bar '(1 5 7))

(define (f x y) (+ x y))

(define (g y) (f 5 y))

И было бы хорошо, если бы каждая функция была на самом деле функцией от одного аргумента:

 

(define (foo x) (lambda (y) (lambda (z) (* x y z))))

(foo 5 6)

(foo 1 2 3)

А приходится писать так:

(define (foo x) (lambda (y) (lambda (z) (* x y z))))

((foo 5) 6)

(((foo 1) 2) 3)

Я понимаю, что можно сделать костыль, чтобы это все работало, но лучше уж тогда создать свой диалект с нуля.
И еще, кстати говоря, мне не нравится, что строки реализованы не в виде списков символов. Нет чтоб сделать как в haskell.
Собственно вопрос, какие есть разумные причины существования данного безобразия в лиспах?

> Собственно вопрос, какие есть разумные причины существования данного безобразия в лиспах?

Отсутствие статической типизации. Без нее неясно, что значит (map foo) - частичное применение или полную аппликацию.

>Отсутствие статической типизации. Без нее неясно, что значит (map foo) - частичное применение или полную аппликацию.

Причем тут статическая типизация? Кому не ясно? Интерпретатору не ясно? Очень даже ясно.

> Как костыль написать я и сам знаю.

Не сомневаюсь, но нужен же ведь наглядный пример. Точнее, "платформа" для проверки идеи.

> Лучше (define 1+ (sum2 1)), где sum2 - бинарная операция сложения.

($define (sum2 a b) (+ a b))

(define 1+ (sum2 1))

(define bar ($map 1+))

(bar '(1 5 7)) ; => '(2 6 8)

Можно обойтись и без свертки

($collect sum2 1 2 3 4 5) ; => 15

($define (div2 a b) (/ a b))

($collect div2 1 2 3 4) ; => 1/24

А нужна ли поддержка переменного числа аргументов?

($collect sum2 1 2 3 4 5) =>

((sum2 ((sum2 ((sum2 ((sum2 1) 2)) 3)) 4)) 5)

Цитата

---

Причем тут статическая типизация? Кому не ясно? Интерпретатору не ясно?

---

Ни интерпретатору, ни компилятору

Цитата

---

Очень даже ясно.

---

Хорошо, ты видишь форму (f x) скажи, что это - аппликация или частичное применение?

И это не говоря уже обо всяких (+ х).

Цитата

---

Если f : (-> t1 t2 t3 t), то

---

Если компилятору известно, что f : (-> t1 t2 t3 t), то ЯП статически типизрован, ты в курсе? Y-комбинатор в таком лиспе, кстати, ты написать уже не сможешь.

> Смотря что из себя представляет f.

А компилятор не знает, что из себя представляет f. И узнать никак не может.
(lambda (g f) (f 1)), например. Неизвестно же, что будет передано потом в эту лямбду.

Цитата

---

Ну вот когда будет передано, тогда и узнает.

---

Но ведь в рантайме это будет медленно? Решил потестить реализацию на case-lambda в Racket - забавные результаты:

 

#lang racket

(require (for-syntax syntax/parse

                     srfi/1))

 

(define-syntax ($case-lambda stx)

  (syntax-parse stx

    [($case-lambda (name arg1 arg ... arg2) (args ...) body ...)

     (with-syntax ([((left ...) ...) (map reverse (pair-fold cons '() (reverse (syntax->list #'(arg1 arg ...)))))]

                   [((right ...) ...) (reverse (pair-fold cons '() (syntax->list #'(arg ... arg2))))])

       #'(case-lambda 

           [(left ...) (let ([curried ($case-lambda (name right ...) (args ...) (name args ...))])

                         curried)] ...

           [(arg1 arg ... arg2) body ...]))]

    [($case-lambda (name arg1) (args ...) body ...) 

     #'(let ([curried (lambda (arg1) (name args ...))])

         curried)]))

 

 

(define-syntax ($define stx)

  (syntax-parse stx

    [(_ (name:id arg1:id arg:id ... arg2:id) body:expr ...+) 

     #'(define name ($case-lambda (name arg1 arg ... arg2) (arg1 arg ... arg2) body ...))]

    [(_ (name:id arg:id ...) body:expr ...+) 

     #'(define (name arg ...) body ...)]))

 

это код, соответственно:

 

($define (f x y z t) (+ x y z t))

(f 1 1 1 1)

((f 1) 1 1 1)

((f 1 1) 1 1)

(((f 1) 1) 1 1)

((f 1 1 1) 1)

(((f 1) 1 1) 1)

(((f 1 1) 1) 1)

((((f 1) 1) 1) 1)

 

->

4

4

4

4

4

4

4

4

 

все работает. А теперь тесты:

 

($define (g x y) (+ x y))

 

(time (for ([i 10000000]) (+ i i)))

(time (for ([i 10000000]) (g i i)))

(time (for ([i 10000000]) ((g i) i)))

 

->

cpu time: 1156 real time: 1195 gc time: 0

cpu time: 1172 real time: 1207 gc time: 0

cpu time: 1203 real time: 1247 gc time: 0

 

Короче, инлайнинг байткода в racket - это нечто!
Ладно, второй вариант совпадает с первым (понятно, что компилятор просто подставил нужную форму), но во третьем случае даже лямбда при частичном применении в (g i) не создавалась! Он и ее раскрыл и заинлайнил на ходу
Вырубаем инлайнинг:

 

($define (g x y) (+ x y))

(define-values (f1 f2) (values #f #f))

(set!-values (f1 f2) (values + g))

(time (for ([i 10000000]) (f1 i i)))

(time (for ([i 10000000]) (f2 i i)))

(time (for ([i 10000000]) ((f2 i) i)))

 

->

cpu time: 1766 real time: 1806 gc time: 0

cpu time: 1500 real time: 1561 gc time: 0

cpu time: 2235 real time: 2307 gc time: 328

 

Теперь уже лямбда создается. Можно обратить внимание - вторйо вариант быстрее первого, т.к. + так же определяется в виде case-lambda, но там больше кейзов (для rest аргумента).

для сравнения вариант с "чистым" сложением:

 

(time (for ([i 10000000]) (unsafe-fx+ i i)))

 

->

cpu time: 1187 real time: 1233 gc time: 0

 

Так что, однако, не так уж и плохо все - везде, где можно, компилятор-таки умудряется оптимизировать до максимальной производительности (как буд-то функция вычисляется "напрямую"), а когда оптимизировать не выходит - просадка вполне разумна. Я думал, будет гораздо хуже, а так оно даже вполне юзабельным выходит, так что беру свои слова обратно на счет невозможности.

Цитата

---

Какой смысл в "(let ([curried ...]) curried)", его ведь упразднит оптимизатор?

---

у функции будет имя <curried> тогда, а не <procedure module line-number column-number>. Вообще, там по-хорошему должно быть что-то типа <curried-name module line-number column-number> (это все для отладки), но мне было лень, оставил так
Хотя вообще можно inferred-name и напрямую в синтаксический объект для лямбды добавить.

Цитата

---

cpu time: 1109 real time: 1110 gc time: 0
cpu time: 1375 real time: 1375 gc time: 0
cpu time: 1922 real time: 1953 gc time: 62

---

у тебя, видимо, инлайнинг и так вырублен.

Цитата

---

Компилятор учитывает наличие переопределения (set! g g), поэтому не производит инлайнинг функции.

---

ну да, все правильно, мне просто почему-то показалось, что он не должен инлайнить только после set!.

Кстати, в какой-то из последних версий добавили cross-module инлайнинг.

Есть идея создать такой диалект лиспа (правда от лиспа там останется только синтаксис - s-выражения): смесь идей из kernel (первоклассность всего и вся), racket (контракты, модульность, pattern matching), haskell (строки в виде списков символов, частичное применение, встроенное каррирование, ленивые вычисления (я не имею в виду те костыли, что в scheme), вывод "типов" (в нашем случае контрактов), чистота (через монады или что-нибудь похожее)). Может еще что-нибудь. Потом, возможно, создам отельную тему, когда реализую это все, если, конечно, это кому-то будет интересно.

Shen отвратителен. Во-первых, он статически типизированный. И при этом хуже haskell по всем параметрам => на фиг не нужен.
Во-вторых, pattern matching убогий, он такой не нужен из коробки.
В-третьих, синтаксис довольно далек от чистого s-expressions. Т.е. грязь. Должны быть в основе либо чистые s-выражения, либо что-то типа навороченного хаскелльного синтаксиса. Что-то промежуточное, совмещающее и то и другое понемножку - бессмысленное убожество.
В-четвертых, костыльное call-by-need, как в scheme.
В-пятых, есть макросы - не первоклассные объекты.
В-шестых, в eval нельзя передать окружение.
В-седьмых, есть строки как базовый тип объектов - лишняя сущность.
Короче, этот Shen вдоль и поперек сплошное говно.

Цитата

---

смесь идей из kernel (первоклассность всего и вся)

---

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

> Во-первых, он статически типизированный.

Это настраиваемая в рантайме опция. Да и типизация больше похожа на контракты. Кстати, хорошо бы и тебе подобное прикрутить.

> Во-вторых, pattern matching убогий, он такой не нужен из коробки.

Для игрушечного языка вполне нормальный. Реализуешь лучше?

> В-третьих, синтаксис довольно далек от чистого s-expressions.

Обоснуй.

> В-четвертых, костыльное call-by-need, как в scheme.

Значит производительность тебя не волнует.

> В-пятых, есть макросы - не первоклассные объекты.

Разделение пространств имен - это правильный шаг.

> В-шестых, в eval нельзя передать окружение.

А зачем? Eval использует текущее пространство имен.

> В-седьмых, есть строки как базовый тип объектов - лишняя сущность.

Обоснуй.

> За тем, чтобы можно было исполнять формы в любом окружении (возможно, только что созданном в рантайме).

Ну так в чем проблема? Это ведь легко реализовать.

> ну например в определении факториала твоем не проставлены скобки

define - это ридер-макрос, т.е. ридер преобразует его в s-выражение.

P.S. Shen - это конструктор лего.