Lisp
От: fionbio  
Дата: 12.07.05 08:17
Оценка: 149 (19) +1
[я — автор темы/бывшей ветки Metaprogramming et al]
http://www.rsdn.ru/forum/?mid=1264362
Автор:
Дата: 09.07.05


Несколько позже я попробую "разразиться" ещё одной "заметкой"
в том же духе, в том числе и по поводу эволюции языков. В данный
момент мне этим заниматься некогда.

Отмечу, что я не хочу агитировать за повальный переход на Лисп,
т.к. достаточно хорошо отдаю себе отчёт в том, насколько это может быть
затруднительно. Это относится как к существующим проектам, так и ещё не начатым.
Я лишь хотел сказать, что

1) Изучение немейнстримовых языков, и в особенности лучшего метаязыка — Лиспа,
способствует повышению квалификации программиста и существенно более глубокому
пониманию мейнстримовых технологий;

2) Лисп более чем пригоден для практического применения, и в ряде случаев
является наилучшим вариантом — в частности (но не ограничиваясь), для реализации
каких-либо единоличных/немноголюдных/open source проектов
(это не подразумевает необходимость мгновенного и поголовного перехода);

3) Практическая ценность "костылей" типа boost ограничена, т.к. по большому
счёту они представляют собой использование языка не по назначению.

Что касается п. 2, зачастую 1-2 человека могут сделать на Лиспе больше, чем
приличная контора мейнстримовцев. Это касается Yahoo Store (откуда Грэхэм свалил,
т.к. заработал на пару с небезызвестным Робертом Моррисом что-то вроде $40M+, а что ещё надо,
чтобы достойно встретить старость? ), а также например вот этого:
http://groups-beta.google.com/group/comp.lang.lisp/browse_thread/thread/1cf0a2866faef1d0/7983e2224c4974ef

Кстати, когда смотрите LOTR, не забывайте, что харю и мимику тов. Gollum'а
тоже сделал Лисп (IZware).

Напоследок приведу ссылку на одну интересную вещь — пример работы с Common Lisp,
в режиме самого что ни на есть interactive development'а. Я уже давал ссылку на
статью известного деятеля в области OO, XP и пр. Martin'а Fowler'а:
http://martinfowler.com/articles/languageWorkbench.html

Если в кратце, то в статье рассказывается о пользе DSL, и в качестве
примера рассматривается написание на C# расширяемого парсера некоего
лога вызовов/чего-то ещё с конфигурацией через XML. Идея заключается
о создании нужного класса в зависимости от типа записи и последующем
раскидовании по пропертям определённых подстрок. Исходные данные выглядят
так:
#123456789012345678901234567890123456789012345678901234567890
SVCLFOWLER         10101MS0120050313.........................
SVCLHOHPE          10201DX0320050315........................
SVCLTWO           x10301MRP220050329..............................
USGE10301TWO          x50214..7050329...............................


C#'ная реализация — см. статью. Лисп в ней, кстати, упоминается,
но пример реализации не приведён.

Rainer Joswig приводит реализацию на Лисп'е:
http://lispm.dyndns.org/news?ID=NEWS-2005-07-08-1

Что более интересно, позже он выложил Quicktime movie, показывающий
процесс разработки Лисп-решения. Торрент доступен тут:
http://www.xach.com/bt/dsl-in-lisp.mov.torrent
Для тех, у кто с торрента скачать не может, здесь отмиррорен сам мувик
http://depni.sinp.msu.ru/~ivan_iv/lisp/dsl-in-lisp.mov
(125 Mb; я, честно говоря, затрудняюсь сказать, почему Rainer Joswig предпочитает
делать квиктаймы, вместо того, чтобы сделать гораздо более компактный swf).

Разработка происходит в среде LispWorks на Power Mac G5. Виден процесс
отладки DSL'я Прошу заметить, в плюсах так просто не посмотришь, во что
разворачивается темплейт. (По поводу самой среды — Personal Edition, более чем
достаточный, чтобы побаловаться, доступен забесплатно для Винды, Мака и Линуха
на сайте www.lispworks.com)

Надеюсь, эти материалы заинтересуют.
Re[2]: AST-based solution
От: fionbio  
Дата: 14.07.05 10:37
Оценка: 54 (9)
[ Эх, обогнали меня Вчера накалякал пример, хоть и башка
была весь день какая-то мутная — странно, не пил вроде. Запостить
вчера моральных сил не хватило ]

Попробую привести решение в духе Лиспа

Если я правильно понимаю, то для публики может представлять
интерес несколько более общее решение задачи. В связи с этим
я хотел бы привести пример с использованием AST. Преимущества
такого подхода, думаю, известны — на основе этой инфраструктуры
можно легко создавать другие, более сложные и полезные генераторы
кода (см R#). Кроме того, мы фактически можем применять подобие
lisp macros к C#.

Если коллег интересует более компактное решение, я могу привести
и сокращённый вариант без деревьев. Также могу сказать, что для Лиспа
есть готовые либы для работы с text templates, например, CL-EMB
(в добавок я ещё свою достаточно удобную примочку как-то написал
для темплейтенья сырцов, я её использовал для VB.NET).

Я буду использовать стандартный Common Lisp Pretty Printer.
Это cразу исключает CLisp, т.к. AFAIK в нём эта часть не доделана.
Код работает с SBCL, Allegro, LispWorks; должен работать с CMUCL.
Данный pretty printer представляет из себя специфическое чудо техники
и конфигурируем в такой степени, что в идеале можно на входе давать
Lisp (списочные структуры), а на выходе получать C#. В силу природной
лени (и, возможно, опыта программирования на Perl ) я воспользовался
в паре мест не особо читабельными строками формата, за что прошу меня
извинить (можно было бы обойтись и без них).

Сразу забегу вперёд и приведу ссылку на решение. Оно может
показаться длинным, на самом деле кода там 70 строк, не
считая данных-примеров, докстрингов функций и комментариев.
Объём, конечно, чудовищный, ничего не скажешь.

Обработанный colorize'ом вариант — тут:
http://depni.sinp.msu.ru/~ivan_iv/lisp/sharpclass.html

Сам исходник — тут:
http://depni.sinp.msu.ru/~ivan_iv/lisp/sharpclass.lisp

Для пущей интересности задачу немного расширим — пусть
для пропертей генерятся не только getter'ы, но и setter'ы,
плюс генерится конструктор без аргументов (в добавок к
конструктору с аргументами) и все классы заворачиваются
в общий namespace

В качестве исходных данных вместо

<objects>
    <object name="Obj1">
        <property name="prop1" type="int"/>
        <property name="prop2" type="string"/>
    </object>
</objects>


мы будем использовать

(namespace "MyNS"
 (object "Obj1"
  (property "prop1" "int")
  (property "prop2" "string")
  (property "dblprop" "double"))
 (object "Obj2"
  (property "someprop" "object[]")))


Следует учесть, что символы namespace, object и property
данным генератором не используются и добавлены здесь для
читабельности.

Вводим промежуточное представление — AST.
Идея заключается в следующем — у нас есть дерево, в
виде символьного выражения записываемое, например, так:
(:namespace "MyTestNS"
 (:class "MyTestClass"
  (:field "int" "_someprop")
  (:constructor "MyTestClass" ((:arg "int" "someprop"))
   (:comment "This is a test")
   (:setf (:id "_someprop") (:id "someprop")))
  (:property "int" "SomeProp"
   (:get (:return (:id "_someprop")))
   (:set (:setf (:id "_someprop") (:id "value"))))
  (:property "int" "AnotherProp"
   (:get (:return 0)))))


В виде XML его можно было бы записать, например, следующим образом:
<namespace name="MyTestNS">
  <class name="MyTestClass">
    <field name="_someprop" type="int"/>
    <constructor name="MyTestClass">
      <args>
        <arg name="someprop" type="int"/>
      </args>
      <body>
        <set>
          <lvalue>
            <identifier name="_someprop">
          </lvalue>
          <rvalue>
            <identifier name="someprop">
          </rvalue>
        </set>
      </body>
    </constructor>
    <property name="SomeProp" type="int">
      ...
    </property>
    ...
</namespace>


Данный AST является достаточно упрощённым, но для наших целей этого
хватит.

Далее, нам надо настроить pretty-printer. Мы определяем способы печати
различных узлов дерева (data-driven approach). Для этого нам нужен следующий framework:

;;; AST printer, much more concise than your CodeDOM and perhaps R# :-P
;;; Can be easily extended to support other language constructs &
;;; several languages simultaneously

;; pretty-print dispatch table: type -> printing func correspondence
(defvar *dispatch* (copy-pprint-dispatch))

(defun ast-print (x &optional (stream *standard-output*))
  "Print the expression x using AST dispatch rules"
  (write x :pretty t :pprint-dispatch *dispatch* :stream stream))

(defun ast-print-form (stream form)
  "Print the AST node (form)"
  (if (and (symbolp (first form))
           (get (first form) 'ast-form))
      (funcall (get (first form) 'ast-form) stream form)
      (error "unknown form: ~S" form)))

;; set dispatch function for cons type in our pretty-print dispatch table
(set-pprint-dispatch 'cons #'ast-print-form 0 *dispatch*)

(defmacro defprinter (name args &body body)
  "Define a printer for specified AST node type"
  (let ((func-name (intern (format nil "PRINT-FORM-~A" name)))
        (item (gensym)))
    `(progn
       (defun ,func-name (stream ,item)
         (destructuring-bind ,args (rest ,item)
           ,@body))
       (setf (get ',name 'ast-form) ',func-name))))


Функция (ast-print ...) печатает AST с использованием созданной
конфигурации. Макрос defprinter позволяет задавать обработчики
узлов дерева с указанием структуры. Функция ast-print-form является
обработчиком, печатающим значения типа cons — он, собственно,
вызывает нужный хендлер.

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

;; определяем простую функцию для печати - чтобы возвращаемое
;; значение не мешало обзору

CL-USER> (defun p (x) (ast-print x) nil)
P

;; играемся

CL-USER> (p '(:id "qwerty"))
qwerty
NIL
CL-USER> (p '(:return (:id "qwerty")))
return qwerty;
NIL
CL-USER> (p '(:property "int" "Qwerty" (:get (:return (:id "qwerty")))))
public int Qwerty
{
    get
    {
        return qwerty;
    }
}
NIL
CL-USER> (p '(:property "int" "Qwerty"
          (:get (:return (:id "qwerty")))
          (:set (:setf (:id "qwerty") (:id "value")))))
public int Qwerty
{
    get
    {
        return qwerty;
    }
    set
    {
        qwerty = value;
    }
}
NIL


Вроде как полезненно. Способствует. Посмотим, что внутрях.
Там есть одна утилитная функция с кривой строкой формата, которая
печатает ... { ... } с новыми строками и индентацией, плюс обработчики.

;;; AST printing specs for C#
;;; (write other specs, get VB.NET, Java, C++, Fortran, etc.)

;; please note that the following function could be writen in a more
;; clear way using pprint-* funcs, but now I'm just too lazy
(defun print-statement-with-body (stream body two-newlines fmt &rest args)
  "Print the statement with brace-enclosed body"
  (format stream
          (if two-newlines
              "~?~:@_~@<{~4i~{~:@_~w~^~:@_~}~i~:@_}~:>"
              "~?~:@_~@<{~4i~{~:@_~w~}~i~:@_}~:>")
          fmt args body))

;; identifier - printed literally
(defprinter :id (id)
  (write-string id stream))

;; private int x;
(defprinter :field (type name)
  (format stream "private ~a ~a;" type name))

;; public int SomeProp { ... }
(defprinter :property (type name &rest body)
  (print-statement-with-body stream body nil "public ~a ~a" type name))

;; get { ... }
(defprinter :get (&rest body)
  (print-statement-with-body stream body nil "get"))

;; set { ... }
(defprinter :set (&rest body)
  (print-statement-with-body stream body nil "set"))

;; return x;
(defprinter :return (expr)
  (format stream "return ~w;" expr))

;; argument
(defprinter :arg (type name)
  (format stream "~a ~a" type name))

;; constructor
(defprinter :constructor (name args &rest body)
  (print-statement-with-body stream body nil "~a(~@<~{~w~^, ~_~}~:>)" name args))

;; a = b;
(defprinter :setf (lvalue rvalue)
  (format stream "~w = ~w;" lvalue rvalue))

;; public class SomeClass { ... }
(defprinter :class (name &rest body)
  (print-statement-with-body stream body t "public class ~a" name))

;; namespace SomeNS { ... }
(defprinter :namespace (name &rest body)
  (print-statement-with-body stream body t "namespace ~a" name))

;; comment
(defprinter :comment (text)
  (format stream "// ~a" text))


Может быть, интересно взглянуть, во что разворачивается defprinter.
Ставим курсор в емаксе на последнюю закрывающуюся скобку и давим Ctrl-C Enter.

(PROGN (DEFUN PRINT-FORM-COMMENT (STREAM #:G288)
         (DESTRUCTURING-BIND (TEXT) (REST #:G288)
                             (FORMAT STREAM "// ~a" TEXT)))
       (SETF (GET ':COMMENT 'AST-FORM) 'PRINT-FORM-COMMENT))


Тут мы видим определение функции для разборки и печати узла
(комментария) и прицепление её к символу :comment (:comment, а не comment —
чтобы это был keyword, не привязанный к пакету — лисповому namespace'у)
через пропертю AST-FORM (здесь пропертя значит именованное значение,
привязанное к символу). #:G288 — сгенерированный (gensym) символ, гарантированно
не конфликтующий с другими именами из environment'а. Вместо
функции можно было бы использовать lambda, но это затруднило бы
отладку — функцию можно отTRACE'ить — после (trace print-form-comment)
в REPL будут выводиться все её вызовы с аргументами и возвращаемыми
значениями.

Следует отметить, что лисповские символы по умолчанию к регистру
не чувствительны (в связи с этим для простоты я решил использовать
строки вместо символов для названий C# пропертей и типов — хотя
проблема решается несложно). Большими буквами обычно выводится ответ Lisp'а.

Давайте ещё раз попробуем:
CL-USER> (p '(:namespace "MyTestNS"
          (:class "MyTestClass"
           (:field "int" "_someprop")
           (:constructor "MyTestClass" ((:arg "int" "someprop"))
        (:comment "This is a test")
        (:setf (:id "_someprop") (:id "someprop")))
           (:property "int" "SomeProp"
        (:get (:return (:id "_someprop")))
        (:set (:setf (:id "_someprop") (:id "value"))))
           (:property "int" "AnotherProp"
        (:get (:return 0))))))
namespace MyTestNS
{
    public class MyTestClass
    {
        private int _someprop;

        MyTestClass(int someprop)
        {
            // This is a test
            _someprop = someprop;
        }

        public int SomeProp
        {
            get
            {
                return _someprop;
            }
            set
            {
                _someprop = value;
            }
        }

        public int AnotherProp
        {
            get
            {
                return 0;
            }
        }
    }
}
NIL


Ну вот, теперь мы кажись могём из символьных выражений генерить C#.
И вроде как даже существенно удобоваримей того же CodeDOM всё выходит.
Ну, теперь дело за малым — делаем функцию-генератор AST на основе
декларативного описания:

;;; Data class generation

(defun generate-csharp-class (object)
  "Generate a C# class from DSL spec"
  (destructuring-bind (class-name . properties) (rest object)
    (loop for (nil prop-name prop-type) in properties
      for sharp-prop-name = (format nil "~:(~a~)" prop-name) ; C# property name
      for field-name = (concatenate 'string "_" prop-name) ; C# field name
      collect `(:arg ,prop-type ,prop-name) into init-args
      collect `(:setf (:id ,field-name) (:id ,prop-name)) into init
      nconc `((:field ,prop-type ,field-name)
          (:property ,prop-type ,sharp-prop-name
            (:get (:return (:id ,field-name)))
            (:set (:setf (:id ,field-name) (:id "value"))))) into props
      finally (return
            `(:class ,class-name
              (:constructor ,class-name ()
               (:comment "NOOP"))
              (:constructor ,class-name ,init-args
               ,@init)
              ,@props)))))

(defun generate-csharp-classes (data)
  "Generate C# classes from DSL spec"
  (destructuring-bind (ns-name . classes) (rest data)
    `(:namespace ,ns-name
      ,@(mapcar #'generate-csharp-class classes))))


generate-csharp-class генерит AST класса на основе
(object "Obj1" ...), а generate-csharp-classes генерит
всё вместе на основе (namespace "MyNS" ...):

;; глянем-ка на AST, интересно всё-таки

CL-USER> (generate-csharp-classes
      '(namespace "MyNS"
        (object "Obj1"
         (property "prop1" "int")
         (property "prop2" "string")
         (property "dblprop" "double"))
        (object "Obj2"
         (property "someprop" "object[]"))))
(:NAMESPACE "MyNS"
 (:CLASS "Obj1" (:CONSTRUCTOR "Obj1" NIL (:COMMENT "NOOP"))
  (:CONSTRUCTOR "Obj1"
   ((:ARG "int" "prop1") (:ARG "string" "prop2") (:ARG "double" "dblprop"))
   (:SETF (:ID "_prop1") (:ID "prop1")) (:SETF (:ID "_prop2") (:ID "prop2"))
   (:SETF (:ID "_dblprop") (:ID "dblprop")))
  (:FIELD "int" "_prop1")
  (:PROPERTY "int" "Prop1" (:GET (:RETURN (:ID "_prop1")))
   (:SET (:SETF (:ID "_prop1") (:ID "value"))))
  (:FIELD "string" "_prop2")
  (:PROPERTY "string" "Prop2" (:GET (:RETURN (:ID "_prop2")))
   (:SET (:SETF (:ID "_prop2") (:ID "value"))))
  (:FIELD "double" "_dblprop")
  (:PROPERTY "double" "Dblprop" (:GET (:RETURN (:ID "_dblprop")))
   (:SET (:SETF (:ID "_dblprop") (:ID "value")))))
 (:CLASS "Obj2" (:CONSTRUCTOR "Obj2" NIL (:COMMENT "NOOP"))
  (:CONSTRUCTOR "Obj2" ((:ARG "object[]" "someprop"))
   (:SETF (:ID "_someprop") (:ID "someprop")))
  (:FIELD "object[]" "_someprop")
  (:PROPERTY "object[]" "Someprop" (:GET (:RETURN (:ID "_someprop")))
   (:SET (:SETF (:ID "_someprop") (:ID "value"))))))

;; ну а теперь на шарп (* - последнее вёрнутое значение)

CL-USER> (p *)
namespace MyNS
{
    public class Obj1
    {
        Obj1()
        {
            // NOOP
        }

        Obj1(int prop1, string prop2, double dblprop)
        {
            _prop1 = prop1;
            _prop2 = prop2;
            _dblprop = dblprop;
        }

        private int _prop1;

        public int Prop1
        {
            get
            {
                return _prop1;
            }
            set
            {
                _prop1 = value;
            }
        }

        private string _prop2;

        public string Prop2
        {
            get
            {
                return _prop2;
            }
            set
            {
                _prop2 = value;
            }
        }

        private double _dblprop;

        public double Dblprop
        {
            get
            {
                return _dblprop;
            }
            set
            {
                _dblprop = value;
            }
        }
    }

    public class Obj2
    {
        Obj2()
        {
            // NOOP
        }

        Obj2(object[] someprop)
        {
            _someprop = someprop;
        }

        private object[] _someprop;

        public object[] Someprop
        {
            get
            {
                return _someprop;
            }
            set
            {
                _someprop = value;
            }
        }
    }
}
NIL

;; вуаля, блин!


У этого, понятное дело, может быть ещё куча применений —
можно генерить разные прокси классы, врапперы к базе/хранимкам и пр., в качестве источника
можно использовать .NET reflection напрямую через RDNZL, DBMS, можно парсить сырцы
через cl-yacc (в отличие от Yacc, препроцессинга он не требует, т.к. грамматика транслируется
макросами — отличный пример их применения, и отлаживается проще, т.к. есть TRACE) и т.д.
Короче говоря, R# на Лиспе написать куда как проще, чем на C#. Можно сделать мегакостыль для .NET.
Оговорка лишь одна — если можете писать на Лиспе, лучше пишите на Лиспе, это проще, чем
на C# с костылями, на чём бы эти костыли написаны не были. В общем и целом — ещё одно
замечательное применение Лиспа — dev tools.

Да, в исходнике я привёл ссылки на "вдохновителей", дублирую. Peter Norvig крут —
на таких, как он, Google держится PAIP читать ВСЕМ — хоть его в нашем краю
и достать не очень легко, оно того стоит — http://www.norvig.com/paip.html

;;;; Inspired by DPP (Dylan Pretty-Printer, a part of Peter Norvig's
;;;; Lisp to Dylan Converter — http://www.norvig.com/ltd/doc/ltd.html)
;;;; and by Dick Waters' paper "Some Useful Lisp Algorithms: Part 2"
;;;; (http://www.merl.com/publications/TR1993-017/)
;;;; See also: XP pretty-printer documentation in XP distribution
;;;; http://www-2.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/lang/lisp/code/io/xp/xp.tgz
Re[3]: Lisp
От: FR  
Дата: 13.07.05 11:37
Оценка: 1 (1) +4 -1 :)))
Здравствуйте, fionbio, Вы писали:


F>а) Научившись программировать на Lisp'е, можно стать асом C#/Java/C++/etc.


Конечно можно стать асом, а можно и не стать, лисп тут ни причем, да и вместо Lisp'а сюда можно много что подставить.

F>Программировать на мейнстриме будете с отвращением, но качественно. И смысл разных

F>design patterns и пр. хрени станет яснее, чем для авторов этих концепций

Угу солнце наверно тоже всходит и заходит только благодоря лиспу.
Re[13]: Lisp
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 18.07.05 12:05
Оценка: 72 (8)
ANS>Здравствуйте, AndrewVK, Вы писали:

AVK>>Вопросы:

AVK>>1) Валидация исходной схемы?
AVK>>2) Собственно генерирующий код?
AVK>>3) Возможность генерации нескольких разных исходников по одной модели?

Всё дело проверялось на LispWorks 4.4 Personal Ed. for Win.

Перед кодом краткое пояснение:
(format t "..." ...) — выводит строку в поток (t — на стандартный вывод). Формат "~&" — новая строка; "~t" — табуляция; "~A" подставляет значение соответсвующего параметра.

(defun gen-constructor (name proplist)
  (format t "~&~tpublic ~A " name)
  ;вывод через з.п.т параметров конструктора
  ;может его можно записать короче, но я не знаю как ;)
  (format t "(~A)" (reduce #'(lambda (a b) (concatenate 'string a ", " b))
      (loop for e in proplist 
           if e collect (concatenate 'string (first e) " " (second e)))
        )
  )
  (format t "~&~t{")
  ;вывод инициализации переменных
  (dolist (i proplist) (format t "~&~t~t_~A = ~A;" (second i) (second i)))
  (format t "~&~t}")
)

(defmacro object (name &body body)
 `(progn 
      (format t "~&class ~A {" ,name)
      ;(eval e) выполняет все вложенные определения свойств
      ;и собирает список пар (тип имя-свойства) по которым и генерируется конструктор
            ;если тут будет не только property, а, например, еще и constant
            ;то тот метод должен вернуть пустой список.
            ;при генерации конструктора эти пустые значения будут отброшены
      (gen-constructor ,name (loop for e in '(,@body) collect (eval e)))
      (format t "~&}~%")
  )
)

(defmacro property (&key name type)
 `(progn
    (format t "~&~tprivate ~A _~A;" ,type ,name)
    (format t "~&~tpublic ~A ~A {" ,type (string-capitalize ,name) )
    (format t "~&~t~tget { return _~A; }" ,name)
    (format t "~&~t}")
        ;выводит в поток определения свойств, и возвращает пару (тип имя-свойства)
    ;для генерации конструктора
    (list ,type ,name)
  )
)


Итого:
Самая сложная часть — вывод параметров конструктора через з.п.т. Меняя эти три функции получаем возможность генерировать разные исходники.

В качестве исходного дерева возьмём:

(object "Test" 
    (property :name "prop1" :type "int")
    (property :name "prop2" :type "string")
)


Результат:
class Test {
 private int _prop1;
 public int Prop1 {
  get { return _prop1; }
 }
 private string _prop2;
 public string Prop2 {
  get { return _prop2; }
 }
 public Test (int prop1, string prop2)
 {
  _prop1 = prop1;
  _prop2 = prop2;
 }
}


Так же, если, постоянно заглядывая в доку, я и смог написать этот фрагмент, то на валидацию
меня уже не хватает. Идея, как реализовать валидацию, у меня такая: завести динамическую переменную, в которой будет хранится список допустимых "тегов". Методы object, property проверяют валидность своих параметров, и, заглядывая в переменную определяют, могут ли они находится на этом уровне вложенности. Это должно получится еще короче, чем методы генерирующие код.
Интересный вопрос: нафига тут валидация вообще? Всё равно, истина в последней
инстанции — это компилятор. С валидацией у тебя есть куча мест, где можно ошибится:
код генерирующий исходный описатель это раз, схема данных это два, генератор это три.
Какой прок от валидации в данном случае?


А теперь пару критических слов о Common Lisp после написания на нём этой программки.

Во-первых, если вас спросят, есть ли что-то общее между Perl и CL, смело отвечайте — есть. "Птичий" язык в CL не уступает перловому: В вышеприведённом коде употребляются модификаторы из прямого апострофа, диеза-и-апострофа, обратного апострофа, запятой, запятой-и-собаки, двоеточия, амперсанда. Есть еще правила их использования внутри "квоченного" текста.

Именование и количество методов — это песня. Если CONS, CAR, CDR — еще запоминается без проблем, то, например, MAP, MAPC, MAPCAR, MAPCAN, MAPL, MAPLIST, MAPCON — и каждая со своими вариантами поведения — это уже перебор. Вот набор повеселее: CAR, CDR, CAAR, CADR, CDAR, CDDR, CAAAR, CAADR, CADAR, CADDR, CDAAR, CDADR, CDDAR, CDDDR, CAAAAR, CAAADR, CAADAR, CAADDR, CADAAR, CADADR, CADDAR, CADDDR, CDAAAR, CDAADR, CDADAR, CDADDR, CDDAAR, CDDADR, CDDDAR, CDDDDR. Разбираться с этим в программе? Я пас.

Неконсистентность. Например:
EVERY — первый параметр это предикат, второй — список.
APPLY — первый параметр — функция, второй — неограниченной число аргументов. (Внутри функции — и то и то — список, а вот с вызывающей стороны выглядит по другому. После smalltalk-овского единообразия это удивляет.)
MAP — первый параметр — тип результата, второй — функция, третий — неограниченное число списков.
DOLIST — первый параметр — пара(!) из имени переменной и обрабатываемого списка, потом тело метода.
DO — первый параметр — список типа (имя-переменной инициализатор-переменной имя-пер...).
LOOP — это вообще не LISP (это демонстрация использования не-лиспа в лиспе)! Пример:
(loop for i in '(1 324 2345 323 2 4 235 252)
when (oddp i)
do (print i)
and collect i into odd-numbers
and do (terpri)
else
collect i into even-numbers
finally
(return (values odd-numbers even-numbers)))
Там к LOOP идёт нехилое руководство.
и еще под конец — PROGV — первый параметр — список имён локальных переменных (может вычислятся в ран-тайме), второй — список начальных значений для переменных. Сравните это с "DO"
Короче, пилите, Шура, они зол... Э... В смысле, это не возможно понять это нужно запомнить!

По непонятной мне причине функции map, concatenate, merge требуют задать тип результата. Например: (concatenate 'string a ", " b)

Дальше: логика, по которой (lambda (x) (* x x)) — это не замыкание а _имя_ замыкания мне кажется несколько инородной Само замыкание достаётся по '#(lambda (x) (* x x))

Ну, и на последок: лисповая подсветка в фаре глючит

В защиту нужно сказать, что в CL есть вроде все(!) возможности из других языков. Лексические, динамические переменный, продолжаемые исключения, возвращение множества результатов с удобным доступом к ним, ключевые параметры, необязательные параметры, неограниченное число параметров, макры, поддержка ООП, мультиметоды, всякие :before, :after и пр. хуки, поддержка функционального программирования, патерн-матчинг, продолжения, замыкания, поддержка GOTO (через tagbody и go), бактрекинг. Что я забыл?
И в конце концов, как по мне, то грехемовская "On Lisp" — неплохая книга.
... << RSDN@Home 1.1.4 stable rev. 510>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[2]: Lisp
От: CrazyPit  
Дата: 14.07.05 05:35
Оценка: 45 (7)
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, fionbio, Вы писали:


AVK>А можно увидеть на лиспе решение следующей задачи:

AVK>Имеем некое текстовое описание модели каких либо объектов. Пусть это будет xml. Например:
AVK>
AVK><objects>
AVK>    <object name="Obj1">
AVK>        <property name="prop1" type="int"/>
AVK>        <property name="prop2" type="string"/>
AVK>    </object>
AVK></objects>
AVK>

AVK>Требуется сгенерировать код на C# примерно такого вида:
AVK>
AVK>public class Obj1
AVK>{

AVK>    public Obj1(int prop1, string prop2)
AVK>    {
AVK>        _prop1 = prop1;
AVK>        _prop2 = prop2;
AVK>    }

AVK>    private int _prop1;
    
AVK>    public int Prop1
AVK>    {
AVK>        get { return _prop1; }
AVK>    }
    
AVK>    private string _prop2;
    
AVK>    public string Prop2
AVK>    {
AVK>        get { return _prop2; }
AVK>    }
AVK>}
AVK>

AVK>?
AVK>Интересует решение именно в духе лиспа.

Что вас конкретно интересует? Простой генератор? Тогда здесь лисп не будет принципиально лучше других языков. Или DSL на основе макросов, который будет генерировать native код и позволит использовать всю мощь лиспа внутри этого макроса, вот второе это уже то в чём лисп силён. (но я пока не силён В том же Practical Common Lisp две предпоследнии главы посвещены этой теме, только там генерируется html.

Ещё буквально недвано видел comp.lang.lisp упоминание о некой DSL на лисп с помощью который один товарищ, по его словам генерит из 400 строк лиспового кода 25000 строк кода на C#, вот к нему можно обратиться с вопросом... Вот здесь в конце есть его цитата.

Приведу её и здесь:


powerful business example
I believe there is a way — macros (real lisp macros). A key to significant business app development productivity is automation. Too much code written in business apps is code of similar patterns.

So the tool of the "top programmer(s)" is a tool to write code that writes code (macros). Then the average programmer glues the pieces together. I know this works because I have proven the concept, albeit in a rather crude way, using Lisp to generate C#. 400 lines of a Lisp DSL generate 25,000 lines of working C# app.

So if we focus on a different aspect of language development, where the .NET or Java VMs are merely the intermediate language, we can have a good high level language, and full intereoperability with components. It is also easier to introduce new languages and concepts to the top programmer in an organization, than to the programming community at large.
By Alex Peake at Tue, 04/12/2005 — 14:55 | reply to this comment


Но я всё-таки, в рамках тренеровки, написал простой генератор, который делает примерно то-что вы написали, только не из XML а из sexpr'ов, т.к. мне сейчас лень возиться с каким-то либами (так-что всё написано на чистом CL), но я думаю с помощью CL-XML можно быстро преобразовать XML в тот вид что у меня, или вообще сделать всё намного короче.


(defparameter *test-desc*
 '(:objects
   (:object :name "Obj1"
    (:property :name "prop1" :type "int")
    (:property :name "prop2" :type "string"))
   (:object :name "Obj2"
    (:property :name "foo10" :type "string")
    (:property :name "bar12" :type "sometype"))))


Вроде практически аналогично XML.

Вот реализация:


(defpackage :c-sharp-simple-class-generator
  (:use :common-lisp)
  (:export generate-classes))

(in-package :c-sharp-simple-class-generator)

(defparameter *test-desc*
 '(:objects
   (:object :name "Obj1"
    (:property :name "prop1" :type "int")
    (:property :name "prop2" :type "string"))
   (:object :name "Obj2"
    (:property :name "foo10" :type "string")
    (:property :name "bar12" :type "sometype"))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Следующие функции преобразуют из вида sexpr близкого к XML к удобному для обработки виду.
(defun get-all-fields (list name)
  (loop for field in list
    when  (and (consp field)
         (eq (first field) name))
    collect (rest field)))

(defun propertys (object)
   (get-all-fields object :property))

(defun objects (description)
  (get-all-fields description :object))

(defun normalize-object (object)
  (append (remove-if-not #'atom object)
      `(:propertys  ,(propertys object))))

(defun normalize-objects (description)
  (mapcar #'normalize-object (objects description)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Шаблоны

(defparameter *constructor-template*
"
    public ~a (~{~a~^, ~}) {
~{      ~a~}
    }
")

(defparameter  *prop-and-access-method-template*
"
    private ~a _~a;
    
    public ~a ~@(~a~)
    {
        get { return _~a; }
    }
")


(defparameter *class-template*
"
public class ~a
{
  ~a
  ~a
}
")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Собственно генерация
(defmacro list-format (list format-string keys format-args)
  `(mapcar #'(lambda (elem)
           (destructuring-bind (&key ,@keys) elem
         (format nil ,format-string ,@format-args)))
    ,list))

(defun generate-constructor (name propertys)
  (format nil *constructor-template*        
        name
        (list-format propertys "~a ~a" (type name) (type name))
        (list-format propertys "  _~a = ~a;~%" (type name) (name name))))


(defun generate-private-propertys-and-access-methods (propertys)
  (format nil "~{~a~%~}" 
      (list-format propertys *prop-and-access-method-template*
               (type name) (type name type name name))))


(defun generate-class-from-normalized (&key name propertys)
  (format nil
      *class-template*
      name
      (generate-constructor name propertys)
      (generate-private-propertys-and-access-methods propertys)))

(defun generate-classes (description)
  (format nil "~{~a~%~}"
           (mapcar (lambda (object) (apply #'generate-class-from-normalized object))
               (normalize-objects description))))


Вывод:
C-SHARP-SIMPLE-CLASS-GENERATOR> (generate-classes *test-desc*)
"
public class Obj1
{
  
    public Obj1 (int prop1, string prop2) {
        _prop1 = prop1;
        _prop2 = prop2;

    }

  
    private int _prop1;
    
    public int Prop1
    {
        get { return _prop1; }
    }


    private string _prop2;
    
    public string Prop2
    {
        get { return _prop2; }
    }


}


public class Obj2
{
  
    public Obj2 (string foo10, sometype bar12) {
        _foo10 = foo10;
        _bar12 = bar12;

    }

  
    private string _foo10;
    
    public string Foo10
    {
        get { return _foo10; }
    }


    private sometype _bar12;
    
    public sometype Bar12
    {
        get { return _bar12; }
    }


}

"


Сейчас нет времени оформить покрасивше с комментами, попозже, возможно оформлю.
Запускать собственно (generate-classes *test-desc*).
Решение на Питоне
От: eugals Россия  
Дата: 18.07.05 21:07
Оценка: 29 (5)
Здравствуйте, AndrewVK, Вы писали:

AVK>А можно увидеть на лиспе решение следующей задачи:

AVK>Имеем некое текстовое описание модели каких либо объектов.

Возможно обчеству будет интересно как это было бы удобно делать на Питоне:
Код генератора (test.py):
class CSClass(object):
    @classmethod
    def genSharpCode(csclass):
        props = sorted((n, desc.tp_name) for n, desc in vars(csclass).items() if isinstance(desc, CSProp))
        # заголовок класса
        code = "public class %s\n" % csclass.__name__
        code += "{\n"
        # конструктор
        code += "\tpublic %s(%s)\n" % (csclass.__name__, ", ".join("%s %s" % (t, n) for n, t in props))
        code += "\t{\n"
        for name, _ in props:
            code += "\t\t_%s = %s;\n" % (name, name)
        code += "\t}\n"
        # свойства
        for name, typ in props:
            code += ("\n\tprivate %(typ)s _%(name)s;\n\n" +
                     "\tpublic %(typ)s %(name)s\n" +
                     "\t{\n" +
                     "\t\tget { return _%(name)s; }\n" +
                     "\t}\n") % vars()
        code += "}"
        return code

class CSProp(property):
    def __init__(self, typ):
        self.tp_name = typ.__name__

# объявления поддерживаемых типов свойств (типы int и bool - не описываю, т.к. они уже есть в питоне под нужными именами)
class string(str): pass
class double(float): pass

# разбор параметров запуска
import sys
module = {}
eval(compile(file(sys.argv[1]).read(), sys.argv[1], "exec"), globals(), module)
for csclass in module.itervalues():
    if issubclass(csclass, CSClass):
        print csclass.genSharpCode()

фaйл исходных данных (test.classes):
class Obj1(CSClass):
    prop1 = CSProp(int)
    prop2 = CSProp(bool)

class Obj2(CSClass):
    prop3 = CSProp(string)
    prop4 = CSProp(double)


запускать так:
d:\>python test.py test.classes


Обратите внимание, что для разрешения имен элементов/атрибутов/типов-свойств используется сам интерпретатор питона, который, попутно, очень даже замечательно их все и валидирует.

Результат:
public class Obj1
{
    public Obj1(int prop1, bool prop2)
    {
        _prop1 = prop1;
        _prop2 = prop2;
    }

    private int _prop1;

    public int prop1
    {
        get { return _prop1; }
    }

    private bool _prop2;

    public bool prop2
    {
        get { return _prop2; }
    }
}
public class Obj2
{
    public Obj2(string prop3, double prop4)
    {
        _prop3 = prop3;
        _prop4 = prop4;
    }

    private string _prop3;

    public string prop3
    {
        get { return _prop3; }
    }

    private double _prop4;

    public double prop4
    {
        get { return _prop4; }
    }
}

AVK>Интересует решение именно в духе лиспа.
Кстати, да — вполне в лисповском духе получилось...
... << RSDN@Home 1.1.4 stable rev. 510>>
Re: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 12.07.05 12:46
Оценка: 1 (1) +4
Здравствуйте, fionbio, Вы писали:

А может ты статейку нам сбацаешь?
... << RSDN@Home 1.1.4 beta 7 rev. 466>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[3]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 02:51
Оценка: -1 :))) :)
Здравствуйте, fionbio, Вы писали:

F>Ещё подход -

F>использование Лиспа для прототипизирования. Написать программу или некий её
F>фрагмент на Лиспе (или иногда хотя бы представить ), а затем переписать
F>на том же шарпе (раз того хочет народ/заказчик/менеджер/хозяин ) зачастую
F>позволяет получить результат быстрее & качественнее.

Ну, это для ламеров. Правильный народ следом пишет генераторы кода, которые из протатипа на Лиспе генерирует законченное приложение на Шарпе.
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[6]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 04:51
Оценка: 30 (4)
Здравствуйте, AndrewVK

Ну вот, наваял сегодня утром. За объем прошу не пинать -- не люблю я сильно компактные навороты. Да и с XML-ем я на "вы", поэтому код парсинга XML был нагло взят из книжки "Programming Ruby 2nd Edition".

require 'rexml/document'

# Для сохранения значений property чтобы не дергать каждый раз xpath.
class    Property
    attr_accessor    :name
    attr_accessor    :type

    def initialize( a_name, a_type )
        @name = a_name
        @type = a_type
    end

    # Имя атрибута в генерируемом классе.
    def attribute_name
        return "_#{name}"
    end
end

# Формирует строку параметров конструктора генерируемого класса.
# Нужен для того, чтобы не ставить запятую после последнего параметра.
def constructor_param_maker( p )
    r = ""
    for i in 0...p.length do
        r = r + "#{p[i].type} #{p[i].name}#{', ' if i+1 < p.length}"
    end
    r
end

# Считываем файл, имя которого указано первым аргументом командной строки.
# Note: я не понял, почему REXML не хочет работать ни с $<, ни с $stdin, а
# разбираться особо нет времени.
xml = REXML::Document.new( File.open( $*[0] ) )

# Обрабатываем все теги <object> и генерируем код класса.
xml.elements.each( "//object" ) do |o|
    class_name = o.attributes[ "name" ]

    # Сразу сохраняем все <property> чтобы затем xpath не трогать.
    properties = Array.new
    o.elements.each( "property" ) do |p|
        properties << Property.new( p.attributes[ "name" ], p.attributes[ "type" ] )
    end

    puts "public class #{class_name}\n" +
        "{\n\n" +
        "\tpublic #{class_name}( #{constructor_param_maker(properties)} )\n" +
        "\t{\n"

    properties.each do |p| puts "\t\t#{p.attribute_name} = #{p.name}\n" end

    puts "\t}\n\n"

    properties.each do |p|
        puts "\tprivate #{p.type} #{p.attribute_name};\n\n" +
            "\tpublic #{p.type} #{p.name}\n" +
            "\t{\n" +
            "\t\tget { return #{p.attribute_name}; }\n" +
            "\t}\n\n"
    end

    puts "}\n"
end


Запускать так:
ruby gen.rb <file.xml>

результат печатается на стандартный поток вывода.

Если на входе:
<objects>
    <object name="Obj1">
        <property name="prop1" type="int"/>
        <property name="prop2" type="string"/>
    </object>
</objects>

то на выходе:
public class Obj1
{

    public Obj1( int prop1, string prop2 )
    {
        _prop1 = prop1
        _prop2 = prop2
    }

    private int _prop1;

    public int prop1
    {
        get { return _prop1; }
    }

    private string _prop2;

    public string prop2
    {
        get { return _prop2; }
    }

}


Если на входе:
<objects>
    <object name="Obj1">
        <property name="prop1" type="int"/>
        <property name="prop2" type="string"/>
    </object>
    <object name="AnotherObject">
    </object>
    <object name="YetAnotherObject">
        <property name="a" type="int"/>
        <property name="b" type="string"/>
        <property name="c" type="AnotherObject"/>
    </object>
</objects>

то на выходе:
public class Obj1
{

    public Obj1( int prop1, string prop2 )
    {
        _prop1 = prop1
        _prop2 = prop2
    }

    private int _prop1;

    public int prop1
    {
        get { return _prop1; }
    }

    private string _prop2;

    public string prop2
    {
        get { return _prop2; }
    }

}
public class AnotherObject
{

    public AnotherObject(  )
    {
    }

}
public class YetAnotherObject
{

    public YetAnotherObject( int a, string b, AnotherObject c )
    {
        _a = a
        _b = b
        _c = c
    }

    private int _a;

    public int a
    {
        get { return _a; }
    }

    private string _b;

    public string b
    {
        get { return _b; }
    }

    private AnotherObject _c;

    public AnotherObject c
    {
        get { return _c; }
    }

}
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[3]: Lisp
От: Mishka Норвегия  
Дата: 13.07.05 09:48
Оценка: 26 (1) +3
Здравствуйте, eao197, Вы писали:

M>>1. Как найти работу программистом на Lisp?

E>Вот об этом есть интересная автобиография: Lisping at JPL

То есть: "хочешь есть, не трогай lisp?"

В этой истории не упоминается одна вещь — для того, чтобы писать на Lisp, нужно думать, что хорошо говорит о людях, его использующих.
Но проекты зависят от людей, а не от языков программирования. Хороший программер закончит проект и на VB в срок и в рамках бюджета, а плохому даже Lisp не поможет.
Так что "наш проект провалился из-за того, что мы не использовали Lisp" — это детский лепет

P.S. Немножко не по теме, но всё же. Microsoft собирается избавится от VBA и пересадить всех на .NET. Для меня это хорошая новость, но вот наши desk developer-ы этому не слишком рады — придётся больше думать, и C# — это не VBA. Попробуй кто меня пересадить на Lisp, я б тоже наверно не был бы слишком счастлив.
Re[19]: AST-based solution
От: cranky Украина  
Дата: 16.07.05 17:47
Оценка: 2 (1) :)))
Здравствуйте, ON, Вы писали:

>> ON>Вот просто по здравому смыслу. Каким образом "семантика определяется по первому элементу списка", если этот список содержит Лямбда-выражение, то есть названия функции там напрочь нет.

>> Ну, лямбда-выражение и определяет семантику... Название совсем не обязательно.

ON>То есть выражение является семантикой не названия функции, а семантикой списка параметров. И такое прекрасно работает. Значит мы можем сделать множество функций с именами и проверяя в некоторой области видимости возможность применения этих функций по "семантике списка параметров", вычислять результаты с снабжать их меткой, что этот результат получен такой-то функцией. То есть имя функции используется совсем не для ее вызова, а приписывается результату после выполнения.

Всё дело в том, что семантика списка параметров инвариантна к так называемому эмпирическому способу применения с-выражений по базису лямбда-функции порядка определяемого результатом побочного действия интерпретации ку-ди-дэра от списка абстрактного замыкания, вычисляемого путём рекурсивного повторения вышеприведённого алгоритма, что в свою очередь не может не порождать многочисленных проблем.
Короче, о чём идёт речь, можете пояснить человеческим языком?
ON>Это механизм так называемой интуиции. Грубо говоря вычислений без алгоритмов и как следствие без программистов.
You aren't expected to absorb this
Re[6]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 13.07.05 12:45
Оценка: 1 (1) +3
Здравствуйте, Курилка, Вы писали:

E>>>>Как мне кажется, первое, что в духе Лиспа нужно будет сделать, так это написать описание на самом Лиспе:

E>>>>
E>>>>(objects
E>>>>    (object
E>>>>        (property (name prop1) (type int))
E>>>>        (property (name prop2) (type string))))
E>>>>


К>>>Если оставлять условие, то XML распарсить должно не ставить проблем

E>>>>А потом окажется, что с помощью defmacro сам objects является кодом по генерации C# кода.

К>Вопрос — а DSL ты откуда взял? Т.е. описание его не включается в решение?


Ну, будь я Lisp-программистом, то привел бы полное решение. Просто прочитав столько отзывов о Lisp-е я пришел к мнению, что основная фича Lisp-а -- это возможность простого построения DSL для конкретной задачи. Т.е., вместо решения чего-нибудь в лоб (как зачастую делается с помощью гор кода на императивных языках), на Lisp-е делается DSL, в котором решение конкретной задачи записывается всего несколькими строчками.

Собственно в том, что построение конкретного DSL выполняется средствами самого языка, и в результате получается тот же Lisp -- и есть, имхо, главное преимущество над C++. Т.е. в C++ так же можно подобные фокусы делать, но навороты на шаблонах могут быть сильно сложными и, все-таки, ограниченными, а применение внешних инструментов типа Yacc/Lex для создания DSL -- то еще удовольствие. И главное, получается несколько разных языков, тогда как в Lisp-е язык один.

Но только в этой области у Lisp-е есть конкуретны. Тот же Ruby позволяет строить вполне нормальные DSL оставаясь в рамках Ruby-синтаксиса.

Да и такая гибкость Lisp-а, как указывал, кажется, Cyberax, оборачивается его главным недостатком. Лишком легко создать свой DSL, который кроме тебя никому не нравится и в котором другим разработчикам сложно ориентироваться.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[2]: Lisp
От: Трурль  
Дата: 13.07.05 12:35
Оценка: +2 :))
Здравствуйте, AndrewVK, Вы писали:

AVK>Интересует решение именно в духе лиспа.

В духе лиспа будет генерировать код лиспе, а не на C#
Re[4]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.07.05 16:33
Оценка: +2 :))
Здравствуйте, eao197, Вы писали:

