Расширение синтаксиса

Форт?

Да какая разница, на чем реализован исполнитель? Это второстепенно, по-моему.

У тебя в голове какаша

Зачем, например, мне, изучать макросистемы, если я пишу код один? Не проще ли мне писать мини-язык под задачу, и расширять его по мере надобности путем изменения самого исполнителя?

А не всё ли равно если первоначальный язык - CL?

макросы позволяют инкрементально расширять язык

Профит невелик. Мне открыть файл кода исполнителя и подправить его не трудно.

незачем, проще

Но в других случаях их применение, как мне кажется, совершенно не обоснованно.

Ты уже написал быструю реализацию регэкспов, ничтожество?

Не проще ли мне писать мини-язык под задачу, и расширять его по мере надобности путем изменения самого исполнителя?

Ну напиши эффективный «исполнитель» (что бы это ни было в твоей шизофреничной башке) для регулярных выражений.

Ты не пишешь код один. Когда будешь смотреть на свой код, написанный 2+ года назад, будешь воспринимать его как написанный кем-то другим.

Ты не пишешь код один.

Ты чо, ты только что оскорбил всю ЛNСП-братию. Для них работа в коллективе — это зашквар и западло.

(Но мы-то с вами знаем, что это просто бугурт от того, что из энтерпрайза/науки/промышленности их погнали ссаными тряпками.)

CL

кстати, схема вот очень хорошо умеет в dsl, а как с этим делом у common lisp?

кстати, схема вот очень хорошо умеет в dsl, а как с этим делом у common lisp

Также. Единственная разница между макросами схемы и CL — работа с лексическим окружением, в котором запущен макрос. Для dsl это не важно.

При использовании даже в CL чуть легче: можно менять синтаксис на кусок файла, а не на модуль целиком.

Не проще ли мне писать мини-язык под задачу, и расширять его по мере надобности путем изменения самого исполнителя?

Не проще.

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

Инструмент надо изучить один единственный раз - и после этого он всегда будет тебе помогать. В результате - огромная эконмия времени и усилий.

Мне открыть файл кода исполнителя и подправить его не трудно.

Но разобраться в макросистеме проще чем в коде исполнителя.

Мне открыть файл кода исполнителя и подправить его не трудно.

ORLY? Если я тебе скажу три своих хотелки в трех разных исполнителях, ты готов взять и быстро решительно их реализовать? Если тебе не трудно, конечно.

А вообще кончай спамить тегами, заебал уже.

Хватит уже лепить на свои высеры таг lisp. Заипал.

А что там изучать-то собственно?

А если в разных модулях тебе надо несколько дслей, то что будешь делать? Хранить несколько исполнителей и помнить, где какой использовать? Или с помощью бондажа и дисциплины не писать пересекающиеся дсли, чтобы всё можно было свалить в одну кучу?

То-то я думаю почему инженера на разработку квантового компьютера нанимают писать код на sbcl.

А если язык можно создать без регулярных выражений?

Не проще ли мне писать мини-язык под задачу

Да-да! Чувак начни уже, начни что-нибудь писать. Лучше что-нибудь полезное для себя, ну или хотя-бы примеры из книжки. Напиши «исполнителя» языка со «сладким и органичным» синтаксисом - покажи всем как ты клепаешь «мини-языки под задачи» (кстати, очень интересно, какие-такие сложные задачи ты там решаешь с помощью мини языков?). А макросистемы действительно достаточно сложны, и требуют времени на изучение. Видимо, это так. Ведь, вместо создания пятитысячной говнотемы, ты бы уже разобрался давно? Верно? Ты ведь не такой тупой как тут говорят?

Чем это отличается от макросов? Ну, кроме того, что свой мини-язык уже сложнее по определению.

Чем это отличается от макросов?

Именно простотой и расширяемостью. Ты должен писать макрос внимательно следя за квотированием, правилами скопа, думать о том, когда он раскроется, и прочее, тогда как я просто напишу if(input===«bar»)(handle input whatEver_You_Want_and_All_Rules_Sucks)

Такое https://gist.github.com/tormaroe/1497179 ?

Нет. Там написано

This script demonstrates how to use the built in parse

functionality of Rebol to create an internal DSL. А я говорю о чистом DSL, то есть, просто язык с нуля под задачу.

Ну сделать интерпретатор который будет читать файлы с dsl и выполнять их не проблема вобщем-то. Что значит с нуля под задачу не совсем понятно, ты хочешь с нуля реализовать все от сложения до конкатенации строк?

Ты действительно считаешь, что проще свой миниязык? Ну тогда язык будет сильно ограниченным, если его интерпретатор писать проще, чем макрос.

Ну тогда язык будет сильно ограниченным, если его интерпретатор писать проще, чем макрос.

Ну почему же? Берём L++ для примера. Получаем скорость C++ (что невозможно на чистом Lisp/Scheme), но при этом возможность доопределять синтаксис так, как нравится.

