Skip to content

Index

Jump to bottom Edit New page
urkerab edited this page Dec 24, 2023 · 1 revision

TIO refers to Try it online! while ATO refers to Attempt This Online!.

  • Print(str);. Writes the string to the canvas.
  • Print(int);. Writes a line of one of -, |, / or \ depending on the current direction of the given length to the canvas.
  • Print(list);. For each element of list, prints it in the current direction without moving the cursor and then moves down a line.

；

Used by Wolfram expressions.

∧

Logical And(any, any). Returns the first argument if it is falsy, otherwise it evaluates the second argument.

∨

Logical Or(any, any). Returns the first argument if it is truthy, otherwise it evaluates the second argument.

“

Starts a compressed string, which is a separate token from ASCII strings.

“y

Starts a literal string (a string containing these command characters, excluding ”, or ⸿). (TIO: or ⸿ will also be quoted, but the deverbosifier erroneously converts \n or \r.)

”

Ends a compressed or literal string. Optional at the end of the program.

⊞

Push(list, any);. Appends the value to the list.

⊞Ｏ

PushOperator(list, any). Appends the value to the list and returns the list.

⊟

Pop(list). Removes and returns the last element of the list.

➙

Used by Wolfram expressions.

⧴

Used by Wolfram expressions.

″

Used by Wolfram expressions.

\n. Literal newline character; counts as part of an ASCII string literal. When printed to the canvas, causes the cursor to move to the start of the next "line" below the cursor position at the start of the print command.

‴

Used by Wolfram expressions.

＆

  • BitwiseAnd(int, int).
  • BitwiseAnd(int, list). Recursively vectorises over the list.
  • BitwiseAnd(list, int). Recursively vectorises over the list.

｜

  • BitwiseOr(int, int).
  • BitwiseOr(int, list). Recursively vectorises over the list.
  • BitwiseOr(list, int). Recursively vectorises over the list.
  • BitwiseOr(string, string). Creates a pair of Wolfram strings.

↶

PivotLeft(int=2);. Rotates the default output direction anticlockwise by 45° times the argument.

↷

PivotRight(int=2);. Rotates the default output direction clockwise by 45° times the argument.

⟲

Rotate(int=2);. Rotates the canvas anticlockwise by 45° times the argument.

⟲Ｔ

RotateTransform(int=2);. Rotates the canvas anticlockwise by 45° times the argument, rotating the characters if possible.

⟲Ｃ

  • RotateCopy(dir=↘, literal);. Rotates the canvas anticlockwise by 45° times each digit in the literal around the given corner of the canvas, overlaying the copies over the original.
  • RotateCopy(dir=↘, int=2);. Rotates the canvas anticlockwise by 45° times the argument around the given corner of the canvas, overlaying the copy over the original.
  • RotateCopy(dir=↘, list);. For each element of list, rotates the canvas anticlockwise by 45° times the element around the given corner of the canvas, overlaying the copy over the original.

⟲Ｐ

  • RotatePrism(dir=↘, literal);.
  • RotatePrism(dir=↘, int=2);.
  • RotatePrism(dir=↘, list);.

Like RotateCopy but rotates the characters if possible.

⟲Ｏ

  • RotateOverlap(dir=↘, literal);.
  • RotateOverlap(dir=↘, int=2);.
  • RotateOverlap(dir=↘, list);.

Like RotateCopy but rotates around the character in the corner (so that the rotated character overlaps itself).

⟲ＯＯ

  • RotateOverlapOverlap(dir=↘, literal, int);.
  • RotateOverlapOverlap(dir=↘, int=2, int);.
  • RotateOverlapOverlap(dir=↘, list, int);.

Like RotateOverlap but specifies the amount of overlap.

⟲Ｓ

  • RotateShutter(dir=↘, literal);.
  • RotateShutter(dir=↘, int=2);.
  • RotateShutter(dir=↘, list);.

Like RotateOverlap but rotates the characters if possible.

⟲ＳＯ

  • RotateShutterOverlap(dir=↘, literal, int);.
  • RotateShutterOverlap(dir=↘, int=2, int);.
  • RotateShutterOverlap(dir=↘, list, int);.

