В место такого кода

&НаКлиенте
Процедура ПередЗакрытием(Отказ, СтандартнаяОбработка)
    ОписаниеОповещения = Новый ОписаниеОповещения("ОбработатьОтвет", ЭтотОбъект);
    ПоказатьВопрос(ОписаниеОповещения, "Завершить работу системы?",РежимДиалогаВопрос.ДаНет, 60);
    Отказ = Истина;
    
КонецПроцедуры

&НаКлиенте
Процедура ОбработатьОтвет(РезультатВопроса, ДополнительныеПараметры) Экспорт
    
    Если РезультатВопроса <> КодВозвратаДиалога.Нет Тогда
        ЗавершитьРаботуСистемы(Ложь);
        Закрыть();
    КонецЕсли;
    

КонецПроцедуры


Писать более простой

&НаКлиенте
Процедура ПередЗакрытием(Отказ, СтандартнаяОбработка)
    ОписаниеОповещения = Новый ОписаниеОповещения("ОбработатьОтвет", ЭтотОбъект);
    ПоказатьВопрос((РезультатВопроса, ДополнительныеПараметры) => (Если РезультатВопроса <> КодВозвратаДиалога.Нет Тогда
        ЗавершитьРаботуСистемы(Ложь);
        Закрыть();
    КонецЕсли;) , "Завершить работу системы?",РежимДиалогаВопрос.ДаНет, 60);
    Отказ = Истина;
    
КонецПроцедуры

Тупые 1сники ещё УФ-то не освоили, а ты им функциональщину предлагаешь...
Людей пожалей...

(1) функиональщину я не предлагаю.
Просто если ввели оповещения, то желательно для них ввести короткую запись.

(0) мне лично ни то ни другое не нравится

первое - костыли
второе - читать не привычно

(0) ээээ... а функция Вопрос()  ?

(2) Замыкания - это самая настоящая функциональщина.

(0) http://tsya.ru/

(5) а 1с это обычные формы.

Я не предлагаю вводить функциональные типы и т д
просто синтаксис похожий на функциональный

(7) Ты предложил анонимные функции

(8) да

(5)+1 да это типичная функциональщина...

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

(10)
1. более просто читаема, тут вопрос вкуса. Создавать ссылки на функции и т д я не предлагаю
2. вариант применять, только когда функция встречается 1 раз. в среде предусмотреть как перевод в аноннимную функцию, так и обратно
3. она так и будет обрабатывать без остановки, функциональность кода не изменилась.

(11) поставь точку остановки отладчика в анонимную функцию

(0) Какое-то кривое и непонятное предложение. Что оно дает?

(12) в чем разница в постановке точки останова на обычную функцию?

(13) упрощение кода

Ну кабы вроде как то же самое можно обработкой выбора реализовать

опять ться?

(12) в том, что для меня логично когда точка входа в процедуру легко определима....

(15) ты хочешь как на лиспе? я писал для автокада, уверяю что это ад кромешный.

Если 1с введет такое - я буду просить 500тр в неделю, по тому как 80% 1с ников свалят из профессии

это как в си шарп шоле

прежде ООП появится

Полагаю есть причины не делать функцию доступной. Т.е. 1с становится кроссплатформенным приложением и на разных платформах пауза по разному воспринимается, много косяков всплывет.
Ну и ожидания для отладки не оч хороший инструмент. В других языках по моему можно многопоточность использовать, пока пауза выполнять какие то другие процессы.

(0)
Пряма праблема #1 в нисчастнай 1С!

(15) Где ж там упрощение-то? Читабельность отвратительная.

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

Замыкания позволяют обратиться из анонимной функции к внешнему контексту (по отношению к самой функции).

Иногда это просто очень пользительно.

(24) Нихрена не понял.
Почему бы просто не сделать вызов функции?

(25)
В 1С нет делегатов - вот ты нихрена и не понял.

(10) Видно ты не знаком с Ajax

(24) Callback

(28)+ это был вопрос.

(28)
Что callback?

(26) Что это?

(31)
"Функциональщина"

(18) Ну народ пищет на JS и нормально.
Linq в том C# уже повсеместно нормальное явление

(30) Тебе в 1С их не хватает ?

(32) Если речь про wiki:Делегат_(программирование), то повторяю вопрос, нахрена?

(0) Это разве замыкания? По моему, это называется делегаты, как в C#...

(35)
Да ХЗ - что нахрена? Нахрена событийная модель?

В контексте 1С - видимо не нахрена.

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

блин, хорошо Вам  - умным!!!
я б ответил: "до версии 15.1 даже не думайте"

(37) А, понятно. Я просто непонятно почему сразу про 1С подумал :))

(39)
Странно. o_O

а к замыканиям еще сразу repl обеспечить и расширение для slime. Ну и макросы нормальные конечно же. Прикольно ведь было бы  :)

(10) Вообще если 1С взяла курс на ВЭБ то им нужно подтягивать язык к JS, так они все равно транслируют код клиента в JS

<!--[if IE]>
    <script type="text/vbscript" language="vbscript">
        Sub ShowFocusMessage(win)
            win.setTimeout "MsgBox ""Нажмите OK для перехода к окну"",vbSystemModal,""1С:Предприятие""",0,"vbscript"
        End Sub
    </script>
<![endif]-->

(42)
--то им нужно подтягивать язык к JS

И это будет конец

(0) Дочитай "bullschildt" до конца и забудь :)

(43) Почему?

+(44) И самое интересное, когда 1С реализует новый синтаксис, то на Мисте опять будут появляться сообщения типа: "Опять только фантики-бантики делают, а о производительность никто не повышает"...

(46) всегда есть недовольные

Ты как бы это, перепутал мисту, с хотлайном. Миста не ведет же разработку 1С.

вообще как только обработку ожидания придумали - надо было сразу и делать. Хотя бы не замыкания, а присвоение функций переменным и использование имен функций без скобок как переменных.

(49)+ служебный массив с параметрами функции для использования внутри функции

(49) Да и использование лямбд и делегатов для универсальных функций. Например сравнения
v8: Отбор с условием

51 и вместо лямбд и делегатов приходится присобачивать Вычислить

(0) по-моему наоборот хуже читается. особенно плохо это будет выглядеть при объединении конфигураций

Кстати... тут я вижу в теме набрались специалисты ООП.
Я вот 10 лет программировал в 1С, там вроде конфа есть, все более менее структурировано до тебя. Есть методология вроде как надо и где писать чтоб было красиво.Ну писал и писал, нормально было.
Щас пишу на java - че-то у меня ппц адский ад получается в проекте... одно туда, другое сюда, то от того наследуюется, тут реализуем интерфейс... там модулей 10 штук я ниче не понимаю уже как это все между собой работает.
Кто может меня натолкнуть на мысль вообще как это все исправить и навести хоть какой-то порядок... может мне че-нить почитать по этому поводу ?

