Implement Base Functionality

[nylvon]

Interfaces

An interface should:

1. Be zero-cost.
2. Be able to generate types based off of them.
3. Be able to "combine" with other interfaces in various ways.
4. Be able to be derived from types.
5. Be able to check if types implement them at compile time.
6. Be able to "grant" types a checkmark that lets other types know what interfaces this type implements without having to re-check.

Proposed example usage

1. Creating interfaces

// A simple reader interface
const IReader = Interface.init([_]Field {
		Interface.Field("buffer", []u8),
		Interface.Declaration("read_fn", [_]type {[]u8, []u8}, []u8)
	});

// "grant" returns the type defined below at compile-time with a special declaration that contains a list of interfaces that it has been checked against and passed the checks for. If any of them fail, compilation fails and an error message is shown detailing why the type does not implement any of the interfaces mentioned.
const custom_reader_type = Interface.Grant([1]Interface{IReader},
	.{
		buffer: []u8,

		pub fn custom_read_fn(path: []u8, options: []u8) []u8 {
			// ...
		}
	});

2. Type merging, type generation, type granting, and interface merging.

// Naive type-merging
const writer_type = struct { ... };
const reader_type = struct { ... };

// Obtain a writer and reader combined type
const writer_reader_type = Interface.AsType([_]type {writer_type, reader_type});

// Safe type-merging
const safe_writer_type = Interface.Grant([1]Interface{IWriter}, .{ ... });
const safe_reader_type = Interface.Grant([1]Interface{IReader}, .{ ... });

// Merged type
const safe_writer_reader_type = Interface.AsType([_]type {safe_writer_type, safe_reader_type});
const safe_writer_reader_interface = Interface.Merge([_]Interface{IReader, IWriter});
const safe_writer_reader_type_from_interface = Interface.AsType([_]Interface {safe_writer_reader_interface});

// These should be identical.
try std.testing.expectEqual(safe_writer_reader_type == safe_writer_reader_type_from_interface);

Related:

• Implement FindInType with tests. #2
• Implement rules for types. #5
• Add more functionality for rule-set creation. #6
• Interface granting (Generating types)
• Interface merging and combining
• Type generation from interfaces
• Type merging (Generation from multiple types)
• Interface generation from types (Extraction)
• Check that they're truly zero-cost

[nylvon]

The Rule type implementation has started with 4d37494.

[nylvon]

A new syntax is here, and is more fluent than the one initially proposed.
See the last comment on #5 for more details.

Here's an example (from #5) how it looks right now:

const IsVec3Simple =
    Blank()
        .And(IsInType(FindField("x")))
        .And(IsInType(FindField("y")))
        .And(IsInType(FindField("z")));

const IsVec3Alternative =
    Blank()
        .And(IsInType(FindField("buffer")));

const IsVec3Full =
    Blank()
        .Or(IsVec3Simple)
        .Or(IsVec3Alternative);

const IsVec3Accessors =
    Blank()
        .And(IsFunction(FindDeclaration("get_X")))
        .And(IsFunction(FindDeclaration("get_Y")))
        .And(IsFunction(FindDeclaration("get_Z")));

const IsVec3 = 
    Blank()
        .And(IsVec3Full)
        .And(IsVec3Accessors);

// ...

pub fn ComplexVec3Op(arg: anytype) !void {
    comptime try IsVec3.Check(arg);
    
    // ... do something with arg ...
    // ... knowing it's a vec3 ...

}