lispdoc - results for elt

(elt sequence index)
Function: Return the element of SEQUENCE specified by INDEX.
Example:
(defun revelt (a b) (elt b a))
Mentioned in:
CLtL2 - 14.1. Simple Sequence Functions
CLtL2 - 15.2. Lists
CLtL2 - 17.2. Array Access
CLtL2 - 18.1. String Access
CLtL2 - 25.1.4. Similarity of Constants
CLtL2 - 6.4. Logical Operators
HyperSpec - Accessor ELT
On Lisp - Other Structures
PCL - hash table iteration
PCL - other structures
PCL - sequence iterating functions
PCL - string comparisons
PCL - vectors as sequences
Successful Lisp - chapter13
Successful Lisp - characters
Successful Lisp - efficiency
(alexandria.0.dev:last-elt sequence)
Function: Returns the last element of SEQUENCE. Signals a type-error if SEQUENCE is not a proper sequence, or is an empty sequence.
  
(alexandria.0.dev:first-elt sequence)
Function: Returns the first element of SEQUENCE. Signals a type-error if SEQUENCE is not a sequence, or is an empty sequence.
  
(alexandria.0.dev:random-elt sequence &key (start 0) end)
Function: Returns a random element from SEQUENCE bounded by START and END. Signals an error if the SEQUENCE is not a proper sequence.
  
(let bindings &body body)
Function: LET ({(var [value]) | var}*) declaration* form* During evaluation of the FORMS, bind the VARS to the result of evaluating the VALUE forms. The variables are bound in parallel after all of the VALUES forms have been evaluated.
Example:
(defun unmemoize-all-functions ()
  "Unmemoizes all currently-memoized functions"
  (let ((previously-memoized-functions
         *memoized-function-names*))
    (unmemoize-functions
     *memoized-function-names*)
    previously-memoized-functions))
Mentioned in:
CLtL2 - 22.1.6. What the Print Function Produces
CLtL2 - 26.2. How the Loop Facility Works
CLtL2 - 26.3.2. Kinds of Loop Clauses
CLtL2 - 27.3. Dynamic Control of the Arrangement of Output
CLtL2 - 27.6. Pretty Printing Dispatch Tables
CLtL2 - 3. Scope and Extent
CLtL2 - 5.1.2. Variables
CLtL2 - 5.3.3. Control of Time of Evaluation
CLtL2 - 7.10.2. Rules Governing the Passing of Multiple Values
CLtL2 - 7.5. Establishing New Variable Bindings
CLtL2 - 7.8. Iteration
CLtL2 - 7.8.2. General Iteration
CLtL2 - 7.8.5. The ``Program Feature''
CLtL2 - 9.1. Declaration Syntax
CLtL2 - 9.2. Declaration Specifiers
CLtL2 - A.2.2. Mapping
CLtL2 - A.3.1. Basic Restrictions
CLtL2 - A.3.4. Declarations
CLtL2 - A.4. Primitives
CLtL2 - B.4. Discussion
HyperSpec - Special Operator LET, LET
On Lisp - A Model of Macros
On Lisp - A Query Compiler (AQC)
On Lisp - A Query Interpreter
On Lisp - Adding Prolog Features
On Lisp - An ATN Compiler
On Lisp - An Interpreter
On Lisp - Anaphoric Macros
On Lisp - Anaphoric Macros (Macro-Defining Macros)
On Lisp - Anaphoric Variants
On Lisp - Applications for Macros
On Lisp - Avoiding Capture by Prior Evaluation
On Lisp - Avoiding Capture with Gensyms
On Lisp - Birth of a Utility
On Lisp - CLOS and Lisp
On Lisp - Chapter _28
On Lisp - Classes and Instances
On Lisp - Common Lisp Evolves
On Lisp - Common Lisp Implementation
On Lisp - Conditional Evaluation
On Lisp - Continuation-Passing Macros
On Lisp - Creating Context
On Lisp - Destructuring in Parameter Lists
On Lisp - Free Symbol Capture
On Lisp - Functional Interfaces
On Lisp - Functions as Properties
On Lisp - Functions as Representation
On Lisp - Imperative Outside-In
On Lisp - Iteration with Multiple Values
On Lisp - Local Functions
On Lisp - Macro-Defining Macros
On Lisp - Macros as Programs
On Lisp - Macros from Functions
On Lisp - Need for Macros
On Lisp - New Implementation
On Lisp - New Utilities (Computation at Compile-Time)
On Lisp - Non-functional Expanders
On Lisp - Number of Evaluations
On Lisp - Objects in Plain Lisp
On Lisp - Operations on Lists
On Lisp - Other Structures
On Lisp - Recursion on Cdrs (Macros Returning Functions)
On Lisp - Recursion on Subtrees (Macros Returning Functions)
On Lisp - Referential Transparency
On Lisp - Scheme Continuations
On Lisp - The Concept (Nondeterminism)
On Lisp - The with- Macro
On Lisp - True Nondeterminism
On Lisp - When Capture Occurs
PCL - closing files
PCL - do
PCL - dynamic aka special variables
PCL - hash tables
PCL - lexical variables and closures
PCL - macro writing macros
PCL - manipulating the lexical environment
PCL - other kinds of io
PCL - other special operators
PCL - other ways to modify places
PCL - plugging the leaks
PCL - query parameter types
PCL - special operators
PCL - the compiler
PCL - the current object stack
PCL - the implementation
PCL - variable basics
PCL - whats next
PCL - where to go next
Successful Lisp - chapter06
Successful Lisp - chapter08
Successful Lisp - chapter09
Successful Lisp - chapter11
Successful Lisp - chapter13
Successful Lisp - chapter15
Successful Lisp - chapter20
Successful Lisp - chapter29
Successful Lisp - global vars and consts
Successful Lisp - lesson 11
Successful Lisp - lesson 3
Successful Lisp - lesson 6
Successful Lisp - lesson 7
Successful Lisp - lesson 9
Successful Lisp - special
Successful Lisp - tail recursion
(let* bindings &body body)
Function: LET* ({(var [value]) | var}*) declaration* form* Similar to LET, but the variables are bound sequentially, allowing each VALUE form to reference any of the previous VARS.
Example:
(defun make-image ()
  (let* ((name (create-name))
         (i
          (make-instance 'photo-image :name
                         name)))
    i))
Mentioned in:
CLtL2 - 5.2.2. Lambda-Expressions
CLtL2 - 7.10.2. Rules Governing the Passing of Multiple Values
CLtL2 - 7.2. Generalized Variables
CLtL2 - 7.5. Establishing New Variable Bindings
CLtL2 - 7.8.2. General Iteration
CLtL2 - 7.8.5. The ``Program Feature''
CLtL2 - A.3.1. Basic Restrictions
On Lisp - Anaphoric Macros (Macro-Defining Macros)
On Lisp - Common Lisp Implementation
On Lisp - Functional Design
On Lisp - Iteration with Multiple Values
On Lisp - Operations on Lists
On Lisp - When Capture Occurs
PCL - manipulating the lexical environment
PCL - the implementation
PCL - variable basics
PCL - where to go next
Successful Lisp - lesson 3
default
 
 Mentioned in:
HyperSpec - 22.1.3 Default Print-Object Methods