Система типов для компонентного программирования.
От: AlexCab LinkedIn
Дата: 20.08.11 11:34
Оценка: :))) :)
Очень вкратце(если не понятно я буду уточнять) о модели компонентного программирования:
Все сущности в программе делятся на две группы:
  1.Компоненты("жесткая" часть), по аналогии с компонентами электронных схем.
      Делятся на:
        1.Средства создания программ:
            1.Модули, состоят из контейнеров.
            2.Контейнеры(переменные) значений, для хранения значений.
        2.Вспомогательные средства:
            1.Типы значений.
  2.Значения("мягкая" часть), по аналогии с сигналами электронных схем.
      Делятся на:
        1.Приметивные:
            1.Значения-данные, содержат данные.
            2.Значения-код(лямбды), содержат код.  
        2.Структурные, состоят из примитивных.

Это можно представить так (зленные стрелки — путь прохождения значений):

Когда значение код находится в контейнере оно может быть выполнено(то есть вызвано из другого значения-кода).
Нет различия между операторами и процедурами, просто вызов процедуры, имеющий два аргумента может быть записан инфиксно.
Имеется некоторый базовый набор типов значений, значений и контейнеров значений и прочих возможностей, на основе которого можно создавать более сложные сущности.
Система типов:
Тип значения — это описание, включающее собственно описание значений и значение по умолчанию для данного типа.
Например, тип "PIXIL":
   PIXIL DATA [3] 0      \\Значения типа "PIXIL" это значения-данные, имеют размер в 3 байта и значение по умолчанию для этих байт 0.

И тип "FOO":
   FOO CODE [PIXIL,BYTE][BO0L] (){}() \\Значения типа "FOO" это значения-коды, принимающие два аргумента типа "PIXIL" и "BYTE", и возвращающие одно значение типа "BO0L",
                                      \\значени по умолчанию для этого типа ничего не делает.

При помощи типа "FOO" можно например реализовать оператор сравнения типа "PIXIL" с типом "BYTE" ():
   == FOO (A,B){                      \\Это определение контейнера
               false => R
               IF (A)Byte[0] == B {
                 IF (A)Byte[1] == B {  
                   IF (A)Byte[2] == B {truth => R}}}  
               }(R)

Типы "BYTE", "BO0L" являются базовым потому для них есть реализация операторов "==","=>","IF",
возможность работать с значением на уровне байт "(\*Имя_контейнера*\)Byte[\*Номер_байта*\]", тагже базовая.
Другой пример:
  \\Определения.
    S PIXIL \\Опеределение контейнера для значений типа "PIXIL".
    G FOO   \\Для значений типа "FOO"
  \\Код
    (A,B){\*Чего-то делаем с "PIXIL" и "BYTE" и возвращаем "BO0L"*\}(R) FOO => G  \\Помещаем значение типа "FOO" в контейнер "G"(присваиваем переменной).
    G(S,1) => S \\Вызываем помещённое в "G" значение.



Как вы считаете:
1.Каковы недостатки, такой модели и системы типов?
2.Жизнеспособно ли это в принципе?
3.Не слишком ли это сложно?
4.Неявное приведение типов, насколько оно нужно?
Спасибо.
Между тем,что я думаю,тем,что я хочу сказать,тем,что я,как мне кажется,говорю,и тем,что вы хотите услышать,тем,что как вам кажется,вы слышите,тем,что вы понимаете,стоит десять вариантов возникновения непонимания.Но всё-таки давайте попробуем...(Э.Уэллс)
 
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.