bug-apl
[Top][All Lists]

## Re: exercise 2019/01

 From: Kacper Gutowski Subject: Re: exercise 2019/01 Date: Sun, 12 Apr 2020 02:32:30 +0200

```On Sat, Apr 11, 2020 at 11:02:39PM +0200, Otto Diesenbacher-Reinmüller wrote:
```
```1 chunk monkey
```
```
I would write it as {(+\(⍴,⍵)⍴⍺↑1)⊂,⍵}.
```
(In low-⎕ML Dyalog it would be {((≢⍵)⍴⍺↑1)⊂,⍵} without needing that +\ on left argument.) You can write ≢⍵ or ⍴,⍵ here, using ≢ is probably more idiomatic in Dyalog and works just as fine in GNU APL. Forcing right argument into a vector using ravel should be enough to handle scalars without any additional branching.
```
```
```  →((0=≢⍴a)∧1=≢a)/skalar        ⍝ matches a skalar, but not ''
```
```
This is redundant as 0=≢⍴a implies 1=≢a.
```
Note that '' is not a scalar but a vector of length zero. The notation for character literals is confusing, I know.
```
```
Checking for types is not easy. 0=⍴N is a scalar. Howto check for a string?
```
```
"String" usually means a "vector of characters". You already know how to check a rank (I suppose it's just a typo and you meant 0=⍴⍴N or maybe 0=≢⍴N for a scalar, i.e. an array of rank zero) and vector is just an array of rank one.
```
```
The closest thing to what can be informally called a type of an array is its typical element (also called fill element or a prototype). For simple numeric arrays the typical element is zero, for simple character arrays it is a blank. You can use it like this:
```
0≡↑0⍴X    ⍝ X is numeric (if simple)
' '≡↑0⍴X  ⍝ X is a character array (if simple)

So it would be something like (1=⍴⍴X)∧' '≡↑0⍴X to check for a "string".
```
Or maybe (1≥⍴⍴X)∧' '≡↑0⍴X if you wanted to include character scalars like 'a' in the definition of a "string". It will nevertheless fail if your array is mixed because those have implementation-defined typical elements, so you might want to check depth and every element:
```      ∧/(1=⍴⍴X),(1≥≡X),{' '≡↑0⍴⍵}¨X

```
(In case of Dyalog replace monadic ↑ with ⊃ as needed depending on the value of ⎕ML)
```
```
You won't really need checks like that. Just write your code assuming your data is of the right "type" and let some primitive throw a domain error if it isn't. If you need to accept vectors but also pretend that scalar is a one-element vector, just ravel it.
```
-k

```