jellyfin-smart-playlist/lisp.md

The lisp interpreter

The interpreter is a lisp-like language used to build the filter expressions.

Builtins

atom: check if a receive value is a atom. (atom 1)

eq: check if two values are equal. (eq (quote a) (quote a))

car: get the first item of the cons.

cdr: get the remainder of the list.

cons: create a new cons. (cons 1 2)

begin: evaluate a series of statements, returning the result of the last one. (begin t nil)

+-*/%: arithmetic operations for integers. (+ 1 2)

=, !=, <, <=, >, >=: compare two integers. (> 1 2)

not: negate the given value. nil -> t, everything else will be nil. (not (quote a))

string=, string!=, string<, string<=, string>, string>=: compare two strings. (> "1" "2")

haskeys: takes any object and a variadic number of arguments (strings) and returns a list with either t or nil describing if a corresponding property/field/method with that name exists on the object. (haskeys mystring "Length")

getitems: takes any object and a variadic number of arguments (strings) and returns the values of the fields/properties. (getitems mystring "Length" "Chars")

invoke: takes 3 arguments and invokes the method defined on the object.

The first argument is the object on which to invoke the method, the second one is the name of the method and the third one is a list of arguments to pass to the method. (invoke mystring "Lower" nil)

invoke-generic: the same as invoke, but takes a fourth argument, a list of string describing the types for the generic method. (invoke-generic mybaseitem "FindParent" nil (list "MediaBrowser.Controller.Entities.Audio.MusicArtist, MediaBrowser.Controller"))

random: gives a random integer. (random)

shuffle: shuffles a list. (shuffle (list 1 2 3 4))

quote: quotes a value. (quote a)

eval: evaluates a expression. (eval (quote a))

cond: checks conditions and evaluates the corresponding expression.

(cond
  ((> 1 2) t)
  (t f))

if: a conditional. (if t 1 2)

define: defines a new symbol. (define foo 1), (define add (lambda (a b) (+ a b)))

let: define variables in the let context and evaluate the last expression. (let (a 1) (b 2) (+ a b))

let*: the same as let, but allows to reference variables defined earlier in the let statement. (let* (a 1) (b (+ 2 a)) (+ a b))

apply: call a function with the specified arguments. (apply + (list 1 2))

and: evaluate the given expressions in order, if any one of them evaluates to nil return early with that value, otherwise return the last value. (and 1 2 nil 3)

or: return nil if all arguments evaluate to nil otherwise the first non-nil value.

Derived builtins

null: the same as not. Can be useful to indicate semantics of a program.

list: create a list from the given arguments. (list 1 2 3)

find: find if an item is in the given list and return it, otherwise return nil. (find 4 (list 1 2 3 4 5 6 7))

map: apply a function to every item in the list. (map (lambda (x) (* 2 x)) (list 1 2 3))

fold: also known as reduce. Apply the function to a sequence of values, reducing the sequence to a single item. It takes a initial value which is returned for empty lists. (fold (lambda (a b) (+ a b)) 0 (list 1 2 3 4))

any: equivalent to (apply or (map function list)). (any (lambda (a) (% a 2)) (list 2 4 6 7 8))

all: equivalent to (apply and (map function list)). (all (lambda (a) (% a 2)) (list 2 4 6 7 8))

append: append an item to the given list. (append (list 1 2 3) 4)

qsort: quicksort, takes a comparison function and the list. (qsort (lambda (a b) (> a b)) (list 1 2 6 4 9 1 19 0))

rand: get a random integer. Takes either zero, one or two arguments. If zero arguments are given it gives a random integer from all possibly representable integers. If one argument is given it gives a integer between 0 (inclusive) and n (exclusive). If two arguments are given it gives a integer between a (inclusive) and b (exclusive).

shuf: same as shuffle.

Pre-defined convenience functions

• lower: lowercases a string ((eq (lower "SomeString") "somestring"))
• is-genre: check if the item is of this genre, partial matches allowed, the example filter would match the genre "Nu-Metal" ((is-genre "metal" (genre-list)))
• is-genre-exact: the same as is-genre, but does not match paritally
• is-favorite: matches a favorite item ((is-favorite))
• is-type: matches the type of item look at BaseItemKind.cs for a list of items. The plugin has enabled support for Audio, MusicAlbum, Playlist ((is-type "Audio"))
• logd, logi, logw, loge: write to the logger with the respective levels (debug, information, warning, error). Takes the same arguments as Logger.LogInformation(...).

And many more.