Like RotateShutter but specifies the amount of overlap.

←

  • :Left. Used as a direction parameter to other commands.
  • Move(:Left);. Moves the cursor one character to the left.
  • Print(:Left, any);. Prints the argument as if the pivot was pointing to the left.

↑

  • :Up. Used as a direction parameter to other commands.
  • Move(:Up);. Moves the cursor one character up.
  • Print(:Up, any);. Prints the argument as if the pivot was pointing up.

→

  • :Right. Used as a direction parameter to other commands.
  • Move(:Right);. Moves the cursor one character to the right.
  • Print(:Right, any);. Prints the argument as if the pivot was pointing to the right.

↓

  • :Down. Used as a direction parameter to other commands.
  • Move(:Down);. Moves the cursor one character down.
  • Print(:Down, any);. Prints the argument as if the pivot was pointing down.

⎇

Ternary(any, any, any). Evaluates the second argument if the first argument is truthy or the third argument if it is falsy.

‽

  • Random(). Returns 0 or 1 randomly.
  • Random(int). Returns a random integer from 0 to (but not including) the argument. (Must be at least 1.)
  • Random(str). Returns a random character from the string. (Must not be an empty string.)
  • Random(list). Returns a random element from the list. (Must not be an empty list.)

↧

  • Lowercase(str). Returns the given string in lowercase.
  • Lowercase(list). Recursively vectorises over the list. (Does not work on empty lists on TIO.)

↥

  • Uppercase(str). Returns the given string in uppercase.
  • Uppercase(list). Recursively vectorises over the list. (Does not work on empty lists on TIO.)

⌊

  • Floor(float).
  • Minimum(str). Returns the character with the lowest Unicode codepoint. (ATO: Returns the empty string if the input was empty.)
  • Minimum(list). Returns None if the list is empty.

⌈

  • Ceiling(float).
  • Maximum(str). Returns the character with the highest Unicode codepoint. (ATO: Returns the empty string if the input was empty.)
  • Maximum(list). Returns None if the list is empty.

±

  • Negate(number). (Does not work on complex numbers on TIO.)
  • Negate(string). Removes a leading -, or adds one if none was present. (Not available on TIO.)
  • Negate(list). Recursively vectorises over the list. (Not recursive on TIO.)

↖

  • :UpLeft. Used as a direction parameter to other commands.
  • Move(:UpLeft);. Moves the cursor one character up and to the left.
  • Print(:UpLeft, any);. Prints the argument as if the pivot was pointing up and to the left.

↗

  • :UpRight. Used as a direction parameter to other commands.
  • Move(:UpRight);. Moves the cursor one character up and to the right.
  • Print(:UpRight, any);. Prints the argument as if the pivot was pointing up and to the right.

↘

  • :DownRight. Used as a direction parameter to other commands.
  • Move(:DownRight);. Moves the cursor one character down and to the right.
  • Print(:DownRight, any);. Prints the argument as if the pivot was pointing down and to the right.

↙

  • :DownLeft. Used as a direction parameter to other commands.
  • Move(:DownLeft);. Moves the cursor one character down and to the left.
  • Print(:DownLeft, any);. Prints the argument as if the pivot was pointing down and to the left.

⭆

  • StringMap(int, any). Evaluates the given expression for each of the integers from 0 up to the first argument and joins the results into a string.
  • StringMap(iter, any). Evaluates the given expression for each of the elements of the first argument and joins the results into a string. (Does not work on dictionaries on TIO.)

？

Used by Wolfram expressions.

⪫

Join(str, iter). Converts the the elements of the iterable to string and joins them using the first argument. (ATO: Also converts the first argument to string.)

⪪

  • Split(iter, int). Splits the argument into pieces of the given length (with a short piece at the end if necessary).
  • Split(str, str). Splits the first argument at matches of the second argument.
  • Split(str, list). Splits the first argument at matches of the elements of the second argument. (Not available on TIO.)

℅

  • Character(int). Returns the Unicode character with the given codepoint.
  • Ordinal(char). Returns the code point of the given Unicode character.
  • Ordinal(""). Returns 0.

◧

