Implicits

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'

Usage

1. Install via pip install implicits.
2. Import with from implicits import implicits.
3. Decorate using @implicits("names", "of", "implicit", "parameters").

Example

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()

References

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!