Оно типа правоассоциативное То есть запись вида lazy f a Будет читаться как lazy (f a)

Я никогда не понимал твою нелюбовь к скобочкам

^fun - вот это всё

И что самое крутое, все что справа от lazy вообще проигнорится компилятором даже если там явно вычисленное выражение. Например, обычное поведение f : unit -> unit f (printf "1") Вызовет рассчёт аргумента, то есть печать в консоль, потом уже вызовет функцию. lazy f (printf "1") Принтф не вызовется

^fun - вот это всё

Может у человека лисп травма

Я никогда не понимал твою нелюбовь к скобочкам

Тут другое. В языке оказывается есть честный лейзи лоадинг.

То есть он настолько честный что даже особым образом компилятор останавливает

Оно небось в лямбду какую неявную заворачивается

Оно небось в лямбду какую неявную заворачивается

Это не так важно, ты такого поведения не добьешься никак руками

?

Якобы равноценная замена let inline myLazy arg = fun () -> arg myLazy (printf "1")

Но она не работает

Не смотря на инлайн

Не смотря на инлайн

С приездом

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

С приездом

Спасибо!

@AnutaU https://twitter.com/mvsmal/status/1089238275775254529?s=19

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

Равноценная замена - аргумент в лямбду завернуть

@Dolfik акка нинужна

Не?

Равноценная замена - аргумент в лямбду завернуть

Ну я завернул выше

@Dolfik акка нинужна

Нормально же общались :)

@Dolfik акка нинужна

абаснуй

Не?

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

@AnutaU https://twitter.com/mvsmal/status/1089238275775254529?s=19

То есть единственный выход писать ебучую лямбду, инлайн делать руками) А вот магию с лейзи может только ключевое слово lazy

myLazy f = f (fun () -> printfn 1)

Потому и говорю что оно очень особое, его нельзя повторить

myLazy f = f (fun () -> printfn 1)

Ты сделал инлайн лямбды ручками

Сделать f (printf "1") чтобы он не вычислял аргумент может только lazy

Нуок :)

Нуок :)

Это же очень круто!!! Ты не оценил! Оно же с мемоизацией5!!!

myLazy f = f (fun () -> printfn 1)

Вроде ж правильно. Чтобы сделать принт, надо вызвать переданный аргумент

Внутри f

Вроде ж правильно. Чтобы сделать принт, надо вызвать переданный аргумент

Тут передается функция только без аргумента же. Аргумент как-то вшит магически в myLazy)

Я начал читать «Concurrency in .net»

это где он из тасок монады делает?

А ну-ка сделайте так чтобы передаваемый сюда arg не был вычислен let myLazy f arg = ...

И верните ленивое, мемоизируемое вычисление

И верните ленивое, мемоизируемое вычисление

Лень!

это где он из тасок монады делает?

Не дочитал до этого

Про мемоизацию сначала речь не шла!

Про мемоизацию сначала речь не шла!

Да хотя бы лейзи!

Но мемоизация это ещё один бонус да. Огромный

Да хотя бы лейзи!

Я вообще в троллейбусе еду!

Тут передается функция только без аргумента же. Аргумент как-то вшит магически в myLazy)

Ну так небось и вшит через лямбду и внутренний лет. Вот и мемоизация.

Я вообще в троллейбусе еду!

В троллейбусе зимой холодно :(

В троллейбусе зимой холодно :(

Мой поинт в том что написать руками функцию которая не напечатает 1 в консоли как в примере ниже нельзя lazy printf "1"

Там же резалт надо форсить. А что это как не вызов этой неявной лямбды?

Там же резалт надо форсить. А что это как не вызов этой неявной лямбды?

Ну в целом там через класс Lazy из обычного дотнета реализовано

Да, я тоже за то, что внутри там может быть валенок!

Но это детали имплементации

Там же резалт надо форсить. А что это как не вызов этой неявной лямбды?

Можно патерн матчить!

Не дочитал до этого

вот эта главка

@omgszer говорил что за такое надо давать лещей )

вот эта главка

Я в середине первой только. До 7-й ещё недели две :(

let inline force (l: Lazy<_>) = l.Force() let (|Lazy|) = force let l = lazy Some 1 match l with | Lazy None -> ... | Lazy (Some _) -> ... //Здесь уже не будет вычисления лейзи так как мемоизация

let inline force (l: Lazy<_>) = l.Force() let (|Lazy|) = force let l = lazy Some 1 match l with | Lazy None -> ... | Lazy (Some _) -> ... //Здесь уже не будет вычисления лейзи так как мемоизация

Эрик на тебя плохо влияет

Не, так плохо, надо по адресам общаться. АкторРефы должны у родителя сидеть

А родитель их должен передавать?

Эрик на тебя плохо влияет

А прикинь что будет когда я на работу выйду!!1

Или вообще не трогать

let inline force (l: Lazy<_>) = l.Force() let (|Lazy|) = force let l = lazy Some 1 match l with | Lazy None -> ... | Lazy (Some _) -> ... //Здесь уже не будет вычисления лейзи так как мемоизация

в чем поинт лишнего патерна?

в чем поинт лишнего патерна?

Удобство при работе с лейзи структурами

Например отложенные списки (стримы)

А прикинь что будет когда я на работу выйду!!1

Завтра?

Завтра?

В пн

О! Тебе дали неделю на дегустацию?

Удобство при работе с лейзи структурами

match l.Value with | None -> ... | Some _ -> ... //Здесь уже не будет вычисления не?

О! Тебе дали неделю на дегустацию?

Ну да

match l.Value with | None -> ... | Some _ -> ... //Здесь уже не будет вычисления не?

Не будет, но тогда уже не получится матчить через ключевое слово function!

К тому же у тебя может быть наоборот

ок

match opt with | Some (Lazy 1) -> ...

И сразу засада

А патерн матчинг справляется

И ещё, можно сразу в функциях лейзи раскладывать

Короче от такого патерна пользы сильно дохуя

хотя some от lazy дичью отдает

хотя some от lazy дичью отдает

Отложенный список.