MP
В джаваскриптовых программах, по моим наблюдениям, лямбды используют чаще, чем в питоне.
Size: a a a
2019 November 14
PS
так-так, интересно. как это работает?
Нельзя, например, написать lambda x: y = 0 :)
YS
Нельзя, например, написать lambda x: y = 0 :)
можно иначе ту же семантику, будет чуть длиннее
PS
можно иначе ту же семантику, будет чуть длиннее
Главное, что разработчика побуждают перейти на expression-стиль кода в lambda :)
YS
Главное, что разработчика побуждают перейти на expression-стиль кода в lambda :)
наоборот, побуждают не трогать лямбды
PS
У меня в коде на Питоне сплошные лямбды!
YS
У меня в коде на Питоне сплошные лямбды!
вы стойкий питонист!
PS
rules = innermost(alt(
rule(Add(C, D), to(lambda v: Int(v.C + v.D))),
rule(Sub(C, D), to(lambda v: Int(v.C - v.D))),
rule(Mul(C, D), to(lambda v: Int(v.C * v.D))),
rule(Neg(C), to(lambda v: Int(-v.C))),
rule(Cmul(Int(1), X), to(lambda v: v.X)),
rule(Cmul(Int(-1), X), to(lambda v: Neg(v.X))),
rule(Sub(X, C), to(lambda v: Add(v.X, Int(-v.C)))),
rule(Cadd(Cmul(X, Y), Cmul(X, Z)), to(lambda v: Mul(v.X, Add(v.Y, v.Z)))),
rule(Sub(Cmul(X, Y), Cmul(X, Z)), to(lambda v: Mul(v.X, Sub(v.Y, v.Z)))),
rule(Cadd(Int(0), X), to(lambda v: v.X)),
rule(Sub(X, X), to(lambda v: Int(0))),
rule(Cmul(Int(0), X), to(lambda v: Int(0))),
rule(Neg(Sub(X, Y)), to(lambda v: Sub(v.Y, v.X))),
rule(Cadd(X, Cadd(C, Y)), to(lambda v: Add(Int(v.C), Add(v.X, v.Y)))),
rule(Cadd(X, Sub(C, Y)), to(lambda v: Add(Int(v.C), Sub(v.X, v.Y)))),
rule(Cadd(X, Sub(Y, C)), to(lambda v: Sub(Add(v.X, v.Y), Int(v.C)))),
rule(Cadd(X, Sub(C, Y)), to(lambda v: Sub(Sub(v.X, v.Y), Int(v.C)))),
rule(Cadd(X, Sub(Y, C)), to(lambda v: Add(Int(v.C), Sub(v.X, v.Y)))),
rule(Cadd(C, Cadd(D, X)), to(lambda v: Add(Int(v.C + v.D), v.X))),
rule(Cadd(C, Sub(D, X)), to(lambda v: Sub(Int(v.C + v.D), v.X))),
rule(Cadd(C, Sub(X, D)), to(lambda v: Add(Int(v.C - v.D), v.X))),
rule(Sub(C, Sub(X, D)), to(lambda v: Sub(Int(v.C + v.D), v.X))),
rule(Sub(C, Sub(D, X)), to(lambda v: Add(Int(v.C - v.D), v.X))),
rule(Cmul(C, Cmul(D, X)), to(lambda v: Mul(Int(v.C * v.D), v.X)))
))PS
Вот вам немножко лямбд :)
YS
rules = innermost(alt(
rule(Add(C, D), to(lambda v: Int(v.C + v.D))),
rule(Sub(C, D), to(lambda v: Int(v.C - v.D))),
rule(Mul(C, D), to(lambda v: Int(v.C * v.D))),
rule(Neg(C), to(lambda v: Int(-v.C))),
rule(Cmul(Int(1), X), to(lambda v: v.X)),
rule(Cmul(Int(-1), X), to(lambda v: Neg(v.X))),
rule(Sub(X, C), to(lambda v: Add(v.X, Int(-v.C)))),
rule(Cadd(Cmul(X, Y), Cmul(X, Z)), to(lambda v: Mul(v.X, Add(v.Y, v.Z)))),
rule(Sub(Cmul(X, Y), Cmul(X, Z)), to(lambda v: Mul(v.X, Sub(v.Y, v.Z)))),
rule(Cadd(Int(0), X), to(lambda v: v.X)),
rule(Sub(X, X), to(lambda v: Int(0))),
rule(Cmul(Int(0), X), to(lambda v: Int(0))),
rule(Neg(Sub(X, Y)), to(lambda v: Sub(v.Y, v.X))),
rule(Cadd(X, Cadd(C, Y)), to(lambda v: Add(Int(v.C), Add(v.X, v.Y)))),
rule(Cadd(X, Sub(C, Y)), to(lambda v: Add(Int(v.C), Sub(v.X, v.Y)))),
rule(Cadd(X, Sub(Y, C)), to(lambda v: Sub(Add(v.X, v.Y), Int(v.C)))),
rule(Cadd(X, Sub(C, Y)), to(lambda v: Sub(Sub(v.X, v.Y), Int(v.C)))),
rule(Cadd(X, Sub(Y, C)), to(lambda v: Add(Int(v.C), Sub(v.X, v.Y)))),
rule(Cadd(C, Cadd(D, X)), to(lambda v: Add(Int(v.C + v.D), v.X))),
rule(Cadd(C, Sub(D, X)), to(lambda v: Sub(Int(v.C + v.D), v.X))),
rule(Cadd(C, Sub(X, D)), to(lambda v: Add(Int(v.C - v.D), v.X))),
rule(Sub(C, Sub(X, D)), to(lambda v: Sub(Int(v.C + v.D), v.X))),
rule(Sub(C, Sub(D, X)), to(lambda v: Add(Int(v.C - v.D), v.X))),
rule(Cmul(C, Cmul(D, X)), to(lambda v: Mul(Int(v.C * v.D), v.X)))
))зачем rule to повторять, если можно списком пар или даже словариком задать?
PS
зачем rule to повторять, если можно списком пар или даже словариком задать?
А это комбинаторы. То есть это небольшой eDSL, возможности которого простираются за пределы обычного сопоставления с образцом. Там есть локальный откат и first class pattern matching и проч.
YS
rules = innermost(alt(
rule(Add(C, D), to(lambda v: Int(v.C + v.D))),
rule(Sub(C, D), to(lambda v: Int(v.C - v.D))),
rule(Mul(C, D), to(lambda v: Int(v.C * v.D))),
rule(Neg(C), to(lambda v: Int(-v.C))),
rule(Cmul(Int(1), X), to(lambda v: v.X)),
rule(Cmul(Int(-1), X), to(lambda v: Neg(v.X))),
rule(Sub(X, C), to(lambda v: Add(v.X, Int(-v.C)))),
rule(Cadd(Cmul(X, Y), Cmul(X, Z)), to(lambda v: Mul(v.X, Add(v.Y, v.Z)))),
rule(Sub(Cmul(X, Y), Cmul(X, Z)), to(lambda v: Mul(v.X, Sub(v.Y, v.Z)))),
rule(Cadd(Int(0), X), to(lambda v: v.X)),
rule(Sub(X, X), to(lambda v: Int(0))),
rule(Cmul(Int(0), X), to(lambda v: Int(0))),
rule(Neg(Sub(X, Y)), to(lambda v: Sub(v.Y, v.X))),
rule(Cadd(X, Cadd(C, Y)), to(lambda v: Add(Int(v.C), Add(v.X, v.Y)))),
rule(Cadd(X, Sub(C, Y)), to(lambda v: Add(Int(v.C), Sub(v.X, v.Y)))),
rule(Cadd(X, Sub(Y, C)), to(lambda v: Sub(Add(v.X, v.Y), Int(v.C)))),
rule(Cadd(X, Sub(C, Y)), to(lambda v: Sub(Sub(v.X, v.Y), Int(v.C)))),
rule(Cadd(X, Sub(Y, C)), to(lambda v: Add(Int(v.C), Sub(v.X, v.Y)))),
rule(Cadd(C, Cadd(D, X)), to(lambda v: Add(Int(v.C + v.D), v.X))),
rule(Cadd(C, Sub(D, X)), to(lambda v: Sub(Int(v.C + v.D), v.X))),
rule(Cadd(C, Sub(X, D)), to(lambda v: Add(Int(v.C - v.D), v.X))),
rule(Sub(C, Sub(X, D)), to(lambda v: Sub(Int(v.C + v.D), v.X))),
rule(Sub(C, Sub(D, X)), to(lambda v: Add(Int(v.C - v.D), v.X))),
rule(Cmul(C, Cmul(D, X)), to(lambda v: Mul(Int(v.C * v.D), v.X)))
))ох, столько скобок, тяжело читать после Хаскеля. как вы с таким тяжёлым синтаксисом живёте?
PS
ох, столько скобок, тяжело читать после Хаскеля. как вы с таким тяжёлым синтаксисом живёте?
А, кстати говоря, в Haskell виденные мной реализации Stratego (чем, собственно, я вдохновлялся) чуть ли не менее читаемые!
PS
(традиционно, все заканчивается примером fib %)
AP
Некоторые запреты Питон как раз делают в большей степени ФП-языком, чем какой-нибудь JS. Например, это касается запрета на использование блока в lambda.
lambda x: (
y := x + 1,
z := y * 2,
w := str(input()),
w + z + y
)[-1]AP
Многострочные лямбды. Теперь и в питоне
AP
Как можно говорить о ФП в языке, где теперь "присваивание как выражение" есть?
PS
Да, это была плохая идея.