ff-notes / ron Goto Github PK

Example from ff:

    (ron_schema_edn [1 0]

        (opaque Status)
        (opaque NoteStatus)

        (struct_lww Tracked
            (provider    String)
            (source      String)
            (externalId  String)
            (url         String))

        (struct_lww Contact
            (status  Status)
            (name    RgaString)
            #Haskell {field_prefix "contact_"})

        (struct_lww Note
            (status  NoteStatus)
            (text    RgaString)
            (start   Day)
            (end     (Option Day))
            (tracked (Option Tracked))
            #Haskell {field_prefix "note_"})
    )

1. Decode EDN -> Schema
2. Macro to write EDN-schema inside Haskell file
3. Macro to write EDN-schema in external file

measure performance

(moved from cblp/crdt#22)

• find bottlenecks in Attoparsec implementation
• try FSM parser
  • #18
  • #19
• increase limits in tests

proposed by @gritzko

• ron (base model types and encoding)
• ron-rdt
• ron-schema
• ron-storage (#17)

Problem:

     +--> Arne --+
     |           |
     |           v
Bjorne           Annie
     |           ^
     |           |
     +-> Bonnie -+

Automatic character-base RGA merge may give words semantically misleading, contradicting human-written versions.

Proposed solution: generate ops using words.

     +--> Arne --+
     |           |
     |           v
Bjorne           ArneBonnie
     |           ^
     |           |
     +-> Bonnie -+

Unresolved questions:

1. Is it still possible to make misleading words?
2. What about misleading sentences made up from word-ops coming from different sources?

Clean up documentation first.

https://hackage.haskell.org/package/Earley

https://matrix.hackage.haskell.org/#/package/ron

Validate consistency of different RON implementations and their conformance to the Spec

Configure:

• spaces between fields, or tabs, or none
• newlines between ops
• skip keys
• skip parts of keys
• paren compression
• reduced op's trailing comma
• frame's trailing dot

Try to generate RGAs from a series of ops.

items = value items of composite types like RGA or OR-Set

Problem: LWW doesn't guarantee correctness in case of concurrent key adding.

Solution: ORSet of pairs (key, UUID-ref to value object)

• When multiple values, merge them according to their type
• When types differ... use the last (lww)?

https://hackage.haskell.org/package/scanner

Useful for RGA

1. Parenthesized chains
2. String chains

To allow Hackage build docs, https://hackage.haskell.org/package/ron-0.1/reports/

https://hackage.haskell.org/package/sexp-grammar

• add item — #58
  • insertAtEnd — #61
• remove item — #62

http://replicated.cc/

0. Keep compatibility with the current implementation
1. Remove stateVersion field #95
2. Add unprefixed atoms #75
3. Add raw ops 2.1 #72
4. Add frames 2.1: incrementing ops #73
5. Add op chains #42
6. Add RON-RDT-2.1 #74
7. Make 2.1 the default encoding
8. Deprecate 2.0

Write own string encoding.

Problem

A fresh timestamp may clash with existing.

Proposed solution

1. Ensure version id is (⩾) than all ops inside a version.
2. Make document versions readable as timestamps. (???)
3. On database open, advance time to all versions.

Add an abstraction level instead of playing around monad transformers.

if it has one

E. g. why Base32 is used and when.

and lift them to the application via OnDocumentChanged

and relax constraint on 'a' from 'ReplicatedAsPayload' to 'Replicated'

use approach from 'isUpperHexDigit'

So far, it's only a stub:

removeBy :: ([Atom] -> Bool) -> StateT (Object (ORSet a)) m ()
removeBy = undefined

and use it when no reducer found