Global state can be hard to reason about, but piping dependencies from function to function is a pain. With implicits, you explicitly annotate which function parameters are implicit dependencies, and these parameters are passed as arguments automatically when you call the function! All that's required is that there exists local variables in scope that match the names of the implicits.
@implicits("current_user")
def create_task(title, *, current_user):
print(f"{current_user} created a task titled '{title}'")
current_user = "Jaden"
create_task("Hooray, a task!") # Jaden created a task titled 'Hooray, a task!'
create_task("Buy some trackpants") # Jaden created a task titled 'Buy some trackpants'- Install via
pip install implicits. - Import with
from implicits import implicits. - Decorate using
@implicits("names", "of", "implicit", "parameters").
import logging
import boto3
from implicits import implicits
class Giraffe:
@implicits("logger")
def __init__(self, name, *, logger):
self.name = name
logger.info(f"Creating a Giraffe named {name}")
@property
@implicits("logger")
def full_name(self, *, logger):
logger.info(f"Getting {self.name}'s full name")
return f"{self.name} the Giraffe"
@property
@implicits("food")
def is_hungry(self, *, food):
return "leaves" in food
@implicits("logger")
def main(*, logger):
jeff = Giraffe("Jeff") # Creating a Giraffe named Jeff
name = jeff.full_name # Getting Jeff's full name
food = ["rocks", "dirt"]
logger.info(jeff.is_hungry) # False
food.append("leaves")
logger.info(jeff.is_hungry) # True
logger = logging.getLogger()
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler())
main()I didn't invent this idea! Quite a few other languages support implicit parameters. The most mainstream of these languages is Scala. Check out how implicits work in Scala!