syndicate-lang
/
syndicate-rkt
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Tweaks; python mapping

This commit is contained in:
Tony Garnock-Jones 2018-09-24 18:34:07 +01:00
parent 3b12a290a3
commit e438085e74
1 changed files with 29 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
syndicate/mc/preserve.md
View File

@ -171,7 +171,7 @@ indicates `SignedInteger`s, not `Float`s or `Double`s.
### Records. ### Records.
A `Record` is a *labelled* tuple of zero or more `Value`s, called the A `Record` is a *labelled* tuple of zero or more `Value`s, called the
record's *fields*. A record's label is, itself, a `Value`, though it record's *fields*. A record's label is itself a `Value`, though it
will usually be a `Symbol`.[^extensibility] [^iri-labels] `Record`s will usually be a `Symbol`.[^extensibility] [^iri-labels] `Record`s
are compared lexicographically as if they were just tuples; that is, are compared lexicographically as if they were just tuples; that is,
first by their labels, and then by the remainder of their fields. We first by their labels, and then by the remainder of their fields. We
@ -180,7 +180,7 @@ sequence of their label `Value` followed by their field `Value`s.
[^extensibility]: The [Racket](https://racket-lang.org/) programming [^extensibility]: The [Racket](https://racket-lang.org/) programming
language defines language defines
[“prefab”](http://docs.racket-lang.org/guide/define-struct.html#(part._prefab-struct)) “[prefab](http://docs.racket-lang.org/guide/define-struct.html#(part._prefab-struct))”
structure types, which map well to our `Record`s. Racket supports structure types, which map well to our `Record`s. Racket supports
record extensibility by encoding record supertypes into record record extensibility by encoding record supertypes into record
labels as specially-formatted lists. labels as specially-formatted lists.
@ -828,12 +828,12 @@ should both be identities.
### JavaScript ### JavaScript
- `SignedInteger` ↔ numbers or `BigInt` [[1](https://developers.google.com/web/updates/2018/05/bigint), [2](https://github.com/tc39/proposal-bigint)] - `Boolean` ↔ `Boolean`
- `Float` and `Double` ↔ numbers
- `SignedInteger` ↔ numbers or `BigInt` (see [here](https://developers.google.com/web/updates/2018/05/bigint) and [here](https://github.com/tc39/proposal-bigint))
- `String` ↔ strings - `String` ↔ strings
- `ByteString` ↔ `Uint8Array` - `ByteString` ↔ `Uint8Array`
- `Symbol` ↔ `Symbol.for(...)` - `Symbol` ↔ `Symbol.for(...)`
- `Boolean` ↔ `Boolean`
- `Float` and `Double` ↔ numbers,
- `Record` ↔ `{ "_label": theLabel, "_fields": [field0, ..., fieldN] }`, plus convenience accessors - `Record` ↔ `{ "_label": theLabel, "_fields": [field0, ..., fieldN] }`, plus convenience accessors
- `(undefined)` ↔ the undefined value - `(undefined)` ↔ the undefined value
- `(rfc3339 F)` ↔ `Date`, if `F` matches the `date-time` RFC 3339 production - `(rfc3339 F)` ↔ `Date`, if `F` matches the `date-time` RFC 3339 production
@ -843,12 +843,12 @@ should both be identities.
### Scheme/Racket ### Scheme/Racket
- `Boolean` ↔ booleans
- `Float` and `Double` ↔ inexact numbers (Racket: single- and double-precision floats)
- `SignedInteger` ↔ exact numbers - `SignedInteger` ↔ exact numbers
- `String` ↔ strings - `String` ↔ strings
- `ByteString` ↔ byte vector (Racket: "Bytes") - `ByteString` ↔ byte vector (Racket: "Bytes")
- `Symbol` ↔ symbols - `Symbol` ↔ symbols
- `Boolean` ↔ booleans
- `Float` and `Double` ↔ inexact numbers (Racket: single- and double-precision floats)
- `Record` ↔ structures (Racket: prefab struct) - `Record` ↔ structures (Racket: prefab struct)
- `Sequence` ↔ lists - `Sequence` ↔ lists
- `Set` ↔ Racket: sets - `Set` ↔ Racket: sets
@ -856,19 +856,22 @@ should both be identities.
### Java ### Java
- `Boolean` ↔ `Boolean`
- `Float` and `Double` ↔ `Float` and `Double`
- `SignedInteger` ↔ `Integer`, `Long`, `BigInteger` - `SignedInteger` ↔ `Integer`, `Long`, `BigInteger`
- `String` ↔ `String` - `String` ↔ `String`
- `ByteString` ↔ `byte[]` - `ByteString` ↔ `byte[]`
- `Symbol` ↔ a simple data class wrapping a `String` - `Symbol` ↔ a simple data class wrapping a `String`
- `Boolean` ↔ `Boolean`
- `Float` and `Double` ↔ `Float` and `Double`
- `Record` ↔ in a simple implementation, a generic `Record` class; else perhaps a bean mapping? - `Record` ↔ in a simple implementation, a generic `Record` class; else perhaps a bean mapping?
- `(mime T B)` ↔ an implementation of `javax.activation.DataSource`?
- `Sequence` ↔ an implementation of `java.util.List` - `Sequence` ↔ an implementation of `java.util.List`
- `Set` ↔ an implementation of `java.util.Set` - `Set` ↔ an implementation of `java.util.Set`
- `Dictionary` ↔ an implementation of `java.util.Map` - `Dictionary` ↔ an implementation of `java.util.Map`
### Erlang ### Erlang
- `Boolean` ↔ `true` and `false`
- `Float` and `Double` ↔ floats (unsure how Erlang deals with single-precision)
- `SignedInteger` ↔ integers - `SignedInteger` ↔ integers
- `String` ↔ tuple of `utf8` and a binary - `String` ↔ tuple of `utf8` and a binary
- `ByteString` ↔ a binary - `ByteString` ↔ a binary
@ -876,13 +879,28 @@ should both be identities.
some kind of an "unsafe" mode is set on the decoder (because Erlang some kind of an "unsafe" mode is set on the decoder (because Erlang
atoms are not GC'd); otherwise perhaps a tuple of `symbol` and a atoms are not GC'd); otherwise perhaps a tuple of `symbol` and a
binary of the utf-8 binary of the utf-8
- `Boolean` ↔ `true` and `false`
- `Float` and `Double` ↔ floats (unsure how Erlang deals with single-precision)
- `Record` ↔ a tuple with the label in the first position, and the fields in subsequent positions - `Record` ↔ a tuple with the label in the first position, and the fields in subsequent positions
- `Sequence` ↔ a list - `Sequence` ↔ a list
- `Set` ↔ a `sets` set (is this unambiguous? Maybe a [map][erlang-map] from elements to `true`?) - `Set` ↔ a `sets` set (is this unambiguous? Maybe a [map][erlang-map] from elements to `true`?)
- `Dictionary` ↔ a [map][erlang-map] (new in Erlang/OTP R17) - `Dictionary` ↔ a [map][erlang-map] (new in Erlang/OTP R17)
This is an unsatisfactory mapping: it conflates `"hello"` with `(utf8 #"hello")`,
and `true` with `#t`.
### Python
- `Boolean` ↔ `True` and `False`
- `Float` ↔ a `Float` wrapper-class for a double-precision value
- `Double` ↔ float
- `SignedInteger` ↔ int
- `String` ↔ `unicode`
- `ByteString` ↔ `bytes`
- `Symbol` ↔ a simple data class wrapping a `unicode`
- `Record` ↔ something like `namedtuple`, but that doesn't care about class identity?
- `Sequence` ↔ `list`
- `Set` ↔ `set`
- `Dictionary` ↔ `dict`
## Appendix. Why not Just Use JSON? ## Appendix. Why not Just Use JSON?
<!-- JSON lacks semantics: JSON syntax doesn't denote anything --> <!-- JSON lacks semantics: JSON syntax doesn't denote anything -->
@ -1041,8 +1059,6 @@ encodings that are irrecoverably ambiguous.
Q. Should "symbols" instead be URIs? Relative, usually; relative to Q. Should "symbols" instead be URIs? Relative, usually; relative to
what? Some domain-specific base URI? what? Some domain-specific base URI?
Q. Are the language mappings reasonable? How about one for Python?
Q. Literal small integers: are they pulling their weight? They're not Q. Literal small integers: are they pulling their weight? They're not
absolutely necessary. They mess up the connection between absolutely necessary. They mess up the connection between
value-ordering and repr-ordering! value-ordering and repr-ordering!