The example in Mutability of Value Types which calls the 🗝 method on credit_card is rejected by the compiler with 🚨 error: _💳 has no suitable 🗝 because 🗝 expects a string argument.
(Bonus typo in the same section: "Only value types in a mutable variables are mutable" in that section should either drop the "a" or change "mutable variables" to singular.)

The example code in Type Methods is rejected by the compiler (Emojicode-1.0-beta.2-Darwin-x86_64).

🐇 🍕 🍇
  📗 Return available pizza dishes. 📗
  🐇❗️ 📜 ➡️ 🍨🐚🔡🍆 🍇
    ↩️ 🍨 🔤Margherita🔤 🔤Tonno🔤 🔤Quattro Formaggi🔤 🍆
  🍉
🍉

pizza.emojic:3:5: 🚨 error: Unexpected token DocumentationComment.
    📗 Return available pizza dishes. 📗
    ⬆️

Removing the documentation section results in the error

pizza.emojic:3:6: 🚨 error: Expected Identifier but instead found EndOfArguments(❗).
    🐇❗️ 📜 ➡️ 🍨🐚🔡🍆 🍇
     ⬆️

I suspect it would also balk at the return line for using 🍨 instead of 🍿.

I'm sure it is just that I need to install/configure something, but I don't know what and it would be a good idea to add an explanation somewhere en the page.

Magic installation seems to be broken for the latest version on Linux, seems to be a simple problem of the latest release file names not being consistent with past versions, breaking the Magic Installation code generation script.

I think that demo is quite good, but we missed a big chance by writing out 'hello world' instead of using the correct emoji for that sentence. It just has to be:

👋🌎

no way around it. Currently it just feels so uncomfortably incomplete.

Should be an easy thing to fix for someone with proper access :)

The example in Calling Methods on Protocol Types does not compile with Emojicode-1.0-beta.2-Darwin-x86_64:

🐊 💿 🍇
  ❗️🎶
🍉

🐇  📱 🍇
  🐊 💿

  ❗️ 🎶 🍇
    😀 🔤Lalalala🔤❗️
  🍉
🍉

🏁🍇
  🖍 🆕 cd_like 💿
  🆕📱  ➡️ 🖍  cd_like
  🎶 cd_like❗️
🍉

produces

protocol.emojic:15:7: 🚨 error: Unexpected token RightProductionOperator.
  🆕📱  ➡️ 🖍 cd_like
      ⬆️

Changing the assignment line to 🆕📱 ❗️ ➡️ 🖍 cd_like (addition of ❗️) produces

protocol.emojic:15:3: 🚨 error: _📱 has no suitable 🆕.
  🆕📱 ❗️ ➡️ 🖍 cd_like
  ⬆️

Additionally, the BNF for protocol does not specify that it uses the grapes-watermelon 🍇🍉 block delimiters to surround the protocol-body, but all of the examples imply that it's required.

"This calls the 🎱 class method on the class 🐪 in namespace 🕚."

Where did class 🐪 and namespace 🕚 come from? They're never referenced before that line.

1. The code example for the 🔁 For-in loop is incorrect. It starts a list declaration with 🍨 rather than 🍿.
2. The explanation of 🔁 For-In compiled bytecode is a bit confusing because it appears before 🔁 Repeat-While is introduced.
3. The 🙅↪️ Else-If section is confusing. The sentence "However, unlike ↪️, it will execute that alternative expressions only if the ↪️ expression is 👍" doesn't make much sense: both ↪️ and 🙅↪️ execute a block if the associated expression is 👍. (Additionally, "that" and "expressions" disagree in grammatical case; it should either be "that alternative expression" singular or "those alternative expressions" plural, though maybe it should actually be talking about an "alternative block"?) Perhaps this should be reworded to say that 🙅↪️ evaluates its expression if no previous 🙅↪️ or ↪️ in the sequence evaluated to 👍.
4. The Markdown-generated header tags have an id attribute based on the section title. Emoji in that title are replaced with -. This results in multiple HTML elements with the same id when a section header doesn't have any ASCII text. This makes fragment links to that section impossible. For example, <h3 id="-">🙅</h3> and <h3 id="-">🙅↪️</h3> conflict for the fragment in https://www.emojicode.org/docs/reference/controlflow.html#-
5. The comments in the code example for ⏩ ranges don't properly explain the use of step. The first comment says "Prints numbers 0 through 8 (including)" but it actually only prints the even numbers (0 2 4 6 8). The 100 -10 -10 example might be more illustrative if it were 100 -15 10 which would (a) help convey that the second argument is the end and the third is the step and (b) illustrate the surprising behavior when abs(end - start) is not a multiple of step (the range seems to go from start to end - step inclusive, rather than from start to end exclusive).

