безтиповые языки

На самом деле выражается, только я предполагаю, что не совсем так, как думает анонимус. В БМУ именно так и делают (я вот сейчас учусь на втором курсе КПИ, и завтра буду по АЛП и БМУ писать контрольную :)).

Представим себе БМУ. Пусть каждая МК состоит из таких частей:

• b1 — используется при формировании следующей команды
• b2 — сигналы, которые должна выдать исполняющаяся команда
• b3 — задержка (на самом деле нужна только в асинхронных БМУ, но нас она все равно интересовать не будет)
• b4 — бит четности (здесь все понятно)

Реально нас будет интересовать только зона b1. Для реализации условного перехода мы можем использовать такой подход: команды, на которые будет осуществлен переход, размещаются рядом, и у их адресов различаются только последним битом (0 — это место, куда будет осуществлен переход, если условие ложно, 1 — место, куда будет осуществлен переход, если условие истинно). И есть входящие сигналы x1, x2, x3, ..., xn, которые и будут возможными условиями, по которым можно осуществлять переход. Тогда можно все эти x1, x2, x3, ..., xn присоединить к мультиплексору (а мультиплексор, как мы знаем, реализуется на двоичной логике, т.е., применяя элементы and и or), и сделать такой формат зоны b1:

• все биты адреса перехода, кроме последнего
• поле управления мультиплексором (номер входящего сигнала)

И адрес следующей МК — это все биты, кроме последнего, + выход мультиплексора. Вот тебе и ветвления, без никакой магии. Все элементы данного БМУ (мультиплексор, память микрокоманд, регистр микрокоманд, ...) можно реализовать на двоичной логике, при желании применяя только элементы and и or.

А CL по моему, слишком перегружен синтаксисом.

Из синтаксиса там ( и )

Разработай свою архитектуру процессора и реализуй ее на ПЛИС, и будет тебе счастье. По ПЛИС и тому, как работают процессоры, документации и учебников огромная куча. Не смотрел, но вполне возможно, что по этому также есть курсы на coursera и подобных ресурсах.

