ExLisp.Builtins (exlisp v0.1.0)

SBCL-compatible quit function. Terminates the process with the specified exit code (default: 0). Accepts keyword arguments :unix-status or :code, or a single integer.

r(args \\ [])

random(arg1, arg2 \\ nil)

rassoc(args)

rassoc(item, alist)

rassoc_if(args)

rassoc_if(predicate, alist)

rassoc_if_not(args)

rassoc_if_not(predicate, alist)

rational(r)

rationalp(x)

read(args \\ [])

read_char(args \\ [])

read_from_string(args)

read_line(args \\ [])

realp(x)

realpart(r)

reduce(args)

reduce(fn_val, seq)

reduce(fn_val, seq, initial_val)

rem(n, d)

rem_plist(plist, indicator)

remhash(key, arg2)

remove(args)

remove(item, seq)

remove_duplicates(args)

remove_if(args)

remove_if(predicate, seq)

remove_if_not(args)

remove_if_not(predicate, seq)

remprop(sym, prop)

replace(args)

replace(seq1, seq2)

require(args)

rest(list)

revappend(args)

revappend(list1, list2)

reverse(seq)

round(x, d \\ 1)

rplaca(args)

rplaca(other, object)

rplacd(args)

rplacd(other, object)

sbit(args)

sbit(arr, idx)

schar(str, idx)

search(args)

search(seq1, seq2)

second(list)

seq_to_list(seq)

set_aref(arr, index, val)

set_char(seq, idx, val)

set_char_update_seq(seq, idx, val)

set_difference(args)

set_difference(list1, list2)

set_elt(arr, index, val)

set_elt_update_seq(seq, idx, val)

set_exclusive_or(args)

set_exclusive_or(list1, list2)

set_fdefinition(sym, fun)

set_fill_pointer(arg, fp)

set_gethash(key, arg, val)

set_nth(args)

set_nth(idx, list, val)

set_slot_value(arg1, slot_name, val)

set_struct_slot(arg1, slot_name, val)

set_subseq_update_seq(seq, start, val)

set_subseq_update_seq(seq, start, end_idx, val)

set_svref(arg, index, val)

set_symbol_function(sym, fun)

set_symbol_plist(sym, plist)

set_symbol_prop(sym, prop, val)

set_symbol_value(list)

set_symbol_value(sym, val)

seventh(list)

shadow(args)

shadowing_import(args)

signum(number)

simple_array_p(val)

simple_bit_vector_p(arg1)

simple_string_p(x)

simple_vector_p(arg1)

sin(x)

sixth(list)

slot_boundp(arg1, slot_name)

slot_makunbound(inst, slot_name)

slot_value(arg1, slot_name)

some(args)

some(predicate, seq)

some(predicate, s1, s2)

sort(args)

sort(seq, predicate)

special_operator_p(args)

sqrt(x)

stable_sort(args)

stable_sort(seq, predicate)

standard_char_p(c)

string(x)

string_capitalize(args)

string_designator_to_string(val)

string_downcase(args)

string_eq(args)

string_eq(s1, s2)

string_equal(args)

string_equal(s1, s2)

string_greaterp(args)

string_greaterp(s1, s2)

string_gt(args)

string_gt(s1, s2)

string_gte(args)

string_gte(s1, s2)

string_left_trim(args)

string_left_trim(bag, s)

string_lessp(args)

string_lessp(s1, s2)

string_lt(args)

string_lt(s1, s2)

string_lte(args)

string_lte(s1, s2)

string_neq(args)

string_neq(s1, s2)

string_not_equal(args)

string_not_equal(s1, s2)

string_not_greaterp(args)

string_not_greaterp(s1, s2)

string_not_lessp(args)

string_not_lessp(s1, s2)

string_right_trim(args)

string_right_trim(bag, s)

string_trim(args)

string_trim(bag, s)

string_upcase(args)

stringp(x)

sub(list)

sub(a, b)

sub_two(a, b)

sublis(args)

sublis(alist, tree)

subseq(args)

subseq(seq, start_idx)

subseq(seq, start_idx, end_idx)

subsetp(args)

subsetp(list1, list2)

subst(args)

subst(new_val, old_val, tree)

subst_if(args)

subst_if(new_val, predicate, tree)

subst_if_not(args)