(Code observations based on Emojicode-1.0-beta.2-Darwin-x86_64.)

This is the table of contents for 👌, as rendered by my Firefox install:

Notice how 😜🐚👌🍆 takes up four lines, even though it's only one interface.

The code sample demoing an initialization of a class is missing from the docs page here. The previous code sample, showing how to create a class, is shown instead.

In the documentation there is a list of operators

binary-operator ⟶ ➕ | ➖ | ➗ | ✖️ | 👐 | 🤝 | ◀️ | ▶️ | ⭕️ | 💢 |
binary-operator ⟶ ❌ | 👈 | 👉 | 🚮 | 🙌 | 😜 | ◀️ 🙌 | ▶️ 🙌

However which one's which, they vary in how obvious their operation is,

Could we have like a legend for at least And / Or / Equals / Doesn't Equal?

One of the example programs is to convert English to Piglatin. I like this idea, but the definition of Pig Latin is actually incorrect.
According to Google ...formed from English by transferring the initial consonant or consonant cluster of each word to the end of the word...
Notice that it is the initial consonant or consonant cluster. The included definition is the Pig Latin word you just have to move the first letter of the English word to the end
The example tests are only words that start with a single consonant followed by a vowel.

Here is the link to relevant page in your docs. http://www.emojicode.org/docs/guides/compile-and-run.html

I tried to use this example from the page about packages: https://www.emojicode.org/docs/reference/packages.html#importing-other-packages

📦 files 🏠

🏁 🍇
  🍺🆕📄📜 🔤novel.txt🔤❗️ ➡️ readFile
🍉

but the compiler gives me this error:

2-1.emojic:4:22: 🚨 error: Unexpected token RightProductionOperator.
  🍺🆕📄📜 🔤novel.txt🔤❗️ ➡️ readFile
                     ⬆️

⭐️ Proposed change

Make it possible to search and/or cross-reference the documentation.

🤔 Rationale

One of the most frustrating things for a new developer getting into Emojicode is when you are reading the docs and you see an emoji (or a bunch of emoji) that you don't know what it means, and the documentation doesn't have any explanation about it. I would love to be able to either:

• Search for the emoji and see other places in the docs it's referenced or defined
• Hover/click on an emoji to see a tooltip description or link to its definition

Luckily, I'm very stubborn and eventually figure it out, but it's a problem I've had soooo many times and I'm sure I'm not alone.

🕺 Additional remarks

It looks like Doxygen creates some search stuff by default, but it doesn't look like it's in use in the docs site. I imagine that this is because it doesn't really work or isn't useful? Could we tweak Doxygen to improve it and make it usable?

If we did want to do tooltips, we would likely need to create an index that maps emoji to a definition and do some post-processing on the Doxygen-generated docs to add the tooltips.