E>А если еще и исходное описание на Lisp-е сделать, то вообще ничего генерировать не нужно будет.


А если еще и ничего вообще не делать, то и голова болеть не будет.
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[7]: AST-based solution
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 11:38
Оценка: 25 (3)
Здравствуйте, eao197, Вы писали:

AVK>>Можно. Только вот одна засада — жутко неудобно. Привести пример xsd, или на слово поверишь, что будет на порядок лаконичнее?


E>Андрей, если не сложно, приведи -- мне интересно.


Не сложно. Правда на таком примитивном примере не все будет видно.
<xs:schema
        targetNamespace="sample_model"
        xmlns:xs="http://www.w3.org/2001/XMLSchema"
        elementFormDefault="qualified">
    <xs:element name="objects">
        <xs:complexType>
            <xs:all minOccurs="1">
                <xs:element name="object">
                    <xs:complexType>
                        <xs:all minOccurs="1">
                            <xs:element name="property">
                                <xs:complexType name="">
                                    <xs:attribute name="name"/>
                                    <xs:attribute name="type"/>
                                </xs:complexType>
                            </xs:element>
                        </xs:all>
                        <xs:attribute name="name"/>
                    </xs:complexType>
                </xs:element>
            </xs:all>
        </xs:complexType>
    </xs:element>
</xs:schema>
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[3]: Lisp
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 15.07.05 16:10
Оценка: 10 (3)
Здравствуйте, Курилка, Вы писали:

ON>>2. Что нельзя написать на Лисп? То есть куда отодвигается горизонт "слишком сложно" при переходе на Лисп.


К>На мой взгляд будет сложно, или точнее малоцелесообразно писать низкоуровневый "железный" код на лиспе, т.к. всёже там есть сборщик мусора и проч. довольно высокоуровневые инструкции языка. Т.е. аналогия с забиванием гвоздей микроскопом. Для таких задч лучше использовать более подходящие инструменты — ассемблер, си (и молоток )


Movitz:

The Movitz system aspires to be an implementation of ANSI Common Lisp that targets the ubiquitous x86 PC architecture "on the metal". That is, running without any operating system or other form of software environment. Movitz is a development platform for operating system kernels, embedded, and single-purpose applications.

... << RSDN@Home 1.1.4 stable rev. 510>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[3]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 09:06
Оценка: 4 (3)
Здравствуйте, mishaa, Вы писали:

M>А давайте ее немножко усложним, такую то задачку когда в одном из проектов пришла идея о кодогенерации я решел после пятиминутного чтения xslt титориала, а чуть позже она чуть задача усложнилась, и так с ходу написать преобразование не вышло.


Эээ, тут вобще то лисп обсуждается, а не xslt. Что же касается xslt, то, если тебе интересно, на практике я на нем реализовывал весьма сложные шаблоны.

M>Собствено задача:


M>есть:


M>
M><object name="A">
M>    <extension object="B">
M></object>

M><object name="B">
M>    <extension object="C">
M></object>

M><object name="C"/>
M>



M>Надо:



M>

M>class A
M>{
M>   public static C getInstance()
M>   {
M>       return new A(new B(new C()));
M>   }
M>}

M>class B
M>{
M>   public static C getInstance()
M>   {
M>       return new B(new C());
M>   }
M>}

M>class C
M>{
M>   public static C getInstance()
M>   {
M>       return new C();
M>   }
M>}
M>


Понятно. Собственно такая задачка может быть решена 2 способами:
1) Избавиться от явной рекурсивности путем перепроектирования того, что должно генерироваться. Например в твоем случае можно было бы заменить код вызова конструктора на такой (для класса A)
return new A((B)B.getInstance());

В этом случае написать шаблон не составит труда даже новичку.
2) Написать рекурсивный шаблон.
Рекурсивный вариант я продемонстрирую. Правда несколько поправок. Во-первых твой xml невалиден. Я доделал его так:
<objects>
    <object name="A">
      <extension object="B"/>
    </object>
    <object name="B">
      <extension object="C"/>
    </object>
    <object name="C"/>
</objects>

Во-вторых результирующий код тоже невалиден. Я предположил, что ты пропустил объявление базового класса. На основании этого получается такой шаблон:
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="text"/>

    <xsl:template match="/objects">
// Recursive templates sample output
        <xsl:apply-templates/>
    </xsl:template>
    
    <xsl:template match="object">
public class <xsl:value-of select="@name"/>
    <xsl:if test="extension"> : <xsl:value-of select="extension/@object"/></xsl:if>
{
    public static <xsl:call-template name="instance-type">
            <xsl:with-param name="object" select="."/>
        </xsl:call-template> getInstance()
    {
        return <xsl:call-template name="ctor-call">
            <xsl:with-param name="object" select="."/>
        </xsl:call-template>;
    }
}
    </xsl:template>
    
    <xsl:template name="instance-type">
        <xsl:param name="object"/>
        <xsl:choose>
            <xsl:when test="not($object/extension)">
                <xsl:value-of select="$object/@name"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:call-template name="instance-type">
                    <xsl:with-param name="object" select="/objects/object[@name = $object/extension/@object]"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    
    <xsl:template name="ctor-call">
        <xsl:param name="object"/>
        <xsl:variable name="not-term" select="$object/extension"/>
        
        <xsl:text>new </xsl:text>
        <xsl:value-of select="$object/@name"/>
        <xsl:text>(</xsl:text>
        <xsl:if test="$not-term">
            <xsl:call-template name="ctor-call">
                <xsl:with-param name="object" select="/objects/object[@name = $object/extension/@object]"/>
            </xsl:call-template>
        </xsl:if>
        <xsl:text>)</xsl:text>
    </xsl:template>
</xsl:stylesheet>


Результат работы:
// Recursive templates sample output
        
public class A : B
{
    public static C getInstance()
    {
        return new A(new B(new C()));
    }
}
    
public class B : C
{
    public static C getInstance()
    {
        return new B(new C());
    }
}
    
public class C
{
    public static C getInstance()
    {
        return new C();
    }
}
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[2]: Lisp
От: fionbio  
Дата: 13.07.05 10:59
Оценка: 1 (1) +1 :)
Здравствуйте, Mishka, Вы писали:

M>Я со всем согласен, но есть два вопроса:


M>1. Как найти работу программистом на Lisp?


а) Скорее всего, никак — во всяком случае, в нашей стране, если только
очень повезёт. Говорят, серьёзные товарищи на #lisp в основном бабки
зашибают удалённо — но это уж совсем повезти должно.

б) self-employment

M>2. Как получать больше денег программируя на Lisp, чем, например, на C# или VBA?


а) Научившись программировать на Lisp'е, можно стать асом C#/Java/C++/etc.
Программировать на мейнстриме будете с отвращением, но качественно. И смысл разных
design patterns и пр. хрени станет яснее, чем для авторов этих концепций Ещё подход —
использование Лиспа для прототипизирования. Написать программу или некий её
фрагмент на Лиспе (или иногда хотя бы представить ), а затем переписать
на том же шарпе (раз того хочет народ/заказчик/менеджер/хозяин ) зачастую
позволяет получить результат быстрее & качественнее.

б) self-employment
Re: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 13.07.05 11:36
Оценка: 1 (1) +2
Здравствуйте, fionbio, Вы писали:

А можно увидеть на лиспе решение следующей задачи:
Имеем некое текстовое описание модели каких либо объектов. Пусть это будет xml. Например:
<objects>
    <object name="Obj1">
        <property name="prop1" type="int"/>
        <property name="prop2" type="string"/>
    </object>
</objects>

Требуется сгенерировать код на C# примерно такого вида:
public class Obj1
{

    public Obj1(int prop1, string prop2)
    {
        _prop1 = prop1;
        _prop2 = prop2;
    }

    private int _prop1;
    
    public int Prop1
    {
        get { return _prop1; }
    }
    
    private string _prop2;
    
    public string Prop2
    {
        get { return _prop2; }
    }
}

?
Интересует решение именно в духе лиспа.
... << RSDN@Home 1.2.0 alpha rev. 558>>
AVK Blog
Re[5]: Lisp
От: Cyberax Марс  
Дата: 13.07.05 14:32
Оценка: +3
eao197 wrote:

> AVK>Я так и знал. Мне не нужно генерить код на Лиспе, мне нужно

> генерить код на шарпе. Ну, предположим, у меня есть большой проект на
> дотнете, который никто под лисп переписывать не будет никогда. И для
> него нужно написать вот такую штуку.
> А нельзя разве XSLT преобразовать XML в Lisp-подобный формат, а затем
> скормить Lisp-овской программе?

А может тогда проще — сразу в C# преобразовать XSLем?

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[9]: AST-based solution
От: Cyberax Марс  
Дата: 14.07.05 14:47
Оценка: 24 (2)
VladD2 wrote:

> Кстати, а как получить ХСД для некоторого ХМЛ-я? Кто-нить умеет

> ревер-инжинирить ХМЛ?

Я пользовался когда-то XMLSpy'ем для этого.

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[2]: Lisp
От: faulx  
Дата: 14.07.05 06:17
Оценка: 11 (2)
Здравствуйте, AndrewVK, Вы писали:

AVK>Интересует решение именно в духе лиспа.


Не знаю, насколько в духе Лиспа. Это моя первая программа на Лиспе, так что, возможно, все делается совсем не так. Работает на Lisp In A Box, с CLISP, под Windows

(defmacro c (&rest strs)
  "Выполняет конкатенацию строковых аргументов. Стандартная функция слишком длинная."
  `(concatenate 'string ,@strs))

(defun mapconcat (fun seq sep)
  "Вызывает функцию `fun' для каждого элемента списка `seq' и сцепляет результаты, разделяя их строкой `sep'."
  (cond ((null seq)
         seq)
        ((null (cdr seq))
         (funcall fun (car seq)))
        (t
         (c (funcall fun (car seq)) 
            sep 
            (mapconcat fun (cdr seq) sep)))))

(defun property (&key name type)
  "Убирает слово property и возвращает просто список из двух элементов."
  `(,name ,type))

