do you think range can be expressed more simply? even the 1_ feels excessive

 r:{1_x(1+)\-1}
 r 5
0 1 2 3 4
 r 0
!0

(that's k7 syntax)

icsa did a simpler one but it uses where, and where is probably best written using range: {&x#1}

if you want to avoid loops, you have to define first which primitives are not to be used.

i think length is ok

i'm not worried about avoiding loops

something recursive could do it but that feels slow

@chrispsn count: +/x~'x

i wonder how far you could get without storing array lengths in the list data structure

just always allocate in the next contiguous sequence of memory and subtract the next pointer from this one to get the array length

@ktye match feels like something that could be implemented recursively, but i'll add it in because maybe this could work with various 'starting rosters'

heh, you could have definitions that are mutually recursive - fine as long as one hits a base case

how to define empty int list without ! or drop or take :P

also weird results in k9

2019-09-25 14:44:44 2core 3gb avx2 © shakti l test
 {(~x=#:){0,x+1}/!0}5
0 1 2 3 4

2020.04.12 (c) shakti
 {(~x=#){0,x+1}/:!0}5
~5=#

 {x{0,x+1}/`i$()}5
0 1 2 3 4

i think this is because in k9 the valence of a composition is undefined before application. while needs an explicid monad.

@ktye would that apply here too?

2019-09-25 14:44:44 2core 3gb avx2 © shakti l test
 {x{0,x+1}/`i$()}5
0 1 2 3 4

2020.04.12 (c) shakti
 {x{0,x+1}/:`i$()}5
5

@chrispsn these are for loops (not while) and there are no compositions.

see also:

 {{~y=#x}[;x]{0,x+1}/:!0}5
{~y=#x}[;5]

so even if you make it an explicit monad condition, it doesn't work out

it's just returning the p (or n, as the case may be)

 {+/{1}'x}"hello"
5

and indeed +/{1}'

@chrispsn k9 doesn't have n f/: yet but it's easy to implement it through f/:

here N[n;f;a] is n f/:a, Ns[n;f;a] is n f\:a, W[f;g;a] is f g/:a, and Ws[f;g;a] is f g\:a

2020.04.12 (c) shakti
 N:{*|{$[*y;(-1+;x)@';]y}[y]/:(x;z)}
 {N[x;{0,x+1};`i$()]}5
0 1 2 3 4

@chrispsn maybe {-1+\x#1} ?