Unless you use Typed Clojure, which is a library.
https://github.com/typedclojure/typedclojure
I haven't used it, so I don't know its tradeoffs; but its docs say its types exist at compile time:
https://github.com/clojure/core.typed/wiki/User-Guide
In Clojure 1.13 adds support for checked keysclojure
core.typed
Clojure2013–2026
clojure / core.typed
core.typed
An optional type system for Clojure
38Distinct people
45Mentions
0Explicit recommenders
1.3KGitHub stars
What to know before exploring
What it is
An optional type system for Clojure
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
- plumatic/schema · linked in 7 of the same discussions
- clojure/core.contracts · linked in 2 of the same discussions
- clojure/core.match · linked in 2 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 12:54:37 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year45 dated mentions
Observed mentions: 2013-03-12 19:44:10 UTC to 2026-07-06 18:53:38 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 14 | 0 | 14 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 12 | 1 | 11 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 5 | 0 | 5 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 1 | 0 | 1 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
core.typed
Optional typing in Clojure, as a library.
NEW REPO -- core.typed is deprecated as of Clojure 1.11
core.typed supports up to Clojure 1.10. Clojure 1.11 introduced new destructuring expansion that is only supported by typedclojure.
Further feature development has been moved to the typedclojure repository
which was forked from this repository at core.typed 1.0.1.
See here for upgrading instructions.
Usage Overview
core.typed is separated into modules. You'll want the full type checker at development
time, and the runtime dependencies in production.
In Clojure CLI's deps.edn, this will look something like this:
{:deps {org.clojure.typed/runtime.jvm {:mvn/version "1.0.1"}}
:aliases {:dev {:extra-deps {org.clojure.typed/checker.jvm {:mvn/version "1.0.1"}}}}}
You can then start a dev repl with clj -A:dev.
In Leiningen's project.clj, something like this:
(defproject a-project "0.0.1-SNAPSHOT"
:dependencies [[org.clojure.typed/runtime.jvm "1.0.1"]]
:profiles {:dev {:dependencies [[org.clojure.typed/checker.jvm "1.0.1"]]}})
Then, lein repl will automatically activate the :dev profile. Verify the type
checker is not included in uberjars with lein with-profile uberjar deps :tree.
Releases and Dependency Information
Latest stable release is 1.0.1.
See modules for specific version coordinates:
Core type system
checker.jvm: The JVM type checker
runtime.jvm: JVM Runtime dependencies
analyzer.jvm: Analyzer for JVM Clojure
analyzer.js: Analyzer for JS Clojure (unreleased)
checker.js: The JS type checker (unreleased)
analyzer.common: Implementation-agnostic base for Clojure analyzers
Library Annotations
lib.clojure: Base type annotations
lib.core.async: Annotations for core.async
Utility libraries
annotator.jvm: Automatic annotator
lang.jvm: Extensible languages
Compatibility
core.typed supports Clojure 1.10.1 and JDK 1.8+.
Mailing List and IRC
Use the core.typed mailing list for core.typed discussion.
Documentation
See wiki.
API Reference
Ambrose's blog
Leiningen Plugin
lein-typed
Vim Plugin
vim-typedclojure
Emacs Mode
typed-clojure-mode
Examples
core.async Rock-paper-scissors
Developer Information
Typed Clojure Contributor Code of Conduct
Contributing guidelines
GitHub Project
Bug Tracker
Continuous Integration
Compatibility Test Matrix
Contributors
Thanks to the following people for contributing to core.typed:
Stephen Compall (S11001001)
Andrew Brehaut (brehaut)
Christopher Spencer (cspencer)
Reid McKenzie (arrdem)
Di Xu (xudifsd)
Nicola Mometto (Bronsa)
Chas Emerick (cemerick)
Jake Goulding (shepmaster)
Andy Fingerhut
Aravind K N (arav93)
Allen Rohner (arohner)
Minori Yamashita (ympbyc)
Kyle Kingsbury (aphyr)
Nathan Sorenson
Tobias Kortkamp (t6)
Alejandro Gomez (dialelo)
Piotr Jarzemski (kazuhiro)
Sponsors
Thanks to the following companies for their active sponsorship of Typed Clojure's development
via OpenCollective.
YourKit
YourKit is kindly supporting core.typed and other open source projects with its full-featured Java Profiler.
YourKit, LLC is the creator of innovative and intelligent tools for profiling
Java and .NET applications. Take a look at YourKit's leading software products:
YourKit Java Profiler and
YourKit .NET Profiler.
License
Copyright © Ambrose Bonnaire-Sergeant, Rich Hickey & contributors.
Licensed under the EPL (see the file epl-v10.html).
tools.analyzer
Copyright © Nicola Mometto, Rich Hickey & contributors.
Licensed under the EPL (see the file epl-v10.html).
tools.analyzer.jvm
Copyright © Nicola Mometto, Rich Hickey & contributors.
Licensed under the EPL (see the file epl-v10.html).
tools.analyzer.js
Copyright © Nicola Mometto, Rich Hickey & contributors.
Licensed under the EPL (see the file epl-v10.html).
Read the full README on GitHubWhat Hacker News says
45 sourcesCould you use https://github.com/clojure/core.typed ? Or https://clojure.org/guides/spec ?
In Ask HN: What's Prolog like in 2024?There's no Typed Clojure, still? I seem to remember people porting Typed Racket to Clojure; a quick search gives me core.typed[1] and typedclojure[2]. There's an example[3] looking like this:
(t/ann hello-world-error [t/Int :-> t/Str])
(defn hello-world-error [a] (inc a) ;#"Simplified a bit")
which looks like Typed Racket, where you'd get:
(: hello (Number . -> . String))
(define (hello num) (add1 num))
(both definitions are rejected at compile time; in Racket, it works in the REPL, too, not sure about Clojure)
...and Typed Racket is a really powerful type system (see refinement types[4]). So, I thought it's just a matter of time for Clojure to get to that level of power and support. It should be much easier to do this to Clojure than to Ruby, given that you have a working example of how to do it well. So I'm really surp
Read the rest
rised Clojure isn't gradually typed by now, with most of the code being annotated and type-checked at compile time.
[1] https://github.com/clojure/core.typed
[2] https://github.com/typedclojure/typedclojure
[3] https://github.com/typedclojure/typedclojure/blob/main/examp...
[4] https://docs.racket-lang.org/ts-reference/Experimental_Featu...
Do you know about the Typed Clojure project? More or less Racket's contract system, for Clojure:
https://github.com/clojure/core.typed
To me, it's one of the great testaments to the power of Lisp that you can bolt on a static type system after the fact.
In Six years of professional Clojure developmentThis is a great article, and I think does a great job of surveying the landscape as it stands. Particularly great to hear reports of ease in hiring and training, which doesn't surprise me, but is nice to be able to cite when risk-averse tech leads express concern about staffing and team-scaling.
I find it somewhat funny that a lot of the critiques here are about purity or types. I really see it as Clojure's core strength that it's both pragmatic and approachable. I'm a math/alegbra nerd, so I love languages like Haskell & OCaml, but they're much more austere for the uninitiated, and have had their own troubles growing. From my experience, the approach of Clojure spec is really nice because it gives you more flexibility/freedom/support in both thinking at a high level about the design of your system (in spec code) before you actually write
Read the rest
the (implementation) code itself, while also not requiring it, and letting you add after the fact. You also get a lot for it: generative testing, destructuring, documentation, etc.
That having been said, I'm surprised that more of the pro-type folks here don't seem to be familiar with the [typed clojure](https://github.com/clojure/core.typed) project, which adds optional typing, along the lines of Racket's contract system. To me, it's one of the great testaments to the power of Lisp that you can fairly easily implement types on top of the core language.
My one beef with this article is that scripting with Clojure is now not only possible, but a joy, thanks to GraalVM and [babashka](https://github.com/babashka/babashka)! This has made a HUGE difference in the surface area of problems to which I'm able to apply Clojure.
Clojure has an optional type system: https://github.com/clojure/core.typed
(note that Lisp is flexible enough that a type system can be written as a library)
There's also this for run-time checking (i.e., you won't get any help at compile-time, but functions called with bad values will fail in very clear ways): https://github.com/plumatic/schema
In Six years of professional Clojure developmentWhat do you mean by Haskell-like type annotations?
Do you mean literally the syntax
foo :: Type0 -> Type1 -> Type2
? Or do you mean the ability to have the type annotation on a separate line from the function implementation itself (rather than e.g. annotating its arguments individually)?
In the case of the former you have Hackett (https://lexi-lambda.github.io/hackett/reference-syntactic-fo...) which unfortunately I think isn't seeing too much work on it anymore.
In the latter case something like Typed Clojure may work (https://github.com/clojure/core.typed).
In Sugar – a typed lispy language targeting webasm/wat> - its dynamic-ness makes it not suited to large projects IMO.
Clojure can be typed https://github.com/clojure/core.typed/
> - The currently-accepted attempt at a non-type-system-type-system 'spec' is not well thought out.
Spec is not a substitute for a type system. It is much more loose, since you are just dealing with implicit predicates but at the same time it is more powerful than what mainstream type systems give you in terms of validity and expressiveness.
In State of Clojure 2020To add another point to the Common lisp over Clojure argument, DECLARE[0] offers a way to take advantage of type declarations natively.
I stopped using Clojure and don't consider it for new projects because I think types are invaluable documentation now, and it pains me that clojure and it's community doesn't believe the same way (typed clojure[1] does exist but it's contentious).
[0]: http://clhs.lisp.se/Body/s_declar.htm
[1]: https://github.com/clojure/core.typed
In Classes vs. Data StructuresIn all my time in Clojure I've never seen a project use compile-time type checking. core.typed [1] exists but I've never used it. Most people use either no type checking or if needed they'll judiciously apply something like schema [2] or spec [3].
[1]: https://github.com/clojure/core.typed
[2]: https://github.com/plumatic/schema
[3]: https://clojure.org/about/spec
In State of Clojure Survey 2019 AnalysisClojure has the core.typed [0] optional type system! So yes, though they are dynamic, they embrace that others can differ.
> This work adds static type checking (and some of its benefits) to Clojure, a dynamically typed language, while still preserving idioms that characterise the language. It allows static and dynamically typed code to be mixed so the programmer can use whichever is more appropriate.
Some communities don't hold the dynamic vs static debate as an issue of such a hard regard that an individual must be rejected, lest they infect others.
matz has pretty much said that static type checking will not be part of Ruby, and he won't open up the syntax for it. But bugs like this one [1] aren't filled with hate, telling people to get lost. There's a constructive approach.
[0] https://github.com/clojure/core.typed/wiki
[1] https://bu
Read the rest
An optional type system for Clojure
1 points · Open discussionTheres the new clojure.spec[1] in 1.9 and core.typed[2] adds an optional type system as well.
[1]: http://clojure.org/about/spec
[1]: https://github.com/clojure/core.typed
The REPL-driven development of Lisps makes types not as important because everything is interactively tested as you write it. Having an optional type system makes it much easier to start with dynamic types and gradually add type annotations as your architecture stabilizes.
In Why Clojure? (2010)There's Typed Racket [1] and for Clojure there's core.typed [2]which do pretty much that. For Clojure there's also Schema [3], which is a bit lighter weight (it's not a full type system), but still gets you some of the benefits like validation and documentation.
[1] https://docs.racket-lang.org/ts-guide/
[2] https://github.com/clojure/core.typed
[3] https://github.com/plumatic/schema
In A Farewell to FRPanother one for the gradual typing would be core.typed https://github.com/clojure/core.typed
In Languages to improve your PythonShowing the 15 most recent of 45 sources. Enable JavaScript to search and browse every indexed mention.