NME syntax list

Every spelling NME actually accepts, in one place. For explanations, read the language reference; this file is a table, not a tour.

It is generated from the compiler source (python scripts/build-syntax-reference.py), and a check fails the build if the compiler accepts a spelling that is missing here — so the list cannot drift away from the implementation.

#How to read this

• Three levels. Sentence needs no quotes, commas, parentheses, equals signs or colons; beginner is short and exact; advanced is ordinary Python. They mix freely in one file and on one line, with nothing to declare.
• Python wins. If a line is valid Python, NME leaves it alone. That is why a one-word line (skip, 멈춰) stays a Python name and only becomes an NME command inside a loop block.
• One NME statement is one Python line. The line count never changes, so a traceback points at the line you actually wrote.
• The Python produced column is exactly what the compiler emits.

#1. Output

Text or code. After an action word, a valid Python expression whose names the program already knows is treated as code; anything else is text. say and 말해 are the exception: they try the expression first. A name introduced earlier is substituted into text (show Hello name! → "Hello " + str(name) + "!").

⚠ All it takes is a word that matches a name. Make a name called morale and the meal raised morale a lot becomes "the meal raised " + str(morale) + " a lot". The same holds in a condition: where wardRune is a true/false name, if choice equals wardRune compares against that value rather than against the text "wardRune".

Quotes say the thing is text. What is inside them stays text even where a name of the same spelling exists.

say "the meal raised morale a lot"      → printed as it stands
if choice equals "wardRune"             → compared against the text

The easier habit is to name things in a shape prose does not use — fightingSpirit rather than morale, hasWardRune rather than wardRune. Short common words are the dangerous ones.

#2. Input

ask number / 숫자로 produces int(input(...)). A question about an age or a count (How old are you?, 몇 살이에요?) is read as a number without it. A prompt that does not end in a space gets one.

#3. Save a value

Korean marks the target with the particle 은/는 and needs no action word. English has no such particle, so it uses set … to ….

#4. Change a value

⚠ A multi-word amount is parenthesised: subtract 1 + 2 from score is score - (1 + 2), not score - 1 + 2.

#5. Wait

The unit word (seconds, 초) is optional. A line with no number in it (잠깐 기다려) stays ordinary output.

#6. Repeat a number of times

A block closes three ways: by indentation, by one statement after :, or by a line containing only end / 끝.

A counting loop counts both ends. With two written numbers it counts up or down by which is bigger; with a name at either end it decides when the loop starts.

#7. Repeat over a list

The name before in / 마다 holds each item in turn, and the block body can use it immediately.

#8. Repeat while a condition holds

#9. Conditions

The right of a comparison takes every reading the left takes — a length, a count, a remainder, a quotient, arithmetic — and only from a name the program already made; anything else is text as before. In Korean a one-syllable name with the ending glued on — 만약에 밤이면, 만약에 비면, 만약에 비라면 — tests that name alone, like if dark, when the program made it.

#10. Comparison vocabulary

English accepts synonyms for the comparison words: greater, above, great, larger, bigger, higher all mean >; less, below, small, smaller, lower all mean <; equals, equal, same mean ==.

#11. Loop control

break and skip (멈춰, 건너뛰어) are valid Python names on their own, so they are read as NME only inside a loop block. Outside one they stay Python.

#12. Lists

Without the list of / 목록 marker a comma-separated line is ordinary text. append Mina to friends (a list) and add 1 to score (a number) are different commands and keep their own meanings.

Items are counted from one. the first of friends is item 1 of friends and becomes friends[0]. There is no item 0; writing one is E0229. Changing an item counts the same way. A record has no numbered items, so changing one of a record is E0234.

The statements that read or rearrange a list (how many, sort, shuffle, the first of, the total of, remove, …) only work on a name the program already made a list. That is what keeps sort out your things and the first of many ordinary sentences. Using one on a name that is not a list is E0231.

comma joins with a comma and a space (", "), space with one space, and newline with a line break. Items go through map(str, …), so a list of numbers joins as readily as a list of words.

#13. Records

A record holds many named values at once. Python calls it a dictionary; a beginner calls it a list of names and what goes with each.

an empty record / 빈 표 is only a record where a value is being saved. An ordinary sentence holding the same word — I keep a record of everything I read — stays a sentence.

