lispdoc - results for iota

t
Undocumented
Example:
(defun host-thread-alivep (pid) t)
Mentioned in:
CLtL2 - 1.2.2. Nil, False, and the Empty List
CLtL2 - 10.1. The Property List
CLtL2 - 10.3. Creating Symbols
CLtL2 - 11.6. Built-in Packages
CLtL2 - 11.7. Package System Functions and Variables
CLtL2 - 12.9. Random Numbers
CLtL2 - 16.1. Hash Table Functions
CLtL2 - 17.1. Array Creation
CLtL2 - 17.3. Array Information
CLtL2 - 17.4. Functions on Arrays of Bits
CLtL2 - 17.5. Fill Pointers
CLtL2 - 17.6. Changing the Dimensions of an Array
CLtL2 - 18.3. String Construction and Manipulation
CLtL2 - 19.5. Defstruct Options
CLtL2 - 19.7.2. Named Structures
CLtL2 - 2. Data Types
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 20.1. Run-Time Evaluation of Forms
CLtL2 - 21.3. Operations on Streams
CLtL2 - 22.1.2. Parsing of Numbers and Symbols
CLtL2 - 22.1.5. The Readtable
CLtL2 - 22.1.6. What the Print Function Produces
CLtL2 - 22.2.1. Input from Character Streams
CLtL2 - 22.3.1. Output to Character Streams
CLtL2 - 23.1.2. Case Conventions
CLtL2 - 23.1.5.3. Using Logical Pathnames
CLtL2 - 23.3. Renaming, Deleting, and Other File Operations
CLtL2 - 24.3. Special Forms for Exhaustive Case Analysis
CLtL2 - 25.1. The Compiler
CLtL2 - 25.3. Debugging Tools
CLtL2 - 26.12.1. Data Types
CLtL2 - 26.3.2. Kinds of Loop Clauses
CLtL2 - 26.7. End-Test Control
CLtL2 - 26.9. Variable Initializations
CLtL2 - 27.3. Dynamic Control of the Arrangement of Output
CLtL2 - 27.4. Format Directive Interface
CLtL2 - 27.6. Pretty Printing Dispatch Tables
CLtL2 - 28.1.2. Classes
CLtL2 - 28.1.3.2. Inheritance of Slots and Slot Options
CLtL2 - 28.1.4. Integrating Types and Classes
CLtL2 - 28.1.5.2. Examples
CLtL2 - 28.1.6.2. Introduction to Methods
CLtL2 - 28.1.6.4. Congruent Lambda-Lists for All Methods of a Generic Function
CLtL2 - 28.1.9.5. Shared-Initialize
CLtL2 - 28.1.9.6. Initialize-Instance
CLtL2 - 28.2. Functions in the Programmer Interface
CLtL2 - 29.4.3. Exhaustive Case Analysis
CLtL2 - 29.4.7. Establishing Restarts
CLtL2 - 4.3. Predicating Type Specifiers
CLtL2 - 4.5. Type Specifiers That Specialize
CLtL2 - 4.8. Type Conversion Function
CLtL2 - 4.9. Determining the Type of an Object
CLtL2 - 5.1.2. Variables
CLtL2 - 5.3.2. Declaring Global Variables and Named Constants
CLtL2 - 6. Predicates
CLtL2 - 6.1. Logical Values
CLtL2 - 6.2.1. General Type Predicates
CLtL2 - 6.3. Equality Predicates
CLtL2 - 6.4. Logical Operators
CLtL2 - 7.10.2. Rules Governing the Passing of Multiple Values
CLtL2 - 7.6. Conditionals
CLtL2 - 7.8.3. Simple Iteration Constructs
CLtL2 - 8.2. Macro Expansion
CLtL2 - 8.5. Environments
CLtL2 - A.2.2. Mapping
CLtL2 - A.2.4. Conditional and Other Complex Transducers
CLtL2 - A.2.5. Collectors
CLtL2 - A.3.4. Declarations
HyperSpec - Constant Variable T
HyperSpec - System Class T
HyperSpec - T
On Lisp - A Query Compiler (AQC)
On Lisp - Adding Prolog Features
On Lisp - An Interpreter
On Lisp - Chapter _28
On Lisp - Classes and Instances
On Lisp - Common Lisp Evolves
On Lisp - Conditional Evaluation
On Lisp - Continuation-Passing Macros
On Lisp - Functions as Representation
On Lisp - Macro Characters
On Lisp - Macro Style
On Lisp - New Implementation
On Lisp - Non-functional Expanders
On Lisp - Objects in Plain Lisp
On Lisp - Operations on Lists
On Lisp - Other Structures
On Lisp - Recursion on Cdrs
On Lisp - Recursion on Cdrs (Macros Returning Functions)
On Lisp - Referential Transparency
On Lisp - The Process Abstraction
On Lisp - The with- Macro
PCL - and more
PCL - and or and not
PCL - cond
PCL - defclass
PCL - defmethod
PCL - fixing the return value
PCL - generic functions and classes
PCL - method combination
PCL - multiple inheritance
PCL - object reorientation classes
PCL - other database operations
PCL - other ways to modify places
PCL - querying the database
PCL - refactoring
PCL - s expressions as lisp forms
PCL - saving your work
PCL - subsequence manipulations
PCL - termination tests
PCL - testing a files existence
PCL - the basic evaluation rule
PCL - the compiler
PCL - the format function
PCL - to be continued
PCL - truth falsehood and equality
PCL - two first tries
Successful Lisp - chapter09
Successful Lisp - chapter10
Successful Lisp - chapter18
Successful Lisp - chapter19
Successful Lisp - chapter24
Successful Lisp - chapter29
Successful Lisp - evaluated
Successful Lisp - global vars and consts
Successful Lisp - hash tables
Successful Lisp - lesson 12
Successful Lisp - lesson 3
Successful Lisp - lesson 4
Successful Lisp - tail recursion
(alexandria.0.dev:iota n &key (start 0) (step 1))
Function: Return a list of n numbers, starting from START (with numeric contagion from STEP applied), each consequtive number being the sum of the previous one and STEP. START defaults to 0 and STEP to 1. Examples: (iota 4) => (0 1 2 3 4) (iota 3 :start 1 :step 1.0) => (1.0 2.0 3.0) (iota 3 :start -1 :step -1/2) => (-1 -3/2 -2)
  
