Struct arithmetic_typing::Slice

pub struct Slice<Prim: PrimitiveType = Num> { /* private fields */ }

Slice type. Unlike in Rust, slices are a subset of tuples. If length is exact (has no UnknownLen part), the slice is completely equivalent to the corresponding tuple.

Notation

A slice is denoted as [T; N] where T is the slice element and N is the slice length. A special case is [T], a slice with a dynamic length.

Examples

use arithmetic_parser::grammars::{F32Grammar, Parse};
use arithmetic_typing::{Annotated, TupleLen, TypeEnvironment, Type};

type Parser = Annotated<F32Grammar>;
let ast = Parser::parse_statements("xs: [Num; _] = (1, 2, 3);")?;
let mut env = TypeEnvironment::new();
env.process_statements(&ast)?;
// Slices with fixed length are equivalent to tuples.
assert_eq!(env["xs"].to_string(), "(Num, Num, Num)");

let code = "
    xs: [Num] = (1, 2, 3);
    ys = xs + 1; // works fine: despite `xs` having unknown length,
                 // it's always possible to add a number to it
    (_, _, z) = xs; // does not work: the tuple length is erased
";
let ast = Parser::parse_statements(code)?;
let errors = env.process_statements(&ast).unwrap_err();

let err = errors.iter().next().unwrap();
assert_eq!(err.main_location().span(code), "(_, _, z)");
assert_eq!(env["ys"], env["xs"]);

Implementations

impl<Prim: PrimitiveType> Slice<Prim>

pub fn new(element: Type<Prim>, length: impl Into<TupleLen>) -> Self

Creates a new slice.

pub fn element(&self) -> &Type<Prim>

Returns the element type of this slice.

pub fn len(&self) -> TupleLen

Returns the length of this slice.

pub fn is_empty(&self) -> bool

Returns true iff this slice is definitely empty.

Trait Implementations

impl<Prim: Clone + PrimitiveType> Clone for Slice<Prim>

fn clone(&self) -> Slice<Prim>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Prim: Debug + PrimitiveType> Debug for Slice<Prim>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Prim: PrimitiveType> Display for Slice<Prim>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Prim: PrimitiveType> From<Slice<Prim>> for Tuple<Prim>

fn from(slice: Slice<Prim>) -> Self

Converts to this type from the input type.

impl<Prim: PrimitiveType> From<Slice<Prim>> for Type<Prim>

fn from(slice: Slice<Prim>) -> Self

Converts to this type from the input type.

impl<Prim: PartialEq + PrimitiveType> PartialEq<Slice<Prim>> for Slice<Prim>

fn eq(&self, other: &Slice<Prim>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Prim: PrimitiveType> StructuralPartialEq for Slice<Prim>