PadLeft(str, int). Pads the first argument with spaces if its length is less than the second argument.

◨

PadRight(str, int). Pads the first argument with spaces if its length is less than the second argument.

⮌

  • Reverse(iter). Reverses the order of the elements or characters in the argument.
  • Reverse(number). Reverses the digits in the number, including any decimal point but excluding the sign. (Only works for positive integers on TIO.)

≡

switch (any) { case:s... (default:) }

≡«

Like switch but uses a closing » to mark the end of the switch statement. (Technically the closing » is optional at the end of the program but in that case you would simply omit the «.) Use switch_delimited in Verbose mode. (Not available on TIO.)

№

  • Count(str, str). Counts the number of non-overlapping matches of the second argument in the first. (Use Length(FindAll(str, str)) to count overlapping matches.)
  • Count(iter, any). Counts the number of occurrences of the given value in the iterable's elements. (Does not work on dictionaries on TIO.)

⊙

  • Any(int, any). Evaluates the given expression for each of the integers from 0 up to the first argument and returns 1 if any value is truthy or 0 if not. (Not available on TIO.)
  • Any(iter, any). Evaluates the given expression for each of the elements of the first argument and returns 1 if any value is truthy or 0 if not. (Does not work on dictionaries on TIO.)

⸿

\r. Literal carriage return character; counts as part of an ASCII string literal. When printed to the canvas, causes the cursor to move to the start of the next line.

⬤

  • All(int, any). Evaluates the given expression for each of the integers from 0 up to the first argument and returns 1 if all of the values are truthy or 0 if not. (Not available on TIO.)
  • All(iter, any). Evaluates the given expression for each of the elements of the first argument and returns 1 if all of the values are truthy or 0 if not. (Does not work on dictionaries on TIO.)

≔

Assign(any, var);.

§≔

AssignAtIndex(list, int, any);. Updates an element of a dictionary, or of a list (including list of cells) using cyclic indexing.

≕

GetVariable(str). Gets a Charcoal variable indirectly by succinct name or a Python constant such as math.tau.

▷

  • EvaluateVariable(str);. Executes the named Python function.
  • EvaluateVariable(str, list);. Executes the named Python function, passing it the given arguments. Note: Only works with literal lists; variable numbers of arguments are not supported.
  • EvaluateVariable(str, value);. Executes the named Python function, passing it the given argument.

▶

ExecuteVariable(str, list);. Executes the named Python function, passing it the given arguments.

✂

  • Slice(list). Returns a shallow clone of list.
  • Slice(iter, int). Returns the argument with the given number of elements removed from the front, or the last elements of the argument if the given number is negative.
  • Slice(iter, int, int). Returns the given range of elements of the argument.
  • Slice(iter, int, int, int). Returns the given range including step of elements of the argument.

Σ

  • Sum(number). Returns the sum of the digits of the argument, excluding any exponent.
  • Sum(str). If the argument looks like a number, returns the sum of its digits, otherwise returns the sum of any embedded numbers, or 0 if there were none. (TIO: Only supports positive numbers.)
  • Sum(list). Returns the sum, join or concatenation of the elements of the list depending on whether the first element is an integer, string or list. (Does not work on lists of lists on TIO).

Π

  • Product(int). Returns the product of the digits of the argument.
  • Product(float). Returns the product of the non-zero digits of the argument, excluding any exponent.
  • Product(str). If the argument looks like a number, returns the product of its digits, otherwise returns the product of any embedded numbers, or 1 if there were none. (TIO: Only supports positive numbers.)
  • Product(list). Returns the product of the elements of the list, or 1 if there were none (None if there were none on TIO).

↨

  • Base(int, int). Converts the first argument to an array of integers representing it in the base of the second argument, with the most significant digit first. Returns an empty array if the first argument is 0.
  • Base(int, str). Equivalent to BaseString(int, str).
  • Base(str, int). Equivalent to BaseString(int, str).
  • Base(str, str). Equivalent to BaseString(str, str) but with the arguments swapped.
  • Base(list, int). Evaluates the list as a polynomial using the second argument, with the most significant degree first. This also works for converting a number from a custom base. If the number is 0, returns the last element of the list, or 0 if it was empty. (Does not remove the last element like Pop would.) If the number is 1, returns the sum of the list, or 0 if it was empty. (Sum does not work in this case.)
  • Base(int, list). Equivalent to Base(list, int).

