Русско-английский словарь, перевод на английский язык

wordmap

Русско-английский словарь — показательная эрудиция

Русско-английский словарь — прерогатива воспользоваться вариативным функционалом, насчитывающим несколько сотен тысяч уникальных английских слов. Чтобы воспользоваться сервисом, потребуется указать предпочтенное слово на русском языке: перевод на английский будет отображен во всплывающем списке.

Русско-английский словарь — автоматизированная система, которая отображает результаты поиска по релевантности. Нужный перевод на английский будет в верхней части списка: альтернативные слова указываются в порядке частоты их применения носителями языка.

Русско-английский словарь содержит строку для поиска, где указывается запрос, а после запускается непосредственный поиск. Система может «предлагать» пользователю примеры по использованию слова: «здравствуйте» на английском языке, «хризантема» на английском языке. Дополнительные опции системы — отображение частей речи (будет выделена соответствующим цветом). В WordMap русско-английский словарь характеризуется наличием функции фильтрации запросов, что позволит «отсеять» ненужные словосочетания.

Применение сервиса и достоинства

Перевод на английский язык с сервисом WordMap — возможность улучшить словарный запас учащегося. Дополнительные преимущества в эксплуатации WordMap:

• Слова с различным значением, которые оптимизированы под любой уровень владения английским языком;
• Русско-английский словарь содержит примеры, позволяющие усовершенствовать практические навыки разговорного английского;
• В списке результатов указаны всевозможные синонимы и паронимы, которые распространены в сложном английском языке.

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

Только что искали:

сцинк 2 секунды назад

в силу состояния здоровья 2 секунды назад

глубина-колодца 4 секунды назад

накладка 5 секунд назад

олегория 5 секунд назад

грабовская-саркисова 7 секунд назад

веющих 8 секунд назад

безлюдная равнина 8 секунд назад

огурцовская 9 секунд назад

дошученному 10 секунд назад

мосток 10 секунд назад

ктуси 14 секунд назад

из чистого интереса 14 секунд назад

мейнвилл 15 секунд назад

зорайб 15 секунд назад

Ваша оценка

Закрыть

Спасибо за вашу оценку!

Закрыть

Имя	Слово	Угадано	Время	Откуда
Игрок 1	своевольница	62 слова	47 минут назад	95. 68.114.220
Игрок 2	шоколад	3 слова	7 часов назад	46.191.192.200
Игрок 3	малознакомое	49 слов	7 часов назад	95.68.114.220
Игрок 4	цемент-пушка	38 слов	9 часов назад	95.68.114.220
Игрок 5	натуральный картофель с ярким вкусом	0 слов	10 часов назад	89.23.156.142
Игрок 6	весна	0 слов	18 часов назад	46.150.23.76
Игрок 7	осень	0 слов	18 часов назад	46.150.23.76
Играть в Слова!

Имя	Слово	Счет	Откуда
Игрок 1	майор	33:34	8 минут назад	176. 59.66.178
Игрок 2	кимвр	50:51	15 минут назад	176.59.66.178
Игрок 3	жевок	49:46	28 минут назад	176.59.66.178
Игрок 4	фильц	47:42	40 минут назад	176.59.66.178
Игрок 5	зачес	49:50	52 минуты назад	176.59.66.178
Игрок 6	рысак	28:29	1 час 56 секунд назад	94.233.236.221
Игрок 7	солея	55:54	1 час назад	176.59.66.178
Играть в Балду!

Имя	Игра	Вопросы	Откуда
Марина	На одного	5 вопросов	2 часа назад	46. 216.179.180
Софа	На одного	20 вопросов	4 часа назад	213.87.133.214
Арина	На одного	10 вопросов	5 часов назад	85.140.1.126
Арина	На одного	10 вопросов	5 часов назад	85.140.1.126
Арина	На одного	10 вопросов	5 часов назад	85.140.1.126
Рената	На одного	20 вопросов	6 часов назад	85.140.6.143
Ввч	На одного	10 вопросов	18 часов назад	188.170.72.6
Играть в Чепуху!

Семантический анализ

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

Мир и слушатель

Буквальный слушатель просто делает вывод о вероятных мирах, предполагая, что значение истинно в мире:

 var literalListener = function(utterance) {
  Вывод({
    модель () {
      вар мир = мирPrior()
      var m = значение (высказывание, мир)
      фактор(m?0:-Бесконечность)
      вернуть мир
    }
  })
}
 

