Mfcttrf

According to my understanding, partial functions are functions that we get by passing fewer parameters to a function than expected. For example, in Python:

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

>> new_function = add(1)
>> new_function(2)
>> 3

In the snippet above, new_function is a partial function. However, according to the Haskell Wiki, the definition of partial function is

A partial function is a function that is not defined for all possible arguments of the specified type.

so, my question is: what exactly is meant by "partial function"?

You are here confusing two concepts. A partially applied function [haskell-wiki] with a partial function [haskell-wiki].

A partially applied function is:

Partial application in Haskell involves passing less than the full number of arguments to a function that takes multiple arguments.

whereas a partial function indeed is a non-total function:

A partial function is a function that is not defined for all possible arguments of the specified type.

A partial function (both in the context of functional programming and mathematics) is exactly what the wiki says: a function not defined for all of its possible arguments. In the context of programming, we usually interpret "not defined" as one of several things, including undefined behaviour, exceptions or non-termination.

An example of a partial function would be integer division, which is not defined if the divisor is 0 (in Haskell it will throw an error).

in above snippet new_function is partial function.

That code would simply cause an error in Python, but if it worked as you intended, it would be a total (meaning not partial) function.

As commentors already pointed out, you're most likely thinking of the fact that it'd be a partially applied function.

The answers explain all, I will just add one example in each language:

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

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

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

this is neither a partial function nor a curried function, is a function that you didn't gave all its arguments.

a curried function like in Haskell should be:

partialAdd= lambda x: lambda y: x + y

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

4

and in haskell:

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

plusOne = plus 1

plusOne 4

5

A partial function in python:

def first(ls):
 return ls[0]

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

output

2

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

And in Haskell, as your link showed up:

head [1,2,3]
3

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

So what is a total function?

Well, basically the opposite, is a function that will work for any input of that type, an example in python:

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

and this work even for infinite list, if you make a little trick:

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]

in 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]

That's is for the functions doesn't hangs forever, but the concept is the same, for every list, the function will work.