(54) ага, на пенсию тебе пора)

(55) Какая пенсия... мне только 30 :)

(54) Гарди Буч ООП, Макконелл Совершенный код. Банда 4х Про паттерны.

Нечитабельно.
Типовой вариант лучше.

(53) Ты не пробовал работать с Linq to DB тогда бы понял их премущество над текстовыми запросами. Ленивые вычисления рулят особенно когда тебе нужно 10 этажный запрос наворотить.
А вообще насчет сложности и читаемости когда лямды и Linq появились все  тоже говорили о том что нечитабельно итд. Сейчас все прекрасно используют и не жалуются на читабельность.

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

(59)
--Ты не пробовал работать с Linq to DB

Хм, я тоже. o_O

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

(54) юзай  clojure. А про все эти паттерны, методики и прочую х*ню забудь.... И сделай свои.

(0) и где в приведенном примере замыкание?

(64) Закрыть(); неявно передан this (ЭтотОбъект)

(0) еще один товарищ, воодушевленный скалой :)
Замыкания сложны в реализации на уровне транслятора. Т.е., у тебя появляется не просто объект с неопределенным временем жизни, а целый контекст объектов. Следить за ними — большая головная боль. Не даром в jvm хороший кусок занимает сборщик мусора.

(0) сначала пусть глюки все уберут, а потом уже можно делать такие плюшки (особо не нужные)

(67) + имхо, даже вредные для 1С

(66) Скорее JS учитывая Вэб клиента. Ну в JS это все реализовано и прекрасно работает

(0) может ты и прав конечно, но большой проблемы на С это представляет - посмотри на clisp, sbcl или любую другую реализацию лиспа

(70) к (66) было

(65) У замыкания есть довольно четкое определение. Причем здесь неявная передача чего бы то ни было?

(72) wiki:%C7%E0%EC%FB%EA%E0%ED%E8%E5_(%EF%F0%EE%E3%F0%E0%EC%EC%E8%F0%EE%E2%E0%ED%E8%E5)

Замыкание (англ. closure) в программировании — функция, в теле которой присутствуют ссылки на переменные, объявленные вне тела этой функции и не в качестве её параметров (а в окружающем коде). Говоря другим языком, замыкание — функция, которая ссылается на свободные переменные в своём контексте.

(73) дальше прочитать не хватило сил?

"Замыкание — это особый вид функции. Она определена в теле другой функции и создаётся каждый раз во время её выполнения. В записи это выглядит как функция, находящаяся целиком в теле другой функции. При этом вложенная внутренняя функция содержит ссылки на локальные переменные внешней функции. Каждый раз при выполнении внешней функции происходит создание нового экземпляра внутренней функции, с новыми ссылками на переменные внешней функции."

(74) Ну и что же не соответсвует в 0.
Есть функция в теле другой функции которая использует ЭтаФорма
Закрыть(); закрыть к чему будет применяться?
Реально в .Net создается экземпляр класса в котором есть ссылка на ЭтаФорма.

(75) "Она определена в теле другой функции..."

Особо обращаю внимание на слово "определена".

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

Причем здесь .Net, причем здесь экземпляр какого-то класса? Речь в (0) идет о встроенном языке 1С.

(76) Вообщето есть статические и экземплярные функции.
Для экземплярных функций this передается скрыто ввиде параметра. В питоне например он передается явно.
Так что этаФорма определена в теле функции.

(77) У тебя дикая каша в голове.


Еще раз для альтернативно одаренных с капсом в нужных местах:

"ЗАМЫКАНИЕ — это особый вид ФУНКЦИИ. ОНА [ФУНКЦИЯ, КОТОРАЯ ЗАМЫКАНИЕ] определена в теле другой функции и создаётся каждый раз во время её выполнения. В ЗАПИСИ ЭТО ВЫГЛЯДИТ КАК ФУНКЦИЯ, НАХОДЯЩАЯСЯ ЦЕЛИКОМ В ТЕЛЕ ДРУГОЙ ФУНКЦИИ. При этом вложенная внутренняя функция содержит ссылки на локальные переменные внешней функции. Каждый раз при выполнении внешней функции происходит создание нового экземпляра внутренней функции, с новыми ссылками на переменные внешней функции."


И еще одна цитата (wiki:%D4%F3%ED%EA%F6%E8%FF_(%EF%F0%EE%E3%F0%E0%EC%EC%E8%F0%EE%E2%E0%ED%E8%E5)):

"Функция должна быть соответствующим образом объявлена и определена. Объявление функции, кроме имени, содержит список имён и типов передаваемых параметров (или: аргументов), а также, тип возвращаемого функцией значения. ОПРЕДЕЛЕНИЕ ФУНКЦИИ СОДЕРЖИТ ИСПОЛНЯЕМЫЙ КОД ФУНКЦИИ. В одних языках программирования объявление функции непосредственно предваряет определение функции, в то время как в ряде других языков необходимо сначала объявить функцию, а уже потом привести её определение."


Внимание вопрос, где определена функция Закрыть() ?

(defparameter Закрывашка (lambda (чего-там-позакрывать доппараметры) (закрыть чеготампозакрывать доппараметры))

(defun юзалка (форма)
  (apply закрывашка форма nil))

хотя через defgeneric было бы проще :)

(78) Ты мне так и не ответил к чему относится Закрыть()?
При этом ЭтаФорма не передается в параметрах функции и не является глобальной переменной.

Ответь для себя чем отличается модуль объекта от модуля менеджера. Чем является для вызывающей функции ЭтаФорма.
Что такое контекст http://habrahabr.ru/post/149516/

А потом уже решай у кого каша в голове.

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

(80) Ок, давай предположим, что я не умею читать, связно логически мыслить и у меня реально каша в голове. А ты все это умеешь и у тебя есть стройное логическое объяснение почему вдруг функция ( а на самом деле метод ЭтаФорма.Закрыть() ) вдруг превратилась в замыкание.

Сделай это пожалуйста в терминологии 1С и в соответствии с определением замыкания. Сравнения с другими языками абсолютно неуместны. Я пишу и на js и  на python, которые ты тут приводил в пример, и не вижу параллелей с 1С, кроме самых общих.

Откуда в функции взялась ЭтаФорма?

(83) Закрыть() это метод объекта Форма. ЭтаФорма для метода Закрыть() является аналогом this или self  в других языках.

Закрыть() это сокращенная форма записи ЭтаФорма.Закрыть(). То есть обращение к методу объекта. Странно было бы если в методе объекта не была доступна ссылка на сам объект.

(81) Так я изначально про кривой код и спросил. А теперь вот пытаюсь понять каким чудом может метод объекта превратиться в замыкание.

То есть ЭтаФорма является переменной вызывающей функции?

