\input texinfo
 
 @c data-lens.texi --- Reference manual
 
 @c Copyright (C) 2019 Edward Langley
 
 @c This file is part of data-lens.
 
 
 
 @c Commentary:
 
 @c Generated automatically by Declt version 2.3 "Robert April"
 @c on Mon Apr 29 23:30:58 2019 GMT-8.
 
 
 @c ====================================================================
 @c Header
 @c ====================================================================
 @c %**start of header
 @setfilename data-lens.info
 @settitle The data-lens Reference Manual
 @afourpaper
 @documentencoding UTF-8
 @c %**end of header
 
 
 
 @c ====================================================================
 @c Settings
 @c ====================================================================
 @setchapternewpage odd
 @documentdescription
 The data-lens Reference Manual.
 @end documentdescription
 
 
 
 @c ====================================================================
 @c New Commands
 @c ====================================================================
 
 @c ---------------
 @c Indexing macros
 @c ---------------
 
 @c Packages
 @macro packageindex{name}
 @tpindex \name\
 @tpindex @r{Package, }\name\
 @end macro
 
 @c Systems
 @macro systemindex{name}
 @tpindex \name\
 @tpindex @r{System, }\name\
 @end macro
 
 @c Modules
 @macro moduleindex{name}
 @cindex @t{\name\}
 @cindex Module, @t{\name\}
 @end macro
 
 @c Lisp files
 @macro lispfileindex{name}
 @cindex @t{\name\}
 @cindex Lisp File, @t{\name\}
 @cindex File, Lisp, @t{\name\}
 @end macro
 
 @c C files
 @macro cfileindex{name}
 @cindex @t{\name\}
 @cindex C File, @t{\name\}
 @cindex File, C, @t{\name\}
 @end macro
 
 @c Java files
 @macro javafileindex{name}
 @cindex @t{\name\}
 @cindex Java File, @t{\name\}
 @cindex File, Java, @t{\name\}
 @end macro
 
 @c Other files
 @macro otherfileindex{name}
 @cindex @t{\name\}
 @cindex Other File, @t{\name\}
 @cindex File, other, @t{\name\}
 @end macro
 
 @c Doc files
 @macro docfileindex{name}
 @cindex @t{\name\}
 @cindex Doc File, @t{\name\}
 @cindex File, doc, @t{\name\}
 @end macro
 
 @c HTML files
 @macro htmlfileindex{name}
 @cindex @t{\name\}
 @cindex HTML File, @t{\name\}
 @cindex File, html, @t{\name\}
 @end macro
 
 @c The following macros are meant to be used within @defxxx environments.
 @c Texinfo performs half the indexing job and we do the other half.
 
 @c Constants
 @macro constantsubindex{name}
 @vindex @r{Constant, }\name\
 @end macro
 
 @c Special variables
 @macro specialsubindex{name}
 @vindex @r{Special Variable, }\name\
 @end macro
 
 @c Symbol macros
 @macro symbolmacrosubindex{name}
 @vindex @r{Symbol Macro, }\name\
 @end macro
 
 @c Slots
 @macro slotsubindex{name}
 @vindex @r{Slot, }\name\
 @end macro
 
 @c Macros
 @macro macrosubindex{name}
 @findex @r{Macro, }\name\
 @end macro
 
 @c Compiler Macros
 @macro compilermacrosubindex{name}
 @findex @r{Compiler Macro, }\name\
 @end macro
 
 @c Functions
 @macro functionsubindex{name}
 @findex @r{Function, }\name\
 @end macro
 
 @c Methods
 @macro methodsubindex{name}
 @findex @r{Method, }\name\
 @end macro
 
 @c Generic Functions
 @macro genericsubindex{name}
 @findex @r{Generic Function, }\name\
 @end macro
 
 @c Setf Expanders
 @macro setfexpandersubindex{name}
 @findex @r{Setf Expander, }\name\
 @end macro
 
 @c Method Combinations
 @macro shortcombinationsubindex{name}
 @tpindex @r{Short Method Combination, }\name\
 @tpindex @r{Method Combination, Short, }\name\
 @end macro
 
 @macro longcombinationsubindex{name}
 @tpindex @r{Long Method Combination, }\name\
 @tpindex @r{Method Combination, Long, }\name\
 @end macro
 
 @c Conditions
 @macro conditionsubindex{name}
 @tpindex @r{Condition, }\name\
 @end macro
 
 @c Structures
 @macro structuresubindex{name}
 @tpindex @r{Structure, }\name\
 @end macro
 
 @c Types
 @macro typesubindex{name}
 @tpindex @r{Type, }\name\
 @end macro
 
 @c Classes
 @macro classsubindex{name}
 @tpindex @r{Class, }\name\
 @end macro
 
 
 
 @c ====================================================================
 @c Info Category and Directory
 @c ====================================================================
 @dircategory Common Lisp
 @direntry
 * data-lens Reference: (data-lens). The data-lens Reference Manual.
 @end direntry
 
 
 
 @c ====================================================================
 @c Title Page
 @c ====================================================================
 @titlepage
 @title The data-lens Reference Manual
 @subtitle Utilities for building data transormations from composable functions, modeled on lenses and transducers
 
 @author Edward Langley <@email{el-cl@@elangley.org}>
 
 @page
 @quotation
 This manual was generated automatically by Declt 2.3 "Robert April" on Mon Apr 29 23:30:58 2019 GMT-8.
 @end quotation
 @end titlepage
 
 
 
 @c ====================================================================
 @c Table of Contents
 @c ====================================================================
 @contents
 
 
 
 @c ====================================================================
 @c Top
 @c ====================================================================
 @ifnottex
 @node Top, Systems, (dir), (dir)
 @top The data-lens Reference Manual
 This is the data-lens Reference Manual,
 generated automatically by Declt version 2.3 "Robert April"
 on Mon Apr 29 23:30:58 2019 GMT-8.
 
 @menu
 * Systems:: The systems documentation
 * Files:: The files documentation
 * Packages:: The packages documentation
 * Definitions:: The symbols documentation
 * Indexes:: Concepts, functions, variables and data types
 @end menu
 @end ifnottex
 
 
 
 @c ====================================================================
 @c Systems
 @c ====================================================================
 @node Systems, Files, Top, Top
 @chapter Systems
 The main system appears first, followed by any subsystem dependency.
 
 @menu
 * The data-lens system::
 @end menu
 
 
 @c --------------------
 @c The data-lens system
 @c --------------------
 @node The data-lens system, , Systems, Systems
 @section @t{data-lens}
 @anchor{go to the data-lens system}@c
 @systemindex{data-lens}@c
 @table @strong
 @item Author
 Edward Langley <@email{el-cl@@elangley.org}>
 @item License
 MIT
 @item Description
 Utilities for building data transormations from composable functions, modeled on lenses and transducers
 @item Dependencies
 @itemize @bullet
 @item
 @t{cl-ppcre}
 @item
 @t{alexandria}
 @item
 @t{serapeum}
 @end itemize
 @item Source
 @ref{go to the data-lens<dot>asd file, , @t{data-lens.asd}} (file)
 @item Component
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 
 
 
 @c ====================================================================
 @c Files
 @c ====================================================================
 @node Files, Packages, Systems, Top
 @chapter Files
 Files are sorted by type and then listed depth-first from the systems
 components trees.
 
 @menu
 * Lisp files::
 @end menu
 
 
 @c ----------
 @c Lisp files
 @c ----------
 @node Lisp files, , Files, Files
 @section Lisp
 @menu
 * The data-lens.asd file: The data-lens<dot>asd file.
 * The data-lens/lens.lisp file: The data-lens/lens<dot>lisp file.
 @end menu
 
 @node The data-lens<dot>asd file, The data-lens/lens<dot>lisp file, Lisp files, Lisp files
 @subsection @t{data-lens.asd}
 @anchor{go to the data-lens<dot>asd file}@c
 @lispfileindex{data-lens.asd}@c
 @table @strong
 @item Location
 @t{data-lens.asd}
 @item Systems
 @ref{go to the data-lens system, , @t{data-lens}} (system)
 @end table
 
 @node The data-lens/lens<dot>lisp file, , The data-lens<dot>asd file, Lisp files
 @subsection @t{data-lens/lens.lisp}
 @anchor{go to the data-lens/lens<dot>lisp file}@c
 @lispfileindex{data-lens/lens.lisp}@c
 @table @strong
 @item Parent
 @ref{go to the data-lens system, , @t{data-lens}} (system)
 @item Location
 @t{lens.lisp}
 @item Packages
 @itemize @bullet
 @item
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @end itemize
 @item Exported Definitions
 @itemize @bullet
 @item
 @ref{go to the DATA-LENS<colon><colon><>1 macro, , @t{<>1}} (macro)
 @item
 @ref{go to the DATA-LENS<colon><colon>APPLICABLE-WHEN function, , @t{applicable-when}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>APPLYING macro, , @t{applying}} (macro)
 @item
 @ref{go to the DATA-LENS<colon><colon>COMBINE-MATCHING-LISTS function, , @t{combine-matching-lists}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>COMPRESS-RUNS function, , @t{compress-runs}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>CUMSUM function, , @t{cumsum}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>DEFUN-CT macro, , @t{defun-ct}} (macro)
 @item
 @ref{go to the DATA-LENS<colon><colon>DENEST function, , @t{denest}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>DERIVE function, , @t{derive}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>ELEMENT function, , @t{element}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>EXCLUDE function, , @t{exclude}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>EXTRACT-KEY generic function, , @t{extract-key}} (generic function)
 @item
 @ref{go to the DATA-LENS<colon><colon>EXTRACT-KEY COMMON-LISP<colon><colon>HASH-TABLE COMMON-LISP<colon><colon>T method, , @t{extract-key}} (method)
 @item
 @ref{go to the DATA-LENS<colon><colon>EXTRACT-KEY COMMON-LISP<colon><colon>LIST COMMON-LISP<colon><colon>T method, , @t{extract-key}} (method)
 @item
 @ref{go to the DATA-LENS<colon><colon>INCLUDE function, , @t{include}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>JUXT function, , @t{juxt}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>KEY function, , @t{key}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>KEY-TRANSFORM function, , @t{key-transform}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>LET-FN macro, , @t{let-fn}} (macro)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-ALIST-LENS function, , @t{make-alist-lens}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-HASH-TABLE-LENS function, , @t{make-hash-table-lens}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-PLIST-LENS function, , @t{make-plist-lens}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>MAXIMIZING function, , @t{maximizing}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>OF-LENGTH function, , @t{of-length}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>OF-MAX-LENGTH function, , @t{of-max-length}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>OF-MIN-LENGTH function, , @t{of-min-length}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>ON function, , @t{on}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>OVER function, , @t{over}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>OVER function, , @t{over}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>PICK function, , @t{pick}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>REGEX-MATCH function, , @t{regex-match}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>SET function, , @t{set}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>SHORTCUT macro, , @t{shortcut}} (macro)
 @item
 @ref{go to the DATA-LENS<colon><colon>SLICE function, , @t{slice}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>SORTED function, , @t{sorted}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>SPLICE-ELT function, , @t{splice-elt}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>TRANSFORM-ELT function, , @t{transform-elt}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>TRANSFORM-HEAD function, , @t{transform-head}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>TRANSFORM-TAIL function, , @t{transform-tail}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>VIEW function, , @t{view}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>ZIPPING function, , @t{zipping}} (function)
 @end itemize
 @item Internal Definitions
 @itemize @bullet
 @item
 @ref{go to the DATA-LENS<colon><colon>=>> function, , @t{=>>}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>CLONE generic function, , @t{clone}} (generic function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>CLONE COMMON-LISP<colon><colon>T AROUND method, , @t{clone}} (method)
 @item
 @ref{go to the DATA-LENS<colon><colon>CONS-NEW function, , @t{cons-new}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>CONSTANT- class, , @t{constant-}} (class)
 @item
 @ref{go to the DATA-LENS<colon><colon>DEDUPLICATE function, , @t{deduplicate}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>FILLER function, , @t{filler}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP generic function, , @t{fmap}} (generic function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T DATA-LENS<dot>LENSES<colon><colon>IDENTITY- method, , @t{fmap}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T DATA-LENS<dot>LENSES<colon><colon>CONSTANT- method, , @t{fmap}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T COMMON-LISP<colon><colon>LIST method, , @t{fmap}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T COMMON-LISP<colon><colon>VECTOR method, , @t{fmap}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>IDENTITY- class, , @t{identity-}} (class)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-ALIST-HISTORY-LENS function, , @t{make-alist-history-lens}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>MATCHING-LIST-REDUCER function, , @t{matching-list-reducer}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>UNCONSTANT DATA-LENS<dot>LENSES<colon><colon>CONSTANT- method, , @t{unconstant}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>UNIDENTITY DATA-LENS<dot>LENSES<colon><colon>IDENTITY- method, , @t{unidentity}} (method)
 @item
 @ref{go to the DATA-LENS<colon><colon>UPDATE function, , @t{update}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>UPDATEF macro, , @t{updatef}} (macro)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>WRAP-CONSTANT function, , @t{wrap-constant}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>WRAP-IDENTITY function, , @t{wrap-identity}} (function)
 @end itemize
 @end table
 
 
 
 @c ====================================================================
 @c Packages
 @c ====================================================================
 @node Packages, Definitions, Files, Top
 @chapter Packages
 Packages are listed by definition order.
 
 @menu
 * The data-lens package::
 * The data-lens.lenses package: The data-lens<dot>lenses package.
 @end menu
 
 
 @c ---------------------
 @c The data-lens package
 @c ---------------------
 @node The data-lens package, The data-lens<dot>lenses package, Packages, Packages
 @section @t{data-lens}
 @anchor{go to the DATA-LENS package}@c
 @packageindex{data-lens}@c
 @table @strong
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @item Use List
 @t{common-lisp}
 @item Exported Definitions
 @itemize @bullet
 @item
 @ref{go to the DATA-LENS<colon><colon><>1 macro, , @t{<>1}} (macro)
 @item
 @ref{go to the DATA-LENS<colon><colon>APPLICABLE-WHEN function, , @t{applicable-when}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>APPLYING macro, , @t{applying}} (macro)
 @item
 @ref{go to the DATA-LENS<colon><colon>COMBINE-MATCHING-LISTS function, , @t{combine-matching-lists}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>COMPRESS-RUNS function, , @t{compress-runs}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>CUMSUM function, , @t{cumsum}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>DEFUN-CT macro, , @t{defun-ct}} (macro)
 @item
 @ref{go to the DATA-LENS<colon><colon>DENEST function, , @t{denest}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>DERIVE function, , @t{derive}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>ELEMENT function, , @t{element}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>EXCLUDE function, , @t{exclude}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>EXTRACT-KEY generic function, , @t{extract-key}} (generic function)
 @item
 @ref{go to the DATA-LENS<colon><colon>EXTRACT-KEY COMMON-LISP<colon><colon>HASH-TABLE COMMON-LISP<colon><colon>T method, , @t{extract-key}} (method)
 @item
 @ref{go to the DATA-LENS<colon><colon>EXTRACT-KEY COMMON-LISP<colon><colon>LIST COMMON-LISP<colon><colon>T method, , @t{extract-key}} (method)
 @item
 @ref{go to the DATA-LENS<colon><colon>INCLUDE function, , @t{include}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>JUXT function, , @t{juxt}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>KEY function, , @t{key}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>KEY-TRANSFORM function, , @t{key-transform}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>LET-FN macro, , @t{let-fn}} (macro)
 @item
 @ref{go to the DATA-LENS<colon><colon>MAXIMIZING function, , @t{maximizing}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>OF-LENGTH function, , @t{of-length}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>OF-MAX-LENGTH function, , @t{of-max-length}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>OF-MIN-LENGTH function, , @t{of-min-length}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>ON function, , @t{on}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>OVER function, , @t{over}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>PICK function, , @t{pick}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>REGEX-MATCH function, , @t{regex-match}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>SHORTCUT macro, , @t{shortcut}} (macro)
 @item
 @ref{go to the DATA-LENS<colon><colon>SLICE function, , @t{slice}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>SORTED function, , @t{sorted}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>SPLICE-ELT function, , @t{splice-elt}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>TRANSFORM-ELT function, , @t{transform-elt}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>TRANSFORM-HEAD function, , @t{transform-head}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>TRANSFORM-TAIL function, , @t{transform-tail}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>ZIPPING function, , @t{zipping}} (function)
 @end itemize
 @item Internal Definitions
 @itemize @bullet
 @item
 @ref{go to the DATA-LENS<colon><colon>=>> function, , @t{=>>}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>CONS-NEW function, , @t{cons-new}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>DEDUPLICATE function, , @t{deduplicate}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>FILLER function, , @t{filler}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>MATCHING-LIST-REDUCER function, , @t{matching-list-reducer}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>UPDATE function, , @t{update}} (function)
 @item
 @ref{go to the DATA-LENS<colon><colon>UPDATEF macro, , @t{updatef}} (macro)
 @end itemize
 @end table
 
 
 @c ----------------------------
 @c The data-lens.lenses package
 @c ----------------------------
 @node The data-lens<dot>lenses package, , The data-lens package, Packages
 @section @t{data-lens.lenses}
 @anchor{go to the DATA-LENS<dot>LENSES package}@c
 @packageindex{data-lens.lenses}@c
 @table @strong
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @item Use List
 @t{common-lisp}
 @item Exported Definitions
 @itemize @bullet
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-ALIST-LENS function, , @t{make-alist-lens}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-HASH-TABLE-LENS function, , @t{make-hash-table-lens}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-PLIST-LENS function, , @t{make-plist-lens}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>OVER function, , @t{over}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>SET function, , @t{set}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>VIEW function, , @t{view}} (function)
 @end itemize
 @item Internal Definitions
 @itemize @bullet
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>CLONE generic function, , @t{clone}} (generic function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>CLONE COMMON-LISP<colon><colon>T AROUND method, , @t{clone}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>CONSTANT- class, , @t{constant-}} (class)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP generic function, , @t{fmap}} (generic function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T DATA-LENS<dot>LENSES<colon><colon>IDENTITY- method, , @t{fmap}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T DATA-LENS<dot>LENSES<colon><colon>CONSTANT- method, , @t{fmap}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T COMMON-LISP<colon><colon>LIST method, , @t{fmap}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T COMMON-LISP<colon><colon>VECTOR method, , @t{fmap}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>IDENTITY- class, , @t{identity-}} (class)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-ALIST-HISTORY-LENS function, , @t{make-alist-history-lens}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>UNCONSTANT generic function, , @t{unconstant}} (generic function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>UNCONSTANT DATA-LENS<dot>LENSES<colon><colon>CONSTANT- method, , @t{unconstant}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>UNIDENTITY generic function, , @t{unidentity}} (generic function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>UNIDENTITY DATA-LENS<dot>LENSES<colon><colon>IDENTITY- method, , @t{unidentity}} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>WRAP-CONSTANT function, , @t{wrap-constant}} (function)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>WRAP-IDENTITY function, , @t{wrap-identity}} (function)
 @end itemize
 @end table
 
 
 
 @c ====================================================================
 @c Definitions
 @c ====================================================================
 @node Definitions, Indexes, Packages, Top
 @chapter Definitions
 Definitions are sorted by export status, category, package, and then by
 lexicographic order.
 
 @menu
 * Exported definitions::
 * Internal definitions::
 @end menu
 
 
 @c --------------------
 @c Exported definitions
 @c --------------------
 @node Exported definitions, Internal definitions, Definitions, Definitions
 @section Exported definitions
 @menu
 * Exported macros::
 * Exported functions::
 * Exported generic functions::
 @end menu
 
 @node Exported macros, Exported functions, Exported definitions, Exported definitions
 @subsection Macros
 @deffn {Macro} <>1 &rest FUNS
 @anchor{go to the DATA-LENS<colon><colon><>1 macro}@c
 @macrosubindex{<>1}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Macro} applying FUN &rest ARGS
 @anchor{go to the DATA-LENS<colon><colon>APPLYING macro}@c
 @macrosubindex{applying}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Macro} defun-ct NAME (&rest ARGS) &body BODY
 @anchor{go to the DATA-LENS<colon><colon>DEFUN-CT macro}@c
 @macrosubindex{defun-ct}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Macro} let-fn (&rest BINDINGS) &body BODY
 @anchor{go to the DATA-LENS<colon><colon>LET-FN macro}@c
 @macrosubindex{let-fn}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Macro} shortcut NAME FUNCTION &body BOUND-ARGS
 @anchor{go to the DATA-LENS<colon><colon>SHORTCUT macro}@c
 @macrosubindex{shortcut}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 
 @node Exported functions, Exported generic functions, Exported macros, Exported definitions
 @subsection Functions
 @deffn {Function} applicable-when FUN TEST
 @anchor{go to the DATA-LENS<colon><colon>APPLICABLE-WHEN function}@c
 @functionsubindex{applicable-when}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} combine-matching-lists &key TEST &allow-other-keys
 @anchor{go to the DATA-LENS<colon><colon>COMBINE-MATCHING-LISTS function}@c
 @functionsubindex{combine-matching-lists}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} compress-runs &key COLLECTOR TEST KEY
 @anchor{go to the DATA-LENS<colon><colon>COMPRESS-RUNS function}@c
 @functionsubindex{compress-runs}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} cumsum &key ADD-FUN KEY COMBINE ZERO
 @anchor{go to the DATA-LENS<colon><colon>CUMSUM function}@c
 @functionsubindex{cumsum}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} denest &key RESULT-TYPE
 @anchor{go to the DATA-LENS<colon><colon>DENEST function}@c
 @functionsubindex{denest}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} derive DIFF-FUN &key KEY
 @anchor{go to the DATA-LENS<colon><colon>DERIVE function}@c
 @functionsubindex{derive}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} element NUM
 @anchor{go to the DATA-LENS<colon><colon>ELEMENT function}@c
 @functionsubindex{element}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} exclude PRED
 @anchor{go to the DATA-LENS<colon><colon>EXCLUDE function}@c
 @functionsubindex{exclude}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} include PRED
 @anchor{go to the DATA-LENS<colon><colon>INCLUDE function}@c
 @functionsubindex{include}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} juxt FUN1 &rest R
 @anchor{go to the DATA-LENS<colon><colon>JUXT function}@c
 @functionsubindex{juxt}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} key KEY
 @anchor{go to the DATA-LENS<colon><colon>KEY function}@c
 @functionsubindex{key}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} key-transform FUN KEY-GET KEY-SET
 @anchor{go to the DATA-LENS<colon><colon>KEY-TRANSFORM function}@c
 @functionsubindex{key-transform}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} make-alist-lens KEY
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-ALIST-LENS function}@c
 @functionsubindex{make-alist-lens}@c
 A lens for updating a alist, discarding previous values
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} make-hash-table-lens KEY
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-HASH-TABLE-LENS function}@c
 @functionsubindex{make-hash-table-lens}@c
 A lens for updating a hash-table, discarding previous values
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} make-plist-lens KEY
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-PLIST-LENS function}@c
 @functionsubindex{make-plist-lens}@c
 A lens for updating a plist, preserving previous values
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} maximizing RELATION MEASURE
 @anchor{go to the DATA-LENS<colon><colon>MAXIMIZING function}@c
 @functionsubindex{maximizing}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} of-length LEN
 @anchor{go to the DATA-LENS<colon><colon>OF-LENGTH function}@c
 @functionsubindex{of-length}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} of-max-length LEN
 @anchor{go to the DATA-LENS<colon><colon>OF-MAX-LENGTH function}@c
 @functionsubindex{of-max-length}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} of-min-length LEN
 @anchor{go to the DATA-LENS<colon><colon>OF-MIN-LENGTH function}@c
 @functionsubindex{of-min-length}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} on FUN KEY
 @anchor{go to the DATA-LENS<colon><colon>ON function}@c
 @functionsubindex{on}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} over FUN &key RESULT-TYPE
 @anchor{go to the DATA-LENS<colon><colon>OVER function}@c
 @functionsubindex{over}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} over LENS CB REC
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>OVER function}@c
 @functionsubindex{over}@c
 Given a lens, a callback and a record, apply the lens to the@*
 record, transform it by the callback and return copy of the record,@*
 updated to contain the result of the callback. This is the fundamental
 operation on a lens and SET and VIEW are implemented in terms of it.@*
 
 A lens is any function of the form (lambda (fun) (lambda (rec) ...))@*
 that obeys the lens laws (where == is some reasonable equality@*
 operator):@*
 
     (== (view lens (set lens value rec))@*
         value)@*
  @*
     (== (set lens (view lens rec) rec)@*
         rec)@*
  @*
     (== (set lens value2 (set lens value1 rec))@*
         (set lens value2 rec))@*
 
 The inner lambda returns a functor that determines the policy to be@*
 applied to the focused part.  By default, this only uses IDENTITY- and
 CONSTANT- in order to implement the lens operations over, set and@*
 view.@*
 
 If these conditions are met, (over (data-lens:<>1 lens1 lens2) ...) is
 equivalent to using lens2 to focus the part lens1 focuses: note that
 composition is "backwards" from what one might expect: this is@*
 because composition composes the wrapper lambdas and applies the@*
 lambda that actually pulls a value out of a record later.
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} pick SELECTOR
 @anchor{go to the DATA-LENS<colon><colon>PICK function}@c
 @functionsubindex{pick}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} regex-match REGEX
 @anchor{go to the DATA-LENS<colon><colon>REGEX-MATCH function}@c
 @functionsubindex{regex-match}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} set LENS V REC
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>SET function}@c
 @functionsubindex{set}@c
 Given a lens, a value and a rec, immutably update the rec to@*
 contain the new value at the location focused by the lens.
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} slice START &optional END
 @anchor{go to the DATA-LENS<colon><colon>SLICE function}@c
 @functionsubindex{slice}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} sorted COMPARATOR &rest R &key KEY
 @anchor{go to the DATA-LENS<colon><colon>SORTED function}@c
 @functionsubindex{sorted}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} splice-elt ELT FUN
 @anchor{go to the DATA-LENS<colon><colon>SPLICE-ELT function}@c
 @functionsubindex{splice-elt}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} transform-elt ELT FUN
 @anchor{go to the DATA-LENS<colon><colon>TRANSFORM-ELT function}@c
 @functionsubindex{transform-elt}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} transform-head FUN
 @anchor{go to the DATA-LENS<colon><colon>TRANSFORM-HEAD function}@c
 @functionsubindex{transform-head}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} transform-tail FUN
 @anchor{go to the DATA-LENS<colon><colon>TRANSFORM-TAIL function}@c
 @functionsubindex{transform-tail}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} view LENS REC
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>VIEW function}@c
 @functionsubindex{view}@c
 Given a lens and a rec, return the focused value
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} zipping RESULT-TYPE &key FILL-VALUE
 @anchor{go to the DATA-LENS<colon><colon>ZIPPING function}@c
 @functionsubindex{zipping}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 
 @node Exported generic functions, , Exported functions, Exported definitions
 @subsection Generic functions
 @deffn {Generic Function} extract-key MAP KEY
 @anchor{go to the DATA-LENS<colon><colon>EXTRACT-KEY generic function}@c
 @genericsubindex{extract-key}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @item Methods
 @deffn {Method} extract-key (MAP @t{hash-table}) KEY
 @anchor{go to the DATA-LENS<colon><colon>EXTRACT-KEY COMMON-LISP<colon><colon>HASH-TABLE COMMON-LISP<colon><colon>T method}@c
 @methodsubindex{extract-key}@c
 @end deffn
 @deffn {Method} extract-key (MAP @t{list}) KEY
 @anchor{go to the DATA-LENS<colon><colon>EXTRACT-KEY COMMON-LISP<colon><colon>LIST COMMON-LISP<colon><colon>T method}@c
 @methodsubindex{extract-key}@c
 @end deffn
 @end table
 @end deffn
 
 
 @c --------------------
 @c Internal definitions
 @c --------------------
 @node Internal definitions, , Exported definitions, Definitions
 @section Internal definitions
 @menu
 * Internal macros::
 * Internal functions::
 * Internal generic functions::
 * Internal classes::
 @end menu
 
 @node Internal macros, Internal functions, Internal definitions, Internal definitions
 @subsection Macros
 @deffn {Macro} updatef PLACE FUN &rest ARGS
 @anchor{go to the DATA-LENS<colon><colon>UPDATEF macro}@c
 @macrosubindex{updatef}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 
 @node Internal functions, Internal generic functions, Internal macros, Internal definitions
 @subsection Functions
 @deffn {Function} =>> FUN1 FUN2
 @anchor{go to the DATA-LENS<colon><colon>=>> function}@c
 @functionsubindex{=>>}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} cons-new &key TEST KEY
 @anchor{go to the DATA-LENS<colon><colon>CONS-NEW function}@c
 @functionsubindex{cons-new}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} deduplicate &optional TEST
 @anchor{go to the DATA-LENS<colon><colon>DEDUPLICATE function}@c
 @functionsubindex{deduplicate}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} filler LENGTH1 LENGTH2 FILL-VALUE
 @anchor{go to the DATA-LENS<colon><colon>FILLER function}@c
 @functionsubindex{filler}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} make-alist-history-lens KEY
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>MAKE-ALIST-HISTORY-LENS function}@c
 @functionsubindex{make-alist-history-lens}@c
 A lens for updating a alist, preserving previous values
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} matching-list-reducer TEST ACC NEXT
 @anchor{go to the DATA-LENS<colon><colon>MATCHING-LIST-REDUCER function}@c
 @functionsubindex{matching-list-reducer}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} update THING FUN &rest ARGS
 @anchor{go to the DATA-LENS<colon><colon>UPDATE function}@c
 @functionsubindex{update}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS package, , @t{data-lens}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} wrap-constant V
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>WRAP-CONSTANT function}@c
 @functionsubindex{wrap-constant}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @deffn {Function} wrap-identity V
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>WRAP-IDENTITY function}@c
 @functionsubindex{wrap-identity}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 
 @node Internal generic functions, Internal classes, Internal functions, Internal definitions
 @subsection Generic functions
 @deffn {Generic Function} clone OBJ &rest NEW-INITARGS &key
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>CLONE generic function}@c
 @genericsubindex{clone}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @item Methods
 @deffn {Method} clone OBJ &rest NEW-INITARGS &key @t{around}
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>CLONE COMMON-LISP<colon><colon>T AROUND method}@c
 @methodsubindex{clone}@c
 @end deffn
 @end table
 @end deffn
 @deffn {Generic Function} fmap FUNCTION DATA
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP generic function}@c
 @genericsubindex{fmap}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @item Methods
 @deffn {Method} fmap FUNCTION (DATA @t{identity-})
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T DATA-LENS<dot>LENSES<colon><colon>IDENTITY- method}@c
 @methodsubindex{fmap}@c
 @end deffn
 @deffn {Method} fmap FUNCTION (DATA @t{constant-})
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T DATA-LENS<dot>LENSES<colon><colon>CONSTANT- method}@c
 @methodsubindex{fmap}@c
 @end deffn
 @deffn {Method} fmap FUNCTION (DATA @t{list})
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T COMMON-LISP<colon><colon>LIST method}@c
 @methodsubindex{fmap}@c
 @end deffn
 @deffn {Method} fmap FUNCTION (DATA @t{vector})
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T COMMON-LISP<colon><colon>VECTOR method}@c
 @methodsubindex{fmap}@c
 @end deffn
 @end table
 @end deffn
 @deffn {Generic Function} unconstant OBJECT
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>UNCONSTANT generic function}@c
 @genericsubindex{unconstant}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Methods
 @deffn {Method} unconstant (CONSTANT- @t{constant-})
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>UNCONSTANT DATA-LENS<dot>LENSES<colon><colon>CONSTANT- method}@c
 @methodsubindex{unconstant}@c
 automatically generated reader method
 @table @strong
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @end table
 @end deffn
 @deffn {Generic Function} unidentity OBJECT
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>UNIDENTITY generic function}@c
 @genericsubindex{unidentity}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Methods
 @deffn {Method} unidentity (IDENTITY- @t{identity-})
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>UNIDENTITY DATA-LENS<dot>LENSES<colon><colon>IDENTITY- method}@c
 @methodsubindex{unidentity}@c
 automatically generated reader method
 @table @strong
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @end table
 @end deffn
 @end table
 @end deffn
 
 @node Internal classes, , Internal generic functions, Internal definitions
 @subsection Classes
 @deftp {Class} constant- ()
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>CONSTANT- class}@c
 @classsubindex{constant-}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @item Direct superclasses
 @t{standard-object} (class)
 @item Direct methods
 @itemize @bullet
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T DATA-LENS<dot>LENSES<colon><colon>CONSTANT- method, , @t{fmap}} (method)
 @item
 @t{print-object} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>UNCONSTANT DATA-LENS<dot>LENSES<colon><colon>CONSTANT- method, , @t{unconstant}} (method)
 @end itemize
 @item Direct slots
 @defvr {Slot} %v
 @slotsubindex{%v}@c
 @table @strong
 @item Initargs
 @t{:value}
 @item Readers
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>UNCONSTANT generic function, , @t{unconstant}} (generic function)
 @end table
 @end defvr
 @end table
 @end deftp
 @deftp {Class} identity- ()
 @anchor{go to the DATA-LENS<dot>LENSES<colon><colon>IDENTITY- class}@c
 @classsubindex{identity-}@c
 @table @strong
 @item Package
 @ref{go to the DATA-LENS<dot>LENSES package, , @t{data-lens.lenses}}
 @item Source
 @ref{go to the data-lens/lens<dot>lisp file, , @t{lens.lisp}} (file)
 @item Direct superclasses
 @t{standard-object} (class)
 @item Direct methods
 @itemize @bullet
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>FMAP COMMON-LISP<colon><colon>T DATA-LENS<dot>LENSES<colon><colon>IDENTITY- method, , @t{fmap}} (method)
 @item
 @t{print-object} (method)
 @item
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>UNIDENTITY DATA-LENS<dot>LENSES<colon><colon>IDENTITY- method, , @t{unidentity}} (method)
 @end itemize
 @item Direct slots
 @defvr {Slot} %v
 @slotsubindex{%v}@c
 @table @strong
 @item Initargs
 @t{:value}
 @item Readers
 @ref{go to the DATA-LENS<dot>LENSES<colon><colon>UNIDENTITY generic function, , @t{unidentity}} (generic function)
 @end table
 @end defvr
 @end table
 @end deftp
 
 
 
 @c ====================================================================
 @c Indexes
 @c ====================================================================
 @node Indexes, , Definitions, Top
 @appendix Indexes
 @menu
 * Concept index::
 * Function index::
 * Variable index::
 * Data type index::
 @end menu
 
 
 @c -------------
 @c Concept index
 @c -------------
 @node Concept index, Function index, Indexes, Indexes
 @appendixsec Concepts
 @printindex cp
 
 @page
 
 
 @c --------------
 @c Function index
 @c --------------
 @node Function index, Variable index, Concept index, Indexes
 @appendixsec Functions
 @printindex fn
 
 @page
 
 
 @c --------------
 @c Variable index
 @c --------------
 @node Variable index, Data type index, Function index, Indexes
 @appendixsec Variables
 @printindex vr
 
 @page
 
 
 @c ---------------
 @c Data type index
 @c ---------------
 @node Data type index, , Variable index, Indexes
 @appendixsec Data types
 @printindex tp
 
 @bye
 
 @c data-lens.texi ends here