Jacinda can imitate cloc by combining it with other command-line tools on the Unix command-line, viz.

@include'prelude/fn.jac'

fn count(xs) :=
  (+)|0 [:1"xs;

let
  val bqn := {%/\.bqn$/}{\`1:i}
  val hs := {%/\.hs$/}{\`1:i}
  val ja := {%/\.jac$/}{\`1:i}
  val pl := {%/\.pl$/}{\`1:i}
  val sed := {%/\.sed$/}{\`1:i}
  val asm := {%/\.(S|asm)$/}{\`1:i}
  val rb := {%/\.rb$/}{\`1:i}
  val py := {%/\.py$/}{\`1:i}
  val c := {%/\.c$/}{\`1:i}
  val awk := {%/\.awk$/}{\`1:i}
in sprintf'Haskell:\t%i\t%i\nBQN:\t\t%i\t%i\nJacinda:\t%i\t%i\nC:\t\t%i\t%i\nPython:\t\t%i\t%i\nPerl:\t\t%i\t%i\nSed:\t\t%i\t%i\nAssembly:\t%i\t%i\nRuby:\t\t%i\t%i\nAwk:\t\t%i\t%i'
  ( count hs . sum hs
  . count bqn . sum bqn
  . count ja . sum ja
  . count c . sum c
  . count py . sum py
  . count pl . sum pl
  . count sed . sum sed
  . count asm . sum asm
  . count rb . sum rb
  . count awk . sum awk
  )
end

This is invoked like so:

fd -t f -x wc -l | ja run cloc.jac

and gives something like

Haskell:	19	3092
BQN:		0	0
Jacinda:	53	389
C:		0	0
Python:		0	0
Perl:		0	0
Sed:		0	0
Assembly:	0	0
Ruby:		0	0
Awk:		11	133

fd and wc performance are the limiting factors; this is faster than cloc though slower than better code counters.

Conclusion

I think this is one of the cases where Jacinda's expression-oriented style is superior to Awk - one would need a variable for each language that would be ticked up.

That Jacinda's performance is not the limiting factor vindicates the underlying design - folds, lazy ByteStrings, a tree-walking interpreter.