Lambda the Ultimate

For example, here's how you transcribe the conventional exhaustive Sudoku solver:

#import std
#import nat

#executable (<'par'>,<>)
#optimize+

sudoku =

~command.files; <.file$[contents: --<''>]>+ *= ~contents.&F; * -+
   ~&rSL+ (psort (nleq+)* <~&blrl,~&blrr>)+ ~&arg^& -+
      ~&al?\~&ar ~&aa^&~&afahPRPfafatPJPRY+ ~&farlthlriNCSPDPDrlCS2DlrTS2J,
      ^|J/~& ~&rt!=+ ^= ~&s+ ~&H(
         -+.|=&lrr;,|=&lrl;,|=&ll;+-,
         ~&rgg&& ~&irtPFXlrjrXPS; ~&lrK2tkZ2g&& ~&llrSL2rDrlPrrPljXSPTSL)+-,
   //~&p ^|DlrDSLlrlPXrrPDSL(~&,num*+ rep2 block3)*= num block27 ~&iiK0 iota9,
   * `0?=\~&iNC ! ~&t digits+-

On the off chance that this isn't self-evident, here's a quick explanation of two parts of the above program:

• ~&irtPFXlrjrXPS ⇒ separate each member of a list of lists of pairs of lists into those with multiple items on the right and those without;
• ~&lrK2tkZ2g ⇒ test that there are no repeated right sides in any of the left sides in a given list of pairs of lists of pairs.

Expressions like these can be verified interactively through "decompilation":

$ fun --main="~&DlrDSLlrlPXrrPDSL" --decompile
main = compose(
   reduce(cat,0),
   compose(
      map compose(
         distribute,
         field(((&,0),(0,(&,0))),(0,(0,&)))),
         compose(
            reduce(cat,0),
            compose(map distribute,distribute))))

I wonder what Paul Graham would say... Ah, who cares. What's important is that we know what Jack Hollingsworth would say to PG:

If you really want to put a language to the test, try it out on something it's not good for.

In the old days, I knew what to do with that sort of code; namely, change the baud rate on the terminal. Nowadays that doesn't seem to help.

Ouch! Are you sure that isn't the first few lines of a PDF that the web server marked text/plain by mistake?

I love that it calls itself Universal. Brevity yields "dramatic improvement in productivity".

Is that why almost all code in the documentation is in shorthand notation?
God... What do we gain over APL?

I think I'll stick to a more intuitive, straightforward language like brainfuck.

Besides the unconventional syntax, Ursala has an interesting unconventional data model. At a core semantic level, the only data type is the unlabeled binary tree; in other words, you get CONS and NIL, and that's it.

There are predefined encodings for characters, integers, floating-point numbers, etc., as unlabeled binary trees, so typically you don't need to care about the underlying data model; but you can always destructure a character and access the underlying tree if you want.

I've only read the reference manual, and never tried to actually use Ursala, so I can't be sure; but I get the impression that the virtual machine is more conventional than this sounds, and actually uses native data types unless your program does something strange like destructure a character.

I use pretty complex algorithm to solve sudoku puzzles at Online Sudoku Solver. Just out of curiosity, how much time does this brute force solve take ? Would be great if we compare the timings.

Just came across ursala and ok the abbreviated syntax looks very hard to decipher. On the other hand, I think there's lots of things of interest in the documentation -- carl touched on a bit above.

* Accessors into data structures mirror the shape of structures themselves. Moreover, there are machine-level "pseudo-pointers" that give, e.g. alternating items of lists etc. So there's a whole mini-language purely for deconstruction.

* The type language is equally powerful. Type expressions can generate random data automatically -- i.e. built-in quickcheck. Native types for grids and lattices are also of interest. Different types can be applied as "views" to the same raw data structure underneath.

I'm sure there's other stuff as well -- but from a PL standpoint those two jumped out at me.

johnwcowan, lodi, and sean crack me up.

el-vadimo: Have you ever seen the 4th.CoSy project? I heard about it, but never got it to compile code.