edechter
commented
7 years ago As I mentioned in the email on the swipl mailing list, I have implemented this using attributed variables, as Jan suggested. The pack is here. In addition, I've implemented some syntactic sugar for that tries to be as similar to your suggestion here as possible. But since _{...} is not a valid dict, for now the syntax is _{... : ...} (spaces required). I'm open to alternatives. I use the function_expansions library to implement this. And I also use it to implement that open dict key paths as you suggest, but I use the operator .^ instead of ^ so as not to conflict with other uses of ^.
So with the current syntactic sugar choices, the synopsis of the functionality is:
?- use_module(library(open_dicts)).
?- A = _{a: 1, ... : ...}, B = _{b : 1, ... : ...}, A = B.
A = B,
open_dict(_104{a:1, b:1}, B).
?- A = _{a: X, ... : ...}, contains(A, [a-1, b-2]).
X = 1,
open_dict(_3520{a:1, b:2}, A).
?- A = _{a:Val, b:2, ... : ...}, B = _{a:1, c:3, ... : ...}, A = B.
A = B,
Val = 1,
open_dict(_4266{a:1, b:2, c:3}, B).
?- A = _{a:Val, b:2, ... : ...}, B = _{a:1, c:3, ... : ...}, A = B, close_dict(B).
A = B, B = _50{a:1, b:2, c:3},
Val = 1.
?- A = _{a: _{b:1, ... : ...}, ... : ...}, B = A.^a.^b.
B = 1,
open_dict(_1430{a:_1434}, A),
open_dict(_1450{b:1}, _1434).
?- A = _{a: _{b:X, ... : ...}, ... : ...}, A.^a.^b = 1.
X = 1,
open_dict(_5378{a:_5382}, A),
open_dict(_5398{b:1}, _5382).
torbjornlager
Qqwy
esad
JanWielemaker
Here is a proposal for sideways open dicts to complement the currently existing dicts (which we will refer to as closed dicts). Our point of departure is the following quote from the manual at http://swish.swi-prolog.org/pldoc/man?section=dicts:
A dict is a structured compound datatype. A closed dict has a tag and a fixed number of pairs of keys and values. Two dicts unify, even if their key-value pairs comes in a different order:
There is a path notation that allows us to select individual values if we have the key:
If the key does not exist, an exception is thrown:
Dicts can also be open. Two open dicts unify if their tags and the values associated with common keys unify, turning both dicts into a new dict that has the union of the keys of the two original dicts.
To keep dicts maximally useful, we are going to need both open and closed dicts as well as ways to convert between them. Our suggestion is to use the notation
foo{a:1, b:2, ...}for open dicts.Unification of two open dicts results in an open dict:
Unification of a closed dict with an open dict results in a closed dict:
With open dicts the path notation should work like so, rather than throwing an exception:
Note that the path notation uses
^rather than a dot (.) when we are dealing with open dicts. As we saw above, having two different path languages is probably necessary.[1]We should be able to close an open dict:
and open a closed one:
We illustrate with an example from computational linguistics. A Definite Clause Grammar (DCG) is a unification-based grammar that uses Prolog terms to represent syntactic categories. In a term-based grammar formalism, the structure of a syntactic category is determined by the predicate symbol, the arguments, and the order of the arguments.
In a feature-structure based formalism, the structure of a category is defined by its features and their values. The value of a feature may be any element, either atomic or complex.
It is easy to see that we can use open dicts instead of terms when parsing and generating with ordinary DCGs. The following is a so called unification-based grammar for a tiny fragment of English. The use of feature structures implemented as the open dicts guarantees number agreement between the subject and the verb of a sentence:[2]
An example run:
[1] We are also inspired by the Oz programming language, which boosts open as well as closed records with two different path languages, with a functionality very similar to the one that our open and closed dicts give us.
[2] The grammar example is borrowed from Stuart Shieber, see https://dash.harvard.edu/handle/1/11576719.