subst_if_not(new_val, predicate, tree)

substitute(args)

substitute(newitem, olditem, seq)

substitute_if(args)

substitute_if(newitem, predicate, seq)

substitute_if_not(args)

substitute_if_not(newitem, predicate, seq)

subtypep(type1, type2)

svref(arg1, index)

sxhash(obj)

symbol_function(sym)

symbol_name(sym)

symbol_package(sym)

symbol_plist(sym)

symbol_value(sym)

symbolp(x)

system_apropos(args)

tailp(args)

tailp(sublist, list)

tan(x)

tenth(list)

terpri()

third(list)

tree_equal(args)

tree_equal(tree1, tree2)

truncate(x, d \\ 1)

truthy?(val)

Determines the truthiness in Lisp. nil, :nil, false, and [] are false; everything else is true.

typep(val, type_spec)

union(args)

union(list1, list2)

unwrap_mv_primary(other)

upper_case_p(c)

use_package(args)

v(args \\ [])

values()

values(args)

values(a, b)

values(a, b, c)

values_list(list)

vector(args)

vector_pop(arg)

vector_push(val, arg)

vector_push_extend(val, arr)

vectorp(arg1)

warn(args)

where_is_system(args)

write(args)

write_char(char, stream \\ nil)

write_line(obj, stream \\ nil)

write_string(obj, stream \\ nil)

write_to_string(obj)

zerop(v)

Functions

abs(x)

acons(args)

acons(key, val, alist)

acos(x)

add(args)

add(a, b)

add_two(a, b)

adjoin(args)

adjoin(item, list)

adjust_array(list)

adjust_array(arr, new_dims)

adjustable_array_p(arg1)

alpha_char_p(c)

alphanumericp(c)

append(lists)

append(a, b)

apply(fn_val, args)

aref(args)

aref(str, idx)

array_dimension(arg1, axis)

array_dimensions(arg1)

array_displacement(arg1)

array_element_type(s)

array_has_fill_pointer_p(arg1)

array_rank(s)

array_row_major_index(args)

array_row_major_index(arr, idx)

array_total_size(arg1)

arrayp(arg1)

ash(n, count)

asin(x)

assoc(args)

assoc(item, alist)

assoc_if(args)

assoc_if(predicate, alist)

assoc_if_not(args)

assoc_if_not(predicate, alist)

atan(x)

atom(x)

bit(args)

bit(arr, idx)

bit_vector_p(arg1)

boole(op, integer1, integer2)

both_case_p(c)

boundp(sym)

butlast(args)

butlast(list, n \\ 1)

byte(size, pos)

caaaar(x)

caaadr(x)

caaar(x)

caadar(x)

caaddr(x)

caadr(x)

caar(x)

cadaar(x)

cadadr(x)

cadar(x)

caddar(x)

cadddr(x)

caddr(x)

cadr(x)

car(other)

cdaaar(x)

cdaadr(x)

cdaar(x)

cdadar(x)

cdaddr(x)

cdadr(x)

cdar(x)

cddaar(x)

cddadr(x)

cddar(x)

cdddar(x)

cddddr(x)

cdddr(x)

cddr(x)

cdr(other)

ceiling(x, d \\ 1)

cell_error_name(c)

cerror(args)

cerror(continue_fmt, error_fmt)

char(str, idx)

char_code(ch)

char_downcase(c)

char_eq(arg1)

char_eq(c1, c2)

char_equal(arg1)

char_equal(c1, c2)

char_greaterp(args)

char_greaterp(c1, c2)

char_gt(args)

char_gt(c1, c2)

char_gte(args)

char_gte(c1, c2)

char_int(char)

char_lessp(args)

char_lessp(c1, c2)

char_lt(args)

char_lt(c1, c2)

char_lte(args)

char_lte(c1, c2)

char_name(char)

char_neq(args)

char_neq(c1, c2)

char_not_equal(args)

char_not_equal(c1, c2)

char_not_greaterp(args)

char_not_greaterp(c1, c2)

char_not_lessp(args)

char_not_lessp(c1, c2)

char_upcase(c)

character(ch)

characterp(x)

close(stream)

clrhash(ht)

code_char(code)

coerce(list)

coerce(object, result_type)

coerce_list_to_type(list, type_spec)

