Зачем ей это делать? :D

Бля

В однопоточном с++ модель вычислений строго последовательная.

И конечно в итоговом коде это не так, но да.

Откуда ты вообще узнал про ленивые вычисления :D

Ленивые вычисления это совсем другое, срсли.

Это стратегия редукции лямбда термов.

В языках типа хаскелль и пр.

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

это про ленивые

Это то как приводить программу к слабозаголовочной нормальной форме

вот я и подумал

Ленивые вычисления (англ. lazy evaluation, также отложенные вычисления) — применяемая в некоторых языках программирования стратегия вычисления, согласно которой вычисления следует откладывать до тех пор, пока не понадобится их результат.

тут нет лямбдя термов))

это С++

Да, поэтому про с++ нельзя сказать о ленивых вычислениях

это не функциональный язык

хотя в руби есть ленивые вычисления

модель с++ это последовательные вычисления

другое дело, что на уровне компилятора есть реордеринг

в плюсах про ленивые можно только сказать когда идет проверка на && и все?

и оптимизация

вот ты написал let(:user) { create(:user) }, пока не использовал переменную user, то ничего не создаётся

на уровне процессора есть реордеринг и branch prediction

в плюсах про ленивые можно только сказать когда идет проверка на && и все?

не только, но да.

Еще есть execution policy для фьючеров

кароче вот что я не понял

std::launch::async \std::launch::deferred

Уж простите за глупые вопросы, но еще поспрашиваю https://tour.golang.org/flowcontrol/7 (Both calls to pow are executed and return before the call to fmt.Println in main begins.) т.е. функции выполняются заранее, еще перед тем как в main() идет их вызов?

В тех же плюсах, на сколько помню, функции выполняются только после их вызова, верно?

нет

там написано, что обе pow выполнятся до того, как Println будет вызвана

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

да

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

А в ленивых тогда как?

Ну человек не совсем прав.

Но вообще в ленивых может быть так

у тебя функция print взяла аругмент

но на самом деле у тебя аргумент не вычислился

до вызова функции

Так, да

вместо аргумента в print передаётся указатель на отложенные вычисления

и идёт выполнятся print

может внутри там вообще аргумент не понадобится

и тогда он не вычислится никогда

в с++ аргументы функции до её вызова вычисляются всегда

в этом смысле это всегда eager

энергичные вычисления

но в каком порядке не говорится

не суть, главное, что вычисляются

до вызова функции

да

в аналоге лямбда исчеления это значит, что сначала в теле лямба терма редуцируются все подтермы, а потом уже само тело лямбды

вместо аргумента в print передаётся указатель на отложенные вычисления

на отложенные вычисления? т.е. это для "ленивых" языков вроде хаскеля, так?

а ленивые или их еще называют нормальные

это когда сначала редуцируется тело лямбды, а потом уже тела её аргументов—подтермов

на отложенные вычисления? т.е. это для "ленивых" языков вроде хаскеля, так?

да

в с++ аргументы вычисляются всегда

Ну это модель вычисления c++

Так вот я тупой еще раз, не могу разницу чуток понять, вот есть у print аргумент, но он не вычислен, в плюсах и go он вычисляется, и потом print их выводит, а в ленивых как

но конечно компилятор може это поведение изменить, но так чтобы не изменилось так называемое observable behaviour

окей

давай поясню

@Doaxan, попробуй хаскель поучи)

вот у тебя есть функция

щас про плюсы

ERROR: S client not available

void foo(int arg1, bool arg2) { if(arg2) { arg1++; } }

http://www.youtube.com/watch?v=7BPQ-gpXKt4&list=PLlb7e2G7aSpRDR44HMNqDHYgrAOPp7QLr

Бтв

на видео

денис москвин

рекомендую, заодно поймёшь откуда функциональщина вообще взялась

чувак который у меня преподавал хаскель

в универе

и которому яодин из немногих сдал на отл экзамен

щас про плюсы

слушаю внимательно)

https://stepic.org/course/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5-%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BD%D0%B0-%D1%8F%D0%B7%D1%8B%D0%BA%D0%B5-Haskell-75/syllabus

вот его курс ещё

а степик это проект универа в котором я учился :3

энивей, про плюсы.

https://stepic.org/course/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5-%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BD%D0%B0-%D1%8F%D0%B7%D1%8B%D0%BA%D0%B5-Haskell-75/syllabus

спасибо как нибудь гляну

void foo(int arg1, bool arg2) { if(arg2) { arg1++; } }

вот здесь вызов foo(x*x , false);

Я прошёл, не жалею, на многое глаза открываются)

будет вычислять x*x в любом случае

потом записывать на стек это значение и вызывать foo

аналогичный код в хаскеле

не будет вычислять x*x

@Doaxan, откуда ты вообще эту ленивость взял?

обычно про неё особо не знают пока хаскель не потрогают

он сначала зайдет в foo()

увидит, что arg2 == false

@Doaxan, откуда ты вообще эту ленивость взял?

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

и забъет на вычисление первого аргумента, который равен x*x

и забъет на вычисление первого аргумента, который равен x*x

хмм, а в плюсах не забьет?

Мы говорим про рантайм.

foo(x*x , y);

y заранее неизвестно

плюсы всегда вычислят x*x