Prolog.NET.Model 0.1.0

Prolog.NET.Model

Schema-first DSL for constructing typed Prolog databases in C#. Declare functor and relation shapes using attributes on partial records; the companion source generator emits strongly-typed factory methods at compile time; PrologSerializer converts the result to .pl source.

Generator

Prolog.NET.Model is designed to be used with Prolog.NET.Model.Generator, a Roslyn incremental analyzer that must be referenced alongside this package:

<ProjectReference Include="..\Prolog.NET.Model.Generator\Prolog.NET.Model.Generator.csproj"
                  OutputItemType="Analyzer"
                  ReferenceOutputAssembly="false" />

If a decorated type is not declared partial, the generator emits diagnostic PNET001 (error). Set <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles> in your .csproj to inspect generated files under obj/<Configuration>/<TFM>/generated/.

Usage

Declaring Relations

A relation type is a partial record decorated with PrologRelationName and one or more PrologRelation<T…> attributes. Place it inside a static partial class to group related declarations:

public static partial class PersonModule
{
    [PrologModule("person")]
    [PrologRelationName("person")]
    [PrologRelation<Name>]
    public partial record Person : IRelation;
}

• [PrologModule("person")] — assigns the type to a Prolog module; generated Query() calls include the module:functor(…) qualifier automatically.
• [PrologRelationName("person")] — sets the Prolog functor name.
• [PrologRelation<T…>] — one attribute per arity; the number of type parameters determines how many arguments Fact(…) and Query(…) accept.

Use PrologArgument as the wildcard type for each position (a marker type; never instantiated). Multiple PrologRelation attributes on the same type register multiple arities.

Declaring Functors

A functor type is a partial record decorated with PrologFunctor<T…>:

[PrologFunctor<PrologArgument, PrologArgument>("name")]
public partial record Name : IFunctor;

The generator emits Name.Of(PrologTerm, PrologTerm) returning a PrologCompound. For example:

Name.Of(PrologDSL.Atom.Create("alice"), PrologDSL.Atom.Create("smith"))
// → PrologCompound("name", […])  →  name(alice, smith)

A type can carry both relation and functor attributes simultaneously, letting it act as both a top-level relation and a reusable compound term:

[PrologModule("addresses")]
[PrologRelationName("address")]
[PrologRelation<PrologArgument, PrologArgument, PrologArgument>]
[PrologFunctor<PrologArgument, PrologArgument, PrologArgument>("address")]
public partial record Address : IRelation, IFunctor;

Generated Methods Summary

Three-Module Example

Declarations for three related modules:

public static partial class PersonModule
{
    // 'name' compound: used inside person facts as name(first, last)
    [PrologFunctor<PrologArgument, PrologArgument>("name")]
    public partial record Name : IFunctor;

    [PrologModule("person")]
    [PrologRelationName("person")]
    [PrologRelation<Name>]
    public partial record Person : IRelation;
}

public static partial class AddressesModule
{
    // 'address' is both a top-level relation and a reusable compound term
    [PrologModule("addresses")]
    [PrologRelationName("address")]
    [PrologRelation<PrologArgument, PrologArgument, PrologArgument>]    // address(street, number, city)
    [PrologFunctor<PrologArgument, PrologArgument, PrologArgument>("address")]
    public partial record Address : IRelation, IFunctor;
}

public static partial class ResidentsModule
{
    [PrologModule("residents")]
    [PrologRelationName("resident")]
    [PrologRelation<Name, Address>]
    public partial record Resident : IRelation;

    [PrologModule("residents")]
    [PrologRelationName("live_together")]
    [PrologRelation<Name, Name>]
    public partial record LiveTogether : IRelation;
}

Building the databases:

var alice       = PrologDSL.Atom.Create("alice");
var smith       = PrologDSL.Atom.Create("smith");
var bob         = PrologDSL.Atom.Create("bob");
var jones       = PrologDSL.Atom.Create("jones");
var elm         = PrologDSL.Atom.Create("elm");
var springfield = PrologDSL.Atom.Create("springfield");
var n42         = PrologDSL.Atom.CreateInt(42);

PrologModule person = PrologDSL.Module.Create("person", [
    PersonModule.Person.Fact(PersonModule.Name.Of(alice, smith)),   // person(name(alice, smith)).
    PersonModule.Person.Fact(PersonModule.Name.Of(bob, jones)),     // person(name(bob, jones)).
]);

PrologModule addresses = PrologDSL.Module.Create("addresses", [
    AddressesModule.Address.Fact(elm, n42, springfield),            // address(elm, 42, springfield).
]);

PrologModule residents = PrologDSL.Module.Create("residents", [
    // resident(name(alice, smith), address(elm, 42, springfield)).
    ResidentsModule.Resident.Fact(
        PersonModule.Name.Of(alice, smith),
        AddressesModule.Address.Of(elm, n42, springfield)),
    // resident(name(bob, jones), address(elm, 42, springfield)).
    ResidentsModule.Resident.Fact(
        PersonModule.Name.Of(bob, jones),
        AddressesModule.Address.Of(elm, n42, springfield)),
    // live_together(P1, P2) :-
    //     person:person(P1), person:person(P2),
    //     resident(P1, A), resident(P2, A).
    ResidentsModule.LiveTogether.Rule()
        .AddDefinition(rule => rule
            .Variables("P1", "P2", "A", (p1, p2, a, r) => r
                .Arguments(p1, p2)
                .Body(PersonModule.Person.Query(p1)              // person:person(P1)
                    .And(PersonModule.Person.Query(p2))          // person:person(P2)
                    .And(ResidentsModule.Resident.Query(p1, a))  // resident(P1, A)
                    .And(ResidentsModule.Resident.Query(p2, a))))),
]);

Serializing

string personSource    = PrologSerializer.Serialize(person);
string addressSource   = PrologSerializer.Serialize(addresses);
string residentsSource = PrologSerializer.Serialize(residents);

use_module directives are emitted automatically for any cross-module calls detected in rule bodies. For example, residentsSource produces:

:- module(residents, [resident/2, live_together/2]).

:- use_module(person).

resident(name(alice, smith), address(elm, 42, springfield)).
resident(name(bob, jones), address(elm, 42, springfield)).
live_together(P1, P2) :-
    person:person(P1),
    person:person(P2),
    resident(P1, A),
    resident(P2, A).

Tests

End-to-end serialization tests for this package live in tests/Prolog.NET.Model.Tests/. The ReadmeTests class builds the three-module example from this README and asserts the exact serialized output for each module.

Appendix: Type Reference

DSL Entry Point

Database Types

Term Types

Body Goal Types

Goals support .And() and .Or() builder methods.

Attributes

Development Notes

This package was developed with the assistance of AI coding tools (Claude Code), under the supervision of the author. All design decisions, architecture choices, and code reviews were made by the author.