MiniScript Wiki - User contributions [en]

Key

2024-07-17T09:38:34Z

Marc Gurevitx:

In [[Mini Micro]], the <msinline>key</msinline> module is a small collection of functions related to detecting the keyboard state and handling the keyboard input buffer, as well as interfacing with button inputs on joystick/gamepad devices.

{| class="wikitable"
|-
! Method !! Purpose
|-
| [[key.available]] || check whether there is a keypress in the input buffer
|-
| [[key.get]] || pull the next key out of the input buffer (waiting if necessary)
|-
| [[key.put]](keyChar) || allows you to enqueue a string, or single character by code point, into the keyboard buffer
|-
| [[key.clear]] || clear the input buffer
|-
| [[key.pressed]](keyName="space") || check whether a specific key is currently down
|-
| [[key.keyNames]] || get list of all possible names for [[key.pressed]]
|-
| [[key.axis]](axis="Horizontal") || get value (-1 to 1) of an analog input axis
|}

See also: [[input]]; [[mouse]]

[[Category:Mini Micro]]
[[Category:Soda]]
[[Category:Farmtronics]]

Key

2024-07-17T05:14:59Z

Marc Gurevitx: + key.put

In [[Mini Micro]], the <msinline>key</msinline> module is a small collection of functions related to detecting the keyboard state and handling the keyboard input buffer, as well as interfacing with button inputs on joystick/gamepad devices.

{| class="wikitable"
|-
! Method !! Purpose
|-
| [[key.available]] || check whether there is a keypress in the input buffer
|-
| [[key.get]] || pull the next key out of the input buffer (waiting if necessary)
|-
| [[key.put]] || allows you to enqueue a string, or single character by code point, into the keyboard buffer
|-
| [[key.clear]] || clear the input buffer
|-
| [[key.pressed]](keyName="space") || check whether a specific key is currently down
|-
| [[key.keyNames]] || get list of all possible names for [[key.pressed]]
|-
| [[key.axis]](axis="Horizontal") || get value (-1 to 1) of an analog input axis
|}

See also: [[input]]; [[mouse]]

[[Category:Mini Micro]]
[[Category:Soda]]
[[Category:Farmtronics]]

RawData

2024-05-15T10:58:50Z

Marc Gurevitx: /* Examples */ + Convert string -> RawData

The <c>RawData</c> class in [[Mini Micro]] represents a buffer of raw bytes. Interpretation of these bytes is entirely up to the programmer.

See also: [[file.loadRaw]], [[file.saveRaw]]

=== Properties ===
{| class="wikitable"
|-
! Property Name !! Type !! Default Value !! Meaning
|-
| <c>littleEndian</c> || number (boolean) || [[true]] || whether multi-byte values are stored with least significant byte first
|}

=== Methods ===

{| class="wikitable"
|-
! Method !! Description
|-
| <c>len</c> || returns the length of the raw data buffer, in bytes
|-
| <c>[[RawData.resize|resize]](''bytes=32'')</c> || change the size of the raw data buffer
|-
| <c>[[RawData.byte|byte]](''self, offset=0'')</c> || get one unsigned byte of data
|-
| <c>[[RawData.setByte|setByte]](''self, offset=0, value=0'')</c> || set one unsigned byte value
|-
| <c>[[RawData.sbyte|sbyte]](''self, offset=0'')</c> || get one signed byte of data
|-
| <c>[[RawData.setSbyte|setSbyte]](''self, offset=0, value=0'')</c> || set one signed byte value
|-
| <c>[[RawData.ushort|ushort]](''self, offset=0'')</c> || get an unsigned 16-bit integer value
|-
| <c>[[RawData.setUshort|setUshort]](''self, offset=0, value=0'')</c> || set an unsigned 16-bit integer value
|-
| <c>[[RawData.short|short]](''self, offset=0'')</c> || get a signed 16-bit integer value
|-
| <c>[[RawData.setShort|setShort]](''self, offset=0, value=0'')</c> || set a signed 16-bit integer value
|-
| <c>[[RawData.uint|uint]](''self, offset=0'')</c> || get an unsigned 32-bit integer value
|-
| <c>[[RawData.setUint|setUint]](''self, offset=0, value=0'')</c> || set an unsigned 32-bit integer value
|-
| <c>[[RawData.int|int]](''self, offset=0'')</c> || get a signed 32-bit integer value
|-
| <c>[[RawData.setInt|setInt]](''self, offset=0, value=0'')</c> || set a signed 32-bit integer value
|-
| <c>[[RawData.float|float]](''self, offset=0'')</c> || get a 32-bit floating-point value
|-
| <c>[[RawData.setFloat|setFloat]](''self, offset=0, value=0'')</c> || set a 32-bit floating-point value
|-
| <c>[[RawData.double|double]](''self, offset=0'')</c> || get a 64-bit floating-point value
|-
| <c>[[RawData.setDouble|setDouble]](''self, offset=0, value=0'')</c> || set a 64-bit floating-point value
|-
| <c>[[RawData.utf8|utf8]](''self, offset=0, bytes=-1'')</c> || get a string of ASCII or UTF-8 text
|-
| <c>[[RawData.setUtf8|setUtf8]](''self, offset=0, value=""'')</c> || set a string as UTF-8; return number of bytes written
|}

==== Notes ====

The getter and setter methods accept <c>offset</c> argument which, as with [[string]] and [[list]] indexing, may be <c>0 .. (len-1)</c> or <c>-len .. -1</c> where the negative indexes mean offset from the end of data.

If offset (positive or negative) is out of range, an <c>IndexError</c> is raised. Same error is raised if the span of read or written bytes go beyond the data boundaries, with the exception of <c>.setUtf8</c> that writes as much of its string value as possible and drops the rest.

=== Examples ===

<ms>
r = new RawData // Create new RawData of zero length

r.resize 100 // resize it before writing and reading data

r.setByte 42, 200

print r.sbyte(42) // prints: -56
</ms>

==== Converting a string to RawData ====

There's no easy way to know how big a string will be in bytes, but it should be less than (or equal to) 4 times the length. So start with a buffer equal to 4 times s.len, and then after you setUtf8 you can get the actual byte count, and resize your rawData down to size.

<ms>
r = new RawData

s = "ॐ मणि पद्मे हूँ"

r.resize s.len * 4

r.resize r.setUtf8(0, s)

print r.utf8 == "ॐ मणि पद्मे हूँ" // prints: 1
</ms>

Key.axis

2024-04-25T15:39:37Z

Marc Gurevitx: /* Arguments */ +smoothed param

<c>[[key]].axis</c> returns the numeric value (from -1 to 1) of an input axis (for example, a joystick horizontal or vertical axis).

See also: [[key.pressed]]; [[How to move a sprite with directional inputs]]

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''axisName'' || string || Horizontal || name of axis to get
|-
| ''smoothed'' || boolean || 1 || if true, return smoothed values to make the input a little more joystick-like; otherwise, return either <c>-1</c>, <c>0</c> or <c>1</c>
|}

=== Usage Notes ===
Available axis names are:
* "Horizontal" and "Vertical", which can be activated by both WASD and arrow keys as well as any joystick or gamepad
* "Mouse X", "Mouse Y", and "Mouse ScrollWheel", which reflect movement/scrolling with the mouse
* "JoyAxis1" through "JoyAxis29" which detect axis inputs from any joystick or gamepad
* "Joy1Axis1" through "Joy8Axis29" which detect axis inputs from specific joystick/gamepad 1 through 8.

== Example ==

<ms>print key.axis("Vertical")</ms>

A bigger example:

<ms>sp = new Sprite
sp.image = file.loadImage("/sys/pics/Wumpus.png")
display(4).sprites.push sp
speed = 10 // pixels per frame
while true
sp.x = sp.x + key.axis("Horizontal") * speed
sp.y = sp.y + key.axis("Vertical") * speed
yield
end while</ms>

[[Category:Mini Micro]]

RawData

2024-04-15T19:17:25Z

Marc Gurevitx: + Examples

RawData

2024-04-15T19:09:27Z

Marc Gurevitx: /* Methods */ + about offset

PixelDisplay.color

2024-03-01T07:13:26Z

Marc Gurevitx: merging example from PixelDipslay.color

The <c>color</c> property of the [[PixelDisplay]] class sets the default drawing color for subsequent drawing calls such as [[PixelDisplay.line]], [[PixelDisplay.drawRect]], and [[PixelDisplay.fillPoly]].

The default value is "#FFFFFFFF", or solid white.

== Example ==

<ms>gfx.color = color.green
gfx.fillRect 50,100, 200,200</ms>

[[Category:Mini Micro]]

TextDisplay.cellBackColor

2024-02-26T13:49:10Z

Marc Gurevitx: /* Example */ Fix syntax

<c>TextDisplay.cellBackColor</c> returns the background color of the given cell.

See also: [[TextDisplay.setCellBackColor]]

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''x'' || number || 0 || column of interest
|-
| ''y'' || number || 0 || row of interest
|}

=== Usage Notes ===
<c>TextDisplay.cellBackColor</c> may appear as either the text color or the surrounding color, depending
on whether the given cell is in inverse mode.

== Example ==

<ms>print text.cellBackColor(0, 10)</ms>

[[Category:Mini Micro]]

TextDisplay.cellColor

2024-02-26T13:48:21Z

Marc Gurevitx: /* Example */ Fix syntax

<c>[[TextDisplay]].cellColor</c> returns the foreground color of the given cell of a text display.

See also: [[TextDisplay.setCellColor]]

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''x'' || number || 0 || column of interest
|-
| ''y'' || number || 0 || row of interest
|}

=== Usage Notes ===
This may appear as either the text color or the surrounding color, depending
on whether the given cell is in inverse mode.

== Example ==

<ms>print text.cellColor(0, 10)</ms>

[[Category:Mini Micro]]

TextDisplay.backColor

2024-02-25T20:13:00Z

Marc Gurevitx: + about assigning invalid color

<c>[[TextDisplay]].backColor</c> gets or sets the background color used on any future printing to this
text display. This is the surrounding color for normal text, or the
text color for inverse-mode text.

=== Usage Notes ===
Assigning an invalid color value to this property will result in <c>"#00000000"</c> (transparent color).

== Example ==

<ms>text.backColor = color.navy</ms>

[[Category:Mini Micro]]

TextDisplay.color

2024-02-25T20:11:38Z

Marc Gurevitx: + about assigning invalid color

<c>[[TextDisplay]].color</c> gets or sets the foreground [[Color|color]] used on any future printing to this
text display. This is the text color for normal text, or the surrounding
color for inverse-mode text.

=== Usage Notes ===
Assigning an invalid color value to this property will result in <c>"#00000000"</c> (transparent color).

== Example ==

<ms>text.color = color.aqua</ms>

[[Category:Mini Micro]]

TextDisplay

2024-02-21T21:30:00Z

