orcmid
commented
6 years ago Question Closed
I misled myself and @rnd0101 in consequence. The straightforward handling of ob-exp, and the proper grammar for it, are all now resolved in Question #8, oFrugal Grammar?, and Question #14, Resolving oFrugal Applicative-Expression Grammar.
The following discussion attempts to clear the misunderstanding I created about a separate eval stage between read and print with the REPL. Formally, eval happens as part of the read ob-exp interpretation of the syntax. While there might be internal separation to avoid actual computations until after the parse is successful, the formal specification is more direct when presented as if the computations occur with the parsing. A sophisticated parser would do better to ensure the complete input is well-formed before carrying out the specified constructions.
The discussion is here for historical purposes. The conclusions are reflected directly in the #8 and #14 questions.
Oh, Oh
@rnd0101 So far my understanding was, that Miser evaluates a script (on the left) and applies to "data" on the right, but "data" can be script's "commands". What am I doing wrong?
I think the problem is assuming that some sort of text substitution is involved in the rules for applicative-expression evaluation and for applicative interpretation.
- It is the case that the ob that results from an obap.ap(p,x) can then be employed as data and/or script. The way it is used as a script is in something like obap.ap(obap.ap(p,x), y) or indirectly after incorporation in some further data.
- This might seem like text substitution but everything is accomplished by applicative operations. There is nothing equivalent to pasting a result into the "text" and rescanning as procedure as part of applicative-expression interpretation.
Checking Combinators
I started those to figure out how can I evaluate combinators in Miser. That is, given S, K, I definitions, how to build something like (SK)(KS) and apply to the data / combinators. Can't find syntactical way for that.
Supposing you have cS and cK, expressed as canonical obs such that
- ap(ap(ap(cS, x), y), z) = ap(ap(x,z),ap(y,z)
- ap(ap(cK, x), y) = x
then it works to construct a combinator-representing ob via
- ap( ap(cS, cK), ap(cK,cS) ) =cSKcKS
so then
- ap(cSKcKS, x) = ap( ap(cK,x), ap(ap(cK,cS),x) ) = x
The way to express these two stages are
- ( ‵(cS) ‵(cK) ) ‵(cK) ‵(cS)
- ( ( ‵(cS) ‵(cK) ) ‵(cK) ‵(cS) ) ‵(x) = ‵(cSKcKS) ‵(x) = x
Here There Be Dragons
The oFrugalese REPL suggestion (from Question #7 comment) would look something like
> ob cS = .C :: ‵.C :: (.C :: (.E :: (.C :: (.E :: .ARG) :: ‵.ARG))
:: ‵(.C :: (.E :: .ARG) :: ‵.ARG) ) ;
> ob cK = .E :: .ARG ;
> ob cSKcKS = @cS @cK ;
> @cSKcKS X;
Xand here might be the problem. There should be no eval in the cS and cK ob statements, just ob construction. Eval would fail if carried out on given ob as expressed since those obs are designed to be used, as written, as ap operator scripts. This means that application is not signified by :: for the above to work. (Apology: I must stop saying that that eval is used on the ob that is expressed. It might be used, but it yields the ob as expressed from an intermediate form created for that purpose. I shouldn't be muddying the waters with that, especially since I led myself astray with such carelessness.)
The REPL expression and its computation of an ob needs to be a bit more elaborate than running eval on the whole thing. The evaluation in the two final statements use applicative notation, not because of the @ but because of the juxtaposition and those applications are carried out via an eval of that part (there the only parts) of the ob formulation. Here, note that @cS @cK is read and evaluated the same as @cS(@cK).
NOTE 1: It must be kept clear that ‵(x) is not the same as the LISP QUOTE. It's more like an enquote operator, in that enclosures, once formed, are evaluated as the enclosed item without further (immediate) evaluation.
NOTE 2: The @ notation is a bit clunky here. Any ideas?
NEXT STEPS
I am reworking some material to deal with the need to interpret REPL input expressions a bit more carefully. I still like the idea of translating to an ob and running eval on it as a kind of semantics, but it is not that simple. In particular, that might be a reference implementation, but not a great way to teach writing REPL statements. And, I think, the semantics of the input expressions is easier to state than that.
The REPL input will be presented as a precedence language, with
- element level of primitives, lindies, \@name and ( ob-exp ) at the lowest level.
- singleton level 0 and ‵ on level 1 at the next level
- application level 1 and level1 level 2 (separated by spacing if not bracketing) at the applicative level
- pairing level 2 and level2 :: level3 above that.
- ob-exp level 3 and level 3 == level 3 above that (because of tradition and emphasis on extensional identity)
There will be additional syntax to accomodate [a1, ..., an] notations and also the different ways of parenthesizing in applicative expressions.
rnd0101
In the following plain
.Dis not equivalent to.A .D .B, even though.A .D .Bevaluates to.D:Here is one answer for this:
https://github.com/orcmid/miser/issues/7#issuecomment-357468310 but discussion moved here.
The proposed addition of enclosures
((.A .D .B) ‵("x" ‵("y" "z")) ‵("x" ("y" "z"))) ("eq" "neq")does not solve the problem: result is still.B.Construct like, again, when evaluated alone:
seems to handle all possible situations with .A and .B and .D.
But when it textually substitutes
.Din the larger expression,.Dstops to work.I am not sure if it's implementation or theory issue. Or maybe it's not the way miser supposed to perform evaluations, but how can I then apply applicative part (the .A .D. .B) to the data? And how to compose more complex applicative expressions?
So far my understanding was, that Miser evaluates a script (on the left) and applies to "data" on the right, but "data" can be script's "commands". What am I doing wrong?
I started those to figure out how can I evaluate combinators in Miser. That is, given S, K, I definitions, how to build something like
(SK)(KS)and apply to the data / combinators. Can't find syntactical way for that.