(defmacro objects (&body objs)
  "Выполняет подряд функции, переданные в тело макроса."
  `(progn ,@objs))

(defun get-ctor-param (props)
  "Получает строку параметров для конструктора"
  (mapconcat 
   (lambda (prop) 
     (c (second prop) " " (first prop)))
   props ", "))

(defun get-prop-init (props)
  "Получает список строк, каждая из которых инициализирует поле класса."
  (mapcar (lambda (prop)
            (let ((name (first prop)))
              (c "_" name " = " name ";")))
          props))

(defun get-prop-field (props)
  "Получает строку с объявлением поля и property."
  (mapcar (lambda (prop)
            (let ((name (first prop))
                  (type (second prop)))
              (c 
"    private " type " _" name ";

    public " type " " (string-capitalize name) "
    {
        get { return _" name "; }
    }

"))) props))
              
              
(defun object (name &rest props)
  "Собственно функция генерации кода объекта."
  (format t "public class ~a~%" name)
  (format t "{~%")
  (format t "    public ~a(~a)~%" name (get-ctor-param props))
  (format t "    {~%")
  (format t "~{        ~a~%~}" (get-prop-init props))
  (format t "    }~%")
  (format t "~{~a~}~%" (get-prop-field props))
  (format t "}~%")
)


Пример использования:
(objects
 (object "Obj1"
         (property :name "prop1" :type "int")
         (property :name "prop2" :type "string"))
 (object "Obj2"
         (property :name "prop3" :type "double")
         (property :name "prop4" :type "bool")))


Генерируется (на стандартный вывод):

public class Obj1
{
    public Obj1(int prop1, string prop2)
    {
        _prop1 = prop1;
        _prop2 = prop2;
    }
    private int _prop1;

    public int Prop1
    {
        get { return _prop1; }
    }

    private string _prop2;

    public string Prop2
    {
        get { return _prop2; }
    }


}
public class Obj2
{
    public Obj2(double prop3, bool prop4)
    {
        _prop3 = prop3;
        _prop4 = prop4;
    }
    private double _prop3;

    public double Prop3
    {
        get { return _prop3; }
    }

    private bool _prop4;

    public bool Prop4
    {
        get { return _prop4; }
    }


}


Повторю, это моя первая программа на Лиспе. Если знатоки этого языка считают, что подобные программы только дискредитируют его, то пусть мой небогатый опыт послужит мне оправданием.
Re[7]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 08:22
Оценка: 11 (2)
Здравствуйте, eao197, Вы писали:

E>Ну, решения на Lisp-е и Ruby приведены. Осталось посмотреть на две строчки XSLT.


Я две строчки не обещал, поэтому покажу как на самом деле.
<stylesheet>
    <template match="/objects">
        <!-- Здесь обычно пишется заголовок файла и неймспейс, но в примере его нет -->
        <apply-templates/>
    </template>
    
    <template match="object">
public class <value-of select="@name"/>
{
        <call-template name="make-ctor"/>
        <apply-templates/>
}
    </template>
    
    <template match="property">
    private <value-of select="@type"/> _<value-of select="@name"/>;
    public <value-of select="@type"/> <value-of select="@name"/>
    {
        get { return _<value-of select="@name"/>; }
    }
    </template>
    
    <template name="make-ctor">
    public <value-of select="@name"/>(
        <for-each select="property">
            <value-of select="@type"/> _<value-of select="@name"/>
            <if test="position() != last()">, </if>
        </for-each>
    )
    {
        <for-each select="property">
            _<value-of select="@name"/> = <value-of select="@name"/>;
        </for-each>
    }
    </template>
</stylesheet>


Синтаксис конечно чудовищный, зато структура очень удобная для создания и модификации.
... << RSDN@Home 1.2.0 alpha rev. 558>>
AVK Blog
Re[7]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 02:51
Оценка: 10 (1) +1
Здравствуйте, eao197, Вы писали:

Я вот тоже решил попробовать решить задачку импиративно на Шарпе. Причем в отличии от твоего примера я все же создал декларативное описание шаблона. Выносить шаблоны и модель в файл было влом, так что в целях сравнения мысленно отбрасывай их .

using System;
using System.Text;
using System.Xml;

class Program
{
    // Модель для преобразования.
    const string _model =
@"<objects>
    <object name='Obj1'>
        <property name='prop1' type='int'/>
        <property name='prop2' type='string'/>
    </object>
    <object name='AnotherObject'>
    </object>
    <object name='YetAnotherObject'>
        <property name='a' type='int'/>
        <property name='b' type='string'/>
        <property name='c' type='AnotherObject'/>
    </object>
</objects>";

    const string _templates =
@"<Templates>
    <Class>
public class #ClassName#
{
    public Obj1(#CtorParams#)
    {
        #CtorInits#
    }

#Properties#
}
    </Class>

    <Properties>
    private #type#  _#fieldName#;
    
    public #type# #PropName#
    {
        get { return _#fieldName#; }
    }
    </Properties>

    <CtorParams>#type# #fieldName#</CtorParams>
    <CtorInits>_#fieldName# = #fieldName#;</CtorInits>
</Templates>";

    static void Main()
    {
        Console.WriteLine(MakeCode());
    }

    static XmlDocument _pemplateDoc = new XmlDocument();

    static string MakeCode()
    {
        _pemplateDoc.LoadXml(_templates);
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(_model);
        string res = "";
        // Перебираем описание класов из файла модели...
        foreach (XmlNode @class in doc.SelectNodes(@"//object"))
        {
            // Заменяем паттерны на шаблоны попутно раскрывая их.
            string str = GetTemplate("#Class#").Replace("#ClassName#", @class.Attributes["name"].Value);
            ReplacePatterns(ref str, "#CtorParams#", @class, ", ");
            ReplacePatterns(ref str, "#CtorInits#", @class, ";\r\n        ");
            ReplacePatterns(ref str, "#Properties#", @class, "\r\n");
            res += str;
        }

        return res;
    }

    // Загружает шаблон и раскрвает его для каждого описания свойства.
    private static void ReplacePatterns(ref string source,
        string templateName, XmlNode @class, string separator)
    {
        StringBuilder str = new StringBuilder();
        string template = GetTemplate(templateName);

        foreach (XmlNode prop in @class.SelectNodes("property"))
        {
            str.Append(separator);
            str.Append(template.Replace("#type#", prop.Attributes["type"].Value)
                .Replace("#fieldName#", prop.Attributes["name"].Value)
                .Replace("#PropName#", Capitalize(prop.Attributes["name"].Value)));
        }

        if (str.Length > 0)
            str.Remove(0, separator.Length);
        source = source.Replace(templateName, str.ToString());
    }

    // Загружает шаблон кода по его имени. Если шаблона нет кидает исключение.
    static string GetTemplate(string templateName)
    {
        templateName = "//" + templateName.Replace("#", "");
        string template = _pemplateDoc.SelectSingleNode(templateName).InnerText;
        if (template == null)
            throw new Exception("The template '" + templateName + "' not exists.");
        return template;
    }

    // Переводит первую букву в строке в верхний регистр.
    static string Capitalize(string text)
    {
        char[] array = text.ToCharArray();
        array[0] = char.ToUpper(array[0]);
        return new String(array);
    }
}


Как видишь, хотя мое решение более универсальное оно на на много длинее твоего. Результат аналогичен твоему, так что я его не привожу вовсе. Причем мой код намного более просто расширяем. Чтобы поправить шаблон вообще ничего менять не нужно.

Кстати, код можно автоматизировать если немного его дароботать. Так можно анализировать шаблон на наличие в нем нераскрытых паттернов и пытаться их раскрыть автоматически. Информацию о повторении можно задать как-то в атрибутах шаблона.

В общем, если еще часа два подумать, то может получиться вполне себе работоспособное решение с очень простым декларативным синтаксисом.

Например в качестве имен паттернов можно попробовать использовать XPath. Однако это все ближе и ближе к XSLT.
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: Lisp
От: mishaa Россия http://kmmbvnr.livejournal.com
Дата: 13.07.05 10:04
Оценка: 8 (2)
P>>Если уж зашел об этом разговор... Какие есть более-менее качественные (минимум — с поддержкой отладки) некоммерческие IDE для Common Lisp? Желательно, чтобы работали под Windows.

P>>P.S. Из IDE для Scheme — я нашел DrScheme, и он мне понравился. По крайней мере, для обучения он хорош (вроде для этого и предназначен). Под Windows работает (как и под Linux). Какие-то возможности отладки есть. А Project Management я там не нашел .


К>Если от emacs сильно не тошнит, то глянь сюда

К>Лично мне показалось юзабельным.

Ну а если тошнит то вот сюда http://jabberwocky.sourceforge.net/
-- Главное про деструктор копирования не забыть --
Re[8]: Lisp
От: fionbio  
Дата: 14.07.05 13:34
Оценка: 8 (1) :)
Здравствуйте, Cyberax, Вы писали:

C>aka50 wrote:


>> VD>А зачем тогда Lisp? XSLT и конечное решение в две строчки пишется.

>> Но лисп то появился до XSLT . Почему ж изобрели лисапед вместо того,
>> чтобы лисп или ту же схему
>> подлатать? .

C>А можно парсер Лиспа в 12 килобайт кода?


Не знаю, как у остальных, а у меня оно живёт вот тут:
C:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\Tool Developers Guide\Samples\clisp\
Re[13]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 14:13
Оценка: 2 (2)
AVK>>Идея понятна?

E>Имхо, на Ruby такое замутить можно. Что-то типа:

E>
E>root "objects" {

E>    element "object", ONE_OR_MORE {
E>        attrubute "name"
E>        element "property", ONE_OR_MORE {
E>            attribute "name"
E>            attribute "type"
E>        }
E>    }
E>}
E>


А как на основе этого строить проверку грамматики?

E>Вот, сегодня наткнулся на проектик xml-mapping для Ruby, так там в документации такой пример приведен. Для xml-я:


Это все совсем не то, это и для дотнета есть. Видишь ли, если решать описанную задачу в лоб, как тут многие пытаются, парся xml и генерируя в императивном стиле текст, параллельно при этом проверяя корректность заглатываемых данных, о результат получается одинаков, будь то лисп, руби или C#. Увы, хоть написать такой код просто и не требует особого напряжения ума, но поддерживать подобное очень тяжело. На реальных задачах все это превращается в огромные простыни пестрого кода. Всякими фокусами на базе ООП бывает удается немного ситуацию упростить, например так,
private void GenerateParamValueDomain(XmlElement parent, XmlElement template,
    ElementParamInfo epi)
{
    XmlPattern pvp = new XmlPattern(template, parent);
    pvp.Element.SetAttribute(s_IdAttr, pvp.Element.GetAttribute(s_IdAttr) +
        epi.Rn);
    XmlElement pvevParent;
    XmlElement pvev = pvp.ExtractTemplate(s_ListParamDomainEnumValueId,
        out pvevParent);
    foreach (ParameterValueInfo pvi in epi.Values)
    {
        XmlPattern evp = new XmlPattern(pvev, pvevParent);
        evp.Element.SetAttribute(s_CodeAttr, pvi.Rn.ToString());
        evp.Element.SetAttribute(s_TextAttr, pvi.Caption);
        evp.Element.InnerText = pvi.Caption;
    }
}

но все равно получается не очень. Вариант с XSLT уже несколько лучше, поскольку удается выкинуть из структуры программы хотя бы обход основной иерархии, но жуткий синтаксис и усложнение понимания в том случае, когда по дереву приходится проходить несколько раз, делают его тоже довольно далеким от идеала. Вариант с универсальным функциональным языком (я пробовал OCaml, в сообщении Re: Задачка: придумать язык
Автор: Gaperton
Дата: 14.07.05
есть пример на Erlang-подобии) тоже не очень. С одной стороны синтаксис проще, с другой нет возможности писать просто конечный код, без того чтобы не заворачивать его в строковые константы. После заверений о крутости лиспа стало интересно посмотреть, а как на нем решить такую задачу. Но, увы, все приведенные решения являются по большей части вариациями на ту же тему.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[16]: AST-based solution
От: ON  
Дата: 16.07.05 13:53
Оценка: 2 (2)
> ON>Тут писали про ООП, полиморфимз и пример где-то есть, draw там что-то. Полиморфизм это же семантика по нескольким элементам?
> Не-а. По нескольким элементам — это называется множественная диспетчеризация или мультиметоды.

С точки зрения реализации полиморфизм это обращение к исполняющей системе с аргументом — ссылкой на тип. А то, что пишут в учебниках это лишь интерпретация этого механизма. Принципиальной разницы нет, передавать один параметр и искать ссылку на метод в одномерной таблице, или два и искать в двумерной. Теоретицски можно обобщать дальше — при вызове передаем исполняющей системе ложку совсем неформализованного бульона, какие там объекты, параметры и прочее, вообще ничего не известно. Там это дело парсится (не будете же спорить, что есть более хитрые способы реагировать на информацию, чем извлечь из таблицы ссылку по индексу), строит метод (из аспектов каких-нибудь) и выполняет. Это, кажется, называется "управление по данным", немного другая модель вычислений, не ООП.

> ON>А где-нибудь рассматриваются такие вещи по-подробнее? Если семантика только по одному символу, тут неизбежно должны возникать лишние формальные уровни в деревьях, которые к вычислению отношения не имеют, а лишь более удобны для человека, внимание которого очень ограничено.

> Что-то как-то непонятно...

Известный факт, что человек может думать образами состоящими не более чем из 5-7 элементов. У компьютера такого ограничения нет в приципе, тут узкое место — человек. Допустим у нас список из 100 элементов и два способа построить дерево — бинарное и десятичное. Десятичное будет в 2 яруса, бинарное в 7. Я говорю про программу, не про дерево данных. Эти лишние 5 ярусов абстракций придется придумывать. Для программиста это работа, а у нормальных людей вся эта диспетчеризация называется бюрократизмом. Поэтому в конторе, где софт пишут для себя, когда важен результат работы программы, а не сама программа — там нормальный начальник будет с Лиспом бороться.

> ON>Вот в Рефал такого нет, и поэтому там программы еще короче, чем в Лиспе. Или опять можно на Лиспе сделать полиморфизм лямбда-выражений и получить таким образом Рефал?

> Вообще все непонятно. Объясните, а?

Мне тоже мало понятно. Я не знаю ни Лисп ни Рефал
Просто хочется не только писать поменьше, но и думать поменьше
Вот просто по здравому смыслу. Каким образом "семантика определяется по первому элементу списка", если этот список содержит Лямбда-выражение, то есть названия функции там напрочь нет.

> В CLOS (== Common Lisp Object System) мультиметоды есть, просто их реализация "спрятана" внутри функции диспетчеризации, которая вызывается при интерпретации s-expression, у которого первый элемент — имя мультиметода.


Вот это отлично понятно. В конце концов получаем, что основное достоинство Лиспа в том, что там программисту ничто не мешает. Единственное что это ничтожество реально делает, это посылает все в eval. А вся ценность Лиспа в библиотеках.
Но при этом вся суть Common-версии Lisp в том, что там нельзя вообще ничего писать. За исключением случая когда это будет официально включено в стандартную библиотеку Common Lisp. А слова ламер и хакер означают абслютно одно и то же.
А социальные проблемы у Лиспа в точности те же, что у Эсперанто.

Кстати, знаете, почему стихи Пушкина написаны таким современным языком? Потому, что наш современный язык это язык Пушкина, язык его произведений.
Posted via RSDN NNTP Server 1.9
Re[17]: AST-based solution
От: Сергей Туленцев Россия http://software.tulentsev.com
Дата: 16.07.05 18:07
Оценка: 1 (1) :)
Здравствуйте, ON, Вы писали:


ON>А социальные проблемы у Лиспа в точности те же, что у Эсперанто.


Cxu vi volas interparoli pri tio?

Проблемы есть, это да. Но мощь языка от этого не уменьшается.
--
Re[5]: Lisp
От: Cyberax Марс  
Дата: 13.07.05 09:11
Оценка: +2
Курилка wrote:

> M>>Хм... меня скобки перестали угнетать где-то к 4-ой главе Practical

> Common Lisp. Вы попробуйте и зацените.
> M>Ты не ответил на мой вопрос.
> Просто в самом вопросе предпосылка неверна, поэтому отвечать на него
> смысла не имеет если её не отрицать. Просто смысл в скобках, т.е. в
> том факте что программа на лиспе есть по сути AST, т.е.
> программа==данные, и трансформации она подвергается с такой же
> лёгкостью как данные в традиционных императивных языках. Т.е.
> экспрессивность решений повышается в разы, паттерны реализуются
> запросто и т.д.

Вот с этим можно поспорить.

Во-первых, писать программу в виде чистого AST — неудобно.
Во-вторых, писать нетривиальные преобразования AST — весьма непросто,
причем тестировать их тоже не легко.
В-третьих, для обычных языков типа Java/C# уже существуют системы для
редактирования AST. Только называется это Aspect Oriented Programming. А
для C# у нас еще и R# есть

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[3]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.07.05 16:33
Оценка: -1 :)
Здравствуйте, Трурль, Вы писали:

AVK>>Интересует решение именно в духе лиспа.

Т>В духе лиспа будет генерировать код лиспе, а не на C#

Т.е. Лисп вещь не полноценная? На нем можно делать только что-то для Лиспа?
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[9]: AST-based solution
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.07.05 14:25
Оценка: +2
Здравствуйте, fionbio, Вы писали:

F>Генерация, блин. Оно лучше гораздо, чем XSLT, поверьте. Удобоваримее и проще.


Ну, вот Эрлинговский вариант Re: Задачка: придумать язык
Автор: Gaperton
Дата: 14.07.05
мне кажется более понятным. Я конечно не "нормальный лиспер". Но таких еще поискать нужно. Все же понятность и модифицируемость — это очень важные вещи.
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[19]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 15:16
Оценка: +1 :)
Здравствуйте, eao197, Вы писали:

AVK>>Можно. Но тот же вопрос — зачем тогда Руби? То же самое я могу сделать, к примеру, на шарпе.


E>Ну, Андрей, попробуй привести код твоего же исходного XML, но выраженный на шарпе.


Так, что то я теряю мысль. Ты предложил, для того чтобы из псевдодекларативности сделать декларативность реальную, преобразовывать декларативное описание в Руби. Так зачем мне тогда выражать на шарпе исходные данные, если для шарпа и XML подходит? Впрочем могу и продемонстрировать:
public interface Obj1
{
    int Prop1 {get;}
    string Prop2 {get;}
}


И заметь, это гарантированно декларативный код, а не его эмуляция. Декларативность контролируется компилятором.

E> И сравни с тем, что на Ruby можно написать. Просто синтаксического мусора меньше.


А по мне так не меньше.

E>Да и твое замечание о том, что тоже самое можно сделать на шарпе я разделяю. Вот Влад давно мне (и не только мне) пытался доказать, что шарп в качестве сриптового языка без проблем можно использовать. Вот можно и попробовать его в этом качестве.


Можно. Только решение на XSLT, несмотря на синтаксис, удобнее.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[4]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 02:51
Оценка: +1 :)
Здравствуйте, eao197, Вы писали:

К>>Сделай Yahoo Shops


E>Боюсь, что для этого нужно быть Полом Грэхэмом.


Боюсь, что он просто так свои деньги уже не отдаст. Так что просто быть вторым Полом Грэхэмом мало.
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re: Решение на Питоне
От: VladD2 Российская Империя www.nemerle.org
Дата: 02.08.05 13:56
Оценка: +1 -1
Здравствуйте, eugals, Вы писали:

E>Кстати, да — вполне в лисповском духе получилось...


Агащазблин. Чистый императив как на Руби, только вместо ХМЛ-я непойми что.
... << RSDN@Home 1.2.0 alpha rev. 591>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[8]: Lisp
От: Andre Украина  
Дата: 17.07.05 15:26
Оценка: 26 (1)
VD>

VD>    // Переводит первую букву в строке в верхний регистр.
VD>    static string Capitalize(string text)
VD>    {
VD>        char[] array = text.ToCharArray();
VD>        array[0] = char.ToUpper(array[0]);
VD>        return new String(array);
VD>    }
VD>


Это в принципе можно сократить до:
CultureInfo.CurrentCulture.TextInfo.ToTitleCase(string text)
... << RSDN@Home 1.1.4 beta 7 rev. 467>> :: silent
Я бы изменил мир — но Бог не даёт исходников...
Re[9]: AST-based solution
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 14:44
Оценка: 22 (1)
Здравствуйте, VladD2, Вы писали:

VD>Кстати, а как получить ХСД для некоторого ХМЛ-я? Кто-нить умеет ревер-инжинирить ХМЛ?


xsd.exe. Только надо понимать, что возможности по угадыванию у нее весьма ограничены. Вот к примеру по тому, что я привел она генерит такую схему:
<xs:schema id="objects" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
  <xs:element name="objects" msdata:IsDataSet="true" msdata:Locale="ru-RU">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="object">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="property" minOccurs="0" maxOccurs="unbounded">
                <xs:complexType>
                  <xs:attribute name="name" type="xs:string" />
                  <xs:attribute name="type" type="xs:string" />
                </xs:complexType>
              </xs:element>
            </xs:sequence>
            <xs:attribute name="name" type="xs:string" />
          </xs:complexType>
        </xs:element>
      </xs:choice>
    </xs:complexType>
  </xs:element>
</xs:schema>


Как видишь — несильно отличается от того, что я нарисовал вручную. В более сложных случаях конечно уже не все так радужно.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[2]: Lisp
От: Павел Кузнецов  
Дата: 14.07.05 16:42
Оценка: 20 (1)
AndrewVK,

> А можно увидеть на лиспе решение следующей задачи:

> Имеем некое текстовое описание модели каких либо объектов. Пусть это будет xml. Например: <...>
> Требуется сгенерировать код на C# примерно такого вида: <...>

Я правильно понимаю, что, на самом деле, тебе не решение на Лиспе нужно, а вообще интересуют решения, связанные с кодогенерацией? Если так, смотрел ли ты на то, что используется в KDE? Например, http://conference2004.kde.org/slides/cornelius.schumacher-metaprogramming.pdf (KConfig XT: XML -> C++).
Posted via RSDN NNTP Server 2.0 beta
Легче одурачить людей, чем убедить их в том, что они одурачены. — Марк Твен
Re[2]: Lisp
От: pongo  
Дата: 12.09.05 23:45
Оценка: 18 (1)
Здравствуйте, AndrewVK, Вы писали:

AVK>А можно увидеть на лиспе решение следующей задачи:

AVK>Имеем некое текстовое описание модели каких либо объектов. Пусть это будет xml. Например:

Быть может, уже поздно. Но хочу предложить свое решение на Ruby

class MyObject
    def initialize(name)
        @name = name
        @propertys = []
    end

    def to_s
        str = ""
        str += "public class #@name\n"
        str += "{\n"               
        
        str += "    public #@name("
        @propertys.each_index { |x|
            str += "#{@propertys[x]['type']} #{@propertys[x]['name']}"
            str += ", " if x < @propertys.length - 1
        }
        str += ")\n"
        
        
        str += "    {\n"
            @propertys.each { |item|
                str += "        _#{item['name']} = #{item['name']};\n"
            }
        str += "    }\n"

        @propertys.each { |item|
            str += "    \n"
            str += "    private #{item['type']} _#{item['name']};\n\n"
            str += "    public #{item['type']} #{item['name'].capitalize}\n"
            str += "    {\n"
            str += "        get { return _#{item['name']}; } \n"
            str += "    }\n"
        }
            
        str += "}\n"
    end
    
    def AddProperty(type, name)
        @propertys += [ { 'type' => type, 'name' => name } ]
    end
end

def _object(name)
    $obj = MyObject.new(name)
    
    yield
    
    print $obj
end

def _property(type, name)
    $obj.AddProperty(type, name)
end

# описание модели

_object("Obj1") {
    _property("int", "prop1")
    _property("string", "prop2")
}


Выводит:
public class Obj1
{
    public Obj1(int prop1, string prop2)
    {
        _prop1 = prop1;
        _prop2 = prop2;
    }
    
    private int _prop1;

    public int Prop1
    {
        get { return _prop1; } 
    }
    
    private string _prop2;

    public string Prop2
    {
        get { return _prop2; } 
    }
}


Итак, руби -- язык интерпретируемый? Значит можно написать всё на самом языке... Надеюсь я понятно выразился

Ps. Это мой первый опыт программирования на руби. Буквально сегодня я начал его изучать, прочитал пока пару статей...
Re[4]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 13.07.05 09:00
Оценка: 8 (1)
Здравствуйте, mihoshi, Вы писали:

M>Здравствуйте, mishaa, Вы писали:


M>>>И все-таки. Какие Lisp имеет преимущества, кроме сверхлегкой для машины (и неудобной для человека) грамматики?


M>>Хм... меня скобки перестали угнетать где-то к 4-ой главе Practical Common Lisp. Вы попробуйте и зацените.


M>Ты не ответил на мой вопрос.


Просто в самом вопросе предпосылка неверна, поэтому отвечать на него смысла не имеет если её не отрицать. Просто смысл в скобках, т.е. в том факте что программа на лиспе есть по сути AST, т.е. программа==данные, и трансформации она подвергается с такой же лёгкостью как данные в традиционных императивных языках. Т.е. экспрессивность решений повышается в разы, паттерны реализуются запросто и т.д.
Re[2]: Решение на Ruby DSL.
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 26.02.06 06:05
Оценка: 8 (1)
Прошу прощения, что поднимаю эту тему, но в разговоре про Nemerle
Автор: Oyster
Дата: 23.02.06
был проявлен интерес к тому, как решение подобной задачи могло выглядеть на Ruby (Ruby как DSL вместо XML, результирующий код так же генерируется для Ruby).

# Подключаем Pretty Printer для печати содержимого объектов.
require 'pp'

### Начало реализации DSL

# Объект этого типа будет аккумулировать метаописание.
class ObjectDesc
  attr_reader :name
  attr_reader :properties

  def initialize( name )
    @name = name
    @properties = []
  end

  def property( name )
    @properties << name
  end
end

# Генератор описания класса из метаописания.
def generate( o )
  c = %Q{
class #{o.name}
#{o.properties.inject('') { |r,p| r << "  attr_accessor :#{p}\n"; r }}
  def initialize( #{o.properties.join(', ')} )
#{o.properties.inject('') { |r,p| r << "    @#{p} = #{p}\n"; r }}
  end
end
}
  c
end

# Это и есть элемент специализированного DSL-я.
def object( name, &blk )
  o = ObjectDesc.new( name )
  o.instance_eval( &blk )

  eval generate( o )
end

### Начало использования DSL

# Задаем метаописание пустого класса посредством DSL.
object "Empty" do
end

# Задаем метаописание первого класса посредством DSL.
object "First" do
  property :first
  property :second
  property :a
end

### Проверка того, что класс Fisrt действительно доступен для разработчика.

# Работаем с уже определенным классом.
f = First.new( 'a', 'b', 'c' )
pp f
f.first = "aa"
f.second = "bb"
pp f


В результате получаем:
#<First:0x2805a68 @a="c", @first="a", @second="b">
#<First:0x2805a68 @a="c", @first="aa", @second="bb">


Собственно сам DSL -- это обращение к функции object:
object "First" do
  property :first
  property :second
  property :a
end

из которого функция generate создает текст вида:

class First
  attr_accessor :first
  attr_accessor :second
  attr_accessor :a

  def initialize( first, second, a )
    @first = first
    @second = second
    @a = a

  end
end

а функция object вычисляет его через eval. Таким образом, внутри object() описание нового класса становится доступным для Ruby-программы.

Функция generate могла иметь и чуть более простой вид (с меньшим количеством обращений к string interpolation):
def generate( o )
  c = String.new
  c << "class #{o.name}\n"
  o.properties.each { |p| c << "  attr_accessor :#{p}\n" }
  c << "  def initialize( #{o.properties.join(', ')} )\n"
  o.properties.each { |p| c << "    @#{p} = #{p}\n" }
  c << "  end\n"
  c << "end\n"
  c
end

к тому же она строит код без лишних пустых строк:
class First
  attr_accessor :first
  attr_accessor :second
  attr_accessor :a
  def initialize( first, second, a )
    @first = first
    @second = second
    @a = a
  end
end


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[8]: Решение на Ruby DSL.
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 07.03.06 10:17
Оценка: 5 (1)
Здравствуйте, VladD2, Вы писали:

VD>Куда же они делись? Самые что ни наесть, но текстуальные. Именно это и роднит их с С. И это их основаня проблема.


Влад, макросы в C/C++ -- это средство, модифицирующее исходный код программы до его обработки компилятором. В Ruby выполняется динамическая трансляция исходного текста во внутреннее представление с последующим исполнением получившегося кода (фактически интерпритация). В таком подходе нет отдельной фазы разворачивания макросов перед трансляцией. Более того, например, декларация класса в Ruby -- это тот же самый код, который исполняется последовательно, что позволяет, к примеру, делать так:
class SomeClass
  if $debug_mode
    # Такой конструктор будет у класса, если работаем в отладке.
    def initialize( param1, param2, param3 )
      # ...
    end

    # Так же для отладки добавляется специальный метод.
    def debug_dump( debug_stream )
      # ...
    end
  else
    # В release у класса будет другой конструктор.
    def initialize( param )
      # ...
    end
  end
end

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

Как следствие этого, в Ruby можно сделать то, что в принципе невозможно сделать макросами C/C++ -- изменить код программы после трансляции.

Так что, никакие это не макросы, это особенность интерпритации кода.


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[10]: Решение на Ruby DSL.
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 13.03.06 10:14
Оценка: 5 (1)
Здравствуйте, Andrei N.Sobchuck, Вы писали:

ANS>Похоже на препроцессор. Я так понимаю, что два раза с разными параметрами такой код не вызвать?


Вызвать.
# Файл class_def.rb
class TestClass
  if $debug
    def debug_dump
    end
  else
    def release_mode
    end
  end

  def initialize
  end

  def hello_world
  end
end

# Файл t1.rb
$debug = true

load 'class_def.rb'

a = TestClass.new

puts "Step 1:\n" + a.class.instance_methods(false).join( "\n" ) + "\n-----"

$debug = false

load 'class_def.rb'

puts "Step 2:\n" + a.class.instance_methods(false).join( "\n" ) + "\n-----"


Запуск t1.rb на выполнение приводит к получению результата:
Step 1:
hello_world
debug_dump
-----
Step 2:
hello_world
release_mode
debug_dump
-----

Видно, что на втором шаге появился метод release_mode.

Комментарий: в Ruby классы являются открытыми, что позволяет расширять класс новыми методами уже по ходу работы программы. Именно поэтому на втором шаге появился метод release_mode. Но ранее определенные в классе методы просто так не исчезают, т.к. они уже были определены. Поэтому на втором шаге метод debug_dump остался в списке методов. Чтобы изъять метод debug_mode нужно было бы переписать определение класса так:
class TestClass
  if $debug
    def debug_dump
    end

    remove_method :release_mode if method_defined? :release_mode
  else
    def release_mode
    end

    remove_method :debug_dump if method_defined? :debug_dump
  end

  def initialize
  end

  def hello_world
  end
end

Тогда бы получили:
Step 1:
hello_world
debug_dump
-----
Step 2:
hello_world
release_mode
-----


Ну и еще симпатичнее это решение бы выглядело, если бы обращения к remove_method были бы упрятаны во вспомогательный метод remove_if_present:
class TestClass
  def self.remove_if_present( sym ); remove_method sym if method_defined? sym; end

  if $debug
    def debug_dump
    end

    remove_if_present :release_mode
  else
    def release_mode
    end

    remove_if_present :debug_dump
  end

  def initialize
  end

  def hello_world
  end
end


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[8]: Lisp
От: aka50 Россия  
Дата: 14.07.05 09:11
Оценка: 4 (1)
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, eao197, Вы писали:


E>>Ну, решения на Lisp-е и Ruby приведены. Осталось посмотреть на две строчки XSLT.


блин... не успел свое выложить . Опередил.

    
    <template match="property">
    private <value-of select="@type"/> _<value-of select="@name"/>;
    public <value-of select="@type"/> <value-of select="@name"/>
    {
        get { return _<value-of select="@name"/>; }
    }
    </template>


Но ошибочка. По условию public должен быть с большой буквы:
Так что строчек чуток по больше будет

    <template match="property">
    private <value-of select="@type"/> _<value-of select="@name"/>;
    public <value-of select="@type"/> <call-template name="capitalize"> <with-param name="toconvert" select="@name" />  </call-template>
    {
        get { return _<value-of select="@name"/>; }
    }
    </template>

  <xsl:template name='capitalize'>
    <xsl:variable name="lcletters">abcdefghijklmnopqrstuvwxyz</xsl:variable>
    <xsl:variable name="ucletters">ABCDEFGHIJKLMNOPQRSTUVWXYZ</xsl:variable>

    <xsl:param name='toconvert' />

    <xsl:if test="string-length($toconvert) > 0">
      <xsl:variable name='f' select='substring($toconvert, 1, 1)' />
      <xsl:variable name='s' select='substring($toconvert, 2)' />

      <xsl:value-of select="translate($f,$lcletters,$ucletters)"/><xsl:value-of select="$s"/>
    </xsl:if>
  </xsl:template>
Re[4]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 13.07.05 09:49
Оценка: 2 (1)
Здравствуйте, pvgoran, Вы писали:

P>Здравствуйте, mishaa, Вы писали:


M>>Единственное условие — пользуйтесь IDE! Без элементарной расскраски и возможности перехода на определение метода, даже прекрасно написанные исходники Eclipse IDE на прекрасно синтаксически вылизанной Java — дремучий лес.


P>Если уж зашел об этом разговор... Какие есть более-менее качественные (минимум — с поддержкой отладки) некоммерческие IDE для Common Lisp? Желательно, чтобы работали под Windows.


P>P.S. Из IDE для Scheme — я нашел DrScheme, и он мне понравился. По крайней мере, для обучения он хорош (вроде для этого и предназначен). Под Windows работает (как и под Linux). Какие-то возможности отладки есть. А Project Management я там не нашел .


Если от emacs сильно не тошнит, то глянь сюда
Лично мне показалось юзабельным.
Re[5]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 13.07.05 10:11
Оценка: 2 (1)
Здравствуйте, pvgoran, Вы писали:

P>Здравствуйте, pvgoran, Вы писали:


P>>Если уж зашел об этом разговор... Какие есть более-менее качественные (минимум — с поддержкой отладки) некоммерческие IDE для Common Lisp? Желательно, чтобы работали под Windows.


P>Будем считать, что про Emacs+SLIME я ответ уже получил
Автор: CrazyPit
Дата: 12.07.05
. Хотя для меня так и осталось непонятным, насколько легко это все установить/настроить — в частности, на Windows.


Lisp in a Box устанавливается как два байта переслать — просто 2 инсталлятора и всё (просто лиспы могут разные использоваться, поэтому 2)
Re[2]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 13.07.05 09:14
Оценка: 1 (1)
Здравствуйте, Mishka, Вы писали:

M>Я со всем согласен, но есть два вопроса:


M>1. Как найти работу программистом на Lisp?


Вот об этом есть интересная автобиография: Lisping at JPL
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[10]: Lisp
От: faulx  
Дата: 14.07.05 09:23
Оценка: 1 (1)
Здравствуйте, Cyberax, Вы писали:

>> C>Но оно правится и тестируется во время компиляции — а это большой плюс.

>> А Лисповские макросы когда?

C>Никогда.


Неужели я первый человек в мире, кто отлаживал и тестировал Лисповские макросы? Требую приз!

C>Оно может и в ран-тайме код уродовать.


Макросы? Которые defmacro? В рантайме? Или мы про что-то другое говорим?

>> И потом, где в С++ аналог функции marcoexpand, которая позволяет

>> посмотреть, во что развернется указанный макрос?

C>Нет, так как она не очень-то и нужна — темплейты не разворачиваются, а

C>инстанцируются.

А в Лиспе нужна, и поэтому есть. Да и в С++ что-нибудь подобное не помешало бы — помогло бы отлаживать разворачивание циклов, вычисление констант метапрограммированием, expression template и т.п. Пока что это приходится делать в голове.

C>Немного не то имею в виду — макрос при желании может как угодно изменить

C>тело функции, шаблон же меняет только типы переменных.

Но как макрос меняет тело функции — посмотреть всегда можно, а вот какие типы переменных появятся в С++ — очень тяжело.
Re[10]: Lisp
От: aka50 Россия  
Дата: 14.07.05 09:55
Оценка: 1 (1)
Здравствуйте, Cyberax, Вы писали:

C>aka50 wrote:


>> C>А можно парсер Лиспа в 12 килобайт кода?

>> Простенький — пожалста:
>> здесь <http://exmortis.narod.ru/src_inter.html&gt;

C>Не простенький, а полноценный. Этот даже строковые литералы не парсит.


К стати, тут собственно не лисп нужен а sexpr интерпретатор .
Дык вот он есть: http://sexpr.sourceforge.net/ правда либа весит 30к,
но думаю это не сильно важно .

This library is intended for developers who wish to manipulate (read, parse, modify, and create) symbolic expressions from C or C++ programs. A symbolic expression, or s-expression, is essentially a LISP-like expression such as (a (b c)). S-expressions are able to represent complex, structured data without requiring additional meta-data describing the structure. They are recursively defined: an s-expression is a list of either atoms or s-expressions. In the example above, the expression contains an atom "a" and an s-expression, which in turn contains two atoms, "b" and "c". They are simple, useful, and well understood.

This library is intended to be a minimal set of functions and structures for the four functions listed above: reading s-expressions (I/O), parsing strings containing them into an AST equivalent, modifying the AST representation, and converting the AST back into a well formatted string. The primary goals are efficiency and simplicity. This library forms the basis of the data representation and transmission protocol for the supermon high-speed cluster monitoring system from the LANL ACL. The usefulness and lack of choice in available, open source s-expression libraries motivated the independent (from supermon) release of this library. Although the number of potential users represents a rather small community, the author felt it was a valuable contribution. As of March 2003, this library has actually received more interest in terms of downloads and page views than it's parent project!

Re[11]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 10:18
Оценка: 1 (1)
Здравствуйте, aka50, Вы писали:

AVK>>Нет, если написать <value-of select="helper:Capitalize(@name)"/>.


A>сорри за невежество, но google не помог. helper — это че за неймспейс такой?


На смайлик обратил внимание? Это намек на то, что подобные алгоритмы я напишу на шарпе и подключу как extension, вместо того чтобы извращаться на xslt.
... << RSDN@Home 1.2.0 alpha rev. 558>>
AVK Blog
Re[8]: Lisp
От: Трурль  
Дата: 14.07.05 11:36
Оценка: 1 (1)
Здравствуйте, Cyberax, Вы писали:

C>А можно парсер Лиспа в 12 килобайт кода?


Первый интерпретатор Лиспа работал на компьютерах с 8K памяти (правда не байт, а слов).
Re[11]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 15.07.05 09:42
Оценка: 1 (1)
Здравствуйте, Andrei N.Sobchuck, Вы писали:

ANS>(Кстати, кто-бы дал ссылки на все приведённые решения на всех языках?).


На Lisp-е:
Re[2]: Lisp
Автор: CrazyPit
Дата: 14.07.05
от CrazyPit
Re[4]: Lisp
Автор: cranky
Дата: 14.07.05
от cranky
Re[2]: Lisp
Автор: faulx
Дата: 14.07.05
от faulx (кстати, у него, имхо, получилось самое компактное и читабельное Lisp-решение, а вот оценок ему незаслуженно не поставили. А ведь это первая Lisp-программа была у человека)
Re[2]: AST-based solution
Автор: fionbio
Дата: 14.07.05
от fionbio

И одно было на Ruby:
Re[6]: Lisp
Автор: eao197
Дата: 14.07.05
(только там XML парсился).
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[14]: Lisp
От: Кодёнок  
Дата: 15.07.05 14:11
Оценка: 1 (1)
Здравствуйте, eao197, Вы писали:

Кё>>Мы сможем разве что сравнить синтаксический сахар Ruby `coll do |e|` против (dolist ...) и `puts` против (format ...), что большой информации не даёт


E>Почему же? Для некоторых это может стать причиной выбора в пользу того или иного языка. Например, конструкция "call do |e|" в свое время склонила для меня чашу весов в пользу Ruby, а не Perl-а или Python-а.


Интересно, чем же `coll do |e|` лучше питоновского `for e in coll` ?

Кё>>Куда интереснее сравнить, например, декларацию + трансформер на самом языке (Ruby например), без привлечения XML, и то же самое на Лиспе.


E>Вот чего мы не увидели, так это решение исходной задачи, включая парсинг XML-я, на Lisp-е. А жаль. Но может еще есть надежда?


В том-то и дело, что с Лиспом обычно не нужно привлекать XML и XSLT. Вот например, реализация apply-templates — функция всего в одну страницу.

Вообщем, парсинг XML на Scheme с использованием сторонней библиотеки выглядит так:
(require (lib "ssax.ss" "ssax"))
(print (ssax:xml->sxml (open-input-file (car (vector->list (current-command-line-arguments))) ) `()) )


XML-файл надо передать как первый аргумент этому скрипту (mzscheme.exe -br script.scm arg1). При этом из такого XML
<objects>
    <object name="Obj1">
        <property name="prop1" type="int"/>
        <property name="prop2" type="string"/>
    </object>
</objects>


Генерируется такое s-expr:

(*TOP* 
  (objects 
    (object (@ (name "Obj1")) 
      (property (@ (type "int") (name "prop1"))) 
      (property (@ (type "string") (name "prop2")))
    )
  )
)


Полностью аналогично парсингу на Ruby Это обращение к библиотеке — при чём тут любой конкретный язык?

Остальное — в понедельник Или кто-нибудь вперед меня успейте. SSAX лежит тут: http://www196.pair.com/lisovsky/xml/index.html XPath там есть, но думаю он тут будет лишним.
Re[3]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 13.09.05 05:09
Оценка: 1 (1)
Здравствуйте, pongo, Вы писали:

P>Ps. Это мой первый опыт программирования на руби. Буквально сегодня я начал его изучать, прочитал пока пару статей...


Ура!!! Полку Rubyist-ов на RSDN прибывает!

Позволю себе пару комментариев по твоему посту. Во-первых, ты выбрал не самый удачный вариант DSL. Можно было бы сделать либо так:
object :Obj1 {
    property :int, :prop1
    property :string, :prop2
}

этот вариант реализуюется с помощью instance_eval вместо yield.
Либо можно применить подход с передачей параметров в блок:
object :Obj1 { |o|
    o.property :int, :prop1
    o.property :string, :prop2
}

Пример того, как это реализуется и работает я приводил вот здесь: Re: Использование метаданных в программах на языке C++
Автор: eao197
Дата: 08.09.05
.
Ну и в твоем варианте можно было вполне обойтись без глобальной переменной.

Во-вторых, Ruby, имхо, лучше изучать не по статьям, а по книге "Programming Ruby: The Pragmatic Programmer's Guide". Ее первое издание свободно доступно на rubycentral.com и, более того, идет в OneClickRubyInstaller. Недавно вышло второе издание. В электронном виде (PDF) доступно только через eMule . Но, имхо, даже первое издание дает очень хорошее представление о языке и о том, как его можно использовать. Например, год назад, имея под рукой только первое издание, я сделал свой Mxx_ru, а там Ruby как раз в качестве DSL и применяется.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[2]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 12.07.05 09:24
Оценка: +1
Здравствуйте, ON, Вы писали:
ON>2. Что нельзя написать на Лисп? То есть куда отодвигается горизонт "слишком сложно" при переходе на Лисп.

На мой взгляд будет сложно, или точнее малоцелесообразно писать низкоуровневый "железный" код на лиспе, т.к. всёже там есть сборщик мусора и проч. довольно высокоуровневые инструкции языка. Т.е. аналогия с забиванием гвоздей микроскопом. Для таких задч лучше использовать более подходящие инструменты — ассемблер, си (и молоток )
Re[2]: Lisp
От: mishaa Россия http://kmmbvnr.livejournal.com
Дата: 13.07.05 06:16
Оценка: +1
Здравствуйте, mihoshi, Вы писали:

M>Здравствуйте, fionbio, Вы писали:


M>И все-таки. Какие Lisp имеет преимущества, кроме сверхлегкой для машины (и неудобной для человека) грамматики?


Хм... меня скобки перестали угнетать где-то к 4-ой главе Practical Common Lisp. Вы попробуйте и зацените.

К 6-ой главе я уже считал что как раз у Лиспа и есть сверхлегкая для человека грамматика, после всяких mainstream XML велосипедов типа BPEL просто наслаждаешся жизнью.

Единственное условие — пользуйтесь IDE! Без элементарной расскраски и возможности перехода на определение метода, даже прекрасно написанные исходники Eclipse IDE на прекрасно синтаксически вылизанной Java — дремучий лес.
-- Главное про деструктор копирования не забыть --
Re[2]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 13.07.05 09:02
Оценка: :)
Здравствуйте, Mishka, Вы писали:

M>2. Как получать больше денег программируя на Lisp, чем, например, на C# или VBA?


Сделай Yahoo Shops
Re[6]: Lisp
От: mishaa Россия http://kmmbvnr.livejournal.com
Дата: 13.07.05 10:22
Оценка: +1
Здравствуйте, Cyberax, Вы писали:


C>Вот с этим можно поспорить.

Ну куда ж без этого


C>Во-первых, писать программу в виде чистого AST — неудобно.

Посмотри на возможности макроса loop — ну где здесь чистый AST? Как ни странно благодоря макросам лисп оказывается самым сладким языком.

C>Во-вторых, писать нетривиальные преобразования AST — весьма непросто,

C>причем тестировать их тоже не легко.
Нетривиальные веши — не просты — это факт
Тестировать, а точнее писать,компилировать,править, шаблоны на С++ IMHO на порядок сложнее.

C>В-третьих, для обычных языков типа Java/C# уже существуют системы для

C>редактирования AST. Только называется это Aspect Oriented Programming. А
C>для C# у нас еще и R# есть
Не есть — а недавно появилось... Что еше раз потверждает выше сказанную мысль о том что все языки медленно двигаются в сторону Лиспа.
Меня собственно и подвигло на серьезноге изучение Лиспа, так это то что в CLOS кажись заложенно и AOP .

Кстати все навороты на лиспе выглядят как лисп — ни чуть не хуже .

IMHO спорить безполезно. Надо пробовать.
-- Главное про деструктор копирования не забыть --
Re[7]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 13.07.05 12:57
Оценка: +1
Здравствуйте, eao197, Вы писали:

E>Здравствуйте, Курилка, Вы писали:


К>>Вопрос — а DSL ты откуда взял? Т.е. описание его не включается в решение?


E>Ну, будь я Lisp-программистом, то привел бы полное решение. Просто прочитав столько отзывов о Lisp-е я пришел к мнению, что основная фича Lisp-а -- это возможность простого построения DSL для конкретной задачи. Т.е., вместо решения чего-нибудь в лоб (как зачастую делается с помощью гор кода на императивных языках), на Lisp-е делается DSL, в котором решение конкретной задачи записывается всего несколькими строчками.


E>Собственно в том, что построение конкретного DSL выполняется средствами самого языка, и в результате получается тот же Lisp -- и есть, имхо, главное преимущество над C++. Т.е. в C++ так же можно подобные фокусы делать, но навороты на шаблонах могут быть сильно сложными и, все-таки, ограниченными, а применение внешних инструментов типа Yacc/Lex для создания DSL -- то еще удовольствие. И главное, получается несколько разных языков, тогда как в Lisp-е язык один.


Не могу не согласиться.

E>Но только в этой области у Lisp-е есть конкуретны. Тот же Ruby позволяет строить вполне нормальные DSL оставаясь в рамках Ruby-синтаксиса.


С руби даже не игрался, так что сравнить не могу, к сожалению
Недостаточно компетентен

E>Да и такая гибкость Lisp-а, как указывал, кажется, Cyberax, оборачивается его главным недостатком. Лишком легко создать свой DSL, который кроме тебя никому не нравится и в котором другим разработчикам сложно ориентироваться.


На любом достаточно мощном языке можно сделать нечто (архитектуру, DSl и проч.), что никому не будет нравиться — и что? Язык не есть лекарство от неправильных решений, язык должне разрешать выражать мысли, а не запрещать
Или из-за некоторой корявости MFC мы и C++ будем признавать убогим языком? Отделяй, плиз, мухи от котлет.
Re[3]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 13.07.05 14:22
Оценка: +1
Здравствуйте, eao197, Вы писали:

E>Как мне кажется, первое, что в духе Лиспа нужно будет сделать, так это написать описание на самом Лиспе:


Я так и знал. Мне не нужно генерить код на Лиспе, мне нужно генерить код на шарпе. Ну, предположим, у меня есть большой проект на дотнете, который никто под лисп переписывать не будет никогда. И для него нужно написать вот такую штуку.

E>А потом окажется, что с помощью defmacro сам objects является кодом по генерации C# кода.


Вот еще бы не на словах, а в реальном коде.
... << RSDN@Home 1.2.0 alpha rev. 558>>
AVK Blog
Re[5]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.07.05 16:33
Оценка: +1
Здравствуйте, eao197, Вы писали:

E>А нельзя разве XSLT преобразовать XML в Lisp-подобный формат, а затем скормить Lisp-овской программе?


А зачем тогда Lisp? XSLT и конечное решение в две строчки пишется.

Я, кстати, присоеденяюсь к АВК. Мне тоже было бы интересно поглядеть решение данной задачи на Лиспе.
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[6]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 06:50
Оценка: +1
Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, eao197, Вы писали:


E>>А нельзя разве XSLT преобразовать XML в Lisp-подобный формат, а затем скормить Lisp-овской программе?


VD>А зачем тогда Lisp? XSLT и конечное решение в две строчки пишется.


Ну, решения на Lisp-е и Ruby приведены. Осталось посмотреть на две строчки XSLT.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[6]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 08:04
Оценка: +1
Здравствуйте, Курилка, Вы писали:

AVK>>>Я так и знал. Мне не нужно генерить код на Лиспе, мне нужно генерить код на шарпе. Ну, предположим, у меня есть большой проект на дотнете, который никто под лисп переписывать не будет никогда. И для него нужно написать вот такую штуку.


К>Вопрос в правомерности постановки задачи: есть XML, есть заточенный на него XSLT, плюсам лиспа в данном случае просто негде проявиться, ибо сей DSL(если его можно таковым назвать) никакой логики практически не содержит. Смысл в том, чтобы макросы содержали какую-то логику "более высокого уровня" чтоли...


Как я понимаю, заточенного под XML XSLT нет. Нужно напрямую из XML генерить шарп. Вот и интересно увидеть, как же это делается.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[8]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 08:20
Оценка: +1
Здравствуйте, Курилка, Вы писали:

E>>Как я понимаю, заточенного под XML XSLT нет.

К>В каком смысле нет? Отменили?

В смысле постановки задачи от AndrewVK.

E>>Нужно напрямую из XML генерить шарп. Вот и интересно увидеть, как же это делается.

К>Опять ищем серебрянную пулю? Одна из составляющих знания программиста — найти наиболее подходящий для задачи язык/инструмент, или ты как передовой велосипедист всё как всегда хочешь решать с помощью 1 инструмента?

Как передовой велосипедист, я хочу увидеть решение на Lisp следующей задачи в постановке из Re: Lisp
Автор: AndrewVK
Дата: 13.07.05
, с дополнением в виде того, что никакого XSLT для этой конкретно схемы XML нет (что следует из Re[5]: Lisp
Автор: AndrewVK
Дата: 13.07.05
и Re[5]: Lisp
Автор: VladD2
Дата: 13.07.05
.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[9]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 08:53
Оценка: +1
Здравствуйте, eao197, Вы писали:

E>Как и можно было ожидать, самый компактный код получился у специально предназначенного для этого инструмента.


Знаешь, меня в данном случае интересует больше не компактность в символах, а компактность в смысловых конструкциях. И тут уже все не так очевидно.

E>Андрей, а в чем удобство выражается? В том, что есть специальные инструменты для создания таких XSLT?


1) Возможность описания хотя бы части структуры выходного кода декларативно. ПО сравнению с конкатенациями и строковыми константами в императивных программах это сильно упрощает поддержку и снижает вероятность глупых ошибок.
2) Готовый инструментарий для создания, контроля, расширения и т.п. Например, если мне нужно написать алгоритмы, которые проще выразить императивно я просто пишу эот код на шарпе.
3) Возможность обработок шаблонов все теми же xml-парсерами.

