Support custom data types (#352)

* Elementary support for deftype* form

* Add support for `set!`ing deftype* fields

* Remove unused gen-type code

* Miscellany

* Handle recur in deftype* methods

* Slight refactoring

* Remove unused Protocol impl

* I hate linting

* Check for interface implementation

* Symbol resolution test

* Merge master

* Docstring improvements

* Disallow extra methods in interface definition

* Teeeeeeeeests

Author: chrisrink10

src/basilisp/core/__init__.lpy

@@ -841,6 +841,10 @@
 ;; Higher Order Functions ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+(defn apply-kw
+  [f & args]
+  (basilisp.lang.runtime/apply-kw f args))
+
 (defmacro lazy-seq
   "Takes a body of expressions which will produce a seq or nil. When
   seq is first called on the resulting lazy-seq, the sequence will be
@@ -2312,3 +2316,114 @@
    (basilisp.lang.runtime/to-lisp o))
   ([o & {:keys [keywordize-keys] :or {keywordize-keys true}}]
    (basilisp.lang.runtime/to-lisp o keywordize-keys)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Data Types & Protocols ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(import* abc)
+
+(defmulti ^:private munge
+  "Munge the input value into a Python-safe string. Converts keywords and
+  symbols into strings as by `name` prior to munging. Returns a string."
+  builtins/type)
+
+(defmethod munge basilisp.lang.keyword/Keyword
+  [kw]
+  (basilisp.lang.util/munge (name kw)))
+
+(defmethod munge basilisp.lang.symbol/Symbol
+  [s]
+  (basilisp.lang.util/munge (name s)))
+
+(defmethod munge builtins/str
+  [s]
+  (basilisp.lang.util/munge s))
+
+(defn gen-interface
+  "Generate and return a new Python interface (abstract base clase).
+
+  Callers should use `definterface` to generate new interfaces."
+  [interface-name methods]
+  (let [methods (reduce (fn [m [method-name args]]
+                          (let [method-args (->> (concat ['self] args)
+                                                 (apply vector))
+                                method      (->> (list 'fn* method-name method-args)
+                                                 (eval)
+                                                 (abc/abstractmethod))]
+                            (assoc m (munge method-name) method)))
+                        {}
+                        methods)]
+    (builtins/type interface-name
+                   #py (abc/ABC)
+                   (lisp->py methods))))
+
+(defmacro definterface
+  "Define a new Python interface (abstract base clase) with the given name
+  and method signatures.
+
+  Method signatures are in the form (method-name [arg1 arg2 ...]).
+
+  Interface objects cannot be directly instantiated. Instead, you must create
+  a concrete implementation of an interface (perhaps via deftype) and supply
+  implementations for all of the abstract methods.
+
+  The generated interface derives from Python's `abc.ABC` and all method
+  definitions are declared as `abc.abstractmethod`s and thus must be implemented
+  by a concrete type.
+
+  The generated interface will be immediately available after this form has
+  been evaluated and its utility is not limited to compilation."
+  [interface-name & methods]
+  (let [name-str    (name interface-name)
+        method-sigs (map #(list 'quote %) methods)]
+    `(def ~interface-name
+       (gen-interface ~name-str [~@method-sigs]))))
+
+(defmacro deftype
+  "Define a new Python concrete type which can implement 0 or more Python
+  interfaces or Basilisp protocols.
+
+  The new type will have fields matching the names in `fields`. Fields may
+  be referred to unqualified in the bodies of implemented methods. By default
+  the fields of this type are immutable. Attempting to set non-mutable fields
+  from a method body will result in a compiler error.
+
+  Fields may be made mutable by annotating their definition with `:mutable`
+  metadata. Mutable fields may be set within method bodies using the `set!`
+  special form. It is not advised to use mutable fields unless you are sure
+  you know what you are doing. As a consequence of Python's lax policy towards
+  immutability, types with even one mutable field may be mutated by outside
+  callers using `set!`, so bear that in mind when choosing mutability.
+
+  Interface or protocol implementations are declared as the name of the
+  interface or protocol as a symbol, followed by 1 or more method
+  definitions for that interface. Types are not required to declare
+  any interface implementations. Types which do declare interface
+  implementations are required to implement all interface methods. Failing
+  to implement all interface methods is a compile time error. Types
+  implementing `object` are not required to implement all `object` methods.
+
+  Method declarations should appear as:
+
+    (method-name [arg1 arg2 ...] & body)
+
+  Type objects are created with sensible `object` defaults as by `attrs`.
+  New types may override `object` defaults. An `__init__` function is
+  automatically created which takes positional arguments matching the
+  order of definition in `fields`. Additionally, given a name `NewType`,
+  a factory function will be created `->NewType` which can be used to
+  generate new instances of the type.
+
+  Methods must supply a `this` or `self` parameter. `recur` special forms
+  used in the body of a method should not include that parameter, as it
+  will be supplied automatically."
+  [type-name fields & method-impls]
+  (let [ctor-name (with-meta
+                    (symbol (str "->" (name type-name)))
+                    (meta type-name))]
+    `(do
+       (deftype* ~type-name ~fields
+         ~@method-impls)
+       (def ~ctor-name ~type-name)
+       ~type-name)))

src/basilisp/lang/compiler/constants.py

@@ -6,6 +6,7 @@ class SpecialForm:
     AWAIT = sym.symbol("await")
     CATCH = sym.symbol("catch")
     DEF = sym.symbol("def")
+    DEFTYPE = sym.symbol("deftype*")
     DO = sym.symbol("do")
     FINALLY = sym.symbol("finally")
     FN = sym.symbol("fn*")
@@ -30,6 +31,7 @@ class SpecialForm:
 SYM_ASYNC_META_KEY = kw.keyword("async")
 SYM_DYNAMIC_META_KEY = kw.keyword("dynamic")
 SYM_MACRO_META_KEY = kw.keyword("macro")
+SYM_MUTABLE_META_KEY = kw.keyword("mutable")
 SYM_NO_WARN_ON_REDEF_META_KEY = kw.keyword("no-warn-on-redef")
 SYM_NO_WARN_WHEN_UNUSED_META_KEY = kw.keyword("no-warn-when-unused")
 SYM_REDEF_META_KEY = kw.keyword("redef")