The spellings a record shares with a list — how many, remove, contains, for each, 개수, 빼, 넣어 — are the same words, and what they do depends on which kind the name holds. That is deliberate: a reader should not have to remember which is which. Using a record line on a list is E0234.

A record has no order, so the total of, the biggest of, the first of and sort are not written for one. for each name in ages hands back the names, so the value is read back with name in ages.

set Mina to 90 in ages and set best to Mina in ages are the same six words in the same order, and they mean opposite things. What follows to decides: a number or a quoted string is a value being written, and a word is a name being read. A record kept under numbers is still readable — put the number in a name first (set key to 90, then set who to key in ages).

A name Python wrote as ages = {} is a record too.

#14. Working with text

the length of gives how many characters a piece of text has, and in capitals / in small letters give the same text with its letters changed. All three are values, so they work in output, in a saved name, and in a condition. They only read a name the program already made, which is what keeps an ordinary sentence containing one of those words a sentence.

#15. Arithmetic and remainders

plus, minus, times, multiplied by and divided by — 더하기, 빼기, 곱하기, 나누기 in Korean — are Python's + - * /. They are arithmetic only when every side is a written number or a name the program already made; if any side is anything else, the words are text as before, so 설탕 빼기 and one plus one equals two still print themselves. A chain follows the order a maths book uses, multiplying and dividing first. The value can be saved, can be the whole of what is shown, and can stand on either side of a comparison.

the remainder of is what is left over after a division, and the whole number of is how many whole times one goes into the other. Both are values, so they work in output, in a saved name, and in a condition; the number being divided by must be a number or a name the program already made.

divided by and divide are Python's /, so the answer is a fraction. A fraction cannot be a position in a list, a number of repeats, or a saved score, and the program stops where one is used as any of those. Ask for the whole number instead.

#16. Values and literals

#17. Randomness

A choice written as a number stays a number (pick from 1 or 2 → choice((1, 2,))).

#18. Chance

30% means 300 times in a thousand. One decimal place is the finest you may write (30.5%); anything finer is reported as E0227 rather than rounded, because a program must never quietly mean something you did not write. The range is 0% to 100%, and outside it you get E0228. 100% always happens and 0% never does. The comparison is between whole thousandths, so no floating-point rounding can creep in.

A chance saved in a name is an ordinary true/false value, so the usual condition words can ask about it: if luck then show You win.

#19. Files

A file path is always quoted. This is the one place the sentence level asks for a quote character.

#20. Modules

After use random, use file and use zero_knowledge, the four most asked for are use list, use text, use math and use date. One line makes every name below ready in both languages, and everything inside them is plain Python builtins, so they run in the browser as they stand. list, text, math and date are ordinary words, so they name a module only when they stand beside use/사용 and nothing else is left over on the line; get the list of names and What is the date today? are sentences and print.

yesterday, tomorrow, 3 days ago and 3 days from now — Korean 어제, 내일, 3일 전, 3일 뒤 — are the sentence way to step off today. They mean a date only after the toolbox is open, so 3 days ago I saw her and 약속은 3일 전이었습니다 are sentences and print.

Six of the date names answer with nothing written after them, so they may be written without brackets and a whole date program stays sentences: show today, show weekday, show year, 오늘 말해줘, 요일 말해줘, 올해 말해줘 — and now/지금, month/이번달, day_of_month/오늘일자 the same way. days_after(n) is not one of them: it needs the number written after it, and what is missing there is the writer's, not the compiler's.

On a Wednesday, weekday() answers Wednesday and its Korean name 요일() answers 수요일. This is the one place in any bundled module where the two names hold different values: a weekday name is a word rather than a number, so it has to be in some language, and the name you write chooses which. The clock a browser hands Python is UTC, so in the browser today() is today in UTC.

use list (목록 사용):

use text (글자 사용):

use math (수학 사용):

use date (날짜 사용):

sort, reverse and remove hand back a new list and leave the original alone. To change the list itself, use the sentence statements sort friends, reverse friends and remove Mina from friends.

#21. Slow text

Each character is printed on its own with a short pause after it. The pause is 0.04 seconds by default, 0.12 with very, and whatever you name with every 3 seconds / 3초씩.

#22. Stories

