12:39 AM
```ptToLine←{
⎕IO ← 1
p0←⍺
p1←⍵[1]
p2←⍵[2]
⍝ vector p1 to p2
v12←-(⍵[1]-⍵[2])
⍝ unit vector of v12
u12←v12÷(0.5*⍨+/v12*2)
⍝ form a project matrix = u12 u12^t
m←u12 ∘.× u12
m
}```
my input
p0 ← 0 1 0
p1 ← 0 0 0
p2 ← 0.5 0.5 0
vv ← p1 p2
p0 ptToLine vv
any idea why I can not get the output of 3x3 matrix?
p0 ptToLine vv
1 1 1
I edit ptToLine on the right side of RIDE, which is you can edit multiple lines funcion, and I save it each time when I edit it

5 hours later…
5:21 AM
@1234 Yes, `p1` and `p2` (which you should use to create `v12`!) are scalars instead of vectors because you've not disclosed them from `⍵`. This works:
``` ptToLine←{
⎕IO←1
p0←⍺
p1←1⊃⍵
p2←2⊃⍵
⍝ vector p1 to p2
v12←p2-p1
⍝ unit vector of v12
u12←v12÷(0.5*⍨+/v12*2)
⍝ form a project matrix = u12 u12^t
m←u12∘.×u12
m
}```

1 hour later…
6:37 AM
``` ⍴vv
2
vv[1]
0 0 0
vv[2]
0.5 0.5 0```
``` vv ← p1 p2
⍴vv
2```
vv is 2 elements array?
when pass vv to as ω to a function, why I can get p1 and p2 as ω[1] and ω[2]?

6:59 AM
@1234 The shape of an indexing operation is the same as the shape of the indexer, so `⍵[1]` must be scalar just as `1` is a scalar. To keep `0 0 0` a scalar, it is enclosed, so you get `⊂0 0 0`. You can see a hint at that by there being a leading space on the `0 0 0` line. Turn `]box on` to make it clearer. That said, you can use `(p1 p2)←⍵` and that will disclose the elements correctly.

7:19 AM
thx
when I try to add it to my keyboard, I can not see the DyalogKeyboard layout.. ?

Did you follow all instructions here?

I following this link to install the layout

OK, but try following the additional steps under "To enable the keyboard key mappings for Dyalog glyphs".

7:39 AM
I can see the DyalogALt on the source when I try to add(+) a new layout,
can not
it might need to restart my macOS.. maybe..

Very strange. Maybe remove the files and start over, or yes, restart OS.

yep, I will see..

8:38 AM
added co-dfns, taken from the dyalog deltas list
did find & replace, might've messed up something

APL64 next?

maybe? i'd wait for the docs
was considering a+, might be interesting doing something a bit different
but i think i remember you mentioning maybe i shouldn't do that one?

Up to you, but the Sharp family is very different.

yeah idk, after a while it gets boring adding the same primitives over and over again
other dialects i could do while waiting for the apl64 docs?

8:54 AM
APL# and VisualAPL?

