anchor.diff:                    value)))
            ,(if (and class tag)
                 `(decode-tagged-type stream #'dec)
  -              `(dec stream))))))
  +              `(dec stream))))
  +     ',name))
   
   
   ;; -----------------------------------
  
positive.code: ;;;; Copyright (c) Frank James 2015 <frank.a.james@gmail.com>
  ;;;; This code is licensed under the MIT license.
  
  (in-package #:asinine)
  
negative.code: ;; (defun (setf object-data)    (new-value object))
  ;;
  ;;
  ;; In general, we don't know for a given type a (valid) prototype
  ;; value.  Therefore we cannot initialize a structure with default
  ;; values: we have to let the slots initialized to NIL.  And we
  ;; don't have a map of ASN.1 types to lisp types, so we cannot type
  ;; the slots either.
  ;;
  ;; So:
  ;; -->
  ;; (defstruct object
  ;;   %alternative
  ;;   %value)
  ;;
  ;; Regarding the encoding/decoding of CHOICE:
  ;;
  ;; * CHOICE with explicit tags generates contextual tag prefixes before
  ;;   the actual alternative data:
  ;;
  ;;     BSX { bsx(31337) } DEFINITIONS ::= BEGIN
  ;;     BsxPDU ::= SEQUENCE {
  ;;         version INTEGER(0..127),
  ;;         object BsxObject
  ;;     }
  ;;     BsxCons ::= SEQUENCE {
  ;;         head BsxObject,
  ;;         tail BsxObject
  ;;     }
  ;;     BsxObject ::= CHOICE {
  ;;         null      [0] NULL,
  ;;         primitive [1] OCTET STRING,
  ;;         cons      [2] BsxCons
  ;;     }
  ;;     END
  ;;
  ;;     (0 :-> bsx-object null null)
  ;;     (1 :-> bsx-object primitive :octet-string)
  ;;     (2 :-> bsx-object cons bsx-cons)
  ;;     30 1D 02 01 01 A2 18 30 16 A1 05 04 03 01 02 03 A2 0D 30 0B A1 05 04 03 04 05 06 A0 02 05 00
  ;;
  ;;
  ;; * CHOICE with implicit tags requires that each alternative has a
  ;;   distinct tag.  For this we need to keep all the type definitions
  ;;   specified (*TYPE* hashtable), so we may retrieve them and use their
  ;;   specific tags.  In this case, the alternatives can be generated in
  ;;   place of the CHOICE without overhead.
  ;;
  ;;     BSX { bsx(31337) } DEFINITIONS ::= BEGIN
  ;;     BsxPDU ::= SEQUENCE {
  ;;         version INTEGER(0..127),
  ;;         object BsxObject
  ;;     }
  ;;     BsxCons ::= SEQUENCE {
  ;;         head BsxObject,
  ;;         tail BsxObject
  ;;     }
  ;;     BsxObject ::= CHOICE {
  ;;         null       NULL,
  ;;         primitive  OCTET STRING,
  ;;         cons       BsxCons
  ;;     }
  ;;     END
  ;;
  ;;     (5 :-> bsx-object null null)
  ;;     (4 :-> bsx-object primitive :octet-string)
  ;;     (16 :-> bsx-object cons bsx-cons)
  ;;     30 13 02 01 01 30 0E 04 03 01 02 03 30 07 04 03 04 05 06 05 00
  
  
  (defun valid-alternatives-p (alternatives)
  