Мое понимание систем типов корректно?

Может быть, Эта книга может помочь. Будьте готовы к какой-то математике. Если я правильно помню, «нематежную» заявление было: «Набрано набрано: язык, который я чувствую себя в безопасности на программу».

Хм, не знаю гораздо больше, но я хотел упомянуть C ++ и его неявные разговоры (неявные конструкторы). Это может быть, а также пример слабых набрав.

Библиотека Midiutil (размещена здесь в Google Code) делает то, что вы хотите: напишите файлы MIDI из чистой библиотеки Python. Однажды хорошая вещь об этом (и полное раскрытие информации: я автор) заключается в том, что вам не нужно следить за средними событиями нижнего уровня, такими как Note-On и Note-Off: это обрабатывает их для вас.

В качестве примера написать записку, вы сделаете что-то вроде:

MyMIDI = MIDIFile(1)
track = 0
channel = 0
pitch = 60
time = 0
duration = 1
volume = 100
MyMIDI.addNote(track,channel,pitch,time,duration,volume)

Надеюсь, это поможет

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

на языках, таких как TCL и Bourne Shell, тип «главный» тип значения - это строка. Числовые операторы доступны, что неявно пострадают входные значения из строкового представления и значения результатов в строковое представление. Их можно считать примерами динамических, слабо напечатанных языков.

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

Я считаю сильным / слабым, чтобы быть концепцией неявного преобразования, и хороший пример - добавление строки и числа. В сильно набранном языке преобразование не произойдет (по крайней мере, на всех языках, которые я могу подумать), и вы получите ошибку. Слабо напечатанные языки, такие как VB (с вариантом явным выключением), и JavaScript постарается отбрасывать один из операндов на другой тип.

В VB.NET с вариантом строгим выключен:

    Dim A As String = "5"
    Dim B As Integer = 5
    Trace.WriteLine(A + B) 'returns 10

с вариантом строгим (поворота VB в сильно напечатанный язык), вы получите ошибку компилятора.

В JavaScript:

    var A = '5';
    var B = 5;
    alert(A + B);//returns 55

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

Я согласен с другими, кто говорят: «Там, похоже, здесь не будет твердое и быстрое определение». Мой ответ имеет тенденцию основываться на том, насколько веревка на языке дает вам типы WRT. Если вы можете в значительной степени подделать все, что вы хотите, то это слабо. Если это действительно не позволяет вам неприятностей, даже если вы хотите, это сильно.

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

Кажется, что там, по крайней мере, два разных вида слабо набравших языки (или, возможно, континуум):

• в C и ассемблере, значения в основном ведра битов, поэтому все возможно, и если вы получите компилятор на размышления Первые 4 байта ничьей строки, вы лучше надеетесь, что это ведет где-то, что не содержит код юридического аппарата.

Я бы не согласился с этим утверждением, по крайней мере, в C. Вы можете манипулировать системой типа в C таким образом, чтобы вы могли лечить какую-либо данную местоположение памяти как ведро битов, но Переменная , определенно имеет тип, и этот тип имеет определенные свойства. Тот факт, что нет проверки времени выполнения (если вы не рассматриваете исключения с плавающей точкой или неисправности сегментации, чтобы проверки времени выполнения) не являются действительно актуальными. C можно считать «слабо напечатано» в том смысле, что компилятор выполнит некоторое неявное преобразование типа для вас, но он не очень далеко не очень далеко.

Относительно статического и динамического набора текста вы мертвы на деньгах. Статическая типизация означает, что программы проверяются перед выполнением, и программа может быть отклонена перед началом выполнения. Динамическая опечатка означает, что типы значений проверяются во время выполнения, а плохо набранная операция может привести к остановке программы или иным образом сигнализировать об ошибке во время выполнения. Основной причиной статического набора значений является исключение программ, которые могут иметь такие "ошибки динамического типа".

Боб Харпер утверждал, что язык динамически типизированных значений может (и должен) рассматриваться как язык статически типизированных значений с одним типом, который Боб называет "значением". Эта точка зрения справедлива, но она полезна только в ограниченных контекстах, таких как попытка быть точным в теории типов языков.

Хотя я думаю, что Вы понимаете это понятие, Ваши пули не дают понять, что типовой вывод является просто частным случаем статического набора текста . В большинстве языков с типовым выводом аннотации типа являются необязательными, но не обязательно во всех контекстах. (Пример: сигнатуры в ML.) Расширенные системы статических типов часто дают компромисс между аннотациями и умозаключением; например, в Haskell можно вводить полиморфные функции более высокого ранга (forall слева от стрелки), но только с аннотациями. Таким образом, если вы хотите добавить аннотацию, вы можете заставить компилятор принять программу, которая будет отклонена без аннотации. Я думаю, что это волна будущего в типовых выводах.

Идеи "сильного" и "слабого" набора текста я охарактеризовал бы как бесполезные , потому что они не имеют общепринятого технического смысла. Сильная клавиатура обычно означает, что в системе типов нет лазеек, в то время как слабая клавиатура означает, что система типов может быть подорвана (аннулируя любые гарантии). Часто эти термины неправильно используются для обозначения статического и динамического набора. Чтобы увидеть разницу, подумайте о C: язык проверяется на тип во время компиляции (статические типы), но лазеек много; вы можете привести значение любого типа к другому типу того же размера - в частности, вы можете свободно приводить указатели на типы. Паскаль был языком, который предназначался для сильных типов, но, как известно, имел непредвиденную лазейку: разновидность записи без тегов.

Внедрение сильно типизированных языков часто обретает лазейки с течением времени, обычно для того, чтобы часть системы исполнения могла быть реализована в языке высокого уровня. Например, Objective Caml имеет функцию Obj.magic, которая имеет эффект времени исполнения, просто возвращая свой аргумент, но при компиляции преобразует значение любого типа в значение любого другого типа. Мой любимый пример - Modula-3, конструкторы которой назвали свою конструкцию приведения типов LOOPHOLE.

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