💐 final pass, address lints and polish formatting

README.md

@@ -139,6 +139,22 @@ voice feels like, and why people do it.
 
 #### 🐣 j
 
+**🔁 main loop**
+
+above we looked at the Incunabulum's main event loop. here is j's equivalent entrypoint:
+
+```rust
+mod p;use{p::*,j::*,std::io::Write};
+fn main()->R<()>{let mut st=ST::default(); // define symbol table
+ let prompt =| |{print!(" ");std::io::stdout().flush()?;ok!()}; // (callback) print whitespace
+ let read =|_ |{let mut l=S::new();stdin().read_line(&mut l)?;Ok(l)}; // (callback) read input
+ let mut eval=|s:S|{eval(&s,&mut st)}; // (callback) read and evaluate once
+ let print =|a:A|{println!("{a}")}; // (callback) print array
+ loop{prompt().and_then(read).and_then(&mut eval)?.map(print);}; /* !!! main event loop !!! */ }
+```
+
+**🏃 verbs**
+
 the core of the four dyadic verbs `[`, `]`, `+`, and `*` is shown below. the definitions of the `A`
 array type and the `D` dyadic verb enum are included for reference.
 

src/a.rs

@@ -15,9 +15,9 @@ use super::*; use std::marker::PhantomData as PD;
  fn oob(&self,i:U,j:U)->R<()>{let A{m,n,..}=*self;
  if(i==0||j==0||i>m||j>n){bail!("({i},{j}) is out-of-bounds of ({m},{n})")}ok!()}
  /// returns the scalar `A_ij` within this array. returns an error if position is out-of-bounds.
- pub fn index(&self,i:U,j:U)->R<U> {self.oob(i,j)?;let A{m,n,..}=*self;let(i,j)=(i-1,j-1);Ok((i*n)+j)}
+ pub fn index(&self,i:U,j:U)->R<U> {self.oob(i,j)?;let(i,j)=(i-1,j-1);Ok((i*self.n)+j)}
  /// returns the scalar `A_ij` within this array. does not check if the position is in bounds.
- pub fn index_uc(&self,i:U,j:U)->R<U>{ let A{m,n,..}=*self;let(i,j)=(i-1,j-1);Ok((i*n)+j)}
+ pub fn index_uc(&self,i:U,j:U)->R<U>{ let(i,j)=(i-1,j-1);Ok((i*self.n)+j)}
  }
  // === test helpers ===
  /// `A::index` test case generator. check that indexing at a position returns the expected value.