Inside story: every line is text. wait 3 seconds and if ready are not commands there; they print, exactly as written. Writing something novel-like is the whole point of the form, so a line of prose can never quietly turn into a statement. Close the block with end / 끝, or, if you opened it by indenting, by ending the indentation. A blank line prints an empty line, names you made earlier are still substituted into the text, and the colon may be the plain : or the full-width ： a Korean keyboard writes.

#23. Named jobs

A named job gives a piece of program a name, so it can be run later by that name. Python calls it a function (def).

to, do, 일 and 하기 are ordinary words, so a named job is recognized by structure and never by a word: the opening to (or, in Korean, the 라는 on the name and the 일 after it), the closing :, and a block underneath. to be honest and 할 일이 많습니다 have none of that.

Without a block it is not a job. A heading such as To do: on its own is printed as the line it is, and there is no one-line form.

The line that runs a job only runs one when the name is a job this program already made. do and run decide nothing on their own. A Python def that takes no arguments can be run the same way.

A name saved inside a job stays inside it, exactly as in a Python function.

⚠ A name a job reads has to exist above the job. A word that is only given a value further down the file is read as text rather than as a name. It compiles, and it stops the program at run time instead.

to draw bar amount:
    set left to barMax        ← becomes barMax = "barMax"
end
set barMax to 20              ← has to be above the job, not here

Gather the values a job reads before you write the job. A block of settings at the top of the program is the safest place for them.

A job may be given one thing. The header names it in front of the job name (to greet someone:, 이름에게 인사하기라는 일:), and the line that runs the job hands it over the same way (do greet with Mina, 민수에게 인사하기 해줘). Giving a job the wrong number of things is refused with E0235, because the Python TypeError it would otherwise cause happens at run time on a line that looks right.

A job can hand an answer back. Write give back <value> inside it, and the place that ran the job becomes that value. answer with <value> is the same thing. To take the answer, write set <name> to the result of <job> with <thing>, or the result of <job> where the job is given nothing. It is a value, so it works in output, in a saved name, and in a condition.

to twice amount:
    give back amount + amount
end
set answer to the result of twice with 5
show answer

give back only means that inside a job. give back the book outside one is the sentence it looks like and prints. The job name carries the same kind of gate: the result of only asks for an answer where the name is one this program has already made a job.

Sentence grammar has no job that takes two things yet. Write a Python def when you need one.

#24. Screen

Clearing the screen sends a terminal control sequence, so somewhere that is not a terminal it may show up as text. The box and the centred line count a Korean character as two columns, so a Korean sentence comes out straight; the width is 40 columns.

#25. The stopwatch

start the timer starts the clock and elapsed / 잰시간 / 걸린시간 reads how many seconds have passed, to two decimal places. It is a value, so it works in output, in a saved name, and in a condition (if elapsed is greater than 3). Reading it without starting the clock is reported at compile time as E0226. A name the program made itself always wins over the word.

#26. Cooldowns

One cooldown belongs to one name. put door on cooldown for 3 seconds remembers the moment three seconds from now, and is ready / 쿨타임이 끝났으면 asks whether that moment has passed. They are conditions, so they work with when, while, else if, and the one-line form of all three. wait for door also reads as an ordinary English sentence, so a name the program already saved as something else is not read as a cooldown.

#27. Every action word

Every spelling accepted for each action, with nothing left out.

#28. Korean particles

These endings are not treated as part of the name they follow.

에게서는 · 한테서는 · 에게서 · 한테서 · 으로는 · 로는 · 에게 · 한테 · 에서 · 으로 · 까지 · 부터 · 처럼 · 보다 · 이라도 · 라도 · 만큼 · 밖에 · 에는 · 에서 · 은 · 는 · 이 · 가 · 을 · 를 · 와 · 과 · 도 · 의 · 에 · 로 · 아 · 야 · 랑 · 이랑 · 예요 · 이에요 · 님 · 님께 · 님은 · 님이

#29. Typo recovery

For action words and connectors only, and only after Python has rejected the line, NME retries once with a single edit repaired (one insertion, deletion, substitution, or adjacent swap). If more than one repair is possible it repairs nothing and points at the exact span instead. Strings and comments are never touched.

#30. Error codes

Run nme en E0102 for the long explanation of a code (nme ko E0102 in Korean).