Datatypes

We’ve shown how to extend existing types to implement new abstractions with protocols, but what if we want to create a new type in Clojure? That’s where datatypes come in.

A datatype provides the following:

• A unique class, either named or anonymous
• Structure, either explicitly as fields or implicitly as a closure
• Fields that can have type hints and can be primitive
• Immutability on by default
• Unification with maps (via records)
• Optional implementations of abstract methods specified in protocols or interfaces

We will use the deftype macro to define a new datatype, called CryptoVault, that will implement two protocols, including IOFactory.

Now that gulp and expectorate support several existing Java classes, let’s create a new supported type, CryptoVault. You’ll create an instance of a CryptoVault by passing in an argument that implements the clojure.java.io.IOFactory protocol (not the one we’ve defined here), a path to a cryptographic key store, and a password. The contents expectorated into the CryptoVault will be encrypted and written to the IOFactory object and then decrypted when gulped back in.

We’ll use deftype to create the new type.

It takes the name of the type and a vector of fields contained by the type. The naming convention for datatypes is the same as used by Java classes, i.e., CamelCase.

Once the type has been defined, we can create an instance of our CryptoVault:

And its fields can be accessed using the same prefix-dot syntax used to access fields in Java objects.

Now that we’ve defined the basic CryptoVault type, let’s add behavior with some methods. Datatypes can implement only those methods that have been specified in either a protocol or an interface, so let’s first create a Vault protocol.

The protocol includes three functions—init-vault, vault-output-stream, and vault-input-stream—that every Vault must implement.

We can define our new type’s methods inline with deftype; we just pass the type name and vector of fields as before, followed by a protocol name and one or more method bodies:

Notice that the methods for more than one protocol can be defined inline; we’ve defined the methods for the Vault and IOFactory protocols together, although the bodies of the Vault methods have been elided and will be described next.

The init-vault method will generate an Advanced Encryption Standard (AES) key, place it in a java.security.KeyStore, write the keystore data to the file specified by the keystore field in the CryptoVault, and then password-protect it.

Both the vault-output-stream and vault-input-stream methods will use a function, vault-key, to load the keystore associated with the CryptoVault and extract the AES key used to encrypt and decrypt the contents of the vault.

The vault-output-stream method uses the vault-key method to initialize an AES cipher object, creates an OutputStream from the Vault’s filename, and then uses the cipher and OutputStream to create an instance of a CipherOutputStream.

vault-input-stream works like vault-output-stream, but returns a CipherInputStream.

To create an instance of a CryptoVault, just pass the location where data should be stored, the keystore filename, and the password protecting the keystore. If the keystore hasn’t been initialized, then call the init-vault method:

Then use the CryptoVault like any other source/destination used by gulp and expectorate.

We can use the CryptoVault with the built-in spit and slurp functions by extending it to support the clojure.java.io/IOFactory protocol. This version of the IOFactory has four methods, instead of two like ours, and there are default method implementations defined in a map called default-streams-impl. We’ll override just two of its methods, make-input-stream and make-output-stream, by assoc’ing our new implementations into this map and passing it to the extend function.

That’s it; now we can read and write to a CryptoVault using slurp and spit.

Let’s put all the pieces together in a .clj file. Make a src/examples/datatypes subdirectory within your project directory, and create a file called vault.clj.