(alexandria.0.dev:map-iota function n &key (start 0) (step 1))
Function: Calls FUNCTION with N numbers, starting from START (with numeric contagion from STEP applied), each consequtive number being the sum of the previous one and STEP. START defaults to 0 and STEP to 1. Returns N. Examples: (map-iota #'print 3 :start 1 :step 1.0) => 3 ;;; 1.0 ;;; 2.0 ;;; 3.0
  
top
 
 Mentioned in:
HyperSpec - 25.1.1 Top level loop
HyperSpec - 3.2.3.1 Processing of Top Level Forms
too
 
 Mentioned in:
HyperSpec - 3.5.1.2 Too Few Arguments
HyperSpec - 3.5.1.3 Too Many Arguments
to
 
 Mentioned in:
HyperSpec - 11.1.1 Introduction to Packages
HyperSpec - 11.1.2.1.2.1 Some Exceptions to Constraints on the COMMON-LISP Package for Conforming Programs
HyperSpec - 13.1.1 Introduction to Characters
HyperSpec - 13.1.2 Introduction to Scripts and Repertoires
HyperSpec - 18.1.2.1 Visible Modification of Objects with respect to EQ and EQL
HyperSpec - 18.1.2.2 Visible Modification of Objects with respect to EQUAL
HyperSpec - 18.1.2.2.1 Visible Modification of Conses with respect to EQUAL
HyperSpec - 18.1.2.2.2 Visible Modification of Bit Vectors and Strings with respect to EQUAL
HyperSpec - 18.1.2.3 Visible Modification of Objects with respect to EQUALP
HyperSpec - 18.1.2.3.1 Visible Modification of Structures with respect to EQUALP
HyperSpec - 18.1.2.3.2 Visible Modification of Arrays with respect to EQUALP
HyperSpec - 18.1.2.3.3 Visible Modification of Hash Tables with respect to EQUALP
HyperSpec - 20.1.1 Coercion of Streams to Pathnames
HyperSpec - 21.1.1 Introduction to Streams
HyperSpec - 21.1.3 Stream Arguments to Standardized Functions
HyperSpec - 3.1.1 Introduction to Environments
HyperSpec - 3.2.4.3 Extensions to Similarity Rules
HyperSpec - 4.3.1 Introduction to Classes
HyperSpec - 5.1.1.1 Evaluation of Subforms to Places
HyperSpec - 5.1.1.1.1 Examples of Evaluation of Subforms to Places
HyperSpec - 5.2 Transfer of Control to an Exit Point
HyperSpec - 7.5.1 Introduction to Slots
HyperSpec - 7.6.1 Introduction to Generic Functions
HyperSpec - 7.6.2 Introduction to Methods
HyperSpec - 7.6.6.1.3 Applying method combination to the sorted list of applicable methods
HyperSpec - 9.1.4.2.2 Interfaces to Restarts
t:
 
 Mentioned in:
HyperSpec - 22.3.6.1 Tilde T: Tabulate
go-to
 
 Mentioned in:
HyperSpec - 22.3.7.1 Tilde Asterisk: Go-To