
- LISP Tutorial
- LISP - Home
- LISP - Overview
- LISP - Environment
- LISP - REPL
- LISP - Program Structure
- LISP - Basic Syntax
- LISP - Data Types
- Lisp Macros
- LISP - Macros
- LISP - Backquote and Comma
- LISP - Code Generation Using Macro
- LISP - Variable Capture and Hygienic macro
- LISP - Scope and Binding
- LISP - Macro Writing Style
- LISP - Macro Characters
- LISP - Read-Time Macros
- LISP - Compiler Macros
- LISP - Uses of Macros
- Lisp Functions
- LISP - Functions
- LISP - Functions vs Macros
- LISP - Calling Function using funcall
- LISP - Calling Function using apply
- LISP - Closures
- LISP - Functions as Arguments
- LISP - Functions as Return Values
- LISP - Recursion
- LISP - Built-in Functions
- Lisp Predicates
- LISP - Predicates
- LISP - Generic Data Type Predicates
- LISP - Specific Data Type Predicates
- LISP - Equality Predicates
- LISP - Numeric Predicates
- LISP - Comparison Predicates
- LISP - Logical Predicates
- LISP - List Predicates
- LISP - Custom Predicates
- LISP - Chaining Predicates
- Lisp Arrays
- LISP - Arrays
- LISP - Adjustable Arrays
- LISP - Fill Pointers in Arrays
- LISP - Specialized Arrays
- LISP - Arrays Properties
- LISP - Iterating over Arrays
- LISP - Multidimensional Arrays
- LISP - Row-Major Order
- Lisp Strings
- LISP - Strings
- LISP - String Concatenation
- LISP - String Comparison
- LISP - String Case Conversion
- LISP - String Trimmimg
- LISP - String Searching
- LISP - Getting Substring
- LISP - String Replacement
- LISP - Sorting Strings
- LISP - Merging Strings
- LISP - Accessing Characters of String
- LISP - String length
- LISP - Escape Sequences
- Lisp Sequences
- LISP - Sequences
- LISP - Accessing Element of Sequence
- LISP - Sequence length
- LISP - Getting Subsequence
- LISP - Search Element in Sequence
- LISP - Sequence Concatenation
- LISP - Reversing a Sequence
- LISP - Mapping Sequence Element
- LISP - position of Element
- LISP - Remove an Element
- LISP - Sort Sequence
- LISP - Merge Sequences
- LISP - every function
- LISP - some function
- LISP - notany function
- LISP - notevery function
- Lisp Lists
- LISP - Lists
- LISP - Accessing Elements of Lists
- LISP - Modifications to Lists
- LISP - Using mapcar on List
- LISP - Using mapc on List
- LISP - Using reduce on List
- LISP - Removing elements from List
- LISP - Reversing a List
- LISP - Sorting a List
- LISP - Searching a List
- LISP - List vs Vectors
- LISP - Matrix Multiplication
- Lisp Vectors
- LISP - Vectors
- LISP - Creating Vectors
- LISP - Accessing Elements of Vectors
- LISP - Modifications to Vectors
- LISP - Adjustable Vectors
- LISP - Specialized Vectors
- LISP - Vector Functions
- Lisp Set
- LISP - Set
- LISP - Adding elements to the Set
- LISP - Getting SubSet from a Set
- LISP - Set Difference
- LISP - Set Exclusive OR
- LISP - Set Intersection
- LISP - Set Union
- LISP - Representing Set with HashTable
- LISP - List as Set vs HashTable as Set
- Lisp Tree
- LISP - Tree
- LISP - Recursive Traversal
- LISP - Inorder Traversal
- LISP - Preorder Traversal
- LISP - Postorder Traversal
- LISP - Depth First Traversal
- LISP - Modifying Tree
- LISP - Search Tree
- LISP - Binary Tree
- Lisp Hash Table
- LISP - Hash Table
- Adding Values to Hash Table
- Removing Values from Hash Table
- Updating Values of Hash Table
- Iterating Hash Table Entries
- Searching key in HashTable
- Checking Size of HashTable
- Using Custom Equality Check
- Lisp - Input − Output
- LISP - Input − Output
- LISP - Streams
- LISP - Reading Data from Streams
- LISP - Writing Data to Streams
- LISP - File I/O
- LISP - String I/O
- LISP - Formatting with Format
- LISP - Interactive I/O
- LISP - Error Handling
- LISP - Binary I/O
- Lisp - Structures
- LISP - Structures
- LISP - Accessors and Mutators
- LISP - Structure Options
- LISP - Structure Types
- LISP - Applications and Best Practices
- Lisp - CLOS
- LISP - CLOS
- Lisp - Objects
- LISP - Class
- LISP - Slots and Accessors
- LISP - Generic Functions
- LISP - Class Precedence
- LISP - Metaobject Protocol
- LISP - Multimethods
- LISP - Multiple Inheritance
- LISP - Method Combinations
- LISP - Method Combinations
- LISP - :before Method Combination
- LISP - :primary Method Combination
- LISP - :after Method Combination
- LISP - :around Method Combination
- LISP - + Method Combination
- LISP - and Method Combination
- LISP - append Method Combination
- LISP Useful Resources
- Lisp - Quick Guide
- Lisp - Useful Resources
- Lisp - Discussion
Lisp - every Function
Lisp provides every function on sequence (list, vector or string) to check if a predicate holds t (true) for all elements of the sequence. every function applies the predicate on each element of the sequence in order. If any of element fails false for the given predicate, every function calls stops and return false.
Syntax - every function
(every predicate sequence)
Arguments
-
predicate− predicate to be applied. It returns t if check on element of sequence is true otherwise nil.
-
sequence− sequence to be searched.
Returns
This function returns t (true) if predicate holds true for all elements of sequence, nil(false) otherwise.
Example - Checking all numbers as even numbers
Following example shows how to apply even number check on every element of the list and vectors.
main.lisp
; Check all elements of a list to be even; T (print(every #'evenp '(2 4 6 8))) (terpri) ; Check all elements of a vector to be even; T (print(every #'evenp #(2 4 6 8))) (terpri) ; Check all elements of a list to be even; NIL as 3 is odd (print(every #'evenp '(2 3 4 6 8))) (terpri) ; Check all elements of a vector to be even; NIL as 3 is odd (print(every #'evenp #(2 3 4 6 8)))
Output
When you execute the code, it returns the following result −
T T NIL NIL
Example - Checking numbers less than 10
Following example shows how to apply a custom function check using lambda function on every element of the list.
main.lisp
; Check if all numbers in the list are less than 10; returns t (print(every #'(lambda (x) (< x 10)) '(1 5 4 2))) (terpri) ; Check if all numbers in the list are less than 10; returns false (print(every #'(lambda (x) (< x 10)) '(1 5 11 2)))
Output
When you execute the code, it returns the following result −
T NIL
Example - Checking all character in String as alphabetic
Following example shows how to apply predicate on string.
main.lisp
; Checking a string to contain only alphabets; returns T (print(every #'alpha-char-p "tutorialspoint")) (terpri) ; Checking a string to contain only alphabets; returns NIL as it is alphanumeric (print(every #'alpha-char-p "tutorialspoint123"))
Output
When you execute the code, it returns the following result −
T NIL
Example - Checking Multiple lists for equality
We can use every on multiple sequences as well. The predicate must accept the same number of parameters as there are sequences as shown below:
main.lisp
; Checking if lists are same; returns T (print(every #'(lambda (x y) (eq x y)) '(a a a) '(a a a))) (terpri) ; Checking if list are same; returns NIL (print(every #'(lambda (x y) (eq x y)) '(a a a) '(b b b)))
Output
When you execute the code, it returns the following result −
T NIL
Applications
The every function is very useful in scenarios where all elements must meet a certain criteria. Following are some of the applications of every function.
Data validation− To check if all entries are as per given criteria.
Property testing− To verify if entries of a collection are following required property.
Algorithm verification− To ensure, all elements of the collection follow the required pre-requisites.
By using every function with relevant predicate, we can efficiently and concisely express complex conditions on a sequence in Lisp.