Skip to content

Commit 8c53847

Browse files
cratelyncratelyn
authored
Merge pull request #12 from cratelyn/clean
🧼 other miscellaneous tidying
2 parents 64b81ed + 75ca47a commit 8c53847

File tree

4 files changed

+30
-51
lines changed

4 files changed

+30
-51
lines changed

‎src/a.rs

+12-29
Original file line numberDiff line numberDiff line change
@@ -41,32 +41,26 @@ use super::*; use std::marker::PhantomData as PD;
4141
toob!(i00_for_3x3,arr3x3,0,0);toob!(i01_for_3x3,arr3x3,0,1);toob!(i14_for_3x3,arr3x3,1,4);
4242
toob!(i41_for_3x3,arr3x3,4,1);toob!(i44_for_3x3,arr3x3,4,4);
4343
ti!(i11_for_3x3,arr3x3,1,1,0);ti!(i21_for_3x3,arr3x3,2,1,3);ti!(i22_for_3x3,arr3x3,2,2,4);
44-
ti!(i31_for_3x3,arr3x3,3,1,6);ti!(i33_for_3x3,arr3x3,3,3,8);
45-
}
44+
ti!(i31_for_3x3,arr3x3,3,1,6);ti!(i33_for_3x3,arr3x3,3,3,8); }
4645

4746
/**array allocation*/mod alloc{use{super::*,std::alloc::{alloc,alloc_zeroed,dealloc}};
4847
/**sealed trait, memory markers*/pub trait MX{} impl MX for MU {} impl MX for MI {}
4948
/**marker: memory uninitialized*/#[derive(CL,DBG)]pub struct MU;
5049
/**marker: memory initialized*/ #[derive(CL,DBG)]pub struct MI;
5150
impl A<MU>{
5251
pub fn new(m:U,n:U)->R<Self>{Self::alloc(m,n).map(|(l,d)|A{m,n,d,l,i:PD})}
53-
// TODO: use `A::iter`
54-
// TODO: use `set_unchecked` here.
5552
pub fn init_with<F:FnMut(U,U)->R<I>>(mut self,mut f:F)->R<A<MI>>{let(A{m,n,..})=self;
5653
for(i)in(1..=m){for(j)in(1..=n){let(v)=f(i,j)?;self.set(i,j,v)?;}}Ok(unsafe{self.finish()})}
57-
pub unsafe fn finish(self)->A<MI>{std::mem::transmute(self)}
58-
}
54+
pub unsafe fn finish(self)->A<MI>{std::mem::transmute(self)}}
5955
impl A<MI>{
6056
pub fn zeroed(m:U,n:U)->R<Self>{let(l,d)=Self::allocz(m,n)?;Ok(A{m,n,d,l,i:PD})}
6157
pub fn from_i(i:I)->R<Self>{let mut a=A::new(1,1)?;a.set(1,1,i)?;Ok(unsafe{a.finish()})}}
6258
impl TF<I> for A<MI>{type Error=E;fn try_from(i:I)->R<Self>{A::from_i(i)}}
6359
impl<X:MX> A<X>{
64-
fn alloc(m:U,n:U)->R<(L,*mut u8)>{let(l)=Self::l(m,n)?;let d=unsafe{alloc(l)};Ok((l,d))}
60+
fn alloc (m:U,n:U)->R<(L,*mut u8)>{let(l)=Self::l(m,n)?;let d=unsafe{alloc(l)}; Ok((l,d))}
6561
fn allocz(m:U,n:U)->R<(L,*mut u8)>{let(l)=Self::l(m,n)?;let d=unsafe{alloc_zeroed(l)};Ok((l,d))}
66-
fn l(m:U,n:U)->R<L>{L::array::<I>(m*n).map_err(E::from)}
67-
}
62+
fn l(m:U,n:U)->R<L>{L::array::<I>(m*n).map_err(E::from)}}
6863
impl<M> Drop for A<M>{fn drop(&mut self){let(A{d,l,..})=self;unsafe{dealloc(*d,*l)}}}
69-
// TODO: add compile_fail checks to ensure that e.g. `get` cannot be used on an uninitialized array
7064
} pub use self::alloc::{MI,MU,MX};
7165

