swipl-devel VS BQN

Still, there are many useful tools based on these ideas, used by programmers and mathematicians alike. What you describe sounds rather like Datalog (e.g. Soufflé Datalog), where you supply some rules and an initial fact, and the system repeatedly expands out the set of facts until nothing new can be derived. (This has to be finite, if you want to get anywhere.) In Prolog (e.g. SWI Prolog) you also supply a set of rules and facts, but instead of a fact as your starting point, you give a query containing some unknown variables, and the system tries to find an assignment of the variables that proves the query. And finally there is a rich array of theorem provers and proof assistants such as Agda, Coq, Lean, and Twelf, which can all be used to help check your reasoning or explore new ideas.

SWIProlog[1] has so far been my go to due to the extensive support system it has. However, I've been meaning to explore higher order logic a bit and Ciao[2] caught my attention there, with sugar for function-like notation and higher order programming including "lambda" style predicate expressions .... and it compiles down to executable. The function notation in this context is along the same lines as Mozart/Oz and can be convenient. Not explore the higher order aspects much though.

[1]: https://www.swi-prolog.org/

[2]: https://en.wikipedia.org/wiki/Ciao_(programming_language)

?- version(). Welcome to SWI-Prolog (threaded, 64 bits, version 9.0.0)SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software. Please run ?- license. for legal details.For online help and background, visit https://www.swi-prolog.org For built-in help, use ?- help(Topic). or ?- apropos(Word). true. ?- del(a, L, [1,2,3]). L = [a, 1, 2, 3] ; L = [1, a, 2, 3] ; L = [1, 2, a, 3] ; L = [1, 2, 3, a] ; false.

$ swipl Welcome to SWI-Prolog (threaded, 64 bits, version 8.5.10) SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software. Please run ?- license. for legal details. For online help and background, visit https://www.swi-prolog.org For built-in help, use ?- help(Topic). or ?- apropos(Word). ?- [fm2gp_primes]. true. ?- time( setup_call_cleanup(open('prolog-primes.txt', write, Out), with_output_to(Out, primes(500_000)), close(Out)) ). % 8,766,852 inferences, 1.055 CPU in 1.198 seconds (88% CPU, 8311018 Lips) Out = (0x600000648100).

The utilities in dgc/bacics.pl that you linked yourself are not too advanced, too quickly. Understanding those is exactly what you need in order to be able to write useful grammars for two reasons. They show how to approach many common issues with DCGs; and you know what building blocks you have at your disposal. I feel you discarded those too fast and strongly suggest you try to revisit them.

- And last but not least... the ability to convert authorization logic into SQL [4]. Which is done by having the language return constraints over any unbound (free) variables.

To me this is what makes logic programming exciting for authorization. It gives you this small kernel of declarative programming, and gives you a ton of freedom to build on top.

[1] https://www.swi-prolog.org/

(Btw. I'm using SWI Prolog.)

Welcome to SWI-Prolog (threaded, 64 bits, version 8.0.2) SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software. Please run ?- license. for legal details. For online help and background, visit http://www.swi-prolog.org For built-in help, use ?- help(Topic). or ?- apropos(Word). ?- use_module(library(lists)). true. ?- clumped([a,a,a,b,b,c], Rs). ERROR: Undefined procedure: clumped/2 (DWIM could not correct goal) ?-

Many library predicates do the argument reordering to take advantage of this special case argument indexing as explained in the answer by u/mycl. For example library(apply) in SWI-Prolog. is full of those.

I recommend checking BQN at https://mlochbaum.github.io/BQN/ and the YouTube channel code_report by Conor Hoekstra (and also "Composition Intuition by Conor Hoekstra | Lambda Days 2023"). It is well documented.

I don't put a lot of stock in the "write-only" accusation. I think it's mostly used by those who don't know APL because, first, it's clever, and second, they can't read the code. However, if I remember I implemented something in J 10 years ago, I will definitely dig out the code because that's the fastest way by far for me to remember how it works.

This project specifically looks to be done in a flat array style similar to Co-dfns[0]. It's not a very common way to use APL. However, I've maintained an array-based compiler [1] for several years, and don't find that reading is a particular difficulty. Debugging is significantly easier than a scalar compiler, because the computation works on arrays drawn from the entire source code, and it's easy to inspect these and figure out what doesn't match expectations. I wrote most of [2] using a more traditional compiler architecture and it's easier to write and extend but feels about the same for reading and small tweaks. See also my review [3] of the denser compiler and precursor Co-dfns.

As for being read by others, short snippets are definitely fine. Taking some from the last week or so in the APL Farm, {⍵÷⍨+/|-/¯9 ¯11+.○?2⍵2⍴0} and {(⍸⍣¯1+\⎕IO,⍺)⊂[⎕IO]⍵} seemed to be easily understood. Forum links at [4]; the APL Orchard is viewable without signup and tends to have a lot of code discussion. There are APL codebases with many programmers, but they tend to be very verbose with long names. Something like the YAML parser here with no comments and single-letter names would be hard to get into. I can recognize, say, that c⌿¨⍨←(∨⍀∧∨⍀U⊖)∘(~⊢∊LF⍪WS⍨)¨c trims leading and trailing whitespace from each string in a few seconds, but in other places there are a lot of magic numbers so I get the "what" but not the "why". Eh, as I look over it things are starting to make sense, could probably get through this in an hour or so. But a lot of APLers don't have experience with the patterns used here.

[0] https://github.com/Co-dfns/Co-dfns

[1] https://github.com/mlochbaum/BQN/blob/master/src/c.bqn

[2] https://github.com/mlochbaum/Singeli/blob/master/singeli.bqn

[3] https://mlochbaum.github.io/BQN/implementation/codfns.html

[4] https://aplwiki.com/wiki/Chat_rooms_and_forums

Uiua is an interesting new language. Strongly influenced by APL and BQN, it's array-oriented and stack-based. To explore it briefly, I will walk through my solutions to this week's Perl weekly challenge (242).

https://mlochbaum.github.io/BQN/

Forth and Lisps tend to be fairly visual syntax free as well.

I'm just speculating though, looking for someone with experience to confirm or rebuke.

> Are there any other languages that use glyphs so heavily?

APL (the first, invented in the 1960s): https://en.wikipedia.org/wiki/APL_(programming_language)

BQN (a modern APL, looks like an inspiration for Uiua though I don't know): https://mlochbaum.github.io/BQN/

Too many smaller esoteric languages to count.

There is no need to have a specific keyboard. The actual solution depends on what APL you're using, but the principle is the same. The various symbols are available on the regular keys, and you use some way to indicate that you want the APL symbol rather than the regular symbol.

Dyalog has two different IDE's the support this. Ride uses backquote by default, while the windows IDE uses control.

Kap uses backquote in all its interfaces. Here's what it looks like in the web version: https://kapdemo.dhsdevelopments.com/clientweb2/

Likewise, BQN does the same thing, but uses backslash: https://mlochbaum.github.io/BQN/

When using GNU APL there is an Emacs mode available (which I am the author of) that provides an input method.

So the long story short, you should be able to get going with any array language without getting any special keyboard.

Vouch for array programming, but also BQN. Modern, very good documentation, a bit less confusing than APL imo.

For anyone looking to get into array programming, I'd recommend https://mlochbaum.github.io/BQN/. I'm no expert but I had a lot of fun using it for Advent of Code last year. I found it to be a lot more sensible and modern feeling than J (the only other one I've tried).

There’s also at least BQN, which I suspect is the language used in those comments:

https://mlochbaum.github.io/BQN/