⍘

  • BaseString(number, int). Converts the first argument to a string representing it in the base of the second argument, using the characters 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ as digits, with the most significant digit first. Returns 0 if the first argument is 0.
  • BaseString(number, str). Converts the number to a string representing it in the base of the length of the given string, using its characters as digits, with the most significant digit first. Returns the first character of the given string if the first argument is 0 (0 if the first argument is 0 on TIO). Does not convert a floating-point fraction if the given string contains ..
  • BaseString(number, list). Converts the number to a string representing it in the base of the length of the list, using its elements as digits, with the most significant digit first. Returns the first element of the list if the first argument is 0 (0 if the first argument is 0 on TIO). Does not convert a floating-point fraction if the list contains ..
  • BaseString(str, int). Converts the first argument as if it was a representation of the base of the second argument, using the characters 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ as digits, with the most significant digit first.
  • BaseString(str, str). Converts the first argument as if it was a representation of the base of the length of the second argument, using its characters as digits, with the most significant digit first.
  • BaseString(str, list). Like BaseString(str, str) but using a list of characters instead of a string.
  • BaseString(list, int). Like BaseString(str, int) but using a list of characters instead of a string.
  • BaseString(list, str). Like BaseString(str, str) but using a list of characters instead of a string.
  • BaseString(list, list). Converts the first argument as if it was a representation of the base of the length of the second argument, using its elements as digits, with the most significant digit first.

✳

  • Direction(int). Represents a computed direction arrow where 0 is → and 7 is ↘.
  • Direction(string). Represents a computed direction arrow where the string is any of Up, Down, Left, Right or their combinations, or a nontrivial prefix thereof, in any case, considering only the letters of the string.

✳✳

Directions(list). Represents a computed multidirectional given by the elements of the list as individual direction arrows.

↔

  • Absolute(number). Returns the norm of the number. (Does not work on complex numbers on TIO.)
  • Absolute(string). Removes a leading - from the string. (Not available on TIO.)
  • Absolute(list). Recursively vectorises over the list. (Does not work on empty lists on TIO.)

≦

  • MapAssign(unary, var);. Applies the unary operator to the contents of the variable and updates the variable. Works for integers and vectorises over lists.
  • MapAssignLeft(binary, any, var);. Applies the binary operator to the given value and the contents of the variable and updates the variable. Works for integers and vectorises over lists (and strings if the binary operator returns a string).

≧

  • MapAssign(unary, var);. Applies the unary operator to the contents of the variable and updates the variable. Works for integers and lists.
  • MapAssignRight(binary, any, var);. Applies the binary operator to the contents of the variable and the given value and updates the variable. Works for integers and vectorises over lists (and strings if the binary operator returns a string).

ⅈ

X(). Returns the X-coordinate of the cursor position on the canvas.

ⅉ

Y(). Returns the Y-coordinate of the cursor position on the canvas.

⌕

  • Find(str, str). Finds the index of the second string in the first, or -1 if the string is not present.
  • Find(list, any). Finds the index of the value in the list, or -1 if the value is not present. (Does not work on dictionaries on TIO.)
  • Find(dict, any). Finds the index of the value in the dictionary, or None if the value is not present. (Not available on TIO.)

⌕Ａ

  • FindAll(str, str). Returns a list of indices of overlapping matches of the second string in the first.
  • FindAll(iter, any). Returns a list of indices of the value in the iterable. (Does not work on dictionaries on TIO.)

⊕

  • Incremented(number). (Does not work on complex numbers and rounds to nearest 1e-15 on TIO.)
  • Incremented(list). Recursively vectorises over list. (Does not work on empty lists on TIO.)

⊖

  • Decremented(number). (Does not work on complex numbers and rounds to nearest 1e-15 on TIO.)
  • Decremented(list). Recursively vectorises over list. (Does not work on empty lists on TIO.)