Marc Gurevitx: /* Methods and Properties */ + clear

The <c>TextDisplay</c> class in [[Mini Micro]] is a display type that represents a 68-column, 26-row text character display. Each row/column position in this display is called a "cell" and may display one character, with any foreground and background color (including transparent colors).

[[File:TextDisplay.png|682px|frameless|center|Illustration of the Mini Micro text display: 26 rows by 68 columns.]]

By default, [[display]] 3 is configured as a text display, and is in fact the main text display to which [[print]] prints, and to which the [[text]] global refers (unless you change it). But you can make any display layer a text display by setting its [[Display.mode|mode]] to <c>displayMode.text</c>.

There are two ways to put text into a text display: use the [[TextDisplay.print]] method, which applies the current values of [[TextDisplay.color]], etc.; or set individual cells with [[TextDisplay.setCell]], [[TextDisplay.setCellColor]], etc.

== Methods and Properties ==

{| class="wikitable"
|-
! Method or Property !! Purpose
|-
| [[TextDisplay.color]] || get or set the text color (used on subsequent [[TextDisplay.print]])
|-
| [[TextDisplay.backColor]] || get or set the background color (used on subsequent [[TextDisplay.print]])
|-
| [[TextDisplay.column]] || get/set the cursor column, 0-67 (where subsequent [[TextDisplay.print]] begins)
|-
| [[TextDisplay.row]] || get or set the cursor row, 0-25 (used on subsequent [[TextDisplay.print]])
|-
| [[TextDisplay.inverse]] || when true, subsequent printing swaps text and background color
|-
| [[TextDisplay.delimiter]] || get/set the extra character output after every [[TextDisplay.print]])
|-
| [[TextDisplay.cell]](''x'', ''y'') || get the character at the given column and row
|-
| [[TextDisplay.setCell]] ''x'', ''y'', k || store character ''k'' into the given column and row
|-
| [[TextDisplay.cellColor]](''x'', ''y'') || get the text color at the given column and row
|-
| [[TextDisplay.setCellColor]] ''x'', ''y'', c || set the text color at the given column and row to ''c''
|-
| [[TextDisplay.cellBackColor]](''x'', ''y'') || get the background color at the given column and row
|-
| [[TextDisplay.setCellBackColor]] ''x'', ''y'', c || set the background color at the given column and row to ''c''
|-
| [[TextDisplay.print]] ''s'' || print string ''s'' (followed by the [[TextDisplay.delimiter|delimiter]])
|-
| [[TextDisplay.clear]] || clear the text display
|}

== TextDisplay in Farmtronics ==

The [[Farmtronics]] computer also has a TextDisplay, but it is only 20 rows by 40 columns. Moreover, there is only ''one'' TextDisplay, unlike Mini Micro, which can have any number of them.

[[Category:Mini Micro]]
[[Category:Farmtronics]]

Env.shell

2024-02-18T08:16:37Z

Marc Gurevitx: Copy paste `help "shells"`

In Mini Micro, a "shell" is a program that launches other programs, and which is automatically re-run when those other programs exit. You can make any program a shell by storing its path in <c>env.shell</c>.

The <c>/sys/demo</c> directory contains three shell programs:

* <c>demos</c>: lists and easily runs a subset of demos
* <c>desktop</c>: a simple desktop-style graphical interface
* <c>lcars</c>: a futuristic sci-fi graphical interface

In addition, these are defined (by code in <c>/sys/startup.ms</c>) as commands in their own right. So, for example, you can launch the desktop shell by just entering <c>desktop</c> at the command line.

Once you have a shell defined in <c>env.shell</c>, you can return to it from the command line (or a program) by using [[exit]]. But note that pressing control-C will always break out to the MiniScript prompt, even if a shell is defined.

Env

2024-02-18T08:12:50Z

Marc Gurevitx: /* Mini Micro */ + shell

<c>env</c> is a built-in map in both [[Mini Micro]] and [[command-line MiniScript]]. It has somewhat different meaning and usage in each environment.

== Mini Micro ==

In [[Mini Micro]], <c>env</c> refers to a map of special values that affect the Mini Micro environment. It contains at least the following keys:

{| class="wikitable"
|-
! Key !! Meaning
|-
| bootOpts || a complete copy of the data in the [[bootOpts.grfon]] file
|-
| curdir || current working directory (same as [[pwd]])
|-
| cmdLine || command line command that was used to launch Mini Micro (where applicable)
|-
| cmdLineArgs || command line arguments (as a [[list]]) used when Mini Micro was launched (where applicable)
|-
| importPaths || [[list]] of directories searched for [[import]] modules
|-
| prompt || [[string]] or [[function]] to use as the command-line prompt
|-
| morePrompt || [[string]] or [[function]] to use as the prompt when more input is needed
|-
| shell || path to the current [[Env.shell|shell]] program (<c>""</c> for the default Mini Micro shell)
|}

== Command-Line MiniScript ==

In [[command-line MiniScript]], <c>env</c> is a copy of the shell environment variables. Assignments to entries of <c>env</c> add or update environment variables. (Deleting environment variables is not possible; you may delete from the <c>env</c> map, but this does not actually affect the environment.)

