Какие задачи решают системы типов - Философия программирования

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

S>Вот об этом я и писал, нконец-то до тебя дошло. Не прошло и двухсот постов...

Ты писал не об этом. Ты как раз писал о том, что есть разница между определением через функцию и определением через тип. Спорю как раз о том, что разницы нет.

FDS>>Кроме этого, само определение функции cons x y говорит, что данные хранятся в памяти. Если определение будет другое, то это будет говорить о том, что данные хранятся по другому, т.е. если

S>Определение? Я утверждал про тип, а не про определение.

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

FDS>>Т.е. в зависимости от того, как именно мы храним данные, меняются и объявления класса, и объявления функции, из которой происходит возврат замыкания — и там, и там хранятся одни и те же данные
S>А типы могут оставаться неизменными. МОГУТ!!! и НЕ ВСЕ ТИПЫ!!! Это на всякий случай..

Могут, в чём вопрос? Причём останутся они неизменными и там, и там. Где же разница между определением типа данных через struct или через замыкание?

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

FDS>>samius считает, что есть разница, но где? Её не видно — и там, и там для одной и той же структуры данных (списка, например) определяются одни и те же кортежи/структуры и информация представлена при объявлении функций точно такая же, как и при объявлении типа структуры.
FDS>>Так где же тогда различие, объявляем мы тип данных как структуру или через лексическое замыкание?

Вряд ли это можно назвать моей точкой зрения.

T>Хорошо, лично я для себя понял точку зрения обоих сторон. А ещё, что вам (обоим) интереснее продолжать спорить, нежели придти к соглашению.

Я уже согласился с тем что FDCS победил, он упрямее.

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

FDS>>Тип функции cons содержит данные о том, что хранится в лексическом замыкании dispatch, именно тип этой функции указывает компилятору что хранится, абсолютно как если бы мы указали определение структуры и операцию new вместо вызова cons

S>Покажи, как тип функции cons содержит данные о том что хранится в замыкании dispatch.
S>Напомню, ты привел следующий тип: object*object -> object

object*object есть кортеж, передаваемый в функцию cons как аргумент, определение этого кортежа и есть определение типа того, что хранится в замыканиии dispatch.

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

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

S>>На бис: и как это отражено в object * object -> object?

FDS>Что именно отражено? В этом сообщении http://rsdn.ru/forum/philosophy/3665604.1.aspx я отписался, как это делается на примере кода.
FDS>В частности, object * object -> object никакого отношения к хранению в файле не имеет

Там сигнатура object -> object, т.к. ты в замыкании будешь хранить лишь имя файла — так это там и отражается

Где отражается то что в замыкании хранится имя файла?

Здравствуйте, samius, Вы писали:
S>10 Dim IntValue = 0
S>20 IntValue = "хаха!"
Я этого языка не знаю и не знаю, о чем должен говорить этот пример кода, но в любом случае найдется язык с отличным поведением.

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

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

S>>Вот об этом я и писал, нконец-то до тебя дошло. Не прошло и двухсот постов...

FDS>Ты писал не об этом. Ты как раз писал о том, что есть разница между определением через функцию и определением через тип. Спорю как раз о том, что разницы нет.

Я допускаю что она для тебя не очевидна

S>>Определение? Я утверждал про тип, а не про определение.

FDS>Определение говорит, что данные хранятся в памяти, а тип говорит какие именно данные, так же как оператор new говорит, что нечто будет хранится в памяти, в то время как определение типа говорит, что именно будет хранится. Мне за тебя каждый мелочный логический вывод делать? Ты вообще думать сам будешь или нет? Или ты идиот и думать сам не способен?

Покажи как тип говорит какие данные будут храниться в памяти.

FDS>Где же разница между определением типа данных через struct или через замыкание?

Попробуй унаследоваться от замыкания для начала

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

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

FDS>>>Тип функции cons содержит данные о том, что хранится в лексическом замыкании dispatch, именно тип этой функции указывает компилятору что хранится, абсолютно как если бы мы указали определение структуры и операцию new вместо вызова cons

S>>Покажи, как тип функции cons содержит данные о том что хранится в замыкании dispatch.
S>>Напомню, ты привел следующий тип: object*object -> object

FDS>object*object есть кортеж, передаваемый в функцию cons как аргумент, определение этого кортежа и есть определение типа того, что хранится в замыканиии dispatch.

т.е. ты уверен в том, что в замыкании dispatch не может храниться хэндл файла, или даже ВООБЩЕ НИЧЕГО?

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

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

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

S>>>На бис: и как это отражено в object * object -> object?

FDS>>Что именно отражено? В этом сообщении http://rsdn.ru/forum/philosophy/3665604.1.aspx я отписался, как это делается на примере кода.
FDS>>В частности, object * object -> object никакого отношения к хранению в файле не имеет