⊗

  • Doubled(number). (Does not work on complex numbers and rounds to nearest 1e-15 on TIO.)
  • Doubled(list). Recursively vectorises over list. (Does not work on empty lists on TIO.)

⊘

  • Halved(number). (Does not work on complex numbers and always floating-point and rounds to nearest 1e-15 on TIO, but integer divide if the original value is even on ATO.)
  • Halved(list). Recursively vectorises over list. (Does not work on empty lists on TIO.)

⎚

Clear();. Clears the canvas and moves the cursor to the origin, but does not change other settings such as the pivot direction.

¬

Not(any). Returns 1 if the value is falsy, 0 otherwise.

₂

  • SquareRoot(number). (Does not work on complex numbers on TIO.)
  • SquareRoot(list). Recursively vectorises over list. (Not available on TIO.)

Φ

  • Filter(int, any). Returns a list of the integers from 0 up to the argument where the expression is truthy.
  • Filter(iter, any). Returns an iterable containing only those elements where the expression is truthy. (Does not work on dictionaries on TIO.)

§

AtIndex(iter, int). Indexes into a dictionary, or cyclically indexes into a list or string. (TIO: Returns the empty string if the result would be the null character.)

§≔

AssignAtIndex(list, int, any);. Updates an element of a dictionary, or of a list (including a list of cells) using cyclic indexing.

﹪

  • Modulo(number, number).
  • Modulo(str, number). Formats a string with a single format parameter.
  • Modulo(str, str). Formats a string with a single format parameter.
  • Modulo(list, number). Recursively vectorises over list.
  • Modulo(list, str). Recursively vectorises over list.
  • Modulo(str, list). Recursively vectorises over list.
  • Modulo(number, list). Recursively vectorises over list.

«

Begins a block or a lambda.

»

Ends a block or lambda. Optional at the end of the program.

×

  • Times(number, number).
  • Times(str, number).
  • Times(number, str). Repeats the string the given number of times, including fractional parts of the string, e.g. Times(1.5, "12") gives "121".
  • Times(list, str). Joins the elements of the list with the string.
  • Times(str, list). Joins the elements of the list with the string.
  • Times(list, number). Recursively vectorises over list. (Not recursive on TIO.)
  • Times(number, list). Recursively vectorises over list. (Not recursive on TIO.)
  • Times(list, list). Pairwise recursive multiplication. (Not available on TIO.)

⁺

  • Plus(number, number).
  • Plus(iter, iter). Concatenates two iterators of the same type. (Does not work on dictionaries on TIO.)
  • Plus(list, number). Recursively vectorises over list. (Not recursive on TIO.)
  • Plus(list, str). Recursively vectorises over list. (Not recursive on TIO.)
  • Plus(number, list). Recursively vectorises over list. (Not recursive on TIO.)
  • Plus(str, list). Recursively vectorises over list. (Not recursive on TIO.)

⁻

  • Minus(number, number).
  • Minus(str, str). Removes matches of the second string from the first.
  • Minus(list, list). Filters out elements of the first list that appear in the second.
  • Minus(dict, dict). Filters out elements of the first dictionary whose keys appear in the second. (Not available on TIO.)
  • Minus(list, number). Recursively vectorises over list. (Not recursive on TIO.)
  • Minus(list, str). Recursively vectorises over list. (Not recursive on TIO.)
  • Minus(number, list). Recursively vectorises over list. (Not recursive on TIO.)
  • Minus(str, list). Recursively vectorises over list. (Not recursive on TIO.)

·

Used as the decimal point in a floating-point literal.

÷

  • IntDivide(number, number). Integer or truncating division.
  • IntDivide(str, number).
  • IntDivide(number, str). Repeats the string the reciprocal of given number of times, including fractional parts of the string, e.g. Divide("121", 1.5) gives "12".
  • IntDivide(str, str). Splits the first string at occurrences of the second.
  • IntDivide(list, number). Recursively vectorises over list. (Not recursive on TIO.)
  • IntDivide(number, list). Recursively vectorises over list. (Not recursive on TIO.)

⁰¹²³⁴⁵⁶⁷⁸⁹

Used to create integer and floating-point literals.

¦