compare_nums(a, b)

compile(args)

compile(name, definition)

compile_file(path, opts \\ [])

complement(pred)

complex(real)

complex(real, imag)

complexp(arg1)

concatenate(args)

concatenate(result_type, seqs)

cons(head, tail)

consp(x)

constantly(val)

copy_alist(args)

copy_list(args)

copy_seq(seq)

copy_struct(other)

copy_symbol(args)

copy_symbol(sym, copy_props \\ nil)

copy_tree(args)

cos(x)

count(args)

count(item, seq)

count_if(args)

count_if(predicate, seq)

count_if_not(args)

count_if_not(predicate, seq)

defpackage(args)

delete(args)

delete(item, seq)

delete_duplicates(args)

delete_if(args)

delete_if(predicate, seq)

delete_if_not(args)

delete_if_not(predicate, seq)

denominator(x)

digit_char(arg1, arg2 \\ 10)

digit_char_p(c, radix \\ 10)

dispatch_builtin(name, raw_args)

Dispatches and executes a built-in function.

divide(list)

divide(a, b)

divide_two(a, b)

dpb(newbyte, arg, integer)

eighth(list)

elt(arg1)

elt(arr, index)

endp(x)

eq(x, y)

eql(x, y)

eqlt(x, y)

eqt(x, y)

equal(x, y)

equalp(x, y)

equalt(x, y)

error(msg)

error(fmt, a1)

error(fmt, a1, a2)

error(fmt, a1, a2, a3)

error(fmt, a1, a2, a3, a4)

error(fmt, a1, a2, a3, a4, a5)

error(fmt, a1, a2, a3, a4, a5, a6)

eval(form)

evenp(v)

every(args)

every(predicate, seq)

every(predicate, s1, s2)

exlisp_check_key_args(args, allowed_keys, allow_other_keys)

exp(x)

export(args)

expt(base, power)

fboundp(sym)

fdefinition(sym)

fifth(list)

file_length(stream)

fill(args)

fill(seq, item)

fill_pointer(arg)

find(args)

find(item, seq)

find_if(args)

find_if(predicate, seq)

find_if_not(args)

find_if_not(predicate, seq)

find_package(args)

find_symbol(name, pkg \\ nil)

first(list)

floatp(x)

floor(x, d \\ 1)

fmakunbound(sym)

format(dest, fmt_string, args \\ [])

fourth(list)

fresh_line()

funcall(fn_val, args)

funcall(fn_val, a, b)

funcall(fn_val, a, b, c)

functionp(x)

gcd(args)

gensym(args \\ [])

gentemp(args \\ [])

get_internal_real_time()

get_internal_real_time(list)

get_internal_run_time()

get_internal_run_time(list)

get_output_stream_string(stream)

get_properties(args)

get_properties(plist, indicator_list)

get_struct_slot(arg1, slot_name)

get_symbol_prop(sym, prop, default \\ nil)

get_universal_time()

get_universal_time(list)

getf(args)

getf(plist, indicator, default \\ nil)

gethash(key, hash_table, default \\ nil)

gethash_mv(key, hash_table, default \\ nil)

graphic_char_p(c)

hash_table_count(arg1)

hash_table_p(arg1)

hex_info(args)

hex_install(args)

hex_install(package, req_or_opts)

hex_search(args)

hex_where_is_package(args)

identity(x)

imagpart(r)

import(args)

in_package(args)

int_char(int)

integer_length(n)

integerp(x)

intern(name, pkg \\ nil)

intersection(args)

intersection(list1, list2)

invoke_fn(fn_val, args)

Invokes a function object or function name symbol with the given arguments list.

isqrt(n)

keywordp(x)

last(args)

last(list, n \\ 1)

lcm(args)

ldb(arg, integer)

ldiff(args)

ldiff(list, sublist)

length(seq)

lisp_bool(val)

Converts an Elixir boolean into a Lisp boolean (:t or nil).

list(args)

list_length(list)

list_star(list)

listen(stream \\ nil)

listp(x)

load(path)

log(x, base \\ nil)

logand()

logand(args)

logand(a, b)

logandc1(a, b)

logandc2(a, b)

logbitp(index, n)

logcount(n)

logeqv()

logeqv(args)

logeqv(a, b)

logior()

logior(args)

logior(a, b)