Если скобки не нравятся, то можно вспомнить Groovy. На базе которого делаются вполне симпатичные DSL, запускаемые из Java. И, опять же, без особых ограничений

Конкатенацию строк реализовать несложно, кстати. Арифметику свою не обязательно, если нет какой-то специфичной задачи.

язык будет сильно ограниченным

На самом деле, это заблуждение. Как правило, чем проще язык, тем он мощней. Обилие фич вместе с усложнением накладывают массу ограничений.

Кроме того, любая фича source-языка будет работать и в target-языке, если мы этого хотим. Это вообще не вопрос.

Кроме того, любая фича source-языка будет работать и в target-языке, если мы этого хотим. Это вообще не вопрос.

Это если у тебя макросы. Если самописный интерпретатор - то не будет.

Причем тут макросы?

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

Берём L++ для примера. Получаем скорость C++ (что невозможно на чистом Lisp/Scheme),

Который интерпретируется ракетой... Хм... Что-то тут не так. :) Да и в самом L++ очень даже встречается define-syntax.

Groovy. На базе которого делаются вполне симпатичные DSL

Ну и где эти DSL? Точнее, сколько разных DSL на груви можно сделать и насколько сильно расширять?

Форт, лисп - куда уж проще то? :) Но и это тебе сложно.

Это ты сейчас до макросов дошёл.

Насчет форта — хз, но, конкретно, CL и Racket — это не простые языки. Могут с плюсами запросто потягаться в уродстве и неконсистентности дизайна. Простые — это, например, смоллток, селф (особенно), в какой-то степени (в плане синтаксиса) scheme R<6RS. Попсовые же лиспы спроектированы так, чтобы быть понятными быдлу, но не концептуально простыми.

R<6RS/R6<RS

Только странное - быдло их не понимает. То ли IT совсем скатилась, то ли ошибочка вышла, не для быдла делали.

Твой язык не умеет не то что в векторы, но даже флоаты.

Ошибка. Запомните: «Не уметь в Гугл», но «Не уметь во векторы»!

Не понимает, потому что в массе не стремится. Отталкивает синтаксис, в основном, а от практического освоения толку мало, потому и не идет в массы. С точки зрения семантики, они максимально приближены к алгол-стайл-языкам. Сравни, например с lisp-3, или даже Interlisp. Это день и ночь. Лисп изначально был экстремально динамичным языком. Очень медленным и очень выразительным.

Нет, я, в данном случае, про метациклический интерпретатор, если рассматривать простой случай.

Который интерпретируется ракетой

Зачем интерпретируется? Компилируется g++ и запускается.

Да и в самом L++ очень даже встречается define-syntax.

Так я же говорю, DSL. Расширяемый. Но раскрывается не в ракетку, а в C++.

Ну и где эти DSL? Точнее, сколько разных DSL на груви можно сделать и насколько сильно расширять?

http://www.slideshare.net/glaforge/going-to-mars-with-groovy-domainspecific-l...

К Розенталю, быдло!

Розенталь устарел, в Лурку не умеешь?

Если макросистемы для тебя сложны, то забей обо всём этом думать. Если о лиспе, то запомнить 3 простых правила сложнее чем мифически «менять исполнитель»? В любом случае самое простое что можно сделать с языком это eDsl, остальное на порядок сложнее.

Если о лиспе, то запомнить 3 простых правила сложнее чем мифически «менять исполнитель»?

Макросистема более ограничена в синтаксисе. Например, в Racket «меняя исполнитель» я могу сделать такие синтаксисы:

Honu:

#lang honu
// A for loop that iterates between two bounds. 
for x = 1 + 5 to 10 do 
  printf("x is ~a\n" x) 
  
// Similar to above but shows a block of expressions in the body 
for x = 1 to 10 do { 
 var y = x + 1; 
 printf("x ~a y ~a\n", x, y) 
} 
  
// A for loop that iterates over a list of numbers 
for x in [1, 2, 3] do { 
 printf("x ~a\n", x); 
} 

Datalog:

#lang datalog
parent(john, douglas).
parent(bob, john).
parent(ebbon, bob).
ancestor(A, B) :- parent(A, B).
ancestor(A, B) :- 
    parent(A, C), 
    ancestor(C, B).
ancestor(A, B)?

Python:

#lang python
from "racket" import time

def sieve(n):
  primes = [True] * (n+1)
  counter = 0
  for i in range(2,n):
    if primes[i]:
      counter = counter + 1
      for j in range(i*i, n, i):
        primes[j] = False
  return counter

print time(sieve(10000000))

Макросами такое никак.

Ну на самом деле если без переписывания лексера - то вполне ок делается на макросах. А если новый лексер нужен - то да, беда. Кстати у меня попытка написать #lang python сразу закрывает др.Ракет. Не встерчал такой проблемы?

reader-macros в CL - позволят и не такое

А как же макрос loop? я вообще о простоте макросов в CL