Там сигнатура object -> object, т.к. ты в замыкании будешь хранить лишь имя файла — так это там и отражается

S>Где отражается то что в замыкании хранится имя файла?

А где это отражается в структуре

struct cons
{
  property a {...};
  property b {...};

  private object fileName;
}

?
Лень внимательно прочитать сообщения?

Уже писал, это

(define (cons fileName) ...)

struct cons
{
  ...

  private object fileName;
}

декларирует один и тот же кортеж object — больше ничего. Файл там или нет — никто не знает. Может быть свойство a = fileName / 2, а b = fileName * 2
Обе декларации указывают на тип object как на тип храненимых данных: в одном случае прямо как тип, в другом случае через тип аргумента функции, в которой определяется замыкание

Другие два типа декларируют кортежи object*object, которые так же указывают на то, что хранится в памяти два некоторых объекта, может быть, два имени файла — отдельно для a и отдельно для b. Тип объектов и там, и там неопределён: может быть целое, а может быть — строка.

Здравствуйте, Mr.Cat, Вы писали:

MC>Здравствуйте, samius, Вы писали:
S>>10 Dim IntValue = 0
S>>20 IntValue = "хаха!"
MC>Я этого языка не знаю и не знаю, о чем должен говорить этот пример кода
Я тоже его не знаю, но говорит пример о том, что типизация есть, а наименования могут не соответствовать.

MC>но в любом случае найдется язык с отличным поведением.
Согласен.

Здравствуйте, samius, Вы писали:
MC>>Я этого языка не знаю и не знаю, о чем должен говорить этот пример кода
S>Я тоже его не знаю, но говорит пример о том, что типизация есть, а наименования могут не соответствовать.
Ну я примерно про то же. Типизация наименований может оказаться ортогональна типизации объектов (значений).

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

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

FDS>>>samius считает, что есть разница, но где? Её не видно — и там, и там для одной и той же структуры данных (списка, например) определяются одни и те же кортежи/структуры и информация представлена при объявлении функций точно такая же, как и при объявлении типа структуры.
FDS>>>Так где же тогда различие, объявляем мы тип данных как структуру или через лексическое замыкание?

S>Вряд ли это можно назвать моей точкой зрения.

Да ну? Что же тогда твоя точка зрения? Ты утверждал, что различие есть, оно какое-то другое, нежели то, о котором я говорю?

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

FDS>>object*object есть кортеж, передаваемый в функцию cons как аргумент, определение этого кортежа и есть определение типа того, что хранится в замыканиии dispatch.

S>т.е. ты уверен в том, что в замыкании dispatch не может храниться хэндл файла, или даже ВООБЩЕ НИЧЕГО?

Где я такое написал?

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

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

FDS>>>object*object есть кортеж, передаваемый в функцию cons как аргумент, определение этого кортежа и есть определение типа того, что хранится в замыканиии dispatch.

S>>т.е. ты уверен в том, что в замыкании dispatch не может храниться хэндл файла, или даже ВООБЩЕ НИЧЕГО?

FDS>Где я такое написал?
Такое ты не писал, но из выделенного следует что в замыкании dispatch не может храниться ничего кроме кортежа, переданного в cons.

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

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

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

FDS>>>>samius считает, что есть разница, но где? Её не видно — и там, и там для одной и той же структуры данных (списка, например) определяются одни и те же кортежи/структуры и информация представлена при объявлении функций точно такая же, как и при объявлении типа структуры.
FDS>>>>Так где же тогда различие, объявляем мы тип данных как структуру или через лексическое замыкание?

S>>Вряд ли это можно назвать моей точкой зрения.

FDS>Да ну? Что же тогда твоя точка зрения? Ты утверждал, что различие есть, оно какое-то другое, нежели то, о котором я говорю?

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

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

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

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

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

S>>>>На бис: и как это отражено в object * object -> object?

FDS>>>Что именно отражено? В этом сообщении http://rsdn.ru/forum/philosophy/3665604.1.aspx я отписался, как это делается на примере кода.
FDS>>>В частности, object * object -> object никакого отношения к хранению в файле не имеет

Там сигнатура object -> object, т.к. ты в замыкании будешь хранить лишь имя файла — так это там и отражается

S>>Где отражается то что в замыкании хранится имя файла?

FDS>А где это отражается в структуре

Стуктура не имеет отношения к типу cons. Мой cons возвращает процедуру

FDS>Лень внимательно прочитать сообщения?

FDS>Уже писал, это
FDS>

FDS>(define (cons fileName) ...)
FDS>

FDS>и
FDS>

FDS>struct cons
FDS>{
FDS>  ...

FDS>  private object fileName;
FDS>}
FDS>

