ExLisp.Builtins (exlisp v0.1.2)

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()

read_char(args)

read_char(s, e)

read_char(s, e, v)

read_from_string(args)

read_line()

read_line(args)

read_line(s, e)

read_line(s, e, v)

read_line_mv()

read_line_mv(args)

read_line_mv(s, e)

read_line_mv(s, e, v)

read_sequence(args)

read_sequence(seq, s)

read_sequence(seq, s, opts)

readtable_case(args)

readtablep(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)

rename_package(args)

rename_package(pkg, new_name)

rename_package(pkg, new_name, new_nicks)

replace(args)

replace(seq1, seq2)

require(args)

rest(list)

restart_name(args)

revappend(args)

revappend(list1, list2)

reverse(seq)

round(x, d \\ 1)

row_major_aref(list)

row_major_aref(arr, idx)

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_dispatch_macro_character(args)

set_dispatch_macro_character(disp, sub, func)

set_dispatch_macro_character(disp, sub, func, rt)

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(list)

set_fill_pointer(arg, fp)

set_gethash(key, arg, val)

set_macro_character(args)

set_macro_character(char, func)

set_macro_character(char, func, non_term)

set_macro_character(char, func, non_term, rt)

set_nth(args)

set_nth(idx, list, val)

set_readtable_case(args)

set_readtable_case(rt, new_case)

set_row_major_aref(list, val)

set_row_major_aref(arr, idx, val)

set_slot_value(instance, 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(arr, 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)

set_syntax_from_char(args)

set_syntax_from_char(to_char, from_char)

set_syntax_from_char(to_char, from_char, to_rt)

set_syntax_from_char(to_char, from_char, to_rt, from_rt)

seventh(list)

shadow(args)

shadow(symbols, pkg)

shadowing_import(args)

shadowing_import(symbols, pkg)

signal(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(instance, slot_name)

slot_exists_p(instance, slot_name)

slot_makunbound(instance, slot_name)

slot_value(instance, 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)

store_value(args)

store_value(val, condition)

stream_element_type(args)

streamp(args)

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)

subclassp(sub, super)

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)

svref(arg1, index)

sxhash(obj)

symbol_function(sym)

symbol_name(sym)

symbol_package(args)

symbol_plist(sym)

symbol_value(sym)

symbolp(x)

synonym_stream_symbol(args)

system_apropos(args)

tailp(args)

tailp(sublist, list)

tan(x)

tenth(list)

terpri()

terpri(s)

third(list)

to_string_val(val)

tree_equal(args)

tree_equal(tree1, tree2)

truename(args)

truncate(x, d \\ 1)

truthy?(val)

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

two_way_stream_input_stream(args)

two_way_stream_output_stream(args)

typep(val, type_spec)

unexport(args)

unexport(symbols, pkg)

unintern(args)

unintern(sym, pkg)

union(args)

union(list1, list2)

unread_char(args)

unread_char(c, s)

unuse_package(args)

unuse_package(pkgs, target_pkg)

unwrap_mv_primary(other)

upgraded_array_element_type(typespec, env \\ nil)

upgraded_complex_part_type(typespec, env \\ nil)

upper_case_p(c)

use_package(args)

use_package(pkgs, target_pkg)

use_value(args)

use_value(val, condition)

user_homedir_pathname()

user_homedir_pathname(_)

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(list)

vector_push_extend(val, arr, extension \\ nil)

vectorp(arg1)

warn(args)

warn(datum, a1)

warn(datum, a1, a2)

where_is_system(args)

wild_pathname_p(args)

wild_pathname_p(p, field)

write(args)

write_char(args)

write_char(c, s)

write_line(args)

write_line(str, s)

write_line(str, s, opts)

write_sequence(args)

write_sequence(seq, s)

write_sequence(seq, s, opts)

write_string(args)

write_string(str, s)

write_string(str, s, opts)

write_to_string(obj)

zerop(v)

Functions

abort(args \\ [])

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(list)

array_dimension(arg1, axis)

array_dimensions(arg1)

array_displacement(arg1)

array_element_type(arg1)

array_has_fill_pointer_p(arg1)

array_in_bounds_p(list)

array_in_bounds_p(arr, indices)

array_rank(arg1)

array_row_major_index(list)

array_row_major_index(arg1, subscripts)

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_and(args)

bit_and(a, b)

bit_and(a, b, opt)

bit_andc1(args)

bit_andc1(a, b)

bit_andc1(a, b, opt)

bit_andc2(args)

bit_andc2(a, b)

bit_andc2(a, b, opt)

bit_eqv(args)

bit_eqv(a, b)

bit_eqv(a, b, opt)

bit_ior(args)

bit_ior(a, b)

bit_ior(a, b, opt)

bit_nand(args)

bit_nand(a, b)

bit_nand(a, b, opt)

bit_nor(args)

bit_nor(a, b)

bit_nor(a, b, opt)

bit_not(bit_arr_or_args)

bit_not(bit_arr, opt_arg)

bit_orc1(args)

bit_orc1(a, b)

bit_orc1(a, b, opt)

bit_orc2(args)

bit_orc2(a, b)

bit_orc2(a, b, opt)

bit_vector_p(arg1)

bit_xor(args)

bit_xor(a, b)

bit_xor(a, b, opt)

boole(op, integer1, integer2)

both_case_p(c)

boundp(sym)

broadcast_stream_streams(args)

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)

call_next_method(args \\ nil)

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_control, datum)

cerror(continue_control, datum, a1)

cerror(continue_control, datum, a1, a2)

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)

