The technical term for this is a closure. A closure is a first-class* function with some associated state. For example, in Scheme, here is a function which returns counters, each with its own internal ticker:

(define (make-counter)

(let ([internal-variable 0])

 (lambda ()
(begin (set! internal-variable (+ internal-variable 1))
internal-variable))))

To create a counter, you'd do something like

(define counter1 (make-counter 0))

(define counter2 (make-counter 0))

Then, to get values from the counter, you could call something like

(display (counter1))

(display (counter2))

(display (counter2))

(display (counter2))

(display (counter1))

(display (counter2)) which prints: 1, 1, 2, 3, 2, 4.

Here is the same example in Python, since that's what most people seem to be posting in:

def make_counter():

def counter(internal_variable=[0]):

 internal_variable[0] += 1
return internal_variable[0]

return counter

counter1 = make_counter()

counter2 = make_counter()

print(counter1())

print(counter2())

print(counter2())

print(counter2())

print(counter1())

print(counter2())

*That is, a function which you can pass around like a value.