I need to look through it and update it.

Within embedded javascript, MotherTode doesn't parse correctly if you go more than one level of indentation deep.

++ works unintuitively sometimes. Consider if this is correct, or should change.

You need to manually specify that you want to carry over the rest of a source after a chain, NOT JUST the matched source.

Should this work the same/different as the then operator? #10

Maybe it would be worth being able to match something by saying what it's NOT. Example:

Comment :: "/*" Inner "*/"
Inner :: { not "*/” }

The or operator should probably work the same way as it does in EBNF

I temporarily removed the error logging from MotherTode because it was a performance issue. I should put in a temporary error message if your mothertode fails to parse.

It might be useful to be able to specify how many times you want a term to be repeated. Imagine you want to match a hex colour code:

:: "#" HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit

It would be great if you could specify that you want only 6 of them... maybe like this... Not sure what syntax would be best.

:: "#" 6 HexDigit

Complete redesign + rewrite based on my shower thoughts of the last 9 months.

• Step 1: TodePond/Frogasaurus#1
• Step 2: Figure out the different use-cases of MotherTode and structure
• Step 3: Write the new spec (including lots of words, not funny symbols)
• Get sidetracked: TodePond/Habitat#54
• Step 4: Write a minimal term.js #26
• Step 5: Make the new MotherTode using term.js

I used to have a standalone mothertode parser as part of Frogasaurus, but I removed it to keep that smaller + simpler. I should make a standalone one as part of the Mothertode project I think.

I wanted to get something working, so I copied your code at the end of README.md

That seemed to go semi-well, but it wasnt outputting anything - so I added in a console.log(...). That was a bit finicky.

Then I decided to just copy the FizzBuzz language from https://l2wilson94.gitbook.io/mothertode/examples, but that didnt turn out very well either.

Turns out language is actually an jumbled mess of otherwise empty arrays... (not all of them are expanded out here)

How do I actually use this tool?

for lookaheads

There's a 'properties' section, but not all the properties are in it, and properties.md isn't in it

Implement a then operator/keyword that lets you perform one match after another.

The hello world example in the readme doesn't print anything to the console, so maybe it would be better replaced by a clearer example.

Only tabs work

Literals

• string
• regexp

Scope

• proxy
• reference
• hoist
• scope

Operators

• list
• skip
• maybe
• many
• any
• or
• except
• not
• and
• select
• until
• before

Built-In

• default
• end
• rest
• anything
• nothing

Automatic Properties

• type
• name
• translate
• test

Manual Properties

• throw
• match
• travel
• select
• emit
• check
• then
• toString

Performance

• memo

State

• options
• except

I removed error logging because it was causing big performance issues. Is this a stupid idea? Maybe. But I should reimplement it in a better way, either way.

List of operators

It seemed as though the list was going quite quickly, so I've compiled them here.

• ✔ Many Term+
  Matches 1 or more occurences of a term

• ✔ Any Term* { Terms }
  Matches 0 or more occurences of a term ( perhaps this could just be replaced with Term+? or Term?+ ? )

• ✔ Maybe Term? [ Terms ]
  Matches 0 or 1 occurences of a term

• ✔ Or Term1 | Term2 < Terms >
  Matches any of the terms in the 'list' of options

• ✔ Except Term1~Term2
  Matches a term, but only if its not a part of another term

• ❌ Select @Term
  Labels a term for later use, serves no functional purpose

• ❌ Then Term THEN Term Term, Term
  Matches multiple terms in sequence

• ❌ Count N Term ( perhaps can be simplified to NTerm, if you restrict terms to only be defined with alphabetic characters)
  Matches a specific number (N) of terms in sequence

The following are suggestions for possible operators

• ❔ But / Not #Term NOT Term ( { Terms } if you end up removing the Any term, as mentioned above )
  Matches anything that is not a Term

• ❔ Anything ... ANY
  Any term. After thinking about this, it'd probably be a bad idea to use this in conjunction with Many or Any, unless it becomes lazy like in regex

• ❔ Built-ins :name: ( inspired by Character Classes in the regex POSIX standard Source )
  This is more like a group of built in terms, but I thought I could put it in here anyway
  Types of characters which turn up it lots of places, so its helpful to have a group that can be used from the beginning, including:

  • :alnum:
    Alphanumeric characters
  • :punct:
    Punctuation characters
  • :xdigit:
    Characters that are hexadecimal digits

In-built terms could have their own syntax so that they don't overlap with users' created terms

EOF could become :eof:

Make it so that you can optionally put commas between terms in a sequence of terms

The chain operator is kinda confusing, and I think its uses could be fulfilled by an upcoming 'then' operator instead. So maybe remove it?

The docs could be clearer on this. And they could specify that only tabs are currently supported. And that double indentation is currently not supported.

So I noticed in notes.txt on line 70 - 71, that there seems to be js's arrow function syntax.

Is that an actual js function? If so, will any javascript there work? If not (which would make sense from the | instead of ||) why use syntax that's similar to js, when you can use keywords like and/or and a syntax that's similar to what you've already done with the basic structure of MotherTode, namely:

let either = (a, b) {
    try {
        match a
    } else {
        match b
    }
}
either("foo", "bar")

Not sure if the try thing works, it's up to you, I was trying to make it more side-effecty, instead of returning values, which is similar to how match, throw, let and term work. (at least from what I can see)

If you don't like the try, then this'd probably work instead.

let either = (a, b) {
    match a or b
}
either("foo", "bar")

Loving the notes, very interesting!

Oh and another suggestion: Make MotherTode with MotherTode!

const language = MotherTode(`:: /[a-zA-Z]/+ >> (name) => 'Hello #{name}!'`)
language("world")

Uses the crazy idea I had for string interpolation inside string interpolation. I got rid of that feature because it was weird, so the example should be updated to remove it.