Why didn't ML ever 'shine'?

[n***@gmail.com]

Since ML is so old/mature, I'm surprised that it never
took the lime-light.

What can lisp/scheme do that ML can't do with a
better: left-to-right read syntax?

After decades of grovelling down at semi-asm level,
I was astounded at the ease and power of *nix piping,
which seems ideal for ML to also do.

One of my favourite examples is to find that important
file that you were reading before you went on leave,
which was about string1, string2 and string3.
How would ML do it?
ListAllFilesIn( Dirtree DaysOld); Dirtree -> ListOfFiles
ListAllFilesContaining( string1); ListOfFiles -> ListOfFiles
ListAllFilesContaining( string2); ListOfFiles -> ListOfFiles
ListAllFilesContaining( string3); ListOfFiles -> ListOfFiles

The functions can have only single args?
So you just put the 'components' in a tuple?
Which even LOOKS like the old-imperative syntax?
And passing the args as a single action is better, conceptually,
than forth-like, pushing them individually.
What about passing (nested(functions))as components of the
(1-tuple arg) when the lispy syntax is tollerable?

Languages like 'joy' claim the be suitable for formal
proofs, because they have <algebraically manipulable>
syntax. But I've NEVER seen ONE example of formal
proof with any language. Does ML have any examples?

Do any of the ML implimentations have Regex facilities?
Or can they 'hook into' *nix facilities?

== TIA.

[Nobody]

Post by n***@gmail.com
Since ML is so old/mature, I'm surprised that it never
took the lime-light.
What can lisp/scheme do that ML can't do with a
better: left-to-right read syntax?

The code-is-data aspect of Lisp is an advantage for writing
domain-specific languages.

[n***@gmail.com]

Post by Nobody

Post by n***@gmail.com
Since ML is so old/mature, I'm surprised that it never
took the lime-light.
What can lisp/scheme do that ML can't do with a
better: left-to-right read syntax?

The code-is-data aspect of Lisp is an advantage for writing
domain-specific languages.

Yes, code-is-data-is-code allows develishly convoluted acrobatics.
When I started coding I wrote mostly convoluted code.
Often I had to put myself into a yoga-like-trance-state to
understand it during development.

Later when I realised that revisiting my own code needed
massive effort, I discovered visual-guidance, where you
recognise, instead of remembering: like linux:mc.

Then I discovered <*nix shell> where you almost fraudulently just say:

giveMe FileX;
butOnlyLinesContaining <keyString>;
butOnlyThe 4th;
butOnlyTheWhiteCharSeparatedWords 1 3 5;
AndConcatenateThoseWithSeparatorChar ":" ;
AndAppendThatTo FileX;

Since *nix has a rather hacked syntax, it seems that
the same serially-transforming-data paradigm via ML
would be even better.

== Chris Glur.

[George Neuner]

Post by n***@gmail.com

Post by Nobody
The code-is-data aspect of Lisp is an advantage for writing
domain-specific languages.

Yes, code-is-data-is-code allows develishly convoluted acrobatics.
When I started coding I wrote mostly convoluted code.
Often I had to put myself into a yoga-like-trance-state to
understand it during development.

It's not about high-flying acrobatics ... mostly it's about JIT
compilation. In Lisp (or Scheme) the compiler is available at
runtime, so a DSL can translate the foreign language to Lisp and
compile rather than interpreting.

I get the sense that you know this, but your comment leads in a
strange direction. 8-)

Post by n***@gmail.com
== Chris Glur.

George