E>Вот мне показалось, что если, наприемер, потребуется убрать знак подчеркивания из имент атрибутов (или заменить его на другой префикс), то поле для ошибок в XSLT больше окажется.


Нет. Потому что в xslt есть переменные. Просто в данном случае вероятность того, что это понадобиться сделать стремиться к 0.
... << RSDN@Home 1.2.0 alpha rev. 558>>
AVK Blog
Re[14]: Lisp
От: aka50 Россия  
Дата: 14.07.05 10:35
Оценка: -1
Здравствуйте, eao197, Вы писали:

E>Может быть удобства использования для средненького программиста, не желающего расширять сознание, а просто получающего зарплату за фиксированный объем работы в течении 40-ка часовой рабочей недели?


Ну опять о простых программерах. Простой программер тоже не шибко обрадуется на XSLT писать. ИМХО лисп проще.
Re[17]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 10:58
Оценка: +1
Здравствуйте, aka50, Вы писали:

A>Здравствуйте, eao197, Вы писали:


E>>Для перечисленных тобой вещей есть готовые инструменты, которые прячут всю эту сложность от программиста. В результате использование более сложных технологий оказывается проще.


A>Сейчас конечно есть. Но в 1999 (или каком там XSLT родился) их не было. А лисп уже был. Зачем было изобретать? (вопрос риторический, можно не отвечать)


Так его можно еще более расширить. Но я обещал больше не спрашивать про причины непопулярности Lisp
(Кстати, когда я познакомился с языком Curl, я был поражен тем, что в нем документация по Curl-у была просто программами на Curl-е. Вообще, Curl -- это производная от Lisp-а. У них в альфа-версии даже арифметические операции записывались как в Lisp-е: {+ x y}. Затем, видимо в надежде сделать Curl более читабельным, арифметические операции стали записываться привычным образом: x + y).

Но вот посмотрев на примеры Lisp-овских программ, я, наверное, стал понимать, почему Lisp еще жив. Потому что некоторым товарищам он позволяет делать все, что они только захотят. Нужно отдать должное. У других языков запас возможностей поменьше будет.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[7]: AST-based solution
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 11:38
Оценка: +1
Здравствуйте, fionbio, Вы писали:

F>Верю, XSD себе представляю. Но. Во-первых, если проверку в Лиспе сделать

F>отдельно, она будет, понятное дело, короче.

Мне пофигу — короче она или длиннее. По символам xsd может и не сильно меньше будет. Дело в другом. Приведенный тобой код поддерживать — это застрелиться просто. XS поддерживать несравнимо проще, просто потому что намного проще структура.

F>голову (особенно это касается 1.0). В третьих, никто, блин, не мешает на входе

F>получать XML — его ж можно отпарсить в одну строчку через pxmlutils в sexpr,
F>а потом перевести в удобоваримый вид с практически нулевыми трудозатратами.

Вот только смысл в лиспе тогда совсем небольшой получается.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[3]: AST-based solution
От: CrazyPit  
Дата: 14.07.05 12:46
Оценка: +1
Здравствуйте, fionbio, Вы писали:

F>[ Эх, обогнали меня Вчера накалякал пример, хоть и башка

F>была весь день какая-то мутная — странно, не пил вроде. Запостить
F>вчера моральных сил не хватило ]

F>Попробую привести решение в духе Лиспа

F>.....

Очень интересно было почитать и потестить код. Буду читать доку. В этих двух тредах я столько полезных ссылок нашёл, сам бы я на них ещё неизвестно когда вышел...
Re[7]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.07.05 12:56
Оценка: +1
Здравствуйте, aka50, Вы писали:

VD>>А зачем тогда Lisp? XSLT и конечное решение в две строчки пишется.

A>Но лисп то появился до XSLT .

И что теперь? Напомню, на дворе 2005-й год.
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.07.05 12:56
Оценка: +1
Здравствуйте, eao197, Вы писали:

E>Ну, после приведенных Lisp-овских примеров (Re[2]: Lisp
Автор: CrazyPit
Дата: 14.07.05
, Re[2]: Lisp
Автор: faulx
Дата: 14.07.05
) стало понятно, что я в своем предположении не ошибся -- нафига XML, если Lisp описывает тоже самое?


Примеры уже больше и сложнее чем ХСЛТ АВК. А что будет если еще соблюсти оригинальный стандарт?

Кстати, то что больше это еще ладно. В конце коцов средсвто универсальное. Но вот читаемость кода явно проигрывает ХСЛТ-шному решению.
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[9]: Lisp
От: Кодёнок  
Дата: 15.07.05 07:16
Оценка: :)
Здравствуйте, Andrei N.Sobchuck, Вы писали:

AVK>>Ахринеть. А вот эта достаточно сложная задача почему то на XSLT решается без проблем.


ANS>Ну, если принять за постулат, что Lisp — язык для построения DSL, а XSLT это DSL, то сравнивать их нельзя. Вот разработать тот DSL, который ты хочеш, на LISP, Ruby, C# и сравнить — это да.


Почему Лиспу приписывают создание DSL? Раньше AI приписывали, сейчас DSL
Re[13]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 15.07.05 10:07
Оценка: +1
Здравствуйте, Кодёнок, Вы писали:

Кё>Например, приведённый код на Ruby, например, можно транслировать в Лисп, если предположить, что в нём есть такая же XML-библиотека, и получится короткая программа, которая ну никак не отражает ни специфику Ruby, на Лиспа. Мы сможем разве что сравнить синтаксический сахар Ruby `coll do |e|` против (dolist ...) и `puts` против (format ...), что большой информации не даёт


Почему же? Для некоторых это может стать причиной выбора в пользу того или иного языка. Например, конструкция "call do |e|" в свое время склонила для меня чашу весов в пользу Ruby, а не Perl-а или Python-а.

Кё>Куда интереснее сравнить, например, декларацию + трансформер на самом языке (Ruby например), без привлечения XML, и то же самое на Лиспе.


А вот это, может быть и интереснее, но бессмысленнее. Инструмент должен хорошо решать ту задачу, для которой он предназначен. XML -- отличная штука для декларативности (если конечно инструменты соответствующие применять). Ruby -- отличная штука для программирования. То, что на Ruby можно достигать декларативности -- это всего лишь бонус вышеупомянутого тобой синтаксического сахара. Но связка из нескольких специализированных инструментов (XML, XML-editor, Ruby) дает отличные результаты. Кстати, REXML -- это стандартная библиотека Ruby для работы с XML, которая входит непосредственно в дистрибутив Ruby 1.8.2 и для работы с XML в Ruby не нужно искать дополнительные иструменты, хотя и такие имеются.

В то же время Lisp позволяет делать и декларацию и реализацию. Результат мы все увидели. No comments.

Вот чего мы не увидели, так это решение исходной задачи, включая парсинг XML-я, на Lisp-е. А жаль. Но может еще есть надежда?
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[14]: Lisp
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 15.07.05 10:18
Оценка: +1
Здравствуйте, eao197, Вы писали:

ANS>>А на Ocaml & Erlang?


E>На Ocaml не видел, а Erlang в соседней теме: Re: Задачка: придумать язык
Автор: Gaperton
Дата: 14.07.05
.


Ок. благодарю. просто, вроде бы, видел упоминание, что решение на OCaml лучше чем на LISP.
... << RSDN@Home 1.1.4 stable rev. 510>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[28]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 15.07.05 11:49
Оценка: :)
Здравствуйте, AndrewVK, Вы писали:

E>>Такой вопрос: этот граф для всех нижеописанных задач декларативно описывается одним XML?


AVK>Да.


Ну тогда просто представь, что в подходе с Ruby это будет один и тот же декларативный скрипт с описанием графа.

AVK>>>Ты уже представил себе код на Руби, все это реализующий? А на XSLT это просто несколько шаблонов.


E>>От которых ты сам хочешь избавиться


AVK>Не то чтобы от шаблонов, но хочется, как всегда, лучшего. Но предлагают пока только худшее.


Наверное те, у кого есть лучшее, просто сидят и молчат, чтобы know-how не раскрывать
Да и я ничего не предлагаю. Просто фантазирую.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[19]: AST-based solution
От: mishaa Россия http://kmmbvnr.livejournal.com
Дата: 16.07.05 17:22
Оценка: :)
Здравствуйте, ON, Вы писали:

ON>Мне кажется Лисп-программист будет более склонен заниматься разработкой каких-нибудь ядер и движков и прочей схоластикой.

ON>Значит мы можем сделать множество функций .... Грубо говоря вычислений без алгоритмов и как следствие без программистов.

Однако выходит выходит Вы и есть самый настояший Лисп программист
-- Главное про деструктор копирования не забыть --
Re[5]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 16.07.05 22:42
Оценка: +1
Здравствуйте, Курилка, Вы писали:

К>Просто в самом вопросе предпосылка неверна, поэтому отвечать на него смысла не имеет если её не отрицать. Просто смысл в скобках, т.е. в том факте что программа на лиспе есть по сути AST, т.е. программа==данные, и трансформации она подвергается с такой же лёгкостью как данные в традиционных императивных языках. Т.е. экспрессивность решений повышается в разы, паттерны реализуются запросто и т.д.


Но есть одна проблема... Думать в понятиях АСТ и писать АСТ значительно соджнее чем на языке имеющем полноценный текстовый синтаксис заточенный для восприятия человеком.
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[4]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 16.07.05 22:42
Оценка: :)
Здравствуйте, Mishka, Вы писали:

M>P.S. Немножко не по теме, но всё же. Microsoft собирается избавится от VBA и пересадить всех на .NET. Для меня это хорошая новость, но вот наши desk developer-ы этому не слишком рады — придётся больше думать, и C# — это не VBA. Попробуй кто меня пересадить на Lisp, я б тоже наверно не был бы слишком счастлив.


Это что... Я тут как-то вот на что наткнулся: Microsoft drops C#
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[3]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 17.07.05 10:35
Оценка: +1
Здравствуйте, ON, Вы писали:

ON>Человек дает два файла — XML с описанием и соответствующий "примерно такой вид" на С#. Программа их сопоставляет — находит лексику, поля подстановок и грамматику. Потом человек дает другой XML и программа уже сама выдает соответствующий код на C#. Если возникает неоднозначность человек просто выбирает тот вариант, который ему больше нравится.


А зачем? Алгоритмы, которые требуются в данном конкретном случае, просты и детерминированны. Вносить неопределенность здесь не имеет никакого смысла.
... << RSDN@Home 1.2.0 alpha rev. 573>>
AVK Blog
Re[9]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 18:33
Оценка: :)
Здравствуйте, Andre, Вы писали:

A>Это в принципе можно сократить до:

A>
A>CultureInfo.CurrentCulture.TextInfo.ToTitleCase(string text)
A>


Сенкс. Однако хорошо они эту функцию припрятали.
... << RSDN@Home 1.2.0 alpha rev. 577>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[3]: Решение на Питоне
От: VladD2 Российская Империя www.nemerle.org
Дата: 03.08.05 06:41
Оценка: -1
Здравствуйте, eugals, Вы писали:

E>Здравствуйте, VladD2, Вы писали:


E>>>Кстати, да — вполне в лисповском духе получилось...

VD>>Агащазблин. Чистый императив как на Руби, только вместо ХМЛ-я непойми что.

E>Ну, там же написано "в лисповском духе", а не "чисто декларативный разборщик DSL" — почувствуй разницу.


Думаю "в лисповском духе" как раз и подразумевает декларативность. Можно спросить у АВК.

E> Под "лисповским духом" я тут имел ввиду, что в качестве формата исходных данных был использован сам язык высокого уровня


Думаю, что это как раз самое плохое в лисповском коде.

E>Что же касается "ХМЛ" vs "непойми что", то сдается мне ты лукавишь.


А мне сдается что ты.

E>Вот это:

E>
E>class Obj1(CSClass):
E>    prop1 = CSProp(int)
E>    prop2 = CSProp(string)
E>

E>вряд ли более "непонятно", чем вот это:
E>
E><objects>
E>    <object name="Obj1">
E>        <property name="prop1" type="int"/>
E>        <property name="prop2" type="string"/>
E>    </object>
E></objects>
E>

E>)

Первое не очевидно. Если человек не знает Питона, так вообще непойми что. Второе описание я понял без объяснений.
... << RSDN@Home 1.2.0 alpha rev. 591>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[3]: Решение на Ruby DSL.
От: Oyster Украина https://github.com/devoyster
Дата: 27.02.06 16:18
Оценка: +1
Здравствуйте, eao197, Вы писали:

E>Прошу прощения, что поднимаю эту тему, но в разговоре про Nemerle
Автор: Oyster
Дата: 23.02.06
был проявлен интерес к тому, как решение подобной задачи могло выглядеть на Ruby (Ruby как DSL вместо XML, результирующий код так же генерируется для Ruby).


Спасибо за код. Я так понял, что Ruby — язык с динамической типизацией?

В общем-то, не нравится мне в его средствах метапрограммирования то, что они недалеко ушли от сишных макросов — фактически мы собираем код в текстовом виде. Со всеми вытекающими в виде отсутствия контроля типов в компайл-тайм (но в Ruby-то этого и так нет, если я всё правильно понимаю) и невнятных ошибок в случае, если что-то генерится неверно (на простом примере можно и глазками посмотреть, а вот на сложном...).

Ну и ещё не нравится то, что нельзя оперировать кусками AST, т.к. это может быть очень полезно (ну там — пройтись по AST рекурсивно и сделать что-нибудь для нодов определённого типа). Или можно, но в коде это не использовалось?

Ну а нравится, соответственно, неограниченная гибкость — пиши что хочешь и как хочешь. В общем, макросы Nemerle — это строготипизированный подход к метапрограммированию
Re[5]: Решение на Ruby DSL.
От: Oyster Украина https://github.com/devoyster
Дата: 27.02.06 16:54
Оценка: +1
Здравствуйте, eao197, Вы писали:

E>Уж не знаю... С сишными макросами ничего общего.


Я имею в виду принцип — сначала собираем код как текст, потом компилим (интерпретируем).

E>(eval):7 -- это как раз место, где Ruby обнаружил синтаксическую ошибку (т.е. 7 -- это номер строки, которую обрабатывал eval). Если результат generate где-нибудь распечатать, то ошибка определяется достаточно точно.


Да это-то понятно, что на ошибку в сгенерированном типе он укажет. Вот указал бы он на ошибку в макросе... но это просто невозможно при таком подходе.
Re[6]: Решение на Ruby DSL.
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 27.02.06 16:59
Оценка: +1
Здравствуйте, Oyster, Вы писали:

O>Да это-то понятно, что на ошибку в сгенерированном типе он укажет. Вот указал бы он на ошибку в макросе... но это просто невозможно при таком подходе.


При таком подходе макросов, как таковых, нет.


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re: Lisp
От: ON  
Дата: 12.07.05 09:11
Оценка:
Лично меня практически убедили заняться Лиспом.

Остается еще пара вопросов:
1. Мэйнстрим-языки хороши еще тем, что они уже интегрированы в привычную инфраструктуру. А большинство задач это сопровождение/адаптация уже существующих приложений/решений, выбирать язык вообще не приходится. Единственный вариант — встраивать Лисп примерно как сейчас это происходит с SQL. Вопрос — где взять эти lisp.cpp, lisp.java, lisp.pas, lisp.cs?

2. Что нельзя написать на Лисп? То есть куда отодвигается горизонт "слишком сложно" при переходе на Лисп.
Posted via RSDN NNTP Server 1.9
Re[2]: Lisp
От: fionbio  
Дата: 12.07.05 12:53
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, fionbio, Вы писали:


VD>А может ты статейку нам сбацаешь?


Попробую, хотя сегодня-завтра не обещаю.
Re[3]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 12.07.05 12:57
Оценка:
Здравствуйте, fionbio, Вы писали:

F>Попробую, хотя сегодня-завтра не обещаю.


Ну, на завтра никто и не надеялся.
... << RSDN@Home 1.1.4 beta 7 rev. 466>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re: Lisp
От: mihoshi Россия  
Дата: 13.07.05 05:34
Оценка:
Здравствуйте, fionbio, Вы писали:

И все-таки. Какие Lisp имеет преимущества, кроме сверхлегкой для машины (и неудобной для человека) грамматики?
Re[3]: Lisp
От: mihoshi Россия  
Дата: 13.07.05 08:53
Оценка:
Здравствуйте, mishaa, Вы писали:

M>>И все-таки. Какие Lisp имеет преимущества, кроме сверхлегкой для машины (и неудобной для человека) грамматики?


M>Хм... меня скобки перестали угнетать где-то к 4-ой главе Practical Common Lisp. Вы попробуйте и зацените.


Ты не ответил на мой вопрос.
Re: Lisp
От: Mishka Норвегия  
Дата: 13.07.05 08:58
Оценка:
Я со всем согласен, но есть два вопроса:

1. Как найти работу программистом на Lisp?
2. Как получать больше денег программируя на Lisp, чем, например, на C# или VBA?
Re[3]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 13.07.05 09:04
Оценка:
Здравствуйте, Курилка, Вы писали:

К>Здравствуйте, Mishka, Вы писали:


M>>2. Как получать больше денег программируя на Lisp, чем, например, на C# или VBA?


К>Сделай Yahoo Shops


Боюсь, что для этого нужно быть Полом Грэхэмом.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[3]: Lisp
От: pvgoran Россия  
Дата: 13.07.05 09:45
Оценка:
Здравствуйте, mishaa, Вы писали:

M>Единственное условие — пользуйтесь IDE! Без элементарной расскраски и возможности перехода на определение метода, даже прекрасно написанные исходники Eclipse IDE на прекрасно синтаксически вылизанной Java — дремучий лес.


Если уж зашел об этом разговор... Какие есть более-менее качественные (минимум — с поддержкой отладки) некоммерческие IDE для Common Lisp? Желательно, чтобы работали под Windows.

P.S. Из IDE для Scheme — я нашел DrScheme, и он мне понравился. По крайней мере, для обучения он хорош (вроде для этого и предназначен). Под Windows работает (как и под Linux). Какие-то возможности отладки есть. А Project Management я там не нашел .
... << RSDN@Home 1.1.4 stable rev. 510>>
Re[4]: Lisp
От: pvgoran Россия  
Дата: 13.07.05 10:04
Оценка:
Здравствуйте, pvgoran, Вы писали:

P>Если уж зашел об этом разговор... Какие есть более-менее качественные (минимум — с поддержкой отладки) некоммерческие IDE для Common Lisp? Желательно, чтобы работали под Windows.


Будем считать, что про Emacs+SLIME я ответ уже получил
Автор: CrazyPit
Дата: 12.07.05
. Хотя для меня так и осталось непонятным, насколько легко это все установить/настроить — в частности, на Windows.
... << RSDN@Home 1.1.4 stable rev. 510>>
Re[6]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 13.07.05 10:08
Оценка:
Здравствуйте, mishaa, Вы писали:

P>>>Если уж зашел об этом разговор... Какие есть более-менее качественные (минимум — с поддержкой отладки) некоммерческие IDE для Common Lisp? Желательно, чтобы работали под Windows.


P>>>P.S. Из IDE для Scheme — я нашел DrScheme, и он мне понравился. По крайней мере, для обучения он хорош (вроде для этого и предназначен). Под Windows работает (как и под Linux). Какие-то возможности отладки есть. А Project Management я там не нашел .


К>>Если от emacs сильно не тошнит, то глянь сюда

К>>Лично мне показалось юзабельным.

M>Ну а если тошнит то вот сюда http://jabberwocky.sourceforge.net/


Спасибо, заценим!
Re[7]: Lisp
От: Cyberax Марс  
Дата: 13.07.05 10:40
Оценка:
mishaa wrote:

> C>Во-первых, писать программу в виде чистого AST — неудобно.

> Посмотри на возможности макроса loop — ну где здесь чистый AST? Как ни
> странно благодоря макросам лисп оказывается самым сладким языком.

Согласен — чуть украшеный AST.

> C>Во-вторых, писать нетривиальные преобразования AST — весьма непросто,

> C>причем тестировать их тоже не легко.
> Нетривиальные веши — не просты — это факт
> Тестировать, а точнее писать,компилировать,править, шаблоны на С++
> IMHO на порядок сложнее.

Но оно правится и тестируется во время компиляции — а это большой плюс.
Еще у шаблонов есть преимущество — они локальны (почти), то есть один
шаблон не оказывает влияния на другие. Так что отлаживать их вполне
нормально.

> C>В-третьих, для обычных языков типа Java/C# уже существуют системы для

> C>редактирования AST. Только называется это Aspect Oriented
> Programming. А
> C>для C# у нас еще и R# есть
> Не есть — а недавно появилось...

AspectJ появился в 99 (если не ошибаюсь), до этого были исследования на
эту тему в PARC'е.

> Что еше раз потверждает выше сказанную мысль о том что все языки

> медленно двигаются в сторону Лиспа.
> Меня собственно и подвигло на серьезноге изучение Лиспа, так это то
> что в CLOS кажись заложенно и AOP .

Кстати, после нескольких лет увлечения AOP сейчас интерес к нему
угасает. Оказалось, что применять манипуляции к коду напрямую — не
так-то уж и нужно, а скорее даже вредно — так как обычно это служит для
заплаток ошибок в дизайне.

Поэтому AOP стал использоваться для предоставления сравнительно
высокоуровневых сервисов, "перпендикулярных" самой логике кода:
1. Прозрачное распределенное кэширование объектов
http://www.jboss.org/products/jbosscache
2. Транзакции на графах объектов: http://www.jboss.org/products/jbossas
3. Прозрачные политики безопасности и т.п.

> IMHO спорить безполезно. Надо пробовать.


Пробовал, к сожалению... В далеком 2000 году.

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[6]: Lisp
От: pvgoran Россия  
Дата: 13.07.05 10:48
Оценка:
Здравствуйте, mishaa, Вы писали:

К>>Если от emacs сильно не тошнит, то глянь сюда

К>>Лично мне показалось юзабельным.

M>Ну а если тошнит то вот сюда http://jabberwocky.sourceforge.net/


Thanks.

P.S. Emacs — скажем так, напрягает, но, похоже, рано или поздно придется приспосабливаться...
... << RSDN@Home 1.1.4 stable rev. 510>>
Re[2]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 13.07.05 11:49
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, fionbio, Вы писали:


AVK>А можно увидеть на лиспе решение следующей задачи:

AVK>Имеем некое текстовое описание модели каких либо объектов. Пусть это будет xml. Например:
AVK>
AVK><objects>
AVK>    <object name="Obj1">
AVK>        <property name="prop1" type="int"/>
AVK>        <property name="prop2" type="string"/>
AVK>    </object>
AVK></objects>
AVK>


Как мне кажется, первое, что в духе Лиспа нужно будет сделать, так это написать описание на самом Лиспе:
(objects
    (object
        (property (name prop1) (type int))
        (property (name prop2) (type string))))


А потом окажется, что с помощью defmacro сам objects является кодом по генерации C# кода.

... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[3]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 13.07.05 11:59
Оценка:
Здравствуйте, eao197, Вы писали:

E>Здравствуйте, AndrewVK, Вы писали:


E>Как мне кажется, первое, что в духе Лиспа нужно будет сделать, так это написать описание на самом Лиспе:

E>
E>(objects
E>    (object
E>        (property (name prop1) (type int))
E>        (property (name prop2) (type string))))
E>


Если оставлять условие, то XML распарсить должно не ставить проблем
E>А потом окажется, что с помощью defmacro сам objects является кодом по генерации C# кода.

когда кажется — надо креститься

для defmacro нужен код макроса, который будет "развёртку" выполнять, лисп — не система ИИ, которая сама должна догадаться что надо сделать, как в любом ЯП ей надо это указать, просто это "указание" имхо должно быть проще. На работе лисп отсутствует как класс , так что, к сожалению задачку сейчас решать не возьмусь, надеюсь более продвинутые лисперы подмогут
Re[4]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 13.07.05 12:24
Оценка:
Здравствуйте, Курилка, Вы писали:

К>Здравствуйте, eao197, Вы писали:


E>>Здравствуйте, AndrewVK, Вы писали:


E>>Как мне кажется, первое, что в духе Лиспа нужно будет сделать, так это написать описание на самом Лиспе:

E>>
E>>(objects
E>>    (object
E>>        (property (name prop1) (type int))
E>>        (property (name prop2) (type string))))
E>>


К>Если оставлять условие, то XML распарсить должно не ставить проблем

E>>А потом окажется, что с помощью defmacro сам objects является кодом по генерации C# кода.

К>когда кажется — надо креститься


Кстати, напрасно прикалываешься. Почитай вот это http://martinfowler.com/articles/languageWorkbench.html
Там как раз говорится про external и internal DSL. Так вот по отношению к Lisp создание external DSL (пример AndrewVK на XML) может быть не нужным и избыточным шагом (если конечно этот XML не используется для интероперопа с другими приложениями).
Так же нормальный internal DSL вполне можно строить и на более популярных языках, скажем на Ruby:
objects do
    object do
        property do
            name "prop1"
            type "int"
        end
        property do
            name "prop1"
            type "string"
        end
    end
end

причем do-end можно заменить на фигурные скобки.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[5]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 13.07.05 12:33
Оценка:
Здравствуйте, eao197, Вы писали:

E>Здравствуйте, Курилка, Вы писали:


К>>Здравствуйте, eao197, Вы писали:


E>>>Здравствуйте, AndrewVK, Вы писали:


E>>>Как мне кажется, первое, что в духе Лиспа нужно будет сделать, так это написать описание на самом Лиспе:

E>>>
E>>>(objects
E>>>    (object
E>>>        (property (name prop1) (type int))
E>>>        (property (name prop2) (type string))))
E>>>


К>>Если оставлять условие, то XML распарсить должно не ставить проблем

E>>>А потом окажется, что с помощью defmacro сам objects является кодом по генерации C# кода.

К>>когда кажется — надо креститься


E>Кстати, напрасно прикалываешься.

См. о чём я ниже

E>Почитай вот это http://martinfowler.com/articles/languageWorkbench.html

E>Там как раз говорится про external и internal DSL. Так вот по отношению к Lisp создание external DSL (пример AndrewVK на XML) может быть не нужным и избыточным шагом (если конечно этот XML не используется для интероперопа с другими приложениями).
E>Так же нормальный internal DSL вполне можно строить и на более популярных языках, скажем на Ruby:
<skipped>

Вопрос — а DSL ты откуда взял? Т.е. описание его не включается в решение?
Re[3]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 13.07.05 12:47
Оценка:
Здравствуйте, Трурль, Вы писали:

Т>Здравствуйте, AndrewVK, Вы писали:


AVK>>Интересует решение именно в духе лиспа.

Т>В духе лиспа будет генерировать код лиспе, а не на C#

А если еще и исходное описание на Lisp-е сделать, то вообще ничего генерировать не нужно будет.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[4]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 13.07.05 12:57
Оценка:
Здравствуйте, eao197, Вы писали:

E>Здравствуйте, Трурль, Вы писали:


Т>>Здравствуйте, AndrewVK, Вы писали:


AVK>>>Интересует решение именно в духе лиспа.

Т>>В духе лиспа будет генерировать код лиспе, а не на C#

E>А если еще и исходное описание на Lisp-е сделать, то вообще ничего генерировать не нужно будет.


Дак о том и речь
Re[4]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 13.07.05 14:26
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, eao197, Вы писали:


E>>Как мне кажется, первое, что в духе Лиспа нужно будет сделать, так это написать описание на самом Лиспе:


AVK>Я так и знал. Мне не нужно генерить код на Лиспе, мне нужно генерить код на шарпе. Ну, предположим, у меня есть большой проект на дотнете, который никто под лисп переписывать не будет никогда. И для него нужно написать вот такую штуку.


А нельзя разве XSLT преобразовать XML в Lisp-подобный формат, а затем скормить Lisp-овской программе?

E>>А потом окажется, что с помощью defmacro сам objects является кодом по генерации C# кода.


AVK>Вот еще бы не на словах, а в реальном коде.


Андрей, я полностью с тобой согласен. Более того, я здесь выступаю противником Lisp-а и мне самому хотелось бы реальный код увидеть.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[4]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.07.05 16:33
Оценка:
Здравствуйте, Курилка, Вы писали:

К>для defmacro нужен код макроса, который будет "развёртку" выполнять,


Думаю, АВК как раз и хотел поглядеть на то насклько понятно будет выглядеть такой макрос. Ну, и догадываюсь, что хотел сравнить его с XSLT. И почему-то я уверен, что его решение будет куда более понятным и простым.
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 13.07.05 16:58
Оценка:
Здравствуйте, eao197, Вы писали:

E>Кстати, напрасно прикалываешься. Почитай вот это http://martinfowler.com/articles/languageWorkbench.html

E>Там как раз говорится про external и internal DSL. Так вот по отношению к Lisp создание external DSL (пример AndrewVK на XML) может быть не нужным и избыточным шагом (если конечно этот XML не используется для интероперопа с другими приложениями).
E>Так же нормальный internal DSL вполне можно строить и на более популярных языках, скажем на Ruby:
E>
E>objects do
E>    object do
E>        property do
E>            name "prop1"
E>            type "int"
E>        end
E>        property do
E>            name "prop1"
E>            type "string"
E>        end
E>    end
E>end
E>

E>причем do-end можно заменить на фигурные скобки.

А схема? Можно к Lisp или Ruby прикрутить схему?
... << RSDN@Home 1.2.0 alpha rev. 558>>
AVK Blog
Re[7]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 13.07.05 16:58
Оценка:
Здравствуйте, eao197, Вы писали:

E>Ну, будь я Lisp-программистом, то привел бы полное решение. Просто прочитав столько отзывов о Lisp-е я пришел к мнению, что основная фича Lisp-а -- это возможность простого построения DSL для конкретной задачи. Т.е., вместо решения чего-нибудь в лоб (как зачастую делается с помощью гор кода на императивных языках), на Lisp-е делается DSL, в котором решение конкретной задачи записывается всего несколькими строчками.


Меня в этой задаче интересовало не столько создание собственно DSL (меня в этом отношении XML устраивает), сколько простота решения его интерпретации, т.е. в данном конкретном случае кодогенерации.
... << RSDN@Home 1.2.0 alpha rev. 558>>
AVK Blog
Re[5]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 13.07.05 16:58
Оценка:
Здравствуйте, eao197, Вы писали:

E>А нельзя разве XSLT преобразовать XML в Lisp-подобный формат, а затем скормить Lisp-овской программе?


Можно. А еще можно сразу при помощи XSLT сгенерировать C#-код. Только я ведь о Лиспе спрашивал.

AVK>>Вот еще бы не на словах, а в реальном коде.


E>Андрей, я полностью с тобой согласен. Более того, я здесь выступаю противником Lisp-а и мне самому хотелось бы реальный код увидеть.


Так, поясняю. Я не являюсь противником лиспа, мне действительно интересно как это будет выглядеть, поскольку существующие средства меня устраивают не полностью.
... << RSDN@Home 1.2.0 alpha rev. 558>>
AVK Blog
Re[6]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 13.07.05 17:05
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>А схема? Можно к Lisp или Ruby прикрутить схему?


Андрей, мне самому стало интересно, насколько просто в Ruby с XML работать. Найду время, разберусь и покажу здесь решение (если получится). А вот на счет схемы не знаю.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[8]: Lisp
От: faulx  
Дата: 14.07.05 04:24
Оценка:
Здравствуйте, Cyberax, Вы писали:

>> C>Во-вторых, писать нетривиальные преобразования AST — весьма непросто,

>> C>причем тестировать их тоже не легко.
>> Нетривиальные веши — не просты — это факт
>> Тестировать, а точнее писать,компилировать,править, шаблоны на С++
>> IMHO на порядок сложнее.

C>Но оно правится и тестируется во время компиляции — а это большой плюс.


А Лисповские макросы когда? И потом, где в С++ аналог функции marcoexpand, которая позволяет посмотреть, во что развернется указанный макрос?

C>Еще у шаблонов есть преимущество — они локальны (почти), то есть один

C>шаблон не оказывает влияния на другие. Так что отлаживать их вполне
C>нормально.

Разве в Лиспе система package'ей не распространаяется на макросы?
Re[4]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 06:50
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, eao197, Вы писали:


E>>Как мне кажется, первое, что в духе Лиспа нужно будет сделать, так это написать описание на самом Лиспе:


AVK>Я так и знал. Мне не нужно генерить код на Лиспе, мне нужно генерить код на шарпе. Ну, предположим, у меня есть большой проект на дотнете, который никто под лисп переписывать не будет никогда. И для него нужно написать вот такую штуку.


Ну, после приведенных Lisp-овских примеров (Re[2]: Lisp
Автор: CrazyPit
Дата: 14.07.05
, Re[2]: Lisp
Автор: faulx
Дата: 14.07.05
) стало понятно, что я в своем предположении не ошибся -- нафига XML, если Lisp описывает тоже самое?
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[5]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 14.07.05 07:50
Оценка:
Здравствуйте, eao197, Вы писали:

E>Здравствуйте, AndrewVK, Вы писали:


AVK>>Здравствуйте, eao197, Вы писали:


E>>>Как мне кажется, первое, что в духе Лиспа нужно будет сделать, так это написать описание на самом Лиспе:


AVK>>Я так и знал. Мне не нужно генерить код на Лиспе, мне нужно генерить код на шарпе. Ну, предположим, у меня есть большой проект на дотнете, который никто под лисп переписывать не будет никогда. И для него нужно написать вот такую штуку.


E>Ну, после приведенных Lisp-овских примеров (Re[2]: Lisp
Автор: CrazyPit
Дата: 14.07.05
, Re[2]: Lisp
Автор: faulx
Дата: 14.07.05
) стало понятно, что я в своем предположении не ошибся -- нафига XML, если Lisp описывает тоже самое?


Вопрос в правомерности постановки задачи: есть XML, есть заточенный на него XSLT, плюсам лиспа в данном случае просто негде проявиться, ибо сей DSL(если его можно таковым назвать) никакой логики практически не содержит. Смысл в том, чтобы макросы содержали какую-то логику "более высокого уровня" чтоли...
Re[7]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 14.07.05 08:11
Оценка:
Здравствуйте, eao197, Вы писали:

E>Здравствуйте, Курилка, Вы писали:


AVK>>>>Я так и знал. Мне не нужно генерить код на Лиспе, мне нужно генерить код на шарпе. Ну, предположим, у меня есть большой проект на дотнете, который никто под лисп переписывать не будет никогда. И для него нужно написать вот такую штуку.


К>>Вопрос в правомерности постановки задачи: есть XML, есть заточенный на него XSLT, плюсам лиспа в данном случае просто негде проявиться, ибо сей DSL(если его можно таковым назвать) никакой логики практически не содержит. Смысл в том, чтобы макросы содержали какую-то логику "более высокого уровня" чтоли...


E>Как я понимаю, заточенного под XML XSLT нет.

В каком смысле нет? Отменили?

E>Нужно напрямую из XML генерить шарп. Вот и интересно увидеть, как же это делается.

Опять ищем серебрянную пулю? Одна из составляющих знания программиста — найти наиболее подходящий для задачи язык/инструмент, или ты как передовой велосипедист всё как всегда хочешь решать с помощью 1 инструмента?
Re[8]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 08:28
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, eao197, Вы писали:


E>>Ну, решения на Lisp-е и Ruby приведены. Осталось посмотреть на две строчки XSLT.


AVK>Я две строчки не обещал, поэтому покажу как на самом деле.

<...код поскипан...>
AVK>Синтаксис конечно чудовищный, зато структура очень удобная для создания и модификации.

Как и можно было ожидать, самый компактный код получился у специально предназначенного для этого инструмента.

Андрей, а в чем удобство выражается? В том, что есть специальные инструменты для создания таких XSLT?

Вот мне показалось, что если, наприемер, потребуется убрать знак подчеркивания из имент атрибутов (или заменить его на другой префикс), то поле для ошибок в XSLT больше окажется.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[9]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 14.07.05 08:30
Оценка:
А вот реши туже задачу, если не трудно, на плюсах — тыж лисп с ними сравнивал кругом тут
Re[10]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 08:34
Оценка:
Здравствуйте, Курилка, Вы писали:

К>А вот реши туже задачу, если не трудно, на плюсах — тыж лисп с ними сравнивал кругом тут


А я ее на Ruby уже решил: Re[6]: Lisp
Автор: eao197
Дата: 14.07.05