class_name(class_or_name)

class_of(obj)

clear_input()

clear_input(s)

clear_output()

clear_output(s)

close(args)

close(s, opts)

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)

compute_restarts(args \\ [])

concatenate(args)

concatenate(result_type, seqs)

concatenated_stream_streams(args)

cons(head, tail)

consp(x)

constantly(val)

continue(args \\ [])

copy_alist(args)

copy_list(args)

copy_readtable(args \\ [])

copy_readtable(from, to)

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)

defpackage(name, opts)

deftype(name, lambda_list, body)

delete(args)

delete(item, seq)

delete_duplicates(args)

delete_if(args)

delete_if(predicate, seq)

delete_if_not(args)

delete_if_not(predicate, seq)

delete_package(args)

denominator(x)

digit_char(arg1, arg2 \\ 10)

digit_char_p(c, radix \\ 10)

directory()

directory(args)

directory_namestring(args)

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)

echo_stream_input_stream(args)

echo_stream_output_stream(args)

eighth(list)

elt(arg1)

elt(arr, index)

endp(x)

enough_namestring(args)

enough_namestring(p, d)

eq(x, y)

eql(x, y)

eqlt(x, y)

eqt(x, y)

equal(x, y)

equalp(x, y)

equalt(x, y)

error(args)

error(datum, a1)

error(datum, a1, a2)

error(datum, a1, a2, a3)

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

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

error(datum, 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)

export(symbols, pkg)

expt(base, power)

fboundp(sym)

fdefinition(sym)

fifth(list)

file_author(args)

file_length(args)

file_namestring(args)

file_position(args)

file_position(s, pos)

file_write_date(args)

fill(args)

fill(seq, item)

fill_pointer(arg1)

find(args)

find(item, seq)

find_class(name)

find_if(args)

find_if(predicate, seq)

find_if_not(args)

find_if_not(predicate, seq)

find_package(args)

find_restart(args)

find_restart(name, condition)

find_symbol(args)

find_symbol(name, pkg)

finish_output()

finish_output(s)

first(list)

floatp(x)

floor(x, d \\ 1)

fmakunbound(sym)

force_output()

force_output(s)

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

fourth(list)

fresh_line()

fresh_line(s)

funcall(fn_val, args)

funcall(fn_val, a, b)

funcall(fn_val, a, b, c)

functionp(x)

gcd(args)

gensym(args \\ [])

gentemp(args \\ [])

get_dispatch_macro_character(args)

get_dispatch_macro_character(disp, sub)

get_dispatch_macro_character(disp, sub, rt)

get_internal_real_time()

get_internal_real_time(list)

get_internal_run_time()

get_internal_run_time(list)

get_macro_character(args)

get_macro_character(char, rt)

get_output_stream_string(args)

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)

host_namestring(args)

identity(x)

imagpart(r)

import(args)

import(symbols, pkg)

in_package(args)

input_stream_p(args)

int_char(int)

integer_length(n)

integerp(x)

interactive_stream_p(args)

intern(args)

intern(name, pkg)

intersection(args)

intersection(list1, list2)

invoke_fn(fn_val, args)

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

invoke_restart(args)

invoke_restart_interactively(args)

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_all_packages()

list_all_packages(list)

list_length(list)

list_star(list)

listen()

listen(s)

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_broadcast_stream(args \\ [])

make_concatenated_stream(args \\ [])

make_condition(args)

make_dispatch_macro_character(args)

make_dispatch_macro_character(char, non_term)

make_dispatch_macro_character(char, non_term, rt)

make_echo_stream(args)

make_echo_stream(in_s, out_s)

make_hash_table(args \\ [])

make_instance(args)

make_list(args)

make_package(args)

make_package(name, opts)

make_pathname(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(args)

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

make_string_output_stream(opts \\ [])

make_struct(struct_name, default_slots, args)

make_symbol(args)

make_synonym_stream(args)

make_two_way_stream(args)

make_two_way_stream(in_s, out_s)

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)

merge_pathnames(args)

merge_pathnames(p, def_p)

merge_pathnames(p, def_p, def_v)

min(list)

min(a, b)

minusp(v)

mismatch(args)

mismatch(seq1, seq2)

mod(n, d)

muffle_warning(args \\ [])

mul(args)

mul(a, b)

mul_two(a, b)

name_char(name)

namestring(args)

nbutlast(args)

nbutlast(list, n)

nconc(lists)

nconc(a, b)

nconc(a, b, c)

nconc(a, b, c, d)

negate_num(v)

next_method_p()

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)

open(filespec, opts)

open_stream_p(args)

output_stream_p(args)

package_name(pkg)

package_nicknames(pkg)

package_shadowing_symbols(pkg)

package_use_list(pkg)

package_used_by_list(pkg)

packagep(pkg)

pairlis(args)

pairlis(keys, values, alist)

parse_integer(args)

parse_integer(str, opts)

parse_lisp_keywords(args, allowed_keys \\ nil)

parse_namestring(args)

parse_namestring_mv(args)

pathname(args)

pathname_device(args)

pathname_directory(args)

pathname_host(args)

pathname_match_p(args)

pathname_match_p(p, wild)

pathname_name(args)

pathname_type(args)

pathname_version(args)

pathnamep(args)

peek_char()

peek_char(args)

peek_char(t, s)

peek_char(t, s, e)

peek_char(t, s, e, v)

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)

probe_file(args)

progv_eval(symbols, values, body_fn)

provide(args)

put_plist(args)

put_plist(plist, indicator, value)

quickload(args)

quit(args \\ [])