The exact meaning of environment variables varies with the platform. They have many uses, such as in [http://www.cgi101.com/book/ch3/text.html CGI scripts].

=== Windows Version ===
{| class="wikitable"
|-
! Key !! Default !! Meaning
|-
| MS_EXE_DIR || Launch directory ||Returns the directory ([[String]]) of which the miniscript.exe was launched from
|-
| MS_IMPORT_PATH || "$MS_SCRIPT_DIR/lib:$MS_EXE_DIR/lib" ||directory listings ([[String]]) of where MiniScript files are located allowing [[Import]] to search in those for file import.
|-
| HOMEPATH || User home || Returns the home Directory ([[String]]) of the user that had launched miniscript.exe
|}

=== Linux Version===
{| class="wikitable"
|-
! Key !! Default !! Meaning
|}

== Useful tips ==

=== Adding more import paths (Windows Command Line) ===
To add more folders to [[Import]] from, alter or add the path with a dollar sign ('''$''') to the beginning of $MS_SCRIPT_DIR or $MS_EXE_DIR [[String]] text with a forward slash ('''/''') before the folder name like so: '''$MS_SCRIPT_DIR/sprites'''. To add multiple paths for import simply add a colon (''':''') between the designated paths to indicate multiple directories to import from. Apply the string to the [[Env|env]].MS_IMPORT_PATH like below:

<ms> env.MS_IMPORT_PATH = "$MS_SCRIPT_DIR/sprites" // replaces the default with one folder named sprites
env.MS_IMPORT_PATH = "$MS_SCRIPT_DIR/lib:$MS_EXE_DIR/lib:$MS_SCRIPT_DIR/sprites" // default plus new folder sprites</ms>

[[Category:Mini Micro]]
[[Category:Command-Line MiniScript]]
[[Category:Farmtronics]]

Open-Source Projects

2024-02-06T17:44:12Z

Marc Gurevitx: /* Third-Party Implementations/Ports */

This page is a collection of links to open-source projects in or for MiniScript.

=== Main Repository ===
https://github.com/JoeStrout/miniscript

Official repository of source code for the MiniScript language (both C# and C++ versions), as well as [[Command-Line MiniScript]].

=== Third-Party Implementations/Ports ===
==== Java version of MiniScript ====
https://github.com/heatseeker0/JavaMiniScript

A third-party reimplementation of MiniScript in Java, suitable for adding MiniScript support to Java games and apps.

==== Kotlin version of MiniScript ====
https://github.com/Arcnor/miniscript-kt

A third-party reimplementation of MiniScript in Kotlin (a more modern Java-like language which runs on the JVM).

==== MiniScript in MiniScript ====
https://github.com/marcgurevitx/ms-ms

A MiniScript parser and evaluator written in MiniScript. Works in [[Command-Line MiniScript]] and [[Mini Micro]] (a slightly modified version of [[TestSuite.txt]] passes).

=== MiniScript-Enhanced Development Environments ===

==== Soda ====
https://github.com/JoeStrout/soda

An open-source, cross-platform game development environment based on MiniScript and SDL.

==== MiniScript in RayLib ====
https://github.com/AlRado/Raylib-cs-Examples/tree/miniscript

Adds MiniScript support to RayLib-cs, an open-source C# game engine.

==== MiniScript in MonoGame ====
https://github.com/guiprada/monomicro

Adds MiniScript support to MonoGame, another open-source C# game engine.

==== GameLodge ====
https://github.com/bananaHemic/gamelodge_unity

A multiplayer VR project that supports online coding & development based on MiniScript. Edit the game while people are in it!

=== Editors & Syntax Highlighting ===

==== NotePad++ UDL ====
: https://github.com/SynapticBytes/MiniScript-UDL-for-Notepad-plus-plus
: User-Defined Language for the NotePad++ text editor for Windows.

==== VS Code Language Toolkit ====
: https://marketplace.visualstudio.com/items?itemName=ayecue.miniscript-vs
: MiniScript Toolkit for Visual Studio Code. Includes syntax highlighting, a built-in interpreter and debugger, and many more features.

==== VS Code Language Module ====
: https://bitbucket.org/colinmac/miniscript-syntax/src/master/
: Provides MiniScript syntax highlighting for Visual Studio Code.

==== BBEdit Language Module ====
: https://github.com/JoeStrout/miniscript-bbedit-lang-mod
: Provides MiniScript syntax highlighting for the BBEdit text editor for macOS.

==== Pygments fork ====
: https://github.com/JoeStrout/pygments
: Fork of the Pygments syntax-coloring library which adds support for MiniScript.
: [https://github.com/pygments/pygments/pull/1397 Merged] into the main Pygments repo on Feb. 29, 2020.

==== Highlight.js Package ====
: https://github.com/JoeStrout/highlightjs-miniscript
: Add-on language module for [https://github.com/highlightjs/highlight.js Highlight.js].

=== MiniScript code libraries ===

==== minimicro-fonts ====
: https://github.com/JoeStrout/minimicro-fonts
: Provides support for colored, proportional or monospaced screen fonts in BMF format.

==== minimicro-tiled ====
: https://github.com/Mantic/minimicro-tiled
: Provides a [https://www.mapeditor.org/ Tiled] map importer and renderer!

=== Games/Apps/Programs written in MiniScript ===

* '''Annelids''': https://github.com/JoeStrout/annelids
* '''Sokoban''': https://github.com/sebnozzi/minimicro-sokoban
* '''Quatris''': https://github.com/JoeStrout/quatris
* '''Clacks''': https://github.com/JoeStrout/clacks
* '''Memory Game''': https://github.com/sebnozzi/minimicro-memorygame
* '''Sliding Puzzle''': https://github.com/sebnozzi/minimicro-sliding-puzzle/
* '''Letter Shooter''': https://github.com/sebnozzi/minimicro-lettershooter/
* '''minimicro-raytracer''': https://github.com/Syntaxxor/minimicro-raytracer
* '''World Conquest''': https://github.com/JoeStrout/worldConquest
* '''Retro Robots''': https://github.com/JoeStrout/RetroRobots
* '''μ-hack''': https://github.com/treytomes/micro-hack

=== Tagged collections ===

* GitHub: https://github.com/topics/miniscript
* itch.io: https://itch.io/games/tag-minimicro
* Rosetta Code: http://www.rosettacode.org/wiki/Category:MiniScript

Key.keyNames

2023-12-13T19:01:53Z

Marc Gurevitx: Deleted redundant `while true`

<c>[[key]].keyNames</c> returns a list of all the key names available for use with <c>[[key.pressed]]</c>.

=== Usage Notes ===
This can be used to check (via <c>[[key.pressed]]</c>) all possible button-like inputs (keypresses, joystick buttons, etc). For example: if waiting for the user to press anything to continue or while configuring their input preferences.

Note the values from <c>[[key]].keyNames</c> are not the same that are received from <c>[[key.get]]</c>. <c>[[key.get]]</c> returns characters including upper- and lower-case letters, etc., which may be generated by a single key or some key combination (such as shift-4 for $ on a U.S. keyboard), whereas <c>[[key]].keyNames</c> and <c>[[key.pressed]]</c> refer to physical hardware keys, regardless of what character (if any) they generate.

== Example 1 ==

<ms>while true
for n in key.keyNames
if key.pressed(n) then
while key.pressed(n)
end while
print n
end if
end for
end while</ms>

See also: <c>[[key.pressed]]</c>, <c>[[key]]</c>

== Sample Output ==
<div class="toccolours mw-collapsible mw-collapsed">
Windows 10 sample output:
<div class="mw-collapsible-content">
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
1
2
3
4
5
6
7
8
9
0
-
=
[
]
\
,
.
/
;
'
`
f1
f2
f3
f4
f5
f6
f7
f8
f9
f10
f11
f12
f13
f14
f15
up
down
left
right
[1]    // keypad input
[2]    // keypad input
[3]    // keypad input
[4]    // keypad input
[5]    // keypad input
[6]    // keypad input
[7]    // keypad input
[8]    // keypad input
[9]    // keypad input
[0]    // keypad input
[+]    // keypad input
[-]    // keypad input
[*]    // keypad input
[/]    // keypad input
enter
equals
clear
left shift
right shift
left ctrl
right ctrl
left alt
right alt
left cmd
right cmd
backspace
tab
return
escape
space
delete
insert
home
end
page up
page down
mouse 0
mouse 1
mouse 2
mouse 3
mouse 4
mouse 5
mouse 6
joystick button 0
joystick button 1
joystick button 2
joystick button 3
joystick button 4
joystick button 5
joystick button 6
joystick button 7
joystick button 8
joystick button 9
joystick button 10
joystick button 11
joystick button 12
joystick button 13
joystick button 14
joystick button 15
joystick 1 button 0
joystick 1 button 1
joystick 1 button 2
joystick 1 button 3
joystick 1 button 4
joystick 1 button 5
joystick 1 button 6
joystick 1 button 7
joystick 1 button 8
joystick 1 button 9
joystick 1 button 10
joystick 1 button 11
joystick 1 button 12
joystick 1 button 13
joystick 1 button 14
joystick 1 button 15
joystick 2 button 0
joystick 2 button 1
joystick 2 button 2
joystick 2 button 3
joystick 2 button 4
joystick 2 button 5
joystick 2 button 6
joystick 2 button 7
joystick 2 button 8
joystick 2 button 9
joystick 2 button 10
joystick 2 button 11
joystick 2 button 12
joystick 2 button 13
joystick 2 button 14
joystick 2 button 15
joystick 3 button 0
joystick 3 button 1
joystick 3 button 2
joystick 3 button 3
joystick 3 button 4
joystick 3 button 5
joystick 3 button 6
joystick 3 button 7
joystick 3 button 8
joystick 3 button 9
joystick 3 button 10
joystick 3 button 11
joystick 3 button 12
joystick 3 button 13
joystick 3 button 14
joystick 3 button 15
joystick 4 button 0
joystick 4 button 1
joystick 4 button 2
joystick 4 button 3
joystick 4 button 4
joystick 4 button 5
joystick 4 button 6
joystick 4 button 7
joystick 4 button 8
joystick 4 button 9
joystick 4 button 10
joystick 4 button 11
joystick 4 button 12
joystick 4 button 13
joystick 4 button 14
joystick 4 button 15
</div>
</div>

[[Category:Mini Micro]]

Comparison

2023-11-22T15:10:36Z

Marc Gurevitx: /* Equality */

Comparison operators: <c> == </c>, <c> != </c>, <c> > </c>, <c> < </c>, <c> >= </c>, <c> <= </c>.

== Equality ==

The operator <c>==</c> tests for equality; the operator <c>!=</c> is the negation of equality. These operators always result in [[true]] or [[false]] (or in some cases of incompatible types - <c>null</c>). Both can be applied to ''any'' values, not necessarily of the same type. If the values have different types, they're considered not equal. Otherwise, they're compared according to their types:

* [[null]] is equal to itself
* [[number]]s and [[string]]s are compared in the usual way. (Unlike in some other languages, <c>0 == "0"</c> is false.)
* [[list]]s are equal if they contain equal elements
* [[map]]s are equal if they contain equal key/value pairs
* [[funcRef]]s are equal if they reference the same function
* The special value [[NaN]] is not equal to anything, even to itself

To compare [[list]]s and [[map]]s by reference, use [[refEquals]] function.

== Relational operators ==

Comparisons <c> > </c>, <c> < </c>, <c> >= </c>, <c> <= </c> are defined for numbers (arithmetic comparison) and strings (alphabetic comparison). These cases result in [[true]] or [[false]].

For other data types or for operands of different data types they return [[null]].

If the operands are a number and a [[null]], they substitute [[null]] with <c>0</c> (resulting in [[true]] or [[false]]).

If the operands are a string and a [[null]], it considers the string being always greater than [[null]] (resulting in [[true]] or [[false]]).

All six operators support [[Operators#Comparison_Operators|chaining]].

=== Examples ===

<ms>
print null == null // prints 1
print 0 != "0" // prints 1
print 13 < 42 <= 420 // prints 1
print 2 < 15 // prints 1
print "2" < "15" // prints 0, alphabetic comparison
print 0/0 == 0/0 // prints 0, NaN != NaN
print [1, 2, 3] == [1, 2, 3] // prints 1
print 0 != null and 0 >= null and 0 <= null // prints 1 :)
</ms>

[[Category:Language]]

Operators

2023-11-20T21:35:11Z

Marc Gurevitx: /* Comparison Operators */ Added chaining of ==/!=

MiniScript defines the following operators (listed in order from lowest to highest precedence):

{| class="wikitable"
|-
! Operator !! Meaning !! Precedence
|-
| A <c>=</c> B || assignment || 0
|-
| A <c>or</c> B || logical OR: true if either operand is true || 1
|-
| A <c>and</c> B || logical AND: true if both operands are true || 2
|-
| <c>not</c> A || logical negation: true if its operand is false, and vice versa || 3
|-
| A <c>[[isa]]</c> B || type checking || 4
|-
| A <c>==</c> B || equality comparison: true if operands are equal || 5
|-
| A <c>!=</c> B || inequality comparison: true if operands are not equal || 5
|-
| A <c>></c> B || greater-than comparison || 5
|-
| A <c><</c> B || less-than comparison || 5
|-
| A <c>>=</c> B || greater-than or equal-to comparison || 5
|-
| A <c><=</c> B || less-than or equal-to comparison || 5
|-
| A <c>+</c> B || addition or concatenation || 6
|-
| A <c>-</c> B || subtraction or string trimming || 6
|-
| A <c>*</c> B || multiplication or replication || 7
|-
| A <c>/</c> B || division or reduction || 7
|-
| A <c>%</c> B || modulo (remainder) || 7
|-
| <c>-A</c> || unary minus (numeric negation) || 8
|-
| <c>[[new]]</c> A || instantiation || 9
|-
| <c>@</c>A || [[@ operator|address-of]] (reference function without invoking it) || 10
|-
| A <c>^</c> B || power: A raised to the power of B || 11
|-
| <c>A[</c>B<c>]</c> || indexing || 12
|-
| <c>A[</c>B<c>:</c>C<c>]</c> || slicing || 12
|-
| <c>A(</c>B, C...<c>)</c> || [[Function#Calling_a_Function | calling a function]] || 12
|-
| A<c>.</c>B || [[Dot syntax|dot operator]] || 12
|}

== Chaining Operators ==

Most binary operators in MiniScript can be combined into chains, for example <c>39 + 2 + 1</c>. The details depend on the type of operator:

=== Arithmetic Operators ===

In an expression involving a chain of arithmetic operators, the highest-precedent operators are evaluated first, as in standard algebra. You can always use parentheses to break such a chain into smaller chunks, forcing a different evaluation order.

{| class="wikitable"
|-
! Code !! Result
|-
| <c>2 + 5 * 8</c> || 42
|-
| <c>(2 + 5) * 8</c> || 56
|-
| <c>3 ^ 2 + 4 ^ 2</c> || 25
|}

=== Comparison Operators ===

In the case of comparison operators (<c>==</c>, <c>!=</c>, <c>></c>, <c><</c>, <c>>=</c> and <c><=</c>), operands are compared in pairs from left to right. All comparisons must be true for the complete chained expression to be considered true. The most common use of this is to check whether a variable is in a certain range, with an expression like <c>0 < x < 10</c>, which is true only if <c>x</c> is between 0 and 10 (non-inclusive).

{| class="wikitable"
|-
! Code !! Given !! Result || Read As
|-
| <c>0 < x < 10</c> || x = 5 || true || x is between 0 and 10
|-
| <c>0 < x < 10</c> || x = 10 || false || x is between 0 and 10
|-
| <c>0 < x <= 10</c> || x = 10 || true || x is between 0 and 10 (including 10)
|-
| <c>0 < x < 10 < y</c> || x = 5; y = 15 || true || x is between 0 and 10, and 10 is less than y
|-
| <c>0 < x == 5 < y</c> || x = 5; y = 15 || true || <c>0 < x</c> ''and'' <c>x == 5</c> ''and'' <c>5 < y</c>
|}

=== Dot Operator ===

A chain of [[Dot syntax|dot operations]] is evaluated one step at a time left to right.

For example, given the code:
<ms>foo.bar.baz</ms>

MiniScript proceeds in the following steps:
# <c>foo.bar</c> is evaluated by looking up "bar" in <c>foo</c> (and in the event that this references a function, it's invoked with <c>[[self]]</c> bound to <c>foo</c>.
# <c>.baz</c> is evaluated by looking up "baz" in the result of step 1 (which should be a map). (And if "baz" references a function, it's invoked with <c>[[self]]</c> bound to the map from step 1.)

This can continue for an arbitrarily long chain of dot operators.

== Math-assignment operators ==

In version ''1.6'' the math-assignment operators were added. They overwrite the value of the first operand variable with the result of the operation when performing the operator without assignment.

<ms>
x = 42
x += 13 // x = x + 13
print x // 55

s = "hello.ms"
s -= ".ms" // s = s - ".ms"
print s // "hello"
</ms>

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>+=</c> B || A = A + B
|-
| A <c>-=</c> B || A = A - B
|-
| A <c>*=</c> B || A = A * B
|-
| A <c>/=</c> B || A = A / B
|-
| A <c>%=</c> B || A = A % B
|-
| A <c>^=</c> B || A = A ^ B
|}

== Tricky spaces ==

MiniScript allows an expression to be the entire statement (which is useful in [[REPL]] where it evaluates the expression and immediately prints the result).

<ms>
4 + 5 // REPL prints 9

f = function(x,y)
x + y // the result is "dropped"
end function
f 4, 5 // prints nothing

</ms>

There are a few cases when using different spacing around operators in such expressions may make MiniScript confuse it with a function call:

<ms>
X[Y] // Index X with key Y
X [Y] // Call function X with argument [Y]

X-Y // Subtract Y from X
X- Y // Subtract Y from X
X -Y // Call function X with argument -Y
X - Y // Subtract Y from X
</ms>

Follow a simple convention to avoid such problems: put spaces around arithmetic operators and if possible don't use a space between an unary operator and its operand.

[[Category:Language]]

Comparison

2023-11-17T16:10:39Z

Marc Gurevitx: Details on comparison

Comparison operators: <c> == </c>, <c> != </c>, <c> > </c>, <c> < </c>, <c> >= </c>, <c> <= </c>.

== Equality ==

The operator <c>==</c> tests for equality; the operator <c>!=</c> is the negation of equality. These operators always result in [[true]] or [[false]]. Both can be applied to ''any'' values, not necessarily of the same type. If the values have different types, they're considered not equal. Otherwise, they're compared according to their types:

* [[null]] is equal to itself
* [[number]]s and [[string]]s are compared in the usual way. (Unlike in some other languages, <c>0 == "0"</c> is false.)
* [[list]]s are equal if they contain equal elements
* [[map]]s are equal if they contain equal key/value pairs
* [[funcRef]]s are equal if they reference the same function
* The special value [[NaN]] is not equal to anything, even to itself

To compare [[list]]s and [[map]]s by reference, use [[refEquals]] function.

== Relational operators ==

Comparisons <c> > </c>, <c> < </c>, <c> >= </c>, <c> <= </c> are defined for numbers (arithmetic comparison) and strings (alphabetic comparison). These cases result in [[true]] or [[false]].

For other data types or for operands of different data types they return [[null]].

If the operands are a number and a [[null]], they substitute [[null]] with <c>0</c> (resulting in [[true]] or [[false]]).

If the operands are a string and a [[null]], it considers the string being always greater than [[null]] (resulting in [[true]] or [[false]]).

All six operators support [[Operators#Comparison_Operators|chaining]].

=== Examples ===

<ms>
print null == null // prints 1
print 0 != "0" // prints 1
print 13 < 42 <= 420 // prints 1
print 2 < 15 // prints 1
print "2" < "15" // prints 0, alphabetic comparison
print 0/0 == 0/0 // prints 0, NaN != NaN
print [1, 2, 3] == [1, 2, 3] // prints 1
print 0 != null and 0 >= null and 0 <= null // prints 1 :)
</ms>

[[Category:Language]]

Isa

2023-11-17T08:43:58Z

Marc Gurevitx: /* isa (operator) */ Other types as RHS

Because this wiki software does not allow topic names to begin with an underscore, this page contains two different topics.

== isa (operator) ==
<c>isa</c> is a [[:Category:Keywords|keyword]] binary [[operators|operator]] which tests the left-hand operator for membership in the type defined by the right-hand side. That right-hand operand could be a user-defined map (to which the left-hand side might belong via the <c>__isa</c> chain), or it could be one of the [[:Category:Data Types|built-in types]]: [[number]], [[string]], [[list]], [[map]], or [[funcRef]].

=== Examples for built-in types ===

<ms>"Hello" isa string // returns 1
"Hello" isa number // returns 0
123 isa number // returns 1
"123" isa number // returns 0
[1,2,3] isa list // returns 1
{"uno":1,"dos":2} isa map // returns 1
@print isa funcRef // returns 1
</ms>

=== Examples for user-defined types ===

<ms>
MyDefinedType = {}
MyOtherDefinedType = {}

obj = new MyDefinedType

obj isa MyDefinedType // returns 1 - direct type
obj isa map // returns 1 - related by inheritance

obj isa MyOtherDefinedType // returns 0 - because unrelated
</ms>

=== Other types as RHS ===

As of MiniScript version <c>1.6.1</c>, it's possible to use ''any'' value as a right hand side of an <c>isa</c> operator. When such values are not types, the operator returns [[false]], except when it's a [[null]] in which case <c>isa</c> checks for equality with [[null]] (this behavior might currently be affected by [https://github.com/JoeStrout/miniscript/issues/84 a bug]).

== __isa (map entry) ==
<c>__isa</c> is a special entry in a map that refers to the map's base class. It is part of MiniScript's support for [[object-oriented programming]].

== See also ==

* [[Object-oriented programming]] in miniscript
* The [[map]] type

[[Category:Language]]
[[Category:Keywords]]
[[Category:Operators]]

{{stub}}

RefEquals

2023-11-17T08:13:37Z

Marc Gurevitx: /* Example */

The <c>refEquals</c> function checks two values for reference equality. This is different from the <c>==</c> operator, which checks whether two values are ''equivalent'' (e.g., two maps that contain equal key/value pairs, or two lists which contain equal values).

Whenever <c>refEquals(a, b)</c> is true (1), then you know that any modification of <c>a</c> will also be seen via <c>b</c>, because <c>a</c> and <c>b</c> refer to the same object.

For immutable types – <c>null</c>s, <c>number</c>s and <c>string</c>'s – <c>refEquals</c> returns the same result as the <c>==</c> operator.

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Default Value !! Meaning
|-
| ''a'' || any value|| first argument
|-
| ''b'' || any value || second argument
|}

== Example ==

<ms>a = {"foo":42}
b = a
c = {"foo":42}
print a == b // prints 1, because a and b have the same value
print a == c // prints 1, because a and c have the same value
print refEquals(a,b) // prints 1, as these are the same map
print refEquals(a,c) // prints 0, as these are different maps

print refEquals(42,42)// prints 1
nan = 0/0
print refEquals(nan,nan)//prints 0
</ms>

[[Category:Intrinsic Functions]]
[[Category:Numeric Functions]]

Truth

2023-11-16T19:15:09Z

Marc Gurevitx: Created page with "In MiniScript certain statements and operations interpret their parts as being ''true'' or ''not true''. These are the conditions of the if and while statements, and t..."

In MiniScript certain statements and operations interpret their parts as being ''true'' or ''not true''. These are the conditions of the [[if]] and [[while]] statements, and the operands of [[and]], [[or]] and [[not]] operators <ref>Boolean operators treat numbers between 0 and 1 in a [[Fuzzy Logic|fuzzy manner]]</ref>.

Any MiniScript value - not only [[true]] and [[false]] values - can be used in these constructions. This is how they are interpreted:

{| class="wikitable"
|-
! Type || Considered false || Considered true
|-
| [[null]] || always false ||
|-
| [[number]] || <c>0</c>, [[false]] || any non-zero number, including [[true]], [[INF]]s and [[NaN]]
|-
| [[string]] || empty string (<c>""</c>) || non-empty strings
|-
| [[list]] || empty list (<c>[]</c>) || non-empty lists
|-
| [[map]] || empty map (<c>{}</c>) || non-empty maps
|-
| [[funcRef]] || || ''should'' always be true (but see [https://github.com/JoeStrout/miniscript/issues/87 this bug] for a command-line version)
|-
|}

== Examples ==

<ms>
if 0 then print "hi" // prints nothing

if 0/0 then print "hi" // prints "hi"

if [false] then print "hi" // prints "hi"

print 0 or {0:0} // prints 1
</ms>

<references />

[[Category:Language]]

RefEquals

2023-11-11T20:10:18Z

Marc Gurevitx: On immutable types

The <c>refEquals</c> function checks two values for reference equality. This is different from the <c>==</c> operator, which checks whether two values are ''equivalent'' (e.g., two maps that contain equal key/value pairs, or two lists which contain equal values).

Whenever <c>refEquals(a, b)</c> is true (1), then you know that any modification of <c>a</c> will also be seen via <c>b</c>, because <c>a</c> and <c>b</c> refer to the same object.

For immutable types – <c>null</c>s, <c>number</c>s and <c>string</c>'s – <c>refEquals</c> returns the same result as the <c>==</c> operator.

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Default Value !! Meaning
|-
| ''a'' || any value|| first argument
|-
| ''b'' || any value || second argument
|}

== Example ==

<ms>a = {"foo":42}
b = a
c = {"foo":42}
print a == b // prints 1, because a and b have the same value
print a == c // prints 1, because a and c have the same value
print refEquals(a,b) // prints 1, as these are the same map
print refEquals(a,c) // prints 0, as these are different maps
</ms>

[[Category:Intrinsic Functions]]
[[Category:Numeric Functions]]

Operators

2023-11-03T10:06:59Z

Marc Gurevitx: Removing space between - and A

MiniScript defines the following operators (listed in order from lowest to highest precedence):

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>=</c> B || assignment
|-
| A <c>or</c> B || logical OR: true if either operand is true
|-
| A <c>and</c> B || logical AND: true if both operands are true
|-
| <c>not</c> A || logical negation: true if its operand is false, and vice versa
|-
| A <c>[[isa]]</c> B || type checking
|-
| A <c>==</c> B || equality comparison: true if operands are equal
|-
| A <c>!=</c> B || inequality comparison: true if operands are not equal
|-
| A <c>></c> B || greater-than comparison
|-
| A <c><</c> B || less-than comparison
|-
| A <c>>=</c> B || greater-than or equal-to comparison
|-
| A <c><=</c> B || less-than or equal-to comparison
|-
| A <c>+</c> B || addition or concatenation
|-
| A <c>-</c> B || subtraction or string trimming
|-
| A <c>*</c> B || multiplication or replication
|-
| A <c>/</c> B || division or reduction
|-
| A <c>%</c> B || modulo (remainder)
|-
| <c>-A</c> || unary minus (numeric negation)
|-
| <c>[[new]]</c> A || instantiation
|-
| <c>@</c>A || [[@ operator|address-of]] (reference function without invoking it)
|-
| A <c>^</c> B || power: A raised to the power of B
|-
| <c>A[</c>B<c>]</c> || indexing
|-
| <c>A[</c>B<c>:</c>C<c>]</c> || slicing
|-
| <c>A(</c>B, C...<c>)</c> || [[Function#Calling_a_Function | calling a function]]
|-
| A<c>.</c>B || [[Dot syntax|dot operator]]
|}

== Chaining Operators ==

Most binary operators in MiniScript can be combined into chains, for example <c>39 + 2 + 1</c>. The details depend on the type of operator:

=== Arithmetic Operators ===

In an expression involving a chain of arithmetic operators, the highest-precedent operators are evaluated first, as in standard algebra. You can always use parentheses to break such a chain into smaller chunks, forcing a different evaluation order.

{| class="wikitable"
|-
! Code !! Result
|-
| <c>2 + 5 * 8</c> || 42
|-
| <c>(2 + 5) * 8</c> || 56
|-
| <c>3 ^ 2 + 4 ^ 2</c> || 25
|}

=== Comparison Operators ===

In the case of comparison operators (<c>></c>, <c><</c>, <c>>=</c> and <c><=</c>), operands are compared in pairs from left to right. All comparisons must be true for the complete chained expression to be considered true. The most common use of this is to check whether a variable is in a certain range, with an expression like <c>0 < x < 10</c>, which is true only if <c>x</c> is between 0 and 10 (non-inclusive).

{| class="wikitable"
|-
! Code !! Given !! Result || Read As
|-
| <c>0 < x < 10</c> || x = 5 || true || x is between 0 and 10
|-
| <c>0 < x < 10</c> || x = 10 || false || x is between 0 and 10
|-
| <c>0 < x <= 10</c> || x = 10 || true || x is between 0 and 10 (including 10)
|-
| <c>0 < x < 10 < y</c> || x = 5; y = 15 || true || x is between 0 and 10, and 10 is less than y
|}

=== Dot Operator ===

A chain of [[Dot syntax|dot operations]] is evaluated one step at a time left to right.

For example, given the code:
<ms>foo.bar.baz</ms>

MiniScript proceeds in the following steps:
# <c>foo.bar</c> is evaluated by looking up "bar" in <c>foo</c> (and in the event that this references a function, it's invoked with <c>[[self]]</c> bound to <c>foo</c>.
# <c>.baz</c> is evaluated by looking up "baz" in the result of step 1 (which should be a map). (And if "baz" references a function, it's invoked with <c>[[self]]</c> bound to the map from step 1.)

This can continue for an arbitrarily long chain of dot operators.

== Math-assignment operators ==

In version ''1.6'' the math-assignment operators were added. They overwrite the value of the first operand variable with the result of the operation when performing the operator without assignment.

<ms>
x = 42
x += 13 // x = x + 13
print x // 55

s = "hello.ms"
s -= ".ms" // s = s - ".ms"
print s // "hello"
</ms>

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>+=</c> B || A = A + B
|-
| A <c>-=</c> B || A = A - B
|-
| A <c>*=</c> B || A = A * B
|-
| A <c>/=</c> B || A = A / B
|-
| A <c>%=</c> B || A = A % B
|-
| A <c>^=</c> B || A = A ^ B
|}

== Tricky spaces ==

MiniScript allows an expression to be the entire statement (which is useful in [[REPL]] where it evaluates the expression and immediately prints the result).

<ms>
4 + 5 // REPL prints 9

f = function(x,y)
x + y // the result is "dropped"
end function
f 4, 5 // prints nothing

</ms>

There are a few cases when using different spacing around operators in such expressions may make MiniScript confuse it with a function call:

<ms>
X[Y] // Index X with key Y
X [Y] // Call function X with argument [Y]

X-Y // Subtract Y from X
X- Y // Subtract Y from X
X -Y // Call function X with argument -Y
X - Y // Subtract Y from X
</ms>

Follow a simple convention to avoid such problems: put spaces around arithmetic operators and if possible don't use a space between an unary operator and its operand.

[[Category:Language]]

Operators

2023-11-03T10:05:04Z

Marc Gurevitx: Removing space between A and brackets

MiniScript defines the following operators (listed in order from lowest to highest precedence):

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>=</c> B || assignment
|-
| A <c>or</c> B || logical OR: true if either operand is true
|-
| A <c>and</c> B || logical AND: true if both operands are true
|-
| <c>not</c> A || logical negation: true if its operand is false, and vice versa
|-
| A <c>[[isa]]</c> B || type checking
|-
| A <c>==</c> B || equality comparison: true if operands are equal
|-
| A <c>!=</c> B || inequality comparison: true if operands are not equal
|-
| A <c>></c> B || greater-than comparison
|-
| A <c><</c> B || less-than comparison
|-
| A <c>>=</c> B || greater-than or equal-to comparison
|-
| A <c><=</c> B || less-than or equal-to comparison
|-
| A <c>+</c> B || addition or concatenation
|-
| A <c>-</c> B || subtraction or string trimming
|-
| A <c>*</c> B || multiplication or replication
|-
| A <c>/</c> B || division or reduction
|-
| A <c>%</c> B || modulo (remainder)
|-
| <c>-</c>A || unary minus (numeric negation)
|-
| <c>[[new]]</c> A || instantiation
|-
| <c>@</c>A || [[@ operator|address-of]] (reference function without invoking it)
|-
| A <c>^</c> B || power: A raised to the power of B
|-
| <c>A[</c>B<c>]</c> || indexing
|-
| <c>A[</c>B<c>:</c>C<c>]</c> || slicing
|-
| <c>A(</c>B, C...<c>)</c> || [[Function#Calling_a_Function | calling a function]]
|-
| A<c>.</c>B || [[Dot syntax|dot operator]]
|}

== Chaining Operators ==

Most binary operators in MiniScript can be combined into chains, for example <c>39 + 2 + 1</c>. The details depend on the type of operator:

=== Arithmetic Operators ===

In an expression involving a chain of arithmetic operators, the highest-precedent operators are evaluated first, as in standard algebra. You can always use parentheses to break such a chain into smaller chunks, forcing a different evaluation order.

{| class="wikitable"
|-
! Code !! Result
|-
| <c>2 + 5 * 8</c> || 42
|-
| <c>(2 + 5) * 8</c> || 56
|-
| <c>3 ^ 2 + 4 ^ 2</c> || 25
|}

=== Comparison Operators ===

In the case of comparison operators (<c>></c>, <c><</c>, <c>>=</c> and <c><=</c>), operands are compared in pairs from left to right. All comparisons must be true for the complete chained expression to be considered true. The most common use of this is to check whether a variable is in a certain range, with an expression like <c>0 < x < 10</c>, which is true only if <c>x</c> is between 0 and 10 (non-inclusive).

{| class="wikitable"
|-
! Code !! Given !! Result || Read As
|-
| <c>0 < x < 10</c> || x = 5 || true || x is between 0 and 10
|-
| <c>0 < x < 10</c> || x = 10 || false || x is between 0 and 10
|-
| <c>0 < x <= 10</c> || x = 10 || true || x is between 0 and 10 (including 10)
|-
| <c>0 < x < 10 < y</c> || x = 5; y = 15 || true || x is between 0 and 10, and 10 is less than y
|}

=== Dot Operator ===

A chain of [[Dot syntax|dot operations]] is evaluated one step at a time left to right.

For example, given the code:
<ms>foo.bar.baz</ms>

MiniScript proceeds in the following steps:
# <c>foo.bar</c> is evaluated by looking up "bar" in <c>foo</c> (and in the event that this references a function, it's invoked with <c>[[self]]</c> bound to <c>foo</c>.
# <c>.baz</c> is evaluated by looking up "baz" in the result of step 1 (which should be a map). (And if "baz" references a function, it's invoked with <c>[[self]]</c> bound to the map from step 1.)

This can continue for an arbitrarily long chain of dot operators.

== Math-assignment operators ==

In version ''1.6'' the math-assignment operators were added. They overwrite the value of the first operand variable with the result of the operation when performing the operator without assignment.

<ms>
x = 42
x += 13 // x = x + 13
print x // 55

s = "hello.ms"
s -= ".ms" // s = s - ".ms"
print s // "hello"
</ms>

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>+=</c> B || A = A + B
|-
| A <c>-=</c> B || A = A - B
|-
| A <c>*=</c> B || A = A * B
|-
| A <c>/=</c> B || A = A / B
|-
| A <c>%=</c> B || A = A % B
|-
| A <c>^=</c> B || A = A ^ B
|}

== Tricky spaces ==

MiniScript allows an expression to be the entire statement (which is useful in [[REPL]] where it evaluates the expression and immediately prints the result).

<ms>
4 + 5 // REPL prints 9

f = function(x,y)
x + y // the result is "dropped"
end function
f 4, 5 // prints nothing

</ms>

There are a few cases when using different spacing around operators in such expressions may make MiniScript confuse it with a function call:

<ms>
X[Y] // Index X with key Y
X [Y] // Call function X with argument [Y]

X-Y // Subtract Y from X
X- Y // Subtract Y from X
X -Y // Call function X with argument -Y
X - Y // Subtract Y from X
</ms>

Follow a simple convention to avoid such problems: put spaces around arithmetic operators and if possible don't use a space between an unary operator and its operand.

[[Category:Language]]

Operators

2023-11-03T09:31:56Z

Marc Gurevitx: About tricky spaces

MiniScript defines the following operators (listed in order from lowest to highest precedence):

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>=</c> B || assignment
|-
| A <c>or</c> B || logical OR: true if either operand is true
|-
| A <c>and</c> B || logical AND: true if both operands are true
|-
| <c>not</c> A || logical negation: true if its operand is false, and vice versa
|-
| A <c>[[isa]]</c> B || type checking
|-
| A <c>==</c> B || equality comparison: true if operands are equal
|-
| A <c>!=</c> B || inequality comparison: true if operands are not equal
|-
| A <c>></c> B || greater-than comparison
|-
| A <c><</c> B || less-than comparison
|-
| A <c>>=</c> B || greater-than or equal-to comparison
|-
| A <c><=</c> B || less-than or equal-to comparison
|-
| A <c>+</c> B || addition or concatenation
|-
| A <c>-</c> B || subtraction or string trimming
|-
| A <c>*</c> B || multiplication or replication
|-
| A <c>/</c> B || division or reduction
|-
| A <c>%</c> B || modulo (remainder)
|-
| <c>-</c>A || unary minus (numeric negation)
|-
| <c>[[new]]</c> A || instantiation
|-
| <c>@</c>A || [[@ operator|address-of]] (reference function without invoking it)
|-
| A <c>^</c> B || power: A raised to the power of B
|-
| A<c>[</c>B<c>]</c> || indexing
|-
| A<c>[</c>B<c>:</c>C<c>]</c> || slicing
|-
| A<c>(</c>B, C...<c>)</c> || [[Function#Calling_a_Function | calling a function]]
|-
| A<c>.</c>B || [[Dot syntax|dot operator]]
|}

== Chaining Operators ==

Most binary operators in MiniScript can be combined into chains, for example <c>39 + 2 + 1</c>. The details depend on the type of operator:

=== Arithmetic Operators ===

In an expression involving a chain of arithmetic operators, the highest-precedent operators are evaluated first, as in standard algebra. You can always use parentheses to break such a chain into smaller chunks, forcing a different evaluation order.

{| class="wikitable"
|-
! Code !! Result
|-
| <c>2 + 5 * 8</c> || 42
|-
| <c>(2 + 5) * 8</c> || 56
|-
| <c>3 ^ 2 + 4 ^ 2</c> || 25
|}

=== Comparison Operators ===

In the case of comparison operators (<c>></c>, <c><</c>, <c>>=</c> and <c><=</c>), operands are compared in pairs from left to right. All comparisons must be true for the complete chained expression to be considered true. The most common use of this is to check whether a variable is in a certain range, with an expression like <c>0 < x < 10</c>, which is true only if <c>x</c> is between 0 and 10 (non-inclusive).

{| class="wikitable"
|-
! Code !! Given !! Result || Read As
|-
| <c>0 < x < 10</c> || x = 5 || true || x is between 0 and 10
|-
| <c>0 < x < 10</c> || x = 10 || false || x is between 0 and 10
|-
| <c>0 < x <= 10</c> || x = 10 || true || x is between 0 and 10 (including 10)
|-
| <c>0 < x < 10 < y</c> || x = 5; y = 15 || true || x is between 0 and 10, and 10 is less than y
|}

=== Dot Operator ===

A chain of [[Dot syntax|dot operations]] is evaluated one step at a time left to right.

For example, given the code:
<ms>foo.bar.baz</ms>

MiniScript proceeds in the following steps:
# <c>foo.bar</c> is evaluated by looking up "bar" in <c>foo</c> (and in the event that this references a function, it's invoked with <c>[[self]]</c> bound to <c>foo</c>.
# <c>.baz</c> is evaluated by looking up "baz" in the result of step 1 (which should be a map). (And if "baz" references a function, it's invoked with <c>[[self]]</c> bound to the map from step 1.)

This can continue for an arbitrarily long chain of dot operators.

== Math-assignment operators ==

In version ''1.6'' the math-assignment operators were added. They overwrite the value of the first operand variable with the result of the operation when performing the operator without assignment.

<ms>
x = 42
x += 13 // x = x + 13
print x // 55

s = "hello.ms"
s -= ".ms" // s = s - ".ms"
print s // "hello"
</ms>

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>+=</c> B || A = A + B
|-
| A <c>-=</c> B || A = A - B
|-
| A <c>*=</c> B || A = A * B
|-
| A <c>/=</c> B || A = A / B
|-
| A <c>%=</c> B || A = A % B
|-
| A <c>^=</c> B || A = A ^ B
|}

== Tricky spaces ==

MiniScript allows an expression to be the entire statement (which is useful in [[REPL]] where it evaluates the expression and immediately prints the result).

<ms>
4 + 5 // REPL prints 9

f = function(x,y)
x + y // the result is "dropped"
end function
f 4, 5 // prints nothing

</ms>

There are a few cases when using different spacing around operators in such expressions may make MiniScript confuse it with a function call:

<ms>
X[Y] // Index X with key Y
X [Y] // Call function X with argument [Y]

X-Y // Subtract Y from X
X- Y // Subtract Y from X
X -Y // Call function X with argument -Y
X - Y // Subtract Y from X
</ms>

Follow a simple convention to avoid such problems: put spaces around arithmetic operators and if possible don't use a space between an unary operator and its operand.

[[Category:Language]]

Mouse

2023-11-01T05:55:08Z

Marc Gurevitx: +.locked

In [[Mini Micro]], the <msinline>mouse</msinline> module is a small collection of functions related to detecting the mouse state, and controlling display of the mouse cursor.

{| class="wikitable"
|-
! Method !! Purpose
|-
| [[mouse.button]](''which=0'') || detect whether a mouse button is pressed
|-
| [[mouse.x]] || get the current X position of the mouse, in [[screen coordinates]]
|-
| [[mouse.y]] || get the current Y position of the mouse, in [[screen coordinates]]
|-
| [[mouse.visible]] || get or set whether the mouse cursor is visible
|-
| mouse.locked || get or set whether the mouse cursor is locked
|}

== See also ==

* [[How to detect single mouse clicks]]

[[Category:Mini Micro]]
[[Category:Soda]]

Operators

2023-10-30T06:03:32Z

Marc Gurevitx: /* Math-assignment operators */ Removing ambiguous "in-place"

MiniScript defines the following operators (listed in order from lowest to highest precedence):

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>=</c> B || assignment
|-
| A <c>or</c> B || logical OR: true if either operand is true
|-
| A <c>and</c> B || logical AND: true if both operands are true
|-
| <c>not</c> A || logical negation: true if its operand is false, and vice versa
|-
| A <c>[[isa]]</c> B || type checking
|-
| A <c>==</c> B || equality comparison: true if operands are equal
|-
| A <c>!=</c> B || inequality comparison: true if operands are not equal
|-
| A <c>></c> B || greater-than comparison
|-
| A <c><</c> B || less-than comparison
|-
| A <c>>=</c> B || greater-than or equal-to comparison
|-
| A <c><=</c> B || less-than or equal-to comparison
|-
| A <c>+</c> B || addition or concatenation
|-
| A <c>-</c> B || subtraction or string trimming
|-
| A <c>*</c> B || multiplication or replication
|-
| A <c>/</c> B || division or reduction
|-
| A <c>%</c> B || modulo (remainder)
|-
| <c>-</c>A || unary minus (numeric negation)
|-
| <c>[[new]]</c> A || instantiation
|-
| <c>@</c>A || [[@ operator|address-of]] (reference function without invoking it)
|-
| A <c>^</c> B || power: A raised to the power of B
|-
| A<c>[</c>B<c>]</c> || indexing
|-
| A<c>[</c>B<c>:</c>C<c>]</c> || slicing
|-
| A<c>(</c>B, C...<c>)</c> || [[Function#Calling_a_Function | calling a function]]
|-
| A<c>.</c>B || [[Dot syntax|dot operator]]
|}

== Chaining Operators ==

Most binary operators in MiniScript can be combined into chains, for example <c>39 + 2 + 1</c>. The details depend on the type of operator:

=== Arithmetic Operators ===

In an expression involving a chain of arithmetic operators, the highest-precedent operators are evaluated first, as in standard algebra. You can always use parentheses to break such a chain into smaller chunks, forcing a different evaluation order.

{| class="wikitable"
|-
! Code !! Result
|-
| <c>2 + 5 * 8</c> || 42
|-
| <c>(2 + 5) * 8</c> || 56
|-
| <c>3 ^ 2 + 4 ^ 2</c> || 25
|}

=== Comparison Operators ===

In the case of comparison operators (<c>></c>, <c><</c>, <c>>=</c> and <c><=</c>), operands are compared in pairs from left to right. All comparisons must be true for the complete chained expression to be considered true. The most common use of this is to check whether a variable is in a certain range, with an expression like <c>0 < x < 10</c>, which is true only if <c>x</c> is between 0 and 10 (non-inclusive).

{| class="wikitable"
|-
! Code !! Given !! Result || Read As
|-
| <c>0 < x < 10</c> || x = 5 || true || x is between 0 and 10
|-
| <c>0 < x < 10</c> || x = 10 || false || x is between 0 and 10
|-
| <c>0 < x <= 10</c> || x = 10 || true || x is between 0 and 10 (including 10)
|-
| <c>0 < x < 10 < y</c> || x = 5; y = 15 || true || x is between 0 and 10, and 10 is less than y
|}

=== Dot Operator ===

A chain of [[Dot syntax|dot operations]] is evaluated one step at a time left to right.

For example, given the code:
<ms>foo.bar.baz</ms>

MiniScript proceeds in the following steps:
# <c>foo.bar</c> is evaluated by looking up "bar" in <c>foo</c> (and in the event that this references a function, it's invoked with <c>[[self]]</c> bound to <c>foo</c>.
# <c>.baz</c> is evaluated by looking up "baz" in the result of step 1 (which should be a map). (And if "baz" references a function, it's invoked with <c>[[self]]</c> bound to the map from step 1.)

This can continue for an arbitrarily long chain of dot operators.

== Math-assignment operators ==

In version ''1.6'' the math-assignment operators were added. They overwrite the value of the first operand variable with the result of the operation when performing the operator without assignment.

<ms>
x = 42
x += 13 // x = x + 13
print x // 55

s = "hello.ms"
s -= ".ms" // s = s - ".ms"
print s // "hello"
</ms>

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>+=</c> B || A = A + B
|-
| A <c>-=</c> B || A = A - B
|-
| A <c>*=</c> B || A = A * B
|-
| A <c>/=</c> B || A = A / B
|-
| A <c>%=</c> B || A = A % B
|-
| A <c>^=</c> B || A = A ^ B
|}

[[Category:Language]]

Operators

2023-10-07T07:54:05Z

Marc Gurevitx: + Math-assignment operators

MiniScript defines the following operators (listed in order from lowest to highest precedence):

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>=</c> B || assignment
|-
| A <c>or</c> B || logical OR: true if either operand is true
|-
| A <c>and</c> B || logical AND: true if both operands are true
|-
| <c>not</c> A || logical negation: true if its operand is false, and vice versa
|-
| A <c>[[isa]]</c> B || type checking
|-
| A <c>==</c> B || equality comparison: true if operands are equal
|-
| A <c>!=</c> B || inequality comparison: true if operands are not equal
|-
| A <c>></c> B || greater-than comparison
|-
| A <c><</c> B || less-than comparison
|-
| A <c>>=</c> B || greater-than or equal-to comparison
|-
| A <c><=</c> B || less-than or equal-to comparison
|-
| A <c>+</c> B || addition or concatenation
|-
| A <c>-</c> B || subtraction or string trimming
|-
| A <c>*</c> B || multiplication or replication
|-
| A <c>/</c> B || division or reduction
|-
| A <c>%</c> B || modulo (remainder)
|-
| <c>-</c>A || unary minus (numeric negation)
|-
| <c>[[new]]</c> A || instantiation
|-
| <c>@</c>A || [[@ operator|address-of]] (reference function without invoking it)
|-
| A <c>^</c> B || power: A raised to the power of B
|-
| A<c>[</c>B<c>]</c> || indexing
|-
| A<c>[</c>B<c>:</c>C<c>]</c> || slicing
|-
| A<c>(</c>B, C...<c>)</c> || [[Function#Calling_a_Function | calling a function]]
|-
| A<c>.</c>B || [[Dot syntax|dot operator]]
|}

== Chaining Operators ==

Most binary operators in MiniScript can be combined into chains, for example <c>39 + 2 + 1</c>. The details depend on the type of operator:

=== Arithmetic Operators ===

In an expression involving a chain of arithmetic operators, the highest-precedent operators are evaluated first, as in standard algebra. You can always use parentheses to break such a chain into smaller chunks, forcing a different evaluation order.

{| class="wikitable"
|-
! Code !! Result
|-
| <c>2 + 5 * 8</c> || 42
|-
| <c>(2 + 5) * 8</c> || 56
|-
| <c>3 ^ 2 + 4 ^ 2</c> || 25
|}

=== Comparison Operators ===

In the case of comparison operators (<c>></c>, <c><</c>, <c>>=</c> and <c><=</c>), operands are compared in pairs from left to right. All comparisons must be true for the complete chained expression to be considered true. The most common use of this is to check whether a variable is in a certain range, with an expression like <c>0 < x < 10</c>, which is true only if <c>x</c> is between 0 and 10 (non-inclusive).

{| class="wikitable"
|-
! Code !! Given !! Result || Read As
|-
| <c>0 < x < 10</c> || x = 5 || true || x is between 0 and 10
|-
| <c>0 < x < 10</c> || x = 10 || false || x is between 0 and 10
|-
| <c>0 < x <= 10</c> || x = 10 || true || x is between 0 and 10 (including 10)
|-
| <c>0 < x < 10 < y</c> || x = 5; y = 15 || true || x is between 0 and 10, and 10 is less than y
|}

=== Dot Operator ===

A chain of [[Dot syntax|dot operations]] is evaluated one step at a time left to right.

For example, given the code:
<ms>foo.bar.baz</ms>

MiniScript proceeds in the following steps:
# <c>foo.bar</c> is evaluated by looking up "bar" in <c>foo</c> (and in the event that this references a function, it's invoked with <c>[[self]]</c> bound to <c>foo</c>.
# <c>.baz</c> is evaluated by looking up "baz" in the result of step 1 (which should be a map). (And if "baz" references a function, it's invoked with <c>[[self]]</c> bound to the map from step 1.)

This can continue for an arbitrarily long chain of dot operators.

== Math-assignment operators ==

In version ''1.6'' the math-assignment operators were added. They perform an operation in-place on a variable provided as first operand. They overwrite the value of the first operand variable with the result of the operation when performing the operator without assignment.

<ms>
x = 42
x += 13 // x = x + 13
print x // 55

s = "hello.ms"
s -= ".ms" // s = s - ".ms"
print s // "hello"
</ms>

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>+=</c> B || A = A + B
|-
| A <c>-=</c> B || A = A - B
|-
| A <c>*=</c> B || A = A * B
|-
| A <c>/=</c> B || A = A / B
|-
| A <c>%=</c> B || A = A % B
|-
| A <c>^=</c> B || A = A ^ B
|}

[[Category:Language]]

Operators

2023-10-07T07:22:05Z

Marc Gurevitx:

MiniScript defines the following operators (listed in order from lowest to highest precedence):

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>=</c> B || assignment
|-
| A <c>or</c> B || logical OR: true if either operand is true
|-
| A <c>and</c> B || logical AND: true if both operands are true
|-
| <c>not</c> A || logical negation: true if its operand is false, and vice versa
|-
| A <c>[[isa]]</c> B || type checking
|-
| A <c>==</c> B || equality comparison: true if operands are equal
|-
| A <c>!=</c> B || inequality comparison: true if operands are not equal
|-
| A <c>></c> B || greater-than comparison
|-
| A <c><</c> B || less-than comparison
|-
| A <c>>=</c> B || greater-than or equal-to comparison
|-
| A <c><=</c> B || less-than or equal-to comparison
|-
| A <c>+</c> B || addition or concatenation
|-
| A <c>-</c> B || subtraction or string trimming
|-
| A <c>*</c> B || multiplication or replication
|-
| A <c>/</c> B || division or reduction
|-
| A <c>%</c> B || modulo (remainder)
|-
| <c>-</c>A || unary minus (numeric negation)
|-
| <c>[[new]]</c> A || instantiation
|-
| <c>@</c>A || [[@ operator|address-of]] (reference function without invoking it)
|-
| A <c>^</c> B || power: A raised to the power of B
|-
| A<c>[</c>B<c>]</c> || indexing
|-
| A<c>[</c>B<c>:</c>C<c>]</c> || slicing
|-
| A<c>(</c>B, C...<c>)</c> || [[Function#Calling_a_Function | calling a function]]
|-
| A<c>.</c>B || [[Dot syntax|dot operator]]
|}

== Chaining Operators ==

Most binary operators in MiniScript can be combined into chains, for example <c>39 + 2 + 1</c>. The details depend on the type of operator:

=== Arithmetic Operators ===

In an expression involving a chain of arithmetic operators, the highest-precedent operators are evaluated first, as in standard algebra. You can always use parentheses to break such a chain into smaller chunks, forcing a different evaluation order.

{| class="wikitable"
|-
! Code !! Result
|-
| <c>2 + 5 * 8</c> || 42
|-
| <c>(2 + 5) * 8</c> || 56
|-
| <c>3 ^ 2 + 4 ^ 2</c> || 25
|}

=== Comparison Operators ===

In the case of comparison operators (<c>></c>, <c><</c>, <c>>=</c> and <c><=</c>), operands are compared in pairs from left to right. All comparisons must be true for the complete chained expression to be considered true. The most common use of this is to check whether a variable is in a certain range, with an expression like <c>0 < x < 10</c>, which is true only if <c>x</c> is between 0 and 10 (non-inclusive).

{| class="wikitable"
|-
! Code !! Given !! Result || Read As
|-
| <c>0 < x < 10</c> || x = 5 || true || x is between 0 and 10
|-
| <c>0 < x < 10</c> || x = 10 || false || x is between 0 and 10
|-
| <c>0 < x <= 10</c> || x = 10 || true || x is between 0 and 10 (including 10)
|-
| <c>0 < x < 10 < y</c> || x = 5; y = 15 || true || x is between 0 and 10, and 10 is less than y
|}

=== Dot Operator ===

A chain of [[Dot syntax|dot operations]] is evaluated one step at a time left to right.

For example, given the code:
<ms>foo.bar.baz</ms>

MiniScript proceeds in the following steps:
# <c>foo.bar</c> is evaluated by looking up "bar" in <c>foo</c> (and in the event that this references a function, it's invoked with <c>[[self]]</c> bound to <c>foo</c>.
# <c>.baz</c> is evaluated by looking up "baz" in the result of step 1 (which should be a map). (And if "baz" references a function, it's invoked with <c>[[self]]</c> bound to the map from step 1.)

This can continue for an arbitrarily long chain of dot operators.

[[Category:Language]]

Operators

2023-10-07T07:04:36Z

Marc Gurevitx: +func call

MiniScript defines the following operators (listed in order from lowest to highest precedence):

{| class="wikitable"
|-
! Operator !! Meaning
|-
| A <c>=</c> B || assignment
|-
| A <c>or</c> B || logical OR: true if either operand is true
|-
| A <c>and</c> B || logical AND: true if both operands are true
|-
| <c>not</c> A || logical negation: true if its operand is false, and vice versa
|-
| A <c>[[isa]]</c> B || type checking
|-
| A <c>==</c> B || equality comparison: true if operands are equal
|-
| A <c>!=</c> B || inequality comparison: true if operands are not equal
|-
| A <c>></c> B || greater-than comparison
|-
| A <c><</c> B || less-than comparison
|-
| A <c>>=</c> B || greater-than or equal-to comparison
|-
| A <c><=</c> B || less-than or equal-to comparison
|-
| A <c>+</c> B || addition or concatenation
|-
| A <c>-</c> B || subtraction or string trimming
|-
| A <c>*</c> B || multiplication or replication
|-
| A <c>/</c> B || division or reduction
|-
| A <c>%</c> B || modulo (remainder)
|-
| <c>-</c>A || unary minus (numeric negation)
|-
| <c>[[new]]</c> A || instantiation
|-
| <c>@</c>A || [[@ operator|address-of]] (reference function without invoking it)
|-
| A <c>^</c> B || power: A raised to the power of B
|-
| A<c>[</c>B<c>]</c> || indexing
|-
| A<c>[</c>B<c>:</c>C<c>]</c> || [[Slice | slicing]]
|-
| A<c>(</c>B, C...<c>)</c> || [[Function#Calling_a_Function | calling a function]]
|-
| A<c>.</c>B || [[Dot syntax|dot operator]]
|}

== Chaining Operators ==

Most binary operators in MiniScript can be combined into chains, for example <c>39 + 2 + 1</c>. The details depend on the type of operator:

=== Arithmetic Operators ===

In an expression involving a chain of arithmetic operators, the highest-precedent operators are evaluated first, as in standard algebra. You can always use parentheses to break such a chain into smaller chunks, forcing a different evaluation order.

{| class="wikitable"
|-
! Code !! Result
|-
| <c>2 + 5 * 8</c> || 42
|-
| <c>(2 + 5) * 8</c> || 56
|-
| <c>3 ^ 2 + 4 ^ 2</c> || 25
|}

=== Comparison Operators ===

In the case of comparison operators (<c>></c>, <c><</c>, <c>>=</c> and <c><=</c>), operands are compared in pairs from left to right. All comparisons must be true for the complete chained expression to be considered true. The most common use of this is to check whether a variable is in a certain range, with an expression like <c>0 < x < 10</c>, which is true only if <c>x</c> is between 0 and 10 (non-inclusive).

{| class="wikitable"
|-
! Code !! Given !! Result || Read As
|-
| <c>0 < x < 10</c> || x = 5 || true || x is between 0 and 10
|-
| <c>0 < x < 10</c> || x = 10 || false || x is between 0 and 10
|-
| <c>0 < x <= 10</c> || x = 10 || true || x is between 0 and 10 (including 10)
|-
| <c>0 < x < 10 < y</c> || x = 5; y = 15 || true || x is between 0 and 10, and 10 is less than y
|}

=== Dot Operator ===

A chain of [[Dot syntax|dot operations]] is evaluated one step at a time left to right.

For example, given the code:
<ms>foo.bar.baz</ms>

MiniScript proceeds in the following steps:
# <c>foo.bar</c> is evaluated by looking up "bar" in <c>foo</c> (and in the event that this references a function, it's invoked with <c>[[self]]</c> bound to <c>foo</c>.
# <c>.baz</c> is evaluated by looking up "baz" in the result of step 1 (which should be a map). (And if "baz" references a function, it's invoked with <c>[[self]]</c> bound to the map from step 1.)

This can continue for an arbitrarily long chain of dot operators.

[[Category:Language]]

Operators

2023-10-07T06:38:20Z

Marc Gurevitx: +indexing and slicing

Operators

2023-10-07T06:22:07Z

Marc Gurevitx: +mod

Operators

2023-10-05T15:57:16Z

Marc Gurevitx: About chained comparison

Print

2023-09-30T19:44:41Z

Marc Gurevitx:

<c>print</c> is an [[:Category:Intrinsic Functions|intrinsic function]] that displays a [[string]] to the user. It is a standard intrinsic, though there may be some implementations where this output is not actually visible. In implementations that have something like a standard output stream, <c>print</c> adds the given string to that stream, typically followed by the standard line delimiter.

See also: [[PixelDisplay.print]]

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Default Value !! Meaning
|-
| s || "" || string to display to the user
|-
| delimiter || <platform's new line> || string to follow '''s''' instead of standard delimiter
|}

=== Usage Notes ===
<c>print</c> returns [[null]], and so it is usually used as a statement. As such, it does not require [[parentheses]] around its argument.

The argument defaults to an empty string, so <c>print</c> by itself may be used to print a blank line.

== Example ==

<ms>print "Hello, world!"</ms>

[[Category:Intrinsic Functions]]

Print

2023-09-30T19:42:11Z

Marc Gurevitx: delimiter

<c>print</c> is an [[:Category:Intrinsic Functions|intrinsic function]] that displays a [[string]] to the user. It is a standard intrinsic, though there may be some implementations where this output is not actually visible. In implementations that have something like a standard output stream, <c>print</c> adds the given string to that stream, typically followed by the standard line delimiter.

See also: [[PixelDisplay.print]]

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Default Value !! Meaning
|-
| s || "" || string to display to the user
|-
| delimiter || <platform's new line> || lines delimiter following '''s'''
|}

=== Usage Notes ===
<c>print</c> returns [[null]], and so it is usually used as a statement. As such, it does not require [[parentheses]] around its argument.

The argument defaults to an empty string, so <c>print</c> by itself may be used to print a blank line.

== Example ==

<ms>print "Hello, world!"</ms>

[[Category:Intrinsic Functions]]

Bibliography

2023-09-06T18:24:51Z

Marc Gurevitx: /* Articles & Conference Proceedings */ + more recent articles + consistent chronology

This page lists published articles that include some nontrivial mention of MiniScript or Mini Micro.

== Primary Sources ==

Primary sources are those written by people directly involved. Currently, that mostly means things written by [[User:JoeStrout|Joe Strout]].

=== Books ===

* Strout, J (2020). ''Learn to Code in 30 Days: with MiniScript and Mini Micro''. MiniScript Press. ISBN 978-1-7361676-0-1. (Also available as ebook: ISBN 978-1-7361676-2-5.)

* Strout, J (2021). ''Introduction to Computer Programming: for kids of all ages''. MiniScript Press. ISBN 978-1-7361676-1-8.

=== Articles & Conference Proceedings ===

* Strout, J. "[https://ieeexplore.ieee.org/document/9625108 MiniScript: A new language for computer programming education.]" [http://istem-ed.com/istem-ed2021/ iSTEM-Ed] (2021). (preprint [https://miniscript.org/files/Strout_iSTEM-Ed2021.pdf PDF])

* Strout, J. "[https://kidscodecs.com/mini-micro-coding-introduction/ Introducing Mini Micro]" [https://beanzmag.com/ Beanz Magazine] February 2022, p. 8-9.

* Strout, J. "[https://kidscodecs.com/mini-micro-stars-experiment/ Experimental Coding]" [https://beanzmag.com/ Beanz Magazine] April 2022, p. 24-25.

* Strout, J. "[https://kidscodecs.com/mini-micro-space-game-project/ An Apple a Day...]" [https://beanzmag.com/ Beanz Magazine] June 2022, p. 13.

* Strout, J. "[https://kidscodecs.com/mini-micro-clock-timer/ Make a Clock Timer]" [https://beanzmag.com/ Beanz Magazine] August 2022, p. 13.

* Strout, J. "[https://kidscodecs.com/mini-micro-secret-message-rot13/ Loopy Secret Messages] [https://beanzmag.com/ Beanz Magazine] October 2022, p. 12-13.

* Strout, J. "[https://kidscodecs.com/farmtronics/ Auto-Code in Stardew Valley]" [https://beanzmag.com/ Beanz Magazine] December 2022, p. 4-5.

* Strout, J. "[https://kidscodecs.com/farmtronics-gardening-howto/ A Bot “Outstanding in its Field”]" [https://beanzmag.com/ Beanz Magazine] February 2023

* Strout, J. "[https://kidscodecs.com/farmtronics-finding-your-way/ Finding Your Way]" [https://beanzmag.com/ Beanz Magazine] April 2023

* Strout, J. "[https://kidscodecs.com/minimicro-project-find-objects/ Explore Mars like a Rover]" [https://beanzmag.com/ Beanz Magazine] June 2023

=== Blog Posts ===

* Strout, Joe. "Why MiniScript?" Luminary Apps, 06 Sep. 2019, https://luminaryapps.com/blog/miniscript-why/. Accessed 5 Dec. 2021.

* Strout, Joe. "VT100 Escape Codes in Command-Line MiniScript" Luminary Apps, 03 Oct. 2021, https://luminaryapps.com/blog/vt100-codes/index.html. Accessed 13 Jul 2022.

* Strout, Joe. "Debugging with a Validate Method" Luminary Apps, 01 Nov. 2021, https://luminaryapps.com/blog/validate/index.html. Accessed 13 Jul 2022.

* Strout, Joe. "String Fill and Match" Luminary Apps, 10 Jun. 2022, https://luminaryapps.com/blog/ms-fill-match/index.html. Accessed 13 Jul 2022.

* Strout, Joe. "Advanced Tricks with Import" Luminary Apps, 16 Jun. 2022, https://luminaryapps.com/blog/advanced-import/index.html. Accessed 13 Jul 2022.

== Secondary Sources ==

Secondary sources are those written by people not directly involved in the work.

=== Blog Posts ===

* Nozzi, Sebastian. “Neo-Retro Computing.” Dev.to, 20 Nov. 2021, https://dev.to/sebnozzi/about-mini-micro-short-1g0e. Accessed 5 Dec. 2021.

* TopaAzul062. "Review of Learn to Code in 30 Days." OnlineBookClub.org, 21 Oct 2021, https://forums.onlinebookclub.org/viewtopic.php?f=24&t=205860. Accessed 5 Dec. 2021.

* Khorne. "Where to begin, where to start?" Khornes MiniScript Journey, 2 Mar 2022, https://khornemsjourney.blogspot.com/2023/07/where-to-begin-where-to-start.html. Accessed 2 Aug. 2023. (Originally located [https://khornems.blogspot.com/2022/03/where-to-begin-where-to-start.html here].)

* Kratt, Max. "Launch in Mini Micro". Max Kratt's blog, 19 Jan 2023, https://maxkratt.hashnode.dev/launch-in-mini-micro

* Tomes, Trey. “Fluent Interfaces.” Micro-Hack wiki, 30 Mar 2023, https://github.com/treytomes/micro-hack/wiki/Fluent-Interfaces

=== Pro Journalism ===

* Stanton, Rich. "Stardew Valley mod adds farming bots." PC Gamer, 01 Jan. 2022, https://www.pcgamer.com/stardew-valley-mod-adds-farming-bots/

Isa

2023-08-09T06:32:06Z

Marc Gurevitx: (fixed typos)

Because this wiki software does not allow topic names to begin with an underscore, this page contains two different topics.

== isa (operator) ==
<c>isa</c> is a [[:Category:Keywords|keyword]] binary [[operators|operator]] which tests the left-hand operator for membership in the type defined by the right-hand side. That right-hand operand could be a user-defined map (to which the left-hand side might belong via the <c>__isa</c> chain), or it could be one of the [[:Category:Data Types|built-in types]]: [[number]], [[string]], [[list]], [[map]], or [[funcRef]].

=== Examples for built-in types ===

<ms>"Hello" isa string // returns 1
"Hello" isa number // returns 0
123 isa number // returns 1
"123" isa number // returns 0
[1,2,3] isa list // returns 1
{"uno":1,"dos":2} isa map // returns 1
</ms>

=== Examples for user-defined types ===

<ms>
MyDefinedType = {}
MyOtherDefinedType = {}

obj = new MyDefinedType

obj isa MyDefinedType // returns 1 - direct type
obj isa map // returns 1 - related by inheritance

obj isa MyOtherDefinedType // returns 0 - because unrelated
</ms>

== __isa (map entry) ==
<c>__isa</c> is a special entry in a map that refers to the map's base class. It is part of MiniScript's support for [[object-oriented programming]].

== See also ==

* [[Object-oriented programming]] in miniscript
* The [[map]] type

[[Category:Language]]
[[Category:Keywords]]
[[Category:Operators]]

{{stub}}

Wait

2023-07-06T13:38:15Z

Marc Gurevitx: Comment on yield

<c>wait</c> pauses execution of this script for some amount of time.

Behind the scenes, it [[yield]]s on every frame until the requested amount of time has passed.

See also: [[time]], [[yield]]

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Default Value !! Meaning
|-
| ''seconds'' || 1.0 || how many seconds to wait
|}

== Example ==

<ms>wait 2.5 // pauses the script for 2.5 seconds</ms>

[[Category:Intrinsic Functions]]

Globals

2023-05-23T10:21:55Z

Marc Gurevitx:

'''globals''' is a built-in keyword that references [[variables]] at the global scope. In the main program, any assignment outside of any function creates (or updates) an entry in the '''globals''' map.

Inside a function, an unqualified assignment (i.e. an assignment to an identifier that does not follow a dot — like ''x'' rather than ''foo.x'') creates a local variable. Local variables exist only within the function where they are created, and disappear as soon as the function exits. This is true even if there happens to already be a global variable of the same name.

So, when you want to create or update a global variable inside a function, the '''globals''' keyword must be used on the left-hand side of the assignment.

See also: [[locals]]; [[outer]].

== Example ==
The ''check'' function below compares its parameter to a global variable. The comparison does not need the '''globals''' keyword, because it's only reading the value (and there is no local variable of the same name). But when it updates the global value, it has to use '''globals'''.

<ms>lastValue = null
check = function(someValue)
if someValue != lastValue then
print "The value is now: " + someValue
globals.lastValue = someValue // <--- Note use of globals
end if
end function

x = 0
while true
check round(x)
x = x + 0.1
wait 0.1
end while</ms>

Also note that the [[while]] loop at the end is at the global scope, so it does not need to use '''globals''' at all; globals and locals are the same in this case.

[[Category:Language]]
[[Category:Intrinsic Functions]]