ichimal / cl-case-control

Case-controlling support package

Geek Repo:Geek Repo

Github PK Tool:Github PK Tool


This package supports case-controlling in both "starndard" case-insensitive environment and "extended" case-sensitive environment.

Note that the ANSI Common Lisp is a case-sensitive language about symbol names.

(intern "AbC") ; => |AbC|
(symbol-name '|AbC|) ; => "AbC"

The term "case-insensitive" here is not for those "barrier" symbols but for "non-barrier" symbols on some extended CL implementations s.t. GNU CLISP.

(in-package :cs-common-lisp-user)
(intern "Abc") ; => Abc
(symbol-name 'Abc) ; => "Abc"
(in-package :common-lisp-user)
(symbol-name 'Abc) ; => "ABC"
(symbol-name 'ABC) ; => "ABC"

Those differences between standard "case-insensitive" mode and extended "case-sensitive" modes cause some troubles at coding.

This package is a helper for solving such problems.


general-purpose predicates:

  • [Function] string-designator-p

    Returns true if given object is a string designator, otherwise, returns false.

  • [Function] lowercase-char-p and uppercase-char-p

    Returns true if given character is a lowercase (uppercase), otherwise, returns false.

    If the given object is not a character, these predicates signal an type error.

general-purpose converters:

  • [Function] char-invertcase

    Returns case inverted character.

    If the given object is not a character, char-invertcase signals an type error.

  • [Function] string-invertcase

    Returns case inverted string.

    If the given object is not a string designator, string-invertcase signals an type error.

    Note: string-invertcase accepts not only string but also string designator, but applying string-invertcase to symbol is depricated because an intuitive result is not necessarily obtained.


      (string-invertcase "aBc") ; => "AbC"
      (string-invertcase #\a) ; => "A"
      (string-invertcase :|aBc|) ; => "AbC"
      (string-invertcase NIL) ; => "nil"
      (string-invertcase Nil) ; => "nil"
      (string-invertcase nil) ; => "nil"

    Especially on GNU CLISP environment;

      (in-package :common-lisp-user)
      (symbol-name 'Abc) ; => "ABC"
      (casectl:string-invertcase 'Abc) ; => "abc"
      (in-package :cs-common-lisp-user)
      (symbol-name 'Abc) ; => "Abc"
      (casectl:string-invertcase 'Abc) ; => "Abc"
      (symbol-name :Abc) ; => "abc"
      (casectl:string-invertcase :Abc) ; => "abc"

    (casectl:char-invertcase and casectl:string-invertcase are just synonyms of exported functions of EXT package of CLISP, respectively.

    For CLISP's case sensitiveness, see CLISP Implementation Notes 11.5. Package Case-Sensitivity)

predicates for system/package case sensitiveness:

  • [Function] case-sensitive-p

    Returns true if the system (compiler and/or interpreter) supports case-sensitiveness, otherwise, returns false.

  • [Function] case-sensitive-package-p

    Returns true if the given package supports case-sensitiveness, otherwise, returns false.

    Current *package* is used when an package parameter is ommited.

utilities to unify codes in both case-sensitive environment and case-insensitive environment:

  • [Function] adj-case

    Adjust string case. This function is a helper for making intern parameter.


      (in-package :a-case-insensitive-package)
      (setf (symbol-value (intern (adj-case "Foo"))) 1)
      (in-package :a-case-sensitive-package)
      (setf (symbol-value (intern (adj-case "Foo"))) 2)
      (in-package :another-package)
      ;; Is the :another-package case-sensitive or not?
      ;; No problem. Everything's fine.
      (list a-case-insensitive-package::Foo
            a-case-sensitive-package::Foo )
      ; => (1 2)

    adj-case can also spcify a package explicitly.

      (adj-case "Foo" :a-case-insensitive-package) ; => "FOO"
      (adj-case "Foo" :a-case-sensitive-package) ; => "Foo"

    WARNING: on GNU CLISP, specifying package explicitly in both adj-case and intern may cause error because of incomaptibility between cl:intern and cs-cl:intern.

      (in-package :a-case-insensitive-package)
      ;; no problem
      (intern (adj-case "Foo" :another-case-insensitive-package)
              :another-case-insensitive-package )
      ;; maybe a bug
      (in-package :a-case-sensitive-package)
      (intern (adj-case "Bar" :a-case-insensitive-package)
              :a-case-insensitive-package )
      ; => a-case-insensitive-package::|bar|
  • [Function] case-selective-intern

    A intern wrapper.

    e.g. (case-selective-intern "Foo")

    And also, you can specify intern-package optionally.

  • [Macro] case-selective-defpackage

    A defpackage wrapper.


      (case-selective-defpackage :package-name
        (and (case-sensitive-p)
             (would-you-want-to-make-case-sensitive-package-p) )
        (:nicknames ...)
        ... )


  • removed string-designator definition; use trivial-types package, instead.


Under MIT license.


Case-controlling support package

License:MIT License


Language:Common Lisp 100.0%