list_utilities

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.cyc.cycjava.cycl
Class list_utilities

java.lang.Object
  com.cyc.tool.subl.util.SubLTrampolineFile
      com.cyc.tool.subl.util.SubLTranslatedFile
          com.cyc.cycjava.cycl.list_utilities

All Implemented Interfaces:: CommonSymbols, SubLFile

public final class list_utilities
extends SubLTranslatedFile
extends SubLTranslatedFile

Nested Class Summary
`static class`	`list_utilities.$cadar$UnaryFunction`
`static class`	`list_utilities.$dotted_list_p$UnaryFunction`
`static class`	`list_utilities.$flip_cons$UnaryFunction`
`static class`	`list_utilities.$negated_test_func$UnaryFunction`
`static class`	`list_utilities.$quotify$UnaryFunction`
`static class`	`list_utilities.$sort_via_position_earlier$BinaryFunction`

Nested classes/interfaces inherited from class com.cyc.tool.subl.util.SubLTranslatedFile
`SubLTranslatedFile.SubL`

Field Summary
`static SubLFloat`	`$float167$0_5`
`static SubLFloat`	`$float90$0_01`
`static SubLInteger`	`$int0$80`
`static SubLInteger`	`$int124$500`
`static SubLInteger`	`$int95$100`
`static SubLSymbol`	`$kw100$FAILED`
`static SubLSymbol`	`$kw101$SUCCEEDED`
`static SubLSymbol`	`$kw102$UPDATED`
`static SubLSymbol`	`$kw111$TEST`
`static SubLSymbol`	`$kw112$OWNER`
`static SubLSymbol`	`$kw113$CLASSES`
`static SubLSymbol`	`$kw114$KB`
`static SubLSymbol`	`$kw115$TINY`
`static SubLSymbol`	`$kw116$WORKING_`
`static SubLSymbol`	`$kw123$TEMP`
`static SubLSymbol`	`$kw130$NOT_UNIQUE`
`static SubLSymbol`	`$kw131$UNIQUE`
`static SubLSymbol`	`$kw147$INCREMENT`
`static SubLSymbol`	`$kw152$NO_VALUE`
`static SubLSymbol`	`$kw178$LESS`
`static SubLSymbol`	`$kw179$EQUAL`
`static SubLSymbol`	`$kw180$GREATER`
`static SubLSymbol`	`$kw185$DOCUMENTATION`
`static SubLSymbol`	`$kw51$ALLOW_OTHER_KEYS`
`static SubLSymbol`	`$kw52$LIST_TYPE`
`static SubLSymbol`	`$kw54$DONE`
`static SubLSymbol`	`$kw65$DOT_FOR_DOTTED_LIST`
`static SubLSymbol`	`$kw71$DELETED`
`static SubLSymbol`	`$kw73$DUMMY`
`static SubLSymbol`	`$kw88$IGNORE_ERRORS_TARGET`
`static SubLSymbol`	`$kw96$_MEMOIZED_ITEM_NOT_FOUND_`
`static SubLList`	`$list11`
`static SubLList`	`$list117`
`static SubLList`	`$list119`
`static SubLList`	`$list120`
`static SubLList`	`$list135`
`static SubLList`	`$list136`
`static SubLList`	`$list138`
`static SubLList`	`$list140`
`static SubLList`	`$list142`
`static SubLList`	`$list143`
`static SubLList`	`$list145`
`static SubLList`	`$list146`
`static SubLList`	`$list150`
`static SubLList`	`$list16`
`static SubLList`	`$list165`
`static SubLList`	`$list17`
`static SubLList`	`$list18`
`static SubLList`	`$list182`
`static SubLList`	`$list184`
`static SubLList`	`$list186`
`static SubLList`	`$list196`
`static SubLList`	`$list24`
`static SubLList`	`$list25`
`static SubLList`	`$list28`
`static SubLList`	`$list32`
`static SubLList`	`$list35`
`static SubLList`	`$list4`
`static SubLList`	`$list41`
`static SubLList`	`$list44`
`static SubLList`	`$list49`
`static SubLList`	`$list50`
`static SubLList`	`$list72`
`static SubLList`	`$list77`
`static SubLList`	`$list80`
`static SubLList`	`$list9`
`static SubLSymbol`	$magic_hashing_cutoff$ the cutoff beyond which it's more efficient to use a hashtable than an N^2 non-consing algorithm, used for the fast-* functions.
`static SubLSymbol`	$negated_test_func$ This variable is only to be used below by the negated sequence and test functions
`static SubLString`	`$str1$nth_cycling__width_must_be_greate`
`static SubLString`	`$str122$_s____s`
`static SubLString`	`$str125$remove_duplicates_eq_table_lock`
`static SubLString`	`$str126$remove_duplicates_eql_table_lock`
`static SubLString`	`$str127$remove_duplicates_equal_table_loc`
`static SubLString`	`$str128$remove_duplicates_equalp_table_lo`
`static SubLString`	`$str154$_A_and__A`
`static SubLString`	`$str156$__`
`static SubLString`	`$str157$__and_`
`static SubLString`	`$str158$_a_____a__`
`static SubLString`	`$str161$_a___4_2f__`
`static SubLString`	`$str162$_a___a__`
`static SubLString`	`$str164$___`
`static SubLString`	`$str189$Expected__S__got__S`
`static SubLString`	`$str190$_S_was_not_a_form_with_operator__`
`static SubLString`	`$str2$nth_cycling__width_must_be_less_t`
`static SubLString`	`$str29$Malformed_csome_multiple_____S_wa`
`static SubLString`	`$str3$nth_cycling__width_overruns_offse`
`static SubLString`	`$str45$COUNTER`
`static SubLString`	`$str46$_orig`
`static SubLString`	`$str47$_cdr`
`static SubLString`	$str64$
`static SubLString`	`$str78$The_lists_of_keys_and_data_are_of`
`static SubLString`	`$str81$FIRST_OF_will_multiply_evaluate__`
`static SubLString`	`$str87$_s_was_not_a_singleton`
`static SubLString`	`$str92$Position_is_not_valid_for_the_siz`
`static SubLString`	`$str99$Number_of_repetitions_must_be_gre`
`static SubLSymbol`	$subseq_subst_recursive_answers$
`static SubLSymbol`	`$sym10$CLET`
`static SubLSymbol`	`$sym103$TREE_SET_EQUAL_`
`static SubLSymbol`	`$sym104$FUNCTION_SYMBOL_P`
`static SubLSymbol`	`$sym105$FLIP_CONS`
`static SubLSymbol`	`$sym106$QUOTE`
`static SubLSymbol`	`$sym107$STRING_`
`static SubLSymbol`	`$sym108$STRING_`
`static SubLSymbol`	`$sym109$SYMBOL_NAME`
`static SubLSymbol`	`$sym110$SAFE_SPLICE_INTO_SORTED_LIST`
`static SubLSymbol`	`$sym118$_REST`
`static SubLSymbol`	`$sym12$CSETF`
`static SubLSymbol`	`$sym121$CAR_IS_EL_VAR_`
`static SubLSymbol`	`$sym129$HASH_TABLE_P`
`static SubLSymbol`	`$sym13$CONS`
`static SubLSymbol`	`$sym132$TERM__`
`static SubLSymbol`	`$sym133$SAFE__`
`static SubLSymbol`	`$sym134$ALIST_P`
`static SubLSymbol`	`$sym137$ALIST_PUSHNEW`
`static SubLSymbol`	`$sym139$ALIST_PUSH`
`static SubLSymbol`	`$sym14$FIRST_N`
`static SubLSymbol`	`$sym141$ALIST_ENTER`
`static SubLSymbol`	`$sym144$PUTF`
`static SubLSymbol`	`$sym148$PLIST_ENTER`
`static SubLSymbol`	`$sym149$PLIST_LOOKUP`
`static SubLSymbol`	`$sym15$_`
`static SubLSymbol`	`$sym151$PROPERTY_LIST_P`
`static SubLSymbol`	`$sym153$PLISTLIST_SORT_KEY`
`static SubLSymbol`	`$sym155$PRINC_TO_STRING`
`static SubLSymbol`	`$sym159$DOUBLE_FLOAT`
`static SubLSymbol`	`$sym160$STR`
`static SubLSymbol`	`$sym163$TO_STRING`
`static SubLSymbol`	`$sym166$PLUSP`
`static SubLSymbol`	`$sym168$SORT_VIA_POSITION_EARLIER`
`static SubLSymbol`	`$sym169$SORT_VIA_TEST_EARLIER`
`static SubLSymbol`	`$sym170$_`
`static SubLSymbol`	`$sym171$SAFE__`
`static SubLSymbol`	`$sym172$SAFE_TREE__`
`static SubLSymbol`	`$sym173$SET__`
`static SubLSymbol`	`$sym174$NOT_CONSP`
`static SubLSymbol`	`$sym175$LIST_STRUCTURE__`
`static SubLSymbol`	`$sym176$FALSE`
`static SubLSymbol`	`$sym177$_`
`static SubLSymbol`	`$sym181$MAPCAR`
`static SubLSymbol`	`$sym183$GET_ARGLIST`
`static SubLSymbol`	`$sym187$KEYWORDP`
`static SubLSymbol`	`$sym188$SYMBOLP`
`static SubLSymbol`	`$sym19$CDR`
`static SubLSymbol`	`$sym191$ATOM`
`static SubLSymbol`	`$sym192$ASSOC`
`static SubLSymbol`	`$sym193$STRINGP`
`static SubLSymbol`	`$sym194$CATCH_ERROR_MESSAGE_HANDLER`
`static SubLSymbol`	`$sym195$NEW_DICTIONARY`
`static SubLSymbol`	`$sym20$CAR`
`static SubLSymbol`	`$sym21$NULL`
`static SubLSymbol`	`$sym22$CDO`
`static SubLSymbol`	`$sym23$CAND`
`static SubLSymbol`	`$sym26$CDOLIST_MULTIPLE`
`static SubLSymbol`	`$sym27$CINC`
`static SubLSymbol`	`$sym30$PUNLESS`
`static SubLSymbol`	`$sym31$COR`
`static SubLSymbol`	`$sym33$LIST_VAR`
`static SubLSymbol`	`$sym34$_`
`static SubLSymbol`	`$sym36$CDOLIST`
`static SubLSymbol`	`$sym37$REVERSE`
`static SubLSymbol`	`$sym38$LIST_VAR`
`static SubLSymbol`	`$sym39$1_`
`static SubLSymbol`	`$sym40$LENGTH`
`static SubLSymbol`	`$sym42$LIST_VAR`
`static SubLSymbol`	`$sym43$CDOLIST_CYCLING_COMPLEX`
`static SubLSymbol`	`$sym48$NTH_CYCLING`
`static SubLSymbol`	`$sym5$PROGN`
`static SubLSymbol`	`$sym53$LISTP`
`static SubLSymbol`	`$sym55$SUBTREE_LIST_VAR`
`static SubLSymbol`	`$sym56$CURRENT_SUBTREE_VAR`
`static SubLSymbol`	`$sym57$NODE_VAR`
`static SubLSymbol`	`$sym58$LIST`
`static SubLSymbol`	`$sym59$DO_LIST`
`static SubLSymbol`	`$sym6$CSETQ`
`static SubLSymbol`	`$sym60$PIF`
`static SubLSymbol`	`$sym61$CPUSH`
`static SubLSymbol`	`$sym62$_OPTIONAL`
`static SubLSymbol`	`$sym63$SEQUENCEP`
`static SubLSymbol`	`$sym66$NEGATED_TEST_FUNC`
`static SubLSymbol`	`$sym67$POSITION_IF_BINARY_LAMBDA`
`static SubLSymbol`	`$sym68$PROPER_LIST_P`
`static SubLSymbol`	`$sym69$NON_DOTTED_LIST_P`
`static SubLSymbol`	`$sym7$FIRST`
`static SubLSymbol`	`$sym70$NON_NEGATIVE_INTEGER_P`
`static SubLSymbol`	`$sym74$TREE_POSITION_DFS`
`static SubLSymbol`	`$sym75$TREE_POSITION_BFS`
`static SubLSymbol`	`$sym76$LESSER_LENGTH_P`
`static SubLSymbol`	`$sym79$DOUBLETON_`
`static SubLSymbol`	`$sym8$CPOP`
`static SubLSymbol`	`$sym82$FIF`
`static SubLSymbol`	`$sym83$FUNCTION_SPEC_P`
`static SubLSymbol`	`$sym84$POSITIVE_INTEGER_P`
`static SubLSymbol`	`$sym85$NREVERSE`
`static SubLSymbol`	`$sym86$VECTORP`
`static SubLSymbol`	`$sym89$IGNORE_ERRORS_HANDLER`
`static SubLSymbol`	`$sym91$INTEGERP`
`static SubLSymbol`	`$sym93$NUM_LIST_CACHED`
`static SubLSymbol`	`$sym94$_NUM_LIST_CACHED_CACHING_STATE_`
`static SubLSymbol`	`$sym97$_`
`static SubLSymbol`	`$sym98$__`
`static SubLFile`	`me`
`static java.lang.String`	`myName`

