はてなブックマーク

The History of Programming Languages conference series produces accurate historical records and descriptions of programming language design, development, and philosophy. It is infrequently held: the first three were in 1978, 1993, and 2007. 2020 is the time for HOPL-IV, and I’m very excited and honored to have a paper on Clojure be accepted. I want to thank Guy Steele and Richard Gabriel, co-chair

The spec library (API docs) specifies the structure of data, validates or conforms it, and can generate data based on the spec.

Clojure is a dynamic language. Among other things this means that type annotations are not required for code to run. While Clojure has some support for type hints, they are not an enforcement mechanism, nor comprehensive, and are limited to communicating information to the compiler to aid in efficient code generation. Clojure gets runtime checking of a richer set of types by the JVM itself. Howeve

These questions and answers are adapted from mailing lists and other Clojure community forums. Keywords are cached and interned. This means that a keyword is reused (reducing memory) everywhere in your program and that checks for equality really become checks for identity (which are fast). Additionally, keywords are invokable to look themselves up in a map and thus this enables the common pattern

Transducers are composable algorithmic transformations. They are independent from the context of their input and output sources and specify only the essence of the transformation in terms of an individual element. Because transducers are decoupled from input or output sources, they can be used in many different processes - collections, streams, channels, observables, etc. Transducers compose direc

Special forms have evaluation rules that differ from standard Clojure evaluation rules and are understood directly by the Clojure compiler. Headings for the special forms informally describe the special form grammar using regular expression syntax: ? (optional), * (0 or more), and + (1 or more). Non-terminals are denoted by italics. Creates and interns or locates a global var with the name of symb

Clojure is a functional programming language. It provides the tools to avoid mutable state, provides functions as first-class objects, and emphasizes recursive iteration instead of side-effect based looping. Clojure is impure, in that it doesn’t force your program to be referentially transparent, and doesn’t strive for 'provable' programs. The philosophy behind Clojure is that most parts of most p

Clojure is written in terms of abstractions. There are abstractions for sequences, collections, callability, etc. In addition, Clojure supplies many implementations of these abstractions. The abstractions are specified by host interfaces, and the implementations by host classes. While this was sufficient for bootstrapping the language, it left Clojure without similar abstraction and low-level impl

Clojure compiles all code you load on-the-fly into JVM bytecode, but sometimes it is advantageous to compile ahead-of-time (AOT). Some reasons to use AOT compilation are: To deliver your application without source To speed up application startup To generate named classes for use by Java To create an application that does not need runtime bytecode generation and custom classloaders The Clojure comp

There are many Clojure libraries available. Additionally, Clojure can use any Java library via Java interop. Together, this provides a vast ecosystem of libraries at your disposal.

Symbols representing class names are resolved to the Class instance. Inner or nested classes are separated from their outer class with a $. Fully-qualified class names are always valid. If a class is `import`ed in the namespace, it may be used without qualification. All classes in java.lang are automatically imported to every namespace. A symbol whose ns-part names a class or a primitive, and whos

Clojure 1.11 Cheat Sheet (v54) Download PDF version / Source repo Many thanks to Steve Tayon for creating it and Andy Fingerhut for ongoing maintenance.

Clojure 1.11 Cheat Sheet (v54) Download PDF version / Source repo Many thanks to Steve Tayon for creating it and Andy Fingerhut for ongoing maintenance.

ClojureDocs - community provided example repository cljdoc - library documentation

If a tree falls in the woods, does it make a sound? If a pure function mutates some local data in order to produce an immutable return value, is that ok? It’s an interesting question. Clojure data structures use mutation every time you call, e.g. assoc, creating one or more arrays and mutating them, before returning them for immutable use thereafter. The reason is performance - you simply can’t ge

Clojure is a dynamic development environment where you interact with your program while you write it, growing and adding to it while it’s running. To work with Clojure you need an editor that supports evaluation in source files and structural editing (working with nested forms in addition to character editing). Clojure provides the language, a REPL (Read Eval Print Loop), library support, and prog

(Note: this page describes the changes made in the last large update to sequences, when Rich was also exploring an alternative called streams. Treat this page as a useful historical record of these design decisions, rather than as reference documentation.)

This information is provided for programmers familiar with Common Lisp or Scheme. Clojure is case sensitive Clojure is a Lisp-1 () is not the same as nil The reader is side-effect free Keywords are not Symbols Symbols are not storage locations (see Var) nil is not a Symbol t is not syntax, use true The read table is not accessible to user programs let binds sequentially do is not a looping constru

Many people come to Clojure from an imperative language and find themselves out of their element when faced with Clojure’s approach to doing things, while others are coming from a more functional background and assume that once they leave Clojure’s functional subset, they will be faced with the same story re: state as is found in Java. This essay intends to illuminate Clojure’s approach to the pro