~jojo/Carth

Carth/CHANGELOG.org -rw-r--r-- 5.4 KiB
74920802JoJo update TODO 2 months ago
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
* v0.4.0
  - Generate rudimentary DWARF debugging information. GDB is now much
    more usable for debugging Carth. Can now view stacktraces with
    source locations and see where in the source we are when running
    ~gdb~ with ~-tui~. Can also step source line-by-line, although
    this is not completely practical as we don't have sequential
    statements but rather trees of expressions.
  - Add subcommand `version`, which simply prints the package version
    and the commit of the particular build.

* v0.3.1 <2020-01-10>
  Pattern match on strings and uninhabited types

  - String literals may be used as patterns, which generates to
    string-equality tests with the matchee.
  - Uninhabited types may be pattern matched on, which is absurd and
    can be used to imply anything.
  - Character literals are removed, as there is not actually any good
    canonical definition of what a character should be. Is it a
    codepoint? An ASCII byte? A grapheme cluster? To avoid ambiguity
    and possible confusion I simply removed it completely.
  - ~undefined~ now panics instead of recursing until stack-overflow.
  - Various updates to the standard library.
  - Environment variables of library path to search for core in, and
    module path to search for modules in are now read at runtime
    instead of when Carth is compiled. This is more dynamic, and will
    probably play better with Guix in the future.
  - Change license to AGPL version 3 *or later*

* v0.3.0 <2020-01-07>
  Make runnable on others systems & impl C calling convention

** Make runnable on others systems
   Remove hardcoded paths & make the build procedure more general with
   a Makefile with configurable variables. Now anyone can simple clone
   the repo and run ~make install~ to get a properly built and working
   ~carth~!

** Add basic import system
   Very rudimentary. Not much more fancy than C-style copy-paste
   ~include~.

   E.g. ~(import std)~ where ~std.carth~ or ~std.org~ is either in the
   same directory as the file being compiled, or in the global module
   directory, which is set when compiling Carth and defaults to
   ~~/.carth/mod~.

** Reimplement foreign-core lib in Rust
   Also add a bunch of functions to it, like ~-str-append~,
   ~display-inline~, ~add-int~, ~-panic~, and more.

** Link with foreign definitions using the ~extern~ special form
   E.g. ~(extern -panic (Fun Str Unit))~

** Implement C calling convention
   Carth functions now follow the C calling convention, passing things
   by reference and returning via register when appropriate,
   etc. Interfacing with foreign C/Rust/etc code is now almost trivial!

   According to ABI, bools are now ~i8~ instead of ~i1~.

** Remove interpreter
   Not much point in keeping it, since it's not compatible with FFI
   as-is. Maybe we'll reimplement it based on LLVM JIT at some point.

** Allow irrefutable patterns as function parameters
   E.g. ~(define (fst (Pair a _)) a)~

** Add more primitive integral types
   ~Nat8~, ~Nat16~, ~Nat32~, ~Nat~, ~Int8~, ~Int16~, ~Int32~.

** Add ~Box~
   Like the old ~Ptr~, but smarter. Also add the special form ~box~
   put a value on the heap, and ~deref~ to dereference a box.

   Also allow ~Box~ as a special kind of destructor in patterns. Works
   as you'd intuitively expect, and dereferences behind the scenes.

** Add some builtin datatypes
   In Carth syntax:
   #+BEGIN_SRC carth
   (type (Array a) (Array (Box a) Nat))
   (type Str (Str (Array Nat8)))
   (type (Pair a b) (Pair a b))
   #+END_SRC

** Generate strings as newly added datatype ~Str~

** Scale datatype tag size by the number of variants
   - 1 variant => no tag,
   - 1 to 256 variants => 8-bit tag,
   - 257 to 65536 variants => 16-bit tag,
   - etc.

** Check that datatype definitions are not recursive without indirection

** Allow wildcards in patterns
   They were treated as variables of name ~_~ before, but duplicate
   variable pattern bindings are not allowed!

** Allow integer and boolean literals in patterns

** Generated better and more readable LLVM
   - More readable name-mangling.
   - Perform beta-reduction.
   - Other minor improvements that add up!

** Rename the user-defined entry-point function ~main~ to ~start~
   Otherwise we have two ~main~:s, and it got messy. Now the
   codegenerator generates an "outer" ~main~ which does some stuff,
   and the user defines ~start~.

** Remove ~tail~ modifiers in codegen
   I thought just marking a call as ~tail~ would do no harm if the
   call was not in tail recursion, but it did!

** Implement ~sizeof~ ourselves!
   The previous method that ran in the ~EncodeAST~ monad was messy and
   stopped working when I needed ~mfix~ for a cyclic binding.

** Verify LLVM module before compiling to catch more errors

** No longer allow square brackets in place of parentheses

** Various bugfixes

* v0.0.2 <2019-10-30>
  Trying out releases -- this is the first one, more or
  less. Everything has been in such heavy development until now (and
  still is really, but it has calmed down slightly), so this feels
  like the first appropriate moment to make a release.

  Nothing is ready to use yet, of course, but many of the core
  components are here. We have parsing with megaparsec, Hindley-Milner
  typechecking, algebraic datatype definitions and pattern matching
  with exhaustiveness and redundancy checking, closures,
  interpretation, and LLVM code generation.

  Next up is modules, typeclasses, etc etc.