Мир представляет собой несколько именованных объектов со случайными (бинарными) свойствами:

 var makeObj = function(name) {
  вернуть {имя: имя, блондин: флип (0,5), приятный: флип (0,5)}
}
var worldPrior = функция (объекты) {
  return [makeObj("Боб"), makeObj("Билл"), makeObj("Алиса")]
}
 

Синтаксический анализатор

Обратите внимание, что мы записали функцию , означающую , как принимающую высказывание и мир и возвращающую (теоретико-модельное) обозначение — значение истинности, когда высказывание является предложением. Мотивация действовать таким образом, а не разбивать его на смысловую функцию, которая строит форму «LF», которая затем отдельно применяется к миру, хорошо описана во введении к Якобсону (19). 99):

Отправной точкой данной статьи является гипотеза «прямой композиционности». (см., например, Montague 1974): синтаксис и теоретико-модельная семантика работают в тандем. Таким образом, синтаксис «строит» (т. е. доказывает правильность) выражений, где каждое синтаксическое правило доказывает правильность построения выходное выражение с точки зрения правильности одного или нескольких входных выражения. (Конечно, эти правила можно было бы изложить в весьма общем и схематические термины, как, например, в категориальной грамматике.) Семантика работает в тандеме при этом — каждому выходному выражению непосредственно присваивается значение (теоретико-модельный интерпретация) с точки зрения значения (значений) входных выражений (выражений). Таким образом, нет необходимости в каком-либо абстрактном уровне, таком как LF, посредник между поверхностью синтаксис и теоретико-модельная интерпретация, и, следовательно, нет необходимости в дополнительных набор правил, отображающих один «уровень» синтаксического представления в другой.

Для нашей системы функция , означающая , представляет собой стохастическую карту от высказываний до значений истинности, с разными возвращаемыми значениями, соответствующими (не однозначно) разным анализам или лексическим выборам.

Сначала мы получаем лексическое значение для каждого слова и отфильтровываем неопределенные значения, затем рекурсивно применяем фрагменты значения друг к другу, пока не останется только один фрагмент значения.

 // Разделить строку на слова, найти лексические значения,
// удаляем слова со бессмысленным значением, затем вызываем combMeanings..
var значение = функция (высказывание, мир) {
  вернуть комбинированные значения(
    фильтр(карта(высказывание.split(" "),
               функция (w) {возврат лексического значения (w, мир)}),
           функция (m) {возврат! (m.sem == undefined)}))
}
 

Лексикон захвачен функцией lexicalMeaning , которая ищет значение слова. Значение — это объект с семантикой и синтаксисом.

 var lexicalMeaning = функция (слово, мир) {
  var wordMeanings = {
    "блондин" : {
      sem: функция (obj) {возврат obj.blond},
      syn: {режим: 'L', интервал: 'NP', выход: 'S'} },
    "хороший" : {
      sem: функция (obj) {return obj.nice},
      syn: {режим: 'L', интервал: 'NP', выход: 'S'} },
    "Боб": {
      sem: найти (функция (obj) {return obj.name = = "Боб"}, мир),
      син: 'НП'},
    "некоторый" : {
      sem: функция (P) {
        функция возврата (Q) {фильтр возврата (Q, фильтр (P, мир)). длина> 0}},
      син: {реж.: 'R',
            интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
            вне: {режим: 'R',
                 интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
                 выход: 'S'}} },
    "все" : {
      sem: функция (P) {
        функция возврата (Q) {фильтр возврата (отрицательный (Q), фильтр (P, мир)). длина == 0}},
      син: {реж.: 'R',
            интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
            вне: {режим: 'R',
                 интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
                 выход:'S'}} }
  }
  значение var = словоЗначения[слово];
  возвращаемое значение == undefined?{sem: undefined, syn: ''}:meaning;
}
// Мы используем эту вспомогательную функцию, чтобы отменить указанный выше предикат:
переменная отрицательная = функция (Q) {
  функция возврата (х) {возврат! Q (х)}
}
 

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

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

 var combMeaning = функция (значения) {
  var возможныхComb = canApply (значения, 0)
  дисплей (возможен гребень)
  var i = возможная гребенка [randomInteger (возможная гребенка. длина)]
  var s = значения[i].syn
  если (s.dir == 'L') {
    var f = значения[i].sem
    var a = значения[i-1].sem
    var newmeaning = {sem: f(a), syn: s.out}
    вернуть значения.slice(0,i-1).concat([новое значение]).concat(значения.slice(i+1))
  }
  если (s.dir == 'R') {
    var f = значения[i].sem
    var a = значения[i+1].sem
    var newmeaning = {sem: f(a), syn: s.out}
    вернуть значения. slice(0,i).concat([новое значение]).concat(значения.slice(i+2))
  }
}
//составляем список индексов, которые могут (синтаксически) применяться.
var canApply = функция (значения, я) {
  если(я==значения.длина){
    возвращаться []
  }
  var s = значения[i].syn
  if (s.hasOwnProperty('dir')){ //функтор
    var a = ((s.dir == 'L')?syntaxMatch(s.int, values[i-1].syn):false) |
            ((s.dir == 'R')?syntaxMatch(s.int, values[i+1].syn):false)
    если (а) {возврат [i].concat (canApply (значения, я + 1))}
  }
  return canApply(значения,i+1)
}
// Функция синтаксисаMatch представляет собой простую рекурсию к
// проверяем, равны ли два синтаксических типа.
var синтаксическое соответствие = функция (s, t) {
  вернуть !s.hasOwnProperty('dir') ? с==т :
  s.dir==t.dir и синтаксическое соответствие (s.int, t.int) и синтаксическое соответствие (s.out, t.out)
}
// Рекурсивно делаем вышеописанное до тех пор, пока не будет найдено только одно значение
// влево, возвращаем его семантику.
var combMeanings = функция (значения) {
  вернуть значения. length==1 ? значения[0].sem : объединитьзначения(объединитьзначения(значения))
}
 

