O que exatamente se entende por "função parcial" na programação funcional?

De acordo com meu entendimento, funções parciais são funções que obtemos ao passar menos parâmetros para uma função do que o esperado. Por exemplo, se isso fosse diretamente válido em Python:

>>> def add(x,y):
...    return x+y
... 
>>> new_function = add(1)
>>> new_function(2)
3

No trecho de código acima, new_functioné uma função parcial. No entanto, de acordo com o Wiki de Haskell , a definição de função parcial é

Uma função parcial é uma função que não está definida para todos os argumentos possíveis do tipo especificado.

então, minha pergunta é: o que exatamente se entende por "função parcial"?

Você está aqui confundindo dois conceitos. Uma função parcialmente aplicada [haskell-wiki] com uma função parcial [haskell-wiki] .

Uma função parcialmente aplicada é:

A aplicação parcial no Haskell envolve passar menos do que o número total de argumentos para uma função que recebe vários argumentos.

considerando que uma função parcial é de fato uma função não total:

Uma função parcial é uma função que não está definida para todos os argumentos possíveis do tipo especificado.

Uma função parcial (tanto no contexto da programação funcional quanto da matemática) é exatamente o que o wiki diz: uma função não definida para todos os seus argumentos possíveis. No contexto da programação, geralmente interpretamos "não definido" como uma das várias coisas, incluindo comportamento indefinido, exceções ou não-encerramento.

Um exemplo de uma função parcial seria a divisão inteira, que não é definida se o divisor for 0 (em Haskell, ocorrerá um erro).

no snippet acima, new_function é uma função parcial.

Esse código simplesmente causaria um erro no Python, mas se funcionasse como você pretendia, seria uma função total (ou seja, não parcial).

Como os comentaristas já apontaram, é mais provável que você pense no fato de que seria uma função parcialmente aplicada .

As respostas explicam tudo, vou apenas adicionar um exemplo em cada idioma:

def add(x,y):
    return x+y

f = add(1)
print(f(3))

    f = add(1)
TypeError: add() missing 1 required positional argument: 'y'

isso não é uma função parcial nem uma função ao curry , é apenas uma função que você não forneceu todos os seus argumentos .

Uma função ao curry em python deve ser assim:

partialAdd= lambda x: lambda y: x + y

plusOne = partialAdd(1)
print(plusOne(3))

4

e em haskell:

plus :: Int -> Int -> Int
plus x y = x + y

plusOne = plus 1

plusOne 4

5

Uma função parcial em python:

def first(ls):
    return ls[0]

print(first([2,4,5]))
print(first([]))

resultado

2

print(first([]))
  File "main.py", line 2, in first
    return ls[0]
IndexError: list index out of range

E em Haskell, como o seu link apareceu:

head [1,2,3]
3

head []
*** Exception: Prelude.head: empty list

Então, o que é uma função total?

Bem, basicamente o oposto: esta é uma função que funcionará para qualquer entrada desse tipo. Aqui está um exemplo em python:

def addElem(xs, x):
  xs.append(x)
  return xs

e isso funciona mesmo para listas infinitas, se você usar um pequeno truque:

def infiniList():
    count = 0
    ls = []
    while True:
        yield ls
        count += 1
        ls.append(count)

ls = infiniList()
for i in range(5):
  rs = next(ls)

print(rs, addElem(rs,6))

[1, 2, 3, 4]
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5]

E o equivalente em Haskell:

addElem :: a -> [a] -> [a]
addElem x xs = x : xs

addElem 3 (take 10 [1..])
=> [3,1,2,3,4,5,6,7,8,9,10]

Aqui as funções não ficam para sempre. O conceito é o mesmo: para cada lista a função funcionará.