Used to separate consecutive integers or strings or as placeholders for optional arguments.

‖

Reflect(dir=→);. Reflects the canvas in the specified direction.

‖Ｔ

ReflectTransform(dir=→);. Reflects the canvas in the specified direction, reflecting the characters if possible.

‖Ｃ

ReflectCopy(dirs=→);. Reflects the canvas in each specified direction in turn, adding the reflected copy to the canvas after each reflection.

‖Ｍ

ReflectMirror(dirs=→);. Like ReflectCopy but reflecting the characters if possible.

‖Ｏ

ReflectOverlap(dirs=→);. Like ReflectCopy but reflects around the edge characters (so that the reflected axis overlaps itself).

‖Ｂ

ReflectButterfly(dirs=→);. Like ReflectOverlap but reflecting the characters if possible.

‖ＯＯ

ReflectOverlapOverlap(dirs=→, num);. Like ReflectOverlap but specifies the amount of overlap.

‖ＢＯ

ReflectButterflyOverlap(dirs=→, num);. Like ReflectOverlapOverlap but reflecting the characters if possible.

‹

  • Less(number, number).
  • Less(str, str).
  • Less(list, list). Compares using Python's < operator.

⁼

Equals(any, any).

›

  • Greater(number, number).
  • Greater(str, str).
  • Greater(list, list). Compares using Python's > operator.

¿

  • if (any) stmt.
  • if (any) stmt else stmt.

Note that the first form is only possible at the end of a block or program.

Ａ

  • Input(). Returns the next input, but doesn't cast it to string or integer. Only relevant for JSON input.
  • Input(var);. Sets var to the the next input, but doesn't cast it to string or integer. Only relevant for JSON input.

ＫＡ

PeekAll(). Returns a list of all the non-background cells in the canvas. Cells can be assigned to using AssignAtIndex.

Ｂ

  • Box(int, str);. Draws the string around the sides of a square of the given size.
  • Box(int, int);. Draws a rectangle of the given size, using +s for the corners and -s and |s for the horizontal and vertical sides.
  • Box(int, int, str);. Draws the string around the sides of a rectangle of the given size.

‖Ｂ

ReflectButterfly(dirs=→);. Like ReflectOverlap but reflecting the characters if possible.

‖ＢＯ

ReflectButterflyOverlap(dirs=→, num);. Like ReflectOverlapOverlap but reflecting the characters if possible.

ＵＢ

SetBackground(str);. Sets the string that should fill the background when the canvas is output. Defaults to a space.

Ｃ

Copy(int, int);. Overlays the canvas with a copy of it offset by the given horizontal and vertical amounts.

‖Ｃ

ReflectCopy(dirs=→);. Reflects the canvas in each specified direction in turn, adding the reflected copy to the canvas after each reflection.

Ｄ

Dump();. Outputs a copy of the canvas to standard output. Delays by 10 milliseconds since the last dump. (ATO: Use --nt to disable the delay.)

ＫＤ

PeekDirection(int, dir). Returns a list of the cell under the cursor and continuing in the given direction up to the given length. Cells can be assigned to using AssignAtIndex.

Ｅ

  • Map(int, any). Evaluates the given expression for each of the integers from 0 up to the first argument and returns a list of the results.
  • Map(iter, any). Evaluates the given expression for each of the elements of the first argument and returns a list of the results. (Does not work on dictionaries on TIO.)
  • See also ＵＥ.

Ｆ

  • for (int). Loops over the integers from 0 up to the argument.
  • for (iter). Loops over the elements of the argument. (Does not work on dictionaries on TIO.)
  • See also ＲＦ.

Ｇ

  • Polygon(dir, int, ... str);. Draws a polygon using the given directions and lengths, filling it with the given string. (Note that the lengths are inclusive.)
  • Polygon(dirs, int, str);. Draws a polygon using the given directions and length, filling it with the given string. (Note that the length is inclusive.)

ＧＨ

  • PolygonHollow(dir, int, ... str);. Draws the string along the given directions and path lengths. (Note that the lengths are inclusive.)
  • PolygonHollow(dirs, int, str);. Draws the string along the given directions and path length. (Note that the length is inclusive.)

