Style Guide

Due to the long and varied history of LambdaNative and the lack of automated style linting, the coding style throughout the repository may be inconsistent. Nevertheless, the below is a guide for all future contributions.

Required

• Never use tabs; always use spaces. Indentation is two spaces in most places.
• Lines may not have trailing spaces.
• Files must end in a newline.

Recommended

• In let-style expressions, declare bindings on separate lines and align the inner parentheses. Use one level of indentation for the body.

(let ((var1 0)
      (var2 #t)
      (var3 ""))
  ...)

(let* ((var1 0)
       (var2 #t)
       (var3 ""))
  ...)

(letrec ((var1 0)
         (var2 #t)
         (var3 ""))
  ...)

• In cond expressions, align the test expressions on separate lines with one level of indentation. If the body is too long, put it on a separate line with an additional level of indentation.

(cond 
  (test1 0)
  (test2 #f)
  (test3
    "this is a very long result")
  (else
    "this is another very long result"))

• In if expressions, if the test expression and the two cases are very short, they may all go on one line. Otherwise, then and else cases should be aligned on separate lines. Often the cases are begins; the keyword may go on the same line as the test expression if there is only a then case, or they may be aligned as usual.

(if condition result1 result2)

(if condition
  "this is a longer then result"
  (string-append "this is a longer " "else result"))

(if condition
  (func1 "do something"))

(if condition (begin
  ...
  ...)

(if condition
  (begin
    ...
    ...)
  (begin ...))

• In lambda, define, or begin expressions, the body is typically on separate lines with one level of indentation, but short bodies may be on the same line as the keyword.

(lambda (arg1 arg2 . args)                 
  ...                                      
  ...)                                     
                                           
(lambda args ...)               ;;         _
                                ;;   λ  -=(')
(define var1 #f)                ;;        ;;
                                ;;       //
(define (func1 arg1 arg2)       ;;      //
  ...                           ;;     : '.---.__
  ...)                          ;;     |  --_-_)__)
                                ;;     `.____,'
(begin                          ;;        \  \
  ...                           ;;      ___\  \
  ...)                          ;;     (       \
                                ;;              \
(begin ...)                     ;;              /

• Closing parentheses are usually stacked, but sometimes when the body of the current expression is vertically long, the parentheses may be hanging to more clearly delineate the extent of an expression. Follow the patterns currently used in the file wherever possible.

Naming Conventions

• Use kebab case for functions and snake case for variables, prefixed with the module name, separated by a colon rather than a dash or an underscore if it is intended to be private to a file, e.g. module-my-public-function, module:my-private-function, and module:my_private_variable.
• Variables should be private to a file and accessed using getters and setters, often named module-variable-get and module-variable-set!.
• Functions whose main purpose is to return a boolean (e.g. to check for certain properties) are sometimes postpended with a question mark, e.g. (define (contains-numbers? str) ...).
• Prefer longer, more descriptive names over shorter, tenser names, unless the short name is conventionally used, e.g. x, y for coordinates, w, h for dimensions, g, wgt for the main gui and a widget.
• Named lets are usually named loop when their main purpose is to recursively loop.

(let loop ((var1 0) (var2 #f))
  ...
  ...
  (loop (+ var1 1) #t))