Fields inherited from class com.cyc.tool.subl.util.SubLTranslatedFile
`EMPTY_SUBL_OBJECT_ARRAY`

Fields inherited from interface com.cyc.tool.subl.jrtl.nativeCode.subLisp.CommonSymbols
ANSWER_TAG, APPEND_KEYWORD, APPEND_STACK_TRACES_TO_ERROR_MESSAGES, AREF, ASSEMBLE_FIXNUMS_TO_INTEGER, ATOM, BIGNUMP, BINARY_KEYWORD, BINDING_TYPE, BOOLEANP, CAAR, CADR, CAND, CAR, CCATCH, CDEC, CDESTRUCTURING_BIND, CDO, CDO_ALL_SYMBOLS, CDO_EXTERNAL_SYMBOLS, CDO_SYMBOLS, CDOHASH, CDOLIST, CDOTIMES, CDR, CHAR, CHAR_E_SYMBOL, CHAR_EQUAL_SYMBOL, CHAR_GREATER_THAN_OR_EQUAL_SYMBOL, CHAR_GREATER_THAN_SYMBOL, CHAR_GT_SYMBOL, CHAR_GTE_SYMBOL, CHAR_LESS_THAN_OR_EQUAL_SYMBOL, CHAR_LESS_THAN_SYMBOL, CHAR_LT_SYMBOL, CHAR_LTE_SYMBOL, CHAR_NE_SYMBOL, CHAR_NOT_EQUAL_SYMBOL, CHARACTERP, CHECK_TYPE, CINC, CLET, CMULTIPLE_VALUE_BIND, CNOT, CONS, CONSP, CONSTANT, COR, CPOP, CPROGV, CPUSH, CPUSHNEW, CREATE_KEYWORD, CSETF, CSETQ, CSOME, CTIME, CUNWIND_PROTECT, CVS_ID, DEBUG_IO, DECLAIM, DECLARE, DEFCONSTANT, DEFINE, DEFLEXICAL, DEFMACRO, DEFPARAMETER, DEFVAR, DIRECTION_KEYWORD, DYNAMIC, EIGHT_INTEGER, EIGHTEEN_INTEGER, ELEMENT_TYPE_KEYWORD, ELEVEN_INTEGER, END_KEYWORD, ENFORCE_MUST, ENFORCE_TYPE, EQ, EQL, EQUAL, EQUALP, ERROR, ERROR_KEYWORD, ERROR_OUTPUT, EVAL, EXTERNAL_FORMAT_KEYWORD, EXTERNAL_KEYWORD, FIF, FIFTEEN_INTEGER, FIRST, FIVE_INTEGER, FIXNUMP, FLOATP, FOUR_INTEGER, FOURTEEN_INTEGER, FUNCTION, FUNCTION_SPEC_P, FUNCTIONP, FUNLESS, FWHEN, GET, GETHASH, GETHASH_WITHOUT_VALUES, GUID_P, HASH_TABLE_ITERATOR_P, HASH_TABLE_P, IDENTITY, IF_DOES_NOT_EXIST_KEYWORD, IF_EXISTS_KEYWORD, IGNORE, INITIALIZATION_TYPE, INITIALIZER, INPUT_KEYWORD, INPUT_STREAM_P, INTEGERP, INTERNAL_KEYWORD, IO_KEYWORD, KEYWORDP, KILL_KEYWORD, LAMBDA_SYMBOL, LEXICAL, LIST, LISTP, LISTS, LOCK_P, LONG_BIGNUM_P, MACRO_ENV, MACRO_FORM, MEDIUM_BIGNUM_P, MEMBER, MINUS_ONE_INTEGER, MULTIPLE_VALUE_LIST, MUST, NCONC, NEW_VERSION_KEYWORD, NIL, NINE_INTEGER, NINETEEN_INTEGER, NREVERSE, NTH, NTH_VALUE, NULL, NULL_INPUT, NULL_OUTPUT, NUM_E_SYMBOL, NUM_GT_SYMBOL, NUM_GTE_SYMBOL, NUM_LT_SYMBOL, NUM_LTE_SYMBOL, NUM_NE_SYMBOL, NUMBERP, ONE_HUNDRED_THIRTY_SEVEN_INTEGER, ONE_HUNDRED_TWENTY_SEVEN_INTEGER, ONE_INTEGER, ONE_THOUSAND_INTEGER, OPTIONAL_SYMBOL, OTHERWISE, OUTPUT_KEYWORD, OUTPUT_STREAM_P, OVERWRITE_KEYWORD, PACKAGEP, PCASE, PCOND, PIF, PROBE_KEYWORD, PROCESS_TO_END, PROCESSP, PROCLAIM, PROGN, PUNLESS, PWHEN, QUERY_IO, QUIT, QUOTE, RENAME_AND_DELETE_KEYWORD, REST_SYMBOL, RET, RET_NIL, RET_T, RETURN_TAG, REVERSE, RW_LOCK_P, SECOND, SEQUENCEP, SEVEN_INTEGER, SEVENTEEN_INTEGER, SHORT_BIGNUM_P, SHOW_STACK_TRACES, SIX_INTEGER, SIXTEEN_INTEGER, SIXTY_FOUR_INTEGER, SORT, SSS, STANDARD_INPUT, STANDARD_OUTPUT, START_KEYWORD, STREAMP, STRING_E_SYMBOL, STRING_EQUAL_SYMBOL, STRING_GREATER_THAN_OR_EQUAL_SYMBOL, STRING_GREATER_THAN_SYMBOL, STRING_GT_SYMBOL, STRING_GTE_SYMBOL, STRING_LESS_THAN_OR_EQUAL_SYMBOL, STRING_LESS_THAN_SYMBOL, STRING_LT_SYMBOL, STRING_LTE_SYMBOL, STRING_NE_SYMBOL, STRING_NOT_EQUAL_SYMBOL, STRINGP, STRUCTURE_P, SUPERSEDE_KEYWORD, SUSPEND_TYPE_CHECKING, SYMBOL_FUNCTION, SYMBOL_VALUE, SYMBOLP, T, TEN_INTEGER, TERMINAL_IO, TEXT_KEYWORD, THIRTEEN_INTEGER, THIRTY_FOUR_INTEGER, THIRTY_THREE_INTEGER, THIRTY_TWO_INTEGER, THREE_INTEGER, TRACE_OUTPUT, TRUE, TWELVE_INTEGER, TWENTY_INTEGER, TWO_HUNDRED_FIFTY_FOUR_INTEGER, TWO_HUNDRED_FORTY_FOUR_INTEGER, TWO_INTEGER, UNDECLARED, UNPROVIDED, VALUES, VECTOR, VECTORP, WITH_ERROR_HANDLER, WITH_STATIC_AREA, WITH_THREAD_PRIVATE_AREA, WITH_WORKING_AREA, WORLD, ZERO_DOUBLE, ZERO_INTEGER

Fields inherited from interface com.cyc.tool.subl.jrtl.nativeCode.subLisp.CommonSymbols