Чтобы обеспечить причудливое перемещение и привязку, мы смешали бы это с операторами изменения типа, следуя, например, Barker (2002) (который расширяет Jacobson, 1999).

 ///свернуть:
var literalListener = функция (высказывание) {
  вернуть вывод({
    модель () {
      вар мир = мирPrior()
      var m = значение (высказывание, мир)
      фактор(m?0:-Бесконечность)
      вернуть мир
    }
  })
}
var makeObj = функция (имя) {
  вернуть {имя: имя, блондин: флип (0,5), приятный: флип (0,5)}
}
var worldPrior = функция (объекты) {
  return [makeObj("Боб"), makeObj("Билл"), makeObj("Алиса")]
}
// Разделяем строку на слова, ищем лексические значения,
// удаляем слова со бессмысленным значением, затем вызываем combMeanings..
var значение = функция (высказывание, мир) {
  вернуть комбинированные значения(
    фильтр (функция (m) {возврат! (m.sem == undefined)},
           карта (функция (w) {return lexicalMeaning (w, мир)},
               высказывание. split(" "))))
}
var lexicalMeaning = функция (слово, мир) {
  var wordMeanings = {
    "блондин" : {
      sem: функция (obj) {возврат obj.blond},
      syn: {режим: 'L', интервал: 'NP', выход: 'S'} },
    "хороший" : {
      sem: функция (obj) {return obj.nice},
      syn: {режим: 'L', интервал: 'NP', выход: 'S'} },
    "Боб": {
      sem: найти (функция (obj) {return obj.name = = "Боб"}, мир),
      син: 'НП'},
    "некоторый" : {
      sem: функция (P) {
        функция возврата (Q) {фильтр возврата (Q, фильтр (P, мир)). длина> 0}},
      син: {реж.: 'R',
            интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
            вне: {режим: 'R',
                 интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
                 выход: 'S'}} },
    "все" : {
      sem: функция (P) {
        функция возврата (Q) {фильтр возврата (отрицательный (Q), фильтр (P, мир)). длина == 0}},
      син: {реж.: 'R',
            интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
            вне: {режим: 'R',
                 интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
                 выход:'S'}} }
  }
  значение var = словоЗначения[слово];
  возвращаемое значение == undefined?{sem: undefined, syn: ''}:meaning;
}
// Мы используем эту вспомогательную функцию, чтобы отменить указанный выше предикат:
переменная отрицательная = функция (Q) {
  функция возврата (х) {возврат! Q (х)}
}
var combMeaning = функция (значения) {
  var возможныхComb = canApply (значения, 0)
  дисплей (возможен гребень)
  var i = возможная гребенка [randomInteger (возможная гребенка.  длина)]
  var s = значения[i].syn
  если (s.dir == 'L') {
    var f = значения[i].sem
    var a = значения[i-1].sem
    var newmeaning = {sem: f(a), syn: s.out}
    вернуть значения.slice(0,i-1).concat([новое значение]).concat(значения.slice(i+1))
  }
  если (s.dir == 'R') {
    var f = значения[i].sem
    var a = значения[i+1].sem
    var newmeaning = {sem: f(a), syn: s.out}
    вернуть значения.slice(0,i).concat([новое значение]).concat(значения.slice(i+2))
  }
}
//составляем список индексов, которые могут (синтаксически) применяться.
var canApply = функция (значения, я) {
  если(я==значения.длина){
    возвращаться []
  }
  var s = значения[i].syn
  if (s.hasOwnProperty('dir')){ //функтор
    var a = ((s.dir == 'L')?syntaxMatch(s.int, values[i-1].syn):false) |
        ((s.dir == 'R')?syntaxMatch(s.int, values[i+1].syn):false)
    если (а) {возврат [i].concat (canApply (значения, я + 1))}
  }
  return canApply(значения,i+1)
}
// Функция синтаксисаMatch представляет собой простую рекурсию к
// проверяем, равны ли два синтаксических типа. 
var синтаксическое соответствие = функция (s, t) {
  вернуть !s.hasOwnProperty('dir') ? с==т :
  s.dir==t.dir и синтаксическое соответствие (s.int, t.int) и синтаксическое соответствие (s.out, t.out)
}
// Рекурсивно делаем вышеописанное до тех пор, пока не будет найдено только одно значение
// влево, возвращаем его семантику.
var combMeanings = функция (значения) {
  вернуть значения.length==1 ? значения[0].sem : объединитьзначения(объединитьзначения(значения))
}
///
//literalListener("Боб хороший")
//literalListener("некоторые блондины хороши")
//literalListener("некоторые блондины милые")
а именно.table (literalListener («все блондины хорошие»))
 