Ｈ

Only used as a modifier; see ＧＨ.

Ｉ

  • Cast(number). Casts the value to a string. (TIO: Tries to remove the trailing .0 for floating-point values that represent integers, but floors the result instead of rounding it. Also the output for large floating-point values is suboptimal.)
  • Cast(str). Interprets the contents of string as a Python literal, or returns 0 if the string is empty. (TIO: Only supports integers and floats.)
  • Cast(list). Recursively vectorises over the list.

Ｊ

JumpTo(int, int);. Moves the cursor to the given absolute position.

Ｋ

ＫＡ

PeekAll(). Returns a list of all the non-background cells in the canvas. Cells can be assigned to using AssignAtIndex.

ＫＤ

PeekDirection(int, dir). Returns a list of the cell under the cursor and continuing in the given direction up to the given length. Cells can be assigned to using AssignAtIndex.

ＫＫ

Peek(). Returns the character under the cursor.

ＫＭ

PeekMoore(). Returns a list of the cells orthogonally and diagonally adjacent, starting with the cell above and to the left and working clockwise around the cursor. Cells can be assigned to using AssignAtIndex.

ＫＶ

PeekVonNeumann(). Returns a list of the cells orthogonally adjacent, starting with the cell above and working clockwise around the cursor. Cells can be assigned to using AssignAtIndex.

Ｌ

Length(iter). Returns the length of the iterable.

Ｍ

  • Move(dir). Moves one character in the given direction. Needed if the direction would otherwise be interpreted as a Print command.
  • Move(int, dir). Moves one character the given amount in the given direction.
  • Move(int, int). Moves the cursor to the given relative position.

ＵＭ

MapCommand(iter, any);. Evaluates the given expression for each of the elements of the first argument and updates the argument if possible. (Does not work on dictionaries on TIO.)

Ｎ

  • InputNumber(). Returns the next input cast to number. (ATO: Accepts any Python literal.)
  • InputNumber(var);. Sets var to the the next input cast to number. (ATO: Accepts any Python literal.)

Ｏ

Only used as a modifier.

⊞Ｏ

PushOperator(list, any). Appends the value to the list and returns the list.

Ｐ

  • Multiprint(str); Writes the string to the canvas without moving the cursor.
  • Multiprint(int); Writes a line of one of -, |, / or \ depending on the current direction of the given length to the canvas without moving the cursor.
  • Multiprint(dirs, str); Writes the string to the canvas in each of the specified directions without moving the cursor.
  • Multiprint(dirs, int); Writes the appropriate lines of -, |, / or \ for each direction of the given length to the canvas without moving the cursor. Note that the resulting character under the cursor will be that of the last direction used.
  • See also ⟲Ｐ.

Ｑ

Unused.

Ｒ

Refresh(int=0); Displays the canvas to the screen, but with an optional delay since the last refresh.

ＲＷ

RefreshWhile(any) Loops while the argument is true, saving it in the next loop variable, but displays the canvas at every step, with the given delay. The argument is evaluated after the RefreshWhile loop variable is reserved.

ＲＦ

  • RefreshFor(int, int). Loops over the integers from 0 up to the second argument, but displays the canvas at every step, with the given delay.
  • RefreshFor(int, iter). Loops over the elements of the argument, but displays the canvas at every step, with the given delay.

Ｓ

  • InputString(). Returns the next input cast to string.
  • InputString(var);. Sets var to the the next input cast to string.
  • See also ⟲Ｓ.
  • See also ⟲ＳＯ.

Ｔ

  • Trim(int);. Removes any part of the canvas outside the square with the given size having its top left at the cursor position, but also any part of the canvas above or to the left of the origin.
  • Trim(int, int);. Removes any part of the canvas outside the rectangle with the given size having its top left at the cursor position, but also any part of the canvas above or to the left of the origin.

⟲Ｔ

RotateTransform(int=2);. Rotates the canvas anticlockwise by 45° times the argument, rotating the characters if possible.

‖Ｔ

ReflectTransform(dir=→);. Reflects the canvas in the specified direction, reflecting the characters if possible.

ＵＴ

