0 (kaute)                                                         
 1                                                                 
 2 'ss:Sheet var                                                   
 3                                                                 
 4 :ss:rows   (-n)    @ss:Sheet fetch ;                            
 5 :ss:cols   (-n)    @ss:Sheet n:inc fetch ;                      
 6 :ss:load   (a-)    !ss:Sheet ;                                  
 7 :ss:size   (-n)    ss:rows ss:cols n:mul ;                      
 8 :ss:new    (rc-a)  here !ss:Sheet swap comma comma              
 9                    ss:size #2 n:mul [ #0 comma ] times          
10                    @ss:Sheet ;                                  
11 :ss:create (rcs-)  d:create ss:new drop ;                       
12 :ss:offset (rc-n)  swap ss:cols n:mul n:add ;                   
13 :ss:data   (rc-a)  ss:offset @ss:Sheet n:add #2 n:add ;         
14 :ss:types  (rc-a)  ss:data ss:size n:add ;                      
15                                                                 
save next new
 0 (kaute)                                                         
 1                                                                 
 2 :ss:store-n (nrc-) dup-pair [ [ ss:data store ] dip ] dip       
 3                    ss:types #0 swap store ;                     
 4 :ss:store-s (src-) dup-pair                                     
 5                    [ [ ss:data &s:keep dip store ] dip ] dip    
 6                    ss:types #1 swap store ;                     
 7 :ss:store-a (nrc-) dup-pair [ [ ss:data store ] dip ] dip       
 8                    ss:types #2 swap store ;                     
 9                                                                 
10 :ss:fetch   (arc-vt) ss:data &fetch sip ss:size n:add fetch ;   
11                                                                 
12 :ss:action  (rc-nt) ss:fetch #2 eq?                             
13                     [ call ] [ drop #0 #0 ] choose ;            
14                                                                 
15                                                                 
save next new
 0 (kaute)                                                         
 1                                                                 
 2 :~name (vr-vrs) over I n:to-s s:append ;                        
 3 :~define (r-r)  &dtc compile:call                               
 4                 &internal:lit comma                             
 5                 dup comma                                       
 6                 &internal:lit comma                             
 7                 I comma                                         
 8                 #0 comma ;                                      
 9                                                                 
10                                                                 
11 :ss:make-fields (rcv-)                                          
12   '_ [ #0 s:store ] sip roll                                    
13   [ ~name d:create ~define ] indexed-times drop-pair ;          
14                                                                 
15                                                                 
save next new
 0 (kaute)                                                         
 1                                                                 
 2 #0  #5 $A ss:make-fields  #1  #5 $B ss:make-fields              
 3 #2  #5 $C ss:make-fields  #3  #5 $D ss:make-fields              
 4 #4  #5 $E ss:make-fields  #5  #5 $F ss:make-fields              
 5 #6  #5 $G ss:make-fields  #7  #5 $H ss:make-fields              
 6 #8  #5 $I ss:make-fields  #9  #5 $J ss:make-fields              
 7 #10 #5 $K ss:make-fields  #11 #5 $L ss:make-fields              
 8 #12 #5 $M ss:make-fields  #13 #5 $N ss:make-fields              
 9 #14 #5 $O ss:make-fields                                        
10                                                                 
11 . Quick fetches to guarantee return type validity               
12                                                                 
13 :ss:fetch-n (rc-n) ss:fetch n:-zero? [ drop #0 ] if ;           
14 :ss:fetch-s (rc-s) ss:fetch #1 -eq? [ drop '_ ] if ;            
15 :ss:fetch-a (rc-a) ss:fetch #2 -eq? [ drop [ ] ] if ;           
save next new
 0 (kaute)                                                         
 1                                                                 
 2 :ss:NUMBER #0 ;                                                 
 3 :ss:STRING #1 ;                                                 
 4 :ss:ACTION #2 ;                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new
 0                                                                 
 1                                                                 
 2                                                                 
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new
 0 kaute : a headless spreadsheet : overview                       
 1                                                                 
 2 The kaute vocabulary provides support for creating and working  
 3 with data stored in a spreadsheet format. It primarily provides 
 4 functionality, not presentation.                                
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new
 0 kaute : a headless spreadsheet : data structure                 
 1                                                                 
 2 In memory, a sheet is structured as:                            
 3                                                                 
 4   rows                                                          
 5   columns                                                       
 6   ... ( rows cells * ) ...  data                                
 7   ... ( rows cells * ) ...  types                               
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new
 0 kaute : a headless spreadsheet : data types                     
 1                                                                 
 2 # Types                                                         
 3                                                                 
 4 Kaute currently supports three types of data in a cell:         
 5                                                                 
 6 - numbers                                                       
 7 - pointers to strings                                           
 8 - pointers to actions                                           
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new
 0 kaute : a headless spreadsheet : actions                        
 1                                                                 
 2 # Actions                                                       
 3                                                                 
 4 Action cells are written as quotes, which return a value & type 
 5 pair. An example might look like:                               
 6                                                                 
 7   [ A1 ss:fetch-n A2 ss:fetch-n n:mul ss:NUMBER ]               
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new
 0 kaute : a headless spreadsheet : strings                        
 1                                                                 
 2                                                                 
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new
 0 kaute : a headless spreadsheet : numbers                        
 1                                                                 
 2 Most cells contain numbers. These are just standard numeric     
 3 values, and can be in any format that fits in a cell. I mostly  
 4 use simple integers, but do sometimes make use of scaled values.
 5                                                                 
 6 It might be of interest to expand this, to separate out the use 
 7 of integers, scaled values, and dusk's fixed & floating point   
 8 values. I'm not going to work on this for now (May 2024).       
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new
 0                                                                 
 1                                                                 
 2                                                                 
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new
 0                                                                 
 1                                                                 
 2                                                                 
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new
 0                                                                 
 1                                                                 
 2                                                                 
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new
 0 (LOAD:kaute)                                                    
 1                                                                 
 2 '(kaute) needs                                                  
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 
save next new