Инкрементное построение мира

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

Задействованы два изменения. Сначала мы адаптируем worldPrior , чтобы разрешить коэффициенты отмены. Во-вторых, эта версия строит функцию от мира к истинностному значению, которую затем можно использовать несколько раз, пока строится мир. То есть мы отходим от непосредственной композиционности, в построении «отложенных» денотатов, которые ждут мира.

Сначала немного модифицированный literalListener и модель мира, без дополнительных факторов, чтобы увидеть, что сгенерированный мир не априори зависит от значения. Мир Prior рекурсивно добавляет объекты в мир:

 var literalListener = function(utterance) {
  вернуть вывод({
    модель () {
      var m = значение (высказывание)
      var world = worldPrior(3,m)
      фактор(м(мир)?0:-Бесконечность)
      вернуть мир
    }
  })
}
вар makeObj = функция () {
  return {блондин: флип (0,5), приятный: флип (0,5), высокий: флип (0,5)}
}
var worldPrior = function(nObjLeft, значениеFn, worldSoFar) {
  вар worldSoFar = worldSoFar==undefined ? [] : мирSoFar
  если(nObjLeft==0) {
    вернуть мирSoFar
  } еще {
    переменная newObj = makeObj()
    var newWorld = worldSoFar. concat([newObj])
    return worldPrior(nObjLeft-1, что означает Fn, newWorld)
  }
}
 

Теперь мы можем добавить отменяющие пары:

 var worldPrior = function(nObjLeft, meanFn, worldSoFar) {
  вар worldSoFar = worldSoFar==undefined ? [] : мирSoFar
  если(nObjLeft==0) {
    вернуть мирSoFar
  } еще {
    переменная newObj = makeObj()
    var newWorld = worldSoFar.concat([newObj])
    var newFactor = значениеFn(newWorld)?0:-100
    фактор(новыйфактор)
    фактор(-новыйфактор)
    return worldPrior(nObjLeft-1, что означает Fn, newWorld)
  }
}
 

И, наконец, продвиньте второй фактор вперед в следующую рекурсию (где он будет называться prevFactor ):

 var worldPrior = function(nObjLeft, значениеFn, worldSoFar, prevFactor) {
  вар worldSoFar = worldSoFar==undefined ? [] : мирSoFar
  var prevFactor = prevFactor==undefined ? 0 : предыдущий фактор
  если(nObjLeft==0) {
    фактор(-предыдущий фактор)
    вернуть мирSoFar
  } еще {
    переменная newObj = makeObj()
    var newWorld = worldSoFar. concat([newObj])
    var newFactor = значениеFn(newWorld)?0:-100
    фактор (новый фактор - предыдущий фактор)
    return worldPrior(nObjLeft-1, означаетFn, newWorld, newFactor)
  }
}
 