@@ -27,17 +27,17 @@ use super::*; use std::marker::PhantomData as PD;
  #[macro_export] macro_rules! toob{($f:ident,$a:ident,$i:literal,$j:literal)=>
  {#[test] fn $f()->R<()>{is!($a()?.index($i,$j).is_err());ok!()}}}
  // === 1x1 array indexing ===
- fn sca()->R<A>{let Ok(a@A{m:1,n:1,..})=A::from_i(42)else{bail!("bad dims")};Ok(a)}
+ #[cfg(test)] fn sca()->R<A>{let Ok(a@A{m:1,n:1,..})=A::from_i(42)else{bail!("bad dims")};Ok(a)}
  toob!(i00_for_scalar,sca,0,0);toob!(i10_for_scalar,sca,1,0);toob!(i01_for_scalar,sca,0,1);
  toob!(i21_for_scalar,sca,2,1);toob!(i12_for_scalar,sca,1,2);toob!(i22_for_scalar,sca,2,2);
  ti!(i11_for_scalar,sca,1,1,0);
  // === 2x3 array indexing ===
- fn arr2x3()->R<A>{let Ok(a@A{m:2,n:3,..})=A::zeroed(2,3)else{bail!("bad dims")};Ok(a)}
+ #[cfg(test)] fn arr2x3()->R<A>{let Ok(a@A{m:2,n:3,..})=A::zeroed(2,3)else{bail!("bad dims")};Ok(a)}
  toob!(i00_for_2x3,arr2x3,0,0);toob!(i01_for_2x3,arr2x3,0,1);toob!(i10_for_2x3,arr2x3,1,0);
  ti!(i11_for_2x3,arr2x3,1,1,0);ti!(i12_for_2x3,arr2x3,1,2,1);ti!(i13_for_2x3,arr2x3,1,3,2);
  ti!(i21_for_2x3,arr2x3,2,1,3);ti!(i22_for_2x3,arr2x3,2,2,4);ti!(i23_for_2x3,arr2x3,2,3,5);
  // === 3x3 array indexing ===
- fn arr3x3()->R<A>{let Ok(a@A{m:3,n:3,..})=A::zeroed(3,3)else{bail!("bad dims")};Ok(a)}
+ #[cfg(test)] fn arr3x3()->R<A>{let Ok(a@A{m:3,n:3,..})=A::zeroed(3,3)else{bail!("bad dims")};Ok(a)}
  toob!(i00_for_3x3,arr3x3,0,0);toob!(i01_for_3x3,arr3x3,0,1);toob!(i14_for_3x3,arr3x3,1,4);
  toob!(i41_for_3x3,arr3x3,4,1);toob!(i44_for_3x3,arr3x3,4,4);
  ti!(i11_for_3x3,arr3x3,1,1,0);ti!(i21_for_3x3,arr3x3,2,1,3);ti!(i22_for_3x3,arr3x3,2,2,4);
@@ -111,8 +111,7 @@ use super::*; use std::marker::PhantomData as PD;
  impl A<MI>{ // only allow matrix access for initialized arrays
  pub fn into_matrix(&self)->R<Vec<&[I]>>{let(A{m,n,..})=*self;
  (0..m).map(|m|{self.ptr_at(m+1,1)}).map(|r|r.map(|d|unsafe{from_raw_parts(d as *mut I, n as U)})).collect()}}
- impl TF<&[&[I]]> for A{type Error=E;fn try_from(s:&[&[I]])->R<A>{todo!("TF<&[I]> for A")}}
- impl PE<&[&[I]]> for A{fn eq(&self,r:&&[&[I]])->bool{let(A{m,n,..})=self;
+ impl PE<&[&[I]]> for A{fn eq(&self,r:&&[&[I]])->bool{
  if(r.len()!=self.m){r!(false)}for(i,r_i)in(r.into_iter().enumerate()){
  if(r_i.len()!=self.n){r!(false)}for(j,r_ij)in(r_i.into_iter().enumerate()){
  let(i,j)=(i+1,j+1);let(a_ij)=match(self.get(i,j)){Ok(v)=>v,Err(_)=>r!(false)};
@@ -121,7 +120,7 @@ use super::*; use std::marker::PhantomData as PD;
 /**monadic verbs*/impl A{
  pub fn m_same(self)->R<A>{Ok(self)}
  pub fn m_idot(self)->R<A>{let(a@A{m,n,..})=self;let gi=|i,j|a.get(i,j)?.try_into().map_err(E::from);
- if let(1,1)=(m,n){let(m,n)=(1,gi(1,1)?);let(mut o)=A::new(1,n)?;
+ if let(1,1)=(m,n){let(n)=(gi(1,1)?);let(mut o)=A::new(1,n)?;
  for(j)in(1..=n){o.set(1,j,(j-1).try_into()?)?;}Ok(unsafe{o.finish()})}
  else if let(1,2)=(m,n){let(m,n)=(gi(1,1)?,gi(1,2)?);
  let(mut v)=0_u32;let(f)=move |_,_|{let(v_o)=v;v+=1;Ok(v_o)};A::new(m,n)?.init_with(f)}
@@ -136,9 +135,9 @@ use super::*; use std::marker::PhantomData as PD;
  /*return dyad function**/ pub fn f(&self)->fn(I,I)->I{use D::*;
  match(self){Plus=>D::add, Mul=>D::mul, Left=>D::left, Right=>D::right} }
  /*add two numbers*/fn add (x:I,y:I)->I{x+y} /*multiply two numbers*/fn mul (x:I,y:I)->I{x*y}
- /*left */fn left(x:I,y:I)->I{x } /*right */fn right(x:I,y:I)->I{ y}
+ /*left */fn left(x:I,_:I)->I{x } /*right */fn right(_:I,y:I)->I{ y}
 } impl A{
- pub fn d_left (self,r:A)->R<A>{Ok(self) }
+ pub fn d_left (self,_:A)->R<A>{Ok(self) }
  pub fn d_right(self,r:A)->R<A>{Ok(r) }
  pub fn d_plus(self,r:A) ->R<A>{A::d_do(self,r,D::add)}
  pub fn d_mul (self,r:A) ->R<A>{A::d_do(self,r,D::mul)}
@@ -171,7 +170,7 @@ use super::*; use std::marker::PhantomData as PD;
  // === monadic `/`, `Ym::Insert` tests
  macro_rules! test_insert{($f:ident,$d:expr,$a:expr,$o:expr)=>
  {#[test]fn $f()->R<()>{let(a):R<A>={$a};let(d):D={$d}; // typecheck macro arguments.
- let i:I=a.and_then(|a:A|Ym::insert($d,a)).and_then(|a|a.as_i())?;
+ let i:I=a.and_then(|a:A|Ym::insert(d,a)).and_then(|a|a.as_i())?;
  eq!(i,$o);ok!()}}}
  test_insert!(add_a_scalar, D::Plus, A::from_i(42), 42 );
  test_insert!(add_a_sequence, D::Plus, <A as TF<&[I]>>::try_from(&[1,2,3,4,5]), (1+2+3+4+5) );
@@ -188,15 +187,14 @@ use super::*; use std::marker::PhantomData as PD;
  let f=|i,j|->R<I>{let(x,y)=(l[i-1],r[j-1]);Ok(d(x,y))};
  A::new(m,n)?.init_with(f)}
  else {bail!("unexpected fallthrough in Yd::table")}}
- fn infix(d:D,l:A,r:A)->R<A>{let(s)=r.as_slice().map_err(|_|err!("infix rhs must be a slice"))?;
+ fn infix(_:D,l:A,r:A)->R<A>{let(s)=r.as_slice().map_err(|_|err!("infix rhs must be a slice"))?;
  let(il)=l.as_i() .map_err(|_|err!("infix lhs must be a scalar"))?.try_into()?;
  let(ic)=(s.len()-il)+1;
  A::new(ic,il)?.init_with(|i,j|Ok(s[(i-1)+(j-1)]))}}}
 
-/**deep-copy*/impl A<MI>{
- pub fn deep_copy(&self)->R<A>{let A{m,n,l:li,d:di,i:_}=*self;A::new(m,n)?.init_with(|i,j|{self.get(i,j)})}}
+/**deep-copy*/impl A<MI>{pub fn deep_copy(&self)->R<A>{A::new(self.m,self.n)?.init_with(|i,j|{self.get(i,j)})}}
 
 /**display*/mod fmt{use super::*;
  impl DS for A<MI>{
- fn fmt(&self,fmt:&mut FMT)->FR{let A{m,n,..}=*self;for(i,j)in(self.iter())
+ fn fmt(&self,fmt:&mut FMT)->FR{let A{n,..}=*self;for(i,j)in(self.iter())
  {let(x)=self.get_uc(i,j).map_err(|_|std::fmt::Error)?;write!(fmt,"{x}{}",if(j==n){'\n'}else{' '})?;}ok!()}}}

src/j.rs

@@ -1,7 +1,6 @@
-#![allow(dead_code,unused_variables,unreachable_code,unused_imports,unused_parens)]
-/**prelude*/mod p;use p::*;#[cfg(test)]use p::tp::*;
-/**array*/mod a; /**read input*/mod r; /**symbol table*/mod s;
-pub use self::{a::*,r::*,s::*};
+#![allow(unused_parens)] /**prelude*/mod p;use p::*; /*test prelude*/#[cfg(test)]use p::tp::*;
+ /**symbol table*/mod s; /**array*/ mod a; /**lex/parse input*/mod r;use r::*;
+pub use self::{a::*,s::*};
 pub fn eval(input:&str,st:&mut ST)->R<O<A>>{
  let(mut ts)=lex(input)?;let(ast)=match(parse(&mut ts)?){Some(x)=>x,None=>rrn!()};eval_(ast,st)}
 fn eval_(ast:B<N>,st:&mut ST)->R<O<A>>{use{M::*,D::*};

src/p.rs

@@ -1,4 +1,4 @@
-//! prelude; shorthand aliases for common types and traits, macros for common patterns.
+#![allow(unused_imports)] //! prelude; shorthand aliases for common types and traits, macros for common patterns.
 pub(crate)use{Box as B,char as C,u32 as I,usize as U,Option as O,String as S,TryFrom as TF,TryInto as TI,Vec as V};
 pub(crate)use{std::{alloc::Layout as L,clone::Clone as CL,cmp::{PartialEq as PE,PartialOrd as PO},
  collections::{BTreeMap as BM,VecDeque as VD},fmt::{Debug as DBG,Display as DS,Formatter as FMT,Result as FR},

src/r.rs

@@ -4,8 +4,7 @@ mod lex{use crate::*;
  /*assignment*/ E ,
  /* NB: this does not identify whether possible verbs */ /*(ad)verb*/ V(S) ,
  /* are monadic or dyadic. that is done during parsing.*/ /*symbol*/ SY(SY) }
- impl T{pub(super) fn is_noun(&self)->bool{use T::*;matches!(self,A(_)|SY(_))}}
- pub(crate) fn lex(input:&str)->R<V<T>>{use std::ops::Deref;
+ pub(crate) fn lex(input:&str)->R<V<T>>{
  let(mut ts)=input.split_whitespace().peekable(); let(mut o)=V::with_capacity(ts.size_hint().0);
  while let Some(t) =ts.next(){
  if t == "=:" {o.push(T::E)} // assignment
@@ -16,7 +15,7 @@ mod lex{use crate::*;
  while let Some(i)=peek!(){put!(i);} o.push(T::A(v));}
  else {o.push(T::V(S::from(t)))} // otherwise, a verb or adverb
  } r!(Ok(o)) }
- #[cfg(test)]mod t{use super::{*,T::A as TA,T::V as TV,T::SY as TSY};
+ #[cfg(test)]mod t{use super::{*,T::A as TA,T::V as TV};
  /// test helper: lex an expression and check the output
  macro_rules! t{($f:ident,$i:literal,$o:expr)=>{#[test]fn $f()->R<()>{eq!(lex($i)?,$o);ok!()}}}
  macro_rules! sy{($i:literal)=>{$i.parse().map(T::SY).unwrap()}}
@@ -31,7 +30,7 @@ mod lex{use crate::*;
  t!(lex_symbol, "abc", v![sy!("abc")] );
  t!(lex_assign, "a =: 1", v![sy!("a"), T::E, TA(v![1])] );
  }
-}/**input parsing*/mod parse{use {crate::*,super::lex::{T,lex}};
+}/**input parsing*/mod parse{use {crate::*,super::lex::T};
  /**dyadic verb */ #[derive(DBG,PE,PO)] pub enum D {Plus,Mul, Left, Right }
  /**monadic verb */ #[derive(DBG,PE,PO)] pub enum M {Idot,Shape,Tally,Transpose,Same,Inc}
  /**dyadic adverb */ #[derive(DBG )] pub enum Yd{/**dyadic `/` */ Table ,
@@ -55,7 +54,6 @@ mod lex{use crate::*;
  fn parse_(ts:&mut V<T>,ctx:&mut V<B<N>>)->R<()>{
  // push a new AST node onto the `ctx` stack and return, indicating a successful parsing "step."
  macro_rules! step{($n:expr)=>{ctx.push(b!($n));r!(ok!());}}
-
  let(v):S=match ts.pop(){
  Some(T::V(v)) =>v, /*take the next verb, or return if done*/ None=>r!(ok!()),
  Some(T::A(v)) =>{let(n)=v.try_into()?;step!(n);} // array literal
@@ -71,7 +69,6 @@ mod lex{use crate::*;
  /*first, process monadic and dyadic verbs*/
  if let Some(l)=lhs{let(d)=D::new(&v).ok_or(err!("invalid dyad {v:?}"))?;step!(N::D{l,r:rhs,d});}
  else if let Some(m)=M::new(&v){step!(N::M{m,o:rhs});}
-
  /*otherwise, we should treat this as an adverb*/
  let(y)=v;let(d)=ts.pop().ok_or(err!("adverbs need a verb to apply"))?;
  macro_rules! ym {()=>{
@@ -88,20 +85,7 @@ mod lex{use crate::*;
  /*monadic adverb*/ /*dyadic adverb */
  None =>{ ym!();} Some(T::A(v)) =>{let(l)=b!(v.try_into()?);yd!(l);}
  Some(t@T::E|t@T::V(_))=>{ts.push(t);ym!();} Some(T::SY(sy))=>{let(l)=b!(sy.into()); yd!(l);}
- }
- bail!("fallthrough: unexpected parsing error");
- }
- /**get a tuple, representing a window peeking on the next two elements in this token stream.*/
- fn lhs_window(ts:&[T])->(O<&T>,O<&T>){match ts{
- []=>(None,None), [a]=>(None,Some(&a)), [a,b]=>(Some(&a),Some(&b)), [..,a,b]=>(Some(&a),Some(&b)) } }
- #[cfg(test)]mod lhs_t{use super::*;
- #[test] fn lhs_window_works_on_empty(){is!(matches!(lhs_window(&[]), (None, None))) }
- #[test] fn lhs_window_works_on_one (){is!(matches!(lhs_window(&[T::E]), (None, Some(_)))) }
- #[test] fn lhs_window_works_on_two (){is!(matches!(lhs_window(&[T::E,T::A(v![])]),(Some(T::E),Some(T::A(_)))))}
- #[test] fn lhs_window_works_on_three(){
- is!(matches!(lhs_window(&[T::E,T::A(v![]),T::V(S::from("+"))]),(Some(T::A(_)),Some(_))))}
- }
-
+ }}
  impl M {fn new(s:&str)->O<M> {use M::*; Some(match s{"i."=>Idot ,"$" =>Shape ,"|:"=>Transpose ,
  "#" =>Tally ,"[" =>Same ,"]" =>Same ,
  ">:"=>Inc, _=>r!(None)})}}
@@ -110,8 +94,10 @@ mod lex{use crate::*;
  impl Ym{fn new(s:&str)->O<Ym>{use Ym::*;Some(match s{"/" =>Insert,"\\"=>Prefix, _=>r!(None)})}}
  impl Yd{fn new(s:&str)->O<Yd>{use Yd::*;Some(match s{"/" =>Table ,"\\"=>Infix , _=>r!(None)})}}
  #[cfg(test)]mod t{use super::*;
- macro_rules! t{($f:ident,$i:literal)=>{#[test]fn $f()->R<()>{let(mut ts)=lex($i)?;let ast=parse(&mut ts)?;ok!()}}}
- macro_rules! tf{($f:ident,$i:literal)=>{#[test] #[should_panic]fn $f(){let(mut ts)=lex($i).unwrap();let ast=parse(&mut ts).unwrap();}}}
+ macro_rules! t {($f:ident,$i:literal)=>{
+ #[test] fn $f()->R<()>{let(mut ts)=lex($i)?; let _=parse(&mut ts)?;ok!()}}}
+ macro_rules! tf{($f:ident,$i:literal)=>{
+ #[test] #[should_panic]fn $f() {let(mut ts)=lex($i).unwrap();let _=parse(&mut ts).unwrap();}}}
  /*parsing unit tests; t!(..) asserts a success, while tf asserts a failure.*/
  t!(parse_1x1,"1"); t!(parse_1x3,"1 2 3");
  t!(parse_tally_1,"# 1"); t!(parse_tally_1x3,"# 1 2 3");

src/x.rs

@@ -1,6 +1,9 @@
-//! a J interpreter fragment, implemented in Rust.
-#![allow(dead_code,unused_variables,unreachable_code,unused_imports,unused_parens)]
-mod p; use{p::*,j::*}; fn main()->R<()>{use std::io::Write;let(mut st)=ST::default();
- let(pr)=||{print!(" ");std::io::stdout().flush()};
- let(rl)=||{let(mut l)=S::new();stdin().read_line(&mut l)?;Ok::<_,E>(l)};let(mut ev)=|l:S|eval(&l,&mut st);
- loop{pr()?;let(o)=rl().and_then(|l|ev(l))?;if let Some(o)=o{println!("{}",o)}}ur!();}
+/**a J interpreter fragment, implemented in Rust.*/
+mod p;use{p::*,j::*,std::io::Write};
+/// main interpreter entrypoint and event-loop.
+fn main()->R<()>{let mut st=ST::default(); // define symbol table
+ let prompt =| |{print!(" ");std::io::stdout().flush()?;ok!()}; // (callback) print whitespace
+ let read =|_ |{let mut l=S::new();stdin().read_line(&mut l)?;Ok(l)}; // (callback) read input
+ let mut eval=|s:S|{eval(&s,&mut st)}; // (callback) read and evaluate once
+ let print =|a:A|{println!("{a}")}; // (callback) print array
+ loop{prompt().and_then(read).and_then(&mut eval)?.map(print);}; /* !!! main event loop !!! */ }