kopia lustrzana https://github.com/peterhinch/micropython-samples
131 wiersze
3.9 KiB
Markdown
131 wiersze
3.9 KiB
Markdown
# Singletons and Functors
|
|
|
|
These closely related concepts describe classes which support only a single
|
|
instance. They share a common purpose of avoiding the need for global data by
|
|
providing a callable capable of retaining state and whose scope may be that of
|
|
the module.
|
|
|
|
In both cases implementation is via very similar class decorators.
|
|
|
|
# Singleton class decorator
|
|
|
|
A singleton is a class with only one instance. Some IT gurus argue against them
|
|
on the grounds that project aims can change: a need for multiple instances may
|
|
arise later. My view is that they have merit in defining interfaces to hardware
|
|
objects. You might be quite certain that your brometer will have only one
|
|
pressure sensor.
|
|
|
|
The advantage of a singleton is that it removes the need for a global instance
|
|
or for passing an instance between functions. The sole instance is efficiently
|
|
retrieved at any point in the code using function call syntax.
|
|
|
|
```python
|
|
def singleton(cls):
|
|
instance = None
|
|
def getinstance(*args, **kwargs):
|
|
nonlocal instance
|
|
if instance is None:
|
|
instance = cls(*args, **kwargs)
|
|
return instance
|
|
return getinstance
|
|
|
|
@singleton
|
|
class MySingleton:
|
|
def __init__(self, arg):
|
|
self.state = arg
|
|
print('In __init__', arg)
|
|
|
|
def foo(self, arg):
|
|
print('In foo', arg + self.state)
|
|
|
|
ms = MySingleton(42) # prints 'In __init__ 42'
|
|
x = MySingleton() # No output: assign existing instance to x
|
|
x.foo(5) # prints 'In foo 47': original state + 5
|
|
```
|
|
The first call instantiates the object and sets its initial state. Subsequent
|
|
calls retrieve the original object.
|
|
|
|
There are other ways of achieving singletons. One is to define a (notionally
|
|
private) class in a module. The module API contains an access function. There
|
|
is a private instance, initially `None`. The function checks if the instance is
|
|
`None`. If so it instantiates the object and assigns it to the instance. In all
|
|
cases it returns the instance.
|
|
|
|
Both have similar logic. The decorator avoids the need for a separate module.
|
|
|
|
# Functor class decorator
|
|
|
|
The term "functor" derives from "function constructor". It is a function-like
|
|
object which can retain state. Like singletons the aim is to avoid globals: the
|
|
state is contained in the functor instance.
|
|
|
|
```python
|
|
def functor(cls):
|
|
instance = None
|
|
def getinstance(*args, **kwargs):
|
|
nonlocal instance
|
|
if instance is None:
|
|
instance = cls(*args, **kwargs)
|
|
return instance
|
|
return instance(*args, **kwargs)
|
|
return getinstance
|
|
|
|
@functor
|
|
class MyFunctor:
|
|
def __init__(self, arg):
|
|
self.state = arg
|
|
print('In __init__', arg)
|
|
|
|
def __call__(self, arg):
|
|
print('In __call__', arg + self.state)
|
|
|
|
MyFunctor(42) # prints 'In __init__ 42'
|
|
MyFunctor(5) # 'In __call__ 47'
|
|
```
|
|
A use case is in asynchronous programming. The constructor launches a
|
|
continuously running task. Subsequent calls alter the behaviour of that task.
|
|
The following simple example has the task waiting for a period which can be
|
|
changed at runtime:
|
|
|
|
```python
|
|
import uasyncio as asyncio
|
|
import pyb
|
|
|
|
def functor(cls):
|
|
instance = None
|
|
def getinstance(*args, **kwargs):
|
|
nonlocal instance
|
|
if instance is None:
|
|
instance = cls(*args, **kwargs)
|
|
return instance
|
|
return instance(*args, **kwargs)
|
|
return getinstance
|
|
|
|
@functor
|
|
class FooFunctor:
|
|
def __init__(self, led, interval):
|
|
self.led = led
|
|
self.interval = interval
|
|
asyncio.create_task(self._run())
|
|
|
|
def __call__(self, interval):
|
|
self.interval = interval
|
|
|
|
async def _run(self):
|
|
while True:
|
|
await asyncio.sleep_ms(self.interval)
|
|
# Do something useful here
|
|
self.led.toggle()
|
|
|
|
def go_fast(): # FooFunctor is available anywhere in this module
|
|
FooFunctor(100)
|
|
|
|
async def main():
|
|
FooFunctor(pyb.LED(1), 500)
|
|
await asyncio.sleep(3)
|
|
go_fast()
|
|
await asyncio.sleep(3)
|
|
|
|
asyncio.run(main())
|
|
```
|