7266
/**array access*/mod access{use{super::*,std::mem::size_of};
@@ -86,8 +80,7 @@ use super::*; use std::marker::PhantomData as PD;
8680
pub(crate)fn ptr_at_uc(&self,i:U,j:U)->R<*mut I>{self.ptr_at_impl(i,j,Self::index_uc)}
8781
fn ptr_at_impl<F:Fn(&Self,U,U)->R<U>>(&self,i:U,j:U,f:F)->R<*mut I>{
8882
let(o):isize=f(self,i,j).map(|x|x*size_of::<I>())?.try_into()?;let(d)=unsafe{(self.d.offset(o) as *mut I)};
89-
Ok(d)}
90-
}}
83+
Ok(d)}}}
9184

9285
/**scalar conversion/comparison*/mod scalars{use super::*; /*todo...*/
9386
impl A<MI>{pub fn as_i(&self)->R<I>{let a@A{m:1,n:1,..}=self else{bail!("not a scalar")};a.get(1,1)}}
@@ -123,8 +116,7 @@ use super::*; use std::marker::PhantomData as PD;
123116
if(r.len()!=self.m){r!(false)}for(i,r_i)in(r.into_iter().enumerate()){
124117
if(r_i.len()!=self.n){r!(false)}for(j,r_ij)in(r_i.into_iter().enumerate()){
125118
let(i,j)=(i+1,j+1);let(a_ij)=match(self.get(i,j)){Ok(v)=>v,Err(_)=>r!(false)};
126-
if(a_ij)!=(*r_ij){r!(false)}}}true}}
127-
}
119+
if(a_ij)!=(*r_ij){r!(false)}}}true}}}
128120

129121
/**monadic verbs*/impl A{
130122
pub fn m_same(self)->R<A>{Ok(self)}
@@ -138,8 +130,7 @@ use super::*; use std::marker::PhantomData as PD;
138130
pub fn m_tally(self)->R<A>{let A{m,n,..}=self;let(i)=I::try_from(m*n)?;A::from_i(i)}
139131
pub fn m_trans(self)->R<A>{let(i@A{m:m_i,n:n_i,..})=self;let(m_o,n_o)=(n_i,m_i);
140132
let(f)=|i_o,j_o|{i.get(j_o,i_o)};A::new(m_o,n_o)?.init_with(f)}
141-
pub fn m_inc(self)->R<A>{let(a@A{m,n,..})=self;A::new(m,n)?.init_with(|i,j|a.get(i,j).map(|x|x+1))}
142-
}
133+
pub fn m_inc(self)->R<A>{let(a@A{m,n,..})=self;A::new(m,n)?.init_with(|i,j|a.get(i,j).map(|x|x+1))}}
143134

144135
/**dyadic verbs*/impl D{
145136
/*return dyad function**/ pub fn f(&self)->fn(I,I)->I{use D::*;
@@ -163,8 +154,7 @@ use super::*; use std::marker::PhantomData as PD;
163154
else if (ml==nr)&&(nl==mr) /*NB: inherit the dimensions of the right-hand operand.*/ // rotation
164155
{let(f)=|i,j|{let(x)=l.get(j,i)?;let(y)=r.get(i,j)?;Ok(f(x,y))};r!(A::new(mr,nr)?.init_with(f))}
165156
bail!("length error");
166-
}
167-
}
157+
}}
168158