ANSWER_TAG, APPEND_KEYWORD, APPEND_STACK_TRACES_TO_ERROR_MESSAGES, AREF, ASSEMBLE_FIXNUMS_TO_INTEGER, ATOM, BIGNUMP, BINARY_KEYWORD, BINDING_TYPE, BOOLEANP, CAAR, CADR, CAND, CAR, CCATCH, CDEC, CDESTRUCTURING_BIND, CDO, CDO_ALL_SYMBOLS, CDO_EXTERNAL_SYMBOLS, CDO_SYMBOLS, CDOHASH, CDOLIST, CDOTIMES, CDR, CHAR, CHAR_E_SYMBOL, CHAR_EQUAL_SYMBOL, CHAR_GREATER_THAN_OR_EQUAL_SYMBOL, CHAR_GREATER_THAN_SYMBOL, CHAR_GT_SYMBOL, CHAR_GTE_SYMBOL, CHAR_LESS_THAN_OR_EQUAL_SYMBOL, CHAR_LESS_THAN_SYMBOL, CHAR_LT_SYMBOL, CHAR_LTE_SYMBOL, CHAR_NE_SYMBOL, CHAR_NOT_EQUAL_SYMBOL, CHARACTERP, CHECK_TYPE, CINC, CLET, CMULTIPLE_VALUE_BIND, CNOT, CONS, CONSP, CONSTANT, COR, CPOP, CPROGV, CPUSH, CPUSHNEW, CREATE_KEYWORD, CSETF, CSETQ, CSOME, CTIME, CUNWIND_PROTECT, CVS_ID, DEBUG_IO, DECLAIM, DECLARE, DEFCONSTANT, DEFINE, DEFLEXICAL, DEFMACRO, DEFPARAMETER, DEFVAR, DIRECTION_KEYWORD, DYNAMIC, EIGHT_INTEGER, EIGHTEEN_INTEGER, ELEMENT_TYPE_KEYWORD, ELEVEN_INTEGER, END_KEYWORD, ENFORCE_MUST, ENFORCE_TYPE, EQ, EQL, EQUAL, EQUALP, ERROR, ERROR_KEYWORD, ERROR_OUTPUT, EVAL, EXTERNAL_FORMAT_KEYWORD, EXTERNAL_KEYWORD, FIF, FIFTEEN_INTEGER, FIRST, FIVE_INTEGER, FIXNUMP, FLOATP, FOUR_INTEGER, FOURTEEN_INTEGER, FUNCTION, FUNCTION_SPEC_P, FUNCTIONP, FUNLESS, FWHEN, GET, GETHASH, GETHASH_WITHOUT_VALUES, GUID_P, HASH_TABLE_ITERATOR_P, HASH_TABLE_P, IDENTITY, IF_DOES_NOT_EXIST_KEYWORD, IF_EXISTS_KEYWORD, IGNORE, INITIALIZATION_TYPE, INITIALIZER, INPUT_KEYWORD, INPUT_STREAM_P, INTEGERP, INTERNAL_KEYWORD, IO_KEYWORD, KEYWORDP, KILL_KEYWORD, LAMBDA_SYMBOL, LEXICAL, LIST, LISTP, LISTS, LOCK_P, LONG_BIGNUM_P, MACRO_ENV, MACRO_FORM, MEDIUM_BIGNUM_P, MEMBER, MINUS_ONE_INTEGER, MULTIPLE_VALUE_LIST, MUST, NCONC, NEW_VERSION_KEYWORD, NIL, NINE_INTEGER, NINETEEN_INTEGER, NREVERSE, NTH, NTH_VALUE, NULL, NULL_INPUT, NULL_OUTPUT, NUM_E_SYMBOL, NUM_GT_SYMBOL, NUM_GTE_SYMBOL, NUM_LT_SYMBOL, NUM_LTE_SYMBOL, NUM_NE_SYMBOL, NUMBERP, ONE_HUNDRED_THIRTY_SEVEN_INTEGER, ONE_HUNDRED_TWENTY_SEVEN_INTEGER, ONE_INTEGER, ONE_THOUSAND_INTEGER, OPTIONAL_SYMBOL, OTHERWISE, OUTPUT_KEYWORD, OUTPUT_STREAM_P, OVERWRITE_KEYWORD, PACKAGEP, PCASE, PCOND, PIF, PROBE_KEYWORD, PROCESS_TO_END, PROCESSP, PROCLAIM, PROGN, PUNLESS, PWHEN, QUERY_IO, QUIT, QUOTE, RENAME_AND_DELETE_KEYWORD, REST_SYMBOL, RET, RET_NIL, RET_T, RETURN_TAG, REVERSE, RW_LOCK_P, SECOND, SEQUENCEP, SEVEN_INTEGER, SEVENTEEN_INTEGER, SHORT_BIGNUM_P, SHOW_STACK_TRACES, SIX_INTEGER, SIXTEEN_INTEGER, SIXTY_FOUR_INTEGER, SORT, SSS, STANDARD_INPUT, STANDARD_OUTPUT, START_KEYWORD, STREAMP, STRING_E_SYMBOL, STRING_EQUAL_SYMBOL, STRING_GREATER_THAN_OR_EQUAL_SYMBOL, STRING_GREATER_THAN_SYMBOL, STRING_GT_SYMBOL, STRING_GTE_SYMBOL, STRING_LESS_THAN_OR_EQUAL_SYMBOL, STRING_LESS_THAN_SYMBOL, STRING_LT_SYMBOL, STRING_LTE_SYMBOL, STRING_NE_SYMBOL, STRING_NOT_EQUAL_SYMBOL, STRINGP, STRUCTURE_P, SUPERSEDE_KEYWORD, SUSPEND_TYPE_CHECKING, SYMBOL_FUNCTION, SYMBOL_VALUE, SYMBOLP, T, TEN_INTEGER, TERMINAL_IO, TEXT_KEYWORD, THIRTEEN_INTEGER, THIRTY_FOUR_INTEGER, THIRTY_THREE_INTEGER, THIRTY_TWO_INTEGER, THREE_INTEGER, TRACE_OUTPUT, TRUE, TWELVE_INTEGER, TWENTY_INTEGER, TWO_HUNDRED_FIFTY_FOUR_INTEGER, TWO_HUNDRED_FORTY_FOUR_INTEGER, TWO_INTEGER, UNDECLARED, UNPROVIDED, VALUES, VECTOR, VECTORP, WITH_ERROR_HANDLER, WITH_STATIC_AREA, WITH_THREAD_PRIVATE_AREA, WITH_WORKING_AREA, WORLD, ZERO_DOUBLE, ZERO_INTEGER