FDS>декларирует один и тот же кортеж object — больше ничего. Файл там или нет — никто не знает. Может быть свойство a = fileName / 2, а b = fileName * 2
FDS>Обе декларации указывают на тип object как на тип храненимых данных: в одном случае прямо как тип, в другом случае через тип аргумента функции, в которой определяется замыкание

FDS>Другие два типа декларируют кортежи object*object, которые так же указывают на то, что хранится в памяти два некоторых объекта, может быть, два имени файла — отдельно для a и отдельно для b. Тип объектов и там, и там неопределён: может быть целое, а может быть — строка.

Я их прочитал внимательно. И пожалел об этом.

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

FDS>Главное, что мы выяснили: система типов позволяет организованно определять группы методов и полей, чем существенно облегчает работу программисту, т.к. иначе для кадого объекта программист вынужден был бы при создании этого объекта определять весь набор методов и полей объекта вручную.

Речь об ОО-типах?

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

S>Покажи как тип говорит какие данные будут храниться в памяти.

При создании лексического замыкания сохраняются все контексты, а значит аргументы, а значит будет сохранён кортеж object * object (кортеж, который мы в качестве примера используем как аргумент функции cons, составляющую контекст лексического замыкания)

FDS>>Где же разница между определением типа данных через struct или через замыкание?

S>Попробуй унаследоваться от замыкания для начала

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

Что касается наследования "попробовать", то завсегда пожалуйста

(define (cons1 x y) 
    (define (getpair m)
      (cond
        ((= m 0) x)
        ((= m 1) y)
      )
  getpair
)

(define (cons2 xy z)
    (define (getThree m)
       (cond
         ((< m 2) (xy m))
         ((= m 2) z)
    )
    getThree
)

(define (cons3 x y z) (cons2 (cons1 x y) z))

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

S>>>Где отражается то что в замыкании хранится имя файла?

FDS>>А где это отражается в структуре

S>Стуктура не имеет отношения к типу cons. Мой cons возвращает процедуру

Мы говорим о различии между определениями типов-структур и типов-функций. Поэтому необходимо провести различие

FDS>>Уже писал, это
FDS>>

FDS>>(define (cons fileName) ...)
FDS>>

FDS>>и
FDS>>

FDS>>struct cons
FDS>>{
FDS>>  ...

FDS>>  private object fileName;
FDS>>}
FDS>>

FDS>>декларирует один и тот же кортеж object — больше ничего. Файл там или нет — никто не знает. Может быть свойство a = fileName / 2, а b = fileName * 2
FDS>>Обе декларации указывают на тип object как на тип храненимых данных: в одном случае прямо как тип, в другом случае через тип аргумента функции, в которой определяется замыкание

FDS>>Другие два типа декларируют кортежи object*object, которые так же указывают на то, что хранится в памяти два некоторых объекта, может быть, два имени файла — отдельно для a и отдельно для b. Тип объектов и там, и там неопределён: может быть целое, а может быть — строка.

S>Я их прочитал внимательно. И пожалел об этом.

Что дальше?

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

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

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

FDS>>>>object*object есть кортеж, передаваемый в функцию cons как аргумент, определение этого кортежа и есть определение типа того, что хранится в замыканиии dispatch.

S>>>т.е. ты уверен в том, что в замыкании dispatch не может храниться хэндл файла, или даже ВООБЩЕ НИЧЕГО?

FDS>>Где я такое написал?
S>Такое ты не писал, но из выделенного следует что в замыкании dispatch не может храниться ничего кроме кортежа, переданного в cons.

Это так и есть, если определение dispatch такое. Вот только в кортеж ты можешь запихнуть всё что угодно, так же как и в структуру с двумя полями object

Если же ты тип процедуры cons изменишь на object -> object, то сможешь передать только имя файла — т.е. структуру из одного поля.

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

S>Я утверждал что есть варианты, кроме как определения типа данных и хранения полей в словаре.

Это не так. Ты говорил, что

Очевидно, что процедура имеет тип, но этот тип ничего не говорит компилятору/интерпретатору о способе хранения данных. Тип процедуры не то же самое, что тип данных, тем не менее процедуры позволяют хранить данные в форме отличном от "словаря переменных".

а вовсе не что "есть варианты, кроме как определение типа данных и хранения полей в словаре". Не надо отступаться от своих слов. Если утверждал — значит утверждал — так на форуме записано.

От:	FDSC	consp11.github.io блог
Дата:	12.01.10 13:17
Оценка:

От:	samius	http://sams-tricks.blogspot.com
Дата:	12.01.10 13:19
Оценка:

От:	FDSC	consp11.github.io блог
Дата:	12.01.10 13:19
Оценка:

От:	samius	http://sams-tricks.blogspot.com
Дата:	12.01.10 13:20
Оценка:

	От:	Mr.Cat
	Дата:	12.01.10 13:22
	Оценка:

От:	lomeo	http://lomeo.livejournal.com/
Дата:	12.01.10 14:04
Оценка: