Я только не понял - это про него или про меня? :))))

лол про него)

всегда думал, что в сишарпе нет оптимизации хвостовой рекурсии например, let rec odd x = if x = 0 then false else even <| x - 1 and even x = if x = 0 then true else odd <| x - 1 public static class _ { public static bool odd(int x) { if (x == 0) return false; return even(x - 1); } public static bool even(int x) { if (x == 0) return true; return odd(x - 1); } } генерят одинаковый асм код _.odd(Int32) L0000: push ebp L0001: mov ebp, esp L0003: test ecx, ecx L0005: jnz L000b L0007: xor eax, eax L0009: pop ebp L000a: ret L000b: dec ecx L000c: jnz L0015 L000e: mov eax, 0x1 L0013: jmp L001c L0015: dec ecx L0016: call dword [0x1d141f44] L001c: pop ebp L001d: ret _.even(Int32) L0000: test ecx, ecx L0002: jnz L000a L0004: mov eax, 0x1 L0009: ret L000a: dec ecx L000b: call _.odd(Int32) L0010: ret

в чем подвох?

ну это же хорошо, не7

да, хорошо

просто неожиданно

притом в фшарпоском ил-коде есть инструкция tail. - в общем, только в этом отличие между сишарповским и фшарповским кодом

чет не похоже на оптимизацию то

возможно

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

в чем подвох?

в том что это не C#

оптимизация хвостовой рекурсии делается джитом

для callvirt + ret call + ret call + pop + ret callvirt + pop +ret патернов

ИЛИ она может делаться через tail команду

что не умеет C#, а умеет F#

F# компилятор явно эмитит команду для джита - сделай здесь хвостовую рекурсию

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

а tail обязан.

А багу про тейл кол и ноп поправили?

А багу про тейл кол и ноп поправили?

Нет)

Гопак должен страдать

Я свой ишью очень общо назвал - nop в релиз коде

убрать конкретно этот nop перед ret ИЗИ

а убрать все прочие нопы - тяжко

для callvirt + ret call + ret call + pop + ret callvirt + pop +ret патернов

call bool _::even(int32) IL_000d: ret } // end of method _::odd - оптимизирует?

call bool _::even(int32) IL_000d: ret } // end of method _::odd - оптимизирует?

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

да, должен

ну как должен

МОЖЕТ

должен он только в случае tail оптимизировать

да я с щарплаба дергаю

был бы там tail call ret

это для сишарповкого кода

был бы там tail call ret

а для фшапровского так, да

Сишарп нихуя не делает для хвостовой рекурсии, поэтому её в языке нет

то что она внезапно иногда джитом оптимизируется - на это нельзя полагаться

это чисто его приколы

понятно

но

Сишарп нихуя не делает для хвостовой рекурсии, поэтому её в языке нет

а что должен сишарп делать для хвостовой рекурсии?

просто, для нее особо ничего не надо делать

ща найду

а что должен сишарп делать для хвостовой рекурсии?

определять её на уровне распарса AST в IL и эмтить tail команду для джита

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

просто, для нее особо ничего не надо делать

её надо ДЕТЕКТИТЬ

я сделал выводы отсюда, Джеральд Джей Сассман и Гай Льюис Стил мл. (см. Steele 1975) построили интерпретатор Scheme с поддержкой хвостовой рекурсии. Позднее Стил показал, что хвостовая рекурсия является следствием естественного способа компиляции вызовов процедур (Steele 1977).

занятно. версия let rec odd2 x = match x with 0 -> false | _ -> even2 <| x - 1 and even2 x = match x with 0 -> true | _ -> odd2 <| x - 1 рожает не такой шизофренический код

т.е. компилятор должен понять - ага, здесь вызов функции внутри самой функции и он последний! А давай-ка сделаем здесь хвостовую рекурсию. Для этого у нас есть железобетонное обещание от джита что если я перед call дам ему команду tail, то он её оптимизнёт

_.odd2(Int32) L0000: test ecx, ecx L0002: jz L000c L0004: dec ecx L0005: call dword [0x19d01f68] L000b: ret L000c: xor eax, eax L000e: ret _.even2(Int32) L0000: test ecx, ecx L0002: jz L000b L0004: dec ecx L0005: call _.odd2(Int32) L000a: ret L000b: mov eax, 0x1 L0010: ret

я давно замечал что мачи более адекватные

забавно)

я давно замечал что мачи более адекватные

кстати, вот

а убрать все прочие нопы - тяжко

ты им свои исправленные скинь хотя бы)

это уже похоже на правду

ты им свои исправленные скинь хотя бы)

Да там исправлений-то, -2 строчки и все исправления

ну скинь

ну пап

Ну лан

Сегодня обещаю что скину

не работать же на работе

так что как и раньше рекомендую забить на if

let nu1 (x : obj) = match x with null -> false | _ -> true let nu2 (x : obj) = x <> null

_.nu1(System.Object) L0000: test ecx, ecx L0002: jz L000a L0004: mov eax, 0x1 L0009: ret L000a: xor eax, eax L000c: ret _.nu2(System.Object) L0000: push 0x1ac6ec5c L0005: xor edx, edx L0007: call dword [0x1ac6ec30] L000d: test eax, eax L000f: setz al L0012: movzx eax, al L0015: ret

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

Ну, надо заметить, в лямбда-счислении есть вариант редукции, который связан с ленивыми вычислениями

Точно так же в нём и композицию изи сделать, да

и как оказалось в последствии - типы пришпандорить вообще в два счёта

но это не является необходимостью для определения лямбд

Ленивость круто иметь как инструмент. То что у нас lazy "замораживает" вычисления - это очень круто. Можно почти как на хаскеле писать, с амортизированной сложностью

не умеет linq в туплы

В туплы не умеет не linq а провайдеры linq для баз данных

В туплы не умеет не linq а провайдеры linq для баз данных

Ну да, какой-то конкретный провайдер для конкретной БД :)

Ленивость круто иметь как инструмент. То что у нас lazy "замораживает" вычисления - это очень круто. Можно почти как на хаскеле писать, с амортизированной сложностью

даже неожиданно > let mutable i = 4;; val mutable i : int = 4 > let l = lazy i;; val l : Lazy<int> = Value is not created. > i <- 10;; val it : unit = () > l.Value;; val it : int = 10

даже неожиданно > let mutable i = 4;; val mutable i : int = 4 > let l = lazy i;; val l : Lazy<int> = Value is not created. > i <- 10;; val it : unit = () > l.Value;; val it : int = 10

Ты лучше попробуй с сайд эффектом lazy printf "1"

Вообще космос

это то я видел

я вот что мутабельное заполнение отложится не ожидал

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

И мемоизируются!

Ну да, какой-то конкретный провайдер для конкретной БД :)

И есть маза тот же linq2db в них научить

И гарантированно один раз вычисляются