obapx: Construction Diary & Job Jar
c000000>
2024-02-12 -13:37 -0800
46
|
|
obapx: Construction Diary & Job Jar |
|
Status |
Date |
Description |
|
| done | 2024-01-31 |
|
|
| 2024-02-06 | I think struct! is getting close to what we would want for environments, but not completely yet. It does seem to be the case that one could do a with! that inserts a kind of monad pair. This is pretty foggy here. I need to be tip-toe around this. | ||
| 2024-02-06 | I am also musing about creation of structures of various kinds. So, in addition to struct!(s) where s is taken as a shape/form, and form!(struct!(s)) is a (normalized) s. The idea is to have a with operation such that the infix struct!(s) with!(t) yields a new struct! consisting of t merged into s by matching the forms, adding new elements where there is not already one in s and replacing other elements whose identifiers match. If one wants to make deletions without knowing what others might be, without! seems appropriate. For CFob, we only need to display struct!(s) with the CFob of s. These remain conservative extensions, yet provide a means to sugar things like let, where, and also a limited multiple assignment. I don't think this gets at compute expression, but it comes close. What we haven't said is what is the applicative interpretation of struct!(s). I think the form labels its constituents (with lindies generally), and struct!(s).label is the value-side of such a component in the form, the components being label :: value pairings. | ||
| 2024-02-06 | index.md and elsewhere: If I am going to use proc!(p) in oFrugal, I should use the form elsewhere, perhaps. The ! is special in Ot, but I think the singular use has to with expressions in CFob that determine (anonymous but distinct) individuals from larger forms. | ||
| 2024-02-05 | index.md and proc!: It appears that proc!(proc!(p)) should be no different than proc!(p). So a fixed-point and so another way to determine that a proc! is in hand. The question becomes whether we break something by exploiting that (extensional?) case. [dh:2024-02-06 taking my own advice about proc! usage.] | ||
| 2024-02-03 | The introduction of quasi-conservative extensions has strong impacts on CFob and also oFrugal. It is unclear what reasonable cases can be handled by something like "compute expressions." | ||
| 2024-02-03 | Distinction of a pseudo-random number generator and of a random-number source are great examples of important cases. How these are expressed in Ot, and how they might be generalized, especially in terms of interactions, is the next challenge. | ||
| 2024-02-01 | handling of shapes, although seemingly higher-level, might be important to enshrine with an extension, especially with regard to stateful operations | ||
| 2024-01-31 | index.md Might want to explain how the proc!/def! technique is only similar to QueryInterface and there remains the notion of somehow providing a kind of reflection this way, nonetheless. This may follow into the run-time in interesting ways as well. [dh:2024-02-06 changing to use ! generally. Technically, def! does not need a special form, since it will not appear in a CFob. We are doing this to make the pairing of the functions explicit, and perhaps distinct in oFrugal although they are just as easily handled with the corresponding primitives. So this may just be sugar for pointing out the extension condition and the involvement of extended individuals.] | ||
| 2024-01-31 | Thinking about shapes has me think about how things like proc work as an oMiser extension. there's a weird hack that has the def check be a kind of type check. This allows typed things to be individuals and the check on them has to do with whether or not the check operations returns the ob itself or something not the ob itself, but related to its definition. This is a bit like the COM request of an interface, with the wrinkle that if the interface is not known, you get the interface you asked with. So you can tell that way. This is a very peculiar variant on the structural distinction of individuals, enclosures, and pairs. I don't know how that didn't occur to me until just now, even though I have thought about this before. | ||
| 2024-01-31 | Today I started thinking about forms and shapes (see 01-06 below). My fancy is to consider shapes by exhibition of something that is an exemplar. There is clearly more to it, because we need to name/identify shapes and their elements. And we also need to specify a cast or some other indication of representations needed at places in a form. This leads to some sort of canonical form that serves as a template. This is very different than encapsulation, although there might be such components in a shape, so there's that also. This is all super-pragmatic because of labelling and the specifics of representations. At this point, my brain is hurting and I move on to cleaning up more of the refactoring. | ||
| done | 2024-02-04 | Un oh. If I use !proc, I run into an ambiguity in oFrugalese when the ! is at the beginning of a line. I need to use proc!. Fair enouth. | |
|
done 2024-02-04 |
2024-02-03 | Isn't it def, not dev? Get to the bottom of this. [dh:2024-02-04 Yup. It's def. Changing it.] | |
|
done 2024-02-04 |
2024-02-03 | index.md: Explain that proc and def are bold-faced because they may involve special forms. Although they can be treated as pre-defined applicative forms. The tricky part is that a CFob needs to show the the proc with the def, not as an applicative operation. In CFob, we don't care about def. But we need to show that an ob is the def value of a proc. This is handled by a proc-notation. This has to pass into and back out of oFrugal properly. maybe proc:( ... ) is the notation. This is easy in the CFob grammar. In oFrugal, it will also work, but the ... may be an ob-exp rather than a CFob. If the proc: notation is not pronounced enough, and .proc is also too subtle, !proc( ... ) might be preferred, with or without :. [dh:2024-02-04: This is about CFob. For obapx, there are two new primitives, obapx.proc and obapx.def whose applicative interpretations are to generate a proc individual and produce a def result, respectively. In a CFob, the terms are descriptive, not applicative even though the oFrugalese semantics is to establish the indicated proc. There is no distinct def form in CFob or oFrugalese, although the obapx.def primitive is available as an individual and for use in applicative-expression interpretation as def..] | |
| done | 2024-02-03 | index.md: Reflect my hesitancy concerning non-determinism and contingency. Having to know time, place, and device may be simply unreasonable. | |
| done | 2024-02-03 | I need to point out that there may be difficulties incorporating applicative extensions in Ot when there is some sort of non-determinism. This may make preservation of individual identity not possible and we have to cope with escaping from the theoretical into the empirical and contingent reality. I don't think it is necessary to go that far. There needs to be a way to account for it if I attempt to cross that bridge in some theoretically-treatable manner. | |
|
done 2024-02-03 |
2024-02-02 | The whole idea about extensions is that they can be under-cover of individuals so that it is all under the scheme even though highly pragmatic. | |
| done | 2024-02-01 | index.htm: Fix the table captions and ensure that the updated text is committed to GitHub | |
|
done 2024-02-01 |
2024-01-31 | index.md Introduce proc and explain the discovery technique and its rather interesting connection with the COM QueryInterface facility. Also it's harmony with the self-referential structural cases for individuals and enclosures. | |
|
done 2024-02-01 |
2024-01-31 | index.md: refer to the GitHub/Miser Discussions on current topics | |
| done | 2024-01-31 | index.md: Create Placeholder | |
| done | 2024-01-31 | Introduce a clean construction zone |
 |
You are navigating
construction material of the Miser Project |
created 2024-01-31T21:07Z by orcmid |