lognand(a, b)

lognor(a, b)

lognot(n)

logorc1(a, b)

logorc2(a, b)

logtest(integer1, integer2)

logxor()

logxor(args)

logxor(a, b)

lower_case_p(c)

macro_function(sym, env \\ nil)

macroexpand(form, env \\ nil)

macroexpand_1(form, env \\ nil)

make_array(args)

make_hash_table(args \\ [])

make_instance(args)

make_list(args)

make_random_state(state \\ nil)

make_sequence(args)

make_sequence(type, size)

make_sequence(type, size, init)

make_string(args)

make_string(size, opts \\ [])

make_string_input_stream(string, arg2 \\ 0, arg3 \\ nil)

make_string_output_stream(opts \\ [])

make_struct(struct_name, default_slots, args)

make_symbol(args)

makunbound(sym)

map(args)

map(result_type, fn_arg, seq1)

map(result_type, fn_arg, seq1, seq2)

map_into(args)

map_into(res_seq, fn_arg)

map_into(res_seq, fn_arg, s1)

mapc(args)

mapc(fn_val, list)

mapcan(args)

mapcan(fn_val, list)

mapcar(args)

mapcar(fn_val, list)

mapcon(args)

mapcon(fn_val, list)

maphash(fun, arg2)

mapl(args)

mapl(fn_val, list)

maplist(args)

maplist(fn_val, list)

max(list)

max(a, b)

member(args)

member(item, list)

member_if(args)

member_if(predicate, list)

member_if_not(args)

member_if_not(predicate, list)

merge(args)

merge(result_type, seq1, seq2, predicate)

min(list)

min(a, b)

minusp(v)

mismatch(args)

mismatch(seq1, seq2)

mod(n, d)

mul(args)

mul(a, b)

mul_two(a, b)

name_char(name)

nbutlast(args)

nbutlast(list, n)

nconc(lists)

nconc(a, b)

nconc(a, b, c)

nconc(a, b, c, d)

negate_num(v)

nintersection(args)

nintersection(list1, list2)

ninth(list)

not_fn(x)

notany(args)

notany(predicate, seq)

notany(predicate, s1, s2)

notevery(args)

notevery(predicate, seq)

notevery(predicate, s1, s2)

nreconc(args)

nreconc(list1, list2)

nreverse(seq)

nset_difference(args)

nset_difference(list1, list2)

nset_exclusive_or(args)

nset_exclusive_or(list1, list2)

nstring_capitalize(args)

nstring_downcase(args)

nstring_upcase(args)

nsublis(args)

nsublis(alist, tree)

nsubst(args)

nsubst(new_val, old_val, tree)

nsubst_if(args)

nsubst_if(new_val, predicate, tree)

nsubst_if_not(args)

nsubst_if_not(new_val, predicate, tree)

nsubstitute(args)

nsubstitute(newitem, olditem, seq)

nsubstitute_if(args)

nsubstitute_if(newitem, predicate, seq)

nsubstitute_if_not(args)

nsubstitute_if_not(newitem, predicate, seq)

nth(args)

nth(n, list)

nthcdr(args)

nthcdr(n, list)

null(x)

num_eq(args)

num_eq(a, b)

num_eq_two(a, b)

num_gt(args)

num_gt(a, b)

num_gt_two(a, b)

num_gte(args)

num_gte(a, b)

num_gte_two(a, b)

num_lt(args)

num_lt(a, b)

num_lt_two(a, b)

num_lte(args)

num_lte(a, b)

num_lte_two(a, b)

num_neq(args)

num_neq(a, b)

num_neq_two(a, b)

numberp(x)

numerator(x)

nunion(args)

nunion(list1, list2)

oddp(v)

one_minus(x)

one_plus(x)

open(args)

pairlis(args)

pairlis(keys, values, alist)

parse_integer(args)

parse_integer(str, opts)

peek_char(args \\ [])

plusp(v)

position(args)

position(item, seq)

position_if(args)

position_if(predicate, seq)

position_if_not(args)

position_if_not(predicate, seq)

primary_val(other)

prin1(obj)

princ(obj)

print(obj)

progv_eval(symbols, values, body_fn)

provide(args)

put_plist(args)

put_plist(plist, indicator, value)

quickload(args)

quit(args \\ [])