9:05 AM
is there a better reference for apl#? only thing i could find is a table (pages 9 and 10) without descriptions
(were the other glpyhs eventually implemented, or not? if not, should I still include them? probably yes, I guess, since I include things from N2k that don't seem to actually exist)

9:35 AM
oh, visualapl looks quite different from traditional apls, cool

@RubenVerg afaik, it stopped there, as the project fizzled out, and no, I don't know of more info.

visualapl looks like if apl and c# had a child
there's a bunch of non-symbolic operators (`new`, `typeof`, ...), i'm not sure if these belong in omnibar

@RubenVerg That's exactly what it was. (Through rape, but whatever…)

@RubenVerg also from a purely aesthetic standpoint, the gylph column will get very wide and look somewhat ugly

@RubenVerg I don't think so. Why would `new` be there but not `⎕NEW`?

9:44 AM
yeah, but how abount `function`? omnibar has `∇`
I think visualapl is somewhat out of scope, it's too different from standard APL, it's like BQN

Hehe.
And APL#?

i'll look through the few docs available and decide if it's too different or not
will be hard documenting it though, without good docs nor an available interpreter to use
their dfn-like thing looks cool

I think its function style is similar to Kap's.

`⍈` (creates a reference to an array) is also interesting
weird how nilads get automatically called when referenced, and you need to use ` to make them unevaluated
wonder why they didn't just make nilads be unevalutaed by default? I guess it might be useful to use nilads as a sort of `let`/`in` (haskell) construct

NARS2000 (and I think also GNU APL) does this too for niladic dfns.

9:56 AM
but on the other hand nilads are also always weird, like you can't pass them around because naming them calls them

Dyalog allows things like `{42}¨array` which can be useful at times. That breaks if the niladic function is evaluated immediately.

interesting, `-` is an identidfier character in apl#

Of course, you can use the trick that is sometimes seen in operators: `{42 ⋄ ⍵}` where `⍵` is never actually reached.
@RubenVerg Really?

@Adám oh, i thought dfns without mentions of `⍵` were just parsed as monads that don't reference the argument
> Names: Any sequence of the characters A-Z,a-z,0-9,_,- that starts with either _ or a letter.

I suspect that's a typo. Maybe they meant `¯` like APL2.

9:59 AM
yeah, it'd be weird for `a-b` not to work
if i add apl# there's a bunch of stuff i'd have to guess. ⍳-nested? yeah probably was supported but who knows! or maybe it wasn't supported, but it was intended, so i should have it anyways...
wonder what "`\$` String" does
nevermind, it's explained below
> Note: \$ is a primitive function for converting character arrays to strings. Format can be used to convert a string to a character vector
guess apl# has scalar strings?
oh yeah, it's explained above
> String
A string is a simple scalar that represents an ordered sequence of Unicode characters
yeah, there's a lot of "will contain"s in the document
forgot to ask, are any of the releases publicly (and freely) available?

@RubenVerg Yes (and no — good luck running this in 2024!)

ah, silverlight.
yeah don't think i'm going through the effort of getting it to run
it's guessing time, I suppose.
still not sure whether to include it though
it definitely looks way more like an APL than visualapl
it's just got some weird features
it looks very unfinished, though
ah, there's a wayback machine snapshot for aplsharp.com including a mention of "updated language documentation" but the download links don't work
would that be available anywhere else? or is it just the doc linked on the wiki (APL# Core language)?
hmm, looks like the two are different documentation since the latter is mentioned below on the page
wonder if the updated language documentation could be recovered in any way
maybe dyalog still has it somewhere?

10:54 AM

you've been really helpful throughout the project, pointing out mistakes, suggesting changes, pointing me, giving me documentation i coudln't have otherwise access to, ...
really don't know how to thank you

2 hours later…
12:38 PM
I would do SAX for SHARP, at least to start with. The documentation link there should work. It's hard to find information on IPSA's SHARP: what I added to the APL Wiki about 1987 involves some guesswork. But I don't see why the current omnibar design would have problems with SHARP or A+. Wasn't the issue before just that they would break up "common APL" too much?

Yeah, I guess, and introduce lots of new meanings to existing symbols.

A Dictionary of APL is sort of an alternative to SHARP, in that it's clearly defined and also was more or less taken as a roadmap for SHARP.

Right, that would make an interesting entry, at least if adding SHARP APL/SAX .

1:16 PM
And as far as I can tell it includes all the glyphs from SHARP at the time (there's a list in table 4, albeit in a weird order, and the Jsoftware version has a handy clickable table at the bottom left).
And yeah, regarding APL# I don't think it's a great addition given that it never got past the prototype stage and also the design focused on things other than the primitives.

Same with VisualAPL?
@user6048 @user1772655 Hi Alan S and Tammie Wagstaffe. If you want to participate here, please email access@apl.chat

1:32 PM
Well, slightly different reasons: they were focused on primitives, just C# ones and not APL.

1 hour later…
2:45 PM
@Marshall thanks, might do that next.
@Marshall yeah, Dictionary is also planned
@Marshall yeah, I guess that's true, but it has some interesting things
maybe I'll add it if I get the aforementioned language documentation and skip it otherwise
(assuming the language documentation in question is actually useful and not just a slightly updated version of the documents already available)
I guess I should make a proper list of dialects I want to support, as a sort of roadmap
any dialect in particular any of you want to appear on the list?

3:39 PM
Announcement: BAA Vector Webinar in 20 mins.

4:07 PM
Found a bug with tacit binding in april github.com/phantomics/april/issues/280
To be honest I'm not sure how well tacit programming is supported by april

4:21 PM
@RubenVerg NARS (not 2000) is historically interesting. The manual focuses on new primitives, but it looks like it does list all of them other than scalar functions, which are presumably the same as APL.SV.

4:50 PM
@RubenVerg Heh, what about (some version of) Iverson Notation? Not an APL, though, but many primitives are shared.

@Marshall thanks!
also are the docs(/papers?) good?

yes, but each version is slightly different
@RubenVerg see e.g. S/360 or APL.

5:11 PM
okay the documentation being somewhat good is definitely a point in favor of adding an iverson notation, but I'm still not convinced that it belongs in omnibar
it's definitely interesting though!
also there's a lot of subscripts and similar that idk how to represent
(well, I guess Iverson notation should be TeX and not Unicode, but that's also another dependency)
yeah I really don't know if I should include it or not

6:00 PM
I don't think Iverson notation is really APL. It's got so many conventions that were discarded, like writing one function on top of another for inner product, implicit subscript for index origin, four different arrows placed on top to flip in various directions...
IVSYS is closer to APL, and some of the stuff there like `n ⍺ j` for a prefix vector even made it into APL\360 for a short time. Still wouldn't include it personally but at least it would fit.
Having the same `⊥y` as Extended Dyalog 53 years earlier is pretty funny though.

Where do you think I got it from?

Is Extended Dyalog APL's "influenced by" field incomplete??
(Well, other than not mentioning Dyalog for some reason)

Yeah, I guess. I got monadic `⊥` from IN, not IVSYS, though.

Oh, I didn't realize (or forgot) it did that.

6:17 PM
Huh, the book doesn't seem to have it. Even though it shows (2∊)⊥x.
It's used extensively in section 2 on microprogramming, and there's a footnote the first time calling it an "elided form".

A.k.a. a monadic form of a dyadic function, with default left arg.

Yes, but it's never indicated that it's part of the language, and it says "Since number bases other than two will be used but rarely in the present chapter, the elided form ..." which suggests it's a subject-specific extension.

Oh well, that is where I got it from.