How to throw a map as an exception in Clojure?

Use Slingshot's `throw+` macro to throw any Clojure map, which will be wrapped in a Throwable via `ex-info`. For example, `(throw+ {:type :error :msg "details"})` allows catching it with a key-value selector like `(catch [:type :error] {:keys [msg]} ...)`.

Slingshot vs standard Clojure exception handling?

Slingshot extends Clojure's native `try` and `throw` with features like throwing non-Throwable objects and flexible catch selectors, while maintaining full compatibility. It's better for complex error handling but adds a dependency and learning curve compared to basic `try`/`catch`.

How to catch exceptions based on keys in Slingshot?

In `try+`, use a key-value vector in the catch clause, e.g., `(catch [:type :error] {:keys [msg]} (log-error msg))`. This matches thrown maps where the key-value pairs align, leveraging Clojure's destructuring for cleaner code.

Does Slingshot work with ClojureScript?

Yes, the README mentions ClojureScript support and ongoing work toward a 1.0 release, indicating compatibility. However, check the latest version or documentation for specific integration details and any limitations in the ClojureScript environment.

How to access stack trace in Slingshot catch clause?

Use the `&throw-context` map in the catch clause, which includes a `:stack-trace` key providing the stack trace for both Throwable and non-Throwable objects. For example, `(log/error (:stack-trace &throw-context))` logs it directly.

What is the else clause in Slingshot try+?

An optional `else` clause in `try+` executes after the try body if no exception was thrown, before any `finally` clause. It's useful for cleanup or logging success, as mentioned in the README's feature list.

slingshot — Enhanced Throw & Catch for Clojure

What is slingshot?

Slingshot is a Clojure library that provides enhanced `try+` and `throw+` macros for more flexible exception handling. It allows developers to throw any Java object (not just `Throwable` instances) and catch exceptions using versatile selectors like class names, key-value vectors, or predicates. This solves the problem of rigid exception handling in Clojure by leveraging the language's features for more expressive error management.

Target Audience

Clojure developers who need more flexible exception handling beyond standard `try`/`catch`, particularly those working with complex error states or integrating with Java code.

Value Proposition

Developers choose Slingshot because it offers full compatibility with Clojure and Java's native exception handling while adding powerful features like throwing arbitrary objects, destructuring in catch clauses, and accessing throw context. Its unique selling point is making exception handling more idiomatic to Clojure without sacrificing interoperability.

Enhanced try and throw for Clojure leveraging Clojure's capabilities

Use Cases

Best For

Throwing Clojure maps or records as exceptions without defining custom exception classes
Catching exceptions based on specific key-value pairs in thrown data structures
Destructuring caught exceptions directly in catch clauses for cleaner code
Accessing detailed throw context (message, cause, stack trace) within exception handlers
Handling non-Throwable objects in exception flows
Writing more expressive and flexible error handling in Clojure applications

Not Ideal For

Projects that strictly adhere to Java's exception handling standards without Clojure-specific extensions
Applications where minimal runtime overhead is critical, due to performance costs from wrapping non-Throwable objects
Teams seeking drop-in exception handling without learning new macros or patterns
Codebases heavily reliant on Java interop that prefer native `try`/`catch` for consistency and simplicity

Pros & Cons

Pros

Throw Any Object

Allows throwing Clojure maps or records as exceptions without needing `gen-class`, making custom exceptions more idiomatic, as shown in the example where `throw+` throws a map with `:type ::bad-tree`.

Flexible Catch Selectors

Catch clauses can match based on class names, key-value vectors, predicates, or custom forms, enabling precise exception handling, such as catching `[:type :tensor.parse/bad-tree]` in the usage example.

Destructuring Support

The binding in catch clauses supports destructuring, allowing easy access to contents of thrown collections, like `{:keys [tree hint]}` in the sample code to extract data directly.

Throw Context Access

Provides access to throw site context via `&throw-context`, including message, cause, and stack trace, enhancing debugging, as detailed in the README's description of the context map.

Cons

Performance Overhead

Wrapping non-Throwable objects in `Throwable` wrappers via `ex-info` adds layers that might impact performance in high-throughput scenarios, as acknowledged in the handling of nested wrappers.

Library Dependency

Requires adding an external library for functionality that could be handled with standard Clojure, increasing project complexity and potential dependency management issues.

Limited Ecosystem

As a niche library for Clojure exception handling, it has a smaller community and fewer integrations compared to mainstream Clojure tools, which might affect long-term support and resources.

What is slingshot?

Target Audience

Clojure developers who need more flexible exception handling beyond standard `try`/`catch`, particularly those working with complex error states or integrating with Java code.

Value Proposition

Use Cases

Best For

Throwing Clojure maps or records as exceptions without defining custom exception classes
Catching exceptions based on specific key-value pairs in thrown data structures
Destructuring caught exceptions directly in catch clauses for cleaner code
Accessing detailed throw context (message, cause, stack trace) within exception handlers
Handling non-Throwable objects in exception flows
Writing more expressive and flexible error handling in Clojure applications

Not Ideal For

Projects that strictly adhere to Java's exception handling standards without Clojure-specific extensions
Applications where minimal runtime overhead is critical, due to performance costs from wrapping non-Throwable objects
Teams seeking drop-in exception handling without learning new macros or patterns
Codebases heavily reliant on Java interop that prefer native `try`/`catch` for consistency and simplicity

Pros & Cons

Pros

Throw Any Object

Flexible Catch Selectors

Destructuring Support

The binding in catch clauses supports destructuring, allowing easy access to contents of thrown collections, like `{:keys [tree hint]}` in the sample code to extract data directly.

Throw Context Access

Provides access to throw site context via `&throw-context`, including message, cause, and stack trace, enhancing debugging, as detailed in the README's description of the context map.

Cons

Performance Overhead

Wrapping non-Throwable objects in `Throwable` wrappers via `ex-info` adds layers that might impact performance in high-throughput scenarios, as acknowledged in the handling of nested wrappers.

Library Dependency

Requires adding an external library for functionality that could be handled with standard Clojure, increasing project complexity and potential dependency management issues.

Limited Ecosystem

As a niche library for Clojure exception handling, it has a smaller community and fewer integrations compared to mainstream Clojure tools, which might affect long-term support and resources.

slingshot

What is slingshot?

Overview

Use Cases

Best For

Not Ideal For

Pros & Cons

Pros

Cons

Frequently Asked Questions

Related Projects

Found a gem we're missing?

slingshot

What is slingshot?

Overview

Use Cases

Best For

Not Ideal For

Pros & Cons

Pros

Cons

Frequently Asked Questions

Related Projects

Found a gem we're missing?