Understanding our code with tests, schemas, and types

Understanding our code
with tests, schemas, and
types
Mark Godfrey
@msgodf

(ns please-understand-me
…)
(defn my-function [its-complicated]
…)

๏ Why do I need to understand the code?
๏ Why the problem exists
๏ Examples of things that might help
๏ Some other ideas
๏ Conclusion

Why do I need to
understand the code?

Why does this problem -
understanding the function
interface - exist?

What things might we ﬁnd
in the codebase that could
help?

(defn my-function
“I take a map like this:
{:name ‘Sebastian’
:age ‘27’}
and return the year of birth.”
[its-complicated]
…))
“You might understand me better with a docstring”
…)

(defn my-function
“I take a map like this:
{:name ‘Sebastian’
:age ‘27’}
and return the year of birth.”
[its-complicated]
(:age its-complicated))
“You might understand me better with a docstring”
…)

(defn my-function
[{:keys [name age] :as its-
complicated}]
…)
…)

(defrecord Person [name age])
(defn my-function
[its-complicated]
…)
…)

(defrecord Person [name age])
(defn my-function
[its-complicated]
(->YearOfBirth (:age its-complicated))
…)

(defprotocol Summarizable
(my-function [its-complicated))
(defrecord Person [name age]
Summarizable
(my-function [its-complicated]
… ))
…)

(defn my-function
[^Person its-complicated]
…)
…)

(deftest verify-me
(is (= (my-function {:name “Derek”
:age 28})
28)))
(ns please-understand-me-test
(:require [clojure.test :refer [deftest is]])
…)

(def Person {:name s/Str
:age s/Int})
(s/defn my-function :- s/Int
[its-complicated :- Person]
…))
(:require [schema.core :as s])
…)

(s/defrecord Person
[name :- s/Str
age :- s/Int])
…))
…)

(def Person
{:name (s/maybe schema/Str)
:age (s/either s/Int
(s/eq :dont-ask))
:occupation (s/protocol Job})
…))
…)

(t/defalias Person {:name String
:age Integer})
(t/defn my-function
[its-complicated :- Person] :- Integer
…))
(:require [clojure.core.typed :as t])
…)

(t/defalias Person {:name String
:age Integer})
(t/ann my-function
[its-complicated :- Person] :- Integer))
(ns please-understand-me.types
(:require [clojure.core.typed :as t])
…)

Are types really an
option in Clojure?

Type Error (core.clj:66:3) Function my-function could not be applied to arguments:
Domains:
(typed/HMap :mandatory {:name String, :age Integer} :optional {:occupation (typed/U
nil None)})
Arguments:
(typed/HMap :mandatory {:name String, :age Integer} :optional {:occupation (typed/U
nil None)
Ranges:
String
with expected type:
Integer
in: (my-function {:name “Derek”, :age 28})
Type Checker: Found 1 error
Found errors
$ lein typed check

(t/ann ^:no-check
clojure.tools.logging/*logger-factory*
clojure.tools.logging.impl/LoggerFactory)
(t/defalias LogLevel
(t/U ':trace ':debug ':info ':warn ':error ':fatal))
(t/ann ^:no-check clojure.tools.logging/log*
[clojure.tools.logging.impl/Logger LogLevel (t/U nil Throwable) String -> nil])
(t/ann-protocol clojure.tools.logging.impl/Logger
enabled?
(t/IFn [clojure.tools.logging.impl/Logger typed/Kw -> typed/Bool])
write!
(t/IFn [clojure.tools.logging.impl/Logger typed/Kw Throwable String -> nil]))
(t/ann-protocol clojure.tools.logging.impl/LoggerFactory
name
(t/IFn [clojure.tools.logging.impl/LoggerFactory -> String])
get-logger
(t/IFn [clojure.tools.logging.impl/LoggerFactory typed/Any ->
clojure.tools.logging.impl/Logger]))
(:require [clojure.core.typed :as t]
[clojure.tools.logging :as log])
…)

The REPL, or interactive
evaluation

Schemas and generative
testing

(defspec describe-my-function 1000
(tc/forall [person (sg/generate Person)]
(is (pos? (my-function person)))))
(ns please-understand-me-test
(:require [clojure.test.check :as tc]
[clojure.test.check.clojure-test :refer [defspec]
[schema.experimental.generators :as sg])
…)

(def Birthdate {:year s/Int
:month s/Int
:day s/Int})
(s/defn mock-helper :- Birthdate
(sg/generate Birthdate)
…))
(:require [schema.core :as s]
[schema.experimental.generators :as sg])
…)

Understanding our code with tests, schemas, and types

“Your ‘reliability’ tools (testing,
refactoring, type systems) don’t
care if program is simple or not”

But they can help you
understand your code

See also
• Jessica Kerr - Contracts asTypes
• Schema for Clojure(Script) Data Shape Declaration and
Validation
• Stuart Sierra -Thinking in Data
• Rich Hickey - Simplicity Matters

Understanding our code with tests, schemas, and types

More Related Content

What's hot (7)

Similar to Understanding our code with tests, schemas, and types (18)

Recently uploaded (20)

Understanding our code with tests, schemas, and types