(85)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    class test
    {
        delegate int Act(int i);
        void info(int i)
        {
            Console.WriteLine(i);
        }
        public void cas(int per)
        {

            Act t = (i) => { info(i); return i + per; };
            t(per);
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            var t=new test();
            t.cas(1);
            Console.ReadKey();
        }
    }
}

(86) Я не готов спорить на тему как именно попадает ЭтаФорма в функции и процедуры модуля — неявно как локальная переменная (очень сомневаюсь) или как глобальная переменная контекста. Я недостаточно хорошо знаю как работает 1С внутри.

В данном случае это абсолютно неважно, потому что вызов Закрыть() это вызов метода переменной ЭтаФорма как бы она ни была определена.

Если принять твою точку зрения, то условно это можно записать так:

Процедура Тест ()

    НеявнаяПеременная = ЭтаФорма;
    
    НеявнаяПеременная.Закрыть(); //никакой передачи тут нет, это вызов метода объекта Форма, который находится в неявной переменной по твоему мнению

КонецПроцедуры

(87) Ты не видишь разницы между тем что написано в (0) и в (87) ?

с замыканием более верный пример


(defparameter y 10)
(setq f (function (lambda (x) (+ x y))))
(apply f 1) вернет 11
затем меняем внешнюю по отношению к f пременную
(setq у 7)
и (apply f 1) вернет 8

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

(90) тут замыкание по ссылке или по значению?

в разных языках это по разному.

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

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

соответственно и ответ будет разный

Например в for и foreach С# в одном случае по ссылке, а в другом по значению.

(93) 1с на лиспе....

"и по молясь Лиспу великому с ужасом не приходящим стал он писать проведение документа прихода от поставщика и за разъяснениями и взмолился он к мисте и послала его миста по дальше вместе с...."

забыл дописать "... ибо не написать на лиспе проведение прихода - это высшая степень кретинизма " :)

(88) Нет лямбда это статическая функция которая ничего не знает о ЭтаФорма. Но как только ты вызываешь в лямбле метод ЭтоФорма она сразу превращается в замыкание, так как в неё передается ссылка на ЭтаФорма.
(89) Там как раз есть вызов метода объекта  info(int i)
то есть неявное замыкание на this

(97) в каком языке?
в C# она знает контекст

(96) если ты лисп знаешь.....
а куча скобок пугает пока не понимаешь какие это дает преимущества.
например отсутствие проблем с обновлениями.(в первом приближении)

100

(98) Я знаю. Здесь идет спор о том что в приведенном тобой примере является замыканием. Если лямда не использует тссылки на переменные, объявленные вне тела этой функции и не в качестве её параметров (а в окружающем коде).
this и ЭтаФорма являются переменными объявленные вне тела лямбды а значит явяется замыканием.

this и ЭтаФорма на самом деле являются переменными вызывающей функции

(101) замыкание это захват контекста.
оно даже не обязательно связано должно быть с функцией, тем более анонимной.

(102) Согласен
wiki:Замыкание_(программирование)

Замыкание (англ. closure) в программировании — функция, в теле которой присутствуют ссылки на переменные, объявленные вне тела этой функции и не в качестве её параметров (а в окружающем коде). Говоря другим языком, замыкание — функция, которая ссылается на свободные переменные в своём контексте.
Замыкание, так же как и экземпляр объекта, есть способ представления функциональности и данных, связанных и упакованных вместе.
Замыкание — это особый вид функции. Она определена в теле другой функции и создаётся каждый раз во время её выполнения. В записи это выглядит как функция, находящаяся целиком в теле другой функции. При этом вложенная внутренняя функция содержит ссылки на локальные переменные внешней функции. Каждый раз при выполнении внешней функции происходит создание нового экземпляра внутренней функции, с новыми ссылками на переменные внешней функции.
В случае замыкания ссылки на переменные внешней функции действительны внутри вложенной функции до тех пор, пока работает вложенная функция, даже если внешняя функция закончила работу, и переменные вышли из области видимости.[1]
Замыкание связывает код функции с её лексическим окружением (местом, в котором она определена в коде). Лексические переменные замыкания отличаются от глобальных переменных тем, что они не занимают глобальное пространство имён. От переменных в объектах они отличаются тем, что привязаны к функциям, а не объектам.

(81) Вообще замыкания в контексте 1С интересны для серверного вызова в теле клиента. Тогда весь код будет компактен и выполнен в одной процедуре, нежели раскидан по нескольким процедурам.

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

(0) сомневаюсь, что скоро. Все работает и без этого и смысла вкладываться в усложнение кода пока не видно.

ЗЫ В день, когда я увижу код с замыканиями в каком-нибудь отраслевом, у меня лопнут или мне придется их себе выколоть, чтобы гарантировать, что я больше ни чего подобного не увижу. Это будет ужасно, я думаю

имею мнение, что того, кто решил всунуть lambda expressions в java, в аду черти ждут с нетерпением. Потому что они може код и сокращают, но делают его нечитабельным в хлам.
В 1С будет все еще хуже, потому, как порог вхождения "специалистов" ниже, ибо практика показывает, что для того, чтобы быть программистом 1С, в большинстве случаев нужно всего лишь уметь поддерживать температуру тела в районе 37 градусов

(107) +100500

(107) Не согласен. Видел УТ 11 допиленную, там из БСП франкенштейна сделали, хотя там все уже было. Вот и здесь, как  говорится можно и ... сломать. Плотно работал с лямбда в шарпе - очень хороший механизм, только 1С до шарпа как до китая.

+ (109) Хотя объектный язык запросов 1С можно рассматривать как аналог

(107) А то, что сейчас гвнокод именно из-за того что язык ограничен.
А на шарпе народ радуется Linq и во всю использует замыкания.
А раньше так же кричали, так как на шарпе пишут куча не сеньоров, а джуниоров

(111) Копрокод он же не из-за возможностей языка, а из-за отсутствия мозга. А выразительные возможности языка и уровень разработчика  - ну никак не связаны.
Можно  на басике написать красиво, можно на С# наговнять.

Коли так не в моготу без замыканий/каринга/лямбд/протоколов/(тут можно подставить без чего еще нельзя жить) - напиши свой интерпретатор с любимого языка на 1С - и пользуйся
Вот только сердце-вещун говорит что будешь ты единственным кто его будет пользовать.

(101) Что ты, никакого спора. Я прозрел.

Теперь я знаю, что Закрыть() при определенных условиях становится замыканием, что ЭтаФорма и ЭтотОбъект передаются в функции модуля в виде неявной локальной переменной и что ЭтаФорма по совместительству еще и метод. Мир никогда не будет прежним.

(112) map/reduce забыл и итераторы:)

(109) (112) ну... это, как с матом - умеючи можно добавить овер 9000 выразительности, а не умеючи... ну вы поняли

(0) Даешь функциональное программирование в 1С ответ за номером 1


И кстати, продолжение к v8: v8: Учетная система на лиспподобном языке программирования? есть? интересно просто

(112)
--Коли так не в моготу без замыканий/каринга/лямбд/протоколов/

Увы, ничего этого в 1С не нужно. Потому что сама 1С - это "пришлепка" к БД, причем пришлепка, которая пытается усидеть на двух стульях. Итог закономерен.

Ну, а если 1С решит вывести свой продукт в другую парадигму, то зачем изобретать свою экосистему? Со своим языком (я про "настоящий"), IDE и прочими? Всё это давно уже есть.

столько нафлудили, но НИКТО не сказал ЗАЧЕМ это нужно???

есть мнение СПОРНОЕ что это более читабельно, других доводов НЕТ!

еще раз зачем вносить довольно сомнительное новшество которое повысит порог вхождения в профессию при явном дифеците специалистов.

(3) А мне второе больше нравится, так как в духе привычного JavaScript

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

(119)
я не вижу чем они уродские кроме как текстовое указание имени функции, поменять это можно если ввести новый тип "функция/процедура".

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

А вот представь свое замыкание в клиент серверном варианте, верхняя процедура на клиенте, а безымянка на сервере :) и понеслось.... передаяа контекста вызова (всех описаных переменных, в том числе и не нужных...)

ИХМО для клиент сервера нужно ужесточения той свободы которая есть сейчас. Нужна явная типизация параметров функций и прочего контекста передаваемого с клиента на сервер и обратно...

Обычные формы уже это реализуют.

...

(120) и на сколько это повысит порог вхождения?

(123) Да не важно насколько, главное зачем? И, еще главнее - зачем во втором варианте строчка


ОписаниеОповещения = Новый ОписаниеОповещения("ОбработатьОтвет", ЭтотОбъект);


Она ведь нигде не используется.

(112) Не скажи когда появился Linq сразу начали писать по другому в том числе используя замыкания. А вот Linq2DB кардинально меняет подход

(120) Замыкания интересны прежде всего в контексте серверных вызовов. Не надо создавать отдельно метод с параметрами. Не надо помечать с контекстом без контекста. Компилятор должен сам решить какие данные передавать на сервер и какие возвращать. Я уже не говорю про ассинхронность

в С++ 2003 не добавили замыкания просто по той причине, что практически никто не мог понять необходимость данной фичи. Единственное место, где она считалась, хоть как то полезной - sort в качестве функции сравнения.

(126)
--  что практически никто не мог понять необходимость данной фичи.

Судя по всему - изменилось немного.

(0) у 1С постоянно, с каждым релизом, одни замыкания.
Разве нет?

(127) посмотри на новые библиотеки.... там все на замыканиях.

(129) Может просто inline?

(130) инлайн сейчас практически не применяют в синтаксической форме, так как компиляторы для этого достаточно умны.

(131) Вот именно. У тебя же нет исходников 1С, с чего ты взял, что это не компилятор inline автоматически сделал?

(132) стоять... что ты имеешь ввиду под инлайном

(0) Блин, тут иногда возникают сра..., простите прения по поводу нужен ли ООП в 1С, а предлагается еще добавить прения функциональщина против объективщина?

(133) То же что и все - физическое размещение кода inline функции в теле вызывающей ее функции и без создания для нее собственного контекста.

А когда в 1С вообще происходило какое-то развитие встроенного языка? Я не про добавление предопределенных классов.

Даешь embedded язык запросов!

(135) 1с это транслятор или интерпритатор, но ни как не компилятор

(137) это что?

(139) это когда текст запроса не передается как строковый параметр, а непосредственно в коде имеет место быть

плюс такого подхода: проверка корректности на стадии компиляции, возможность предварительной оптимизации

(140) linq?

(141) LINQ это только одна из реализаций, причем местами неудачная

(138) Тогда к чему (129)? Кстати, для критических задач все эти новомодные штучки очень не любят использовать. В бой идет олдскульный код.

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

(140) - обоснуй. какой от этого выигрыш? лучше чем сервер интерпретатор 1С вряд ли оптимизирует план запроса.

(143) потому что он - предсказуем и для него легко найти разработчиков

(144) Когда нибудь и научаться. Это для java/C#/visual basic есть best practics. Для 1С пока нет, не доросли еще

(145) ну может с оптимизацией и нет, хотя может повыкидывать избыточные части типа "ГДЕ ИСТИНА"
но синтакс-проверка на уровне компиляции точно помогла бы

(148) да ничем бы она не помогла. это раз. и два - тект запроса не обязательно к этой базе относиться. три - думать надо прежде чем писать.

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

(140) Народ на C# с огромным удовольствием использует LINQ to Entities и не можер нарадоваться. Так где не хватает производительности используют запросы с выводом типа.

http://msdn.microsoft.com/ru-ru/magazine/hh781018.aspx



string entitySQL = " SELECT p, p.Filling " +
"FROM PartyContext.Pinatas AS p "
"WHERE p.Filling.Description='Candy'";
var query=context.CreateQuery<DbDataRecord>(entitySQL);
query.MergeOption = System.Data.Objects.MergeOption.NoTracking;
var pinatasWithFilling=query.ToList();



http://msdn.microsoft.com/ru-ru/library/bb386964(v=vs.110).aspx

(151)>>Народ на C# с огромным удовольствием использует LINQ
потомуц что на безрыбье и рак - рыба.
На фоне остальной реализации работы с БД в С# - это глоток воздуха с помойки в душном подземелье.

(152) ты как гений - 1С это круто

(153) да нет возможно ))
А, впрочем, мы тут про С#.

(0) Что такое замыкания ?

то что хочет ТС впринципе штука нужная, как уже отмечали, на JS (и не только) активно используемая
токма вопрос накой это вкрячивать в эску ???

(155) wiki:Замыкание_(программирование)

(152) То есть 1С запросы это рыбное место c rhegysvb ktofvb, а LINQ to EF это малек шпроты?
(156) смотри 125

(158)>>Не надо создавать отдельно метод с параметрами. Не надо помечать с контекстом без контекста. Компилятор должен сам решить какие данные передавать на сервер и какие возвращать. Я уже не говорю про ассинхронность

имхо мне кажется замыкания не панацея

(158) если уж интересно про запросы, то SQL-запросы - это рыбное место. При чем тут 1С, и каким боком - известно только вам, в силу сообщения ( 153) :))

А как же высказывание про то, что "одинэсники тупые и жадные"
Зачем усложнять язык? Для повышения жадности?)

(160) А Linq to EF это объектные запросы с выводом типа и ленивыми вычислениями из которых удобно создавать запросы которые в итоге транслируется в SQL запросы. Также EF поддерживает и объектные запросы (151)

(160) По твоей идеологии ассемблер это рыбное место, а C# это малек шпроты?

(159) Замыкания придуманы для удобства, что бы захватывать контекст и уменьшить лишние телодвижения для программиста перекладывая всю нагрузку на компилятор и удобства читаемости программы

(153) вообще-то он прав. Посмотри как в других языках  сделаны макросы/замыкания (лисп, схема) и поймешь что в С# - очень жалкая поделка.
(161) 10% нахрен не нужен, 10% жить без него не могут, оставшимся 80 - пофиг.
(164) когда возникли замыкания - люди даже  в машинных кодах не писали. Ты бы хоть не по вики учил что такое замыкание, а нормальную доку почитал.


Вот для всех еще раз предложение - чем муссировать тему чего в 1С не хвататет - возьмите и напишите свой компилер с лиспа на 1С - а затем попробуйте окружаюших убедить его использовать

(165) Макросы это отдельная тема.
На лиспе и схеме программировать не приходилось, но того что есть в C# в большинстве случаев достаточно, ну если только Pattern matching добавить.

И добавить замыкание в 1С для серверных вызовов очень нужная вещь. А на лиспе пусть гики пишут

(157) Ок.

(125)это был толстый клиент
а вообще тема хорошая, тупо чтобы не писать портянку в 10+ передаваемых параметров (привет БСП присоединенные файлы) или хотя бы 1 раз определить что они могут быть контекстными

(163) ты запросы на ассемблере пишешь? уважаю

(166) Тогда почему тебе не достаточно того что есть в 1С? Твой код станет лучше если добавить замыкания?
Если да - приведи пример. Желательно - убедительный, а не с косяками как в 0.

А отзывы других форумчан будут тебе в поддержку потом.

(169) Спасибо. Linq to EF это объектная надстройка над ДБ которая в итоге генерит SQL код к конкретной БД. При этом используются ленивые вычисления которые можно использовать для повторного использования сокращая код и улучшая читабельность. А то бывают такие потрянки SQL кода на десятки страниц где разобраться очень сложно в том числе и используя конструктор запроса.

(170) Чем тебе в 0 не нравится?Где там косяк. Там есть захват контекста.


&НаСервереБезКонтекста
Функция П2(парам1,парам2,парам3)
    возврат парам1+парам2+парам3
КонецПроцедуры


&НаКлиенте
Процедура Ткнуть(Команда)
Парам1=1;
парам2=2;


рез=П2(парам1,парам2,РевизитФрмы)
//используя замыкания
рез=СерверныйВызов(возврат парам1+парам2+РевизитФрмы)
КонецПроцедуры

изучай http://docs.racket-lang.org/web-server/run.html (как самое близкое из предоженного тобой)

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

(171) Мало того если замыкание получилось большое его можно отфакорить в отдельную процедуру со всеми параметрами

(171) а где тут замыкание? я что-то не в гоняю

(172) Тормозить будет только компиляция в серверный код по сути должно получаться из
СерверныйВызов(возврат парам1+парам2+РевизитФрмы)

&НаСервереБезКонтекста
Функция П2(парам1,парам2,парам3)
    возврат парам1+парам2+парам3
КонецПроцедуры

(173) замыкание это не заклинание! ну разбери ты любое замыкание в let-форму и увидишь что параметры передавать надо, а раз надо, то от необходимости сериализовать данные не избавиться. Ты прикольно взял 1 и 2 в части параметров. А если мне надо на сервер передать содержимое динамической таблицы?

и втрое - замыкания сами могут быть параметром. и как тогда не запутаться бедному адынэснику?

(174) Замыкание это захват парам1 парам2 РевизитФрмы
Код то будет выполняться на сервере, что аналогично
&НаСервереБезКонтекста
Функция П2(парам1,парам2,парам3)

176 передавай что угодно смыл замыкания это уменьшить код
Для примера на C# http://www.rsdn.ru/article/csharp/Closure_in_Csharp.xml#EDG
создается отдельный класс

(177) Я не пойму в чем проблема то, что 1С ки тупые что ли?
Не вижу проблемы замыканий в качестве переменной. Наоборот вижу одни только плюсы. Проблема больше в реализации в 1С вот у кого проблема.

Хендерсон "Функциональное программирование", читаешь, много думаешь и  потом (если будешь так уж уверен) пытаешься озвучить мысль что в 1С с этим проблемы не будет.

и что 1С это так жизнено необходимо

(180) И как это в C# по проблем не видят?
Не путай чистую функциональщину с гибридными языками.
Хотя ограниченный патерн матчинг вещь нужная.
(181) Для серверных вызовов да. И это тебе подвердят многие когда на каждый чих нужно городить отдельный метод.

(179)>>Проблема больше в реализации в 1С вот у кого проблема.
есть такая проблема.
Поэтому никогда и не будет реализована в 1С.

(178)>>Код то будет выполняться на сервере
у 1С свое понимание, что исполнять на сервере, что - на клиенте.
В 1С все это будет глючить неимоверно, т.к. обработка таких сущностей вне компетенции разработчиков 1С.
Вспомнить хотя бы полуработающую Перейти...Метка (типа Goto...)

Вот блин... У Лёши даже перейти не работает...

(181) Или просто даже делегаты или лямбды v8: Отбор с условием

(183) Посмотрим. Что то ты совсем плохого мнения о разработчиках 1С. Там проблем больших то нет. Обычный рефакторинг

Чего-то не понял, или столько постов написано из-за размещения текста процедуры внутри вызывающей процедуры? Плюс - это использование общего контекста процедур ?

(184) Ты не поверишь я еще программировал на Бухгалтерии 6.0
7.0 и на моих глазах многое в 1С менялось. Так что посмотрим.

(187) Да. Люди не видят пользы, либо не считаю захват контекста замыканием.

(185) ну да. не работает как минимум тут v8: Выполнить. Весь мозг поломал
(189) Открой глаза, в конце концов замыкания вполне можно реализовать через  напиши ВК.

(184)>>Там проблем больших то нет
ну да, нет, только неработающая платформа ))
А так остальное правится в конфигураторе.

через  напиши ВК. = через ВК, напиши .

(187) ну было такое в 7.7. Раз говоришь, начинал с 6.0 - должен знать.
И где теперь этот контекст? в свете " я еще программировал на Бухгалтерии 6.0, 7.0 и на моих глазах многое в 1С менялось"

(193) к (189)

+ 193
ах, да, приобрел форму клиента УФ ))

(190) То есть тебе подход в 171 не нравится. Все оставить по старому через процедуры? При чем тут ВК.
(193) Ты не видишь разницу между Бухгалтерия 6.0 и Предприятие 8.3?

(190) Вот лямды и замыкания нужны, для того что бы к Выполнить по меньше обращаться. Для тебя Выполнить это нормально с которыми сам разобраться не можешь, а замыкания это зло.

(196) не вижу
как там не работали расчеты, так здесь - не работает сбор данных.
Какая разница, что не работает, если воз и ныне там.

+ а с 8.3 ты, видимо, сам не работал. Там даже супротив глюкавой 8.2 полная попа.

200

(197) зачем нужны лямбда, замыкание -  я как для себя знаю и где нужно применяю, зачем это в 1С -  не понимаю, вся ветка не смогла убедить в необходимости. Вот честно - никакой выгоды  не вижу.

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

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

(198) Спасибо рассмешил. Ты для интереса почитай что такое Бухгалтерия 6.0. По твоим выводам на 1С писать вообще нельзя. А ведь пишут. А вэб клиент это уже отдельная платформа с использованием HTML JS.
По твоей логике Вэб клиент это чуть переделанный тольстый клиент?

(201) Ответь на 196 чем тебе не нравится подход в 171.
По твоей же логике Зачем нужны вычислить?

(202) Не должен опухать, так как компилятор должен анализировать код и если значения не изменяются то передавать только необходимые данные. Если есть изменения только в реквизитах то отслеживать эти реквизиты и изменять их на клиенте. Если изменяются табличные части то придется  передавать и их. Сейчас как раз многие ради лени используют На сервере передавая полный контекст.

в (171) у тебя собственная реализация вычислить. Например так

МоеЗамыкание = новый Структура();
МоеЗамыкание.Вставить("Замыкание","Тип");
МоеЗамыкание.Вставить("х1 + х2 + х3","Код");
МоеЗамыкание.Вставить("1","х1");
МоеЗамыкание.Вставить("2","х2");
МоеЗамыкание.Вставить("3","х3");

Результат = моеВыполнить(моеЗамыкание);

функция МоеВыполнить(замыкание)
если замыкание.Тип = "Замыкание" тогда
строкакода = замыкание.Код;
для каждого х из Замыкание
   строкаКод = стрЗаменить(строкаКод, х.Ключ, х.Значение);
конеццикла;
возврат вычислилить (строкакод);
конецесли;
кнецфункции

Это будет прямо сейчас работать в коде, то что ты предлагаешь сделать - то же самое, но на уровне платформы, исходя из того что 1 и 2 как параметры очень легко передаются.
И проигнорировал вопрос - что будет если я захочу передать не числа, например захочу обойти строки динамической таблицы. И главное - как ЭТО по твоему должно реализоватся на платформе?

(204) А кто тебя обманул и сказал что 1С компилятор?
и что он что-то кому-то должен оптимизировать?

(204) Хм, а на счет #НаСервере - может тогда и не нужно более никаких других методов?

(204) понятно, что транслятор, а не компилятор (хотя, у 1с есть система предварительной компиляции).

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

(205)  Смысл замыкании как раз в рефакторинге.
Я тебе уже приводил пример как это реализовано в Net.
Замыкания нужны для упрощения кода.
(206) Так скажем в зависимости от мутабельности по разному  передача. Например касаемо табличной части если к контексте замыкания нет вызова внешних процедур и  данные не изменяются, то передавать можно не всю табличную часть а только определенные колонки.
Хотя бы отслеживали и возвращали только используемые переменные и реквизиты.

(205) Так же как и сейчас передаешь на сервер различия нет.
Смысл в том что вместо
Процедура(парам1,парам2,...парам101)
Просто использовать захват этих переменных и реквизитов.

(205) Транслятор вместо компилятора тебя удовлетворит?

209+ wiki:Компилятор

Все равно нужно
1.Лексический анализ. На этом этапе последовательность символов исходного файла преобразуется в последовательность лексем.
2.Синтаксический (грамматический) анализ. Последовательность лексем преобразуется в дерево разбора.
3.Семантический анализ. Дерево разбора обрабатывается с целью установления его семантики (смысла) — например, привязка идентификаторов к их декларациям, типам, проверка совместимости, определение типов выражений и т. д. Результат обычно называется «промежуточным представлением/кодом», и может быть дополненным деревом разбора, новым деревом, абстрактным набором команд или чем-то ещё, удобным для дальнейшей обработки.
4.Оптимизация. Выполняется удаление излишних конструкций и упрощение кода с сохранением его смысла. Оптимизация может быть на разных уровнях и этапах — например, над промежуточным кодом или над конечным машинным кодом.

(0) А когда в 1С один и тот же код сможет выполняться на вэб-клиенте, тонком клиенте, мобильном приложении, сервере. При этом еще указывать на каком именно сервере кластера и тп? :)

(205) Заметь насколько твой код больше обычного замыкания
x1=1; x2=2; x3=3;
Лямбда=() => x1+x2+x3;

результат=Лямбда();

(212) и сразу вопрос:
если после твоего кода написать

х1=2; х2=3; х3=4;
результат1 = Лямбда();

чему будет равен результат1?

точнее, чему _должен_ быть равен результат1

Я уже давал тебе ссылку как это в Net реализовано.
будет как при  х1=2; х2=3; х3=4;
То есть в замыкании ссылки на эти переменные.

215+ А что касается 171 там замыкание для передачи и возврата переменных реквизитов

Поэтому есть проблемы с переменными циклов
http://habrahabr.ru/post/36601/

Хотя в C#5 Это уже подправили
http://deilycode.ru/index.php/2013/08/foreach-closures/

(214) Если нужна неизменяемые то можно как то так
Функция ВернутьЗамыкание(знач x1,знач x2,знач x3)
Лямбда=() => x1+x2+x3;
возврат Лямбда
КонецФункции

(215) а вот, например, у scala на этот счет есть иное мнение

(220) Ну я на скала не пишу. Ты не забывай что в функциональном программировании все рид онли (Неизменяемые типы, иммутабельные типы) окромя монад.

На C# будет так так как он гибридный язык.
А с точки зрения сервеных вызовов все изменения переменных в замыкании должно переносится и в вызывающий метод.

(221) в scala в этом смысле проще — там мутабельность переменной определяется явно и контролируются компилятором. Но побочные эффекты возможны и в этом случае.

(0)
Фуфел это всё, сынки.

В Informix можно было указывать - на каком месте цилиндра HDD хранить таблицу!

О как!

Таблицы партионного учета - СТРОГО близка к стержню!

Восстановление партионного учета - танец у шеста!

(223) в случае с SSD особенно актуально, да

(222) Ну вот здесь пишут что изменения видны
http://blog.lakhtin.com/post/2348212568/closure

scala> var more = 1
more: Int = 1

scala> val addMore = (x: Int) => x + more
addMore: (Int) => Int = <function1>


scala> more = 100
more: Int = 100

scala> addMore(10)
res17: Int = 110

scala> more = 200
more: Int = 200

scala> addMore(10)
res18: Int = 210

(207) > Смысл замыкании как раз в рефакторинге. - в мемориз
> Я тебе уже приводил пример как это реализовано в Net.  - ты бы на пример реализации в lisp или clojure глянул. дя академической простоты - в ракетке
> Замыкания нужны для упрощения кода.  поржал

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

(221) внезапно - у лиспа на этот счет тоже другое мнение.
(224) круть!


Резюмируя - ветка смысла не имеет, все говорят на разных языках.

(227) Смысл есть в упрощении кода. Еще раз в 212 намного проще использовать чем твой код в 205 почувствуй разницу и ржи себе на здоровье.

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

Кстати ссылочки приводи для общего развития.

Код из (205) это то что сейчас уже будет работать, код из 212 - твоя мечта которая не скомпилиться ни под какой платформой. Так как 1С развивает платформу не пойми как, то надеяться что в новой версии введут тот синтаксический сахар что ты указал - глупо.  
Насчет ссылок - было уже. читай не вики, а учебники. Для понимания как это внутри работает - прочти Lisp in Small Pieces (есть и на русском ссылка - http://ilammy.github.io/lisp/ )
А вот по поводу "..правой кнопочкой выбираем создать серверную процедуру задаем имя и в конфигураторе создается процедура и её вызов. Если такое введут предлагаю тебе не пользоваться." - уже полгода пользуюсь. открой для себя снегопат.

(229) Здесь разговор не о том, что есть, а что желательно ввести для облегчения программирования. Т поверь я сам активно использую выполнить.
Тесты не проводил, но мне кажется что выполнить более медленая операция по сравнению с инлайн кодом.
v8: Отбор с условием

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

Ну вот видишь в снегопате то уже есть, значит не все так уж и сложно?

(229) В приведенной тобой ссылке нет того что захватываются значения, а не ссылки переменных.

(230) хм.. то есть тебе достаточно регэкспов? так может так и стоило писать - хочу регэкспы выполянемые в конфигураторе, а не замыкания.
(231) ты сделал мой день. Но если что - прочти чуть дальше чем введение.

(232) Вообще то это регекспы это далеко не рефакторинг.
Так как нужно анализировать изменнеия и оптимизировать передачу и возврат данных. При этом выглядеть такой код будет как замыкания. Например на шарпе генерится отдельный класс. От этого суть замыкания не меняется. Меняется её реализация.

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

Когда в руках молоток, все кажется гвоздями. Если знаешь С# - то везде видишь классы. И вольно или невольно пытаешься применить свои знания и здесь.

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

200 постов - ни о чем.

(234) Посмотрим что будет в 9.0. Но рефакторинг уже в ближайших версиях могут вводить

(234)
Хорошо сказал!

рефакторинг - это не свойство языка. его ты и сейчас можешь делать (кроме лени - ничего не мешает). Если что - его еще на 77 можно было делать.
Замыкание - свойство языка, для его реализации в 1С придется переделывать платформу.

(237) Ну от рефакторинга wiki:Рефакторинг#.D0.92.D1.8B.D0.B4.D0.B5.D0.BB.D0.B5.D0.BD.D0.B8.D0.B5_.D0.BC.D0.B5.D1.82.D0.BE.D0.B4.D0.B0_.28Extract_Method.29

Выделение метода недалеко и от совмещения серверного кода внутри клиентского, а там уже недалеко и до лямбд и замыканий.

А там уже и совсем рукой подать и до Linq и Linq to DB.
Начинать надо с малого.

В том числе можно создавать аналог расширяемого класса
v8: v8: Использование сборок .NET в 1С 7.x и 8.x

(0) Очередная ненужная фигня... Не удивлюсь, если эту фигню пропихнут в каком-нибудь новом релизе.

(238) с твоей точки зрения получается - теплое и кислое - практически идентичные понятия. И ничем  не отличаются от  твердого и желтого.
(239) Сейчас тебе что это мешает сделать?
(240) Не боись. не пропихнут. Потребности в этом нет. пара гиков  с С# и один с лиспом - не повод менять язык.

(241) если в типовых начнут активно использовать фоновые асинхронные вызовы, то может что-то такое и появится. Сейчас реализация тех же фоновых отчетов больше похоже на шаманство, чем на технологию

(241) Здесь не проблема гиков. Linq это уже постоянное использование в том числе и Linq to EF. Индустрия развивается и борьба за клиентов идет полным ходом. Тот кто создаст удобный с максимальными возможностями инструмент тот и будет завоевывать клиентов. Ты просто отстал от времени. Например я сейчас на 7.7 программирую и получаю больше удовольствия из-за того что на 1С++ могу использовать всю мощь T-SQL.
Да и среды разработки постоянно совершенствуются. Если сравнить Visual Studio или IntelliJ IDEA.

А потребность в этом есть. Просто ты этого не видишь.

Опачки сейчас открыл 1С:Предприятие 8.3 (8.3.5.823)
а там рефакторинг то уже есть. Например "Выделить в ассинхронную процедуру". Так что до совмещения клиентского и серверного кода недалеко

Блин прорустил http://v8.1c.ru/o7/201312ref/index.htm

(242) в (207) ясно сказано "Смысл замыкании как раз в рефакторинге", так что отчеты в пролете.
(243) Да. я отстал. моя среда разработки для не 1С - емакс. и необходимости в ее модификации я не вижу. Вполне нормально работает и для С++ и для лиспа.
(244) Круть. Значит до замыканий осталось полшага - основное то сделано уже. чисто косметические вещи остались - переписать платформу и переобучить армию программистов.

В общем, это мое последнее  сообщение в этой ветке. Смысла продолжать нет. Мы действительно говорим о разных вещах разным языком.

[Смысл замыкании как раз в рефакторинге] — чо?!

мопед не мой, он из 207 сообщения в этой ветке

После апдейта на 8.3.4.482 код, указанный у топик-стартера, отправляет платформу в дамп по таймауту, т.е. если не отвечать на вопрос в течение минуты.

(246) Ты посмотри на 245. Выделение на каждый модальный вызов отдельную процедуру еще то удовольствие.
Можно просто поместить ассинхронный код внутри например метода
АссинхронныйВызов(
ВыбранноеЗначение=ВыбратьИзМеню(СписокВыБора,Элементы.КомандаМеню);
Ф=154;
)

(248) Для выделения серверного кода или ассинхронного достаточно рефакторинга, который генерит методы при компиляции этакий аналог макроса который активно используется например в Немерле.

(247) На самом деле сначала анализируется захватываемый контекст и в итоге генерится новый код при компиляции.
Например если используются переменные то создается  класс с этими переменными доступ которым осуществляется как из вызывающей процедуры так и замыкания. Реализации могут быть различными.

Слишком сложный руский синтаксис для простого парня из маленькой северо-мадагаскарской деревушки. Точки , стрелочки, скобочки (( Придумай проще!

251+ http://hashcode.ru/questions/233227/реализация-замыканий-в-c

(250) Чем для тебя 250 сложен?

в C# для упрощения работы с ассинронностью  ввели
async и await http://habrahabr.ru/post/162353/

(168) Чтобы не писать портянку - любая коллекция КлючИЗначение к вашим услугам.

(179) Да нет никакой проблемы. Разработчикам платформы это просто не нужно. Ведь этого никто кроме обслуги не увидит. А вот внешние плюшки - очень даже нужны, заказчика впечатлить.

(212) Заметь, насколько проще ошибиться в таком коде, если подумаешь, например, что x1 уже давно не используется, и используешь для своих целей.

(243) Клиентов заработает тот, кто создаст хороший конечный продукт. Как он сделан внутри - 99,9% клиентов не интересует вообще.

(244) Осталось все это дело отладить :)

(250) АССинхронный - это от слова ASS? Т.е. по-русски - через-задницу-в-будущее?

Ассинхронное программирование это тренд.
А замыкания там в тему.

(259) Вот блин, даже как название правильно пишется не знаете, а все туда же... аСинхронное оно. А ассинхронное - это через задницу получается.

(260) Прошу прощение за неправильное написание. Но вот то, что тренд существует это факт. При этом async и await значительно сложнее чем
АссинхронныйВызов(
ВыбранноеЗначение=ВыбратьИзМеню(СписокВыБора,Элементы.КомандаМеню);
Ф=154;
)  

см 255
Главное, что бы упростить код, а через что это будет сделано глубоко наплевать.
250 легко делается через рефакторин во время компиляции кода в промежуточный код (AST дерево wiki:%C0%E1%F1%F2%F0%E0%EA%F2%ED%EE%E5_%F1%E8%ED%F2%E0%EA%F1%E8%F7%E5%F1%EA%EE%E5_%E4%E5%F0%E5%E2%EE) или трехадресный код wiki:%CA%EE%E4%EE%E3%E5%ED%E5%F0%E0%F6%E8%FF

Ну и можно посмотреть на байт код в 1С http://kb.mista.ru/article.php?id=519

" делается через рефакторин во время компиляции кода" - а как рефакторинг (изменение текста! программы) можно сделать в момент анализа AST? и как этому помогут замыкания?

(263) Посмотри  http://v8.1c.ru/o7/201312ref/index.htm

Там как таковые замыкания и не нужны. Просто генерация года во время компиляции. Это же касается и серверного кода внутри клиентского.

Вернее так скажем нет явного использования замыканий.
Посмотри на async и await http://habrahabr.ru/post/162353/

Вот зарекался я суда писать. Но блин нельзя же так в одну кучу сваливать все вместе. Возьми ты книжку любую - как минимум sicp - и прочитай что такое замыкание. Затем прочитай у Фаулера что такое рефакторинг. И попытайся найти хоть одно сходство.
А то все вместе - и асинхронность, и замыкания, и рефакторинг, и видимо скоро китайский язык потребуется (ибо тренд от которого нельзя отмахнуться)

Насчет посмотри туда или сюда - все что ты пытаешься показать - не изобретения Майкрософта, использовалось это все еще в 90 году и нормально работало в лиспе, начиная с 2003 - перекочевало в ракету где стало еще лучше работать.

В общем не все вокруг гвозди. И читай не только вику

(266) Ты мне только на один вопрос ответь, что тебе не нравится код в 261 и 171. Чем для тебя плох Linq, await.
Почему лисп несмотря на его мощность не получил такого распространения чем тот же C#.

По пунктам - почему не понравился? - код не баба. его задача работать, а не нравиться. Но конкретно по куску

АссинхронныйВызов(
ВыбранноеЗначение=ВыбратьИзМеню(СписокВыБора,Элементы.КомандаМеню);
Ф=154;
)  

тут у тебя мешаются 2 подхода к написанию, которые сложно читать.
Убери осмысленные имена и ты получишь
ф(х=у(й)) что приводит к увеличению времени чтения кода
Код должен быть однородным и не напрягать при чтении.
Хреновый сахар короче ты предлагаешь. Как было бы лучше? Не знаю.
Чем плох linq и прочий модный набор слов? Да ничем. Как впрочем ничем и не хорош. а если впихивать его вневпиху*мое - так даже вреден.
Почему лисп не получил распространения? Не знаю. Наверное потому что детям чернобыля было проще прочитать книжку "Освой программирование на C# за 21 день" чем htdp, paip или sicp. Да того же Страуструппа не читали. Как логичный результат подобного обучения - рефакторинг не сделать без асихроности и замыканий.

(268)
Сегодня ты рефакторинг без замыканий делаешь, а завтра?!

А завтра ты запросы в цикле крутить будешь!

(269) :) ты сделал мой день!

(270)
;)

(268) То есть по твоему вместо 268 вот это легче читается?

ПоказатьВыборИзМеню(Новый ПоказатьВыборИзМеню("КомандаМенюЗавершение",ЭтотОбъект),СписокВыбора,Элементы.КомандаМеню);


Процедура КомандаМенюЗавершение(результат,ДополнительныеПараметры) Экспорт
ф=154
КонецПроцедуры

(269) Еще раз посморти на await и все, что за ним стоит.
Народ тоже раньше писал BeginXXX EndXXX. Не было анонимных делегатов и замыканий. Как только все это появилось народ с большим удовольствием начал писать по новому.
По поводу LINQ то там ты можешь писать запросы и в цикле, которые в итоге будут разворачиваться в один запрос.


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

Да, проще читается.
Народ до сих пор такое пишет на С++ и ничего, не пишут гневные письма в комитет по стандартизации. Странная ситуация, не находишь?

Приведи пример когда запрос в цикле будет разобран в один запрос.

Вот здесь - v8: Мощь LINQ-а, или 1С и  не снилось. написан простой запросик. Измени его так что бы бегая по массиву слов он отобрал все первые большие буквы при условии что  массив обходиться циклом. Как они в итоге развернутся?

На вкус и цвет как говориться. Но ради эксперимента покажи свой код 100 коллегам и попроси охарактеризовать его.

(273) Ну там в цикле можно условия задавать.
v8: Мощь LINQ-а, или 1С и  не снилось.
там запрос состоит из двух запросов

(273) Ну мои коллеги с удовольствием используют await
А конструкция из 261 На C# будет такой
выбзнач = await ВыбранноеЗначение=ВыбратьИзМенюAsync(СписокВыБора,Элементы.КомандаМеню);
// Код который ниже будет выполняться после того как выполнится выбор
// При этом не будет блокировки основного потока
Если выбранноеЗначение<>неопределено Тогда
Ф=154;
КонецЕсли;

Ну а сишникам я сочувствую. Особенно когда они мучаются с IDispatch  и прочим