ToggleTrim();. Toggles whether the canvas output is right-padded (default true).

Ｕ

ＵＢ

SetBackground(str);. Sets the string that should fill the background when the canvas is output. Defaults to a space.

ＵＥ

  • Extend(int);. Inserts a gap between every column of the canvas.
  • Extend(int, int);. Inserts a gap between every column and row of the canvas.

ＵＭ

MapCommand(iter, any);. Evaluates the given expression for each of the elements of the first argument and updates the argument if possible. (Does not work on dictionaries on TIO.)

ＵＯ

  • Oblong(int, str);. Fills a square of the given size with the string.
  • Oblong(int, int, str);. Fills a rectangle of the given size with the string.

ＵＲ

  • Rectangle(int);. Draws a square of the given size, using +s for the corners and -s and |s for the horizontal and vertical sides.
  • Rectangle(int, str);. Draws the string around the sides of a square of the given size.
  • Rectangle(int, int);. Draws a rectangle of the given size, using +s for the corners and -s and |s for the horizontal and vertical sides.

ＵＴ

ToggleTrim();. Toggles whether the canvas output is right-padded (default true).

ＵＶ

PythonEvaluate(). Evaluates the string as Python code.

ＵＸ

PythonExecute(str). Executes the string as Python code.

Ｖ

  • Evaluate(str) Evalutes the string as Charcoal code.
  • Evaluate(str); Executes the string as Charcoal code.

ＫＶ

PeekVonNeumann(). Returns a list of the cells orthogonally adjacent, starting with the cell above and working clockwise around the cursor. Cells can be assigned to using AssignAtIndex.

ＵＶ

PythonEvaluate(). Evaluates the string as Python code.

Ｗ

while (any) Loops while the argument is true, saving it in the next loop variable. The argument is evaluated after the while loop variable is reserved.

ＲＷ

RefreshWhile(any) Loops while the argument is true, saving it in the next loop variable, but displays the canvas at every step, with the given delay. The argument is evaluated after the RefreshWhile loop variable is reserved.

Ｘ

  • Power(number, number).
  • Power(list, number). Recursively vectorises over the list.
  • Power(number, list). Recursively vectorises over the list.

ＵＸ

PythonExecute(str). Executes the string as Python code.

Ｙ

Unused.

Ｚ

Unused

⟦

Begins a list.

∕

  • Divide(number, number). Floating-point division.
  • Divide(str, number).
  • Divide(number, str). Repeats the string the reciprocal of given number of times, including fractional parts of the string, e.g. Divide("121", 1.5) gives "12".
  • Divide(str, str). Splits the first string at occurrences of the second.
  • Divide(list, number). Recursively vectorises over list. (Not recursive on TIO.)
  • Divide(number, list). Recursively vectorises over list. (Not recursive on TIO.)

⟧

Ends a list. Optional at the end of the program.

…

  • Range(int). Returns the range [0, value).
  • Range(int, int).
  • Range(char, char).
  • CycleChop(iterable, int). Cyclically extends or truncates the iterable to the given length, e.g. CycleChop("12", 5) gives "12121". (TIO: iterable must not be empty, even if the length is zero.)

…·

  • InclusiveRange(int). Returns the range [0, value].
  • InclusiveRange(int, int).
  • InclusiveRange(char, char).

´

Quotes a command character, allowing it to be used as part of an ASCII string literal.

αβχδεφγηικλμνπθρστυςωξψζ

Variables. αβχφγυωψ have preset values. ικλμνξπρςστδεζηθ are used by loop variables, if possible. (Note that expression loops consume two variables, one for the value and one for the index.) θηζεδ attempt to retrieve the first five inputs, if not being used as loop variables. (TIO: θηζεδ can only be used as loop variables.)

¤

Fill(str);. If the cursor is in an empty space, fills that space with the given string, repeating as needed.

⦃

Begins a dictionary.

⦄

Ends a dictionary. Optional at the end of the program.

～

BitwiseNot(int).

Add a custom footer

Tutorial

Home

Reference sheet

Syntax

Code page

Commands

Operators

Preset variables

Builtin aliases

Index

Clone this wiki locally