А вот на плюсах мне не интересно -- я приблизительно знаю, что получится. И главная сложность в том, что нужно сначала какой-нибудь XML парсер выбрать. Но, т.к. я с XML по своей основной работе не сталкиваюсь, то колупаться с каким-то С++ XML парсером для спортивного интереса у меня стимула нет.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[9]: Lisp
От: Cyberax Марс  
Дата: 14.07.05 08:57
Оценка:
faulx wrote:

>>> Нетривиальные веши — не просты — это факт

>>> Тестировать, а точнее писать,компилировать,править, шаблоны на С++
>>> IMHO на порядок сложнее.
> C>Но оно правится и тестируется во время компиляции — а это большой плюс.
> А Лисповские макросы когда?

Никогда. Оно может и в ран-тайме код уродовать.

> И потом, где в С++ аналог функции marcoexpand, которая позволяет

> посмотреть, во что развернется указанный макрос?

Нет, так как она не очень-то и нужна — темплейты не разворачиваются, а
инстанцируются.

> C>Еще у шаблонов есть преимущество — они локальны (почти), то есть один

> C>шаблон не оказывает влияния на другие. Так что отлаживать их вполне
> C>нормально.
> Разве в Лиспе система package'ей не распространаяется на макросы?

Немного не то имею в виду — макрос при желании может как угодно изменить
тело функции, шаблон же меняет только типы переменных.

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[9]: Lisp
От: Cyberax Марс  
Дата: 14.07.05 09:03
Оценка:
eao197 wrote:

> Как и можно было ожидать, самый компактный код получился у специально

> предназначенного для этого инструмента.
> Андрей, а в чем удобство выражается? В том, что есть специальные
> инструменты для создания таких XSLT?

Есть — XMLSpy, например. Там это даже графически рисовать можно.

Но XML дает еще кучу других преимуществ: декларативная валидация по XSD,
умный автокомплит (по XSD/DTD), генерация биндингов к куче языков,
удобные редакторы и т.п.

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[3]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 09:03
Оценка:
Здравствуйте, CrazyPit, Вы писали:

CP>Что вас конкретно интересует? Простой генератор? Тогда здесь лисп не будет принципиально лучше других языков. Или DSL на основе макросов, который будет генерировать native код и позволит использовать всю мощь лиспа внутри этого макроса, вот второе это уже то в чём лисп силён. (но я пока не силён В том же Practical Common Lisp две предпоследнии главы посвещены этой теме, только там генерируется html.


Я описал что меня интересует. Только, заметь, я описал задачу, а не способы ее решения. XML тут, разумеется, не самоцель. Подойдет любой текстовый декларативный формат, который описывается декларативной же схемой, контролирующей синтаксическую структуру. Императивные возможности в этом формате не нужны и вредны. Цель — создать по описанной этим форматом модели код на C#. Именно на C#, это обязательное требование.

CP>Но я всё-таки, в рамках тренеровки, написал простой генератор, который делает примерно то-что вы написали, только не из XML а из sexpr'ов, т.к. мне сейчас лень возиться с каким-то либами (так-что всё написано на чистом CL), но я думаю с помощью CL-XML можно быстро преобразовать XML в тот вид что у меня, или вообще сделать всё намного короче.


CP>

CP>(defparameter *test-desc*
CP> '(:objects
CP>   (:object :name "Obj1"
CP>    (:property :name "prop1" :type "int")
CP>    (:property :name "prop2" :type "string"))
CP>   (:object :name "Obj2"
CP>    (:property :name "foo10" :type "string")
CP>    (:property :name "bar12" :type "sometype"))))

CP>


Вопрос — насколько тщательно контролируется структура того, что ты привел?

CP>Вроде практически аналогично XML.


Только двоеточия какие то странные.

CP>Вот реализация:


CP>
CP>


Мда, сурово. Я, если честно, ожидал поменьше.

P.S. Большая просьба — лишнее цитирование из ответа выкидывать.
... << RSDN@Home 1.2.0 alpha rev. 558>>
AVK Blog
Re[6]: Lisp
От: aka50 Россия  
Дата: 14.07.05 09:21
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>А зачем тогда Lisp? XSLT и конечное решение в две строчки пишется.

Но лисп то появился до XSLT . Почему ж изобрели лисапед вместо того, чтобы лисп или ту же схему
подлатать? .
Re[7]: Lisp
От: Cyberax Марс  
Дата: 14.07.05 09:26
Оценка:
aka50 wrote:

> VD>А зачем тогда Lisp? XSLT и конечное решение в две строчки пишется.

> Но лисп то появился до XSLT . Почему ж изобрели лисапед вместо того,
> чтобы лисп или ту же схему
> подлатать? .

А можно парсер Лиспа в 12 килобайт кода?

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[8]: Lisp
От: aka50 Россия  
Дата: 14.07.05 09:29
Оценка:
Здравствуйте, Cyberax, Вы писали:

C>А можно парсер Лиспа в 12 килобайт кода?


Простенький — пожалста:

здесь

-rwxr-xr-x  1 aka50 aka50 12876 Jul 14 13:26 lisp*
-rw-r--r--  1 aka50 aka50 16901 Feb 19 01:43 lisp.c
-rw-r--r--  1 aka50 aka50  1662 Feb 19 01:26 lisp.h
-rw-r--r--  1 aka50 aka50  9496 Jul 14 13:28 lisp.o
Re[8]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 14.07.05 09:34
Оценка:
Здравствуйте, Cyberax, Вы писали:

C>aka50 wrote:


>> VD>А зачем тогда Lisp? XSLT и конечное решение в две строчки пишется.

>> Но лисп то появился до XSLT . Почему ж изобрели лисапед вместо того,
>> чтобы лисп или ту же схему
>> подлатать? .

C>А можно парсер Лиспа в 12 килобайт кода?


А зачем парсер? Сразу интерпретатор да и всё, в 12 кило запихать его вполне думаю можно, вопрос с полной спецификацией Common Lisp — тут 12 не обойдёшься, а ядро самого вполне. Просто в стандарт входит ещё куча всего вспомогательного — разных макросов и т.п.
Вопрос — а парсер XSLT у тебя 12 килобайт? Откуда магическая цифра?
Re[9]: Lisp
От: Cyberax Марс  
Дата: 14.07.05 09:36
Оценка:
aka50 wrote:

> C>А можно парсер Лиспа в 12 килобайт кода?

> Простенький — пожалста:
> здесь <http://exmortis.narod.ru/src_inter.html&gt;

Не простенький, а полноценный. Этот даже строковые литералы не парсит.

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[10]: Lisp
От: aka50 Россия  
Дата: 14.07.05 09:47
Оценка:
Здравствуйте, Cyberax, Вы писали:

C>aka50 wrote:


>> C>А можно парсер Лиспа в 12 килобайт кода?

>> Простенький — пожалста:
>> здесь <http://exmortis.narod.ru/src_inter.html&gt;

C>Не простенький, а полноценный. Этот даже строковые литералы не парсит.

А покажи плиз XML+XSLT процессор чтоб в 12 кил влез... Я посмотрю.
xerses + DOM почти 4 мега весят.
Re[9]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 09:56
Оценка:
Здравствуйте, aka50, Вы писали:

A>Но ошибочка. По условию public должен быть с большой буквы:


Это не ошибка. Просто в приведенном варианте большую букву тоже не добавляли.

A>Так что строчек чуток по больше будет


Нет, если написать <value-of select="helper:Capitalize(@name)"/>.
... << RSDN@Home 1.2.0 alpha rev. 558>>
AVK Blog
Re[11]: Lisp
От: Cyberax Марс  
Дата: 14.07.05 09:57
Оценка:
aka50 wrote:

>>> C>А можно парсер Лиспа в 12 килобайт кода?

>>> Простенький — пожалста:
>>> здесь <http://exmortis.narod.ru/src_inter.html&gt;
> <http://exmortis.narod.ru/src_inter.html%3E&gt;
> C>Не простенький, а полноценный. Этот даже строковые литералы не парсит.
> А покажи плиз XML+XSLT процессор чтоб в 12 кил влез... Я посмотрю.
> xerses + DOM почти 4 мега весят.

А кто сказал, что мне нужен именно DOM? Для XMLя есть еще и SAX (тоже
стандартизованный, кстати).

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[9]: Lisp
От: Cyberax Марс  
Дата: 14.07.05 09:58
Оценка:
Курилка wrote:

> C>А можно парсер Лиспа в 12 килобайт кода?

> А зачем парсер? Сразу интерпретатор да и всё, в 12 кило запихать его
> вполне думаю можно, вопрос с полной спецификацией Common Lisp — тут 12
> не обойдёшься, а ядро самого вполне. Просто в стандарт входит ещё куча
> всего вспомогательного — разных макросов и т.п.

Ну-ну. Уже была ссылка на интерпретатор Лиспа в 16Кб. Только вот он даже
строковые литералы не поддерживает.

> Вопрос — а парсер XSLT у тебя 12 килобайт? Откуда магическая цифра?


Столько занимает С++ный SAX парсер.

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[10]: Lisp
От: Курилка Россия http://kirya.narod.ru/
Дата: 14.07.05 10:06
Оценка:
Здравствуйте, Cyberax, Вы писали:

C>Курилка wrote:


>> C>А можно парсер Лиспа в 12 килобайт кода?

>> А зачем парсер? Сразу интерпретатор да и всё, в 12 кило запихать его
>> вполне думаю можно, вопрос с полной спецификацией Common Lisp — тут 12
>> не обойдёшься, а ядро самого вполне. Просто в стандарт входит ещё куча
>> всего вспомогательного — разных макросов и т.п.

C>Ну-ну. Уже была ссылка на интерпретатор Лиспа в 16Кб. Только вот он даже

C>строковые литералы не поддерживает.

>> Вопрос — а парсер XSLT у тебя 12 килобайт? Откуда магическая цифра?


C>Столько занимает С++ный SAX парсер.


Тебе ехать или шашечки? И чего тебе даст сакс парсер в рамках данной задачи? Непонятно что ты этим хочешь показать...
Re[10]: Lisp
От: aka50 Россия  
Дата: 14.07.05 10:08
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, aka50, Вы писали:


A>>Но ошибочка. По условию public должен быть с большой буквы:


AVK>Это не ошибка. Просто в приведенном варианте большую букву тоже не добавляли.


A>>Так что строчек чуток по больше будет


AVK>Нет, если написать <value-of select="helper:Capitalize(@name)"/>.


сорри за невежество, но google не помог. helper — это че за неймспейс такой?
Вот эта штука его не поняла:
Using libxml 20616, libxslt 10112 and libexslt 810
xsltproc was compiled against libxml 20616, libxslt 10112 and libexslt 810
libxslt 10112 was compiled against libxml 20616
libexslt 810 was compiled against libxml 20616


Это случаем не MS-specific?
Re[12]: Lisp
От: aka50 Россия  
Дата: 14.07.05 10:22
Оценка:
Здравствуйте, Cyberax, Вы писали:

C>А кто сказал, что мне нужен именно DOM? Для XMLя есть еще и SAX (тоже

C>стандартизованный, кстати).

Хорошо. Уговорил. libexpat весит 200к. Но в 200к можно запросто не то что лисп,
схему запихнуть (там же по ссылке лежит scheme инерпретатор чуть больше 200к)

Но к чему это? Для чего тебе тут лисп? Если рассматривать альтернативные решения XML XSLT то надо смотреть в каком контексте:
1 Если просто данные передавать, то можно sexpr
2 Процессинг — sexrp + простенький lisp.
3 Если RPC или скриптование — lisp.
4 Если полноценная система типа .Net или Java — common lisp (дохрена весит, почти как perl или python, ну шустрее в разы) + ffi.

Это все конечно реализуемо, но при этом синтаксис получается еще более "страшным" чем у lisp. (4-й пункт вроде токо XUL — аналог)
Сколько эти решения весят? Насколько они преносимы? (вот уже второй день пытаюсь в JanusSvc Dataset из SOAP s:any выдернуть.
нифига себе стандартизация. Изврат полный).

По этому собственно и спор. Что такого нового в этих технологиях чего нет в старых технологиях 60-ти летней давности?
Re[12]: Lisp
От: aka50 Россия  
Дата: 14.07.05 10:24
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, aka50, Вы писали:


AVK>>>Нет, если написать <value-of select="helper:Capitalize(@name)"/>.


A>>сорри за невежество, но google не помог. helper — это че за неймспейс такой?


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

ааа . Ну тогда в лиспе есть ffi. Но фишка в том, что в лиспе _не необходимости_ вызывать ниче. В нем все реализуется достаточно просто
понятно и главное на нем самом .
Так что думаю 1:0 в пользу лиспа
Re[13]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 10:27
Оценка:
Здравствуйте, aka50, Вы писали:

A>По этому собственно и спор. Что такого нового в этих технологиях чего нет в старых технологиях 60-ти летней давности?


Может быть удобства использования для средненького программиста, не желающего расширять сознание, а просто получающего зарплату за фиксированный объем работы в течении 40-ка часовой рабочей недели?
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[13]: Lisp
От: Mamut Швеция http://dmitriid.com
Дата: 14.07.05 10:34
Оценка:
A>Это все конечно реализуемо, но при этом синтаксис получается еще более "страшным" чем у lisp. (4-й пункт вроде токо XUL — аналог)
A>Сколько эти решения весят? Насколько они преносимы? (вот уже второй день пытаюсь в JanusSvc Dataset из SOAP s:any выдернуть.
A>нифига себе стандартизация. Изврат полный).

Как выдернешь, свистни
Автор: Mamut
Дата: 12.07.05
А то меня тоже интересуют методы борьбы с.


dmitriid.comGitHubLinkedIn
Re[13]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 10:37
Оценка:
Здравствуйте, aka50, Вы писали:

A>ааа . Ну тогда в лиспе есть ffi. Но фишка в том, что в лиспе _не необходимости_ вызывать ниче. В нем все реализуется достаточно просто


Замечательно.

A>понятно и главное на нем самом .

A>Так что думаю 1:0 в пользу лиспа

Я кажется объяснял, что я не ставлю задачу показать что лисп никуда не годен.
... << RSDN@Home 1.2.0 alpha rev. 558>>
AVK Blog
Re[15]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 10:46
Оценка:
Здравствуйте, aka50, Вы писали:

A>Здравствуйте, eao197, Вы писали:


E>>Может быть удобства использования для средненького программиста, не желающего расширять сознание, а просто получающего зарплату за фиксированный объем работы в течении 40-ка часовой рабочей недели?


A>Ну опять о простых программерах. Простой программер тоже не шибко обрадуется на XSLT писать. ИМХО лисп проще.


Для перечисленных тобой вещей есть готовые инструменты, которые прячут всю эту сложность от программиста. В результате использование более сложных технологий оказывается проще.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[3]: AST-based solution
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 10:47
Оценка:
Здравствуйте, fionbio, Вы писали:

F>
F>(namespace "MyNS"
F> (object "Obj1"
F>  (property "prop1" "int")
F>  (property "prop2" "string")
F>  (property "dblprop" "double"))
F> (object "Obj2"
F>  (property "someprop" "object[]")))
F>


F>Следует учесть, что символы namespace, object и property

F>данным генератором не используются и добавлены здесь для
F>читабельности.

Значит уже не годится — по причине того что эти символы должны проверяться, а любое отклонение детектироваться.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[16]: Lisp
От: aka50 Россия  
Дата: 14.07.05 10:48
Оценка:
Здравствуйте, eao197, Вы писали:

E>Для перечисленных тобой вещей есть готовые инструменты, которые прячут всю эту сложность от программиста. В результате использование более сложных технологий оказывается проще.


Сейчас конечно есть. Но в 1999 (или каком там XSLT родился) их не было. А лисп уже был. Зачем было изобретать? (вопрос риторический, можно не отвечать)
Re[4]: AST-based solution
От: fionbio  
Дата: 14.07.05 10:57
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, fionbio, Вы писали:


F>>
F>>(namespace "MyNS"
F>> (object "Obj1"
F>>  (property "prop1" "int")
F>>  (property "prop2" "string")
F>>  (property "dblprop" "double"))
F>> (object "Obj2"
F>>  (property "someprop" "object[]")))
F>>


F>>Следует учесть, что символы namespace, object и property

F>>данным генератором не используются и добавлены здесь для
F>>читабельности.

AVK>Значит уже не годится — по причине того что эти символы должны проверяться, а любое отклонение детектироваться.


Елки-палки, да пожалуйста:
;;; Data class generation

