the details are in there : https://tel.archives-ouvertes.fr/tel-01947309/document
..The problem is the prefix-only calling convention that requires a back-and-forth movement of the cursor, and causes the expression to expand leftwards, opposite of the direction of the user’s typing.
While some languages have some support for linear composition using operators such as Clojure’s arrow macros or OCaml’s |> operator, the integration of these macros with the underlying subsystem is shallow.
I question this last statement.
Just this weekend I was reading about Hy's (based on Clojure's) threading macros:
"Threading macros, also known as arrow macros, convert nested function calls into a linear flow of function calls"
-> (or the threading macro) is used to avoid nesting of expressions. The threading macro inserts each expression into the next expression’s first argument place.
->> (or the threading tail macro) is similar to the threading macro, but instead of inserting each expression into the next expression’s first argument, it appends it as the last argument.
At least to me this seems far from "shallow" and even more useful/flexible than the pipeline operator.
(which is cited on the first page of the thesis!)
I hope that Oil can a lot of these things in a backward compatible way, but I still have to read it and understand it more.
It gives you a more readable and concise way to select a colum, split it and sau snip out few characters.
Thanks for sharing.
1.4 The Desktop-Scripting Problem
Related to the shell-language design problem is the desktop-scripting problem:
How should unrelated programs written in different languages be integrated—especially
in an ad-hoc manner in a desktop environment? Such a task can require a large
amount of glue code, written by users who are unfamiliar with the inner workings of
the programs they are using. Notable attempts at solving the desktop-scripting prob-
lem include the TCL language [Ousterhout, 1989] and Guile Scheme [Blandy, 1998].
However, while most of these approaches use a large, robust language, it still remains
difficult to integrate them with external programs—instead putting the burden on
those programs to integrate with their system. We believe a shell-based approach is
Remember that Scheme is not the lambda calculus -- you need dynamic types like integers, strings, vectors, hash tables, IO, etc. to get anything done.
In contrast in Julia they said that the semantics of numbers are defined in Julia. Julia has a much richer notion of number than any other language AFAICT, e.g. int8 .. int128, uint8 .. uint128, vectors of those, matrices of those, rationals, etc. They're all on the "same level" -- there aren't primitives vs. libraries, as far as I know.
I'm serious - this isn't Joke 101, but this is Marketing 101 in some respects.
Plus, as jpfed says below: The twist here is that this language doesn't use actual pipes; it just creates representations of pipes that can be used by a different interpreter.
Some computations just want to be imperative. IMO, if you can avoid developing programming fetishes; power to you.
Side note: here's another "Magritte" from 1983: http://reports-archive.adm.cs.cmu.edu/anon/scan/CMU-CS-83-13.... Is there a connection?
Here's another one: the Magritte meta-description framework for Squeak Smalltalk, often used with the Seaside continuation-based web framework:
"| ceci n'est pas une pipe"