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, mostly because they have been deprecated. They
4 are here in this file to give docstring.el a chance to update them
7 - GOOPS is documented in its own manual.
11 @deffn {Scheme Procedure} substring-move-right!
12 implemented by the C function "scm_substring_move_x"
15 @deffn {Scheme Procedure} substring-move-left!
16 implemented by the C function "scm_substring_move_x"
19 @deffn {Scheme Procedure} gentemp [prefix [obarray]]
20 @deffnx {C Function} scm_gentemp (prefix, obarray)
21 Create a new symbol with a name unique in an obarray.
22 The name is constructed from an optional string @var{prefix}
23 and a counter value. The default prefix is @code{t}. The
24 @var{obarray} is specified as a second optional argument.
25 Default is the system obarray where all normal symbols are
26 interned. The counter is increased by 1 at each
27 call. There is no provision for resetting the counter.
30 @deffn {Scheme Procedure} symbol-set! o s v
31 @deffnx {C Function} scm_symbol_set_x (o, s, v)
32 Find the symbol in @var{obarray} whose name is @var{string}, and rebind
33 it to @var{value}. An error is signalled if @var{string} is not present
37 @deffn {Scheme Procedure} symbol-bound? o s
38 @deffnx {C Function} scm_symbol_bound_p (o, s)
39 Return @code{#t} if @var{obarray} contains a symbol with name
40 @var{string} bound to a defined value. This differs from
41 @var{symbol-interned?} in that the mere mention of a symbol
42 usually causes it to be interned; @code{symbol-bound?}
43 determines whether a symbol has been given any meaningful
47 @deffn {Scheme Procedure} symbol-binding o s
48 @deffnx {C Function} scm_symbol_binding (o, s)
49 Look up in @var{obarray} the symbol whose name is @var{string}, and
50 return the value to which it is bound. If @var{obarray} is @code{#f},
51 use the global symbol table. If @var{string} is not interned in
52 @var{obarray}, an error is signalled.
55 @deffn {Scheme Procedure} unintern-symbol o s
56 @deffnx {C Function} scm_unintern_symbol (o, s)
57 Remove the symbol with name @var{string} from @var{obarray}. This
58 function returns @code{#t} if the symbol was present and @code{#f}
62 @deffn {Scheme Procedure} intern-symbol o s
63 @deffnx {C Function} scm_intern_symbol (o, s)
64 Add a new symbol to @var{obarray} with name @var{string}, bound to an
65 unspecified initial value. The symbol table is not modified if a symbol
66 with this name is already present.
69 @deffn {Scheme Procedure} string->obarray-symbol o s [softp]
70 @deffnx {C Function} scm_string_to_obarray_symbol (o, s, softp)
71 Intern a new symbol in @var{obarray}, a symbol table, with name
74 If @var{obarray} is @code{#f}, use the default system symbol table. If
75 @var{obarray} is @code{#t}, the symbol should not be interned in any
76 symbol table; merely return the pair (@var{symbol}
77 . @var{#<undefined>}).
79 The @var{soft?} argument determines whether new symbol table entries
80 should be created when the specified symbol is not already present in
81 @var{obarray}. If @var{soft?} is specified and is a true value, then
82 new entries should not be added for symbols not already present in the
83 table; instead, simply return @code{#f}.
86 @deffn {Scheme Procedure} read-and-eval! [port]
87 @deffnx {C Function} scm_read_and_eval_x (port)
88 Read a form from @var{port} (standard input by default), and evaluate it
89 (memoizing it in the process) in the top-level environment. If no data
90 is left to be read from @var{port}, an @code{end-of-file} error is
94 @deffn {Scheme Procedure} sloppy-member x lst
95 @deffnx {C Function} scm_sloppy_member (x, lst)
96 This procedure behaves like @code{member}, but does no type or error checking.
97 Its use is recommended only in writing Guile internals,
98 not for high-level Scheme programs.
101 @deffn {Scheme Procedure} sloppy-memv x lst
102 @deffnx {C Function} scm_sloppy_memv (x, lst)
103 This procedure behaves like @code{memv}, but does no type or error checking.
104 Its use is recommended only in writing Guile internals,
105 not for high-level Scheme programs.
108 @deffn {Scheme Procedure} sloppy-memq x lst
109 @deffnx {C Function} scm_sloppy_memq (x, lst)
110 This procedure behaves like @code{memq}, but does no type or error checking.
111 Its use is recommended only in writing Guile internals,
112 not for high-level Scheme programs.
115 @deffn {Scheme Procedure} builtin-variable name
116 @deffnx {C Function} scm_builtin_variable (name)
117 Do not use this function.
120 @deffn {Scheme Procedure} variable-set-name-hint! var hint
121 @deffnx {C Function} scm_variable_set_name_hint (var, hint)
122 Do not use this function.
125 @deffn {Scheme Procedure} close-all-ports-except . ports
126 @deffnx {C Function} scm_close_all_ports_except (ports)
127 [DEPRECATED] Close all open file ports used by the interpreter
128 except for those supplied as arguments. This procedure
129 was intended to be used before an exec call to close file descriptors
130 which are not needed in the new process. However it has the
131 undesirable side effect of flushing buffers, so it's deprecated.
132 Use port-for-each instead.
135 @deffn {Scheme Procedure} c-clear-registered-modules
136 @deffnx {C Function} scm_clear_registered_modules ()
137 Destroy the list of modules registered with the current Guile process.
138 The return value is unspecified. @strong{Warning:} this function does
139 not actually unlink or deallocate these modules, but only destroys the
140 records of which modules have been loaded. It should therefore be used
141 only by module bookkeeping operations.
144 @deffn {Scheme Procedure} c-registered-modules
145 @deffnx {C Function} scm_registered_modules ()
146 Return a list of the object code modules that have been imported into
147 the current Guile process. Each element of the list is a pair whose
148 car is the name of the module, and whose cdr is the function handle
149 for that module's initializer function. The name is the string that
150 has been passed to scm_register_module_xxx.
153 @deffn {Scheme Procedure} module-import-interface module sym
154 @deffnx {C Function} scm_module_import_interface (module, sym)
155 Return the module or interface from which @var{sym} is imported in @var{module}. If @var{sym} is not imported (i.e., it is not defined in @var{module} or it is a module-local binding instead of an imported one), then @code{#f} is returned.
159 @deffn {Scheme Procedure} self-evaluating? obj
160 @deffnx {C Function} scm_self_evaluating_p (obj)
161 Return #t for objects which Guile considers self-evaluating
164 @deffn {Scheme Procedure} unmemoize-expr m
165 @deffnx {C Function} scm_i_unmemoize_expr (m)
166 Unmemoize the memoized expression @var{m},
169 @deffn {Scheme Procedure} weak-key-alist-vector? obj
170 @deffnx {Scheme Procedure} weak-value-alist-vector? obj
171 @deffnx {Scheme Procedure} doubly-weak-alist-vector? obj
172 @deffnx {C Function} scm_weak_key_alist_vector_p (obj)
173 Return @code{#t} if @var{obj} is the specified weak hash
174 table. Note that a doubly weak hash table is neither a weak key
175 nor a weak value hash table.
178 @deffn {Scheme Procedure} make-weak-key-alist-vector [size]
179 @deffnx {Scheme Procedure} make-weak-value-alist-vector size
180 @deffnx {Scheme Procedure} make-doubly-weak-alist-vector size
181 @deffnx {C Function} scm_make_weak_key_alist_vector (size)
182 Return a weak hash table with @var{size} buckets. As with any
183 hash table, choosing a good size for the table requires some
186 You can modify weak hash tables in exactly the same way you
187 would modify regular hash tables. (@pxref{Hash Tables})
190 @deffn {Scheme Procedure} include-deprecated-features
191 Return @code{#t} if deprecated features should be included in public
192 interfaces, or @code{#f} otherwise.
195 @deffn {Scheme Procedure} issue-deprecation-warning . msgs
196 Output @var{msgs} to @code{(current-error-port)} when this
197 is the first call to @code{issue-deprecation-warning} with
198 this specific @var{msg}. Do nothing otherwise.
199 The argument @var{msgs} should be a list of strings;
200 they are printed in turn, each one followed by a newline.
203 @deffn {Scheme Procedure} valid-object-procedure? proc
204 @deffnx {C Function} scm_valid_object_procedure_p (proc)
205 Return @code{#t} ff @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}.
208 @deffn {Scheme Procedure} %get-pre-modules-obarray
209 @deffnx {C Function} scm_get_pre_modules_obarray ()
210 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.
213 @deffn {Scheme Procedure} standard-interface-eval-closure module
214 @deffnx {C Function} scm_standard_interface_eval_closure (module)
215 Return a interface eval closure for the module @var{module}. Such a closure does not allow new bindings to be added.
218 @deffn {Scheme Procedure} env-module env
219 @deffnx {C Function} scm_env_module (env)
220 Return the module of @var{ENV}, a lexical environment.
223 @deffn {Scheme Procedure} single-active-thread?
224 implemented by the C function "scm_single_thread_p"
227 @deffn {Scheme Procedure} set-debug-cell-accesses! flag
228 @deffnx {C Function} scm_set_debug_cell_accesses_x (flag)
229 This function is used to turn on checking for a debug version of GUILE. This version does not support this functionality
233 @deffn {Scheme Procedure} standard-eval-closure module
234 @deffnx {C Function} scm_standard_eval_closure (module)
235 Return an eval closure for the module @var{module}.
238 @deffn {Scheme Procedure} mask-signals
239 @deffnx {C Function} scm_mask_signals ()
240 Mask signals. The returned value is not specified.
243 @deffn {Scheme Procedure} unmask-signals
244 @deffnx {C Function} scm_unmask_signals ()
245 Unmask signals. The returned value is not specified.
248 @deffn {Scheme Procedure} noop . args
249 @deffnx {C Function} scm_noop (args)
250 Do nothing. When called without arguments, return @code{#f},
251 otherwise return the first argument.
254 @deffn {Scheme Procedure} system-async thunk
255 @deffnx {C Function} scm_system_async (thunk)
256 This function is deprecated. You can use @var{thunk} directly
257 instead of explicitly creating an async object.
261 @deffn {Scheme Procedure} object-address obj
262 @deffnx {C Function} scm_object_address (obj)
263 Return an integer that for the lifetime of @var{obj} is uniquely
264 returned by this function for @var{obj}
267 @deffn {Scheme Procedure} %compute-slots class
268 @deffnx {C Function} scm_sys_compute_slots (class)
269 Return a list consisting of the names of all slots belonging to
270 class @var{class}, i.e.@: the slots of @var{class} and of all of
274 @deffn {Scheme Procedure} get-keyword key l default_value
275 @deffnx {C Function} scm_get_keyword (key, l, default_value)
276 Determine an associated value for the keyword @var{key} from
277 the list @var{l}. The list @var{l} has to consist of an even
278 number of elements, where, starting with the first, every
279 second element is a keyword, followed by its associated value.
280 If @var{l} does not hold a value for @var{key}, the value
281 @var{default_value} is returned.
284 @deffn {Scheme Procedure} slot-ref-using-class class obj slot_name
285 @deffnx {C Function} scm_slot_ref_using_class (class, obj, slot_name)
289 @deffn {Scheme Procedure} slot-set-using-class! class obj slot_name value
290 @deffnx {C Function} scm_slot_set_using_class_x (class, obj, slot_name, value)
294 @deffn {Scheme Procedure} class-of x
295 @deffnx {C Function} scm_class_of (x)
296 Return the class of @var{x}.
299 @deffn {Scheme Procedure} %goops-loaded
300 @deffnx {C Function} scm_sys_goops_loaded ()
301 Announce that GOOPS is loaded and perform initialization
302 on the C level which depends on the loaded GOOPS modules.
305 @deffn {Scheme Procedure} %method-more-specific? m1 m2 targs
306 @deffnx {C Function} scm_sys_method_more_specific_p (m1, m2, targs)
307 Return true if method @var{m1} is more specific than @var{m2} given the argument types (classes) listed in @var{targs}.
310 @deffn {Scheme Procedure} find-method . l
311 @deffnx {C Function} scm_find_method (l)
315 @deffn {Scheme Procedure} primitive-generic-generic subr
316 @deffnx {C Function} scm_primitive_generic_generic (subr)
320 @deffn {Scheme Procedure} enable-primitive-generic! . subrs
321 @deffnx {C Function} scm_enable_primitive_generic_x (subrs)
325 @deffn {Scheme Procedure} generic-capability? proc
326 @deffnx {C Function} scm_generic_capability_p (proc)
330 @deffn {Scheme Procedure} %invalidate-method-cache! gf
331 @deffnx {C Function} scm_sys_invalidate_method_cache_x (gf)
335 @deffn {Scheme Procedure} %invalidate-class class
336 @deffnx {C Function} scm_sys_invalidate_class (class)
340 @deffn {Scheme Procedure} %modify-class old new
341 @deffnx {C Function} scm_sys_modify_class (old, new)
345 @deffn {Scheme Procedure} %modify-instance old new
346 @deffnx {C Function} scm_sys_modify_instance (old, new)
350 @deffn {Scheme Procedure} %set-object-setter! obj setter
351 @deffnx {C Function} scm_sys_set_object_setter_x (obj, setter)
355 @deffn {Scheme Procedure} %allocate-instance class initargs
356 @deffnx {C Function} scm_sys_allocate_instance (class, initargs)
357 Create a new instance of class @var{class} and initialize it
358 from the arguments @var{initargs}.
361 @deffn {Scheme Procedure} slot-exists? obj slot_name
362 @deffnx {C Function} scm_slot_exists_p (obj, slot_name)
363 Return @code{#t} if @var{obj} has a slot named @var{slot_name}.
366 @deffn {Scheme Procedure} slot-bound? obj slot_name
367 @deffnx {C Function} scm_slot_bound_p (obj, slot_name)
368 Return @code{#t} if the slot named @var{slot_name} of @var{obj}
372 @deffn {Scheme Procedure} slot-set! obj slot_name value
373 @deffnx {C Function} scm_slot_set_x (obj, slot_name, value)
374 Set the slot named @var{slot_name} of @var{obj} to @var{value}.
377 @deffn {Scheme Procedure} slot-exists-using-class? class obj slot_name
378 @deffnx {C Function} scm_slot_exists_using_class_p (class, obj, slot_name)
382 @deffn {Scheme Procedure} slot-bound-using-class? class obj slot_name
383 @deffnx {C Function} scm_slot_bound_using_class_p (class, obj, slot_name)
387 @deffn {Scheme Procedure} %fast-slot-set! obj index value
388 @deffnx {C Function} scm_sys_fast_slot_set_x (obj, index, value)
389 Set the slot with index @var{index} in @var{obj} to
393 @deffn {Scheme Procedure} %fast-slot-ref obj index
394 @deffnx {C Function} scm_sys_fast_slot_ref (obj, index)
395 Return the slot value with index @var{index} from @var{obj}.
398 @deffn {Scheme Procedure} @@assert-bound-ref obj index
399 @deffnx {C Function} scm_at_assert_bound_ref (obj, index)
400 Like @code{assert-bound}, but use @var{index} for accessing
401 the value from @var{obj}.
404 @deffn {Scheme Procedure} assert-bound value obj
405 @deffnx {C Function} scm_assert_bound (value, obj)
406 Return @var{value} if it is bound, and invoke the
407 @var{slot-unbound} method of @var{obj} if it is not.
410 @deffn {Scheme Procedure} unbound? obj
411 @deffnx {C Function} scm_unbound_p (obj)
412 Return @code{#t} if @var{obj} is unbound.
415 @deffn {Scheme Procedure} make-unbound
416 @deffnx {C Function} scm_make_unbound ()
417 Return the unbound value.
420 @deffn {Scheme Procedure} accessor-method-slot-definition obj
421 @deffnx {C Function} scm_accessor_method_slot_definition (obj)
422 Return the slot definition of the accessor @var{obj}.
425 @deffn {Scheme Procedure} method-procedure obj
426 @deffnx {C Function} scm_method_procedure (obj)
427 Return the procedure of the method @var{obj}.
430 @deffn {Scheme Procedure} method-specializers obj
431 @deffnx {C Function} scm_method_specializers (obj)
432 Return specializers of the method @var{obj}.
435 @deffn {Scheme Procedure} method-generic-function obj
436 @deffnx {C Function} scm_method_generic_function (obj)
437 Return the generic function for the method @var{obj}.
440 @deffn {Scheme Procedure} generic-function-methods obj
441 @deffnx {C Function} scm_generic_function_methods (obj)
442 Return the methods of the generic function @var{obj}.
445 @deffn {Scheme Procedure} generic-function-name obj
446 @deffnx {C Function} scm_generic_function_name (obj)
447 Return the name of the generic function @var{obj}.
450 @deffn {Scheme Procedure} class-environment obj
451 @deffnx {C Function} scm_class_environment (obj)
452 Return the environment of the class @var{obj}.
455 @deffn {Scheme Procedure} class-slots obj
456 @deffnx {C Function} scm_class_slots (obj)
457 Return the slot list of the class @var{obj}.
460 @deffn {Scheme Procedure} class-precedence-list obj
461 @deffnx {C Function} scm_class_precedence_list (obj)
462 Return the class precedence list of the class @var{obj}.
465 @deffn {Scheme Procedure} class-direct-methods obj
466 @deffnx {C Function} scm_class_direct_methods (obj)
467 Return the direct methods of the class @var{obj}
470 @deffn {Scheme Procedure} class-direct-subclasses obj
471 @deffnx {C Function} scm_class_direct_subclasses (obj)
472 Return the direct subclasses of the class @var{obj}.
475 @deffn {Scheme Procedure} class-direct-slots obj
476 @deffnx {C Function} scm_class_direct_slots (obj)
477 Return the direct slots of the class @var{obj}.
480 @deffn {Scheme Procedure} class-direct-supers obj
481 @deffnx {C Function} scm_class_direct_supers (obj)
482 Return the direct superclasses of the class @var{obj}.
485 @deffn {Scheme Procedure} class-name obj
486 @deffnx {C Function} scm_class_name (obj)
487 Return the class name of @var{obj}.
490 @deffn {Scheme Procedure} instance? obj
491 @deffnx {C Function} scm_instance_p (obj)
492 Return @code{#t} if @var{obj} is an instance.
495 @deffn {Scheme Procedure} %inherit-magic! class dsupers
496 @deffnx {C Function} scm_sys_inherit_magic_x (class, dsupers)
500 @deffn {Scheme Procedure} %prep-layout! class
501 @deffnx {C Function} scm_sys_prep_layout_x (class)
505 @deffn {Scheme Procedure} %initialize-object obj initargs
506 @deffnx {C Function} scm_sys_initialize_object (obj, initargs)
507 Initialize the object @var{obj} with the given arguments
511 @deffn {Scheme Procedure} make . args
512 @deffnx {C Function} scm_make (args)
513 Make a new object. @var{args} must contain the class and
514 all necessary initialization information.
517 @deffn {Scheme Procedure} slot-ref obj slot_name
518 @deffnx {C Function} scm_slot_ref (obj, slot_name)
519 Return the value from @var{obj}'s slot with the name
523 @deffn {Scheme Procedure} %tag-body body
524 @deffnx {C Function} scm_sys_tag_body (body)
525 Internal GOOPS magic---don't use this function!
528 @deffn {Scheme Procedure} make-keyword-from-dash-symbol symbol
529 @deffnx {C Function} scm_make_keyword_from_dash_symbol (symbol)
530 Make a keyword object from a @var{symbol} that starts with a dash.
533 @deffn {Scheme Procedure} keyword-dash-symbol keyword
534 @deffnx {C Function} scm_keyword_dash_symbol (keyword)
535 Return the dash symbol for @var{keyword}.
536 This is the inverse of @code{make-keyword-from-dash-symbol}.
539 @deffn {Scheme Procedure} dimensions->uniform-array dims prot [fill]
540 @deffnx {Scheme Procedure} make-uniform-vector length prototype [fill]
541 @deffnx {C Function} scm_dimensions_to_uniform_array (dims, prot, fill)
542 Create and return a uniform array or vector of type
543 corresponding to @var{prototype} with dimensions @var{dims} or
544 length @var{length}. If @var{fill} is supplied, it's used to
545 fill the array, otherwise @var{prototype} is used.
548 @deffn {Scheme Procedure} list->uniform-array ndim prot lst
549 @deffnx {C Function} scm_list_to_uniform_array (ndim, prot, lst)
550 Return a uniform array of the type indicated by prototype
551 @var{prot} with elements the same as those of @var{lst}.
552 Elements must be of the appropriate type, no coercions are
555 The argument @var{ndim} determines the number of dimensions
556 of the array. It is either an exact integer, giving the
557 number directly, or a list of exact integers, whose length
558 specifies the number of dimensions and each element is the
559 lower index bound of its dimension.
562 @deffn {Scheme Procedure} array-prototype ra
563 @deffnx {C Function} scm_array_prototype (ra)
564 Return an object that would produce an array of the same type
565 as @var{array}, if used as the @var{prototype} for
566 @code{make-uniform-array}.
569 @deffn {Scheme Procedure} call-with-dynamic-root thunk handler
570 @deffnx {C Function} scm_call_with_dynamic_root (thunk, handler)
571 Call @var{thunk} with a new dynamic state and within a continuation barrier. The @var{handler} catches all otherwise uncaught throws and executes within the same dynamic context as @var{thunk}.
574 @deffn {Scheme Procedure} dynamic-root
575 @deffnx {C Function} scm_dynamic_root ()
576 Return an object representing the current dynamic root.
578 These objects are only useful for comparison using @code{eq?}.
582 @deffn {Scheme Procedure} uniform-vector? obj
583 @deffnx {C Function} scm_uniform_vector_p (obj)
584 Return @code{#t} if @var{obj} is a uniform vector.
587 @deffn {Scheme Procedure} uniform-vector-ref v idx
588 @deffnx {C Function} scm_uniform_vector_ref (v, idx)
589 Return the element at index @var{idx} of the
590 homogeneous numeric vector @var{v}.
593 @deffn {Scheme Procedure} uniform-vector-set! v idx val
594 @deffnx {C Function} scm_uniform_vector_set_x (v, idx, val)
595 Set the element at index @var{idx} of the
596 homogeneous numeric vector @var{v} to @var{val}.
599 @deffn {Scheme Procedure} uniform-vector->list uvec
600 @deffnx {C Function} scm_uniform_vector_to_list (uvec)
601 Convert the uniform numeric vector @var{uvec} to a list.
604 @deffn {Scheme Procedure} uniform-vector-length v
605 @deffnx {C Function} scm_uniform_vector_length (v)
606 Return the number of elements in the uniform vector @var{v}.
609 @deffn {Scheme Procedure} make-u8vector len [fill]
610 @deffnx {C Function} scm_make_u8vector (len, fill)
611 Return a newly allocated uniform numeric vector which can
612 hold @var{len} elements. If @var{fill} is given, it is used to
613 initialize the elements, otherwise the contents of the vector
617 @deffn {Scheme Procedure} u8vector . l
618 @deffnx {C Function} scm_u8vector (l)
619 Return a newly allocated uniform numeric vector containing
623 @deffn {Scheme Procedure} list->u8vector l
624 @deffnx {C Function} scm_list_to_u8vector (l)
625 Convert the list @var{l} to a numeric uniform vector.
628 @deffn {Scheme Procedure} any->u8vector obj
629 @deffnx {C Function} scm_any_to_u8vector (obj)
630 Convert @var{obj}, which can be a list, vector, or
631 uniform vector, to a numeric uniform vector of
635 @deffn {Scheme Procedure} string-any-c-code char_pred s [start [end]]
636 @deffnx {C Function} scm_string_any (char_pred, s, start, end)
637 Check if the predicate @var{pred} is true for any character in
640 Calls to @var{pred} are made from left to right across @var{s}.
641 When it returns true (ie.@: non-@code{#f}), that return value
642 is the return from @code{string-any}.
644 The SRFI-13 specification requires that the call to @var{pred}
645 on the last character of @var{s} (assuming that point is
646 reached) be a tail call, but currently in Guile this is not the
650 @deffn {Scheme Procedure} string-every-c-code char_pred s [start [end]]
651 @deffnx {C Function} scm_string_every (char_pred, s, start, end)
652 Check if the predicate @var{pred} is true for every character
653 in the string @var{s}.
655 Calls to @var{pred} are made from left to right across @var{s}.
656 If the predicate is true for every character then the return
657 value from the last @var{pred} call is the return from
660 If there are no characters in @var{s} (ie.@: @var{start} equals
661 @var{end}) then the return is @code{#t}.
663 The SRFI-13 specification requires that the call to @var{pred}
664 on the last character of @var{s} (assuming that point is
665 reached) be a tail call, but currently in Guile this is not the
669 @deffn {Scheme Procedure} inf? x
670 @deffnx {C Function} scm_inf_p (x)
671 Return @code{#t} if @var{x} is either @samp{+inf.0}
672 or @samp{-inf.0}, @code{#f} otherwise.