Inevitably due to size limitations there are many useful functions in Common Lisp that are not provided in uLisp. If one of your favourite functions is missing, this page shows how to write the most popular ones in uLisp.

You can make sure that the functions you want are always available in your copy of uLisp using the Lisp Library feature.

Note that in many cases these aren’t as fully featured as the full Common Lisp versions. For example:

- The sequence functions only support lists.
- Keyword arguments such as
**:key**and**:test**aren’t supported. - There’s reduced error checking.

I’d welcome suggestions for additions, or improvements to these.

#### count

Counts the number of items **eq** to **x** in **lst**.

```
(defun count (x lst)
(if (null lst) 0
(+ (if (eq x (car lst)) 1 0) (count x (cdr lst)))))
```

#### count-if

Counts the number of items in **lst** for which **tst** is true.

```
(defun count-if (tst lst)
(if (null lst) 0
(+ (if (funcall tst (car lst)) 1 0) (count-if tst (cdr lst)))))
```

#### count-if-not

Counts the number of items in **lst** for which **tst** is false.

```
(defun count-if-not (tst lst)
(if (null lst) 0
(+ (if (funcall tst (car lst)) 0 1) (count-if-not tst (cdr lst)))))
```

#### eql

In uLisp **eq** and **eql** are equivalent.

```
(defvar eql eq)
```

#### equal

Tests whether two objects or strings are equal, or have the same list structure.

```
(defun equal (x y)
(cond
((and (stringp x) (stringp y)) (string= x y))
((and (consp x) (consp y)) (and (equal (car x) (car y)) (equal (cdr x) (cdr y))))
(t (eq x y))))
```

#### every

Returns **t** if **tst** is true for every item in **lst**, or returns **nil** on the first false item.

```
(defun every (tst lst)
(if (null lst) t
(and (funcall tst (car lst)) (every tst (cdr lst)))))
```

#### find

Returns **x** if **x** is in **lst**, or **nil** otherwise.

```
(defun find (x lst) (car (member x lst)))
```

#### find-if

Returns the first item for which **tst** is true in **lst**, or **nil** otherwise.

```
(defun find-if (tst lst)
(cond
((null lst) nil)
((funcall tst (car lst)) (car lst))
(t (find-if tst (cdr lst)))))
```

#### find-if-not

Returns the first item for which **tst** is false in **lst**, or **nil** otherwise.

```
(defun find-if-not (tst lst)
(cond
((null lst) nil)
((not (funcall tst (car lst))) (car lst))
(t (find-if-not tst (cdr lst)))))
```

#### fourth

Returns the fourth item in a list.

```
(defun fourth (lst) (car (cdddr lst)))
```

#### identity

Simply returns its argument.

```
(defun identity (x) x)
```

#### last

Returns the last **cdr** of **lst**.

```
(defun last (lst)
(if (null (cdr lst)) lst
(last (cdr lst))))
```

#### mapl

Applies **fn** to successive cdrs of **lst**, and returns **lst**.

```
(defun mapl (fn lst)
(mapl2 fn lst)
lst)
(defun mapl2 (fn lst)
(cond
((null lst) nil)
(t (funcall fn lst)
(mapl2 fn (cdr lst)))))
```

#### maplist

Applies **fn** to successive cdrs of **lst**, and returns a list of the results.

```
(defun maplist (fn lst)
(if (null lst) nil
(cons (funcall fn lst) (maplist fn (cdr lst)))))
```

#### nconc

Destructively appends its arguments together, which must be lists.

```
(defun nconc (&rest ls)
(mapcan #'(lambda (x) x) ls))
```

#### nthcdr

Returns the nth **cdr** of **lst**.

```
(defun nthcdr (n lst)
(if (zerop n) lst
(nthcdr (1- n) (cdr lst))))
```

#### position

Returns the position of the first **x** in **lst**, or **nil** if it’s not found.

```
(defun position (x lst &optional (n 0))
(cond
((null lst) nil)
((eq x (car lst)) n)
(t (position x (cdr lst) (1+ n)))))
```

#### position-if

Returns the position of the first item in **lst** for which **tst** is true, or **nil** if none is found.

```
(defun position-if (tst lst &optional (n 0))
(cond
((null lst) nil)
((funcall tst (car lst)) n)
(t (position-if tst (cdr lst) (1+ n)))))
```

#### position-if-not

Returns the position of the first item in **lst** for which **tst** is false, or **nil** if none is found.

```
(defun position-if-not (tst lst &optional (n 0))
(cond
((null lst) nil)
((not (funcall tst (car lst))) n)
(t (position-if-not tst (cdr lst) (1+ n)))))
```

#### reduce

Returns the result of applying **fn** to successive pairs of items from **lst**.

```
(defun reduce (fn lst)
(if (null (cdr lst)) (car lst)
(funcall fn (car lst) (reduce fn (cdr lst)))))
```

#### remove

Removes all occurrences of **x** from **lst**.

```
(defun remove (x lst)
(mapcan #'(lambda (y) (unless (eq x y) (list y))) lst))
```

#### remove-if

Removes all items from **lst** for which **tst** is true.

```
(defun remove-if (tst lst)
(mapcan #'(lambda (x) (unless (funcall tst x) (list x))) lst))
```

#### remove-if-not

Removes all items from **lst** for which **tst** is false.

```
(defun remove-if-not (tst lst)
(mapcan #'(lambda (x) (when (funcall tst x) (list x))) lst))
```

#### subseq (for lists)

Returns the subsequence of **lst** from item **n** to item **m-1**.

```
(defun subseq* (lst n m)
(cond
((> n 0) (subseq* (cdr lst) (1- n) (1- m)))
((zerop m) nil)
(t (cons (car lst) (subseq* (cdr lst) 0 (1- m))))))
```

#### third

Returns the third item in a list.

```
(defvar third caddr)
```

Thanks to Max-Gerd Retzlaff for inspiring me to provide this.