(defun generate-csharp-class (object)
  "Generate a C# class from DSL spec"
  (destructuring-bind (obj class-name . properties) object
    (assert (eq obj 'object) nil
        "malformed data, expected object: ~s" object)
    (loop for property in properties
      for (prop prop-name prop-type) = property
      for sharp-prop-name = (format nil "~:(~a~)" prop-name) ; C# property name
      for field-name = (concatenate 'string "_" prop-name) ; C# field name
      do (assert (eq prop 'property) nil
             "malformed data, expected property: ~s" property)
      collect `(:arg ,prop-type ,prop-name) into init-args
      collect `(:setf (:id ,field-name) (:id ,prop-name)) into init
      nconc `((:field ,prop-type ,field-name)
          (:property ,prop-type ,sharp-prop-name
            (:get (:return (:id ,field-name)))
            (:set (:setf (:id ,field-name) (:id "value"))))) into props
      finally (return
            `(:class ,class-name
              (:constructor ,class-name ()
               (:comment "NOOP"))
              (:constructor ,class-name ,init-args
               ,@init)
              ,@props)))))

(defun generate-csharp-classes (data)
  "Generate C# classes from DSL spec"
  (destructuring-bind (ns ns-name . classes) data
    (assert (eq ns 'namespace) nil
        "malformed data, expected namespace: ~s" data)
    `(:namespace ,ns-name
      ,@(mapcar #'generate-csharp-class classes))))


Можно ещё типы проверить, что там строки, где надо.
Я больше идею AST хотел продемонстрировать.
Re[4]: Lisp
От: cranky Украина  
Дата: 14.07.05 11:07
Оценка:
Здравствуйте, AndrewVK, Вы писали:

CP>>

CP>>(defparameter *test-desc*
CP>> '(:objects
CP>>   (:object :name "Obj1"
CP>>    (:property :name "prop1" :type "int")
CP>>    (:property :name "prop2" :type "string"))
CP>>   (:object :name "Obj2"
CP>>    (:property :name "foo10" :type "string")
CP>>    (:property :name "bar12" :type "sometype"))))

CP>>


AVK>Вопрос — насколько тщательно контролируется структура того, что ты привел?


Гм, а если так:
; Это автолисп
; проверено, работает

(setq objs
    '("objects"
        ("object" ("name" . "Obj1")
            ("property"
                (("name" . "prop1") ("type" . "int"))
                (("name" . "prop2") ("type" . "string"))
            )
        )
    )
)

(defun fun (lst)
    (if (= (car lst) "objects")
        (mapcar
            '(lambda (obj / name prop objpar)
                (cond
                    ((= (car obj) "object")
                        (setq
                            obj (cdr obj)
                            name (cdr (assoc "name" obj))
                            prop
                                (mapcar
                                    '(lambda (prp)
                                        (cons
                                            (cdr (assoc "type" prp))
                                            (cdr (assoc "name" prp))
                                        )
                                    )
                                    (cdr (assoc "property" obj))
                                )
                            objpar
                                (if prop
                                    (apply
                                        'strcat
                                        (mapcar
                                            '(lambda (prp) (strcat (car prp) " " (cdr prp) ", "))
                                            prop
                                        )
                                    )
                                    "__"
                                )
                            objpar (substr objpar 1 (- (strlen objpar) 2))
                        )
                        (princ (strcat
                            "public class " name "\n"
                            "{\n"
                            "\tpublic " name "(" objpar ")\n"
                            "\t{\n"
                            (apply
                                'strcat
                                (mapcar
                                    '(lambda (prp) (strcat "\t\t_" (cdr prp) " = " (cdr prp) ";\n"))
                                    prop
                                )
                            )
                            "\t}\n"
                            (apply
                                'strcat
                                (mapcar
                                    '(lambda (prp / typ nam)
                                        (setq typ (car prp) nam (cdr prp))
                                        (strcat
                                            "\tprivate " typ " _" nam ";\n"
                                            "\tpublic " typ " " (strcase (substr nam 1 1)) (substr nam 2) "\n"
                                            "\t{\n"
                                            "\t\tget { return _" nam "; }\n"
                                            "\t}\n"
                                        )
                                    )
                                    prop
                                )
                            )
                            "}\n"
                        ))
                    )
                )
            )
            (cdr lst)
        )
    )
    (princ)
)

(fun objs)
You aren't expected to absorb this
Re[5]: AST-based solution
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 11:08
Оценка:
Здравствуйте, fionbio, Вы писали:

F>Елки-палки, да пожалуйста:

F>
F>;;; Data class generation

F>(defun generate-csharp-class (object)
F>  "Generate a C# class from DSL spec"
F>  (destructuring-bind (obj class-name . properties) object
F>    (assert (eq obj 'object) nil
F>        "malformed data, expected object: ~s" object)
F>    (loop for property in properties
F>      for (prop prop-name prop-type) = property
F>      for sharp-prop-name = (format nil "~:(~a~)" prop-name) ; C# property name
F>      for field-name = (concatenate 'string "_" prop-name) ; C# field name
F>      do (assert (eq prop 'property) nil
F>             "malformed data, expected property: ~s" property)
F>      collect `(:arg ,prop-type ,prop-name) into init-args
F>      collect `(:setf (:id ,field-name) (:id ,prop-name)) into init
F>      nconc `((:field ,prop-type ,field-name)
F>          (:property ,prop-type ,sharp-prop-name
F>            (:get (:return (:id ,field-name)))
F>            (:set (:setf (:id ,field-name) (:id "value"))))) into props
F>      finally (return
F>            `(:class ,class-name
F>              (:constructor ,class-name ()
F>               (:comment "NOOP"))
F>              (:constructor ,class-name ,init-args
F>               ,@init)
F>              ,@props)))))

F>(defun generate-csharp-classes (data)
F>  "Generate C# classes from DSL spec"
F>  (destructuring-bind (ns ns-name . classes) data
F>    (assert (eq ns 'namespace) nil
F>        "malformed data, expected namespace: ~s" data)
F>    `(:namespace ,ns-name
F>      ,@(mapcar #'generate-csharp-class classes))))
F>


F>Можно ещё типы проверить, что там строки, где надо.


Можно. Только вот одна засада — жутко неудобно. Привести пример xsd, или на слово поверишь, что будет на порядок лаконичнее?
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[6]: AST-based solution
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 11:11
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Можно. Только вот одна засада — жутко неудобно. Привести пример xsd, или на слово поверишь, что будет на порядок лаконичнее?


Андрей, если не сложно, приведи -- мне интересно.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[5]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 11:19
Оценка:
Здравствуйте, cranky, Вы писали:

AVK>>Вопрос — насколько тщательно контролируется структура того, что ты привел?


C>Гм, а если так:


Здорово, но я вобще то в лиспе не особо разбираюсь. Можно комментарии где и что и каким образом?
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[6]: AST-based solution
От: fionbio  
Дата: 14.07.05 11:25
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, fionbio, Вы писали:


F>>Елки-палки, да пожалуйста:

F>>
F>>;;; Data class generation

F>>(defun generate-csharp-class (object)
F>>  "Generate a C# class from DSL spec"
F>>  (destructuring-bind (obj class-name . properties) object
F>>    (assert (eq obj 'object) nil
F>>        "malformed data, expected object: ~s" object)
F>>    (loop for property in properties
F>>      for (prop prop-name prop-type) = property
F>>      for sharp-prop-name = (format nil "~:(~a~)" prop-name) ; C# property name
F>>      for field-name = (concatenate 'string "_" prop-name) ; C# field name
F>>      do (assert (eq prop 'property) nil
F>>             "malformed data, expected property: ~s" property)
F>>      collect `(:arg ,prop-type ,prop-name) into init-args
F>>      collect `(:setf (:id ,field-name) (:id ,prop-name)) into init
F>>      nconc `((:field ,prop-type ,field-name)
F>>          (:property ,prop-type ,sharp-prop-name
F>>            (:get (:return (:id ,field-name)))
F>>            (:set (:setf (:id ,field-name) (:id "value"))))) into props
F>>      finally (return
F>>            `(:class ,class-name
F>>              (:constructor ,class-name ()
F>>               (:comment "NOOP"))
F>>              (:constructor ,class-name ,init-args
F>>               ,@init)
F>>              ,@props)))))

F>>(defun generate-csharp-classes (data)
F>>  "Generate C# classes from DSL spec"
F>>  (destructuring-bind (ns ns-name . classes) data
F>>    (assert (eq ns 'namespace) nil
F>>        "malformed data, expected namespace: ~s" data)
F>>    `(:namespace ,ns-name
F>>      ,@(mapcar #'generate-csharp-class classes))))
F>>


F>>Можно ещё типы проверить, что там строки, где надо.


AVK>Можно. Только вот одна засада — жутко неудобно.

AVK>Привести пример xsd, или на слово поверишь, что будет на порядок лаконичнее?

Верю, XSD себе представляю. Но. Во-первых, если проверку в Лиспе сделать
отдельно, она будет, понятное дело, короче. Обычно лично мне этого попросту не
требуется. Во-вторых, XSLT для генерации кода я когда-то сам использовать пытался
(см. Metaprogramming et al) и нашёл это крайне неудобным в силу чрезвычайной
ограниченности языка. XSLT логически являет собой своеобразный кастрированный
диалект Лиспа, беда только в том, что, простите, вместе с яйцами ему отхватили
голову (особенно это касается 1.0). В третьих, никто, блин, не мешает на входе
получать XML — его ж можно отпарсить в одну строчку через pxmlutils в sexpr,
а потом перевести в удобоваримый вид с практически нулевыми трудозатратами.
Re[6]: Lisp
От: cranky Украина  
Дата: 14.07.05 11:32
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, cranky, Вы писали:


AVK>>>Вопрос — насколько тщательно контролируется структура того, что ты привел?


C>>Гм, а если так:


AVK>Здорово, но я вобще то в лиспе не особо разбираюсь. Можно комментарии где и что и каким образом?


Вот:
(setq objs
    '("objects"
        ("object" ("name" . "Obj1")
            ("property"
                (("name" . "prop1") ("type" . "int"))
                (("name" . "prop2") ("type" . "string"))
            )
        )
    )
)

(defun fun (lst)
    ; здесь проверяется, что мы имеем именно список "objects"
    (if (= (car lst) "objects")
        (mapcar ; обработка объектов
            '(lambda (obj / name prop objpar)
                (cond
                    ; выбор вариантов по первому эл-ту, пока только "object"
                    ((= (car obj) "object")
                        (setq
                            obj (cdr obj)
                            name (cdr (assoc "name" obj)) ; имя объекта
                            prop
                                (mapcar ; обработка пропертей, и только их
                                    '(lambda (prp)
                                        (cons
                                            (cdr (assoc "type" prp))
                                            (cdr (assoc "name" prp))
                                        )
                                    )
                                    (cdr (assoc "property" obj))
                                )
                            objpar ; строка параметров конструктора
                                (if prop
                                    (apply
                                        'strcat
                                        (mapcar
                                            '(lambda (prp) (strcat (car prp) " " (cdr prp) ", "))
                                            prop
                                        )
                                    )
                                    "__" ; если нету свойств
                                )
                            objpar (substr objpar 1 (- (strlen objpar) 2))
                        )
                        (princ (strcat ; печать вывода одного класса
                            "public class " name "\n"
                            "{\n"
                            "\tpublic " name "(" objpar ")\n"
                            "\t{\n"
                            (apply
                                'strcat
                                (mapcar ; присваивания пропов в конструкторе
                                    '(lambda (prp) (strcat "\t\t_" (cdr prp) " = " (cdr prp) ";\n"))
                                    prop
                                )
                            )
                            "\t}\n"
                            (apply
                                'strcat
                                (mapcar ; объявления свойств и функций доступа к ним
                                    '(lambda (prp / typ nam)
                                        (setq typ (car prp) nam (cdr prp))
                                        (strcat
                                            "\tprivate " typ " _" nam ";\n"
                                            "\tpublic " typ " " (strcase (substr nam 1 1)) (substr nam 2) "\n"
                                            "\t{\n"
                                            "\t\tget { return _" nam "; }\n"
                                            "\t}\n"
                                        )
                                    )
                                    prop
                                )
                            )
                            "}\n"
                        ))
                    )
                )
            )
            (cdr lst)
        )
    )
    (princ)
)

(fun objs)
You aren't expected to absorb this
Re[7]: clarification
От: fionbio  
Дата: 14.07.05 11:39
Оценка:
Чтобы не возникло путаницы.

1. Приведённые функции осуществляют не только валидацию,
но и генерацию дерева. Проверки осуществляются несколькими
assert'ами (генерирующими исключения при ошибке). Это,
может быть, несколько quick-and-dirty по сравнению
с отдельной схемой вроде XSD, но для целей этого примера
вполне достаточно.

2. Эти ассерты всё-таки едва ли намного длиннее XSD схемы,
хотя у неё есть плюс — декларативность. Но, в конце концов,
никто не мешает на крайняк использовать в качестве источника
XML, у которого можно валидировать схему. Да и на Лиспе
если уж так надо схемовый валидатор сделать совсем не трудно.

3. XSL шаблоны неудобны для генерации кода. Текстовые темплейты
(самопальные или с исп. готовой либы) в Лиспе использовать удобнее.
Здесь же вообще рассматривается подход без текстовых шаблонов,
с использованием AST.
Re[8]: AST-based solution
От: fionbio  
Дата: 14.07.05 11:43
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, fionbio, Вы писали:


F>>Верю, XSD себе представляю. Но. Во-первых, если проверку в Лиспе сделать

F>>отдельно, она будет, понятное дело, короче.

AVK>Мне пофигу — короче она или длиннее. По символам xsd может и не сильно меньше будет. Дело в другом.

AVK>Приведенный тобой код поддерживать — это застрелиться просто.
AVK>XS поддерживать несравнимо проще, просто потому что намного проще структура.

Этот код — генератор, а не валидатор (исправленные функции оригинала)!!!
Валидацию я сделал по ходу дела. Любой нормальный лиспер в этом коде разберётся
без проблем за 0,5 секунды. И поддерживать — никаких проблем.

F>>голову (особенно это касается 1.0). В третьих, никто, блин, не мешает на входе

F>>получать XML — его ж можно отпарсить в одну строчку через pxmlutils в sexpr,
F>>а потом перевести в удобоваримый вид с практически нулевыми трудозатратами.

AVK>Вот только смысл в лиспе тогда совсем небольшой получается.


Генерация, блин. Оно лучше гораздо, чем XSLT, поверьте. Удобоваримее и проще.
Re[7]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 11:48
Оценка:
Здравствуйте, cranky, Вы писали:

AVK>>Здорово, но я вобще то в лиспе не особо разбираюсь. Можно комментарии где и что и каким образом?


C>Вот:


Ну понятно, опять императивный код. Я же говорил о другом — о декларативном задании схемы. Например как в сообщении Re[7]: AST-based solution
Автор: AndrewVK
Дата: 14.07.05
.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[9]: AST-based solution
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 11:58
Оценка:
Здравствуйте, fionbio, Вы писали:

F>Этот код — генератор, а не валидатор (исправленные функции оригинала)!!!

F>Валидацию я сделал по ходу дела. Любой нормальный лиспер в этом коде разберётся
F>без проблем за 0,5 секунды. И поддерживать — никаких проблем.

Не, ты мне покажи валидацию. Это важно. А если валидация совмещена с генерацией, то это еще хуже.

F>Генерация, блин. Оно лучше гораздо, чем XSLT, поверьте. Удобоваримее и проще.


Не, верить не буду. Потому и прошу показать.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[8]: Lisp
От: cranky Украина  
Дата: 14.07.05 12:15
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, cranky, Вы писали:


AVK>>>Здорово, но я вобще то в лиспе не особо разбираюсь. Можно комментарии где и что и каким образом?


C>>Вот:


AVK>Ну понятно, опять императивный код. Я же говорил о другом — о декларативном задании схемы. Например как в сообщении Re[7]: AST-based solution
Автор: AndrewVK
Дата: 14.07.05
.

Можно определения того и другого подхода?
You aren't expected to absorb this
Re[9]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 12:36
Оценка:
Здравствуйте, cranky, Вы писали:

AVK>>Ну понятно, опять императивный код. Я же говорил о другом — о декларативном задании схемы. Например как в сообщении Re[7]: AST-based solution
Автор: AndrewVK
Дата: 14.07.05
.

C>Можно определения того и другого подхода?

Можно.
http://en.wikipedia.org/wiki/Imperative_programming
http://en.wikipedia.org/wiki/Declarative_programming
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[4]: Lisp
От: CrazyPit  
Дата: 14.07.05 12:42
Оценка:
Здравствуйте, AndrewVK, Вы писали:



AVK>Вопрос — насколько тщательно контролируется структура того, что ты привел?


Из objects выбираются только те элементы, в которых первый символ — object. Если в object нет :name будет ошибка, также если в property не будет :type или :name будет ошибка. Для генерации property выбираются только те элементы object, которые в которых первый символ :property

CP>>Вроде практически аналогично XML.

Да есть на эту тему большое обсуждение на c2.com — XML vs. Lisp :

AVK>Только двоеточия какие то странные.


CP>>Вот реализация:


CP>>
CP>>


AVK>Мда, сурово. Я, если честно, ожидал поменьше.


Ну это же без каких-либо библиотек, и вообще весьма прямолянейное решение, здесь нужен более общий подход, как у fionbio.

AVK>P.S. Большая просьба — лишнее цитирование из ответа выкидывать.


Ок.
Re[7]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.07.05 12:56
Оценка:
Здравствуйте, eao197, Вы писали:

Забавно, что решение на Руби оказалось короче Лисповского и при этом использует формат описанный в постановке задачи. Хотя тому есть простое объяснение. Использовалась библиотека и язык запростов — XPath. Без них было бы куда длинее.

Интересно было бы глянуть на полное решение на Лиспе. Кстати, на Окамле тоже.
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[10]: Lisp
От: cranky Украина  
Дата: 14.07.05 13:19
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, cranky, Вы писали:


AVK>>>Ну понятно, опять императивный код. Я же говорил о другом — о декларативном задании схемы. Например как в сообщении Re[7]: AST-based solution
Автор: AndrewVK
Дата: 14.07.05
.

C>>Можно определения того и другого подхода?

AVK>Можно.

AVK>http://en.wikipedia.org/wiki/Imperative_programming
AVK>http://en.wikipedia.org/wiki/Declarative_programming
Ясно. Значит нужны правила типа таких:
(defun generate-constructor (name propertys) ...)
(defun generate-private-propertys-and-access-methods (propertys) ...)
(defun generate-class-from-normalized (&key name propertys) ...)
(defun generate-classes (description) ...)

Но мой же вариант получился короче и, вроде, понятнее? Плюс его несложно расширять и изменять...
You aren't expected to absorb this
Re[8]: clarification
От: _Obelisk_ Россия http://www.ibm.com
Дата: 14.07.05 13:31
Оценка:
Здравствуйте, fionbio, Вы писали:

F>Чтобы не возникло путаницы.


F>3. XSL шаблоны неудобны для генерации кода. Текстовые темплейты

F>(самопальные или с исп. готовой либы) в Лиспе использовать удобнее.
F>Здесь же вообще рассматривается подход без текстовых шаблонов,
F>с использованием AST.

Во, я как раз работаю над template-based кодогенератором (для UML 2.0) и заинтересовался функциональными языками. Проблема в том, что мне надо взаимодействовать с кодом на С++. Вопрос, есть ли возможность вызова external функций на С++ из Лисп-программы (или программы на ином ФЯ) ? Если нет, то есть ли возможность вызывать просто внешний тул из лисп-программы ? (Т.е. нужен аналог С-шной функции system() или т.п.)

И еще, например Tcl-интерпретатор можно встроить в программу на С/С++, а можно ли подобное сделать с каким либо ФЯ ?



Душа обязана трудиться! (с) Н.Заболоцкий.
Re[11]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 13:31
Оценка:
Здравствуйте, cranky, Вы писали:

C>Ясно. Значит нужны правила типа таких:

C>
C>(defun generate-constructor (name propertys) ...)
C>(defun generate-private-propertys-and-access-methods (propertys) ...)
C>(defun generate-class-from-normalized (&key name propertys) ...)
C>(defun generate-classes (description) ...)
C>


Нет. Нужно декларативное задание схемы исходного файла. Что то вроде:
тег objects
(
    тег object[один или больше раз]
    (
        атрибут name
        тег property[один или более раз]
        (
            атрибут name
            атрибут type
        )
    )
)


Идея понятна?

C>Но мой же вариант получился короче и, вроде, понятнее?

C> Плюс его несложно расширять и изменять...

Нет, ничуть не понятнее. Он тебе кажется короче и понятнее, потому что пример игрушечный.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[3]: Lisp
От: ON  
Дата: 14.07.05 13:40
Оценка:
C "железным кодом" все понятно. По-моему это вообще очень мало пересекающиеся задачи — заставить железку работать и формализовать предметную область. К сожалению термин "программирование" только один. Первое меня, как и большинство людей, считающих себя программистами не интересует.

Все же мне кажется можно поискать компромисс. Между созданием своей операционки с Лиспом в качестве системного языка, и разработкой своих версий встроенного Лиспа при создании больших приложений. Лучше всего писать на привычном языке, а для вещей, которые более естественно реализуются на Лиспе иметь небольшой движок Лиспа. У меня есть интепретатор Марка Адлера, но боюсь он в чем-то урезан, и хотелось бы к нему заодно иметь и основные Лисп-библиотеки, и желательно по возможности переделанные в С, чтоб работали побыстрее. А сам движок можно оставить интерпретатором. Вот таким я бы пользовался.

Еще вот мысль. Для Лиспа не было попыток сделать типа стилей, как в Word. Чтобы для символа можно было определить как в редакторе форматировать его ветви. Чтобы полностью в 2D, а не одними шрифтами и цветом — таблицы как таблицы, деревья как деревья. Такой бы конструктор получился.
Posted via RSDN NNTP Server 1.9
Re[5]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 13:42
Оценка:
Здравствуйте, CrazyPit, Вы писали:

AVK>>Вопрос — насколько тщательно контролируется структура того, что ты привел?


CP>Из objects выбираются только те элементы, в которых первый символ — object.


А мне нужно, чтобы если там было что то, начинающееся не с object, то была бы ошибка, причем с сообщением, понятным пользователю. Наконец, правила, по которым определяется корректность, должны быть декларативными.

CP> Если в object нет :name будет ошибка, также если в property не будет :type или :name будет ошибка.


Какая?

CP>>>Вроде практически аналогично XML.

CP>Да есть на эту тему большое обсуждение на c2.com — XML vs. Lisp :

Блин, меня не интересует XML, меня интересуют потребительские качества. Если для контроля структуры лиспа нужно писать код, который здесь приводили, то лисп в этом отношении ничем не лучше C#.

AVK>>Мда, сурово. Я, если честно, ожидал поменьше.


CP>Ну это же без каких-либо библиотек, и вообще весьма прямолянейное решение, здесь нужен более общий подход, как у fionbio.


Да у него тоже как то не очень получилось. И это на примитивнейшем примере.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[12]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 13:48
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Нет. Нужно декларативное задание схемы исходного файла. Что то вроде:

AVK>
AVK>тег objects
AVK>(
AVK>    тег object[один или больше раз]
AVK>    (
AVK>        атрибут name
AVK>        тег property[один или более раз]
AVK>        (
AVK>            атрибут name
AVK>            атрибут type
AVK>        )
AVK>    )
AVK>)
AVK>


AVK>Идея понятна?


Имхо, на Ruby такое замутить можно. Что-то типа:
root "objects" {

    element "object", ONE_OR_MORE {
        attrubute "name"
        element "property", ONE_OR_MORE {
            attribute "name"
            attribute "type"
        }
    }
}


Вот, сегодня наткнулся на проектик xml-mapping для Ruby, так там в документации такой пример приведен. Для xml-я:
<?xml version="1.0" encoding="ISO-8859-1"?>

  <Order reference="12343-AHSHE-314159">
    <Client>
      <Name>Jean Smith</Name>
      <Address where="home">
        <City>San Mateo</City>
        <State>CA</State>
        <ZIP>94403</ZIP>
        <Street>2000, Alameda de las Pulgas</Street>
      </Address>
      <Address where="work">
        <City>San Francisco</City>
        <State>CA</State>
        <ZIP>94102</ZIP>
        <Street>98765, Fulton Street</Street>
      </Address>
    </Client>

    <Item reference="RF-0001">
      <Description>Stuffed Penguin</Description>
      <Quantity>10</Quantity>
      <UnitPrice>8.95</UnitPrice>
    </Item>

    <Item reference="RF-0034">
      <Description>Chocolate</Description>
      <Quantity>5</Quantity>
      <UnitPrice>28.50</UnitPrice>
    </Item>

    <Item reference="RF-3341">
      <Description>Cookie</Description>
      <Quantity>30</Quantity>
      <UnitPrice>0.85</UnitPrice>
    </Item>

    <Signed-By>
      <Signature>
        <Name>John Doe</Name>
        <Position>product manager</Position>
      </Signature>

      <Signature>
        <Name>Jill Smith</Name>
        <Position>clerk</Position>
      </Signature>

      <Signature>
        <Name>Miles O'Brien</Name>
      </Signature>
    </Signed-By>

  </Order>


Описываются вот такие Ruby-классы:
require 'xml/mapping'

  # forward declarations
  class Client; end
  class Address; end
  class Item; end
  class Signature; end

  class Order
    include XML::Mapping

    text_node :reference, "@reference"
    object_node :client, "Client", :class=>Client
    hash_node :items, "Item", "@reference", :class=>Item
    array_node :signatures, "Signed-By", "Signature", :class=>Signature, :default_value=>[]

    def total_price
      items.values.map{|i| i.total_price}.inject(0){|x,y|x+y}
    end
  end

  class Client
    include XML::Mapping

    text_node :name, "Name"
    object_node :home_address, "Address[@where='home']", :class=>Address
    object_node :work_address, "Address[@where='work']", :class=>Address, :default_value=>nil
  end

  class Address
    include XML::Mapping

    text_node :city, "City"
    text_node :state, "State"
    numeric_node :zip, "ZIP"
    text_node :street, "Street"
  end

  class Item
    include XML::Mapping

    text_node :descr, "Description"
    numeric_node :quantity, "Quantity"
    numeric_node :unit_price, "UnitPrice"

    def total_price
      quantity*unit_price
    end
  end

  class Signature
    include XML::Mapping

    text_node :name, "Name"
    text_node :position, "Position", :default_value=>"Some Employee"
  end


И вот так затем может использоваться:
o.client.name="James T. Kirk"
o.items['RF-4711'] = Item.new
o.items['RF-4711'].descr = 'power transfer grid'
o.items['RF-4711'].quantity = 2
o.items['RF-4711'].unit_price = 29.95

o.reference = "FOOBAR-1234"

o.client = Client.new
o.client.name = 'Ford Prefect'
o.client.home_address = Address.new
o.client.home_address.street = '42 Park Av.'
o.client.home_address.city = 'small planet'
o.client.home_address.zip = 17263
o.client.home_address.state = 'Betelgeuse system'

o.items={'XY-42' => Item.new}
o.items['XY-42'].descr = 'improbability drive'
o.items['XY-42'].quantity = 3
o.items['XY-42'].unit_price = 299.95


При этом корректность схемы проверяет сам Ruby, т.к. он не позволяет обращатся к неизвестным атрибутам/методам класса.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[9]: Lisp
От: Cyberax Марс  
Дата: 14.07.05 13:58
Оценка:
Трурль wrote:

> C>А можно парсер Лиспа в 12 килобайт кода?

> Первый интерпретатор Лиспа работал на компьютерах с 8K памяти (правда
> не байт, а слов).

И что? В нем вообще строковый тип был?

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[9]: clarification
От: Mamut Швеция http://dmitriid.com
Дата: 14.07.05 14:00
Оценка:
_O_>Во, я как раз работаю над template-based кодогенератором (для UML 2.0) и заинтересовался функциональными языками. Проблема в том, что мне надо взаимодействовать с кодом на С++. Вопрос, есть ли возможность вызова external функций на С++ из Лисп-программы (или программы на ином ФЯ) ? Если нет, то есть ли возможность вызывать просто внешний тул из лисп-программы ? (Т.е. нужен аналог С-шной функции system() или т.п.)

Lisp Universal Foreign Function Interface

UFFI is a package to interface Common Lisp programs with C-language compatible libraries.



dmitriid.comGitHubLinkedIn
Re[10]: clarification
От: Трурль  
Дата: 14.07.05 14:04
Оценка:
Здравствуйте, Mamut, Вы писали:


M>Lisp Universal Foreign Function Interface

M>

M>UFFI is a package to interface Common Lisp programs with C-language compatible libraries.

Буквально следующее предложение:

Every Common Lisp implementation has a method for interfacing to such libraries.

Re[10]: AST-based solution
От: fionbio  
Дата: 14.07.05 14:15
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, fionbio, Вы писали:


F>>Этот код — генератор, а не валидатор (исправленные функции оригинала)!!!

F>>Валидацию я сделал по ходу дела. Любой нормальный лиспер в этом коде разберётся
F>>без проблем за 0,5 секунды. И поддерживать — никаких проблем.

AVK>Не, ты мне покажи валидацию. Это важно. А если валидация совмещена с генерацией, то это еще хуже.


В условиях задачи валидация не была оговорена. Я позже сделаю отдельный валидатор,
это не сложно, сейчас по просту некогда. Вообще, для многих задач приведённого
подхода вполне достаточно.

F>>Генерация, блин. Оно лучше гораздо, чем XSLT, поверьте. Удобоваримее и проще.


AVK>Не, верить не буду. Потому и прошу показать.


Это проще всего понять, попробовав. Преимуществ с точки зрения
удобства программирования много, например:

1) Возможность бысто и эффективно оттестировать каждый маленький
кусок в REPL. Упрощает отладку в сотни раз. По-хорошему, это не
отменяет юнит-тестов, их можно использовать для более крупных компонент.

2) Компактность кода. Работа с последовательностями и с деревьями/иерархиями
на C#/C++/etc. по сравнению с Лиспом — PITA. Lisp позволяет за секунды в пару
строчек описать то, что выльется в десятки-сотни строк кода на других языках.
Это связано со своеобразным подходом — имеется набор недеструктивных
функций типа remove, remove-if, mapcar и пр., чем-то напоминающих STL'евые
аналоги, но возвращающих результат в виде новой последовательности.
Конечно, это не бесплатно — написаный "с лёту" может быть вполне красив, но
не очень производителен. Но тут идея такая — сначала сделать, чтобы _всё_ работало,
затем оптимизировать. Преждевременная оптимизация — зло.
Пример компактности — транспонирование матрицы (как раз в стиле прототипа —
неоптимально по производительности, зато для лиспера — более чем компактно,
просто и ясно):
(apply #'mapcar #'list
'((1 2 3)
(4 5 6)
(7 8 9)))
-->
((1 4 7)
(2 5 8)
(3 6 9))

3) Компактная и простая запись исходных данных и промежуточных результатов
в виде s-expressions. С возможностью в любой момент без проблем посмотреть
*любые* промежуточные результаты в том же REPL.
Re[14]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 14:24
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>>>Идея понятна?


E>>Имхо, на Ruby такое замутить можно. Что-то типа:

E>>
E>>root "objects" {

E>>    element "object", ONE_OR_MORE {
E>>        attrubute "name"
E>>        element "property", ONE_OR_MORE {
E>>            attribute "name"
E>>            attribute "type"
E>>        }
E>>    }
E>>}
E>>


AVK>А как на основе этого строить проверку грамматики?


Андрей, здесь фокус в том, что это императив, который за счет фокусов Ruby выглядит как декларация.
На самом деле здесь происходит следующее:
# Вызов метода root с двумя параметрами:
# имя "objects" и блок кода в фигурных скобках.
# Так же это можно было бы записать в виде:
root( "objects" ) do

    # Вот этот блок кода может быть вызван внутри метода root
    # для какого-нибудь скрытого объекта. И следующий метод
    # element будет вызыватся для этого объекта с тремя параметрами:
    # именем "object", константой ONE_OR_MORE и блоком кода.
    element( "object", ONE_OR_MORE ) do

        # И здесь все то же самое.
        ...
    end
end


При этом Ruby не дает вызывать неизвестных методов и использовать неизвестные константы. Поэтому, если написать, что-то типа:
root "object" {
    Element "object", one_or_more { ... }
}

то сам Ruby будет ругаться на невозможность работы с Element и неопределенность one_or_more.

На таких фокусах у меня весь mxx_ru построен. Вот, пример якобы декларативности:
require 'mxx_ru/cpp'

require 'oess_1/util_cpp_serializer/gen'

Mxx_ru::setup_target(
    Mxx_ru::Cpp::Dll_target.new( "aag_3/smpp_smsc/prj.rb" ) {

    required_prj "ace/dll.rb" 

    required_prj "cls_2/prj.rb" 
    required_prj "smart_ref_3/lib.rb" 

    required_prj "threads_1/dll.rb" 

    required_prj "oess_1/defs/prj.rb" 
    required_prj "oess_1/io/prj.rb" 
    required_prj "oess_1/stdsn/prj.rb" 
    required_prj "oess_1/db/prj.rb" 

    required_prj "so_4/prj.rb" 
    required_prj "so_sysconf_2/prj.rb" 
    required_prj "so_log_1/prj.rb" 

    required_prj "mbapi_3/prj.rb" 
    required_prj "mbapi_3_mbox/core/prj.rb" 
    required_prj "mbsms_2/prj.rb" 

    required_prj "gemont_1/prj.rb" 
    required_prj "smpp_pdu_1/prj.rb" 

    required_prj "aag_3/sms_data_type/prj.rb"
    required_prj "aag_3/safe_sms_history/prj.rb"

    target "aag.smpp_smsc" 

    ddl = generator Oess_1::Util_cpp_serializer::Gen.new( self )

    cpp_source "trx_id.cpp"
    ddl.ddl_file "trx_id.ddl"

    sources_root( "impl" ) {
        cpp_source "send_trx_map.cpp" 
        cpp_source "receive_trx_map.cpp" 

        cpp_source "oess_send_trx_map.cpp"
        ddl.ddl_file "oess_send_trx_map.ddl"

        cpp_source "oess_receive_trx_map.cpp"
        ddl.ddl_file "oess_receive_trx_map.ddl"
    }

    cpp_source "cfg.cpp"
    cpp_source "a_channel.cpp"
    cpp_source "a_send_history.cpp"
    cpp_source "a_receive_history.cpp"
    cpp_source "coop_maker.cpp"
    cpp_source "coop_factory.cpp"
})


Хотя на самом деле все это чистой воды императив.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[8]: AST-based solution
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.07.05 14:25
Оценка:
Здравствуйте, AndrewVK, Вы писали:

Кстати, а как получить ХСД для некоторого ХМЛ-я? Кто-нить умеет ревер-инжинирить ХМЛ?
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re: Lisp
От: andyJB  
Дата: 14.07.05 14:32
Оценка:
Здравствуйте, fionbio, Вы писали:
F>[skip]
Появился вопрос. Чем возможности CL как "метаязыка" лучше CamlP4?
Re[15]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 14:34
Оценка:
Здравствуйте, eao197, Вы писали:

AVK>>А как на основе этого строить проверку грамматики?


E>Андрей, здесь фокус в том, что это императив, который за счет фокусов Ruby выглядит как декларация.


Фокусов мне не надо. Я думал что там что то большее за этим стоит, чего я не понимаю. Прелесть декларации не в том, как это выглядит, а в том что декларация не позволяет изменить логику, вся логика прошита в интерпретаторе. Проще говоря мы заменяем подход "как?" подходом "что?".
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[16]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 14:37
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, eao197, Вы писали:


AVK>>>А как на основе этого строить проверку грамматики?


E>>Андрей, здесь фокус в том, что это императив, который за счет фокусов Ruby выглядит как декларация.


AVK>Фокусов мне не надо. Я думал что там что то большее за этим стоит, чего я не понимаю. Прелесть декларации не в том, как это выглядит, а в том что декларация не позволяет изменить логику, вся логика прошита в интерпретаторе. Проще говоря мы заменяем подход "как?" подходом "что?".


Так на самом деле это ничему не противоречит. Ведь такое описание может просто формировать в памяти какое-то представление, которое затем будет доступно интерпритатору. А уже интерпритатор можно менять как угодно -- декларации останутся неизменными. То же самое возможно и в обратном направлении.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[6]: Lisp
От: CrazyPit  
Дата: 14.07.05 14:38
Оценка:
Здравствуйте, AndrewVK, Вы писали:



CP>>Из objects выбираются только те элементы, в которых первый символ — object.


AVK>А мне нужно, чтобы если там было что то, начинающееся не с object, то была бы ошибка, причем с сообщением, понятным пользователю. Наконец, правила, по которым определяется корректность, должны быть декларативными.


CP>> Если в object нет :name будет ошибка, также если в property не будет :type или :name будет ошибка.


AVK>Какая?


Понятно, но это делается добавлением валидаторов, но я вы сами написали что это не то что вам нужно. Вы хотите иметь возможность декларативно задавать методы генерации, но вас не польностью устраивает XSLT, в случае использовании лиспа ИМХО правельный путь решения ваших задач — это создание декларативного языка на основе лиспа(с помощью тех же макросов), аналогичного XSLT, но лишённого некоторых недостатков. Но это уже достаточно сложная задача, нужно поискать, возможно что-то аналогичное уже есть.
Re[12]: Lisp
От: cranky Украина  
Дата: 14.07.05 14:44
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, cranky, Вы писали:


C>>Ясно. Значит нужны правила типа таких:

[...]

AVK>Нет. Нужно декларативное задание схемы исходного файла. Что то вроде:

AVK>
AVK>тег objects
AVK>(
AVK>    тег object[один или больше раз]
AVK>    (
AVK>        атрибут name
AVK>        тег property[один или более раз]
AVK>        (
AVK>            атрибут name
AVK>            атрибут type
AVK>        )
AVK>    )
AVK>)
AVK>


AVK>Идея понятна?


Ну а с этим списком/схемой что было не так?
(setq objs
    '("objects"
        ("object" ("name" . "Obj1")
            ("property"
                (("name" . "prop1") ("type" . "int"))
                (("name" . "prop2") ("type" . "string"))
            )
        )
    )
)
You aren't expected to absorb this
Re[11]: AST-based solution
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 14:44
Оценка:
Здравствуйте, fionbio, Вы писали:

AVK>>Не, верить не буду. Потому и прошу показать.


F>Это проще всего понять, попробовав.


Вот я и хочу попробовать. Но прежде чем тратить уйму времени на то, чтобы начать делать концептуально кривые программки, я прошу показать мне пример правильного решения простенькой задачи. Пока что вижу все то же, что есть и в других языках.

F>1) Возможность бысто и эффективно оттестировать каждый маленький

F>кусок в REPL.

Что такое REPL? Отладчик местный?

F>2) Компактность кода.


Пока что даже XSLT на конкретной задаче оказался не сильно хуже. А уж у него избыточность синтаксиса жуткая.

F> Работа с последовательностями и с деревьями/иерархиями

F>на C#/C++/etc. по сравнению с Лиспом — PITA. Lisp позволяет за секунды в пару
F>строчек описать то, что выльется в десятки-сотни строк кода на других языках.

Например?

F>Это связано со своеобразным подходом — имеется набор недеструктивных

F>функций типа remove, remove-if, mapcar и пр., чем-то напоминающих STL'евые
F>аналоги, но возвращающих результат в виде новой последовательности.

Просто функциональный стиль? Это много где есть. Есть масса функциональных языков, при помощи шаблонов в C++ и анонимных методов в C# функциональный стиль в определенной мере можно эмулимровать.

F>Пример компактности — транспонирование матрицы


Это по твоему работа со списками? Трансформирование матрицы это конечно здорово, но это не та задача, которая лично мне интересна.

F>(как раз в стиле прототипа -

F>неоптимально по производительности, зато для лиспера — более чем компактно,
F>просто и ясно):
F>(apply #'mapcar #'list
F> '((1 2 3)
F> (4 5 6)
F> (7 8 9)))
-->>
F>((1 4 7)
F> (2 5 8)
F> (3 6 9))

Ага, а за этим стоит какой нибудь чудовищный макрос. Ну и зачем?

F>3) Компактная и простая запись исходных данных и промежуточных результатов

F>в виде s-expressions.

Результатов чего?
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[14]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.07.05 14:50
Оценка:
Здравствуйте, AndrewVK, Вы писали:

Я вот все подумываю как к R#-у прикрутить нечто вроде этого:
http://people.csail.mit.edu/jrb/jse/index.htm
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[11]: clarification
От: Mamut Швеция http://dmitriid.com
Дата: 14.07.05 14:52
Оценка:
M>>Lisp Universal Foreign Function Interface
M>>

M>>UFFI is a package to interface Common Lisp programs with C-language compatible libraries.

Т>Буквально следующее предложение:
Т>

Every Common Lisp implementation has a method for interfacing to such libraries.


Именно поэтому UFFI ривлекает своей "универсальностью". Тем более, что поддерживает основные платформы


dmitriid.comGitHubLinkedIn
Re[17]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 14:55
Оценка:
Здравствуйте, eao197, Вы писали:

E>Так на самом деле это ничему не противоречит. Ведь такое описание может просто формировать в памяти какое-то представление, которое затем будет доступно интерпритатору. А уже интерпритатор можно менять как угодно -- декларации останутся неизменными. То же самое возможно и в обратном направлении.


Можно. Но тот же вопрос — зачем тогда Руби? То же самое я могу сделать, к примеру, на шарпе.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[13]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 14:55
Оценка:
Здравствуйте, cranky, Вы писали:

C>Ну а с этим списком/схемой что было не так?

C>
C>(setq objs
C>    '("objects"
C>        ("object" ("name" . "Obj1")
C>            ("property"
C>                (("name" . "prop1") ("type" . "int"))
C>                (("name" . "prop2") ("type" . "string"))
C>            )
C>        )
C>    )
C>)
C>


То, что я говорю не о данных, а о их схеме.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[18]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 15:03
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, eao197, Вы писали:


E>>Так на самом деле это ничему не противоречит. Ведь такое описание может просто формировать в памяти какое-то представление, которое затем будет доступно интерпритатору. А уже интерпритатор можно менять как угодно -- декларации останутся неизменными. То же самое возможно и в обратном направлении.


AVK>Можно. Но тот же вопрос — зачем тогда Руби? То же самое я могу сделать, к примеру, на шарпе.


Ну, Андрей, попробуй привести код твоего же исходного XML, но выраженный на шарпе. И сравни с тем, что на Ruby можно написать. Просто синтаксического мусора меньше.

Да и твое замечание о том, что тоже самое можно сделать на шарпе я разделяю. Вот Влад давно мне (и не только мне) пытался доказать, что шарп в качестве сриптового языка без проблем можно использовать. Вот можно и попробовать его в этом качестве.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[14]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.07.05 15:04
Оценка:
Здравствуйте, AndrewVK, Вы писали:

Вот, кстати, пример на JSE генерирующий свойсва для Явы:
// Copyright (c) 2001-2003, Jonathan Bachrach, Tom White. See file LICENSE.

import net.sf.jse.IdentifierFragment;
import net.sf.jse.Fragment;
import net.sf.jse.SyntaxMatchFailure;

public syntax property {
  case #{ 
    ?modifiers:* property ?:type ?:name ?init:*; 
  }:
  {
    Fragment getterName =
      new IdentifierFragment("get".concat(capitalize(name.getName())));
    Fragment setter = #{ };
    Fragment setterName =
      new IdentifierFragment("set".concat(capitalize(name.getName())));
    return #{
      private ?type ?name ?init;
      ?modifiers ?type ?getterName() { return ?name; }
      ?modifiers void ?setterName (?type x) { this.?name = x; }
    };
  }
  
  // Need this method since IdentifierFragment.capitalize() doesn't do the right thing...
  private static String capitalize(String s) {
    if (s.length() == 0) {
         return s;
    }
    char chars[] = s.toCharArray();
    chars[0] = Character.toUpperCase(chars[0]);
    return new String(chars);
  }
}


Этот макрос преобразует такую конструкцию:
class Bean implements Serializable
{
  public property String firstName = "Tom";
}

В такую:
class Bean implements Serializable
{ 
  private String firstName = "Tom";
  public String getFirstName () { return firstName ; }
  public void setFirstName (String x) { this.firstName = x ; }
}



Думаю из него ясно как будет выглядить твой пример.
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[7]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 15:06
Оценка:
Здравствуйте, CrazyPit, Вы писали:

AVK>>Какая?


CP>Понятно, но это делается добавлением валидаторов, но я вы сами написали что это не то что вам нужно.


Мне не нужны ручные императивные валидаторы в кодогенераторе. Потмоу что подобную валидацию можно сделать на любом современном императивном языке и лисп тут ничего не дает.

CP> Вы хотите иметь возможность декларативно задавать методы генерации, но вас не польностью устраивает XSLT, в случае использовании лиспа ИМХО правельный путь решения ваших задач — это создание декларативного языка на основе лиспа(с помощью тех же макросов), аналогичного XSLT, но лишённого некоторых недостатков.


Ну вот и покажите мне пример решения на лиспе этой задачи, которое бы выглядело так же просто, декларативно и понятно, как хотя бы XSLT. Пока что я вижу что при переходе на лисп я получу сомнительное преимущество ввиде замены xml на массу скобок, при этом в нагрузочку получив императивный код генерации и ручную валидацию, либо несколько преобразований из формата в формат.

CP> Но это уже достаточно сложная задача, нужно поискать, возможно что-то аналогичное уже есть.


Ахринеть. А вот эта достаточно сложная задача почему то на XSLT решается без проблем.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[14]: Lisp
От: cranky Украина  
Дата: 14.07.05 15:14
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, cranky, Вы писали:


C>>Ну а с этим списком/схемой что было не так?


AVK>То, что я говорю не о данных, а о их схеме.

То есть, калькируя Re[7]: AST-based solution
Автор: AndrewVK
Дата: 14.07.05
, схема — это вот что:
(setq schema
    '(element (name . "objects")
        (complex-type
            (all (min-occurs . "1")
                (element (name . "object")
                    (complex-type
                        (all (min-occurs . "1")
                            (element (name . "property")
                                (complex-type (name . "")
                                    (attribute (name . "name"))
                                    (attribute (name . "type"))
                                )
                            )
                        )
                    )
                )
            )
        )
    )
)

Правильно?
You aren't expected to absorb this
Re[15]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 14.07.05 15:18
Оценка:
Здравствуйте, cranky, Вы писали:

C> Правильно?


Да. Теперь осталось написать валидатор .
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[8]: Lisp
От: CrazyPit  
Дата: 14.07.05 15:29
Оценка:
Здравствуйте, AndrewVK, Вы писали:


AVK>Ахринеть. А вот эта достаточно сложная задача почему то на XSLT решается без проблем.


Потому что XSLT — это специализированный декларативный язык, созданный для этих целей, а Lisp — универсальный ЯП. Но в Lisp'e легче чем во многих дургих языках можно создавать свои языки, поэтому Лисп и XSLT не стоит ставить на один уровень, вот если сначала создать свой DSL на lisp'e (я про это говорил, когда упоминал сложную задачу), тогда его уже нужно сравнивать с XSLT. Но в создание DSL мои познание пока весьма малы, есть люди которые этим плотно занимаются, вот ссылка на один такой исследовательский проект.
Re[15]: Lisp
От: WolfHound  
Дата: 14.07.05 15:52
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Думаю из него ясно как будет выглядить твой пример.

Мне нет. В примере Андрея нужно еще конструктор сгенерировать.
... << RSDN@Home 1.1.4 beta 6a rev. 436>>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[2]: Lisp
От: mishaa Россия http://kmmbvnr.livejournal.com
Дата: 14.07.05 16:02
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, fionbio, Вы писали:


AVK>А можно увидеть на лиспе решение следующей задачи:

AVK>Интересует решение именно в духе лиспа.

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

Собствено задача:

есть:

<object name="A">
    <extension object="B">
</object>

<object name="B">
    <extension object="C">
</object>

<object name="C"/>



Надо:



class A
{
   public static C getInstance()
   {
       return new A(new B(new C()));
   }
}

class B
{
   public static C getInstance()
   {
       return new B(new C());
   }
}

class C
{
   public static C getInstance()
   {
       return new C();
   }
}
-- Главное про деструктор копирования не забыть --
Re[16]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.07.05 18:03
Оценка:
Здравствуйте, WolfHound, Вы писали:

WH>Мне нет. В примере Андрея нужно еще конструктор сгенерировать.


А какая разница? Если на пальцах то идея такова...

Есть парсер который кроме обычного синтаксиса языка (в нашем случае Шарпа) поддерживает еще макросы. Далее есть некий движок который позволяет найти такой макрос в коде и раскрыть его. И писк и раскрытие делаются на базе АСТ.

Сам макрос оформляется так:
public syntax ИмяМакроса
{
    case #{ некий паттерн обнаруживающий этот самый макрос в АСТ. }
  {
        Некий императивный код которому доступны все ветки АСТ найденные 
        паттерн-матчингом.
    return
        #{
            Результирующий набор АСТ-веток часть из которых может быть сформирована
            в предыдущем блоке или взято из АСТ-веток найденных паттерн-матчингом.
    };
  }
    
    Другой императивный код оформленный в виде методов.
}


Таким образом в return можно нагородить хоть черта лысого. Бло бы то на базе чего городить.
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[20]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 14.07.05 19:56
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Так, что то я теряю мысль. Ты предложил, для того чтобы из псевдодекларативности сделать декларативность реальную, преобразовывать декларативное описание в Руби.


Нет, я предлагал делать декларативное описание сразу на Руби. В этом случае валидатором (по крайней мере синтаксическим) будет сам Руби. Далее на Руби же делается преобразование описания в результирующий C# код. Схема получается практически такая же, как в Лиспе. Только, на мой вкус, читабельнее.

AVK> Так зачем мне тогда выражать на шарпе исходные данные, если для шарпа и XML подходит? Впрочем могу и продемонстрировать:

AVK>
AVK>public interface Obj1
AVK>{
AVK>    int Prop1 {get;}
AVK>    string Prop2 {get;}
AVK>}
AVK>


AVK>И заметь, это гарантированно декларативный код, а не его эмуляция. Декларативность контролируется компилятором.


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

На самом деле здорово. Если речь идет именно о таких простых декларациях, то мне очень нравится. Правда, в таком подходе генерация вряд ли будет идти по шаблону -- скорее она будет так жестко прошита на шарпе. Но это, имхо, не страшно.

А поскольку ты не очерчивал заранее рамки задачи, то дальше можно пофантазировать. Например, если требуется добавить в декларацию что-то еще, что не описывается синтаксисом шарпа. У тебя в качестве варианта остается только атрибуты. Т.е. что-то типа:
public interface Obj
{
    int Prop1 {get;}
    [StrongChecking]
    string Prop2 {get;}
}

Это так же вполне удобно, до тех пор, пока синтаксиса атрибутов будет хватать. А допустим, мы хотим описывать методы с пред- и постусловиями (что-то типа контракта), где условия должны быть представлены в виде шарповского кода, чтобы результирующий код имел вид:
int Prop1
{
    // Понятно, что в getter-е вряд ли потребуются постусловия, но для демострации сойдет.
    get {
        <...some C# code...>
        int result = _prop1;
        <...some C# code...>
        return result;
    }
}


Вот тогда шапровского синтаксиса для декларативности может не хватить. В Руби/Лиспе в этом смысле запас будет, имхо, побольше. Например:
interface( "Obj" ) {
    property( "Prop1", Property::Type::INT ) {
        precondition <<-PRE
                <...some C# code...>
            PRE
        postcondition <<-PRE
                <...some C# code...>
            PRE
    }
    property( "Prop2", Property::Type::STRING ) {
        strong_checking
    }
}



Повторюсь, что без представления о том, что нужно в задаче сейчас и что может потребоваться в будущем, сложно строить предположения. Но, имхо, вариант с XML/XSLT выглядит весьма конкурентноспособно.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[12]: AST-based solution
От: cranky Украина  
Дата: 15.07.05 05:37
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, fionbio, Вы писали:


F>>Пример компактности — транспонирование матрицы


AVK>Это по твоему работа со списками? Трансформирование матрицы это конечно здорово, но это не та задача, которая лично мне интересна.


F>>(как раз в стиле прототипа -

F>>неоптимально по производительности, зато для лиспера — более чем компактно,
F>>просто и ясно):
F>>(apply #'mapcar #'list
F>> '((1 2 3)
F>> (4 5 6)
F>> (7 8 9)))
-->>>
F>>((1 4 7)
F>> (2 5 8)
F>> (3 6 9))

AVK>Ага, а за этим стоит какой нибудь чудовищный макрос. Ну и зачем?


Не знаю как в clisp, но в autolisp это записывается так:
(defun matr:trans(matr)(apply'mapcar(cons'list matr)))
, где apply, mapcar, cons и list — стандартные функции, никаких макросов, но, конечно, хранить и обрабатывать матрицы в списке списков — решение малоэффективное, хотя и единственное для данного диалекта (ну нет там массивов).
А это перемножение двух матриц:
(defun matr:*(a b)(mapcar'(lambda(j)(mapcar'(lambda(i)(apply'+(mapcar'* i j)))(matr:trans b)))a))
Интересно, кстати, завести пару матриц размерностью побольше да потестировать компилятор clisp'а на эффективность...

F>>3) Компактная и простая запись исходных данных и промежуточных результатов

F>>в виде s-expressions.
Что такое "s-expressions"?

AVK>Результатов чего?
You aren't expected to absorb this
Re[8]: Lisp
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 15.07.05 06:36
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Ахринеть. А вот эта достаточно сложная задача почему то на XSLT решается без проблем.


Ну, если принять за постулат, что Lisp — язык для построения DSL, а XSLT это DSL, то сравнивать их нельзя. Вот разработать тот DSL, который ты хочеш, на LISP, Ruby, C# и сравнить — это да.
... << RSDN@Home 1.1.4 stable rev. 510>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[17]: Lisp
От: WolfHound  
Дата: 15.07.05 07:24
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>А какая разница? Если на пальцах то идея такова...


VD>Есть парсер который кроме обычного синтаксиса языка (в нашем случае Шарпа) поддерживает еще макросы. Далее есть некий движок который позволяет найти такой макрос в коде и раскрыть его. И писк и раскрытие делаются на базе АСТ.

хъ
VD>Таким образом в return можно нагородить хоть черта лысого. Бло бы то на базе чего городить.
Я так понял что эта конструкция заменяет найденый паттрен на то что возвращает return?
Но я не понял как это можно использовать если надо из нескольких паттернов собрать одну конструкцию?
... << RSDN@Home 1.1.4 beta 6a rev. 436>>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[10]: Lisp
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 15.07.05 07:43
Оценка:
Здравствуйте, Кодёнок, Вы писали:

Кё>Почему Лиспу приписывают создание DSL? Раньше AI приписывали, сейчас DSL


Нужно всегда быть на "гребне волны"
... << RSDN@Home 1.1.4 stable rev. 510>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[21]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 08:24
Оценка:
Здравствуйте, eao197, Вы писали:

E>Нет, я предлагал делать декларативное описание сразу на Руби. В этом случае валидатором (по крайней мере синтаксическим) будет сам Руби.


Но как гарантировать что декларативное описание останется декларативным? Или как по единственной модели сгенерить несколько исходников?

AVK>>
AVK>>public interface Obj1
AVK>>{
AVK>>    int Prop1 {get;}
AVK>>    string Prop2 {get;}
AVK>>}
AVK>>


AVK>>И заметь, это гарантированно декларативный код, а не его эмуляция. Декларативность контролируется компилятором.


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


Не обязательно. Можно и сразу распарсить.

E>Повторюсь, что без представления о том, что нужно в задаче сейчас и что может потребоваться в будущем, сложно строить предположения. Но, имхо, вариант с XML/XSLT выглядит весьма конкурентноспособно.


Я тебе больше скажу — я на этом варианте написал уже массу кода. Но хотелось бы лучшего.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[9]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 08:24
Оценка:
Здравствуйте, CrazyPit, Вы писали:

CP>Потому что XSLT — это специализированный декларативный язык, созданный для этих целей,


Не для этого xslt создавался. Он создавался прежде всего для генерации html и xsl:fo по xml-файлам с данными. Вобщем понятно — эффективно предложенную задачу на лиспе не решить. И, заметь, совсем не потому что он универсальный. На универсальном O'Caml задачка решается не сильно хуже XSLT.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[9]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 08:24
Оценка:
Здравствуйте, Andrei N.Sobchuck, Вы писали:

ANS>Ну, если принять за постулат, что Lisp — язык для построения DSL, а XSLT это DSL, то сравнивать их нельзя. Вот разработать тот DSL, который ты хочеш, на LISP, Ruby, C# и сравнить — это да.


Плохому танцору, как известно, завсегда что то мешает
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[3]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 08:34
Оценка:
Здравствуйте, Павел Кузнецов, Вы писали:

ПК>Я правильно понимаю, что, на самом деле, тебе не решение на Лиспе нужно, а вообще интересуют решения, связанные с кодогенерацией?


Да.

ПК> Если так, смотрел ли ты на то, что используется в KDE?


Нет.

ПК> Например, http://conference2004.kde.org/slides/cornelius.schumacher-metaprogramming.pdf (KConfig XT: XML -> C++).


Посмотрю. Спасибо.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[13]: AST-based solution
От: pvgoran Россия  
Дата: 15.07.05 08:40
Оценка:
Здравствуйте, cranky, Вы писали:

F>>>3) Компактная и простая запись исходных данных и промежуточных результатов

F>>>в виде s-expressions.
C>Что такое "s-expressions"?

И это справшивает человек, который пишет на Lisp'е (точнее, на одном из его диалектов)?

Насколько я понимаю, S-expression — это список, в котором каждый элемент может быть либо "атомом", либо S-expression, причем семантика такого списка определяется его первым элементом.

Программа на Lisp'е — это именно последовательность S-expression'ов (с точностью до всяческих необязательных синтаксических "наворотов" типа '(something)).
... << RSDN@Home 1.1.4 stable rev. 510>>
Re[10]: Lisp
От: pvgoran Россия  
Дата: 15.07.05 08:56
Оценка:
Здравствуйте, AndrewVK, Вы писали:

CP>>Потому что XSLT — это специализированный декларативный язык, созданный для этих целей,


AVK>Не для этого xslt создавался. Он создавался прежде всего для генерации html и xsl:fo по xml-файлам с данными. Вобщем понятно — эффективно предложенную задачу на лиспе не решить.


Это еще почему???
... << RSDN@Home 1.1.4 stable rev. 510>>
Re[22]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 15.07.05 09:09
Оценка:
Здравствуйте, AndrewVK, Вы писали:

E>>Нет, я предлагал делать декларативное описание сразу на Руби. В этом случае валидатором (по крайней мере синтаксическим) будет сам Руби.


AVK>Но как гарантировать что декларативное описание останется декларативным?


Никак. Все-таки это просто использование возможности языка программирования для создания декларативных описаний. И я не знаю, как в таком описании запретить кому-нибудь написать if или while. Думаю, что это вообще не возможно.

AVK> Или как по единственной модели сгенерить несколько исходников?


Если коротко, то просто подключить несколько генераторов.

Если более развертнуто, то я вижу картину так. В общем случае мы имеем какое-то декларативное описание, которое сначала требуется перевести в какое-то внутреннее представление, а затем из внутреннего представления что-то сгенерировать. Если мы возьмем в качестве декларативного языка XML, а генераторы будем писать на шарпе, то у нас получается, фактически, три задачи:
1) разработать схему XML-деклараций;
2) написать парсер XML во внутреннее представление (здесь я имею в виду не синтаксический парсер, а извлечение семантики), т.е. в набор объектов каких-то шарповских типов;
3) написать генератор использующий внутреннее представление.

В случае Ruby у нас опять есть две похожие задачи:
1) придумать такие Ruby классы, создание объектов которых в неком Ruby-скрипте будет являтся нужным декларативным описанием. Фактически, это есть объединение задач 1-2 из подхода с использованием XML и шарпа. Но в результате исполнения скрипта с декларативными описаниями мы сразу получаем необходимое внутренне представление;
2) написать генератор использующий внутреннее представление.

Понятно, что генераторов можно создать сколько угодно. Как их комбинировать с декларативными скриптами -- это уже технические детали, имхо. Можно на вход Ruby подавать скрипт-генератор и указывать в качестве аргумента декларативный скрипт. А можно наоборот, отдавать Ruby декларативный скрипт и передавать ему аргументом имя генератора(ов). А можно сделать третий скрипт, который передается Ruby и которому, в качестве аргументов, указываются и декларативный скрип и генератор(ы).

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

Эти же достоинства оборачиваются и недостатками. Мы не можем гарантировать, что скрипты будут декларативными. Мы не можем использовать продвинутые редакторы с подсказками (как в случае XML с XSD). Мы не можем декларацию обработать программой на другом языке. Хотя, при необходимости, можно будет сделать генератор из Ruby куда-то еще (но нужно ли тогда с Ruby вообще связываться ?).

Вот такие дела. Никаких однозначных преимуществ Ruby перед связкой XML-C# я не вижу. Но сделать на Ruby такую штуку можно и я просто об этом сказал, совершенно не настаивая на том, что так нужно делать.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[10]: Lisp
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 15.07.05 09:12
Оценка:
Здравствуйте, AndrewVK, Вы писали:

ANS>>Ну, если принять за постулат, что Lisp — язык для построения DSL, а XSLT это DSL, то сравнивать их нельзя. Вот разработать тот DSL, который ты хочеш, на LISP, Ruby, C# и сравнить — это да.


AVK>Плохому танцору, как известно, завсегда что то мешает


С этим фактом не поспориш
Есть два вопроса.
Один к тебе: а зачем (как используется) тебе эта генерация.

Второй to ALL: Возможно я какое-то решение пропустил (было мало времени, всё подробно рассматривать).
(Кстати, кто-бы дал ссылки на все приведённые решения на всех языках?).
Но рассмотрим этот файл:

(object "Obj1"
         (property :name "prop1" :type "int")
         (property :name "prop2" :type "string"))


Это по сути Lisp-код. Делаем функцию object, делаем функцию property. И запускаем этот код на выполнение. Результат выполнения — вывод кода. Самому парсить ничего не нужно. Что-то в этом духе было?
... << RSDN@Home 1.1.4 stable rev. 510>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[11]: Lisp
От: mishaa Россия http://kmmbvnr.livejournal.com
Дата: 15.07.05 09:16
Оценка:
Здравствуйте, pvgoran, Вы писали:

P>Здравствуйте, AndrewVK, Вы писали:


AVK>>Не для этого xslt создавался. Он создавался прежде всего для генерации html и xsl:fo по xml-файлам с данными. Вобщем понятно — эффективно предложенную задачу на лиспе не решить.


P>Это еще почему???


К чему вопрос? Почему xslt не предназначен? Ну хотя бы потому что банальный вызов шаблона с парочкой параметров может быть длиннее самого шаблона, да и если на выходе хочется получить нормально отформатированные исходники то начинаются танцы с бубном.

Ну а если про лисп. То не вижу причин не реализовать спомошью лисповских макросов что-то типа:

(xsl:apply-templates (match '(object (property)))
(format t "class ~a" *curr-tag*))

На выходе имем
1) Возможность писать внутри шаблонов в императивном стиле
2) Все тот же лисп, а значит есть полная поддержка со стороны ide и деббагера.

Реализация получается ни чуть не сложнее чем у связки XSLT трансформер + XSLT файл.
-- Главное про деструктор копирования не забыть --
Re[11]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 09:16
Оценка:
Здравствуйте, pvgoran, Вы писали:

P>Это еще почему???


Не знаю. Но если пошли отмазки
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[11]: Lisp
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 15.07.05 09:17
Оценка:
Здравствуйте, Andrei N.Sobchuck, Вы писали:

ANS>Это по сути Lisp-код. Делаем функцию object, делаем функцию property. И запускаем этот код на выполнение. Результат выполнения — вывод кода. Самому парсить ничего не нужно. Что-то в этом духе было?


И про валидатор — другой набор функций (или макр?) результат их выполнения — валидность/невалидность кода.
... << RSDN@Home 1.1.4 stable rev. 510>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[12]: Lisp
От: raskin Россия  
Дата: 15.07.05 09:25
Оценка:
AndrewVK wrote:
> Здравствуйте, pvgoran, Вы писали:
>
> P>Это еще почему???
>
> Не знаю. Но если пошли отмазки

Здесь уже были решения с изменением формата. Сейчас кто-нибудь припомнит
библиотеку — строк на 1000 — производящую полный аккуратный разбор XML в
этот вид (или сам напишет). При этом заявит, что из-за общности размер
неважен, а важна читаемость. После этого сошлётся для описания деталей
генерации на самое изящное из решений с объявлением функции (object
&rest properties)
Posted via RSDN NNTP Server 2.0 beta
Re[4]: Lisp
От: mishaa Россия http://kmmbvnr.livejournal.com
Дата: 15.07.05 09:33
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, mishaa, Вы писали:

AVK>Понятно. Собственно такая задачка может быть решена 2 способами:

Спасибо.

Действительно select="/objects/object[@name = $object/extension/@object]" выглядит вполне красиво. Но в обшем вся сила то оказывается в XPath'е,а а не в XSLT как таковом, и именно XPath оказывается самым человеко читаемым куском программы.
-- Главное про деструктор копирования не забыть --
Re[12]: Lisp
От: Кодёнок  
Дата: 15.07.05 09:36
Оценка:
Здравствуйте, mishaa, Вы писали:

M>Ну а если про лисп. То не вижу причин не реализовать спомошью лисповских макросов что-то типа:


M>(xsl:apply-templates (match '(object (property)))

M> (format t "class ~a" *curr-tag*))

Я вообще не понимаю, о чем дискуссия.

Например, приведённый код на Ruby, например, можно транслировать в Лисп, если предположить, что в нём есть такая же XML-библиотека, и получится короткая программа, которая ну никак не отражает ни специфику Ruby, на Лиспа. Мы сможем разве что сравнить синтаксический сахар Ruby `coll do |e|` против (dolist ...) и `puts` против (format ...), что большой информации не даёт

Обсуждать связку XML+XSLT против Лиспа некорректно, потому что первые два языки специального назначения, а второй — общего. Всё равно что обсуждать один оператор пёрла `$s =~ /(foo){2,10}/i` против многих страниц _реализации_ этих самых регулярных выражений. Куда интереснее сравнить, например, декларацию + трансформер на самом языке (Ruby например), без привлечения XML, и то же самое на Лиспе.
Re[14]: AST-based solution
От: cranky Украина  
Дата: 15.07.05 09:42
Оценка:
Здравствуйте, pvgoran, Вы писали:

P>Здравствуйте, cranky, Вы писали:


C>>Что такое "s-expressions"?


P>И это справшивает человек, который пишет на Lisp'е (точнее, на одном из его диалектов)?


P>Насколько я понимаю, S-expression — это список, в котором каждый элемент может быть либо "атомом", либо S-expression, причем семантика такого списка определяется его первым элементом.


P>Программа на Lisp'е — это именно последовательность S-expression'ов (с точностью до всяческих необязательных синтаксических "наворотов" типа '(something)).

символьное выражение, что ль? Я лисп исключительно по русским источникам изучал
You aren't expected to absorb this
Re[12]: Lisp
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 15.07.05 09:59
Оценка:
Здравствуйте, eao197, Вы писали:

E>На Lisp-е:

E>Re[2]: Lisp
Автор: CrazyPit
Дата: 14.07.05
от CrazyPit

E>Re[4]: Lisp
Автор: cranky
Дата: 14.07.05
от cranky

E>Re[2]: Lisp
Автор: faulx
Дата: 14.07.05
от faulx (кстати, у него, имхо, получилось самое компактное и читабельное Lisp-решение, а вот оценок ему незаслуженно не поставили. А ведь это первая Lisp-программа была у человека)

E>Re[2]: AST-based solution
Автор: fionbio
Дата: 14.07.05
от fionbio


E>И одно было на Ruby:

E>Re[6]: Lisp
Автор: eao197
Дата: 14.07.05
(только там XML парсился).


А на Ocaml & Erlang?
... << RSDN@Home 1.1.4 stable rev. 510>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[13]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 15.07.05 10:08
Оценка:
Здравствуйте, Andrei N.Sobchuck, Вы писали:

ANS>А на Ocaml & Erlang?


На Ocaml не видел, а Erlang в соседней теме: Re: Задачка: придумать язык
Автор: Gaperton
Дата: 14.07.05
.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[23]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 10:40
Оценка:
Здравствуйте, eao197, Вы писали:

AVK>>Но как гарантировать что декларативное описание останется декларативным?


E>Никак.


Вот. В этом и проблема. Потому и говорю что подобные фокусы это не совсем то, что хотелось бы видеть.

AVK>> Или как по единственной модели сгенерить несколько исходников?


E>Если коротко, то просто подключить несколько генераторов.


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

E>Если более развертнуто, то я вижу картину так. В общем случае мы имеем какое-то декларативное описание, которое сначала требуется перевести в какое-то внутреннее представление, а затем из внутреннего представления что-то сгенерировать.


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

E> Если мы возьмем в качестве декларативного языка XML, а генераторы будем писать на шарпе, то у нас получается, фактически, три задачи:

E>1) разработать схему XML-деклараций;
E>2) написать парсер XML во внутреннее представление (здесь я имею в виду не синтаксический парсер, а извлечение семантики), т.е. в набор объектов каких-то шарповских типов;

Не обязательно. Во-первых для шарпа xml-байндинг входит в состав фреймворка. Он может и схему сгенерить, и парсинг осуществить. И все практически декларативно.
А во-вторых можно сразу генерить по XML DOM.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[13]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 10:41
Оценка:
Здравствуйте, raskin, Вы писали:

R>Здесь уже были решения с изменением формата.


Были. Но необходимость изменить формат я лично воспринимаю как недостаток.

R> Сейчас кто-нибудь припомнит R>библиотеку — строк на 1000 — производящую полный аккуратный разбор XML в

R>этот вид (или сам напишет).

Знаешь в чем проблема — в том что это не DSL, для которого такой разбор надо написать один раз. Этот формат создается на коленке под конкретную задачу и в процессе разработки может неоднократно модифицироваться. И что, каждый раз писать эти 1000 строк?
И опять же — вопрос о валидации так и остался повисшим в воздухе.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[13]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 10:41
Оценка:
Здравствуйте, Кодёнок, Вы писали:

Кё>Обсуждать связку XML+XSLT против Лиспа некорректно,


Не помню уже в который раз пишу это — я ничего не обсуждаю против. Я обсуждаю за. В качестве эталона я предложил решение на XSLT. Заметь, я сейчас не хочу обсуждать Lisp vs XSLT, мне интересно решение конкретной задачи на Lisp vs решение ее же на XSLT.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[14]: Lisp
От: raskin Россия  
Дата: 15.07.05 10:46
Оценка:
AndrewVK wrote:
> R> Сейчас кто-нибудь припомнит R>библиотеку — строк на 1000 —
> производящую полный аккуратный разбор XML в
> R>этот вид (или сам напишет).
>
> Знаешь в чем проблема — в том что это не DSL, для которого такой разбор
> надо написать один раз. Этот формат создается на коленке под конкретную
> задачу и в процессе разработки может неоднократно модифицироваться. И
> что, каждый раз писать эти 1000 строк?
> И опять же — вопрос о валидации так и остался повисшим в воздухе.

Я имею в виду типа схемной. <body><a href="no" /></body> -> (body (a
(properties ("href" "no")))) . И валидирует только XML. Из этого вида мы
видели уже изящные решения (недлинные).
Posted via RSDN NNTP Server 2.0 beta
Re[24]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 15.07.05 10:49
Оценка:
Здравствуйте, AndrewVK, Вы писали:

E>>Если коротко, то просто подключить несколько генераторов.


AVK>Подожди. Но у тебя конкретная конструкция будет интерпретироваться однозначно, либо кодогенерацию придется вводить дискриминатор, показывающий что собственно мы сейчас генерим.


Придется вводить дискриминатор, если я правильно понимаю, о чем идет речь.

E>>Если более развертнуто, то я вижу картину так. В общем случае мы имеем какое-то декларативное описание, которое сначала требуется перевести в какое-то внутреннее представление, а затем из внутреннего представления что-то сгенерировать.


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


Так я тебе и не возражал в этом вопросе. Я просто хотел показать, что в отличии от других императивных языков, где для декларативности нужно будет брать XML, в Ruby можно обойтись возможностями самого Ruby. FYI, так сказать.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[11]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 10:51
Оценка:
Здравствуйте, Andrei N.Sobchuck, Вы писали:

ANS>Один к тебе: а зачем (как используется) тебе эта генерация.


Для решения внутрипрограммных задач кодогенерации. В основном сложный объектных графов. Подробнее о таких задачках описано в документе, ссылку на который приводил ПК (к сожалению там почти ничего нет о том как они решаются) — http://conference2004.kde.org/slides/cornelius.schumacher-metaprogramming.pdf .

ANS>(Кстати, кто-бы дал ссылки на все приведённые решения на всех языках?).

ANS>Но рассмотрим этот файл:

ANS>
ANS>(object "Obj1"
ANS>         (property :name "prop1" :type "int")
ANS>         (property :name "prop2" :type "string"))
ANS>


ANS>Это по сути Lisp-код. Делаем функцию object, делаем функцию property. И запускаем этот код на выполнение. Результат выполнения — вывод кода. Самому парсить ничего не нужно. Что-то в этом духе было?


Вопросы:
1) Валидация исходной схемы?
2) Собственно генерирующий код?
3) Возможность генерации нескольких разных исходников по одной модели?
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[5]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 10:51
Оценка:
Здравствуйте, mishaa, Вы писали:

M>Действительно select="/objects/object[@name = $object/extension/@object]" выглядит вполне красиво. Но в обшем вся сила то оказывается в XPath'е,а а не в XSLT как таковом, и именно XPath оказывается самым человеко читаемым куском программы.


XPath прежде всего для XSLT разрабатывался. По началу, если я не ошибаюсь, стандарт на XPath был частью стандарта XSL. Ну и изюминка тут прежде всего не в нем, а в рекурсивном вызове шаблона.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[25]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 11:02
Оценка:
Здравствуйте, eao197, Вы писали:

AVK>>Подожди. Но у тебя конкретная конструкция будет интерпретироваться однозначно, либо кодогенерацию придется вводить дискриминатор, показывающий что собственно мы сейчас генерим.


E>Придется вводить дискриминатор, если я правильно понимаю, о чем идет речь.


И это жопа, потому что структуры того, что нужно генерить могут отличаться кардинально. Вот один из примеров: имеется модель некоего объектного графа. По ней нужно сгенерить
1) Интерфейсную модель на шарпе, представляющую собой API для работы с графом.
2) XSD xml-представления графа.
3) Загрузчик графа из XML.
4) SQL-скрипт для создания таблиц в БД для хранения графа.
5) Загрузчик графа из БД.
6) Реализацию графа, оптимизированную под XPath запросы, но не позволяющую модификацию
7) Реализацию графа, позволяющую модификацию
8) Несколько вспомогательных классов-хелперов, являющихся либо контейнерами с определенной спецификой, либо алгоритмами, работающими с графом.

Ты уже представил себе код на Руби, все это реализующий? А на XSLT это просто несколько шаблонов.

E>Так я тебе и не возражал в этом вопросе. Я просто хотел показать, что в отличии от других императивных языков, где для декларативности нужно будет брать XML, в Ruby можно обойтись возможностями самого Ruby. FYI, так сказать.


Можно. Но вариант на XSLT или функциональном языке все же лучше.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[15]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 11:02
Оценка:
Здравствуйте, raskin, Вы писали:

R>Я имею в виду типа схемной. <body><a href="no" /></body> -> (body (a

R>(properties ("href" "no")))) . И валидирует только XML. Из этого вида мы
R>видели уже изящные решения (недлинные).

Не знаю что ты имеешь ввиду, но то что я видел это обычный императивный код, который недлинный и простой только потому что исходный пример примитивный.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[26]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 15.07.05 11:08
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>И это жопа, потому что структуры того, что нужно генерить могут отличаться кардинально. Вот один из примеров: имеется модель некоего объектного графа.


Такой вопрос: этот граф для всех нижеописанных задач декларативно описывается одним XML?

AVK> По ней нужно сгенерить

AVK>1) Интерфейсную модель на шарпе, представляющую собой API для работы с графом.
AVK>2) XSD xml-представления графа.
AVK>3) Загрузчик графа из XML.
AVK>4) SQL-скрипт для создания таблиц в БД для хранения графа.
AVK>5) Загрузчик графа из БД.
AVK>6) Реализацию графа, оптимизированную под XPath запросы, но не позволяющую модификацию
AVK>7) Реализацию графа, позволяющую модификацию
AVK>8) Несколько вспомогательных классов-хелперов, являющихся либо контейнерами с определенной спецификой, либо алгоритмами, работающими с графом.

AVK>Ты уже представил себе код на Руби, все это реализующий? А на XSLT это просто несколько шаблонов.


От которых ты сам хочешь избавиться
На самом деле я не думаю, что на Ruby будет сложнее, чем на XSLT. Больше по объему -- да, скорее всего. А вот в том, что сложнее и менее сопровождаемее... Но в XSLT я даже не дилетант, поэтому спорить не буду.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[12]: Lisp
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 15.07.05 11:10
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Вопросы:

AVK>1) Валидация исходной схемы?
AVK>2) Собственно генерирующий код?
AVK>3) Возможность генерации нескольких разных исходников по одной модели?

Пока я думаю, всё это возможно. При том "малой кровью". Я в вск попробую пример забацать.
... << RSDN@Home 1.1.4 stable rev. 510>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[12]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 15.07.05 11:25
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, Andrei N.Sobchuck, Вы писали:


ANS>>Один к тебе: а зачем (как используется) тебе эта генерация.


AVK>Для решения внутрипрограммных задач кодогенерации. В основном сложный объектных графов. Подробнее о таких задачках описано в документе, ссылку на который приводил ПК (к сожалению там почти ничего нет о том как они решаются)


Думаю, что о том, как они решаются, самую подробную информацию можно найти в SVN KDE:
http://lxr.kde.org/source/kdelibs/kdecore/kconfig_compiler
http://lxr.kde.org/source/kdepim/kode/kxml_compiler/
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[27]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 11:44
Оценка:
Здравствуйте, eao197, Вы писали:

E>Такой вопрос: этот граф для всех нижеописанных задач декларативно описывается одним XML?


Да.

AVK>>Ты уже представил себе код на Руби, все это реализующий? А на XSLT это просто несколько шаблонов.


E>От которых ты сам хочешь избавиться


Не то чтобы от шаблонов, но хочется, как всегда, лучшего. Но предлагают пока только худшее.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[12]: Lisp
От: pvgoran Россия  
Дата: 15.07.05 12:54
Оценка:
Здравствуйте, mishaa, Вы писали:

M>Здравствуйте, pvgoran, Вы писали:


P>>Здравствуйте, AndrewVK, Вы писали:


AVK>>>Не для этого xslt создавался. Он создавался прежде всего для генерации html и xsl:fo по xml-файлам с данными. Вобщем понятно — эффективно предложенную задачу на лиспе не решить.


P>>Это еще почему???


M>К чему вопрос?


К невозможности эффективного решения задачи на Лиспе.
... << RSDN@Home 1.1.4 stable rev. 510>>
Re[12]: Lisp
От: pvgoran Россия  
Дата: 15.07.05 12:54
Оценка:
Здравствуйте, AndrewVK, Вы писали:

P>>Это еще почему???


AVK>Не знаю. Но если пошли отмазки


Т.е. "чувствую, что не решить задачу эффективно, а почему — не знаю"?
... << RSDN@Home 1.1.4 stable rev. 510>>
Re[14]: AST-based solution
От: ON  
Дата: 15.07.05 13:38
Оценка:
> S-expression — это список... причем семантика такого списка определяется его первым элементом.

Тут писали про ООП, полиморфимз и пример где-то есть, draw там что-то. Полиморфизм это же семантика по нескольким элементам?

А где-нибудь рассматриваются такие вещи по-подробнее? Если семантика только по одному символу, тут неизбежно должны возникать лишние формальные уровни в деревьях, которые к вычислению отношения не имеют, а лишь более удобны для человека, внимание которого очень ограничено. При компиляции эти формальности должны выбрасываться, на манер inline-подстановок. Получается стандартное представление в виде списков избыточно, хоть его тут и хвалят как самое простое. Даже такая простота может боком выйти. Вот в Рефал такого нет, и поэтому там программы еще короче, чем в Лиспе. Или опять можно на Лиспе сделать полиморфизм лямбда-выражений и получить таким образом Рефал?
Posted via RSDN NNTP Server 1.9
Re[13]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 15.07.05 13:41
Оценка:
Здравствуйте, pvgoran, Вы писали:

P>Т.е. "чувствую, что не решить задачу эффективно, а почему — не знаю"?


Т.е. пока не увидел, чтобы кто то предложил такое решение.
... << RSDN@Home 1.2.0 alpha rev. 565>>
AVK Blog
Re[15]: AST-based solution
От: fionbio  
Дата: 15.07.05 14:19
Оценка:
Здравствуйте, ON, Вы писали:

>> S-expression — это список... причем семантика такого списка определяется его первым элементом.


ON>Тут писали про ООП, полиморфимз и пример где-то есть, draw там что-то. Полиморфизм это же семантика по нескольким элементам?


ON>А где-нибудь рассматриваются такие вещи по-подробнее?

ON>Если семантика только по одному символу, тут неизбежно должны возникать лишние формальные уровни в деревьях,
ON>которые к вычислению отношения не имеют, а лишь более удобны для человека, внимание которого очень ограничено.
ON>При компиляции эти формальности должны выбрасываться, на манер inline-подстановок.
ON>Получается стандартное представление в виде списков избыточно, хоть его тут и хвалят как самое простое.
ON>Даже такая простота может боком выйти. Вот в Рефал такого нет, и поэтому там программы еще короче, чем в Лиспе.
ON>Или опять можно на Лиспе сделать полиморфизм лямбда-выражений и получить таким образом Рефал?

На лиспе можно сделать и делаются embedded Prolog (http://www.franz.com/support/tech_corner/prolog-071504.lhtml),
Erlang (http://www.dirkgerrits.com/programming/erlisp/), SQL (http://clsql.b9.com/), HTML (http://www.weitz.de/cl-who/)
— и всё равно это остаётся Лиспом + сохраняет прозрачное взаимодействие / является embeddable по отношению
к Common Lisp. Не вижу никаких препятствий к тому, чтобы эту судьбу мог разделить и Рефал.
Re[15]: Lisp
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 15.07.05 14:26
Оценка:
Здравствуйте, Кодёнок, Вы писали:

E>>Почему же? Для некоторых это может стать причиной выбора в пользу того или иного языка. Например, конструкция "call do |e|" в свое время склонила для меня чашу весов в пользу Ruby, а не Perl-а или Python-а.


Кё>Интересно, чем же `coll do |e|` лучше питоновского `for e in coll` ?


Тем, что в Питоне выражение 'for e in coll', как я понимаю -- это foreach. А в Руби выражение 'do |e| ... end' -- это блок кода, который можно привязать к большому количество операций. В том числе foreach. Насколько я понимаю в терминологии, 'do |e| ... end' и есть closure. В Питоне, как я помню, это же реализуется через lambda. Но вот в Руби блок кода можно передать параметром в любой метод.

E>>Вот чего мы не увидели, так это решение исходной задачи, включая парсинг XML-я, на Lisp-е. А жаль. Но может еще есть надежда?


Кё>В том-то и дело, что с Лиспом обычно не нужно привлекать XML и XSLT. Вот например, реализация apply-templates — функция всего в одну страницу.


То, что не нужно привлекать, это давно понятно. Важно то, что решать задачи часто приходится именно так, как они заданы, а не так как нам удобнее. Изначально речь шла об XML.
... << RSDN@Home 1.1.4 stable rev. 510>>


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[18]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 15.07.05 15:44
Оценка:
Здравствуйте, WolfHound, Вы писали:

WH>Я так понял что эта конструкция заменяет найденый паттрен на то что возвращает return?


Да. Потому это дело макросами и обозвали.

WH>Но я не понял как это можно использовать если надо из нескольких паттернов собрать одну конструкцию?


Это вопрос не ко мне. Я бы туда XPath или нечто аналогичное прикрутил бы.
... << RSDN@Home 1.2.0 alpha rev. 557>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[2]: Lisp
От: prVovik Россия  
Дата: 15.07.05 17:19
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, fionbio, Вы писали:


AVK>А можно увидеть на лиспе решение следующей задачи:

AVK>Имеем некое текстовое описание модели каких либо объектов. Пусть это будет xml. Например:

Я написал штуковину как раз для подобных преобразований. По возможностям она не уступает XSLT (есть модули, подпрограммы, переменные и пр.), но пользоваться ГОРАЗДО удобнее!
Шаблон для твоей задачи будет выглядить так:

<?"objects/object"
public class <?"@name"?>
{

    public <?"@name"?>(<?"property[position()=1]"<?"@type"?> _<?"@name"?>?>
                       <?"property[position()>1]" ,<?"@type"?> _<?"@name"?>?> )
    {
      <?"property"
        _<?"@name"?> = <?"@name"?>;
      ?>
    }

  <?"property"
    private <?"@type"?> _<?"name"?>;

    public <?"@type"?> <?"name"?>
    {
        get { return _<?"name"?>; }
    }
  ?>
}
?>
... << RSDN@Home 1.1.4 @@subversion >>
лэт ми спик фром май харт
Re[3]: Смеха ради
От: CrazyPit  
Дата: 15.07.05 21:41
Оценка:
Вот мой переделанный пример, основанный на макросах, сделал просто ради смеха, но получилось почти так-же коротко как xslt + название у меня с большой буквы;) :
(defmacro list-format (list format-string keys format-args)
  `(mapcar #'(lambda (elem)
           (destructuring-bind (&key ,@keys) elem
         (format nil ,format-string ,@format-args)))
    ,list))

(defmacro gen-private-propertys-and-access-methods (propertys)
  `(concatenate 'string
      ,@(list-format propertys "
    private ~a _~a;
    
    public ~a ~@(~a~)
    {
        get { return _~a; }
    }
"
               (type name) (type name type name name))))

(defmacro gen-constructor (name propertys)
  `(format nil
       "
    public ~a (~{~a~^, ~}) {
~{      ~a~}
    }
"
       ,name
       (list-format ',propertys "~a ~a" (type name) (type name))
       (list-format ',propertys "  _~a = ~a;~%" (type name) (name name))))

(defmacro gen-object (&key name propertys)
  `(format nil "
public class ~a
{
  ~a
  ~a
}
" ,name
      (gen-constructor ,name ,propertys)
      (gen-private-propertys-and-access-methods ,propertys)))

(defmacro gen ((&key objects))
  `(concatenate 'string
    ,@(loop for obj in objects
        collect `(gen-object ,@obj))))





Использование:

CL-USER> (gen
   (:objects ((:name "Obj1"
          :propertys  ((:name "prop1" :type "int")
                   (:name "prop2" :type "string")))
       (:name "Obj2"
          :propertys ((:name "foo10" :type "string")
                  (:name "bar12" :type "sometype"))))))
; Note: Variable TYPE defined but never used.
; 
; Note: Variable TYPE defined but never used.
; 
"
public class Obj1
{
  
    public Obj1 (int prop1, string prop2) {
        _prop1 = prop1;
        _prop2 = prop2;

    }

  
    private int _prop1;
    
    public int Prop1
    {
        get { return _prop1; }
    }

    private string _prop2;
    
    public string Prop2
    {
        get { return _prop2; }
    }

}

public class Obj2
{
  
    public Obj2 (string foo10, sometype bar12) {
        _foo10 = foo10;
        _bar12 = bar12;

    }

  
    private string _foo10;
    
    public string Foo10
    {
        get { return _foo10; }
    }

    private sometype _bar12;
    
    public sometype Bar12
    {
        get { return _bar12; }
    }

}
"


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

А вообще большое спасибо AndrewVK, вы меня очень заинтересовали проблеммой кодогенерации, набрал себе разных ссылок, буду на досуге вникать. А пока я поехал отдыхать, может ещё оттуда что-нибудь напишу по теме, удачи!

ЗЫ: валидность более менее проверяется, только ошибки будут не очень внятными.
Re[14]: Lisp
От: pvgoran Россия  
Дата: 16.07.05 08:45
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, pvgoran, Вы писали:


P>>Т.е. "чувствую, что не решить задачу эффективно, а почему — не знаю"?


AVK>Т.е. пока не увидел, чтобы кто то предложил такое решение.


Дык, так и надо было писать с самого начала...
... << RSDN@Home 1.1.4 stable rev. 510>>
Re[15]: AST-based solution
От: pvgoran Россия  
Дата: 16.07.05 08:45
Оценка:
Здравствуйте, ON, Вы писали:

>> S-expression — это список... причем семантика такого списка определяется его первым элементом.


ON>Тут писали про ООП, полиморфимз и пример где-то есть, draw там что-то. Полиморфизм это же семантика по нескольким элементам?


Не-а. По нескольким элементам — это называется множественная диспетчеризация или мультиметоды.

ON>А где-нибудь рассматриваются такие вещи по-подробнее? Если семантика только по одному символу, тут неизбежно должны возникать лишние формальные уровни в деревьях, которые к вычислению отношения не имеют, а лишь более удобны для человека, внимание которого очень ограничено.


Что-то как-то непонятно...

ON>При компиляции эти формальности должны выбрасываться, на манер inline-подстановок. Получается стандартное представление в виде списков избыточно, хоть его тут и хвалят как самое простое. Даже такая простота может боком выйти.


Опять непонятно.

ON>Вот в Рефал такого нет, и поэтому там программы еще короче, чем в Лиспе. Или опять можно на Лиспе сделать полиморфизм лямбда-выражений и получить таким образом Рефал?


Вообще все непонятно. Объясните, а?

В CLOS (== Common Lisp Object System) мультиметоды есть, просто их реализация "спрятана" внутри функции диспетчеризации, которая вызывается при интерпретации s-expression, у которого первый элемент — имя мультиметода.
... << RSDN@Home 1.1.4 stable rev. 510>>
Re[17]: AST-based solution
От: pvgoran Россия  
Дата: 16.07.05 14:46
Оценка:
Здравствуйте, ON, Вы писали:

>> ON>Тут писали про ООП, полиморфимз и пример где-то есть, draw там что-то. Полиморфизм это же семантика по нескольким элементам?

>> Не-а. По нескольким элементам — это называется множественная диспетчеризация или мультиметоды.

ON>С точки зрения реализации полиморфизм это обращение к исполняющей системе с аргументом — ссылкой на тип. А то, что пишут в учебниках это лишь интерпретация этого механизма.


IMHO интерпретация (т.е. семантика ) — это первично. Т.е. для меня полиморфизм — это именно "то, что пишут в учебниках".

ON> Принципиальной разницы нет, передавать один параметр и искать ссылку на метод в одномерной таблице, или два и искать в двумерной. Теоретицски можно обобщать дальше — при вызове передаем исполняющей системе ложку совсем неформализованного бульона, какие там объекты, параметры и прочее, вообще ничего не известно. Там это дело парсится (не будете же спорить, что есть более хитрые способы реагировать на информацию, чем извлечь из таблицы ссылку по индексу), строит метод (из аспектов каких-нибудь) и выполняет. Это, кажется, называется "управление по данным", немного другая модель вычислений, не ООП.


OK.

>> ON>А где-нибудь рассматриваются такие вещи по-подробнее? Если семантика только по одному символу, тут неизбежно должны возникать лишние формальные уровни в деревьях, которые к вычислению отношения не имеют, а лишь более удобны для человека, внимание которого очень ограничено.

>> Что-то как-то непонятно...

ON>Известный факт, что человек может думать образами состоящими не более чем из 5-7 элементов. У компьютера такого ограничения нет в приципе, тут узкое место — человек. Допустим у нас список из 100 элементов и два способа построить дерево — бинарное и десятичное. Десятичное будет в 2 яруса, бинарное в 7. Я говорю про программу, не про дерево данных. Эти лишние 5 ярусов абстракций придется придумывать. Для программиста это работа, а у нормальных людей вся эта диспетчеризация называется бюрократизмом.


Я не уверен, что понял правильно, но... Идея в том, что в программе на Лиспе будет много уровней вложенности — больше, чем нужно? Если да — то это не так, т.к. (теоретически) представление программы может быть целиком определено программистом — правда, в рамках "списочно-скобочной" структуры, но это не проблема — в эту структуру можно уместить многое.

ON>Поэтому в конторе, где софт пишут для себя, когда важен результат работы программы, а не сама программа — там нормальный начальник будет с Лиспом бороться.


Опять непонятно... Почему так? Лисп-программа не может правильно работать?

>> ON>Вот в Рефал такого нет, и поэтому там программы еще короче, чем в Лиспе. Или опять можно на Лиспе сделать полиморфизм лямбда-выражений и получить таким образом Рефал?

>> Вообще все непонятно. Объясните, а?

ON>Мне тоже мало понятно. Я не знаю ни Лисп ни Рефал




ON>Просто хочется не только писать поменьше, но и думать поменьше

ON>Вот просто по здравому смыслу. Каким образом "семантика определяется по первому элементу списка", если этот список содержит Лямбда-выражение, то есть названия функции там напрочь нет.

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

>> В CLOS (== Common Lisp Object System) мультиметоды есть, просто их реализация "спрятана" внутри функции диспетчеризации, которая вызывается при интерпретации s-expression, у которого первый элемент — имя мультиметода.


ON>Вот это отлично понятно. В конце концов получаем, что основное достоинство Лиспа в том, что там программисту ничто не мешает.


Так... Я уже замучился писать "не понял". А где что чему мешает?

ON> Единственное что это ничтожество реально делает, это посылает все в eval. А вся ценность Лиспа в библиотеках.


Какое ничтожество??

ON>Но при этом вся суть Common-версии Lisp в том, что там нельзя вообще ничего писать. За исключением случая когда это будет официально включено в стандартную библиотеку Common Lisp. А слова ламер и хакер означают абслютно одно и то же.


???

ON>А социальные проблемы у Лиспа в точности те же, что у Эсперанто.


Не знаю, соц. проблемы Эсперанто мне неизвестны...

ON>Кстати, знаете, почему стихи Пушкина написаны таким современным языком? Потому, что наш современный язык это язык Пушкина, язык его произведений.




P.S. По ходу чтения/отвечания складывалось впечатление, что Вы, скажем так, не очень серьезны.
... << RSDN@Home 1.1.4 stable rev. 510>>
Re[17]: AST-based solution
От: cranky Украина  
Дата: 16.07.05 15:10
Оценка:
Здравствуйте, ON, Вы писали:

>> ON>А где-нибудь рассматриваются такие вещи по-подробнее? Если семантика только по одному символу, тут неизбежно должны возникать лишние формальные уровни в деревьях, которые к вычислению отношения не имеют, а лишь более удобны для человека, внимание которого очень ограничено.

>> Что-то как-то непонятно...

ON>Известный факт, что человек может думать образами состоящими не более чем из 5-7 элементов. У компьютера такого ограничения нет в приципе, тут узкое место — человек. Допустим у нас список из 100 элементов и два способа построить дерево — бинарное и десятичное. Десятичное будет в 2 яруса, бинарное в 7. Я говорю про программу, не про дерево данных. Эти лишние 5 ярусов абстракций придется придумывать. Для программиста это работа, а у нормальных людей вся эта диспетчеризация называется бюрократизмом. Поэтому в конторе, где софт пишут для себя, когда важен результат работы программы, а не сама программа — там нормальный начальник будет с Лиспом бороться.


А при чём тут бинарные деревья и лисп? (код и данные там одно и то же) На нём возможны деревья любых размерностей, в том числе и переменных. И вообще кампутир думать не может, так что ещё неизвестно, что есть узкое место...

>> ON>Вот в Рефал такого нет, и поэтому там программы еще короче, чем в Лиспе. Или опять можно на Лиспе сделать полиморфизм лямбда-выражений и получить таким образом Рефал?

>> Вообще все непонятно. Объясните, а?

ON>Мне тоже мало понятно. Я не знаю ни Лисп ни Рефал

ON>Просто хочется не только писать поменьше, но и думать поменьше
ON>Вот просто по здравому смыслу. Каким образом "семантика определяется по первому элементу списка", если этот список содержит Лямбда-выражение, то есть названия функции там напрочь нет.
pvgoran писал: "В CLOS (== Common Lisp Object System) мультиметоды есть, просто их реализация "спрятана" внутри функции диспетчеризации, которая вызывается при интерпретации s-expression, у которого первый элемент — имя мультиметода."
Ну что тут непонятного? Вызывается функция (мультиметод, если угодно), которая по своим параметрам (любому кол-ву) определяет, какой метод (тоже функцию) вызвать с оставшимися параметрами!
Конечно нет у лямбда-функций имён, да они там и не нужны, на то они и лямбда, т.е. анонимные, применимые только по месту объявления (ну и ещё используются как значения функционального типа для колбэка).
Полиморфизм? Да пожалуйста:
(mapcar
    '(lambda (x) ; х - символ, привязанный к значению любого типа (атом или список)
        (type x) ; тип определяется в рантайме и заносится в список, являющийся результирующим
    )
    '(1 56.8 "monkey" lang '(a b)) ; исходный список
)
-> (INT REAL STR SYM LIST) ; список символов, обозначающих типы


>> В CLOS (== Common Lisp Object System) мультиметоды есть, просто их реализация "спрятана" внутри функции диспетчеризации, которая вызывается при интерпретации s-expression, у которого первый элемент — имя мультиметода.


ON>Вот это отлично понятно. В конце концов получаем, что основное достоинство Лиспа в том, что там программисту ничто не мешает. Единственное что это ничтожество реально делает, это посылает все в eval. А вся ценность Лиспа в библиотеках.

Ты знаешь, ничтожествам иногда приходится писать свои библиотеки Но eval это ещё что, вот read — вот это самое оно!
ON>Но при этом вся суть Common-версии Lisp в том, что там нельзя вообще ничего писать. За исключением случая когда это будет официально включено в стандартную библиотеку Common Lisp. А слова ламер и хакер означают абслютно одно и то же.
ON>А социальные проблемы у Лиспа в точности те же, что у Эсперанто.
Это какие?

ON>Кстати, знаете, почему стихи Пушкина написаны таким современным языком? Потому, что наш современный язык это язык Пушкина, язык его произведений.

Осталось выяснить при чём тут Рефал...
You aren't expected to absorb this
Re[18]: AST-based solution
От: ON  
Дата: 16.07.05 16:41
Оценка:
> IMHO интерпретация (т.е. семантика ) — это первично.

Не всегда. Меня интересует датамайнинг. То есть на входе имеем данные, на выходе программу, которая такие данные генерирует. Тут семантика появляется на выходе программы, а не на входе программиста.

> Я не уверен, что понял правильно, но... Идея в том, что в программе на Лиспе будет много уровней вложенности — больше, чем нужно? Если да — то это не так, т.к. (теоретически) представление программы может быть целиком определено программистом — правда, в рамках "списочно-скобочной" структуры, но это не проблема — в эту структуру можно уместить многое.


Да, понял.

> ON>Поэтому в конторе, где софт пишут для себя, когда важен результат работы программы, а не сама программа — там нормальный начальник будет с Лиспом бороться.

> Опять непонятно... Почему так? Лисп-программа не может правильно работать?

Мне кажется Лисп-программист будет более склонен заниматься разработкой каких-нибудь ядер и движков и прочей схоластикой.

> ON>Вот просто по здравому смыслу. Каким образом "семантика определяется по первому элементу списка", если этот список содержит Лямбда-выражение, то есть названия функции там напрочь нет.

> Ну, лямбда-выражение и определяет семантику... Название совсем не обязательно.

То есть выражение является семантикой не названия функции, а семантикой списка параметров. И такое прекрасно работает. Значит мы можем сделать множество функций с именами и проверяя в некоторой области видимости возможность применения этих функций по "семантике списка параметров", вычислять результаты с снабжать их меткой, что этот результат получен такой-то функцией. То есть имя функции используется совсем не для ее вызова, а приписывается результату после выполнения.
Это механизм так называемой интуиции. Грубо говоря вычислений без алгоритмов и как следствие без программистов.
Posted via RSDN NNTP Server 1.9
Re[4]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 02:51
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>На основании этого получается такой шаблон:...


Нда, и вот это уже прочесть очень не просто .
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 02:51
Оценка:
Здравствуйте, mishaa, Вы писали:

M>Действительно select="/objects/object[@name = $object/extension/@object]" выглядит вполне красиво. Но в обшем вся сила то оказывается в XPath'е,а а не в XSLT как таковом, и именно XPath оказывается самым человеко читаемым куском программы.


Дык XPath это часть ХСЛТ. Это его декларативный язык доступа к данным. А ХСЛТ сам по себе декларативный язык генерации кода и паттенр-матчинга.

Вот только он на ХМЛ слишком сильно заточен и не знает о формате генерируемых данных.
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[6]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 02:51
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>XPath прежде всего для XSLT разрабатывался. По началу, если я не ошибаюсь, стандарт на XPath был частью стандарта XSL. Ну и изюминка тут прежде всего не в нем, а в рекурсивном вызове шаблона.


И в нем тоже. Все же язык запросов в сотни раз более выразителен чем код доступа к объектной модели, особенно если она полиморфна (при этом начинаются страшнешие приведения типов).
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[3]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 02:51
Оценка:
Здравствуйте, prVovik, Вы писали:

V>Я написал штуковину как раз для подобных преобразований. По возможностям она не уступает XSLT (есть модули, подпрограммы, переменные и пр.), но пользоваться ГОРАЗДО удобнее!


А эту "штуковину" можно где-то глянуть?

В принципе ее можно было бы попробовать интегрировать с R# для сложного рефакторинга на базе XPath.
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[2]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 02:51
Оценка:
Здравствуйте, andyJB, Вы писали:

JB>Здравствуйте, fionbio, Вы писали:

F>>[skip]
JB>Появился вопрос. Чем возможности CL как "метаязыка" лучше CamlP4?

Хороший вопрос. Я про не го много слышал. Да и Ocaml мне лично больше нравится чем Илсп.

Покажи как будет выглядить пример с генерацией свойсатв на CamlP4 и Ocaml-е. Думаю, тут всем будет интересно.
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[10]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 02:51
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Не для этого xslt создавался. Он создавался прежде всего для генерации html и xsl:fo по xml-файлам с данными. Вобщем понятно — эффективно предложенную задачу на лиспе не решить. И, заметь, совсем не потому что он универсальный. На универсальном O'Caml задачка решается не сильно хуже XSLT.


А где решение? Ссылочку можно?
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[15]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 02:51
Оценка:
Здравствуйте, Andrei N.Sobchuck, Вы писали:

ANS>Ок. благодарю. просто, вроде бы, видел упоминание, что решение на OCaml лучше чем на LISP.


Да, я тоже. Но найти не смог.

Если тко видел, дайте ссылку, плиз.
... << RSDN@Home 1.2.0 alpha rev. 575>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[9]: Lisp
От: Cyberax Марс  
Дата: 17.07.05 05:58
Оценка:
fionbio wrote:

>>> VD>А зачем тогда Lisp? XSLT и конечное решение в две строчки пишется.

>>> Но лисп то появился до XSLT . Почему ж изобрели лисапед вместо того,
>>> чтобы лисп или ту же схему
>>> подлатать? .
> C>А можно парсер Лиспа в 12 килобайт кода?
> Не знаю, как у остальных, а у меня оно живёт вот тут:
> C:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\Tool
> Developers Guide\Samples\clisp\

И это _полноценный_ Лисп?

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[11]: Lisp
От: Cyberax Марс  
Дата: 17.07.05 06:02
Оценка:
aka50 wrote:

> C>Не простенький, а полноценный. Этот даже строковые литералы не парсит.

> К стати, тут собственно не лисп нужен а sexpr интерпретатор .
> Дык вот он есть: http://sexpr.sourceforge.net/ правда либа весит 30к,
> но думаю это не сильно важно .

Называется: "XML — вид в профиль". Вдобавок потоковый процессинг не
поддерживается.

--
С уважением,
Alex Besogonov (alexy@izh.com)
Posted via RSDN NNTP Server 1.9
Sapienti sat!
Re[11]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 17.07.05 06:55
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>А где решение? Ссылочку можно?


Нельзя. Под рукой нету, а вспоминать влом. Но в принципе очень похоже на то, что приводил Гапертон для Erlang.
... << RSDN@Home 1.2.0 alpha rev. 573>>
AVK Blog
Re[2]: Lisp
От: ON  
Дата: 17.07.05 10:21
Оценка:
> А можно увидеть на лиспе решение следующей задачи

На Лиспе все должно быть совсем по другому. Это же язык ИИ.
Без шаблонов и парсеров. Программа сама вполне в состоянии их сделать.

Человек дает два файла — XML с описанием и соответствующий "примерно такой вид" на С#. Программа их сопоставляет — находит лексику, поля подстановок и грамматику. Потом человек дает другой XML и программа уже сама выдает соответствующий код на C#. Если возникает неоднозначность человек просто выбирает тот вариант, который ему больше нравится.

Тут несколько человек смогут такое написать. Не важно на каком языке, но в таком вот мета- духе.
Posted via RSDN NNTP Server 1.9
Re[4]: Lisp
От: ON  
Дата: 17.07.05 11:46
Оценка:
> А зачем? Алгоритмы, которые требуются в данном конкретном случае, просты и детерминированны. Вносить неопределенность здесь не имеет никакого смысла.

Можно из такой программы выдернуть парсер+генератор и в явном виде. Но раз они просты и детерминированы, компьютер с ними как раз лучше справится.
Posted via RSDN NNTP Server 1.9
Re[5]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 17.07.05 13:53
Оценка:
Здравствуйте, ON, Вы писали:

ON>Можно из такой программы выдернуть парсер+генератор и в явном виде. Но раз они просты и детерминированы, компьютер с ними как раз лучше справится.


Он с ними лучше справится, если ему точно объяснить что нужно. А в этом как раз и закавыка.
... << RSDN@Home 1.2.0 alpha rev. 573>>
AVK Blog
Re[6]: Lisp
От: ON  
Дата: 17.07.05 16:20
Оценка:
> Он с ними лучше справится, если ему точно объяснить что нужно. А в этом как раз и закавыка.

Лучше один раз показать, чем сто раз объяснить
Posted via RSDN NNTP Server 1.9
Re[9]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.07.05 18:40
Оценка:
Здравствуйте, Andre, Вы писали:

A>Это в принципе можно сократить до:

A>
A>CultureInfo.CurrentCulture.TextInfo.ToTitleCase(string text)
A>


Глянул ее реализацию... и понял, что в МС платят за объем кода :
public unsafe string ToTitleCase(string str)
{
      if (str == null)
      {
            throw new ArgumentNullException("str");
      }
      if (this.m_cultureTableRecord.IsSynthetic)
      {
            if (this.ANSICodePage == 0x4e6)
            {
                  return CultureInfo.GetCultureInfo("tr-TR").TextInfo.ToTitleCase(str);
            }
            return CultureInfo.GetCultureInfo("en-US").TextInfo.ToTitleCase(str);
      }
      int num1 = str.Length;
      if (num1 == 0)
      {
            return str;
      }
      StringBuilder builder1 = new StringBuilder();
      string text1 = null;
      for (int num2 = 0; num2 < num1; num2++)
      {
            int num3;
            UnicodeCategory category1 = CharUnicodeInfo.InternalGetUnicodeCategory(str, num2, out num3);
            if (char.CheckLetter(category1))
            {
                  if (num3 == 1)
                  {
                        builder1.Append(TextInfo.nativeGetTitleCaseChar(this.m_pNativeTextInfo, str[num2]));
                  }
                  else
                  {
                        char ch1;
                        char ch2;
                        this.ChangeCaseSurrogate(str[num2], str[num2 + 1], out ch1, out ch2, true);
                        builder1.Append(ch1);
                        builder1.Append(ch2);
                  }
                  num2 += num3;
                  int num4 = num2;
                  bool flag1 = category1 == UnicodeCategory.LowercaseLetter;
                  while (num2 < num1)
                  {
                        category1 = CharUnicodeInfo.InternalGetUnicodeCategory(str, num2, out num3);
                        if (this.IsLetterCategory(category1))
                        {
                              if (category1 == UnicodeCategory.LowercaseLetter)
                              {
                                    flag1 = true;
                              }
                              num2 += num3;
                              continue;
                        }
                        if (str[num2] == '\'')
                        {
                              num2++;
                              if (flag1)
                              {
                                    if (text1 == null)
                                    {
                                          text1 = this.ToLower(str);
                                    }
                                    builder1.Append(text1, num4, (int) (num2 - num4));
                              }
                              else
                              {
                                    builder1.Append(str, num4, (int) (num2 - num4));
                              }
                              num4 = num2;
                              flag1 = true;
                              continue;
                        }
                        if (this.IsWordSeparator(category1))
                        {
                              break;
                        }
                        num2 += num3;
                  }
                  int num5 = num2 - num4;
                  if (num5 > 0)
                  {
                        if (flag1)
                        {
                              if (text1 == null)
                              {
                                    text1 = this.ToLower(str);
                              }
                              builder1.Append(text1, num4, num5);
                        }
                        else
                        {
                              builder1.Append(str, num4, num5);
                        }
                  }
                  if (num2 < num1)
                  {
                        if (num3 == 1)
                        {
                              builder1.Append(str[num2]);
                        }
                        else
                        {
                              builder1.Append(str[num2++]);
                              builder1.Append(str[num2]);
                        }
                  }
            }
            else if (num3 == 1)
            {
                  builder1.Append(str[num2]);
            }
            else
            {
                  builder1.Append(str[num2++]);
                  builder1.Append(str[num2]);
            }
      }
      return builder1.ToString();
}


Да и это немного не то. Это подем регистра у первых букв каждого слова.
... << RSDN@Home 1.2.0 alpha rev. 577>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[10]: Lisp
От: Andre Украина  
Дата: 17.07.05 18:54
Оценка:
VD>Глянул ее реализацию... и понял, что в МС платят за объем кода
Мне как то лень было Мда... Лучше действительно тогда твою оставить
... << RSDN@Home 1.1.4 beta 7 rev. 467>> :: silent
Я бы изменил мир — но Бог не даёт исходников...
Re[11]: Lisp
От: Cyberax Марс  
Дата: 18.07.05 12:40
Оценка:
Здравствуйте, Andre, Вы писали:

VD>>Глянул ее реализацию... и понял, что в МС платят за объем кода

A>Мне как то лень было Мда... Лучше действительно тогда твою оставить

Для какого-нибудь арабского работать не будет. Юникод — дело тонкое...
Sapienti sat!
Re[14]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 18.07.05 12:50
Оценка:
Здравствуйте, Andrei N.Sobchuck, Вы писали:

ANS>Интересный вопрос: нафига тут валидация вообще? Всё равно, истина в последней

ANS>инстанции — это компилятор. С валидацией у тебя есть куча мест, где можно ошибится:
ANS>код генерирующий исходный описатель это раз, схема данных это два, генератор это три.
ANS>Какой прок от валидации в данном случае?

Очень простой. В случае xml я просто описываю схему, а в кодогенераторе даже не забочусь о том, что в исходных данных будет некорректная синтаксическая структура.
... << RSDN@Home 1.2.0 alpha rev. 580>>
AVK Blog
Re[15]: Lisp
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 18.07.05 13:41
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, Andrei N.Sobchuck, Вы писали:


ANS>>Интересный вопрос: нафига тут валидация вообще? Всё равно, истина в последней

ANS>>инстанции — это компилятор. С валидацией у тебя есть куча мест, где можно ошибится:
ANS>>код генерирующий исходный описатель это раз, схема данных это два, генератор это три.
ANS>>Какой прок от валидации в данном случае?

AVK>Очень простой. В случае xml я просто описываю схему, а в кодогенераторе даже не забочусь о том, что в исходных данных будет некорректная синтаксическая структура.


Я не совсем идею понял. Почему тебя не волнует правильность исходных данных? И всё таки, если прохождение валидации не гарантирует правильность целевого кода, то зачем она нужна?

Если речь идёт о внутрипрограмной генерации, то не проще ли создать генератор с неким API. Который, можно протестировать. У тебя будет одна точка, где может возникнуть ошибка, а не три.
... << RSDN@Home 1.1.4 stable rev. 510>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[16]: Lisp
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 18.07.05 14:00
Оценка:
Здравствуйте, Andrei N.Sobchuck, Вы писали:

ANS>Я не совсем идею понял. Почему тебя не волнует правильность исходных данных?


С чего ты взял что не волнует?

ANS> И всё таки, если прохождение валидации не гарантирует правильность целевого кода, то зачем она нужна?


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

ANS>Если речь идёт о внутрипрограмной генерации, то не проще ли создать генератор с неким API. Который, можно протестировать.


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

ANS> У тебя будет одна точка, где может возникнуть ошибка, а не три.


Каких три?
... << RSDN@Home 1.2.0 alpha rev. 580>>
AVK Blog
Re[17]: Lisp
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 18.07.05 14:31
Оценка:
ANS>> У тебя будет одна точка, где может возникнуть ошибка, а не три.

AVK>Каких три?


Генератор, валидатор, конвертор.

Впрочем, ладно, не зная use-cases я не могу сказать ничего умного
... << RSDN@Home 1.1.4 stable rev. 510>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[3]: Lisp
От: andyJB  
Дата: 18.07.05 16:57
Оценка:
Здравствуйте, VladD2, Вы писали:


VD>Покажи как будет выглядить пример с генерацией свойсатв на CamlP4 и Ocaml-е. Думаю, тут всем будет интересно.


А можно ссылку на пример, который нужно переписать?
Re[4]: Lisp
От: andyJB  
Дата: 18.07.05 17:59
Оценка:
Здравствуйте, andyJB, Вы писали:

JB>Здравствуйте, VladD2, Вы писали:



VD>>Покажи как будет выглядить пример с генерацией свойсатв на CamlP4 и Ocaml-е. Думаю, тут всем будет интересно.


JB>А можно ссылку на пример, который нужно переписать?

А понял, из предыдущего ответа.
Re[4]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.07.05 23:35
Оценка:
Здравствуйте, andyJB, Вы писали:

JB>А можно ссылку на пример, который нужно переписать?


XSLT-версию найти к сожалению не могу. Но она самая понятная и простая.

Исходная задача
Автор: AndrewVK
Дата: 13.07.05


Реализации на лиспе...
Реализация на Лиспе 1
Автор: fionbio
Дата: 14.07.05
.
Реализация на Лиспе 2
Автор: CrazyPit
Дата: 14.07.05

Реализация на Лиспе 3
Автор: Andrei N.Sobchuck
Дата: 18.07.05


Императивные реализации.
Реализация на C#
Автор: VladD2
Дата: 17.07.05

Реализация на Ruby
Автор: eao197
Дата: 14.07.05


Реализация на Руби совсем лобовая, так что на нее лучше не ориентироваться.
... << RSDN@Home 1.2.0 alpha rev. 578>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[12]: Lisp
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.07.05 23:35
Оценка:
Здравствуйте, Cyberax, Вы писали:

C>Для какого-нибудь арабского работать не будет. Юникод — дело тонкое...


Она и для русского работает не ахти.
... << RSDN@Home 1.2.0 alpha rev. 578>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re: Lisp
От: Ka3a4oK  
Дата: 20.07.05 19:46
Оценка:
У меня пара вопросов.

1. На сколько хорош LispWorks Personal Edition? Я так понимаю LispWorks всем лучше LispBox, только он платный ?
2. Можно ли создать исполняемый *.exe модуль программы на лиспе.
3. Cкачал LispBox — не работает OpenFile. Просто какой-то писк, словно ошибка произошла и все.
Что делать?
4. JabberWokly — лажа ?
... << RSDN@Home 1.1.4 stable rev. 510>>
Re: Lisp
От: aefimov Россия
Дата: 21.07.05 16:36
Оценка:
Здравствуйте, fionbio, Вы писали:

F>Напоследок приведу ссылку на одну интересную вещь — пример работы с Common Lisp,

F>в режиме самого что ни на есть interactive development'а. Я уже давал ссылку на
F>статью известного деятеля в области OO, XP и пр. Martin'а Fowler'а:
F>http://martinfowler.com/articles/languageWorkbench.html

Я пытался поработать с MPS, чесно говоря немноо запутался. НЕ могли бы вы ткуть меня носом в книгу/туториал типа:
http://www.jetbrains.com/mps/start/index.html

Я скачал ListWorks, и посмотрел на examples, но даже не смог из запустить. Т.е. не понятно ничего вообще...
Качать мувик не хочется, хочется прочитать и самому написать DSL, пободный JetBrainsсовскому HelloWorld, чтобы
сравнить.

Спасибо!
Re[8]: Lisp
От: cranky Украина  
Дата: 24.07.05 17:46
Оценка:
Здравствуйте, Cyberax, Вы писали:

C>А можно парсер Лиспа в 12 килобайт кода?


В 22К пойдёт? (если там не только парсер):

http://rapidshare.de/files/3318324/rklisp.rar.html

Интерпретатор написан на D+MinTL, ещё не всё реализовано, но пара десятков основных функций и все типы, кроме REAL, работают будто бы неплохо
You aren't expected to absorb this
Re[2]: Решение на Питоне
От: eugals Россия  
Дата: 02.08.05 14:35
Оценка:
Здравствуйте, VladD2, Вы писали:

E>>Кстати, да — вполне в лисповском духе получилось...

VD>Агащазблин. Чистый императив как на Руби, только вместо ХМЛ-я непойми что.

Ну, там же написано "в лисповском духе", а не "чисто декларативный разборщик DSL" — почувствуй разницу. Под "лисповским духом" я тут имел ввиду, что в качестве формата исходных данных был использован сам язык высокого уровня (Internal DSL, в определении Фаулера).
Что же касается "ХМЛ" vs "непойми что", то сдается мне ты лукавишь.
Вот это:
class Obj1(CSClass):
    prop1 = CSProp(int)
    prop2 = CSProp(string)

вряд ли более "непонятно", чем вот это:
<objects>
    <object name="Obj1">
        <property name="prop1" type="int"/>
        <property name="prop2" type="string"/>
    </object>
</objects>

... << RSDN@Home 1.1.4 stable rev. 510>>
Re[4]: Lisp
От: pongo  
Дата: 13.09.05 09:58
Оценка:
Здравствуйте, eao197, Вы писали:

E>Позволю себе пару комментариев по твоему посту.


я сделал так, как позволили мои знания. В общем, надо будет это изучить

E>Ну и в твоем варианте можно было вполне обойтись без глобальной переменной.

Знаю.

E>Во-вторых, Ruby, имхо, лучше изучать не по статьям, а по книге "Programming Ruby: The Pragmatic Programmer's Guide".

до неё я еще не дошел. Как не дошел и до DSL. Читал про DSL только маленькую статью в одном блоге...
Re[4]: Смеха ради
От: vdimas Россия  
Дата: 10.12.05 19:42
Оценка:
Здравствуйте, CrazyPit, Вы писали:

Смеха ради можно попользовать макросы из С. Прогонять только препроцессором.

Вот программа:
#define CLASS(name, properties)\
public class name {\
properties\
}

#define BASE(name) : name

#define PROP(type, name)\
  type _##name;\
  type name { \
    get {return _##name; }\
    set { _##name = value; }\
}


Вот на входе:
CLASS(SomeClass BASE(BaseClass), 
    PROP(int, Prop1) 
    PROP(string, Prop2))


Вот на выходе (после форматирования):
     public class SomeClass : BaseClass {
        int _Prop1;
        int Prop1 {
            get { return _Prop1; }
            set { _Prop1 = value; }
        }

        string _Prop2;
        string Prop2 {
            get { return _Prop2; }
            set { _Prop2 = value; }
        }
    }
Re[8]: Lisp
От: Dr.Gigabit  
Дата: 26.02.06 17:22
Оценка:
Здравствуйте, Cyberax, Вы писали:

>> C>В-третьих, для обычных языков типа Java/C# уже существуют системы для

>> C>редактирования AST. Только называется это Aspect Oriented
>> Programming. А
>> C>для C# у нас еще и R# есть
>> Не есть — а недавно появилось...

Ваши представления об АОП несколько искажены.

C>AspectJ появился в 99 (если не ошибаюсь), до этого были исследования на

C>эту тему в PARC'е.

>> Что еше раз потверждает выше сказанную мысль о том что все языки

>> медленно двигаются в сторону Лиспа.
>> Меня собственно и подвигло на серьезноге изучение Лиспа, так это то
>> что в CLOS кажись заложенно и AOP .

C>Кстати, после нескольких лет увлечения AOP сейчас интерес к нему

C>угасает.

Достаточно сюда глянуть.
... << RSDN@Home 1.1.4 stable SR1 rev. 568>>
Re[4]: Решение на Ruby DSL.
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 27.02.06 16:47
Оценка:
Здравствуйте, Oyster, Вы писали:

O>Спасибо за код. Я так понял, что Ruby — язык с динамической типизацией?


Да.

O>В общем-то, не нравится мне в его средствах метапрограммирования то, что они недалеко ушли от сишных макросов — фактически мы собираем код в текстовом виде. Со всеми вытекающими в виде отсутствия контроля типов в компайл-тайм (но в Ruby-то этого и так нет, если я всё правильно понимаю) и невнятных ошибок в случае, если что-то генерится неверно (на простом примере можно и глазками посмотреть, а вот на сложном...).


Уж не знаю... С сишными макросами ничего общего.
На счет невнятности сообщений об ошибках: попробовал сейчас сделать синтаксическую ошибку в методе generate, убрал закрывающую скобку в конструкторе. Получил такое сообщение:
t3.rb:37:in `object': (eval):7:in `object': compile error (SyntaxError)
(eval):6: syntax error  from t3.rb:41:in `eval'
        from t3.rb:37:in `object'
        from t3.rb:41

(eval):7 -- это как раз место, где Ruby обнаружил синтаксическую ошибку (т.е. 7 -- это номер строки, которую обрабатывал eval). Если результат generate где-нибудь распечатать, то ошибка определяется достаточно точно.

O>Ну и ещё не нравится то, что нельзя оперировать кусками AST, т.к. это может быть очень полезно (ну там — пройтись по AST рекурсивно и сделать что-нибудь для нодов определённого типа). Или можно, но в коде это не использовалось?


Я вообще не представляю, какое у Ruby AST и зачем над ним чего-нибудь делать. Чем мне меньше всего хочется заниматься -- так это копаться во внутренностях компилятора.

По-моему, недавно на какой-то конференции по Ruby был доклад про какую-то штуку, которая Ruby код позволяет в виде дерева представлять. Но вот насколько это удобно --


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[4]: Решение на Ruby DSL.
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 27.02.06 17:20
Оценка:
Здравствуйте, Oyster, Вы писали:

O>Ну и ещё не нравится то, что нельзя оперировать кусками AST, т.к. это может быть очень полезно (ну там — пройтись по AST рекурсивно и сделать что-нибудь для нодов определённого типа). Или можно, но в коде это не использовалось?


Вот штука, которая должна позволять работать с Ruby AST: Parse Tree.


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[7]: Решение на Ruby DSL.
От: VladD2 Российская Империя www.nemerle.org
Дата: 06.03.06 19:46
Оценка:
Здравствуйте, eao197, Вы писали:


E>При таком подходе макросов, как таковых, нет.


Куда же они делись? Самые что ни наесть, но текстуальные. Именно это и роднит их с С. И это их основаня проблема.
... << RSDN@Home 1.2.0 alpha rev. 637>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[9]: Решение на Ruby DSL.
От: VladD2 Российская Империя www.nemerle.org
Дата: 07.03.06 15:04
Оценка:
Здравствуйте, eao197, Вы писали:

E>Влад, макросы в C/C++ -- это средство, модифицирующее исходный код программы до его обработки компилятором. В Ruby выполняется динамическая трансляция исходного текста во внутреннее представление с последующим исполнением получившегося кода (фактически интерпритация). В таком подходе нет отдельной фазы разворачивания макросов перед трансляцией.


Без разницы. Разница только в том на каком уровне работают макросы. На уровне текста, или на уровне АСТ.

E>Более того, например, декларация класса в Ruby -- это тот же самый код, который исполняется последовательно, что позволяет, к примеру, делать так:

E>
E>class SomeClass
E>  if $debug_mode
E>    # Такой конструктор будет у класса, если работаем в отладке.
E>    def initialize( param1, param2, param3 )
E>      # ...
E>    end

E>    # Так же для отладки добавляется специальный метод.
E>    def debug_dump( debug_stream )
E>      # ...
E>    end
E>  else
E>    # В release у класса будет другой конструктор.
E>    def initialize( param )
E>      # ...
E>    end
E>  end
E>end
E>


Ну, и в чем тут отличие от С? Замени if на #ifdef и ...

E>Фактически, исходный файл для Ruby-интерпритатора -- это исходный поток, из которого нужно извлекать очередную строку, транслировать ее во внутренее представление и исполнять. Поэтому совершенно нормальным является временная смена этого исходного потока на строку, сформированную самой программой.


Ключевое слово выделено. Формирование строк слишком подверженно ошибкам и имеет слишком слабый контроль. Плюс это полностью отрежает возможность получать информацию о типах.

Итерпретируемость язык конечно дает некоторую выгоду в данной ситуации, но положения дел не меняет.

E>Как следствие этого, в Ruby можно сделать то, что в принципе невозможно сделать макросами C/C++ -- изменить код программы после трансляции.


Это не заслука макроподсистемы. Это заслуга интерпретатора. В С++ моного нельзя того что можно в Руби. Но это уже ограничения подхода (статически типизированного языка).

E>Так что, никакие это не макросы, это особенность интерпритации кода.


То что ты показал — это макросы чистой воды. Причем худший их вариант.
... << RSDN@Home 1.2.0 alpha rev. 637>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[10]: Решение на Ruby DSL.
От: eao197 Беларусь http://eao197.blogspot.com
Дата: 08.03.06 08:57
Оценка:
Здравствуйте, VladD2, Вы писали:

> Без разницы. Разница только в том на каком уровне работают макросы. На

> уровне текста, или на уровне АСТ.

Интересно. А что в твоем представлении является макросами?

> Ну, и в чем тут отличие от С? Замени if на #ifdef и ...


... и ты не понял. В декларации класса можно использовать любой код, хоть if-ы, хоть циклы. Вот, например:
class Demo
    FUNCS = { :strlen => 'int strlen(const char *str)',
        :strcpy => 'char * strcpy(char *to, const char *from)',
        :strcat => 'char * strcat(char *to, const char *from)' }

    FUNCS.each { |k, v| define_method( k ) { v } }
end

puts Demo.instance_methods( false )
puts "---------------"

d = Demo.new
puts d.strlen
puts d.strcpy
puts d.strcat


Производит:
strcat
strcpy
strlen
---------------
int strlen(const char *str)
char * strcpy(char *to, const char *from)
char * strcat(char *to, const char *from)


Как такое сделать в C с помощью директив компиляции?
А ведь можно еще и так написать:
FUNCS.each { |k, v| class_eval "def #{k}; '#{v}'; end" }


Результат будет тот же самый.

> Ключевое слово выделено. Формирование строк слишком подверженно ошибкам

> и имеет слишком слабый контроль.

О каких ошибках и о каком контроле ты говоришь?

> Плюс это полностью отрежает возможность

> получать информацию о типах.

Не понимаю.

> E>Так что, никакие это не макросы, это особенность интерпритации кода.

>
> То что ты показал — это макросы чистой воды. Причем худший их вариант.

Чем же это худший вариант? Обычная кодогенерация в run-time.
Просто в динамических языках работа идет по другому. Поэтому не нужно пытаться повесить на динамические языки ярлыки из статически-типизированных языков.


SObjectizer: <микро>Агентно-ориентированное программирование на C++.
Re[9]: Решение на Ruby DSL.
От: Andrei N.Sobchuck Украина www.smalltalk.ru
Дата: 13.03.06 09:44
Оценка:
Здравствуйте, eao197, Вы писали:

E> В Ruby выполняется динамическая трансляция исходного текста во внутреннее представление с последующим исполнением получившегося кода (фактически интерпритация). В таком подходе нет отдельной фазы разворачивания макросов перед трансляцией. Более того, например, декларация класса в Ruby -- это тот же самый код, который исполняется последовательно, что позволяет, к примеру, делать так:


Похоже на препроцессор. Я так понимаю, что два раза с разными параметрами такой код не вызвать?
http://www.smalltalk.ru | << RSDN@Home 1.1.4 stable SR1 rev. 568>>
Я ненавижу Hibernate
Автор: Andrei N.Sobchuck
Дата: 08.01.08
!
Re[10]: Решение на Ruby DSL.
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.03.06 16:38
Оценка:
Здравствуйте, Andrei N.Sobchuck, Вы писали:

ANS>Похоже на препроцессор. Я так понимаю, что два раза с разными параметрами такой код не вызвать?


А в чем проблема препроцессор два раза прогнать?
... << RSDN@Home 1.2.0 alpha rev. 637>>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
 
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.