Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.0

0.6.0 / src / logic / atoms.lucb

## Structured predicate atoms and ordered constant/variable arguments.
import interop
import memory
from storage import Buffer, List, Reader, text_copy
from model import DocumentData
from animation import resolve_property
from query.scalars import numeric
from types import DType, invalid

pub enum RuleKind as u8:
    strict = 0
    defeasible = 1
    defeater = 2

pub enum ProofTag as u8:
    definite_proof = 0
    definite_refute = 1
    defeasible_proof = 2
    defeasible_refute = 3

pub struct Term:
    pub var name: Buffer
    pub var variable: bool

    pub func close():
        self.name.close()

pub struct AtomData:
    pub var predicate: Buffer
    pub var negative: bool
    pub var arguments: List[Term]

    pub func copy() -> AtomData!:
        var result = AtomData(negative = self.negative)
        errdefer result.close()
        result.predicate = try self.predicate.copy()
        for term in self.arguments.span():
            try result.append(term.name.view(), term.variable)
        return result

    pub func append(name: str, variable: bool) -> !:
        var term = Term(variable = variable)
        errdefer term.close()
        term.name = try text_copy(name)
        try self.arguments.push(term)

    pub func key() -> Buffer!:
        var result: Buffer
        errdefer result.close()
        if self.negative:
            try result.byte('-')
        try result.text(self.predicate.view())
        try result.byte('(')
        for i in 0..<self.arguments.count:
            if i > 0:
                try result.byte(',')
            try result.text(self.arguments.items[i].name.view())
        try result.byte(')')
        return result

    pub func close():
        self.predicate.close()
        for i in 0..<self.arguments.count:
            self.arguments.items[i].close()
        self.arguments.close()

pub struct Atom:
    var data: AtomData

    pub func init(predicate: str, negative: bool = false) -> !:
        self.data = AtomData(negative = negative)
        self.data.predicate = try text_copy(predicate)

    pub func view_data() -> const AtomData*:
        return &self.data

    pub func predicate() -> str:
        return self.data.predicate.view()

    pub func negative() -> bool:
        return self.data.negative

    pub func constant(name: str) -> !:
        try self.data.append(name, false)

    pub func variable(name: str) -> !:
        try self.data.append(name, true)

    pub func count() -> usize:
        return self.data.arguments.count

    pub func argument(index: usize) -> str!:
        if index >= self.data.arguments.count:
            error(invalid, "Prism atom argument index is out of bounds")
        return self.data.arguments.items[index].name.view()

    pub func is_variable(index: usize) -> bool!:
        if index >= self.data.arguments.count:
            error(invalid, "Prism atom argument index is out of bounds")
        return self.data.arguments.items[index].variable

    pub func close():
        self.data.close()

pub let atom_type = interop.Type[Atom]("Prism atom", Atom.close, closeable = true)

pub struct Atoms:
    var atoms: List[AtomData]

    pub func init():
        return

    pub func view_data() -> const List[AtomData]*:
        return &self.atoms

    pub func append(atom: interop.Reference[Atom]) -> !:
        var owned = try (try atom.get()).view_data().copy()
        errdefer owned.close()
        try self.atoms.push(owned)

    pub func count() -> usize:
        return self.atoms.count

    pub func close():
        for i in 0..<self.atoms.count:
            self.atoms.items[i].close()
        self.atoms.close()

pub let atoms_type = interop.Type[Atoms]("Prism atoms", Atoms.close, closeable = true)

pub func read_text(doc: const DocumentData*, path: str, name: str) -> Buffer!:
    let index = doc.find(path) else return Buffer()
    let element = &doc.elements.items[index]
    let position = element.property(name) else return Buffer()
    var value = try resolve_property(&element.properties.items[position], 0.0)
    defer value.close()
    if value.kind != DType.string or value.count() == 0:
        return Buffer()
    var reader = Reader(data = value.payload.bytes())
    return try text_copy(try reader.text())

pub func read_negative(doc: const DocumentData*, path: str) -> bool!:
    let index = doc.find(path) else return false
    let element = &doc.elements.items[index]
    let position = element.property("neg") else return false
    var value = try resolve_property(&element.properties.items[position], 0.0)
    defer value.close()
    return (f32)(numeric(&value) else 0.0) != 0.0

pub func read_atom(doc: const DocumentData*, path: str) -> AtomData!:
    var atom: AtomData
    errdefer atom.close()
    atom.predicate = try read_text(doc, path, "pred")
    atom.negative = try read_negative(doc, path)
    for i in 0..<doc.child_count(path):
        let child = doc.child_at(path, i) else error(invalid, "invalid Prism atom child index")
        var name = try read_text(doc, child, "name")
        defer name.close()
        try atom.append(name.view(), try doc.type_at(child) == "var")
    return atom