Liking cljdoc? Tell your friends :D

Effuse

A Clojure library designed to handle Dependancy Injection through mimicing Alegbraic Effects.

Warnings

This library is still in alpha. That means the core API can be changed at anytime.

Laziness, higher-order functions and threads might do not work properly because of the implementation using ^:dynamic and binding. You are expected to make all results eager before existing handle. bound-fn and bound-fn* could be useful.

This library was inspired from https://lilac.town/writing/effects-in-clojure/ and https://github.com/clojureman/special

Installation

Leiningen dependencies:

[effuse       "0.0.1"]

Usage

(def effects-config
    {
        :save-data (partial spit "temp.txt") 
    })

(defn do-stuff []
  (->> 
    "test"
    (perform :save-data)))

(defn do-stuff-handled (handle do-stuff effects-config))

;; Saves to "temp.txt"
(do-stuff-handled)

Why?

Algebraic effects have a lot of cool features like continuations or being able to go down multiple branches at once. However, what interested me in them is that effectively they make Dependency Injection into a language construct.

Dependency Injection is broadly composed of two parts

Lifecycle/State Management
Implementation Injection

This framework focuses on Implementation Injection and NOT state management. Libraries like

Effuse has the following immediate goals...

Exploration of Alegrbaic Effect like system for state management and side effects
Minimall API - Two main functions handle and perform.
Context/Scope aware - The context of how a function was called is relevant to how an effect happens.
No default implementation for perform - This is more a stylistic choice than a this-is-better choice. For you to call a function that uses perform you must handle what that effect does. Also makes it obvious if laziness is causing an issue.
Run time configurable - Implied by the Context-awareness but listed here for explicitness

...and the following long-term goals...

Use of Spec to validate effects are managed
Minimally invasive - Should be similar to how most Clojure code is written. This is not totally true because of the lazy and other issues mentioned above.
Support Laziness
Support higher-order functions