Method Summary
`static SubLObject`	`alist_delete(SubLObject alist, SubLObject key, SubLObject test)` Delete any association for KEY in ALIST (using TEST for key equality).
`static SubLObject`	`alist_enter_without_values(SubLObject alist, SubLObject key, SubLObject value, SubLObject test)` Note that VALUE is associated with KEY in ALIST (using TEST for key equality).
`static SubLObject`	`alist_enter(SubLObject alist, SubLObject key, SubLObject value, SubLObject test)` Note that VALUE is associated with KEY in ALIST (using TEST for key equality).
`static SubLObject`	`alist_has_keyP(SubLObject alist, SubLObject key, SubLObject test)`
`static SubLObject`	`alist_keys(SubLObject alist)` Return a list of all the keys of ALIST.
`static SubLObject`	`alist_lookup_without_values(SubLObject alist, SubLObject key, SubLObject test, SubLObject v_default)` Return the value associated with KEY in ALIST (using TEST for key equality).
`static SubLObject`	`alist_lookup(SubLObject alist, SubLObject key, SubLObject test, SubLObject v_default)` Return the value associated with KEY in ALIST (using TEST for key equality).
`static SubLObject`	`alist_optimize(SubLObject alist, SubLObject predicate)` Return a copy of ALIST where the order of the keys have been optimized (sorted) via the preference PREDICATE.
`static SubLObject`	`alist_p(SubLObject object)` Return T iff OBJECT is an association list.
`static SubLObject`	`alist_push(SubLObject alist, SubLObject key, SubLObject value, SubLObject test)` Note that VALUE is in a list associated with KEY in ALIST (using TEST for key equality).
`static SubLObject`	`alist_to_hash_table(SubLObject alist, SubLObject test)` Return a hashtable of all the (key .
`static SubLObject`	`alist_to_reverse_hash_table(SubLObject alist, SubLObject test)` Return a hashtable of all the (key .
`static SubLObject`	`alist_values(SubLObject alist)` Return a list of all the values of ALIST.
`static SubLObject`	`all_permutations(SubLObject n)` Returns all permutations of the numbers from 0 to N-1.
`static SubLObject`	`any_in_list(SubLObject predicate, SubLObject list, SubLObject key)`
`static SubLObject`	`cartesian_helper(SubLObject a, SubLObject b, SubLObject fun)` takes two lists and returns the cartesian product.
`static SubLObject`	`cartesian_product(SubLObject l, SubLObject fun, SubLObject start, SubLObject test)`
`static SubLObject`	`cdddr(SubLObject cons)`
`static SubLObject`	`cons_tree_find_if(SubLObject test, SubLObject object, SubLObject key)` Obsolete -- use tree-find-if
`static SubLObject`	`declare_list_utilities_file()`
`void`	`declareFunctions()` Declares the mapping between functions and symbols for all named functions defined in the file.
`static SubLObject`	`delete_duplicate_forts(SubLObject v_forts)`
`static SubLObject`	`delete_duplicates_sorted(SubLObject sorted_list, SubLObject test)` Deletes duplicates from SORTED-LIST.
`static SubLObject`	`delete_first(SubLObject obj, SubLObject sequence, SubLObject test)`
`static SubLObject`	`delete_if_not(SubLObject test, SubLObject sequence, SubLObject key, SubLObject start, SubLObject end, SubLObject count)` Negated version of DELETE-IF
`static SubLObject`	`delete_subsumed_items(SubLObject list, SubLObject test, SubLObject key)` if a and b are in LIST, and (TEST (KEY a) (KEY b)) is true, don't include b in the result
`static SubLObject`	`dotted_length(SubLObject cons)`
`static SubLObject`	`dotted_list_p(SubLObject object)`
`static SubLObject`	`doubletonP(SubLObject list)`
`static SubLObject`	`duplicates(SubLObject list, SubLObject test, SubLObject key)`
`static SubLObject`	`duplicatesP(SubLObject list, SubLObject test, SubLObject key)`
`static SubLObject`	`every_in_list(SubLObject predicate, SubLObject list, SubLObject key)`
`static SubLObject`	`extremal(SubLObject list, SubLObject test, SubLObject key)` Return the first item in LIST which maximizes TEST
`static SubLObject`	`fast_delete_duplicates(SubLObject sequence, SubLObject test, SubLObject key, SubLObject hashtable, SubLObject start, SubLObject end)`
`static SubLObject`	`fast_set_difference(SubLObject list1, SubLObject list2, SubLObject test)` Like @xref set-difference except not slow.
`static SubLObject`	`fast_sets_equalP(SubLObject set1, SubLObject set2, SubLObject test)`
`static SubLObject`	`fast_subsetP(SubLObject list1, SubLObject list2, SubLObject test)`
`static SubLObject`	`filter_plist(SubLObject plist, SubLObject pred)` Creates a new plist based on PLIST, but only including properties which pass PRED.
`static SubLObject`	`find_all_if_not(SubLObject test, SubLObject seq, SubLObject key)`
`static SubLObject`	`find_if_not(SubLObject test, SubLObject sequence, SubLObject key, SubLObject start, SubLObject end)` Negated version of FIND-IF
`static SubLObject`	`first_n(SubLObject n, SubLObject list)` return the first N elements of LIST
`static SubLObject`	`flatten(SubLObject tree)` Non-recursive function which returns a list of the non-nil atoms in TREE.
`static SubLObject`	`flip_alist(SubLObject alist)`
`static SubLObject`	`flip_cons(SubLObject cons)`
`static SubLObject`	`greater_length_p(SubLObject seq1, SubLObject seq2)`
`static SubLObject`	`greater_or_same_length_p(SubLObject seq1, SubLObject seq2)`
`static SubLObject`	`init_list_utilities_file()`
`void`	`initializeVariables()` Initializes all global variables and private internal variables for constants defined in the file.
`static SubLObject`	`last1(SubLObject list)` Returns a list consisting of the last item in LIST.
`static SubLObject`	`lengthE(SubLObject seq, SubLObject n, SubLObject count_dotted_listP)`
`static SubLObject`	`lengthG(SubLObject seq, SubLObject n, SubLObject count_dotted_listP)`
`static SubLObject`	`lengthGE(SubLObject seq, SubLObject n, SubLObject count_dotted_listP)`
`static SubLObject`	`lengthL(SubLObject seq, SubLObject n, SubLObject count_dotted_listP)`
`static SubLObject`	`lengthLE(SubLObject seq, SubLObject n, SubLObject count_dotted_listP)`
`static SubLObject`	`list_of_type_p(SubLObject pred, SubLObject object)`
`static SubLObject`	`mapappend(SubLObject function, SubLObject list)`
`static SubLObject`	`mapcar_product(SubLObject function, SubLObject list1, SubLObject list2)`
`static SubLObject`	`mapnunion(SubLObject function, SubLObject list, SubLObject test)`
`static SubLObject`	`mapunion(SubLObject function, SubLObject list, SubLObject test)`
`static SubLObject`	`member_eqP(SubLObject item, SubLObject list)` An optimized form of (member? ITEM LIST #'eq)
`static SubLObject`	`member_equalP(SubLObject item, SubLObject list)` An optimized form of (member? ITEM LIST #'equal)
`static SubLObject`	`merge_plist(SubLObject plist_a, SubLObject plist_b)` Place all of the values of list B onto a copy of list A and return the resulting PLIST.
`static SubLObject`	`multisets_equalP(SubLObject set1, SubLObject set2, SubLObject test)`
`static SubLObject`	`nadd_to_end(SubLObject item, SubLObject list)` Returns the LIST with ITEM as the new last element.
`static SubLObject`	`ncons(SubLObject car, SubLObject cdr, SubLObject cons)` Return CONS after replacing its CAR and CDR.
`static SubLObject`	`negated_test_func(SubLObject obj)`
`static SubLObject`	`new_num_list(SubLObject num, SubLObject start)`
`static SubLObject`	`nmapcar(SubLObject function, SubLObject list)` A destructive version of @xref mapcar.
`static SubLObject`	`nmerge_plist(SubLObject plist_a, SubLObject plist_b)` Place all of the values of list B onto list A destructively and return the resulting PLIST.
`static SubLObject`	`non_dotted_list_p(SubLObject object)`
`static SubLObject`	`not_eq(SubLObject obj1, SubLObject obj2)`
`static SubLObject`	`nreplace_nth(SubLObject n, SubLObject v_new, SubLObject list)` replace the Nth item of LIST with NEW (destructive) This is a safer version of @xref set-nth
`static SubLObject`	`num_list_cached_internal(SubLObject num, SubLObject start)`
`static SubLObject`	`num_list_cached(SubLObject num, SubLObject start)`
`static SubLObject`	`num_list(SubLObject num, SubLObject start)`
`static SubLObject`	`numlist(SubLObject length, SubLObject start)`
`static SubLObject`	`only_one(SubLObject list)`
`static SubLObject`	`ordered_set_difference(SubLObject list1, SubLObject list2, SubLObject test, SubLObject key)` Like @xref set-difference except the order of returned items is the same order as in LIST1.
`static SubLObject`	`ordered_union(SubLObject set1, SubLObject set2, SubLObject test, SubLObject key)` like union only the result preserves the order of elements in the input sets
`static SubLObject`	`parametrized_median(SubLObject list, SubLObject sort_pred)` returns the median of a list, after sorting by SORT-PRED.
`static SubLObject`	`partition_list(SubLObject list, SubLObject func)`
`static SubLObject`	`permute_list_int(SubLObject elements, SubLObject test)` Given a list of elements, return all permutations of the elements
`static SubLObject`	`permute_list(SubLObject elements, SubLObject test)` Return a list of all possible distinct ordered lists of the elements in ELEMENTS.
`static SubLObject`	`permute(SubLObject list, SubLObject permutation)` e.g.
`static SubLObject`	`position_L(SubLObject item1, SubLObject item2, SubLObject guide_seq, SubLObject test, SubLObject key)` Return T iff the position of ITEM1 in GUIDE-SEQ is less than that of ITEM2.
`static SubLObject`	`proper_list_p(SubLObject object)`
`static SubLObject`	`proper_subsetp(SubLObject list1, SubLObject list2, SubLObject test, SubLObject key)`
`static SubLObject`	`quotify(SubLObject object)` Return an expression which, if evaluated, would return OBJECT.
`static SubLObject`	`recons(SubLObject car, SubLObject cdr, SubLObject cons)` Cons a new pair only if the CAR or CDR of CONS are not EQ to CAR and CDR.
`static SubLObject`	`remove_duplicate_forts(SubLObject v_forts)`
`static SubLObject`	`remove_if_not(SubLObject test, SubLObject sequence, SubLObject key, SubLObject start, SubLObject end, SubLObject count)` Negated version of REMOVE-IF
`static SubLObject`	`replace_nth(SubLObject n, SubLObject v_new, SubLObject list)` replace the Nth item of LIST with NEW (nondestructive)
`void`	`runTopLevelForms()` Runs all top-level forms in order.
`static SubLObject`	`safe_E(SubLObject object1, SubLObject object2)`
`static SubLObject`	`self_evaluating_form_p(SubLObject object)` Return T iff evaluation of OBJECT necessarily returns OBJECT.
`static SubLObject`	`sets_equalP(SubLObject set1, SubLObject set2, SubLObject test)`
`static SubLObject`	`setup_list_utilities_file()`
`static SubLObject`	`simple_tree_find_via_equalP(SubLObject item, SubLObject object)` Return T iff the non-nil ITEM is found in OBJECT (via EQUAL)
`static SubLObject`	`simple_tree_findP(SubLObject item, SubLObject object)` Return T iff the non-nil ITEM is found in OBJECT (via EQ)
`static SubLObject`	`singletonP(SubLObject list)`
`static SubLObject`	`sort_via_position_earlier(SubLObject item1, SubLObject item2)`
`static SubLObject`	`sort_via_position(SubLObject seq, SubLObject guide_seq, SubLObject test, SubLObject key)` Sort SEQ using GUIDE-SEQ as a positional guide.
`static SubLObject`	`splice_into_sorted_list(SubLObject object, SubLObject sorted_list, SubLObject predicate, SubLObject key)` Splice OBJECT into SORTED-LIST sorted by PREDICATE.
`static SubLObject`	`stable_sort_via_position(SubLObject seq, SubLObject guide_seq, SubLObject test, SubLObject key)` Stably sort SEQ using GUIDE-SEQ as a positional guide.
`static SubLObject`	`sublisp_boolean(SubLObject object)` Convert OBJECT to T or NIL
`static SubLObject`	`tree_count_if(SubLObject test, SubLObject object, SubLObject key)`
`static SubLObject`	`tree_find_any(SubLObject items, SubLObject tree, SubLObject test, SubLObject key)` Look for any of ITEMS in the tree OBJECT.
`static SubLObject`	`tree_find_if(SubLObject test, SubLObject object, SubLObject key)`
`static SubLObject`	`tree_find(SubLObject item, SubLObject object, SubLObject test, SubLObject key)` For the first sub-object in OBJECT (including OBJECT) that satisfies TEST applied to KEY of it and ITEM, return the sub-object.
`static SubLObject`	`tree_funcall_if(SubLObject test, SubLObject fn, SubLObject object, SubLObject key)`
`static SubLObject`	`tree_gather_internal(SubLObject object, SubLObject predicate, SubLObject test, SubLObject key, SubLObject subs_tooP, SubLObject so_far)`
`static SubLObject`	`tree_gather(SubLObject object, SubLObject predicate, SubLObject test, SubLObject key, SubLObject subs_tooP)`
`static SubLObject`	`tripleP(SubLObject list)`
`static SubLObject`	`verify_num_list(SubLObject num_list, SubLObject length, SubLObject start)`

Methods inherited from class com.cyc.tool.subl.util.SubLTranslatedFile
`extractFunctionNamed`

Methods inherited from class com.cyc.tool.subl.util.SubLTrampolineFile
`checkType, enforceType, extractBinaryFunc, extractCount, extractEnd, extractEndUsingSize, extractPackage, extractStart, extractUnaryFunc, main`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

me

public static final SubLFile me

myName

public static final java.lang.String myName

See Also:: Constant Field Values

$magic_hashing_cutoff$

public static SubLSymbol $magic_hashing_cutoff$

the cutoff beyond which it's more efficient to use a hashtable than an N^2 non-consing algorithm, used for the fast-* functions.

$negated_test_func$

public static SubLSymbol $negated_test_func$

This variable is only to be used below by the negated sequence and test functions

$subseq_subst_recursive_answers$

public static SubLSymbol $subseq_subst_recursive_answers$

$int0$80

public static final SubLInteger $int0$80

$str1$nth_cycling__width_must_be_greate

public static final SubLString $str1$nth_cycling__width_must_be_greate

$str2$nth_cycling__width_must_be_less_t

public static final SubLString $str2$nth_cycling__width_must_be_less_t

$str3$nth_cycling__width_overruns_offse

public static final SubLString $str3$nth_cycling__width_overruns_offse

$list4

public static final SubLList $list4

$sym5$PROGN

public static final SubLSymbol $sym5$PROGN

$sym6$CSETQ

public static final SubLSymbol $sym6$CSETQ

$sym7$FIRST

public static final SubLSymbol $sym7$FIRST

$sym8$CPOP

public static final SubLSymbol $sym8$CPOP

$list9

public static final SubLList $list9

$sym10$CLET

public static final SubLSymbol $sym10$CLET

$list11

public static final SubLList $list11

$sym12$CSETF

public static final SubLSymbol $sym12$CSETF

$sym13$CONS

public static final SubLSymbol $sym13$CONS

$sym14$FIRST_N

public static final SubLSymbol $sym14$FIRST_N

$sym15$_

public static final SubLSymbol $sym15$_

$list16

public static final SubLList $list16

$list17

public static final SubLList $list17

$list18

public static final SubLList $list18

$sym19$CDR

public static final SubLSymbol $sym19$CDR

$sym20$CAR

public static final SubLSymbol $sym20$CAR

$sym21$NULL

public static final SubLSymbol $sym21$NULL

$sym22$CDO

public static final SubLSymbol $sym22$CDO

$sym23$CAND

public static final SubLSymbol $sym23$CAND

$list24

public static final SubLList $list24

$list25

public static final SubLList $list25

$sym26$CDOLIST_MULTIPLE

public static final SubLSymbol $sym26$CDOLIST_MULTIPLE

$sym27$CINC

public static final SubLSymbol $sym27$CINC

$list28

public static final SubLList $list28

$str29$Malformed_csome_multiple_____S_wa

public static final SubLString $str29$Malformed_csome_multiple_____S_wa

$sym30$PUNLESS

public static final SubLSymbol $sym30$PUNLESS

$sym31$COR

public static final SubLSymbol $sym31$COR

$list32

public static final SubLList $list32

$sym33$LIST_VAR

public static final SubLSymbol $sym33$LIST_VAR

$sym34$_

public static final SubLSymbol $sym34$_

$list35

public static final SubLList $list35

$sym36$CDOLIST

public static final SubLSymbol $sym36$CDOLIST

$sym37$REVERSE

public static final SubLSymbol $sym37$REVERSE

$sym38$LIST_VAR

public static final SubLSymbol $sym38$LIST_VAR

$sym39$1_

public static final SubLSymbol $sym39$1_

$sym40$LENGTH

public static final SubLSymbol $sym40$LENGTH

$list41

public static final SubLList $list41

$sym42$LIST_VAR

public static final SubLSymbol $sym42$LIST_VAR

$sym43$CDOLIST_CYCLING_COMPLEX

public static final SubLSymbol $sym43$CDOLIST_CYCLING_COMPLEX

$list44

public static final SubLList $list44

$str45$COUNTER

public static final SubLString $str45$COUNTER

$str46$_orig

public static final SubLString $str46$_orig

$str47$_cdr

public static final SubLString $str47$_cdr

$sym48$NTH_CYCLING

public static final SubLSymbol $sym48$NTH_CYCLING

$list49

public static final SubLList $list49

$list50

public static final SubLList $list50

$kw51$ALLOW_OTHER_KEYS

public static final SubLSymbol $kw51$ALLOW_OTHER_KEYS

$kw52$LIST_TYPE

public static final SubLSymbol $kw52$LIST_TYPE

$sym53$LISTP

public static final SubLSymbol $sym53$LISTP

$kw54$DONE

public static final SubLSymbol $kw54$DONE

$sym55$SUBTREE_LIST_VAR

public static final SubLSymbol $sym55$SUBTREE_LIST_VAR

$sym56$CURRENT_SUBTREE_VAR

public static final SubLSymbol $sym56$CURRENT_SUBTREE_VAR

$sym57$NODE_VAR

public static final SubLSymbol $sym57$NODE_VAR

$sym58$LIST

public static final SubLSymbol $sym58$LIST

$sym59$DO_LIST

public static final SubLSymbol $sym59$DO_LIST

$sym60$PIF

public static final SubLSymbol $sym60$PIF

$sym61$CPUSH

public static final SubLSymbol $sym61$CPUSH

$sym62$_OPTIONAL

public static final SubLSymbol $sym62$_OPTIONAL

$sym63$SEQUENCEP

public static final SubLSymbol $sym63$SEQUENCEP

$str64$

public static final SubLString $str64$

$kw65$DOT_FOR_DOTTED_LIST

public static final SubLSymbol $kw65$DOT_FOR_DOTTED_LIST

$sym66$NEGATED_TEST_FUNC

public static final SubLSymbol $sym66$NEGATED_TEST_FUNC

$sym67$POSITION_IF_BINARY_LAMBDA

public static final SubLSymbol $sym67$POSITION_IF_BINARY_LAMBDA

$sym68$PROPER_LIST_P

public static final SubLSymbol $sym68$PROPER_LIST_P

$sym69$NON_DOTTED_LIST_P

public static final SubLSymbol $sym69$NON_DOTTED_LIST_P

$sym70$NON_NEGATIVE_INTEGER_P

public static final SubLSymbol $sym70$NON_NEGATIVE_INTEGER_P

$kw71$DELETED

public static final SubLSymbol $kw71$DELETED

$list72

public static final SubLList $list72

$kw73$DUMMY

public static final SubLSymbol $kw73$DUMMY

$sym74$TREE_POSITION_DFS

public static final SubLSymbol $sym74$TREE_POSITION_DFS

$sym75$TREE_POSITION_BFS

public static final SubLSymbol $sym75$TREE_POSITION_BFS

$sym76$LESSER_LENGTH_P

public static final SubLSymbol $sym76$LESSER_LENGTH_P

$list77

public static final SubLList $list77

$str78$The_lists_of_keys_and_data_are_of

public static final SubLString $str78$The_lists_of_keys_and_data_are_of

$sym79$DOUBLETON_

public static final SubLSymbol $sym79$DOUBLETON_

$list80

public static final SubLList $list80

$str81$FIRST_OF_will_multiply_evaluate__

public static final SubLString $str81$FIRST_OF_will_multiply_evaluate__

$sym82$FIF

public static final SubLSymbol $sym82$FIF

$sym83$FUNCTION_SPEC_P

public static final SubLSymbol $sym83$FUNCTION_SPEC_P

$sym84$POSITIVE_INTEGER_P

public static final SubLSymbol $sym84$POSITIVE_INTEGER_P

$sym85$NREVERSE

public static final SubLSymbol $sym85$NREVERSE

$sym86$VECTORP

public static final SubLSymbol $sym86$VECTORP

$str87$_s_was_not_a_singleton

public static final SubLString $str87$_s_was_not_a_singleton

$kw88$IGNORE_ERRORS_TARGET

public static final SubLSymbol $kw88$IGNORE_ERRORS_TARGET

$sym89$IGNORE_ERRORS_HANDLER

public static final SubLSymbol $sym89$IGNORE_ERRORS_HANDLER

$float90$0_01

public static final SubLFloat $float90$0_01

$sym91$INTEGERP

public static final SubLSymbol $sym91$INTEGERP

$str92$Position_is_not_valid_for_the_siz

public static final SubLString $str92$Position_is_not_valid_for_the_siz

$sym93$NUM_LIST_CACHED

public static final SubLSymbol $sym93$NUM_LIST_CACHED

$sym94$_NUM_LIST_CACHED_CACHING_STATE_

public static final SubLSymbol $sym94$_NUM_LIST_CACHED_CACHING_STATE_

$int95$100

public static final SubLInteger $int95$100

$kw96$_MEMOIZED_ITEM_NOT_FOUND_

public static final SubLSymbol $kw96$_MEMOIZED_ITEM_NOT_FOUND_

$sym97$_

public static final SubLSymbol $sym97$_

$sym98$__

public static final SubLSymbol $sym98$__

$str99$Number_of_repetitions_must_be_gre

public static final SubLString $str99$Number_of_repetitions_must_be_gre

$kw100$FAILED

public static final SubLSymbol $kw100$FAILED

$kw101$SUCCEEDED

public static final SubLSymbol $kw101$SUCCEEDED

$kw102$UPDATED

public static final SubLSymbol $kw102$UPDATED

$sym103$TREE_SET_EQUAL_

public static final SubLSymbol $sym103$TREE_SET_EQUAL_

$sym104$FUNCTION_SYMBOL_P

public static final SubLSymbol $sym104$FUNCTION_SYMBOL_P

$sym105$FLIP_CONS

public static final SubLSymbol $sym105$FLIP_CONS

$sym106$QUOTE

public static final SubLSymbol $sym106$QUOTE

$sym107$STRING_

public static final SubLSymbol $sym107$STRING_

$sym108$STRING_

public static final SubLSymbol $sym108$STRING_

$sym109$SYMBOL_NAME

public static final SubLSymbol $sym109$SYMBOL_NAME

$sym110$SAFE_SPLICE_INTO_SORTED_LIST

public static final SubLSymbol $sym110$SAFE_SPLICE_INTO_SORTED_LIST

$kw111$TEST

public static final SubLSymbol $kw111$TEST

$kw112$OWNER

public static final SubLSymbol $kw112$OWNER

$kw113$CLASSES

public static final SubLSymbol $kw113$CLASSES

$kw114$KB

public static final SubLSymbol $kw114$KB

$kw115$TINY

public static final SubLSymbol $kw115$TINY

$kw116$WORKING_

public static final SubLSymbol $kw116$WORKING_

$list117

public static final SubLList $list117

$sym118$_REST

public static final SubLSymbol $sym118$_REST

$list119

public static final SubLList $list119

$list120

public static final SubLList $list120

$sym121$CAR_IS_EL_VAR_

public static final SubLSymbol $sym121$CAR_IS_EL_VAR_

$str122$_s____s

public static final SubLString $str122$_s____s

$kw123$TEMP

public static final SubLSymbol $kw123$TEMP

$int124$500

public static final SubLInteger $int124$500

$str125$remove_duplicates_eq_table_lock

public static final SubLString $str125$remove_duplicates_eq_table_lock

$str126$remove_duplicates_eql_table_lock

public static final SubLString $str126$remove_duplicates_eql_table_lock

$str127$remove_duplicates_equal_table_loc

public static final SubLString $str127$remove_duplicates_equal_table_loc

$str128$remove_duplicates_equalp_table_lo

public static final SubLString $str128$remove_duplicates_equalp_table_lo

$sym129$HASH_TABLE_P

public static final SubLSymbol $sym129$HASH_TABLE_P

$kw130$NOT_UNIQUE

public static final SubLSymbol $kw130$NOT_UNIQUE

$kw131$UNIQUE

public static final SubLSymbol $kw131$UNIQUE

$sym132$TERM__

public static final SubLSymbol $sym132$TERM__

$sym133$SAFE__

public static final SubLSymbol $sym133$SAFE__

$sym134$ALIST_P

public static final SubLSymbol $sym134$ALIST_P

$list135

public static final SubLList $list135

$list136

public static final SubLList $list136

$sym137$ALIST_PUSHNEW

public static final SubLSymbol $sym137$ALIST_PUSHNEW

$list138

public static final SubLList $list138

$sym139$ALIST_PUSH

public static final SubLSymbol $sym139$ALIST_PUSH

$list140

public static final SubLList $list140

$sym141$ALIST_ENTER

public static final SubLSymbol $sym141$ALIST_ENTER

$list142

public static final SubLList $list142

$list143

public static final SubLList $list143

$sym144$PUTF

public static final SubLSymbol $sym144$PUTF

$list145

public static final SubLList $list145

$list146

public static final SubLList $list146

$kw147$INCREMENT

public static final SubLSymbol $kw147$INCREMENT

$sym148$PLIST_ENTER

public static final SubLSymbol $sym148$PLIST_ENTER

$sym149$PLIST_LOOKUP

public static final SubLSymbol $sym149$PLIST_LOOKUP

$list150

public static final SubLList $list150

$sym151$PROPERTY_LIST_P

public static final SubLSymbol $sym151$PROPERTY_LIST_P

$kw152$NO_VALUE

public static final SubLSymbol $kw152$NO_VALUE

$sym153$PLISTLIST_SORT_KEY

public static final SubLSymbol $sym153$PLISTLIST_SORT_KEY

$str154$_A_and__A

public static final SubLString $str154$_A_and__A

$sym155$PRINC_TO_STRING

public static final SubLSymbol $sym155$PRINC_TO_STRING

$str156$__

public static final SubLString $str156$__

$str157$__and_

public static final SubLString $str157$__and_

$str158$_a___a

public static final SubLString $str158$_a_____a__

$sym159$DOUBLE_FLOAT

public static final SubLSymbol $sym159$DOUBLE_FLOAT

$sym160$STR

public static final SubLSymbol $sym160$STR

$str161$_a___4_2f__

public static final SubLString $str161$_a___4_2f__

$str162$_a_a

public static final SubLString $str162$_a___a__

$sym163$TO_STRING

public static final SubLSymbol $sym163$TO_STRING

$str164$___

public static final SubLString $str164$___

$list165

public static final SubLList $list165

$sym166$PLUSP

public static final SubLSymbol $sym166$PLUSP

$float167$0_5

public static final SubLFloat $float167$0_5

$sym168$SORT_VIA_POSITION_EARLIER

public static final SubLSymbol $sym168$SORT_VIA_POSITION_EARLIER

$sym169$SORT_VIA_TEST_EARLIER

public static final SubLSymbol $sym169$SORT_VIA_TEST_EARLIER

$sym170$_

public static final SubLSymbol $sym170$_

$sym171$SAFE__

public static final SubLSymbol $sym171$SAFE__

$sym172$SAFE_TREE__

public static final SubLSymbol $sym172$SAFE_TREE__

$sym173$SET__

public static final SubLSymbol $sym173$SET__

$sym174$NOT_CONSP

public static final SubLSymbol $sym174$NOT_CONSP

$sym175$LIST_STRUCTURE__

public static final SubLSymbol $sym175$LIST_STRUCTURE__

$sym176$FALSE

public static final SubLSymbol $sym176$FALSE

$sym177$_

public static final SubLSymbol $sym177$_

$kw178$LESS

public static final SubLSymbol $kw178$LESS

$kw179$EQUAL

public static final SubLSymbol $kw179$EQUAL

$kw180$GREATER

public static final SubLSymbol $kw180$GREATER

$sym181$MAPCAR

public static final SubLSymbol $sym181$MAPCAR

$list182

public static final SubLList $list182

$sym183$GET_ARGLIST

public static final SubLSymbol $sym183$GET_ARGLIST

$list184

public static final SubLList $list184

$kw185$DOCUMENTATION

public static final SubLSymbol $kw185$DOCUMENTATION

$list186

public static final SubLList $list186

$sym187$KEYWORDP

public static final SubLSymbol $sym187$KEYWORDP

$sym188$SYMBOLP

public static final SubLSymbol $sym188$SYMBOLP

$str189$ExpectedSgot__S

public static final SubLString $str189$Expected__S__got__S

$str190$_S_was_not_a_form_with_operator__

public static final SubLString $str190$_S_was_not_a_form_with_operator__

$sym191$ATOM

public static final SubLSymbol $sym191$ATOM

$sym192$ASSOC

public static final SubLSymbol $sym192$ASSOC

$sym193$STRINGP

public static final SubLSymbol $sym193$STRINGP

$sym194$CATCH_ERROR_MESSAGE_HANDLER

public static final SubLSymbol $sym194$CATCH_ERROR_MESSAGE_HANDLER

$sym195$NEW_DICTIONARY

public static final SubLSymbol $sym195$NEW_DICTIONARY

$list196

public static final SubLList $list196

Method Detail

sublisp_boolean

public static final SubLObject sublisp_boolean(SubLObject object)

Convert OBJECT to T or NIL

not_eq

public static final SubLObject not_eq(SubLObject obj1,
                                      SubLObject obj2)

cdddr

public static final SubLObject cdddr(SubLObject cons)

proper_subsetp

public static final SubLObject proper_subsetp(SubLObject list1,
                                              SubLObject list2,
                                              SubLObject test,
                                              SubLObject key)

lengthL

public static final SubLObject lengthL(SubLObject seq,
                                       SubLObject n,
                                       SubLObject count_dotted_listP)

Parameters:: count-dotted-list? - whether (1 2 . 3) counts as length 2 or 3. If it is t, it counts as length 3, otherwise it counts as length 2.
Returns:: boolean; whether the length of SEQ is strictly less than N.

lengthLE

public static final SubLObject lengthLE(SubLObject seq,
                                        SubLObject n,
                                        SubLObject count_dotted_listP)

Parameters:: count-dotted-list? - whether (1 2 . 3) counts as length 2 or 3. If it is t, it counts as length 3, otherwise it counts as length 2.
Returns:: boolean; whether the length of SEQ is less than or equal to N.

lengthE

public static final SubLObject lengthE(SubLObject seq,
                                       SubLObject n,
                                       SubLObject count_dotted_listP)

Parameters:: count-dotted-list? - whether (1 2 . 3) counts as length 2 or 3. If it is t, it counts as length 3, otherwise it counts as length 2.
Returns:: boolean; whether the length of SEQ is exactly N.

lengthG

public static final SubLObject lengthG(SubLObject seq,
                                       SubLObject n,
                                       SubLObject count_dotted_listP)

Parameters:: count-dotted-list? - whether (1 2 . 3) counts as length 2 or 3. If it is t, it counts as length 3, otherwise it counts as length 2.
Returns:: boolean; whether the length of SEQ is strictly greater than N.

lengthGE

public static final SubLObject lengthGE(SubLObject seq,
                                        SubLObject n,
                                        SubLObject count_dotted_listP)

Parameters:: count-dotted-list? - whether (1 2 . 3) counts as length 2 or 3. If it is t, it counts as length 3, otherwise it counts as length 2.
Returns:: boolean; whether the length of SEQ is greater than or equal to N.

greater_length_p

public static final SubLObject greater_length_p(SubLObject seq1,
                                                SubLObject seq2)

Parameters:: seq1; - a sequence.
Returns:: boolean; whether the first sequence is of greater length than the second sequence.

greater_or_same_length_p

public static final SubLObject greater_or_same_length_p(SubLObject seq1,
                                                        SubLObject seq2)

Parameters:: seq1; - a sequence.
Returns:: boolean; whether the first sequence is of greater or equal length than the second sequence.

proper_list_p

public static final SubLObject proper_list_p(SubLObject object)

dotted_list_p

public static final SubLObject dotted_list_p(SubLObject object)

non_dotted_list_p

public static final SubLObject non_dotted_list_p(SubLObject object)

dotted_length

public static final SubLObject dotted_length(SubLObject cons)

negated_test_func

public static final SubLObject negated_test_func(SubLObject obj)

remove_if_not

public static final SubLObject remove_if_not(SubLObject test,
                                             SubLObject sequence,
                                             SubLObject key,
                                             SubLObject start,
                                             SubLObject end,
                                             SubLObject count)

Negated version of REMOVE-IF

delete_if_not

public static final SubLObject delete_if_not(SubLObject test,
                                             SubLObject sequence,
                                             SubLObject key,
                                             SubLObject start,
                                             SubLObject end,
                                             SubLObject count)

Negated version of DELETE-IF

find_if_not

public static final SubLObject find_if_not(SubLObject test,
                                           SubLObject sequence,
                                           SubLObject key,
                                           SubLObject start,
                                           SubLObject end)

Negated version of FIND-IF

recons

public static final SubLObject recons(SubLObject car,
                                      SubLObject cdr,
                                      SubLObject cons)

Cons a new pair only if the CAR or CDR of CONS are not EQ to CAR and CDR.

See Also:: for a destructive version of this.

ncons

public static final SubLObject ncons(SubLObject car,
                                     SubLObject cdr,
                                     SubLObject cons)

Return CONS after replacing its CAR and CDR.

See Also:: for a non-destructive version of this.

delete_first

public static final SubLObject delete_first(SubLObject obj,
                                            SubLObject sequence,
                                            SubLObject test)

nmapcar

public static final SubLObject nmapcar(SubLObject function,
                                       SubLObject list)

A destructive version of @xref mapcar. WARNING: This will produce really funky behaviour if elements of LIST share list structure.

mapappend

public static final SubLObject mapappend(SubLObject function,
                                         SubLObject list)

mapunion

public static final SubLObject mapunion(SubLObject function,
                                        SubLObject list,
                                        SubLObject test)

Parameters:: FUNCTION - a unary function that returns a list.; LIST - a list, each of whose elements is a valid argument to FUNCTION. FUNCTION is applied to each element of LIST to get a new element X (which is also a list). Then we return the unique elements of X, concatenating over all elements of LIST. e.g. (define mapabs (list) (ret (mapcar 'abs list))) (mapunion 'mapabs '((1 2 3) (0 -1 -2))) -> (1 2 3 0)

mapnunion

public static final SubLObject mapnunion(SubLObject function,
                                         SubLObject list,
                                         SubLObject test)

mapcar_product

public static final SubLObject mapcar_product(SubLObject function,
                                              SubLObject list1,
                                              SubLObject list2)

last1

public static final SubLObject last1(SubLObject list)

Returns a list consisting of the last item in LIST.

nadd_to_end

public static final SubLObject nadd_to_end(SubLObject item,
                                           SubLObject list)

Returns the LIST with ITEM as the new last element. LIST may be destructively modified.

partition_list

public static final SubLObject partition_list(SubLObject list,
                                              SubLObject func)

Returns:: 0 list; all the elements of LIST which pass FUNC

find_all_if_not

public static final SubLObject find_all_if_not(SubLObject test,
                                               SubLObject seq,
                                               SubLObject key)

only_one

public static final SubLObject only_one(SubLObject list)

flatten

public static final SubLObject flatten(SubLObject tree)

Non-recursive function which returns a list of the non-nil atoms in TREE.

first_n

public static final SubLObject first_n(SubLObject n,
                                       SubLObject list)

return the first N elements of LIST

nreplace_nth

public static final SubLObject nreplace_nth(SubLObject n,
                                            SubLObject v_new,
                                            SubLObject list)

replace the Nth item of LIST with NEW (destructive) This is a safer version of @xref set-nth

replace_nth

public static final SubLObject replace_nth(SubLObject n,
                                           SubLObject v_new,
                                           SubLObject list)

replace the Nth item of LIST with NEW (nondestructive)

num_list

public static final SubLObject num_list(SubLObject num,
                                        SubLObject start)

Returns:: list; a list of length NUM containing the integers START to NUM-1+START.

new_num_list

public static final SubLObject new_num_list(SubLObject num,
                                            SubLObject start)

Returns:: list; a list of length NUM containing the integers START to NUM-1+START.

verify_num_list

public static final SubLObject verify_num_list(SubLObject num_list,
                                               SubLObject length,
                                               SubLObject start)

Returns:: BOOLEAN; Is NUM-LIST a list of length LENGTH containing the integers START to LENGTH-1+START?

num_list_cached_internal

public static final SubLObject num_list_cached_internal(SubLObject num,
                                                        SubLObject start)

Returns:: list; a list of length NUM containing the integers START to NUM-1+START.

num_list_cached

public static final SubLObject num_list_cached(SubLObject num,
                                               SubLObject start)

numlist

public static final SubLObject numlist(SubLObject length,
                                       SubLObject start)

Returns:: list; a list of length LENGTH containing the numbers 0 + START to LENGTH-1 + START.

member_eqP

public static final SubLObject member_eqP(SubLObject item,
                                          SubLObject list)

An optimized form of (member? ITEM LIST #'eq)

member_equalP

public static final SubLObject member_equalP(SubLObject item,
                                             SubLObject list)

An optimized form of (member? ITEM LIST #'equal)

singletonP

public static final SubLObject singletonP(SubLObject list)

doubletonP

public static final SubLObject doubletonP(SubLObject list)

tripleP

public static final SubLObject tripleP(SubLObject list)

duplicatesP

public static final SubLObject duplicatesP(SubLObject list,
                                           SubLObject test,
                                           SubLObject key)

duplicates

public static final SubLObject duplicates(SubLObject list,
                                          SubLObject test,
                                          SubLObject key)

multisets_equalP

public static final SubLObject multisets_equalP(SubLObject set1,
                                                SubLObject set2,
                                                SubLObject test)

sets_equalP

public static final SubLObject sets_equalP(SubLObject set1,
                                           SubLObject set2,
                                           SubLObject test)

fast_sets_equalP

public static final SubLObject fast_sets_equalP(SubLObject set1,
                                                SubLObject set2,
                                                SubLObject test)

fast_subsetP

public static final SubLObject fast_subsetP(SubLObject list1,
                                            SubLObject list2,
                                            SubLObject test)

ordered_union

public static final SubLObject ordered_union(SubLObject set1,
                                             SubLObject set2,
                                             SubLObject test,
                                             SubLObject key)

like union only the result preserves the order of elements in the input sets

ordered_set_difference

public static final SubLObject ordered_set_difference(SubLObject list1,
                                                      SubLObject list2,
                                                      SubLObject test,
                                                      SubLObject key)

Like @xref set-difference except the order of returned items is the same order as in LIST1.

fast_set_difference

public static final SubLObject fast_set_difference(SubLObject list1,
                                                   SubLObject list2,
                                                   SubLObject test)

Like @xref set-difference except not slow.

flip_alist

public static final SubLObject flip_alist(SubLObject alist)

flip_cons

public static final SubLObject flip_cons(SubLObject cons)

self_evaluating_form_p

public static final SubLObject self_evaluating_form_p(SubLObject object)

Return T iff evaluation of OBJECT necessarily returns OBJECT.

quotify

public static final SubLObject quotify(SubLObject object)

Return an expression which, if evaluated, would return OBJECT.

splice_into_sorted_list

public static final SubLObject splice_into_sorted_list(SubLObject object,
                                                       SubLObject sorted_list,
                                                       SubLObject predicate,
                                                       SubLObject key)

Splice OBJECT into SORTED-LIST sorted by PREDICATE.

tree_funcall_if

public static final SubLObject tree_funcall_if(SubLObject test,
                                               SubLObject fn,
                                               SubLObject object,
                                               SubLObject key)

fast_delete_duplicates

public static final SubLObject fast_delete_duplicates(SubLObject sequence,
                                                      SubLObject test,
                                                      SubLObject key,
                                                      SubLObject hashtable,
                                                      SubLObject start,
                                                      SubLObject end)

remove_duplicate_forts

public static final SubLObject remove_duplicate_forts(SubLObject v_forts)

Returns:: the list FORTS with all duplicates removed

delete_duplicate_forts

public static final SubLObject delete_duplicate_forts(SubLObject v_forts)

Returns:: listp; the list FORTS with all duplicates destructively removed

delete_duplicates_sorted

public static final SubLObject delete_duplicates_sorted(SubLObject sorted_list,
                                                        SubLObject test)

Deletes duplicates from SORTED-LIST.

alist_p

public static final SubLObject alist_p(SubLObject object)

Return T iff OBJECT is an association list.

alist_lookup

public static final SubLObject alist_lookup(SubLObject alist,
                                            SubLObject key,
                                            SubLObject test,
                                            SubLObject v_default)

Return the value associated with KEY in ALIST (using TEST for key equality). Return DEFAULT if KEY is not present. Return a second value of T iff KEY was found.

alist_lookup_without_values

public static final SubLObject alist_lookup_without_values(SubLObject alist,
                                                           SubLObject key,
                                                           SubLObject test,
                                                           SubLObject v_default)

Return the value associated with KEY in ALIST (using TEST for key equality). Return DEFAULT if KEY is not present. Unlike ALIST-LOOKUP, only 1 value is returned.

alist_has_keyP

public static final SubLObject alist_has_keyP(SubLObject alist,
                                              SubLObject key,
                                              SubLObject test)

Returns:: booleanp; whether KEY is a key in the association list ALIST

alist_enter

public static final SubLObject alist_enter(SubLObject alist,
                                           SubLObject key,
                                           SubLObject value,
                                           SubLObject test)

Note that VALUE is associated with KEY in ALIST (using TEST for key equality). Return the resulting alist. Return a second value of T iff KEY was found.

alist_enter_without_values

public static final SubLObject alist_enter_without_values(SubLObject alist,
                                                          SubLObject key,
                                                          SubLObject value,
                                                          SubLObject test)

Note that VALUE is associated with KEY in ALIST (using TEST for key equality). Return the resulting alist. Unlike ALIST-ENTER, only 1 value is returned.

alist_delete

public static final SubLObject alist_delete(SubLObject alist,
                                            SubLObject key,
                                            SubLObject test)

Delete any association for KEY in ALIST (using TEST for key equality). Return the resulting alist. Return a second value of T iff KEY was found.

alist_push

public static final SubLObject alist_push(SubLObject alist,
                                          SubLObject key,
                                          SubLObject value,
                                          SubLObject test)

Note that VALUE is in a list associated with KEY in ALIST (using TEST for key equality). Return the resulting alist. Return a second value of T iff KEY was found.

alist_keys

public static final SubLObject alist_keys(SubLObject alist)

Return a list of all the keys of ALIST.

alist_values

public static final SubLObject alist_values(SubLObject alist)

Return a list of all the values of ALIST.

alist_optimize

public static final SubLObject alist_optimize(SubLObject alist,
                                              SubLObject predicate)

Return a copy of ALIST where the order of the keys have been optimized (sorted) via the preference PREDICATE.

alist_to_hash_table

public static final SubLObject alist_to_hash_table(SubLObject alist,
                                                   SubLObject test)

Return a hashtable of all the (key . value) entries in ALIST. TEST is the equality test for keys in ALIST.

alist_to_reverse_hash_table

public static final SubLObject alist_to_reverse_hash_table(SubLObject alist,
                                                           SubLObject test)

Return a hashtable of all the (key . value) entries in ALIST using the value as the key and the key as the value. TEST is the equality test for values in ALIST.

filter_plist

public static final SubLObject filter_plist(SubLObject plist,
                                            SubLObject pred)

Creates a new plist based on PLIST, but only including properties which pass PRED.

nmerge_plist

public static final SubLObject nmerge_plist(SubLObject plist_a,
                                            SubLObject plist_b)

Place all of the values of list B onto list A destructively and return the resulting PLIST.

merge_plist

public static final SubLObject merge_plist(SubLObject plist_a,
                                           SubLObject plist_b)

Place all of the values of list B onto a copy of list A and return the resulting PLIST.

any_in_list

public static final SubLObject any_in_list(SubLObject predicate,
                                           SubLObject list,
                                           SubLObject key)

every_in_list

public static final SubLObject every_in_list(SubLObject predicate,
                                             SubLObject list,
                                             SubLObject key)

extremal

public static final SubLObject extremal(SubLObject list,
                                        SubLObject test,
                                        SubLObject key)

Return the first item in LIST which maximizes TEST

position_L

public static final SubLObject position_L(SubLObject item1,
                                          SubLObject item2,
                                          SubLObject guide_seq,
                                          SubLObject test,
                                          SubLObject key)

Return T iff the position of ITEM1 in GUIDE-SEQ is less than that of ITEM2. All objects not in the GUIDE-SEQ are considered to be after all those that are, and are themselves considered equivalent by this test.

sort_via_position

public static final SubLObject sort_via_position(SubLObject seq,
                                                 SubLObject guide_seq,
                                                 SubLObject test,
                                                 SubLObject key)

Sort SEQ using GUIDE-SEQ as a positional guide. Objects in GUIDE-SEQ appear in the order they are in GUIDE-SEQ. Objects not in GUIDE-SEQ all appear after those that do.

stable_sort_via_position

public static final SubLObject stable_sort_via_position(SubLObject seq,
                                                        SubLObject guide_seq,
                                                        SubLObject test,
                                                        SubLObject key)

Stably sort SEQ using GUIDE-SEQ as a positional guide. Objects in GUIDE-SEQ appear in the order they are in GUIDE-SEQ. Objects not in GUIDE-SEQ all appear after those that do.

sort_via_position_earlier

public static final SubLObject sort_via_position_earlier(SubLObject item1,
                                                         SubLObject item2)

safe_E

public static final SubLObject safe_E(SubLObject object1,
                                      SubLObject object2)

parametrized_median

public static final SubLObject parametrized_median(SubLObject list,
                                                   SubLObject sort_pred)

returns the median of a list, after sorting by SORT-PRED. It picks the larger if the median falls in the middle.

tree_find

public static final SubLObject tree_find(SubLObject item,
                                         SubLObject object,
                                         SubLObject test,
                                         SubLObject key)

For the first sub-object in OBJECT (including OBJECT) that satisfies TEST applied to KEY of it and ITEM, return the sub-object.

Returns:: 0 the found sub-object.

simple_tree_findP

public static final SubLObject simple_tree_findP(SubLObject item,
                                                 SubLObject object)

Return T iff the non-nil ITEM is found in OBJECT (via EQ)

simple_tree_find_via_equalP

public static final SubLObject simple_tree_find_via_equalP(SubLObject item,
                                                           SubLObject object)

Return T iff the non-nil ITEM is found in OBJECT (via EQUAL)

tree_find_any

public static final SubLObject tree_find_any(SubLObject items,
                                             SubLObject tree,
                                             SubLObject test,
                                             SubLObject key)

Look for any of ITEMS in the tree OBJECT. Return the first item found, or NIL if none found.

cons_tree_find_if

public static final SubLObject cons_tree_find_if(SubLObject test,
                                                 SubLObject object,
                                                 SubLObject key)

Obsolete -- use tree-find-if

tree_find_if

public static final SubLObject tree_find_if(SubLObject test,
                                            SubLObject object,
                                            SubLObject key)

tree_count_if

public static final SubLObject tree_count_if(SubLObject test,
                                             SubLObject object,
                                             SubLObject key)

tree_gather

public static final SubLObject tree_gather(SubLObject object,
                                           SubLObject predicate,
                                           SubLObject test,
                                           SubLObject key,
                                           SubLObject subs_tooP)

tree_gather_internal

public static final SubLObject tree_gather_internal(SubLObject object,
                                                    SubLObject predicate,
                                                    SubLObject test,
                                                    SubLObject key,
                                                    SubLObject subs_tooP,
                                                    SubLObject so_far)

delete_subsumed_items

public static final SubLObject delete_subsumed_items(SubLObject list,
                                                     SubLObject test,
                                                     SubLObject key)

if a and b are in LIST, and (TEST (KEY a) (KEY b)) is true, don't include b in the result

permute_list

public static final SubLObject permute_list(SubLObject elements,
                                            SubLObject test)

Return a list of all possible distinct ordered lists of the elements in ELEMENTS. By convention, (permute-list NIL) -> NIL. By convention, if TEST is NIL, the check for duplicates is skipped.

permute_list_int

public static final SubLObject permute_list_int(SubLObject elements,
                                                SubLObject test)

Given a list of elements, return all permutations of the elements

all_permutations

public static final SubLObject all_permutations(SubLObject n)

Returns all permutations of the numbers from 0 to N-1. By convention, (all-permutations 0) -> (NIL).

permute

public static final SubLObject permute(SubLObject list,
                                       SubLObject permutation)

e.g. (permute '(a b c) '(2 0 1)) -> (c a b) By convention, (permute X NIL) -> X.

cartesian_product

public static final SubLObject cartesian_product(SubLObject l,
                                                 SubLObject fun,
                                                 SubLObject start,
                                                 SubLObject test)

Parameters:: l; - listp: a list of lists; fun; - fboundp: an optional function to build the product; start; - listp: an optional seed for building the product; test; - fboundp (binary function) or nil

cartesian_helper

public static final SubLObject cartesian_helper(SubLObject a,
                                                SubLObject b,
                                                SubLObject fun)

takes two lists and returns the cartesian product. fun generally should be #'cons

list_of_type_p

public static final SubLObject list_of_type_p(SubLObject pred,
                                              SubLObject object)

Parameters:: PRED; - unary function Returns T if: - OBJECT is a non-dotted list, and - PRED returns non-nil when applied to any item in OBJECT Otherwise, returns NIL.

declare_list_utilities_file

public static final SubLObject declare_list_utilities_file()

init_list_utilities_file

public static final SubLObject init_list_utilities_file()

setup_list_utilities_file

public static final SubLObject setup_list_utilities_file()

declareFunctions

public void declareFunctions()

Description copied from interface: SubLFile

Declares the mapping between functions and symbols for all named functions defined in the file. Like CRTL define.

initializeVariables

public void initializeVariables()

Description copied from interface: SubLFile

Initializes all global variables and private internal variables for constants defined in the file. Like CRTL init.

runTopLevelForms

public void runTopLevelForms()

Description copied from interface: SubLFile

Runs all top-level forms in order. Like CRTL setup.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.cyc.cycjava.cycl Class list_utilities

me

myName

$magic_hashing_cutoff$

$negated_test_func$

$subseq_subst_recursive_answers$

$int0$80

$str1$nth_cycling__width_must_be_greate

$str2$nth_cycling__width_must_be_less_t

$str3$nth_cycling__width_overruns_offse

$list4

$sym5$PROGN

$sym6$CSETQ

$sym7$FIRST

$sym8$CPOP

$list9

$sym10$CLET

$list11

$sym12$CSETF

$sym13$CONS

$sym14$FIRST_N

$sym15$_

$list16

$list17

$list18

$sym19$CDR

$sym20$CAR

$sym21$NULL

$sym22$CDO

$sym23$CAND

$list24

$list25

$sym26$CDOLIST_MULTIPLE

$sym27$CINC

$list28

$str29$Malformed_csome_multiple_____S_wa

$sym30$PUNLESS

$sym31$COR

$list32

$sym33$LIST_VAR

$sym34$_

$list35

$sym36$CDOLIST

$sym37$REVERSE

$sym38$LIST_VAR

$sym39$1_

$sym40$LENGTH

$list41

$sym42$LIST_VAR

$sym43$CDOLIST_CYCLING_COMPLEX

$list44

$str45$COUNTER

$str46$_orig

$str47$_cdr

$sym48$NTH_CYCLING

$list49

$list50

$kw51$ALLOW_OTHER_KEYS

$kw52$LIST_TYPE

$sym53$LISTP

$kw54$DONE

$sym55$SUBTREE_LIST_VAR

$sym56$CURRENT_SUBTREE_VAR

$sym57$NODE_VAR

$sym58$LIST

$sym59$DO_LIST

$sym60$PIF

$sym61$CPUSH

$sym62$_OPTIONAL

$sym63$SEQUENCEP

$str64$

$kw65$DOT_FOR_DOTTED_LIST

$sym66$NEGATED_TEST_FUNC

$sym67$POSITION_IF_BINARY_LAMBDA

$sym68$PROPER_LIST_P

$sym69$NON_DOTTED_LIST_P

$sym70$NON_NEGATIVE_INTEGER_P

$kw71$DELETED

$list72

$kw73$DUMMY

com.cyc.cycjava.cycl
Class list_utilities