use super::{Error, INVALID_PROOF};
use crate::linear::Mode;
use crate::linear::nets::{MellStructure, NetError, ProofStructure};
use crate::linear::occurrences::instances::Framing;
use crate::linear::occurrences::{Forest, Instances, Member, OccId, Reading, ShapeError};
use crate::linear::proofs::{CheckError, Derivation, Proof};
use crate::linear::sequents::notation::TEXT;
use std::fmt::{self, Display, Formatter, Write};
pub(crate) type Limit = Option<usize>;
pub(crate) struct Budget<'a, W: Write + ?Sized> {
pub(crate) f: &'a mut W,
pub(crate) left: usize,
pub(crate) cut: bool,
}
impl<'a, W: Write + ?Sized> Budget<'a, W> {
pub(crate) fn new(f: &'a mut W, limit: Limit) -> Self {
Self {
f,
left: limit.unwrap_or(usize::MAX),
cut: false,
}
}
}
impl<W: Write + ?Sized> Write for Budget<'_, W> {
fn write_str(&mut self, s: &str) -> fmt::Result {
let n = s.chars().count();
if n <= self.left {
self.left -= n;
return self.f.write_str(s);
}
let head: String = s.chars().take(self.left).collect();
self.f.write_str(&head)?;
(self.left, self.cut) = (0, true);
Err(fmt::Error)
}
}
#[derive(Clone, Copy)]
pub(crate) struct Names<'a> {
pub(crate) forest: &'a Forest,
pub(crate) reading: Option<&'a Reading<'a>>,
pub(crate) framing: Option<&'a Framing<'a>>,
}
pub(crate) const TERM: usize = 1 << 12;
pub(crate) fn occurrence(
f: &mut (impl Write + ?Sized),
names: Option<Names<'_>>,
o: Member,
) -> fmt::Result {
match names {
Some(Names {
forest,
reading,
framing: Some(framing),
}) if o.index() >= forest.len() => {
let mut text = String::new();
TEXT.instance(&mut text, forest, reading, framing, o, Some(TERM))?;
f.write_str(&text)
}
Some(Names { forest, .. }) if o.index() >= forest.len() => write!(f, "#{}", o.get()),
Some(Names {
reading: Some(reading),
..
}) => write!(f, "{}", reading.formula(o.occ())),
Some(Names { forest, .. }) => write!(f, "{}", forest.formula(o.occ())),
None => write!(f, "{}", o.get()),
}
}
pub(crate) fn cut(
f: &mut (impl Write + ?Sized),
names: Option<Names<'_>>,
o: Member,
limit: Limit,
) -> fmt::Result {
let mut budget = Budget::new(f, limit);
match occurrence(&mut budget, names, o) {
Err(_) if budget.cut => budget.f.write_char('…'),
written => written,
}
}
pub trait Owner: crate::sealed::Owner {
fn forest(&self) -> &Forest;
}
impl crate::sealed::Owner for Forest {}
impl Owner for Forest {
fn forest(&self) -> &Forest {
self
}
}
impl crate::sealed::Owner for Proof {
fn mode(&self) -> Option<Mode> {
Proof::mode(self)
}
fn instances(&self) -> Option<&Instances> {
Proof::instances(self)
}
}
impl Owner for Proof {
fn forest(&self) -> &Forest {
Proof::forest(self)
}
}
impl crate::sealed::Owner for Derivation<'_> {
fn mode(&self) -> Option<Mode> {
self.reading().map(|reading| {
if reading.is_ordered() {
Mode::LAMBEK
} else {
Mode::INTUITIONISTIC
}
})
}
}
impl Owner for Derivation<'_> {
fn forest(&self) -> &Forest {
Derivation::forest(self)
}
}
impl crate::sealed::Owner for ProofStructure {}
impl crate::sealed::Owner for MellStructure {
fn vertices(&self) -> Option<&[OccId]> {
Some(self.occurrences())
}
}
impl Owner for MellStructure {
fn forest(&self) -> &Forest {
MellStructure::forest(self)
}
}
impl Owner for ProofStructure {
fn forest(&self) -> &Forest {
ProofStructure::forest(self)
}
}
#[cfg(feature = "interactive")]
impl crate::sealed::Owner for crate::linear::Interactive {
fn mode(&self) -> Option<Mode> {
Some(crate::linear::Interactive::mode(self))
}
}
#[cfg(feature = "interactive")]
impl Owner for crate::linear::Interactive {
fn forest(&self) -> &Forest {
crate::linear::Interactive::forest(self)
}
}
#[derive(Clone, Copy, Debug)]
pub(crate) enum Subject<'a> {
Error(&'a Error),
Check(&'a CheckError),
Net(&'a NetError),
Shape(&'a ShapeError),
}
#[derive(Clone, Copy, Debug)]
pub struct Described<'a> {
error: Subject<'a>,
forest: &'a Forest,
vertices: Option<&'a [OccId]>,
limit: Option<usize>,
mode: Option<Mode>,
instances: Option<&'a Instances>,
}
impl<'a> Described<'a> {
pub(crate) fn new(error: Subject<'a>, owner: &'a impl Owner) -> Self {
Self {
error,
forest: owner.forest(),
vertices: owner.vertices(),
limit: None,
mode: owner.mode(),
instances: owner.instances(),
}
}
#[must_use]
pub const fn abbreviated(self, limit: Option<usize>) -> Self {
Self { limit, ..self }
}
#[must_use]
pub const fn in_mode(self, mode: Mode) -> Self {
Self {
mode: Some(mode),
..self
}
}
}
impl Display for Described<'_> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
let reading = self
.mode
.filter(|mode| mode.is_intuitionistic())
.and_then(|mode| Reading::of_mode(self.forest, mode.with_empty_antecedents()).ok());
let framing = self
.instances
.map(|table| Framing::new(&self.forest.sequent().fo, table));
let forest = Some(Names {
forest: self.forest,
reading: reading.as_ref(),
framing: framing.as_ref(),
});
match self.error {
Subject::Error(Error::Net(e)) => {
f.write_str("not a proof net: ")?;
e.write_over(f, forest, self.vertices, self.limit)
}
Subject::Net(e) => e.write_over(f, forest, self.vertices, self.limit),
Subject::Error(e) => e.write(f, forest, self.limit),
Subject::Check(e) => e.write(f, forest, self.limit),
Subject::Shape(e) => e.write(f, forest, self.limit),
}
}
}
#[cfg(feature = "serialize")]
impl serde::Serialize for Described<'_> {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let owned;
let error = match self.error {
Subject::Error(e) => e,
Subject::Check(e) => {
owned = Error::Check(e.clone());
&owned
}
Subject::Net(e) => {
owned = Error::Net(Box::new(e.clone()));
&owned
}
Subject::Shape(e) => {
owned = Error::NotIntuitionistic(e.clone());
&owned
}
};
crate::serialize::envelope(error, &self.to_string(), serializer)
}
}
impl Error {
pub fn describe<'a>(&'a self, owner: &'a impl Owner) -> Described<'a> {
Described::new(Subject::Error(self), owner)
}
pub(crate) fn write(
&self,
f: &mut Formatter<'_>,
names: Option<Names<'_>>,
limit: Option<usize>,
) -> fmt::Result {
if names.is_none() {
return Display::fmt(self, f);
}
match self {
Self::Check(e) => {
if let CheckError::Invalid(_) = e {
f.write_str(INVALID_PROOF)?;
}
e.write(f, names, limit)
}
Self::Rejected(e) => {
f.write_str(REJECTED)?;
e.write(f, names, limit)
}
Self::Net(e) => {
f.write_str("not a proof net: ")?;
e.write(f, names, limit)
}
Self::NotIntuitionistic(e) => {
f.write_str("not an intuitionistic sequent: ")?;
e.write(f, names, limit)
}
_ => Display::fmt(self, f),
}
}
}
pub(super) const REJECTED: &str = "the proof the search found does not pass the checker, which \
is a defect of the engine and no verdict on the sequent: ";