Теперь мы «поощряем» мир, который мы строим, чтобы он был таким, чтобы значение было истинным на каждом этапе, но требуем, чтобы оно было истинным только в конце literalListener (и это также единственный фактор, который t отменен в конце).

Остальная часть модели аналогична приведенной выше, но с отсроченными обозначениями в качестве семантических значений:

 var смысл = функция (высказывание) {
  вернуть комбинированные значения(
    фильтр (функция (m) {возврат! (m.sem == undefined)},
карта (функция (w) {возврат лексического значения (w)},
высказывание.split(" "))))
}
var lexicalMeaning = функция (слово) {
  var wordMeanings = {
    "блондин" : {
      sem: функция (мир) {возвратная функция (obj) {возврат obj.blond}},
      syn: {режим: 'L', интервал: 'NP', выход: 'S'} },
    "хороший" : {
      sem: функция (мир) {возвратная функция (объект) {возврат объекта.  хороший}},
      syn: {режим: 'L', интервал: 'NP', выход: 'S'} },
    "Боб": {
    sem: функция (мир) {возврат найти (функция (объект) {возврат obj.name = = "Боб"}, мир)},
      син: 'НП'},
    "некоторый" : {
      sem: функция (мир) {возвратная функция (P) {возвратная функция (Q) {возвратный фильтр (Q, фильтр (P, мир)). длина> 0}}},
      син: {реж.: 'R',
            интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
            вне: {режим: 'R',
                 интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
                 выход: 'S'}} },
    "все" : {
      sem: функция (мир) {возвратная функция (P) {возвратная функция (Q) {возвратный фильтр (отрицательный (Q), фильтр (P, мир)). длина == 0}}},
      син: {реж.: 'R',
            интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
            вне: {режим: 'R',
                 интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
                 выход:'S'}} }
  }
  значение var = словоЗначения[слово];
  возвращаемое значение == undefined?{sem: undefined, syn: ''}:meaning;
}
// Мы используем эту вспомогательную функцию, чтобы отменить указанный выше предикат:
переменная отрицательная = функция (Q) {
  функция возврата (х) {возврат! Q (х)}
}
//предполагаем, что и f, и a дадут свое фактическое семантическое значение после применения к миру.  придать новое значение, которое передается мировому аргументу.
вар applyWorldPassing = функция (f, a) {
  функция возврата (ш) {возврат е (ш) (а (ш))}
}
var combMeaning = функция (значения) {
  var возможныхComb = canApply (значения, 0)
  var i = возможная гребенка [randomInteger (возможная гребенка. длина)]
  var s = значения[i].syn
  если (s.dir == 'L') {
    var f = значения[i].sem
    var a = значения[i-1].sem
    var newmeaning = {sem: applyWorldPassing(f,a), syn: s.out}
    вернуть значения.slice(0,i-1).concat([новое значение]).concat(значения.slice(i+1))
  }
  если (s.dir == 'R') {
    var f = значения[i].sem
    var a = значения[i+1].sem
    var newmeaning = {sem: applyWorldPassing(f,a), syn: s.out}
    вернуть значения.slice(0,i).concat([новое значение]).concat(значения.slice(i+2))
  }
}
//составляем список индексов, которые могут (синтаксически) применяться.
var canApply = функция (значения, я) {
  если(я==значения.длина){
    возвращаться []
  }
  var s = значения[i].syn
  if (s. hasOwnProperty('dir')){ //функтор
    var a = ((s.dir == 'L')?syntaxMatch(s.int, values[i-1].syn):false) |
            ((s.dir == 'R')?syntaxMatch(s.int, values[i+1].syn):false)
    если (а) {возврат [i].concat (canApply (значения, я + 1))}
  }
  return canApply(значения,i+1)
}
// Функция синтаксисаMatch представляет собой простую рекурсию к
// проверяем, равны ли два синтаксических типа.
var синтаксическое соответствие = функция (s, t) {
  вернуть !s.hasOwnProperty('dir') ? с==т :
  s.dir==t.dir и синтаксическое соответствие (s.int, t.int) и синтаксическое соответствие (s.out, t.out)
}
// Рекурсивно делаем вышеописанное до тех пор, пока не будет найдено только одно значение
// влево, возвращаем его семантику.
var combMeanings = функция (значения) {
  вернуть значения.length==1 ? значения[0].sem : объединитьзначения(объединитьзначения(значения))
}
 

 ///свернуть:
var literalListener = функция (высказывание) {
 Вывод({
 модель () {
 var m = значение (высказывание)
 var world = worldPrior(3,m)
 фактор(м(мир)?0:-Бесконечность)
 вернуть мир
 }
 })
}
вар makeObj = функция () {
 return {блондин: флип (0,5), приятный: флип (0,5), высокий: флип (0,5)}
}
var worldPrior = function(nObjLeft, значениеFn, worldSoFar, prevFactor) {
 вар worldSoFar = worldSoFar==undefined ? [] : мирSoFar
 var prevFactor = prevFactor==undefined ? 0 : предыдущий фактор
 если(nObjLeft==0) {
 фактор(-предыдущий фактор)
 вернуть мирSoFar
 } еще {
 переменная newObj = makeObj()
 var newWorld = worldSoFar. concat([newObj])
 var newFactor = значениеFn(newWorld)?0:-100
 фактор (новый фактор - предыдущий фактор)
 return worldPrior(nObjLeft-1, означаетFn, newWorld, newFactor)
 }
}
значение var = функция (высказывание) {
 вернуть комбинированные значения(
 фильтр (функция (m) {возврат! (m.sem == undefined)},
 карта (функция (w) {возврат лексического значения (w)},
 высказывание.split(" "))))
}
var lexicalMeaning = функция (слово) {
 var wordMeanings = {
 "блондин" : {
 sem: функция (мир) {возвратная функция (obj) {возврат obj.blond}},
 syn: {режим: 'L', интервал: 'NP', выход: 'S'} },
 "хороший" : {
 sem: функция (мир) {возвратная функция (объект) {возврат объекта. хороший}},
 syn: {режим: 'L', интервал: 'NP', выход: 'S'} },
 "Боб": {
 sem: функция (мир) {возврат найти (функция (объект) {возврат obj.name = = "Боб"}, мир)},
 син: 'НП'},
 "некоторый" : {
 sem: функция (мир) {возвратная функция (P) {возвратная функция (Q) {возвратный фильтр (Q, фильтр (P, мир)). длина> 0}}},
 син: {реж.: 'R',
 интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
 вне: {режим: 'R',
 интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
 выход: 'S'}} },
 "все" : {
 sem: функция (мир) {возвратная функция (P) {возвратная функция (Q) {возвратный фильтр (отрицательный (Q), фильтр (P, мир)). длина == 0}}},
 син: {реж.: 'R',
 интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
 вне: {режим: 'R',
 интервал: {режим: 'L', интервал: 'NP', выход: 'S'},
 выход:'S'}} }
 }
 значение var = словоЗначения[слово];
 возвращаемое значение == undefined?{sem: undefined, syn: ''}:meaning;
}
// Мы используем эту вспомогательную функцию, чтобы отменить указанный выше предикат:
переменная отрицательная = функция (Q) {
 функция возврата (х) {возврат! Q (х)}
}
//предполагаем, что и f, и a дадут свое фактическое семантическое значение после применения к миру. придать новое значение, которое передается мировому аргументу. вар applyWorldPassing = функция (f, a) {
 функция возврата (ш) {возврат е (ш) (а (ш))}
}
var combMeaning = функция (значения) {
 var возможныхComb = canApply (значения, 0)
 var i = возможная гребенка [randomInteger (возможная гребенка. длина)]
 var s = значения[i].syn
 если (s.dir == 'L') {
 var f = значения[i].sem
 var a = значения[i-1].sem
 var newmeaning = {sem: applyWorldPassing(f,a), syn: s.out}
 вернуть значения.slice(0,i-1).concat([новое значение]).concat(значения.slice(i+1))
 }
 если (s.dir == 'R') {
 var f = значения[i].sem
 var a = значения[i+1].sem
 var newmeaning = {sem: applyWorldPassing(f,a), syn: s.out}
 вернуть значения.slice(0,i).concat([новое значение]).concat(значения.slice(i+2))
 }
}
//составляем список индексов, которые могут (синтаксически) применяться.
var canApply = функция (значения, я) {
 если(я==значения.длина){
 возвращаться []
 }
 var s = значения[i].syn
 if (s.hasOwnProperty('dir')){ //функтор
 var a = ((s.dir == 'L')?syntaxMatch(s.