Clojure's spellings. Forma's types.

; clojure.forma
; -----------------------------------------------------------------------------
; Clojure spellings over Forma semantics (RFC 0021, stage 0).
;
; An ordinary macro library for file modules. It lets code written with
; Clojure habits read as Forma: every macro expands to core Forma, so types,
; diagnostics, and artifacts are Forma's. It does not add Clojure semantics:
; `if` still needs a Bool, `nil` is not `None`, and numbers are Int or Float.
;
; Limits: `defn` takes one parameter vector (no multi-arity bodies) and drops
; a docstring or attribute map, because `define` has no docstring slot.
; -----------------------------------------------------------------------------
(import "./kernel.forma" [-> ->>])
(export def defn defn- if-let when-let if-not when-not comment -> ->>)

;; def — bind a value to a name
(macro (def name value) `(define ~name ~value))

;; defn — define a function from a parameter vector and a body
;;
;; (defn area "Rectangle area." [w h] (* w h))
;;
;; Parts before the parameter vector (a docstring, an attribute map) are
;; accepted and dropped.
(macro (defn name parts ...)
  (if (sexpr-vector? (first parts))
    `(define ~name (fn ~@parts))
    (if (sexpr-vector? (nth parts 1))
      `(define ~name (fn ~@(rest parts)))
      `(define ~name (fn ~@(rest (rest parts)))))))

;; defn- — module-private in Clojure; Forma modules export by name, so this
;; is `defn`
(macro (defn- name parts ...) `(defn ~name ~@parts))

;; if-let — branch on an Option, binding the value inside Some
;;
;; (if-let [user (find-user id)] (greet user) "nobody")
(macro (if-let binding then else)
  (let [items (sexpr-items binding)]
    `(match ~(nth items 1) (Some ~(first items)) ~then None ~else)))

;; when-let — run the body with the value inside Some, or return nil
(macro (when-let binding body ...)
  (let [items (sexpr-items binding)]
    `(match ~(nth items 1) (Some ~(first items)) (do ~@body) None nil)))

;; if-not — inverse if
(macro (if-not test then else) `(if ~test ~else ~then))

;; when-not — run the body when the test is false
(macro (when-not test body ...) `(if ~test nil (do ~@body)))

;; comment — ignore the enclosed forms
(macro (comment forms ...) nil)

; orders.forma
; -----------------------------------------------------------------------------
; Clojure spellings over Forma semantics (RFC 0021, stage 0).
;
; Every head below that Clojure programmers recognise — `def`, `defn`, `defn-`,
; `if-let`, `->` — is an ordinary macro imported from preludes/clojure.forma.
; The semantics are Forma's: `if` takes a Bool, absence is `Option`, and the
; annotations are checked by Hindley-Milner inference.
; -----------------------------------------------------------------------------
(import "./clojure.forma" [def defn defn- if-let ->])
(export quote-for receipt)

(def free-shipping-from 5000)
(def flat-shipping 700)

;; `defn-` is module-private in Clojure. Forma modules export by name, so it
;; is `defn` with a comment.
(: shipping-for (-> Int Int))
(defn- shipping-for "Shipping in cents for a subtotal." [subtotal]
  (if (>= subtotal free-shipping-from) 0 flat-shipping))

;; `if-let` binds the value inside `Some`. There is no truthiness and no nil
;; punning: the coupon is an `Option Int`, so the missing case is `None`.
(: after-coupon (-> Int (Option Int) Int))
(defn after-coupon [subtotal coupon]
  (if-let [off coupon]
    (max 0 (- subtotal off))
    subtotal))

;; `->` threads the value first, as in Clojure.
;; This is the whole module's job: one receipt line.
(: quote-for (-> Int (Option Int) String))
(defn quote-for [subtotal coupon]
  (-> (after-coupon subtotal coupon)
      (+ (shipping-for subtotal))
      (str " cents")))

(define receipt (quote-for 4200 (Some 500)))