If we did want to do cross-referencing, we would likely need to create an index that maps emoji to a URL (with # to the id of the section) and do some post-processing on the Doxygen-generated docs to add the links.

When you have a lot of tabs up, the Emojicode documentation doesn't stand out very well. Perhaps we could use a recognizable icon such as the file extension (🍇)?

The documentation for 📶 directs the reader to the "Memory Management" page of the Language Guide and Reference. However, the latter does not mention 📶. I suspect this is a case of linkrot.

I am trying to run an example from the generics documentation page: https://www.emojicode.org/docs/reference/generics.html

🍨🔤aa🔤 🔤12345🔤🍆 ➡️ list
🐰 list 🐚🔡🍆 🍇 a 🔡 ➡️ 🔡
  ↩️ 🔤🧲a🧲!🔤
🍉

Compiling gives me the error:

2-1.emojic:3:18: 🚨 error: Unexpected token RightProductionOperator.
  🍨🔤aa🔤 🔤12345🔤🍆 ➡️ list
                 ⬆️

I tried changing the 🍨 to 🍿 after seeing this issue: #65 but then I get the error, which I'm unsure of how to fix:

2-1.emojic:4:10: 🚨 error: Unexpected token Generic.
  🐰 list 🐚🔡🍆 🍇 a 🔡 ➡️ 🔡
         ⬆️

The example with type inference:

  🐰 list 🍇 a 🔡 ➡️ 🔡
    ↩️ 🔤🧲a🧲!🔤
  🍉

also gave me an Unexpected token BlockEnd but I think I was able to fix it by adding an ❗️.

I cannot find any information on what happens when the result of an arithmetic operation does not fit in the value range of an integer. Is it wrapping around, a panic, or perhaps nasal demons or other undefined behavior?

The example below from this page doesn't compile. The list variable is missing a mutability crayon.

🏁 🍇
  🍨 🔤Hey!🔤 🔤Hi!🔤 🔤Howdy!🔤 🔤Aloha!🔤 🍆 ➡️ list
  🐹 list❗️
  😀 🐽list 0❗️❗️
🍉

While compiling the "Howdy Partner" example from the main site, I received the

The compiler crashed due to an internal problem: std::bad_alloc

message.

I am using Ubuntu for Windows 10 to compile.

While compiling, my computer slowed down considerably -- almost as if frozen.

@ :EMOJICODE: // 🔓 :EMOJICODE:

The operators section of the language guide should explain the semantics of each operator for basic types. It's implied that ➗, ✖️, ➖, ➕ are the standard arithmetic operators. 🤝 and 👐 are explained as logical and and or. 😜 is defined as the identity check operator and says to use 😛 for value equality, but 😛 is not part of the BNF for binary-operator at the top of the page, nor in the operator precedence list. The remaining 11 operators in the binary-operator declaration are not explained.

The operators with highest precedence (🔲, ⬛, 🔺, ⁉️, 🍺) are not part of the BNF for binary-operator and I have absolutely no clue what they might mean as operators.

The Operator Precedence section says "Operators at top are evaluated first" but does not specify how operators with the same precedence are handled. (One might guess that they're left-associative, but this should be stated explicitly.)

A paragraph in compile-and-run.md still refers to 🍨 as the beginning of a list

You wrote:

The point of Optionals is providing more safety. This is achieved by forcing the programmer to take
special care of optionals as optionals cannot be used like the they make optionals.

I tried to fix it in a PR, but couldn't actually figure out what you mean by "as optionals cannot be used like the they make optionals."

https://www.linkedin.com/in/xzyxzyxzyxzyxzyxzyxzy-xzyxzyxzyxzyxzy-a07290221

The description of start-flag in https://www.emojicode.org/docs/reference/syntax.html says

start-flag was already described in the previous chapter. All other rules will be explained in detail later on.

The Syntax page is the second one in the Language Reference and Guide, and the first page doesn't say anything about start-flag, so this reference is confusing.

The document should link to the documentation of 🏁 directly (https://www.emojicode.org/docs/reference/basics.html#the-block) rather than by navigation relative navigation.

I might be blind, but even after looking through the documentation a few times, I haven't encountered any modulo operation examples. I've seen that the compiler uses 0x25 for this, but I have no idea what to do with this knowledge.

Also, you have perhaps done this on purpose, but it would be a bit easier (for me, at least) to find what I'm looking for, had the documentation used more common keywords like "for loops" or "if statements". Even though this might not be entirely correct for some reason, I find knowing what to search for incredibly hard.

Nice work, anyways. Keep it up!