Introduce DummyRing, DummyCommutativeRing, and DummyField

CAP/PackageInfo.g

@@ -10,7 +10,7 @@ SetPackageInfo( rec(
 
 PackageName := "CAP",
 Subtitle := "Categories, Algorithms, Programming",
-Version := "2023.11-01",
+Version := "2023.11-02",
 Date := (function ( ) if IsBound( GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE ) then return GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE; else return Concatenation( ~.Version{[ 1 .. 4 ]}, "-", ~.Version{[ 6, 7 ]}, "-01" ); fi; end)( ),
 License := "GPL-2.0-or-later",
 

CAP/doc/Doc.autodoc

@@ -24,6 +24,6 @@
 
 @Chapter Create wrapper hulls of a category
 
-@Chapter Dummy categories
+@Chapter Dummy implementations
 
 @Chapter Examples and Tests

CAP/examples/DummyCategory.g

@@ -1,6 +1,8 @@
 #! @Chapter Examples and Tests
 
-#! @Section Dummy category
+#! @Section Dummy implementations
+
+#! @Subsection Dummy categories
 
 #! @Example
 

CAP/examples/dummy_rings.g

@@ -0,0 +1,37 @@
+#! @Chapter Examples and Tests
+
+#! @Section Dummy implementations
+
+#! @Subsection Dummy rings
+
+#! @Example
+
+LoadPackage( "CAP", false );
+#! true
+
+DummyRing( );
+#! Dummy ring 1
+DummyRing( );
+#! Dummy ring 2
+IsRing( DummyRing( ) );
+#! true
+
+DummyCommutativeRing( );
+#! Dummy commutative ring 1
+DummyCommutativeRing( );
+#! Dummy commutative ring 2
+IsRing( DummyCommutativeRing( ) );
+#! true
+IsCommutative( DummyCommutativeRing( ) );
+#! true
+
+DummyField( );
+#! Dummy field 1
+DummyField( );
+#! Dummy field 2
+IsRing( DummyField( ) );
+#! true
+IsField( DummyField( ) );
+#! true
+
+#! @EndExample

CAP/gap/DummyImplementations.gd

@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+# CAP: Categories, Algorithms, Programming
+#
+# Declarations
+#
+
+#! @Chapter Dummy implementations
+#! 
+#! A dummy implementation of a concept seems to provide an interface for the concept, but calling any operation in this interface will simply signal an error.
+#! Hence, when using a dummy implementation, we can be sure that we only rely on the abstract interface but not on any implementation details,
+#! for the simple reason that there is no actual implementation.
+#! This is useful for testing or compilation against a generic implementation of a concept.
+
+####################################
+#
+#! @Section Dummy rings
+#
+####################################
+
+####################################
+#
+# GAP filters
+#
+####################################
+
+#! @Description
+#!  The ⪆ filter of dummy rings.
+DeclareFilter( "IsDummyRing",
+        IsRingWithOne );
+
+#! @Description
+#!  The ⪆ filter of elements of a dummy ring.
+DeclareFilter( "IsDummyRingElement",
+        IsRingElementWithOne );
+
+#! @Description
+#!  The ⪆ filter of dummy commutative rings.
+DeclareFilter( "IsDummyCommutativeRing",
+        IsDummyRing );
+
+#! @Description
+#!  The ⪆ filter of elements of a dummy commutative ring.
+DeclareFilter( "IsDummyCommutativeRingElement",
+        IsDummyRingElement );
+
+#! @Description
+#!  The ⪆ filter of dummy fields.
+DeclareFilter( "IsDummyField",
+        IsDummyCommutativeRing );
+
+#! @Description
+#!  The ⪆ filter of elements of a dummy commutative ring.
+DeclareFilter( "IsDummyFieldElement",
+        IsDummyCommutativeRingElement );
+
+####################################
+#
+# Constructors
+#
+####################################
+
+#! @Description
+#! @Returns a dummy ring
+DeclareGlobalFunction( "DummyRing" );
+
+#! @Description
+#! @Returns a dummy commutative ring
+DeclareGlobalFunction( "DummyCommutativeRing" );
+
+#! @Description
+#! @Returns a dummy field
+DeclareGlobalFunction( "DummyField" );
+
+####################################
+#
+#! @Section Dummy categories
+#
+####################################
+
+####################################
+#
+# GAP categories
+#
+####################################
+
+#! @Description
+#!  The ⪆ category of a dummy CAP category.
+DeclareCategory( "IsDummyCategory",
+        IsCapCategory );
+
+#! @Description
+#!  The ⪆ category of objects in a dummy CAP category.
+DeclareCategory( "IsDummyCategoryObject",
+        IsCapCategoryObject );
+
+#! @Description
+#!  The ⪆ category of morphisms in a dummy CAP category.
+DeclareCategory( "IsDummyCategoryMorphism",
+        IsCapCategoryMorphism );
+
+####################################
+#
+# Constructors
+#
+####################################
+
+#! @Description
+#!  Creates a dummy category subject to the options given via <A>options</A>, which is a record passed on to <Ref Oper="CategoryConstructor" Label="for IsRecord" />.
+#!  Note that the options `{category,object,morphism}_filter` will be set to `IsDummyCategory{,Object,Morphism}` and the options `{object,morphism}_{constructor,datum}` and
+#!  `create_func_*` will be set to dummy implementations (throwing errors when actually called).
+#!  The dummy category will pretend to support empty limits by default.
+#! @Arguments options
+#! @Returns a category
+DeclareOperation( "DummyCategory",
+                  [ IsRecord ] );