169159
/**monadic adverbs*/mod adverbs_m{use super::*;
170160
impl Ym{
@@ -177,17 +167,15 @@ use super::*; use std::marker::PhantomData as PD;
177167
else if let Ok(s)=a.as_slice(){let (m,n)=(s.len(),s.len());
178168
let p=|i,j|if(j>i){Ok(0)}else{a.get(1,j).map(d_)};
179169
A::new(m,n)?.init_with(p)}
180-
else { bail!("monadic `\\` is not implemented for matrices") }}
181-
}
170+
else { bail!("monadic `\\` is not implemented for matrices") }}}
182171
// === monadic `/`, `Ym::Insert` tests
183172
macro_rules! test_insert{($f:ident,$d:expr,$a:expr,$o:expr)=>
184173
{#[test]fn $f()->R<()>{let(a):R<A>={$a};let(d):D={$d}; // typecheck macro arguments.
185174
let i:I=a.and_then(|a:A|Ym::insert($d,a)).and_then(|a|a.as_i())?;
186175
eq!(i,$o);ok!()}}}
187176
test_insert!(add_a_scalar, D::Plus, A::from_i(42), 42 );
188177
test_insert!(add_a_sequence, D::Plus, <A as TF<&[I]>>::try_from(&[1,2,3,4,5]), (1+2+3+4+5) );
189-
test_insert!(mul_a_sequence, D::Mul , <A as TF<&[I]>>::try_from(&[1,2,3,4,5]), (1*2*3*4*5) );
190-
}
178+
test_insert!(mul_a_sequence, D::Mul , <A as TF<&[I]>>::try_from(&[1,2,3,4,5]), (1*2*3*4*5) ); }
191179

192180
/**dyadic adverbs*/mod adverbs_d{use super::*;
193181
impl Yd{
@@ -203,17 +191,12 @@ use super::*; use std::marker::PhantomData as PD;
203191
fn infix(d:D,l:A,r:A)->R<A>{let(s)=r.as_slice().map_err(|_|err!("infix rhs must be a slice"))?;
204192
let(il)=l.as_i() .map_err(|_|err!("infix lhs must be a scalar"))?.try_into()?;
205193
let(ic)=(s.len()-il)+1;
206-
A::new(ic,il)?.init_with(|i,j|Ok(s[(i-1)+(j-1)]))}
207-
}
208-
}
194+
A::new(ic,il)?.init_with(|i,j|Ok(s[(i-1)+(j-1)]))}}}
209195

210196
/**deep-copy*/impl A<MI>{
211-
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)})}
212-
}
197+
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)})}}
213198

214199
/**display*/mod fmt{use super::*;
215200
impl DS for A<MI>{
216-
// TODO: buffer stdout, flush after loops
217-
// TODO: use `unchecked` to elide bounds checks in printing
218201
fn fmt(&self,fmt:&mut FMT)->FR{let A{m,n,..}=*self;for(i,j)in(self.iter())
219202
{let(x)=self.get_uc(i,j).map_err(|_|std::fmt::Error)?;write!(fmt,"{x}{}",if(j==n){'\n'}else{' '})?;}ok!()}}}

‎src/j.rs

