anchor.diff:  (defclass restart-kind (kind)
     ())
   
  +;; (defun register-restart-kind (kind))
  +;; (defun find-restart-kind (name &optional (noerr nil)))
  +;; (defun remove-restart-kind (kind))
  +
  +
   (defsingleton continue-restart-kind (restart-kind)
     ()
     (:default-initargs :name 'continue))
   
  +;; (register-restart-kind 'continue-restart-kind)
   
   (defclass lambda-kind (kind)
     ())
   
  +;; (defun register-lambda-kind (kind))
  +;; (defun find-lambda-kind (name &optional (noerr nil)))
  +;; (defun remove-lambda-kind (kind))
  +
  +
   (defsingleton restart-main-lambda-kind (lambda-kind)
     ()
     (:default-initargs :name :main))
  
positive.code: 
  (in-package #:ltp/dobelle/app)
  
  ;; ---
  
  (defgeneric kind-name (kind))
  (defgeneric (setf kind-name) (new-name kind))
  
negative.code: ;; w/ symbols subsq renamed s/app-//
  
  
  #|
  
  Remarks - API Design
  
  - This API endeavors to develop some characteristics of a concept,
    broadly: Normal application definitions, for Common Lisp programs.
  
    Below, this concept - in a manner, an application pattern -- is
    represented insofar as for two generic usage cases in Common Lisp
    programming, principally:
  
      - Representation of Common Lisp Restarts and Condition Objects
  
      - Definition of a generic API for definition and management
        of an application runtime lifecycle - in a manner: Application
        initialization, application runtime event handling, and
        application termination.
  
  
    With regards to representations of restarts and condition objects, in
    Common Lisp programs, two generic usage cases are addressed below:
  
      - Interactive Common Lisp applications, represented here as vis a
        vis: User interaction with the implementation debugger - here,
        focusing on the implementation of a generic 'CONTINUE' restart, at
        a granularity of a genric application API
  
      - N!ointeractive Common Lisp applications, such as may provide any
        manner of intrinsic handling for Common Lisp conditions, in any
        arbitrary application usage cases. (NB: CERROR -> CONTINUE := FAIL)
  
  
    The concept of a generic API for applications lifecyle (definition and
    management) is developed - albeit in something of a rudimentary regard -
    towards applications in multi-threaded and single-threaded Common Lisp
    programming environments.
  
  
    A generic API is proposed for asynchronous dispatch onto multiple
    applications in single-threaded Common Lisp programming environments,
    such that might serve - in some limited way - as to resemble an
    application data flow for multi-threaded   applications.
  
    In this regard, an APPLICATION-CONTROLLER is developed, such that the
    implementation of the APPLICATION-CONTROLLER will differ as per
    whether the Common Lisp implementation is assumed to provide, or
    assumed to not provide an API for multi-threaded applications.
  
  
    It is assumed that any API for multi-threaded applications may be
    provided in a manner generally resembling POSIX threads.
  
  
  --
  
    In a broad manner, the programming pattern - developed below - defines
    a separation between the Common Lisp runtime image and individual
    tasks, such that may be comprised of simultaneous threads or
    asynchronous call structures in, respectively, a multi-threaded or
    single-threaded programming environment.
  
  --
  
    This API extends the SINGLETON MOP extension -- as developed in the
    Thinkum Labs Lisp Tools Project (LTP) -- extending the SINGLETON
    pattern as to define a generic enumerated type, in a manner such that
    any members of the enumerated type, or the enumerated type itself, may
    be used for principally static dispatching in Common Lisp method
    definitions.
  
    The macro DEFINE-SINGLETON-ENUM .... [TBD: Documentation]
  
  --
  
    The macro CONTROLLER-MAIN provides a generic, pseudocode-like example
    of a top-level function for an APPLICATION-CONTROLLER. The source code
    of this macro, as such, may be subject to change in subsequent
    revisions of this soruce file.
  
  |#
  
  (in-package #:ltp/common)
  
  (defpackage #:ltp/dobelle/app
    (:nicknames #:ltp.dobelle.app)
    (:use #:ltp/common/singleton
          #:ltp/common/mop
          #:ltp/common
          #:cl))
  