GitLab

Wrote quite a bit, but section both far from done & good.

Introduced some new TeX macros for easily differentiating
between haskell code which is part of the program, and which
is only part of the document text.

Fixed up AstHaskell quite a bit, added some better type declarations.
Added a whole bunch of TODO's.

Also started prototyping on the RPC monad, which will be an extension of
the IO monad, and needed for the remote procedure calls (RPC).

A file about how we best convert from BNF to Haskell.

I however don't know if the the document compiles
correctly with them yet. Currently on a system
without LaTeX installed.

Having Ast.lhs be compiled from a .htex file would
be a good future improvement, since then the sample
output could always be in sync with the source code.
It does however come with the drawback that HaTeX and
HaskInTeX would be required for building the document.

rpcParser is actually rather ok to look at now. Instead of being the
worst function of the entire program.

Rewrote most of the text in Notation.lhs, along with some
minor changes to the actual code.

Also changed heading levels one down in TeX and added some extra text in
some places.

Changed all lhs files to be on TeX form.

Created a LaTeX main file which sources everything and puts it into a
document.

Started writing a bit about how to implement the remaining
types. But it's not that good and there still is a lot todo.

Added a parser which binds together all the other parsers.
Can "almost" parse the entire document"

I started testing my parsers against the actual BNF file. And found
quite a few problems. Most of them should be solved by now.

Updated RPC.lhs to parse Async requests
in addition to "Normal" requests.

Added a bunch of miscellaneous parsers, mostly so parsing an
entire document can be a reality sooner.

Added some help functions for padding whitespace and parsers
with delimiters surrounding them. I'm however not compleatly
sure that they all stil work exactly as intended. Since I
haven't written any tests.

RPC requests and returns actually had on optional type. So that's fixed
now...

Moved the small helper functions from Notation.lhs to Helpers.lhs, as
well as introduced the new `eol` helper.

Added a short description of the structure type in Datatype.lhs.
It needs to be expanded quite a bit.

Wrote the parser. As well as a bunch of documentation on how it probably
should work.

After actually reading the whole "Simple Data Types" page of the
documentation I noticed that types on the form

    ( name : type ;
      name : type ;
    )

Actually had the name structure. So I updated the parser to match.

At the same time I also changed the parser in question to parse a
type binding, instead of two words.

Added description for why both LysType and TypeFiled exists.

Notation.lhs is now its own module,
I also removed the debug stuff at the very end.

When looking at RPC notation I realised the need for a type without a
binding. So I split up DerivedType into two components.
I also realised that primitive types and derived types are both types,
and should therefor be treated equally.

Notation.lhs still contains quite a bit of text refering to derived
types, so it should be updates once I have a better understanding of
how things go together. Together with the energy to actually do stuff.

Added some text about RPC notation. No code yet do the need to change
Notation.lhs first. See RPC.lhs#16

Much more information about how selections "probably" work. Along with a
parser for reading the BNF of a selection DECLARATION. Some minor
rewrites also to allow better nested structures. And parsing of ARRAY
types.

It's now possibly to parse ENUMERATION declarations from the BNF file.
Note that ENUMERATION-OF is still lacking since SELCTION isn't yet
implemented.

Just a file rename, together with the module declaration line.

Added the Notation file, which is subject to a name change.

Wrote most of the code for parsing derived types. The documentation for
it is however still quite lacking.

In the future the plan is to incorporate Template Haskell, and create
parsers for each derived type.

Added short text about selections, which
just said that we don't have them yet.

I decided to actually put my work under version control.
So far I have re-documented multiple types. As well as
written parsers for them.