+11-12
Original file line numberDiff line numberDiff line change
@@ -5,16 +5,15 @@ pub use self::{a::*,r::*,s::*};
55
pub fn eval(input:&str,st:&mut ST)->R<O<A>>{
66
let(mut ts)=lex(input)?;let(ast)=match(parse(&mut ts)?){Some(x)=>x,None=>rrn!()};eval_(ast,st)}
77
fn eval_(ast:B<N>,st:&mut ST)->R<O<A>>{use{M::*,D::*};
8-
let(mut rec)=|a|->R<A>{match(eval_(a,st)){Ok(Some(a))=>Ok(a),Err(e)=>Err(e), // recursively evaluate subexpression.
8+
let(mut rec)=|a|->R<A>{match(eval_(a,st)){Ok(Some(a))=>Ok(a),Err(e)=>Err(e),/*recursively evaluate*/
99
Ok(None)=>Err(err!("expression did not result in a value"))}};
10-
match *ast{
11-
N::A{a} =>Ok(a),
12-
N::M{m,o} =>{let(a)=rec(o)?; match m{Idot=>a.m_idot(), Shape=>a.m_shape(), Same=>a.m_same(),
13-
Tally=>a.m_tally(),Transpose=>a.m_trans(), Inc=>a.m_inc()}}
14-
N::D{d,l,r}=>{let(l,r)=(rec(l)?,rec(r)?);match d{Plus=>l.d_plus(r), Mul=>l.d_mul(r),
15-
Left=>l.d_left(r), Right=>l.d_right(r)}}
16-
N::Ym{ym,d,o}=>{rec(o).and_then(|a|ym.apply(d,a))}
17-
N::Yd{yd,d,l,r}=>{let(l,r)=(rec(l)?,rec(r)?);yd.apply(d,l,r)}
18-
N::S{sy} =>{st.get(&sy).ok_or(err!("undefined symbol: {sy:?}")).and_then(A::deep_copy)}
19-
N::E{sy,e} =>{let(a)=rec(e)?;st.insert(sy,a);r!(Ok(None))}
20-
}.map(O::Some)}
10+
match *ast{N::A{a}=>Ok(a), // array literal
11+
N::M{m,o }=>{let(a)=rec(o)?; match m{Idot=>a.m_idot(),Shape=>a.m_shape(),Transpose=>a.m_trans(), // monadic verb
12+
Same=>a.m_same(),Tally=>a.m_tally(),Inc=>a.m_inc()}}
13+
N::D{d,l,r }=>{let(l,r)=(rec(l)?,rec(r)?);match d{Plus=>l.d_plus(r),Mul=>l.d_mul(r), // dyadic verb
14+
Left=>l.d_left(r),Right=>l.d_right(r)}}
15+
N::Ym{ym,d,o }=>{rec(o).and_then(|a|ym.apply(d,a))} // monadic adverb
16+
N::Yd{yd,d,l,r}=>{let(l,r)=(rec(l)?,rec(r)?);yd.apply(d,l,r)} // dyadic adverb
17+
N::E {sy,e }=>{let(a)=rec(e)?;st.insert(sy,a);r!(Ok(None))} // symbol assignment
18+
N::S {sy }=>{st.get(&sy).ok_or(err!("undefined symbol: {sy:?}")).and_then(A::deep_copy)} // symbol
19+
}.map(O::Some)}

‎src/p.rs

+1-4
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,4 @@ pub(crate)use{anyhow::{Context,Error as E,anyhow as err,bail}};
1313
#[macro_export] /**`unreachable!()`*/ macro_rules! ur {()=>{unreachable!()}}
1414
/**`Result<T, anyhow::Error>`*/ pub type R<T> = Result<T,E>;
1515
#[cfg(test)]/**test prelude*/pub(crate) mod tp{
16-
pub(crate) use{assert_eq as eq,assert_ne as neq,assert as is,vec as v};
17-
}
18-
// todo: extension trait for abbreviated `try_into`, `try_from`
19-
// todo: extension trait for abbreviated `map`, `and_then`, `unwrap`
16+
pub(crate) use{assert_eq as eq,assert_ne as neq,assert as is,vec as v}; }

‎src/s.rs

+6-6
Original file line numberDiff line numberDiff line change
@@ -9,12 +9,12 @@ use super::*; use std::ops::Not;
99
let(sv)=|c:&char|c.is_ascii_lowercase()||c.is_ascii_digit()||*c=='_'; // validate
1010
if(sc.iter().all(sv).not()){bail!("symbols may only contain a-z, 0-9, or `_`")}
1111
Ok(SY(s.to_owned()))}}
12-
#[test] fn simple_symbol_succeeds() {assert!(SY::from_str("abc") .is_ok())}
13-
#[test] fn underscore_symbol_succeeds() {assert!(SY::from_str("abc_def").is_ok())}
14-
#[test] fn trailing_number_symbol_succeeds(){assert!(SY::from_str("a1") .is_ok())}
15-
#[test] fn empty_symbol_fails() {assert!(SY::from_str("") .is_err())}
16-
#[test] fn number_symbol_fails() {assert!(SY::from_str("1") .is_err())}
17-
#[test] fn leading_number_symbol_fails() {assert!(SY::from_str("1a") .is_err())}
12+
#[test] fn simple_symbol_succeeds() {is!(SY::from_str("abc") .is_ok())}
13+
#[test] fn underscore_symbol_succeeds() {is!(SY::from_str("abc_def").is_ok())}
14+
#[test] fn trailing_number_symbol_succeeds(){is!(SY::from_str("a1") .is_ok())}
15+
#[test] fn empty_symbol_fails() {is!(SY::from_str("") .is_err())}
16+
#[test] fn number_symbol_fails() {is!(SY::from_str("1") .is_err())}
17+
#[test] fn leading_number_symbol_fails() {is!(SY::from_str("1a") .is_err())}
1818
}
1919

2020
impl ST{

0 commit comments

Comments
 (0)