APL386 Unicode – An APL Font
abrudz.github.io
abrudz.github.io
Not really. It's a natural learning process as you learn the language. Very easy. If you are truly learning the language (rather than just messing around) you can get to the point where you are comfortable typing most common symbols in a week or two.
I used to touch-type APL back in the day. Even though I don't use APL at all these days, every so often, when I do, I am amazed by how quickly I remember where the various symbols are on the keyboard. Some of it just make sense, for example "iota" is shift-i, "rho" is shift-r, etc.
I would argue that difficulty in reading code and knowing what symbols represent what operations is a much more pertinent consideration. And though neither is especially mnemonic (can you really have a mnemonic for something as abstract as 'sort'?), it's much clearer that single-character grade down (⍒) is the reverse of single-character grade up (⍋), than for digraphs (/: and \:). (It's also easier to parse symbols when they're only one character.) Not least because unqualified / and \ represent very different operations—the first is reduce, and the second is either scan or prefix—as do /. and \.; so there's no precedent for it.
And so, assuming you accept the obvious superiority of graphical/unicode representation of symbols, the digraph method for typing them becomes superfluous. You now have to associate the mental concept of grade with two completely separate representations: the graphical representation of the completed character (⍋) and the ascii representation which you type (/:). You can't escape the latter, because every time you type a grade, you'll see the '/' on screen for a moment before you type the ':' and the character gets digraphed.
I mentioned in the beginning that you can configure your editor (and repl) to automatically replace digraphs with their associated symbols (so /: automatically gets replaced with ⍋). On face, this seems functionally equivalent to the ligature suggestion, but it's not. Mainly, it affords flexibility. If you want to type digraphs in your environment, you can, all my criticisms aside. But I can configure my environment to use an alternate keyboard layout, avoid complicating my editor environment by introducing ligatures, and we can work together seamlessly. Doing it that way also adds flexibility to the language; if ⍋ is the single canonical representation of 'grade up', and / and : are separate symbols with their own unique semantics, then they can be freely juxtaposed. It'd also be somewhat of a pointless indirection, to have ascii digraphs underlying what are essentially unicode-pictorial representations.
(Note: I said only 'digraphs', for clarity, but everything I said applies also to trigraphs, of which j has a couple.)
I like being able to type some J (or, most times, some K) in an email, in a note I take in my phone, in a comment of a C program, ... Yes, I could configure my environment(s) to do all this with a custom input method, but being able to do it with anything I find without any configuration is a huge advantage.
It implements features such as macro-like custom syntax, first-class functions and closures.
It's developed in Kotlin and can be compiled to the JVM as well as natively using the new Kotlin multiplatform feature. Javascript will also be possible once Kotlin multiplatform supports reflection. The project is still nowhere near finished, but it can at least run Conway's Game of Life:
https://peertube.mastodon.host/videos/watch/4a19ca9e-7ca6-41...
I haven't worked on it for the last several months due to other projects having higher priority, but I will probably get back to it later.
To clarify: it'd be cool if language's supported multiple lexemes (?) for a single token. So -> and → (U-2192) are equivalent.
Not only does it have it, it has it in (what I feel) is a really accessible way. Seen a symbol and you don't know what it is or how to reproduce it? Enter "?" and paste them symbol into the repl and it'll tell you what's it's called, the shortcut to make it, what it does, and the equivalent non-symbol function name.
quicksort=: (($:@(<#[) , (=#[) , $:@(>#[)) ({~ ?@#)) ^: (1<#)
quicksort ⤆ ((∇⍛(<#⊣) , (=#⊣) , ∇⍛(>#⊢)) ({⍨ ?⍛#))⍣(1<#)
[0]: https://wjmn.github.io/posts/j-can-look-like-apl/I like it, though some of the spacing is odd (might be able to fix it even if it is a monospaced font.)
EDIT: In case people are wondering this is what I see: https://imgur.com/a/P3npCYW
As you see W looks "bolder" (?) than others.
Please link to the actual image ( https://i.imgur.com/qMshely.png ), not imgur's gallery crapware.
But yeah, the "W" and to a lesser extent the "o" look more heavily struck than the rest of the letters. (Same problem shows up in font viewer, so it's definitely not just your browser.)
[1] https://www.myfonts.com/fonts/tabular-type-foundry/comic-cod...
Maybe. What comes to mind is OpenBSD. In the OpenBSD community, developers use Comic Sans exclusively in all official slideshows. One purpose is making an in-joke, another purpose is trolling everyone else not genuinely interested in system development ("Weaponized Comic Sans. This page scientifically designed to troll web hipsters.") [0]
[0] https://www.openbsd.org/papers/bsdcan14-libressl/mgp00025.ht...
Has any programming language since then tried to use more than ASCII for its keywords?
The impl of AVL trees in stdlib: https://github.com/agda/agda-stdlib/blob/master/src/Data/Tre...
Some basic properties of natural numbers: https://github.com/agda/agda-stdlib/blob/master/src/Data/Nat...
It makes the code look absolutely gorgeous, readable and it's very easy to type too. I use Emacs agda-mode so it just automatically replaces e.g. \r with → or \== with ≡ etc...
I don't use Agda for theorem proving, I make real life programs in Agda, I compile them to Haskell and compile with GHC to executables.
Using Sized Types you can do pretty much anything in Agda though. It's not technically Turing complete since all programs are proved to terminate but you can go very far with it. I really like it because it gives very robust guarantees which makes it very easy think about the state of your program.
I once seriously considered trying to build something that included math symbols in the syntax. It's pretty cool to see that I don't have to.
I think Emacs is basically required to use Agda, right? To the point that the set of Agda users is a strict subset of the set of Emacs users.
UnicodeSyntax: https://downloads.haskell.org/~ghc/latest/docs/html/users_gu...
Base Library Symbols: http://hackage.haskell.org/package/base-unicode-symbols
Containers Library Symbols: http://hackage.haskell.org/package/containers-unicode-symbol...
There's a full rune reference available at https://urbit.org/docs/reference/hoon-expressions/rune/, but tldr they're group into families, with the first character being broadly what it does. AST nodes that have to do with "conditionals" are ?:, ?., ?@, etc.
I don't think anyone uses non-ASCII diagraph fonts for them, but it wouldn't be a big jump.