Clojure-如何声明记录的集合或向量

Question

How Can I define a Record Collection or a Vector of Records?

I have this snippet code:

(defrecord Transaction [a, b, c])

I want define a Transaction collection called LastTransactions to implement a function like this:

(defn can-authorize
    "Validate Authorization by Transaction"
    [^Transaction transaction, ^LastTransactions lastTransactions]
    (... business logic)
    )

First Question, is that the right way to do that?

Second, How can i declare that structure?

Answer 1

Clojure's type hints don't offer any type validation - you can use Clojure Spec or Plumatic Schema for that. They only serve for the compiler to prevent reflection when Java methods are called on the parameters. For that purpose, you don't need to type hint a vector since Clojure's core functions for collections ( first , conj , etc.) by design don't require reflection on standard collections.

However, if you need, you can type-hint the elements that you extract from the lastTransaction sequence, for example:

(defn can-authorize
  "Validate Authorization by Transaction"
  [^Transaction transaction, lastTransactions]
  ...
  (for [^Transaction t lastTransactions]
    (...do-something-with t))

Answer 2

Type-hints are used to avoid reflection. They are not used to statically type function or constructor args.

Just use basic ^java.util.List type-hint instead of ^LastTransactions . In this case, any use of wrong lastTransactions in the body of the function will fail with ClassCastException . However, it won't check the type of elements in that list. To do so, use type hinting everytime you work with elements of lastTransactions .

Example 1 with type hinting :

(defn can-authorize
  [^Transaction transaction, ^java.util.List lastTransactions]
  (.size lastTransactions) 
)

In this case, decompiled java code will look like:

// Decompiling class: user$can_authorize
import clojure.lang.*;
import java.util.*;

public final class user$can_authorize extends AFunction
{
    public static Object invokeStatic(final Object transaction, Object lastTransactions) {
        final Object o = lastTransactions;
        lastTransactions = null;
        return ((List)o).size();
    }

    public Object invoke(final Object transaction, final Object lastTransactions) {
        return invokeStatic(transaction, lastTransactions);
    }
}

Example 2 without type hinting :

(defn can-authorize [^String transaction,  lastTransactions]
             (.size lastTransactions))

decompiled to:

// Decompiling class: user$can_authorize
import clojure.lang.*;

public final class user$can_authorize extends AFunction
{
    public static Object invokeStatic(final Object transaction, Object lastTransactions) {
        final Object target = lastTransactions;
        lastTransactions = null;
        return Reflector.invokeNoArgInstanceMember(target, "size", false);
    }

    public Object invoke(final Object transaction, final Object lastTransactions) {
        return invokeStatic(transaction, lastTransactions);
    }
}

Compare the resulted return statements:

with type hinting

return ((List)o).size();

without type hinting

return Reflector.invokeNoArgInstanceMember(target, "size", false);

PS: code decompiled by using clj-java-decompiler