~jojo/Carth

ref: 2f51b9e5dee555fe4f5bd58e80d9ccea5bac09eb Carth/CHANGELOG.org -rw-r--r-- 3.9 KiB
2f51b9e5JoJo Release 0.3.0. Update CHANGELOG & bump version 1 year, 6 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
* 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.