doc/ref/api-undocumented.texi

   1 This file gathers entries that have been automatically generated from
   2 docstrings in libguile.  They are not included in the manual, however,
   3 for various reasons.  They are here in this file to give docstring.el a
   4 chance to update them automatically.
   5
   6 - The 'environments' are only in Guile by accident and are not used at
   7   all and we don't want to advertise them.
   8
   9 - GOOPS is documented in its own manual.
  10
  11 @deffn {Scheme Procedure} module-import-interface module sym
  12 @deffnx {C Function} scm_module_import_interface (module, sym)
  13
  14 @end deffn
  15
  16
  17 @deffn {Scheme Procedure} self-evaluating? obj
  18 @deffnx {C Function} scm_self_evaluating_p (obj)
  19 Return #t for objects which Guile considers self-evaluating
  20 @end deffn
  21
  22 @deffn {Scheme Procedure} unmemoize-expr m
  23 @deffnx {C Function} scm_i_unmemoize_expr (m)
  24 Unmemoize the memoized expression @var{m},
  25 @end deffn
  26
  27 @deffn {Scheme Procedure} weak-key-alist-vector? obj
  28 @deffnx {Scheme Procedure} weak-value-alist-vector? obj
  29 @deffnx {Scheme Procedure} doubly-weak-alist-vector? obj
  30 @deffnx {C Function} scm_weak_key_alist_vector_p (obj)
  31 Return @code{#t} if @var{obj} is the specified weak hash
  32 table. Note that a doubly weak hash table is neither a weak key
  33 nor a weak value hash table.
  34 @end deffn
  35
  36 @deffn {Scheme Procedure} make-weak-key-alist-vector [size]
  37 @deffnx {Scheme Procedure} make-weak-value-alist-vector size
  38 @deffnx {Scheme Procedure} make-doubly-weak-alist-vector size
  39 @deffnx {C Function} scm_make_weak_key_alist_vector (size)
  40 Return a weak hash table with @var{size} buckets. As with any
  41 hash table, choosing a good size for the table requires some
  42 caution.
  43
  44 You can modify weak hash tables in exactly the same way you
  45 would modify regular hash tables. (@pxref{Hash Tables})
  46 @end deffn
  47
  48 @deffn {Scheme Procedure} include-deprecated-features
  49 Return @code{#t} iff deprecated features should be included
  50 in public interfaces.
  51 @end deffn
  52
  53 @deffn {Scheme Procedure} issue-deprecation-warning . msgs
  54 Output @var{msgs} to @code{(current-error-port)} when this
  55 is the first call to @code{issue-deprecation-warning} with
  56 this specific @var{msg}.  Do nothing otherwise.
  57 The argument @var{msgs} should be a list of strings;
  58 they are printed in turn, each one followed by a newline.
  59 @end deffn
  60
  61 @deffn {Scheme Procedure} valid-object-procedure? proc
  62 @deffnx {C Function} scm_valid_object_procedure_p (proc)
  63 Return @code{#t} iff @var{proc} is a procedure that can be used with @code{set-object-procedure}.  It is always valid to use a closure constructed by @code{lambda}.
  64 @end deffn
  65
  66 @deffn {Scheme Procedure} %get-pre-modules-obarray
  67 @deffnx {C Function} scm_get_pre_modules_obarray ()
  68 Return the obarray that is used for all new bindings before the module system is booted.  The first call to @code{set-current-module} will boot the module system.
  69 @end deffn
  70
  71 @deffn {Scheme Procedure} standard-interface-eval-closure module
  72 @deffnx {C Function} scm_standard_interface_eval_closure (module)
  73 Return a interface eval closure for the module @var{module}. Such a closure does not allow new bindings to be added.
  74 @end deffn
  75
  76 @deffn {Scheme Procedure} env-module env
  77 @deffnx {C Function} scm_env_module (env)
  78 Return the module of @var{ENV}, a lexical environment.
  79 @end deffn
  80
  81 @deffn {Scheme Procedure} single-active-thread?
  82 implemented by the C function "scm_single_thread_p"
  83 @end deffn
  84
  85 @deffn {Scheme Procedure} set-debug-cell-accesses! flag
  86 @deffnx {C Function} scm_set_debug_cell_accesses_x (flag)
  87 This function is used to turn on checking for a debug version of GUILE. This version does not support this functionality
  88
  89 @end deffn
  90
  91 @deffn {Scheme Procedure} standard-eval-closure module
  92 @deffnx {C Function} scm_standard_eval_closure (module)
  93 Return an eval closure for the module @var{module}.
  94 @end deffn
  95
  96 @deffn {Scheme Procedure} mask-signals
  97 @deffnx {C Function} scm_mask_signals ()
  98 Mask signals. The returned value is not specified.
  99 @end deffn
 100
 101 @deffn {Scheme Procedure} unmask-signals
 102 @deffnx {C Function} scm_unmask_signals ()
 103 Unmask signals. The returned value is not specified.
 104 @end deffn
 105
 106 @deffn {Scheme Procedure} noop . args
 107 @deffnx {C Function} scm_noop (args)
 108 Do nothing.  When called without arguments, return @code{#f},
 109 otherwise return the first argument.
 110 @end deffn
 111
 112 @deffn {Scheme Procedure} system-async thunk
 113 @deffnx {C Function} scm_system_async (thunk)
 114 This function is deprecated.  You can use @var{thunk} directly
 115 instead of explicitely creating an async object.
 116
 117 @end deffn
 118
 119 @deffn {Scheme Procedure} object-address obj
 120 @deffnx {C Function} scm_object_address (obj)
 121 Return an integer that for the lifetime of @var{obj} is uniquely
 122 returned by this function for @var{obj}
 123 @end deffn
 124
 125 @deffn {Scheme Procedure} environment? obj
 126 @deffnx {C Function} scm_environment_p (obj)
 127 Return @code{#t} if @var{obj} is an environment, or @code{#f}
 128 otherwise.
 129 @end deffn
 130
 131 @deffn {Scheme Procedure} environment-bound? env sym
 132 @deffnx {C Function} scm_environment_bound_p (env, sym)
 133 Return @code{#t} if @var{sym} is bound in @var{env}, or
 134 @code{#f} otherwise.
 135 @end deffn
 136
 137 @deffn {Scheme Procedure} environment-ref env sym
 138 @deffnx {C Function} scm_environment_ref (env, sym)
 139 Return the value of the location bound to @var{sym} in
 140 @var{env}. If @var{sym} is unbound in @var{env}, signal an
 141 @code{environment:unbound} error.
 142 @end deffn
 143
 144 @deffn {Scheme Procedure} environment-fold env proc init
 145 @deffnx {C Function} scm_environment_fold (env, proc, init)
 146 Iterate over all the bindings in @var{env}, accumulating some
 147 value.
 148 For each binding in @var{env}, apply @var{proc} to the symbol
 149 bound, its value, and the result from the previous application
 150 of @var{proc}.
 151 Use @var{init} as @var{proc}'s third argument the first time
 152 @var{proc} is applied.
 153 If @var{env} contains no bindings, this function simply returns
 154 @var{init}.
 155 If @var{env} binds the symbol sym1 to the value val1, sym2 to
 156 val2, and so on, then this procedure computes:
 157 @lisp
 158   (proc sym1 val1
 159         (proc sym2 val2
 160               ...
 161               (proc symn valn
 162                     init)))
 163 @end lisp
 164 Each binding in @var{env} will be processed exactly once.
 165 @code{environment-fold} makes no guarantees about the order in
 166 which the bindings are processed.
 167 Here is a function which, given an environment, constructs an
 168 association list representing that environment's bindings,
 169 using environment-fold:
 170 @lisp
 171   (define (environment->alist env)
 172     (environment-fold env
 173                       (lambda (sym val tail)
 174                         (cons (cons sym val) tail))
 175                       '()))
 176 @end lisp
 177 @end deffn
 178
 179 @deffn {Scheme Procedure} environment-define env sym val
 180 @deffnx {C Function} scm_environment_define (env, sym, val)
 181 Bind @var{sym} to a new location containing @var{val} in
 182 @var{env}. If @var{sym} is already bound to another location
 183 in @var{env} and the binding is mutable, that binding is
 184 replaced.  The new binding and location are both mutable. The
 185 return value is unspecified.
 186 If @var{sym} is already bound in @var{env}, and the binding is
 187 immutable, signal an @code{environment:immutable-binding} error.
 188 @end deffn
 189
 190 @deffn {Scheme Procedure} environment-undefine env sym
 191 @deffnx {C Function} scm_environment_undefine (env, sym)
 192 Remove any binding for @var{sym} from @var{env}. If @var{sym}
 193 is unbound in @var{env}, do nothing.  The return value is
 194 unspecified.
 195 If @var{sym} is already bound in @var{env}, and the binding is
 196 immutable, signal an @code{environment:immutable-binding} error.
 197 @end deffn
 198
 199 @deffn {Scheme Procedure} environment-set! env sym val
 200 @deffnx {C Function} scm_environment_set_x (env, sym, val)
 201 If @var{env} binds @var{sym} to some location, change that
 202 location's value to @var{val}.  The return value is
 203 unspecified.
 204 If @var{sym} is not bound in @var{env}, signal an
 205 @code{environment:unbound} error.  If @var{env} binds @var{sym}
 206 to an immutable location, signal an
 207 @code{environment:immutable-location} error.
 208 @end deffn
 209
 210 @deffn {Scheme Procedure} environment-cell env sym for_write
 211 @deffnx {C Function} scm_environment_cell (env, sym, for_write)
 212 Return the value cell which @var{env} binds to @var{sym}, or
 213 @code{#f} if the binding does not live in a value cell.
 214 The argument @var{for-write} indicates whether the caller
 215 intends to modify the variable's value by mutating the value
 216 cell.  If the variable is immutable, then
 217 @code{environment-cell} signals an
 218 @code{environment:immutable-location} error.
 219 If @var{sym} is unbound in @var{env}, signal an
 220 @code{environment:unbound} error.
 221 If you use this function, you should consider using
 222 @code{environment-observe}, to be notified when @var{sym} gets
 223 re-bound to a new value cell, or becomes undefined.
 224 @end deffn
 225
 226 @deffn {Scheme Procedure} environment-observe env proc
 227 @deffnx {C Function} scm_environment_observe (env, proc)
 228 Whenever @var{env}'s bindings change, apply @var{proc} to
 229 @var{env}.
 230 This function returns an object, token, which you can pass to
 231 @code{environment-unobserve} to remove @var{proc} from the set
 232 of procedures observing @var{env}.  The type and value of
 233 token is unspecified.
 234 @end deffn
 235
 236 @deffn {Scheme Procedure} environment-observe-weak env proc
 237 @deffnx {C Function} scm_environment_observe_weak (env, proc)
 238 This function is the same as environment-observe, except that
 239 the reference @var{env} retains to @var{proc} is a weak
 240 reference. This means that, if there are no other live,
 241 non-weak references to @var{proc}, it will be
 242 garbage-collected, and dropped from @var{env}'s
 243 list of observing procedures.
 244 @end deffn
 245
 246 @deffn {Scheme Procedure} environment-unobserve token
 247 @deffnx {C Function} scm_environment_unobserve (token)
 248 Cancel the observation request which returned the value
 249 @var{token}.  The return value is unspecified.
 250 If a call @code{(environment-observe env proc)} returns
 251 @var{token}, then the call @code{(environment-unobserve token)}
 252 will cause @var{proc} to no longer be called when @var{env}'s
 253 bindings change.
 254 @end deffn
 255
 256 @deffn {Scheme Procedure} make-leaf-environment
 257 @deffnx {C Function} scm_make_leaf_environment ()
 258 Create a new leaf environment, containing no bindings.
 259 All bindings and locations created in the new environment
 260 will be mutable.
 261 @end deffn
 262
 263 @deffn {Scheme Procedure} leaf-environment? object
 264 @deffnx {C Function} scm_leaf_environment_p (object)
 265 Return @code{#t} if object is a leaf environment, or @code{#f}
 266 otherwise.
 267 @end deffn
 268
 269 @deffn {Scheme Procedure} make-eval-environment local imported
 270 @deffnx {C Function} scm_make_eval_environment (local, imported)
 271 Return a new environment object eval whose bindings are the
 272 union of the bindings in the environments @var{local} and
 273 @var{imported}, with bindings from @var{local} taking
 274 precedence. Definitions made in eval are placed in @var{local}.
 275 Applying @code{environment-define} or
 276 @code{environment-undefine} to eval has the same effect as
 277 applying the procedure to @var{local}.
 278 Note that eval incorporates @var{local} and @var{imported} by
 279 reference:
 280 If, after creating eval, the program changes the bindings of
 281 @var{local} or @var{imported}, those changes will be visible
 282 in eval.
 283 Since most Scheme evaluation takes place in eval environments,
 284 they transparently cache the bindings received from @var{local}
 285 and @var{imported}. Thus, the first time the program looks up
 286 a symbol in eval, eval may make calls to @var{local} or
 287 @var{imported} to find their bindings, but subsequent
 288 references to that symbol will be as fast as references to
 289 bindings in finite environments.
 290 In typical use, @var{local} will be a finite environment, and
 291 @var{imported} will be an import environment
 292 @end deffn
 293
 294 @deffn {Scheme Procedure} eval-environment? object
 295 @deffnx {C Function} scm_eval_environment_p (object)
 296 Return @code{#t} if object is an eval environment, or @code{#f}
 297 otherwise.
 298 @end deffn
 299
 300 @deffn {Scheme Procedure} eval-environment-local env
 301 @deffnx {C Function} scm_eval_environment_local (env)
 302 Return the local environment of eval environment @var{env}.
 303 @end deffn
 304
 305 @deffn {Scheme Procedure} eval-environment-set-local! env local
 306 @deffnx {C Function} scm_eval_environment_set_local_x (env, local)
 307 Change @var{env}'s local environment to @var{local}.
 308 @end deffn
 309
 310 @deffn {Scheme Procedure} eval-environment-imported env
 311 @deffnx {C Function} scm_eval_environment_imported (env)
 312 Return the imported environment of eval environment @var{env}.
 313 @end deffn
 314
 315 @deffn {Scheme Procedure} eval-environment-set-imported! env imported
 316 @deffnx {C Function} scm_eval_environment_set_imported_x (env, imported)
 317 Change @var{env}'s imported environment to @var{imported}.
 318 @end deffn
 319
 320 @deffn {Scheme Procedure} make-import-environment imports conflict_proc
 321 @deffnx {C Function} scm_make_import_environment (imports, conflict_proc)
 322 Return a new environment @var{imp} whose bindings are the union
 323 of the bindings from the environments in @var{imports};
 324 @var{imports} must be a list of environments. That is,
 325 @var{imp} binds a symbol to a location when some element of
 326 @var{imports} does.
 327 If two different elements of @var{imports} have a binding for
 328 the same symbol, the @var{conflict-proc} is called with the
 329 following parameters:  the import environment, the symbol and
 330 the list of the imported environments that bind the symbol.
 331 If the @var{conflict-proc} returns an environment @var{env},
 332 the conflict is considered as resolved and the binding from
 333 @var{env} is used.  If the @var{conflict-proc} returns some
 334 non-environment object, the conflict is considered unresolved
 335 and the symbol is treated as unspecified in the import
 336 environment.
 337 The checking for conflicts may be performed lazily, i. e. at
 338 the moment when a value or binding for a certain symbol is
 339 requested instead of the moment when the environment is
 340 created or the bindings of the imports change.
 341 All bindings in @var{imp} are immutable. If you apply
 342 @code{environment-define} or @code{environment-undefine} to
 343 @var{imp}, Guile will signal an
 344  @code{environment:immutable-binding} error. However,
 345 notice that the set of bindings in @var{imp} may still change,
 346 if one of its imported environments changes.
 347 @end deffn
 348
 349 @deffn {Scheme Procedure} import-environment? object
 350 @deffnx {C Function} scm_import_environment_p (object)
 351 Return @code{#t} if object is an import environment, or
 352 @code{#f} otherwise.
 353 @end deffn
 354
 355 @deffn {Scheme Procedure} import-environment-imports env
 356 @deffnx {C Function} scm_import_environment_imports (env)
 357 Return the list of environments imported by the import
 358 environment @var{env}.
 359 @end deffn
 360
 361 @deffn {Scheme Procedure} import-environment-set-imports! env imports
 362 @deffnx {C Function} scm_import_environment_set_imports_x (env, imports)
 363 Change @var{env}'s list of imported environments to
 364 @var{imports}, and check for conflicts.
 365 @end deffn
 366
 367 @deffn {Scheme Procedure} make-export-environment private signature
 368 @deffnx {C Function} scm_make_export_environment (private, signature)
 369 Return a new environment @var{exp} containing only those
 370 bindings in private whose symbols are present in
 371 @var{signature}. The @var{private} argument must be an
 372 environment.
 373
 374 The environment @var{exp} binds symbol to location when
 375 @var{env} does, and symbol is exported by @var{signature}.
 376
 377 @var{signature} is a list specifying which of the bindings in
 378 @var{private} should be visible in @var{exp}. Each element of
 379 @var{signature} should be a list of the form:
 380   (symbol attribute ...)
 381 where each attribute is one of the following:
 382 @table @asis
 383 @item the symbol @code{mutable-location}
 384   @var{exp} should treat the
 385   location bound to symbol as mutable. That is, @var{exp}
 386   will pass calls to @code{environment-set!} or
 387   @code{environment-cell} directly through to private.
 388 @item the symbol @code{immutable-location}
 389   @var{exp} should treat
 390   the location bound to symbol as immutable. If the program
 391   applies @code{environment-set!} to @var{exp} and symbol, or
 392   calls @code{environment-cell} to obtain a writable value
 393   cell, @code{environment-set!} will signal an
 394   @code{environment:immutable-location} error. Note that, even
 395   if an export environment treats a location as immutable, the
 396   underlying environment may treat it as mutable, so its
 397   value may change.
 398 @end table
 399 It is an error for an element of signature to specify both
 400 @code{mutable-location} and @code{immutable-location}. If
 401 neither is specified, @code{immutable-location} is assumed.
 402
 403 As a special case, if an element of signature is a lone
 404 symbol @var{sym}, it is equivalent to an element of the form
 405 @code{(sym)}.
 406
 407 All bindings in @var{exp} are immutable. If you apply
 408 @code{environment-define} or @code{environment-undefine} to
 409 @var{exp}, Guile will signal an
 410 @code{environment:immutable-binding} error. However,
 411 notice that the set of bindings in @var{exp} may still change,
 412 if the bindings in private change.
 413 @end deffn
 414
 415 @deffn {Scheme Procedure} export-environment? object
 416 @deffnx {C Function} scm_export_environment_p (object)
 417 Return @code{#t} if object is an export environment, or
 418 @code{#f} otherwise.
 419 @end deffn
 420
 421 @deffn {Scheme Procedure} export-environment-private env
 422 @deffnx {C Function} scm_export_environment_private (env)
 423 Return the private environment of export environment @var{env}.
 424 @end deffn
 425
 426 @deffn {Scheme Procedure} export-environment-set-private! env private
 427 @deffnx {C Function} scm_export_environment_set_private_x (env, private)
 428 Change the private environment of export environment @var{env}.
 429 @end deffn
 430
 431 @deffn {Scheme Procedure} export-environment-signature env
 432 @deffnx {C Function} scm_export_environment_signature (env)
 433 Return the signature of export environment @var{env}.
 434 @end deffn
 435
 436 @deffn {Scheme Procedure} export-environment-set-signature! env signature
 437 @deffnx {C Function} scm_export_environment_set_signature_x (env, signature)
 438 Change the signature of export environment @var{env}.
 439 @end deffn
 440
 441 @deffn {Scheme Procedure} %compute-slots class
 442 @deffnx {C Function} scm_sys_compute_slots (class)
 443 Return a list consisting of the names of all slots belonging to
 444 class @var{class}, i. e. the slots of @var{class} and of all of
 445 its superclasses.
 446 @end deffn
 447
 448 @deffn {Scheme Procedure} get-keyword key l default_value
 449 @deffnx {C Function} scm_get_keyword (key, l, default_value)
 450 Determine an associated value for the keyword @var{key} from
 451 the list @var{l}.  The list @var{l} has to consist of an even
 452 number of elements, where, starting with the first, every
 453 second element is a keyword, followed by its associated value.
 454 If @var{l} does not hold a value for @var{key}, the value
 455 @var{default_value} is returned.
 456 @end deffn
 457
 458 @deffn {Scheme Procedure} slot-ref-using-class class obj slot_name
 459 @deffnx {C Function} scm_slot_ref_using_class (class, obj, slot_name)
 460
 461 @end deffn
 462
 463 @deffn {Scheme Procedure} slot-set-using-class! class obj slot_name value
 464 @deffnx {C Function} scm_slot_set_using_class_x (class, obj, slot_name, value)
 465
 466 @end deffn
 467
 468 @deffn {Scheme Procedure} class-of x
 469 @deffnx {C Function} scm_class_of (x)
 470 Return the class of @var{x}.
 471 @end deffn
 472
 473 @deffn {Scheme Procedure} %goops-loaded
 474 @deffnx {C Function} scm_sys_goops_loaded ()
 475 Announce that GOOPS is loaded and perform initialization
 476 on the C level which depends on the loaded GOOPS modules.
 477 @end deffn
 478
 479 @deffn {Scheme Procedure} %method-more-specific? m1 m2 targs
 480 @deffnx {C Function} scm_sys_method_more_specific_p (m1, m2, targs)
 481
 482 @end deffn
 483
 484 @deffn {Scheme Procedure} find-method . l
 485 @deffnx {C Function} scm_find_method (l)
 486
 487 @end deffn
 488
 489 @deffn {Scheme Procedure} primitive-generic-generic subr
 490 @deffnx {C Function} scm_primitive_generic_generic (subr)
 491
 492 @end deffn
 493
 494 @deffn {Scheme Procedure} enable-primitive-generic! . subrs
 495 @deffnx {C Function} scm_enable_primitive_generic_x (subrs)
 496
 497 @end deffn
 498
 499 @deffn {Scheme Procedure} generic-capability? proc
 500 @deffnx {C Function} scm_generic_capability_p (proc)
 501
 502 @end deffn
 503
 504 @deffn {Scheme Procedure} %invalidate-method-cache! gf
 505 @deffnx {C Function} scm_sys_invalidate_method_cache_x (gf)
 506
 507 @end deffn
 508
 509 @deffn {Scheme Procedure} %invalidate-class class
 510 @deffnx {C Function} scm_sys_invalidate_class (class)
 511
 512 @end deffn
 513
 514 @deffn {Scheme Procedure} %modify-class old new
 515 @deffnx {C Function} scm_sys_modify_class (old, new)
 516
 517 @end deffn
 518
 519 @deffn {Scheme Procedure} %modify-instance old new
 520 @deffnx {C Function} scm_sys_modify_instance (old, new)
 521
 522 @end deffn
 523
 524 @deffn {Scheme Procedure} %set-object-setter! obj setter
 525 @deffnx {C Function} scm_sys_set_object_setter_x (obj, setter)
 526
 527 @end deffn
 528
 529 @deffn {Scheme Procedure} %allocate-instance class initargs
 530 @deffnx {C Function} scm_sys_allocate_instance (class, initargs)
 531 Create a new instance of class @var{class} and initialize it
 532 from the arguments @var{initargs}.
 533 @end deffn
 534
 535 @deffn {Scheme Procedure} slot-exists? obj slot_name
 536 @deffnx {C Function} scm_slot_exists_p (obj, slot_name)
 537 Return @code{#t} if @var{obj} has a slot named @var{slot_name}.
 538 @end deffn
 539
 540 @deffn {Scheme Procedure} slot-bound? obj slot_name
 541 @deffnx {C Function} scm_slot_bound_p (obj, slot_name)
 542 Return @code{#t} if the slot named @var{slot_name} of @var{obj}
 543 is bound.
 544 @end deffn
 545
 546 @deffn {Scheme Procedure} slot-set! obj slot_name value
 547 @deffnx {C Function} scm_slot_set_x (obj, slot_name, value)
 548 Set the slot named @var{slot_name} of @var{obj} to @var{value}.
 549 @end deffn
 550
 551 @deffn {Scheme Procedure} slot-exists-using-class? class obj slot_name
 552 @deffnx {C Function} scm_slot_exists_using_class_p (class, obj, slot_name)
 553
 554 @end deffn
 555
 556 @deffn {Scheme Procedure} slot-bound-using-class? class obj slot_name
 557 @deffnx {C Function} scm_slot_bound_using_class_p (class, obj, slot_name)
 558
 559 @end deffn
 560
 561 @deffn {Scheme Procedure} %fast-slot-set! obj index value
 562 @deffnx {C Function} scm_sys_fast_slot_set_x (obj, index, value)
 563 Set the slot with index @var{index} in @var{obj} to
 564 @var{value}.
 565 @end deffn
 566
 567 @deffn {Scheme Procedure} %fast-slot-ref obj index
 568 @deffnx {C Function} scm_sys_fast_slot_ref (obj, index)
 569 Return the slot value with index @var{index} from @var{obj}.
 570 @end deffn
 571
 572 @deffn {Scheme Procedure} @@assert-bound-ref obj index
 573 @deffnx {C Function} scm_at_assert_bound_ref (obj, index)
 574 Like @code{assert-bound}, but use @var{index} for accessing
 575 the value from @var{obj}.
 576 @end deffn
 577
 578 @deffn {Scheme Procedure} assert-bound value obj
 579 @deffnx {C Function} scm_assert_bound (value, obj)
 580 Return @var{value} if it is bound, and invoke the
 581 @var{slot-unbound} method of @var{obj} if it is not.
 582 @end deffn
 583
 584 @deffn {Scheme Procedure} unbound? obj
 585 @deffnx {C Function} scm_unbound_p (obj)
 586 Return @code{#t} if @var{obj} is unbound.
 587 @end deffn
 588
 589 @deffn {Scheme Procedure} make-unbound
 590 @deffnx {C Function} scm_make_unbound ()
 591 Return the unbound value.
 592 @end deffn
 593
 594 @deffn {Scheme Procedure} accessor-method-slot-definition obj
 595 @deffnx {C Function} scm_accessor_method_slot_definition (obj)
 596 Return the slot definition of the accessor @var{obj}.
 597 @end deffn
 598
 599 @deffn {Scheme Procedure} method-procedure obj
 600 @deffnx {C Function} scm_method_procedure (obj)
 601 Return the procedure of the method @var{obj}.
 602 @end deffn
 603
 604 @deffn {Scheme Procedure} method-specializers obj
 605 @deffnx {C Function} scm_method_specializers (obj)
 606 Return specializers of the method @var{obj}.
 607 @end deffn
 608
 609 @deffn {Scheme Procedure} method-generic-function obj
 610 @deffnx {C Function} scm_method_generic_function (obj)
 611 Return the generic function for the method @var{obj}.
 612 @end deffn
 613
 614 @deffn {Scheme Procedure} generic-function-methods obj
 615 @deffnx {C Function} scm_generic_function_methods (obj)
 616 Return the methods of the generic function @var{obj}.
 617 @end deffn
 618
 619 @deffn {Scheme Procedure} generic-function-name obj
 620 @deffnx {C Function} scm_generic_function_name (obj)
 621 Return the name of the generic function @var{obj}.
 622 @end deffn
 623
 624 @deffn {Scheme Procedure} class-environment obj
 625 @deffnx {C Function} scm_class_environment (obj)
 626 Return the environment of the class @var{obj}.
 627 @end deffn
 628
 629 @deffn {Scheme Procedure} class-slots obj
 630 @deffnx {C Function} scm_class_slots (obj)
 631 Return the slot list of the class @var{obj}.
 632 @end deffn
 633
 634 @deffn {Scheme Procedure} class-precedence-list obj
 635 @deffnx {C Function} scm_class_precedence_list (obj)
 636 Return the class precedence list of the class @var{obj}.
 637 @end deffn
 638
 639 @deffn {Scheme Procedure} class-direct-methods obj
 640 @deffnx {C Function} scm_class_direct_methods (obj)
 641 Return the direct methods of the class @var{obj}
 642 @end deffn
 643
 644 @deffn {Scheme Procedure} class-direct-subclasses obj
 645 @deffnx {C Function} scm_class_direct_subclasses (obj)
 646 Return the direct subclasses of the class @var{obj}.
 647 @end deffn
 648
 649 @deffn {Scheme Procedure} class-direct-slots obj
 650 @deffnx {C Function} scm_class_direct_slots (obj)
 651 Return the direct slots of the class @var{obj}.
 652 @end deffn
 653
 654 @deffn {Scheme Procedure} class-direct-supers obj
 655 @deffnx {C Function} scm_class_direct_supers (obj)
 656 Return the direct superclasses of the class @var{obj}.
 657 @end deffn
 658
 659 @deffn {Scheme Procedure} class-name obj
 660 @deffnx {C Function} scm_class_name (obj)
 661 Return the class name of @var{obj}.
 662 @end deffn
 663
 664 @deffn {Scheme Procedure} instance? obj
 665 @deffnx {C Function} scm_instance_p (obj)
 666 Return @code{#t} if @var{obj} is an instance.
 667 @end deffn
 668
 669 @deffn {Scheme Procedure} %inherit-magic! class dsupers
 670 @deffnx {C Function} scm_sys_inherit_magic_x (class, dsupers)
 671
 672 @end deffn
 673
 674 @deffn {Scheme Procedure} %prep-layout! class
 675 @deffnx {C Function} scm_sys_prep_layout_x (class)
 676
 677 @end deffn
 678
 679 @deffn {Scheme Procedure} %initialize-object obj initargs
 680 @deffnx {C Function} scm_sys_initialize_object (obj, initargs)
 681 Initialize the object @var{obj} with the given arguments
 682 @var{initargs}.
 683 @end deffn
 684
 685 @deffn {Scheme Procedure} make . args
 686 @deffnx {C Function} scm_make (args)
 687 Make a new object.  @var{args} must contain the class and
 688 all necessary initialization information.
 689 @end deffn
 690
 691 @deffn {Scheme Procedure} slot-ref obj slot_name
 692 @deffnx {C Function} scm_slot_ref (obj, slot_name)
 693 Return the value from @var{obj}'s slot with the name
 694 @var{slot_name}.
 695 @end deffn
 696
 697 @deffn {Scheme Procedure} %tag-body body
 698 @deffnx {C Function} scm_sys_tag_body (body)
 699 Internal GOOPS magic---don't use this function!
 700 @end deffn