Clojure, Type System and SPEC

Type systems and statically/dynamically typed languages

In programming languages, the type system describes the types of values used in a program and provides a mechanism to prevent errors due to mismatched types of values.

As mentioned in the previous article “Difference between statically and dynamically typed languages in programming” there are two types of type systems: static typing and dynamic typing. Simply put, static typing performs type checking at compile time, while dynamic typing performs type checking at run time.

The introduction of this type system has the advantage of improving program quality and program stability, as well as making the code easier to understand by reading the code instead of the documentation. In recent years, type systems have also been applied to automated processes such as automatic code generation and automatic optimization.

Programming languages include both statically and dynamically typed languages. Typical statically typed languages are Java, C++, C#, and Scala, while dynamically typed languages include Python, Ruby, and JavaScript.

Statically typed languages require pre-declaration of variable types, making them unsuitable for agile development. In contrast, for large-scale waterfall-style development, static typing has the advantage of improving code readability, reducing the number of bugs, and increasing safety because type errors can be detected at compile time.

On the other hand, dynamically typed languages do not require type declarations for variables, making the code more concise, which has the advantage of speeding up the development cycle and making it suitable for agile development. However, since type errors cannot be detected at compile time, bugs can occur, and care must be taken during large-scale development.

Clojure and type systems

Clojure, developed by Rich Hickey and first released in 2007, will be a Lisp-like programming language running on the Java Virtual Machine (JVM).

Clojure employs functional programming philosophies such as immutable data structures, higher-order functions, macros, and parallelism, while leveraging the productivity and scalability of the Java platform. As such, it is capable of implementing large enterprise systems as well as solving complex problems in web applications, distributed systems, data processing, scientific computing, and machine learning.

From a type system perspective, Clojure can be described as a Lisp-like programming language with both static and dynamic type systems. It combines the characteristics of a statically typed language, which Java is based on, with the dynamic type system of the Lisp language system, which supports flexible coding without type declarations, thus increasing code reliability and maintaining code flexibility at the same time. This makes the code more reliable and at the same time allows the code to remain flexible.

Clojure from the perspective of a type system has the following characteristics.

• Support for primitive types: Clojure’s type system extends the Java Virtual Machine (JVM) type system. Therefore, Clojure supports Java primitive types (int, long, float, double, boolean, etc.).
• Type Inference: Clojure supports type inference. That is, you may not need to declare the type of a variable; Clojure’s type inference is based on the initialized value of the variable.
• Record Types: Clojure supports record types, which extend Java classes and interfaces. Record types define a list of fields and automatically generate functions to access these fields.
• Protocols: Clojure has a facility for defining polymorphic abstractions, called protocols. Protocols provide a type-independent way to implement functions.
• Type hinting: Clojure supports type hinting. This allows the argument and return types to be specified as hints for functions in Clojure.

Clojure Spec

Clojure spec is one of the libraries included in Clojure. It is a tool that can define specifications for various elements such as function arguments, return values, and data structures, and can also perform data verification and conversion.

• Tools for data validation and transformation: Clojure spec is a validation tool that validates and transforms certain data to conform to a given specification, This can improve the reliability and maintainability of programs.
• Defining specifications for data structures and function arguments and return values: Clojure spec can define specifications for data structures, such as the type and range of element types for vectors and the key and value types for maps. It is also possible to define specifications for function argument and return types. By describing such specifications, the intent of the code can be communicated more clearly, reducing the burden of understanding and maintaining the code.
• Use in code: Clojure specs can be easily used in Clojure code to specify argument and return types in Clojure functions and macros. You can also use the Clojure spec library to define specifications for specific data structures or functions.
• Test Automation: You can use Clojure spec to define specifications and then generate test cases automatically by generating random data based on the specifications. By using random data, the behavior of the code can be automatically tested in a variety of scenarios.
• Extensibility: Clojure Spec is flexible in the way it defines specifications, allowing new validation rules and generators to be added at will. This allows developers to customize Clojure Spec to their own needs.

Clojure spec will be a development support tool with various functions such as random code testing using generators as well as type annotation.

How to use Clojure Spec

To use Clojure Spec, it is necessary to import clojure.spec, which is the standard library of Clojure.

(require '[clojure.spec :as s])

Below is an example of specifying and validating a data structure using Clojure Spec.

1. Specification Definition

The def macro is used to define a specification for a data structure in Clojure. The following example defines a specification for a map named person.

(s/def ::name string?)
(s/def ::age pos-int?)
(s/def ::person (s/keys :req [::name ::age]))

The above specification specifies that::name and::age are strings and positive integers, respectively. And::person specifies that both::name and::age are required using the :req option.

Clojure Spec supports the following types.

• • any?：Arbitrary value
  • nil?：nil
  • number?：numerical value
  • string?：character string
  • map?：map data
  • vector?：vector date
  • set?：set data
  • coll-of：collection data

2. Data Validation

The valid? function can be used to check whether the specified data conforms to a given specification. In the following example, we are checking to see if the map named person conforms to the::person specification.

(s/valid? ::person {::name "Alice" ::age 25})

result

true

3. Error Description

The explain function can be used to explain why the specified data does not conform to the specification. The following example details the error when the map named person does not conform to the::person specification.

(s/explain ::person {::name "Alice" ::age -25})

result

:clojure.spec/invalid
  {::person {::age (not (pos-int? -25))}}

The above output indicates that the value of the::age key in the::person map is not compliant with the specification because it is not a positive integer.

4. Random data generation

The spec generator depends on Clojure’s property testing library test.check, and if you want to use gen, exercise, or testing, you must declare a dev dependency on test.check. To do so, add the following to the project.clj file

:profiles {:dev {:dependencies [[org.clojure/test.check "0.9.0"]]}}

It is also necessary to set up an additional require so that the introduced test.check can be used.

(require '[clojure.spec.gen.alpha :as gen])

From the above, the gen function can be used to generate random data based on a specified data structure. In the following example, random data is generated based on the::person specification.

(gen/generate (s/gen ::person))

result

#:spec-test.core{:name "L92FFX5ZwJ2h6MJ36q8JJ2l", :age 777010}
#:spec-test.core{:name "96", :age 10803}

In addition, gen/sample can be used to randomly generate multiple (10 by default) data.

(gen/sample (s/gen ::person))

The results are as follows

(#:spec-test.core{:name "", :age 1} 
 #:spec-test.core{:name "", :age 2} 
 #:spec-test.core{:name "", :age 1} 
 #:spec-test.core{:name "S2", :age 2} 
 #:spec-test.core{:name "7MAO", :age 3} 
 #:spec-test.core{:name "5Ox9o", :age 3} 
 #:spec-test.core{:name "", :age 4} 
 #:spec-test.core{:name "OeIrL8p", :age 5} 
 #:spec-test.core{:name "9f66", :age 42} 
 #:spec-test.core{:name "R62U", :age 2})

These data can be used to test whether the code is working correctly