Чи може чисто функціональне рішення цієї проблеми бути таким же чистим, як і імператив?

У мене вправа в Python наступна:

• поліном задається у вигляді множини коефіцієнтів, таким чином, що потужність визначається за показниками, наприклад: (9,7,5) означає 9 + 7 * x + 5 * x ^ 2

• написати функцію для обчислення її значення для заданого x

Оскільки я останнім часом займаюся функціональним програмуванням, я писав

def evaluate1(poly, x):
  coeff = 0
  power = 1
  return reduce(lambda accu,pair : accu + pair[coeff] * x**pair[power],
                map(lambda x,y:(x,y), poly, range(len(poly))),
                0)

що я вважаю нечитабельним, тому написав

def evaluate2(poly, x):
  power = 0
  result = 1
  return reduce(lambda accu,coeff : (accu[power]+1, accu[result] + coeff * x**accu[power]),
                poly,
                (0,0)
               )[result]

що принаймні як нечитабельне, так я написав

def evaluate3(poly, x):
  return poly[0]+x*evaluate(poly[1:],x) if len(poly)>0 else 0

що може бути менш ефективним (редагувати: я помилявся!), оскільки він використовує безліч множень замість експоненції, в принципі мені тут не байдуже вимірювання (редагувати: Як глупо! все ще не настільки читабельні (можливо), як ітераційне рішення:

def evaluate4(poly, x):
  result = 0
  for i in range(0,len(poly)):
      result += poly[i] * x**i
  return result

Чи є чисте функціональне рішення таке читабельне, як імперативне і близьке до нього за ефективністю?

Щоправда, зміна представництва допоможе, але це було надано вправою.

Це може бути Хаскелл або Лісп, а не лише Пітон.

Метод Хорнера, ймовірно, більш обчислювально ефективний, як вказує @delnan, але я б назвав це досить читабельним в Python для рішення експоненції:

def eval_poly(poly, x):
    return sum( [a * x**i for i,a in enumerate(poly)] )

У багатьох функціональних мовах є виконання карт, які дозволяють вам індексувати через карту. Поєднайте це із сумою, і у вас є наступне на F #:

let compute coefficients x = 
    coefficients 
        |> Seq.mapi (fun i c -> c * Math.Pow(x, (float)i))
        |> Seq.sum

Я не розумію, як ваш код стосується визначеної вами задачі, тому я наведу свою версію того, що ваш код ігнорує область проблеми (на основі імперативного коду, який ви написали).

Досить читабельний haskell (такий підхід можна легко перекласти на будь-яку мову FP, яка має руйнування списку і виходить чистою та читаною):

eval acc exp val [] = acc
eval acc exp val (x:xs) = eval (acc + execPoly) (exp+1) xs
  where execPoly = x * (val^exp)

Іноді наївний простий підхід у подібному хаскелі чистіший, ніж більш стислий підхід до людей, менш звикших до ПП.

Більш чітко необхідний підхід, який все ще є абсолютно чистим:

steval val poly = runST $ do
  accAndExp <- newSTRef (0,1)
  forM_ poly $ \x -> do
    modifySTRef accAndExp (updateAccAndExp x)
  readSTRef accAndExp
  where updateAccAndExp x (acc, exp) = (acc + x*(val^exp), exp + 1)

бонус до другого підходу полягає в тому, що в монаді СТ він буде працювати дуже добре.

Хоча для певності, найбільш вірогідною реальною реалізацією від Haskeller буде zipwith, згаданий в іншій відповіді вище. zipWithце дуже типовий підхід, і я вважаю, що Python може імітувати підхід блискавки комбінування функцій та індексатора, який можна відобразити на карті.

Якщо у вас просто є (фіксований) кортеж, чому б не зробити цього (в Haskell):

evalPolyTuple (c, b, a) x = c + b*x + a*x^2

Якщо замість цього у вас є список коефіцієнтів, ви можете використовувати:

evalPolyList coefs x = sum $ zipWith (\c p -> c*x^p) coefs [0..]

або зі зменшенням, як у вас було:

evalPolyList' coefs x = foldl' (\sum (c, p) -> sum + c*x^p) 0 $ zip coefs [0..]

Існує загальний набір кроків, які можна використовувати для поліпшення читабельності функціональних алгоритмів:

• Поставте імена на проміжні результати, замість того, щоб намагатися втиснути все в один рядок.
• Використовуйте іменовані функції замість лямбда, особливо в мовах із багатослівним синтаксисом лямбда. Набагато простіше читати щось на кшталт, evaluateTermніж довгий лямбдаський вираз. Тільки тому, що ви можете використовувати лямбда, не обов'язково означає, що вам слід .
• Якщо одна з названих вами тепер функцій виглядає як щось, що з’являється досить часто, швидше за все, це вже в стандартній бібліотеці. Подивись навколо. Мій пітон трохи іржавий, але схоже, що ви в основному винаходили enumerateабо zipWith.
• Часто перегляд названих функцій та проміжних результатів полегшує міркування про те, що відбувається, і спрощення його, і в цей момент може бути доцільним повернути лямбда назад або об'єднати деякі рядки назад.
• Якщо імператив для циклу виглядає більш читабельним, шанси на розуміння спрацюють добре.