Вот альтернативная реализация member? - предикат, проверяющий есть ли элемент в списке. Если честно, я нашел свои эксперименты полугодовалой давности и четкого понимания кода у меня сейчас нет, но писал сам, чесслово. (scheme)

 
(define member?
  (let ((state #f))
    (lambda(a lst)
      (and
	(not (null? lst))
	(set! state (car lst))
	(not (eq? a (car lst)))
	(member? a (cdr lst)))
      (eq? a state))))

(write (member? 1 '(2 1 3)))
(write (member? 4 '(2 1 3)))
 

Макросы и специальные формы — это тоже синтаксис.

Угу, учитывая что and внутри чаще всего определяется как макрос

(define-syntax and
  (syntax-rules ()
    ((and) #t)
    ((and expr) expr)
    ((and expr1 expr1 ...)
     (if expr1 (and expr2 ...) #f) ) ) )

Угу, учитывая что and внутри чаще всего определяется как макрос

а какая разница что внутри? Смысл в том что мы имеем полноценный and. К тому же я делал подобные вещи и на js. Убежден, что это возможно на любом языке имеющем and. То же самое и с or.

Макросы и специальные формы — это тоже синтаксис.

Это и есть синтаксис в прямом смысле слова, а не «тоже». Хоть я и нуб, (простите меня за дерзость), но насколько я понимаю, выражение «У лиспа нет синтаксиса» относиться к старым, «ленивым» лиспам, где были функциональные выражения позволяющие не вычислять аргументы. Это оттуда повелось, а сейчас, это просто повторяют как мантру. В современных лиспах этого нет, как нет «code as data» - это другая мантра. Это имхо, конечно, я не профи чтобы утверждать, но это мое понимание вопроса.

Пошел купил ПЛИС и делай шо хочешь

Проще взять МК, документацию на электрику и ядро, книги и статьи по архитектуре таких ядер. Писать программы и смотреть отладчиком/читать книги и понимать происходящее. Для понятия интерфейсных модулей (а у нормальных МК в документации все нарисовано) полезно повторить модуль программно или из рассыпухи собрать, эдакий реверс-инжиниринг. А после всего этого плис, к тому времени голова готова будет

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

Тебе сюда: http://ru.wikipedia.org/wiki/ПЛИС

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

Если надо в железе копаться и экспериментировать со схемой девайса, FPGA для этого и созданы.

слой, который связывает двоичный код и электрические сигналы

Декодер команд, шоле?

Как на нем сделать

while((int c = getchar()) != EOF) {

}

для любого двоичного текста на входе? ;)

Ты прямо таки не понимаешь, о чём говоришь. Есть ленивый and и побитовый #'logand, например. Если на первом ещё можно какое-то ветвление реализовать, то на втором (который может быть аналогичным электронным компонентом) - уж точно нет

Если на первом ещё можно какое-то ветвление реализовать

Не «можно», а он и есть разновидность ветвления.

// другой анон

Я говорил конечно про ленивый.

который может быть аналогичным электронным компонентом

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

Ну а тот аноним имел в виду

http://upload.wikimedia.org/wikipedia/commons/thumb/0/0f/AND_IEC.svg/100px-AN...

Хотя на самом деле сложно сказать, что там имелось в виду.

Я и есть тот самый анононим.

И я именно это и имел в виду, а в чем проблема-то, я не пойму?

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

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

тебе нужно знать значение на обоих входящих проводах

А откуда твоя программа знает значения элементов выразения and? Мне не нужно знать эти значения: электросхема получит их во время работы как и твоя прога в рантайме!

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

Вот тебе пример:

if (and foo bar)->lamp_on
__/ __/ __lamp_on
[\code]
че не похоже?

Даже можно так:

and foo bar ->lamp_on
__/__/__lamp_on

Разница не втом, как это вычисляется, в том, будут ли побочные эффекты, блеать!

Кроме того, некоторые вещи могут вообще быть невычислимы. Бесконечные структуры в кацкеле или хотя бы банальное деление на ноль в Си.

Ленивость возволяет проветвиться мимо таких вычислений. Неленивость - не позволит.

Вообще принципиальная разница в том, что неленивый and есть обычная арифметическая операция, в то время как неленивый — частный случай операции сопоставления с образцом. Они разные на концептуальном уровне, как раз примерно как сова и глобус.

будут ли побочные эффекты

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

Ленивость возволяет проветвиться мимо таких вычислений.

ленивость позволяет их не производить, это разные вещи.

Побочные эффекты не принципиальны? Т.е., например, не принципиально будет выполнен rm -rf /* или нет?

А вычисление длины бесконечного спика тоже не принципиальный момент для завершимости алгортма?

Квантовые компьютеры Шредингера, не иначе. Я хочу такую траву!

Побочные эффекты не принципиальны? Т.е., например, не принципиально будет выполнен rm -rf /* или нет?

Не надо разводить детсад. Речь идет о том что они не выжны если они под контролем. Это уже твоя забота, как ты будешь их контролировать. Однако, еще раз, как это относится к вопросу?

А вычисление длины бесконечного спика тоже не принципиальный момент для завершимости алгортма?

не принципиальный, если он выполняется параллельно.

Он не сможет выполнять параллельно с функцией, в вызове которой его результаты нужны как аргумент.

Ну и что? Причем здесь это?

К тому же это могут быть две нити которые обмениваются сообщениями, и тогда это возможно

facepalm.png

(капча strictest prupee как бы символизирует)

Вообще принципиальная разница в том, что неленивый and есть обычная арифметическая операция, в то время как неленивый — частный случай операции сопоставления с образцом. Они разные на концептуальном уровне, как раз примерно как сова и глобус.

Только сейчас доперло, что ты хотел этим сказать.

Все дело тут в том, что мы всегда как бы имеем 2 объекта, один из них записывает а другой читает. Вот представь себе, что один программный объект (подпрограмма) записала данные в некую структуру: 1 1 - то что ты называешь, причем неправильно, арифметической операцией. А другая прочитала и для нее это означает что нужно передать дальше сигнал. Передала. Если бы первым стоял ноль(что эквивалентно разрыву цепи) сигнал не пошел, в этом ее, как бы, «ленивость». Вот это и есть отображение and оr на электросхему.

Вот это и есть отображение and оr на электросхему.

Пардон, только And.

Ксати, я сейчас подумал, и понял еще одну важную фигню: if-else тоже напрямую отображается на электросхеме - это транзистор.

if-else — это толстый триггер, а один транзистор — это, в лучшем случае — инвертор

Как было написано ранее JavaScript безтиповый. Но в С++ эта проблема решается кастомными типами(классами) которые могут хранить всё что хошь типа QVariant. В boost тоже есть чтото подобное.

Как было написано ранее

Не было это написано ранее. О javascript вообще в этом треде только два упоминания, и оба об одном и том же — некий анонимус его умеет.

JavaScript безтиповый

Неправда. JavaScript — не безтиповый, а динамически типизированный.

shell