Oh boy. It's working. See issue #83. Right now it's in a "the first properly working" state, so it still has work to do. The compiler-rewrite branch is now fully using this new one, there's no trace of the old, horrible switch-clause.

I will keep on improving it, most likely refactoring some parselets (I'm looking at you, queries and functions).

Feel free to ask anything about it, I'll try my best to justify my weird decisions for things. Do tell me if I forgot to implement something.

There's a bunch of tests related to the compiler that fail, not too sure what to do with them. Make test follow the new compiler, make compiler follow the tests?

You can merge this PR if you so wish, I'll keep working on this branch or on a new branch (something like compiler-improvement).

(I set the milestone to Rant 3 as the original issue had it as well.)

I ran the migrate-2017 cli to update to the new csproj format (minimum requirements is now VS2017), and changed the Rant lib to .Net standard.

Also changed the other projects to NET 4.7 (so it works with Standard)

I haven't tested this properly in production yet, but the 244 tests ran absolutely fine.

The only thing I had to change manually was the Post-build event command-line, since docpal seems to exit with 9009 (might just have something weird with the path there)

I'll comment on here if I find any issues after my changes.

And a huge thanks for making this in the first place! Such a cool idea 👍

I'm pretty glad .NET Core has matured a bit since this issue was posted, and allowed for a fairly quick and simple conversion.

The Rant console currently crashes when the standard input is either manually closed (e.g. CTRL+D in a linux terminal) or redirected. This happens because the input loop doesn't check for EOF, and as a result can pass a null string to PrintOutput.

The fix checks whether the string returned by Console.ReadLine is null, and returns gracefully if so.

I replaced the entire output system with a new, better system that uses a linked list to store outputs buffers. It is designed to be easily extended for upcoming features.

RantPattern's constructor uses GenerateTokens to split the given pattern into a lazy sequence of lexer tokens. When RantEngine.Do is called, it creates a new VM, which creates a new RantState, which creates a new PatternReader, which finally evaluates the given pattern's token sequence using .ToArray(). However, the results of the evaluation are not cached (IEnumerable won't do that automatically). This makes using RantPattern.FromString/FromFile mostly useless, since the pattern is parsed again and again for each iteration.

The performance issue is fixed by calling .ToList() after GenerateTokens in RantPattern's constructor. This patch improves pattern evaluation performance by at least 15-25x in synthetic benchmarks.

Here's the rhyme update, giving you all sorts of rhyming power! It adds different rhyme modes, which will work with the rhyme carrier to generate rhymes of varying degrees of correctness. You can use the [rhymemode] function to select your modes. Separate multiple modes with a space (ex. [rhymemode: perfect forced slant_rhyme]). Here are the valid rhyme modes:

• perfect - What everyone thinks of when they think of a rhyme. lime / sublime, picky / icky. This means that the first vowel sound after the primary stress and everything after it matches. This is the only default mode.
• weak - Where the penultimate syllable is stressed and the final syllable rhymes. hammer / carpenter, coffin / raisin.
• syllabic - The last syllables rhyme. senator / otter, knuckle / tentacle
• semirhyme - Where the words would rhyme if not for the last syllable. broom / broomstick, viking / flamingo
• forced - If you really, really need something that rhymes, try this. It's a bag of worms, but it can be funny.
• slant_rhyme - The ending consonants match. trunk / skunk, rant / ant.
• pararhyme - All the consonants match. tuna / teen, man / money, boat / bat.
• alliteration - The beginning consonants match. leg / lady, dog / dude.

Classes that have three or fewer items don't get their own directives. However, this would lead to items with those classes being unable to find a directive to put themselves under, and would just be ignored. This has been fixed and now FindDirectiveForClasses returns the "best match" (it returns itself if all of its children don't have the class).

I actually am kind of confused why this works, but it does?

I've finally (with the help of Stack Exchange) managed to create a way to regenerate class directives when exporting dictionary tables. It essentially generates a tree of class directives based on the method described in the Stack Exchange question I linked before, and then populates them with the dictionary entries. It's a whole bunch of recursion and Rohan would probably cry but it works (as far as I can tell)!

• New arithmetic literal syntax
• New carriers (associative, match-associative)
• Carrier resetting
• Exclusive query improvements
• Optional classes
• Lots of bugfixes