min Language Developer Guide

• • About min
    • Why?
    • How?
    • Who?
    • When?
  • Get Started
    • Building from source
      • Using nimble
      • Building from source for additional platforms
      • Additional build options
        • -d:ssl
        • -d:nopcre
    • Running the min shell
    • Executing a min program
    • Compiling a min program
    • Getting help on a min symbol
    • Syntax highlighting
  • Learning the min Language
    • Data Types
    • Quotations
      • Quoting, dequoting, and applying
    • Operators
      • Symbols
        • Using the lambda operator
      • Sigils
      • Auto-popping
      • Operator signatures
        • Type classes
          • Capturing lambdas
        • Type expressions
        • Type aliases
        • Generics
        • Constructors
    • Definitions
      • Lexical scoping and binding
      • Sealing symbols
    • Scopes
      • Accessing the current scope
      • Dequoting a quotation within the context of a specific scope
    • Control Flow
      • Conditionals
      • Loops
      • Error handling
  • Using the min Shell
    • Autocompletion and shortcuts
    • Shell configuration files
      • .minrc
      • .min_history
      • .min_symbols
  • Extending min
    • Implementing new min modules using min itself
    • Specifying a prelude program
    • Embedding min in your Nim program
  • Module Management
    • How mmm works
      • The registry
      • Module lookup
    • Commands
      • min init
      • min install [name version | name@version] [-g]
      • min uninstall [name version | name@version] [-g]
      • min update [name version | name@version] [-g]
      • min list
      • min search [arg1 arg2 ... argN]
    • Creating a managed min module
      • Metadata
      • Publishing
  • Reference
    • Commands
      • min init
      • min install [name version | name@version] [-g]
      • min uninstall [name version | name@version] [-g]
      • min update [name version | name@version] [-g]
      • min list
      • min search [arg1 arg2 ... argN]
    • Creating a managed min module
      • Metadata
      • Publishing
  • Reference
    • Notation
      • Types and Values
      • Suffixes
    • global Module
    • crypto Module
    • dict Module
    • fs Module
    • http Module
    • io Module
    • math Module
    • net Module
    • stack Module
    • store Module
    • sys Module
    • time Module
    • xml Module

About min

min is a concatenative, fully-homoiconic, functional, interpreted programming language.

This basically means that:

• It is based on a somewhat obscure and slightly unintuitive programming paradigm, think of Forth, Factor and Joy but with parentheses for an extra Lispy flavor.
• Programs written in min are actually written using quotations, i.e. lists.
• It comes with map, filter, find, map-reduce, and loads of other functional goodies. See the seq Module for more.
• It is probably slower than the average production-ready programming language.

Why?

Because creating a programming language is something that every programmer needs to do, at some point in life. And also because there are way too few concatenative programming language out there – so people are likely to be less pissed off than if I made a yet another Lisp instead.

I always wanted to build a minimalist language, but that could also be used for real work and provided a standard library for common tasks and functionalities like regular expression support, cryptography, execution of external programs, shell-like operators, and keywords to work with files, and more.

Additionally, I wanted it to be fully self-contained, cross-platform, and small. Not stupidly small, but I feel it’s a good compromise compared to the alternatives out there, considering that you only need one file to run any min program.

I also created a static site generator called HastySite, which also powers https://min-lang.org. HastySite internally uses min as the language to write the rules to process the source files of the site, and also all its scripts.

Finally, I think more and more people should get to know concatenative programming languages, because concatenative programming matters.

How?

min is developed entirely in Nim – the name is (almost) entirely a coincidence. I wanted to call it minim but then shortened it for more… minimalism.

min’s parser started off as a fork of Nim’s JSON parser – adapted to process a concatenative programming language with less primitive types than JSON. It is interpreted in the traditional sense: no bytecode, no JIT, just plain read, parse, and run.

Who?

min was created and implemented by Fabio Cevasco, with contributions by Peter Munch-Ellingsen, Yanis Zafirópulos, and baykus871.

Special thanks to mwgkgk for contributing to the design of native dictionaries.

When?

min source code repository was created on November 8^th 2014. This only means that I’ve been very slowly developing something that was actually made public at the end of July 2017.

Get Started

You can download one of the following pre-built min binaries:

• min v0.46.0 for macOS (x64)
• min v0.46.0 for Windows (x64)
• min v0.46.0 for Linux (x64)

Building from source

Alternatively, you can build min from source in one of the following ways:

Using nimble

If you already installed nim, you probably already have the nimble package manager installed.

If that’s the case, simply run nimble install min.

Building from source for additional platforms

By default, min is released as a pre-built binary executable for Windows x64, macOS x64 and Linux x64. However, it should run without issues on any platform supported by the Nim programming language.

To build on a different operating system and architecture from the default ones, you also need to get or build the following static libraries:

• libssl (OpenSSL)
• libcrypto (OpenSSL)
• libpcre (PCRE)

and also specify the following additional flag when compiling:

--passL:"-static -L<dir> -lpcre -lssl -lcrypto"

Where <dir> is the directory containing the *.a files for the static libraries listed above.

Additional build options

-d:ssl

If the -d:ssl flag is specified when compiling, min will be built with SSL support, so it will be possible to:

• perform HTTPS requests with the http Module.
• use all the cryptographic symbols defined in the crypto Module.

If this flag is not specified:

• It will not be possible to perform HTTPS requests

• Only the following symbols will be exposed by the crypto Module:

  • crypto.md5
  • crypto.sha1
  • crypto.encode
  • crypto.decode
  • crypto.aes

-d:nopcre

If the -d:nopcre is specified when compiling, min will be built without PCRE support, so it will not be possible to use regular expressions and the following symbols will not be exposed by the global Module:

• search
• match?
• search-all
• replace
• replace-apply

Running the min shell

To start the min shell, run min with no arguments. You will be presented with a prompt displaying the path to the current directory:

You can type min code and press ENTER to evaluate it immediately:

The result of each operation will be placed on top of the stack, and it will be available to subsequent operation

To exit min shell, press CTRL+C or type 0 exit and press ENTER.

Executing a min program

To execute a min script, you can:

• Run min eval "...program..." to execute a program inline.
• Run min myfile.min to execute a program contained in a file.
• Run min run <mmm> to execute the main symbol of the specified min managed module. If the managed module is not installed globally, it will be downloaded and installed automatically.

min also supports running programs from standard input, so the following command can also be used (on Unix-like system) to run a program saved in myfile.min:

Compiling a min program

min programs can be compiled to a single executable simply by using the built-in compile command:

Essentially, this will:

1. Generate a myfile.nim containing the equivalent Nim code of your min program.
2. Call the Nim compiler to do the rest ;)

If you want to pass any options to the Nim compiler (like -d:release for example) you can do so by using the -n (or --passN) option:

Additionally, you can also use -m:<path> (or --module-path) to specify one path containing .min files which will be compiled as well (but not executed) along with the specified file. Whenever a load or a require symbol is used to load/require an external .min file, it will attempt to retrieve its contents from the pre-loaded files first before searching the filesystem.

For example, the following command executed in the root folder of the min project will compile run.min along with all .min files included in the tasks folder and its subfolders:

Similarly, you can also bundle additional files in the executable by specifying the -a:<path> (or --asset-path) option. At runtime, the compiled min program will attempt to lookup bundled asset files before checking the filesystem.

Getting help on a min symbol

min comes with a built-in help command that can be used to print information on a specific symbol. Essentially, this is equivalent to use the help symbol within the min REPL.

Syntax highlighting

• If you are using Visual Studio Code, you can install the official min extension which provides syntax highlighting support, code folding, and auto-indentation.
• If you are using Vim, a min.vim syntax definition file is available in the min repo.
• If you are using Sublime Text 3, Rafael Carrasco created a min syntax definition file that is available here.

Learning the min Language

min is a stack-based, concatenative programming language that uses postfix notation. If you already know Forth, Factor or Joy, or if you ever used an RPN calculator, then min will look somewhat familiar to you.

If not, well, here’s how a short min program looks like:

; This is a comment
(1 2 3 4 5) (stack.dup *) map
#| This is a...
...multiline comment |#

This program returns a list containing the square values of the first five integer numbers:

(1 4 9 16 25)

Let’s see how it works:

1. First, a list containing the first five integers is pushed on the stack.
2. Then, another list containing two symbols (stack.dup and *) is pushed on the stack. This constitutes a quoted program which, when executed duplicates the first element on the stack — this is done by stack.dup— and then multiplies — with *— the two elements together.
3. Finally, the symbol map is pushed on the stack. Map takes a list of elements and a quoted program and applies the program to each element.

Note that:

• There are no variable assignments.
• elements are pushed on the stack one by one.
• Parentheses are used to group one or more elements together so that they are treated as a single element and they are not evaluated immediately.
• Symbols (typically single words, or several words joined by dashes) are used to execute code that performs operations on the whole stack.

Unlike more traditional programming languages, in a concatenative programming language, there is no inherent need for variables or named parameters, as symbols act as stack operators that consume elements that are placed in order on top of a stack.

Data Types

The following data types are availanle in min (with the corresponding shorthand symbols used in operator signatures in brackets):

null (null)

null value.

boolean (bool)

true or false.

integer (int)

A 64-bit integer number like 1, 27, or -15.

float (flt)

A 64-bit floating-point number like 3.14 or -56.9876.

string (str)

A series of characters wrapped in double quotes: “Hello, World!”.

quotation (quot)

A list of elements, which may also contain symbols. Quotations can be used to create heterogenous lists of elements of any data type, and also to create a block of code that will be evaluated later on (quoted program). Example: (1 2 3 + *)

command (cmd)

A command string wrapped in square brackets that will be immediately executed on the current shell and converted into the command standard output. Example: [ls -a]

dictionary (dict)

A key/value table. Dictionaries are implemented as an immediately-dequoted quotation, are enclosed in curly braces, and are represented by their symbol definitions. Note that dictionary keys must start with :and be followed by a double-quoted string, or a single word (which can be written without double quotes). The dict Module provides some operators on dictionaries.

Example

The following is a simple dictionary containing three keys: name, paradigm, and first-release-year:

{
    "min" :name
    "concatenative" :paradigm
    2017 :"first release year"
}

Additionally, dictionaries can also be typed to denote complex objects like sockets, errors, etc. For example, the following dictionary defines an error:

  {
   "MyError" :error
   "An error occurred" :message
   "symbol1" :symbol
   "dir1/file1.min" :filename
   3 :line
   13 :column
   ;error
  }

The global Module provides predicate operators to check if an element belongs to a particular data type or pseudo-type (boolean?, number?, integer?, float?, …).

Additionally, the global Module provides operators to convert values from a data type to another (e.g. integer, string, and so on).

Quotations

Quotations are the most important thing to understand in min. Besides being the data type used for lists, they are also used to delimit blocks of min code that is not going to be immediately executed.

Consider for example the following min code which returns all the files present in the current folder sorted by name:

 sys.pwd sys.ls (fs.type "file" ==) filter '> sort

The symbol seq.filter takes two quotations as arguments – the first quotation on the stack is applied to all the elements of the second quotation on the stack, to determine which elements of the second quotation will be part of the resulting quotation. This is an example of how quotations can be used both as lists and programs.

Let’s examine this program step-by-step:

1. The sys.pwd symbol is pushed on the stack, and it is immediately evaluated to the full path to the current directory.
2. The sys.ls symbol is pushed on the stack, it consumes the string already on the stack and returns a quotation containing all files and directories within the current directory.
3. The quotation (fs.type 'file ==) is pushed on the stack. It is treated exactly like a list of data and it is not evaluated.
4. The filter symbol is pushed on the stack. This symbol takes two quotations as input, and applies the result of the first quotation on the stack ((fs.type "file" ==)) to all elements of the second quotation of the stack (the list of files and directories), returning a new quotation containing only those elements of the second quotation on the stack that satisfy the result of the first quotation. In this case, it returns a new quotation containing only files.
5. '> is pushed on the stack. The ' sigil can be used instead of the quote symbol to quote a single symbol, > in this case. In other words, it is instantly evaluated to the quotation (>).
6. The symbol sort is pushed on the stack. This symbol, like filter, takes two quotations as input, and applies the first quotation to each element of the second quotation, effectively sorting each element of the second quotation using the predicate expressed by the first quotation. In this case, all files are sorted by name in ascending order.

Quoting, dequoting, and applying

When a quotation is created, it is treated as data, no matter what it contains: it is placed on the stack, like an integer or a string would. However, unlike other data types, a quotation can be evaluated in certain situations and when it happens its contents are pushed on the stack.

Consider the following program:

 (1 2 3 4 5 6 7) (odd?) filter

This program returns a new quotation containing all odd numbers contained in quotation (1 2 3 4 5 6 7).

In this case, the second quotation is used to quote the symbol odd? so that instead of being executed immediately, it will be executed by the symbol filter on each element of the first quotation. In this way, we may say that (odd?) is dequoted by the symbol filter.

The symbol dequote or its alias -> can be used to dequote a quotation by pushing all its elements on the main stack. Essentially, this executes the quotation in the current context.

For example, the following program leaves the elements 1 and -1 on the stack:

 (1 2 3 -) ->

Alternatively, the symbol apply or its alias => can also be used to dequote a quotation but in this case it will not push its elements on the main stack, instead it will:

1. Create a temporary empty stack.
2. Push all elements on it, one by one.
3. Push the entire temporary stack as a quotation back on the main stack.

For example, the following program leaves the element (1 -1) on the stack:

 (1 2 3 -) =>

Operators

Every min program needs operators to:

• Manipulate elements on the stack
• Perform operations on data
• Provide side effects (read/print to standard input/output/files, etc.)

There are two types of operators: symbols and sigils.

Symbols

Symbols are the most common type of operator. A min symbol is a single word that is either provided by one of the predefined min modules like stack.dup or sys.pwd or defined by the user. User-defined symbols must:

• Start with a letter or an underscore (_).
• Contain zero or more letters, numbers and/or any of the following characters: / ! ? + * _ -

If a symbol contains a dot (.) then it is namespaced by its containing module or dictionary. For example, fs.dirname identifies the {fs.dirname}} operator defined in the {{#link-module symbol. The following min program defines a new symbol called square that duplicates the first element on the stack and multiplies the two elements:

 (
   symbol square
   (num :n ==> num :result)
   (n dup * @result)
 ) operator
 ;; Calculates the square of n.

The operator symbol provides way to:

• Specify the name of the symbol operator (square in this case)
• Specify a signature to identify the type of the input and output values (in this case, the operator takes a numeric input value and produces a numeric output value). Also, note how inputs and outputs are captured into the n and result symbols in the signature quotation and then referenced in the body quotation.
• Specify a quotation containing the code that the operator will execute.

Also, symbol operator definitions can be annotated with documentation comments (starting with ;; or wrapped in #|| ... ||#)) so that a help text can be displayed using the help symbol.

Using the lambda operator

Sometimes you just want to bind a piece of code to a symbol to reuse it later, typically something simple and easy-to-read. In these cases, you can use the lambda operator (or the ^ sigil). For example, the previous square operator definition could be rewritten simply as the following.

 (stack.dup *) ^square

Note that this feels like using define, but the main difference between lambda and define is that lambda only works on quotations doesn’t auto-quote them, so that they are immediately evaluated when the corresponding symbol is pushed on the stack.

Also note that unlike with operator, symbols defined with lambda:

• have no built-in validation of input and output values.
• do not support the return symbol to immediately end their execution.
• have no built-in stack pollution checks.

Sigils

Besides symbols, you can also define sigils. min provides a set of predefined sigils as abbreviations for commonly used symbols.

A sigil can be prepended to a double-quoted string or a single word (with no spaces) which will be treated as a string instead of using the corresponding symbol.

Currently min provides the following sigils:

'

Alias for quote.

:

Alias for define.

?

Alias for help.

~

Alias for lambda-bind.

$

Alias for |get-env.

@

Alias for bind.

^

Alias for lambda.

Besides system sigils, you can also create your own sigils. Unlike system sigils however, user defined sigils:

• have the same character restrictions as symbols
• can only be prepended to double-quoted strings
• can be unsealed, deleted, redefined, and sealed.

Sigils can be a very powerful construct and a way to reduce boilerplate code: you can define a sigil to use as you would use any symbol which requires a single string or quoted symbol on the stack.

Like symbols, sigils can be defined with the operator operator, like this:

 (
   sigil j
   (string :json ==> a :result)
   (json from-json @result)
 ) operator

This definition will add a j sigil that will process the following string as JSON code, so for example:

 j"{\\"test\\": true}"

…will push the following dictionary on the stack:

{true :test}

Also, sigil definitions can be annotated with documentation comments (starting with ;; or wrapped in #|| ... ||#) so that a help text can be displayed using the help symbol.

Auto-popping

Typically, but not always, operators push one or more value to the stack. While this is typically the desired behavior, in some cases you may want to keep the stack clear so in these cases you can append a ! character to any symbol to cause the symbol pop to be pushed on the stack immediately afterwards.

 "test" puts  ;Prints "test" and pushes "test" on the stack.
 "test" puts! ;Prints "test" without pushing anything on the stack.

Operator signatures

When defining symbols and sigils with the operator operator, you must specify a signature that will be used to validate and capture input and output values:

 (
   symbol square
   (num :n ==> num :result)
   (n stack.dup * @result)
 ) operator

In this case for example the square symbol expects a number on the stack, which will be captured to the symbol n and it will place a number on the stack which needs to be bound in the operator body to the symbol result.

In a signature, a type expression must precede the capturing symbol. Such type expression can be:

• One of the following shorthand symbols identifying a well-known min base type (see the reference section for more information): a, bool, null, str, int, num, flt, 'sym, quot, or dict.
• A typed dictionary like dict:module or dict:datastore.
• A type class (see below).
• a type expression like str|int.

Type classes

Besides standard base types, you can define your own type classes to express custom constraints/validations for operator input and output values.

Consider the following type class definition validating a quotation containing strings:

 (
   typeclass strquot
   (quot :q ==> bool :o)
   (q (string?) all? @o)
 ) ::

The operator operator can be used to define a symbol prefixed with typeclass: (typeclass:strquot in this case) corresponding to a type class that can be used in operator signatures in place of a type, like this:

 (
   symbol join-strings
   (strquot :q ==> str :result)
   ( 
      q "" (suffix) reduce @result
   )
 )

This operator will raise an error if anything other than a quotation of strings is found on the stack.

Capturing lambdas

You can also specify a lambda to be captured to an output value, like this:

 (
   symbol square
   (==> quot ^o)
   (
     (stack.dup *) ~o
   )
 ) ::

Essentially, this allows you to push a lambda on the stack from an operator.

Note that:

• Lambdas must be captured using the ^ sigil in signatures and bound using lambda-bind in the operator body.
• Lambdas cannot be captured in input values (they have already been pushed on the stack).
• Requiring a lambda as an output value effectively bypasses stack pollution checks. While this can be useful at times, use with caution!

Type expressions

When specifying types in operator signatures or through the expect operator, you can specify a logical expression containing types and type classes joined with one of the following operators:

• | (or)
• & (and)
• ! (not)

Suppose for example you defined the following type classes:

(typeclass fiveplus
    (int :n ==> bool :o)
    (
      n 5 > @o
    )
) ::

(typeclass tenminus
    (int :n ==> bool :o)
    (
      n 10 < @o
    )
) ::

(typeclass even
    (int :n ==> bool :o)
    (
      n 2 mod 0 == @o
    )
) ::

You can combine them in a type expression as following:

(symbol test
    (!even|tenminus&fiveplus :n ==> bool :o)
    (
      true @o
    )
) ::
4 test  ; error
6 test  ; true
11 test ; true 

Type aliases

As you can see, type expressions can quickly become quite long and complex. To avoid this, you can define type aliases using the typealias operator.

For example, you can create an alias of part of the type expression used in the previous example, like this:

'tenminus&fiveplus 'five-to-ten typealias

(symbol test
    (!even|five-to-ten :n ==> bool :o)
    (
      true @o
    )
) ::

Note that:

• Type aliases be used to create an alias for any type expression.
• Aliased type expressions can contain standard min types, dictionary types, type classes, and even other type aliases.
• The typealias operator actually creates lexically-scoped, typealias:-prefixed symbols that can be sealed, unsealed, and deleted exactly like other symbols.

Generics

min supports generics in operator signatures. in other words, you can define a custom type alias on-the-fly directly in an operator signature, like this:

(
  symbol add
  ((str|num|quot :t) :a t :b ==> t :result)
  (
   (a type "str" ==)
     (a b suffix @result return)
   when
   (a type "num" ==)
     (a b + @result return)
   when
   (a type "quot" ==)
     (a b concat #result return)
   when
  )
) ::

In this case, t is set to the type union stribg|num|quot, and the add method above can be used to sum two numbers or join two strings or quotations.

Note that the value of t is evaluated to the type of the first value that is processed. In other words, the following programs will work as expected:

 3 5 add ;outputs 8

 "hello, " "world" ;outputs "hello, world"

while the following will raise an error, because the value of t from num to quot within the same operator use:

 12 "test" add ;raises an error

Constructors

The operator operator can also be used to create constructor symbols. A constructor is a particular type of operator that is used to create a new typed dictionary.

Consider the following example:

 (
   constructor point
   (num :x num :y ==> dict :out)
   (
     {}
       x 'x dset
       y 'y dset
     @out
   )
 ) ::

The operator above creates a point constructor symbol that can be used to create a new dict:point typed dictionary by popping two numbers from the stack:

 2 3 point ; {2 :x 3 :y ;point}

Definitions

Being a concatenative language, min does not really need named parameters or variables: symbols just pop elements off the main stack in order, and that’s normally enough. There is however one small problem with the traditional concatenative paradigm; consider the following program for example:

 stack.dup stack.dup
 "\.zip$" match?
 stack.swap fs.size 1000000 > and 
 stack.swap fs.mtime now 3600 - >

This program takes a single string corresponding to a file path and returns true if it’s a .zip file bigger than 1MB that was modified in the last hour. Sure, it is remarkable that no variables are needed for such a program, but it is not very readable: because no variables are used, it is often necessary to make copies of elements and push them to the end of the stack – that’s what the stack.dup and stack.swap are used for.

The good news is that you can use the define operator and the : sigil to define new symbols, and symbols can also be set to fixed values (literals).

Consider the following program:

 :filepath
 filepath "\.zip$" match?
 filepath fs.size 1000000 >
 filepath fs.mtime time.now 3600 - >
 and and

In this case, the filepath symbol is defined and then used on the following three lines, each of which defines a condition to be evaluated. The last line contains just two and symbols necessary to compare the three conditions.

Lexical scoping and binding

min, like many other programming languages, uses lexical scoping to resolve symbols.

Consider the following program:

 4 :a
 ( 
   a 3 + :a
   (
      a 1 + :a
      (a stack.dup * :a) dequote
   ) dequote
 ) dequote

…What is the value of the symbol a after executing it?

Simple: 4. Every quotation defines its own scope, and in each scope, a new variable called a is defined. In the innermost scope containing the quotation (a stack.dup * :a) the value of a is set to 64, but this value is not propagated to the outer scopes. Note also that the value of a in the innermost scope is first retrieved from the outer scope (8).

If we want to change the value of the original a symbol defined in the outermost scope, we have to use the bind or its shorthand sigil @, so that the program becomes the following:

 4 :a ;First definition of the symbol a
 (
   a 3 + @a ;The value of a is updated to 7.
   (
     a 1 + @a ;The value of a is updated to 8
     (a stack.dup * @a) dequote ;The value of a is now 64
   ) dequote
 ) dequote

Sealing symbols

Finally, symbols can be sealed to prevent accidental updates or deletions. By default, all symbols defined in the core min modules are sealed, so the following code if run in min shell will result in an error:

 5 :quote

…because the symbol quote is already defined in the root scope. However, note that the following code will not return an error:

 (5 :quote quote stack.dup *) -> ;returns 25

…because the quote symbol is only defined in the root scope and can therefore be redefined in child scopes.

If you want, you can seal your own symbols so that they may not be redefined using the bind operator or deleted using the delete.

Scopes

As explained in Definitions, min uses lexical scoping to resolve symbols and sigils. A scope is an execution context (a symbol table really) that:

• is created while a new quotation is being dequoted or a dictionary is created.
• is destroyed after a quotation has been dequoted.
• is attached to a dictionary.

The main, root-level scope in min can be accessed using the global Module symbol and it typically contains all symbols and sigils imported from all the standard library modules. The global symbol pushes a module on the stack that references the global scope:

Accessing the current scope

You can access the current scope using the scope operator, which pushes a module on the stack that references the current scope.

Consider the following program:

 {} :innerscope ("This is a test" :test scope @myscope) -> myscope scope-symbols

In this case:

1. A new variable called innerscope is defined on the global scope.
2. A quotation is dequoted, but its scope is retrieved using the scope operator and bound to innerscope.
3. After the quotation is dequoted, myscope is accessed and its symbols (test in this case) are pushed on the stack using the scope-symbols operator.

Note that scopes can only be accessed if they are bound to a dictionary, hence the global and scope operators push a module on the stack, and a module is nothing but a typed dictionary.

Dequoting a quotation within the context of a specific scope

The with operator can be used to dequote a quotation within a specific scope instead of the current one.

Consider the following program, which leaves 2 on the stack:

 (4 2 minus) {'- :minus} with ->

In this case, when with is pushed on the stack, it will dequote (4 2 minus). Note that the symbol minus is defined in the dictionary that will be used by with as the current scope, so after with is pushed on the stack, the stack contents are:

 4 2 (-)

At this point, the dequote operator is pushed on the stack and the subtraction is executed leaving 2 on the stack.

Control Flow

The global Module provide some symbols that can be used for the most common control flow statements. Unlike most programming languages, min does not differentiate between functions and statements – control flow statements are just ordinary symbols that manipulate the main stack.

Conditionals

The following symbols provide ways to implement common conditional statements:

• case
• if
• unless
• when

For example, consider the following program:

 (
   (  
     "" :type
     (("\.(md|markdown)$") ("markdown" @type))
     (("\.txt$") ("text" @type))
     (("\.min$") ("min" @type))
     (("\.html?$") ("HTML" @type))
     ((true) ("unknown" @type))
   ) case 
   "This is a $1 file." (type) % echo
 ) ^display-file-info

This program defines a symbol display-file-info that takes a file name and outputs a message displaying its type if known.

Loops

The following symbols provide ways to implement common loops:

• foreach
• times
• while

For example, consider the following program:

 (
   :n
   1 :i
   1 :f
   (i n <=)
   (
     f i * @f 
     i succ @i
   ) while
   f
 ) ^factorial

This program defines a symbol factorial that calculates the factorial of an integer iteratively using the symbol while.

Error handling

The following symbols provide ways to manage errors in min:

• format-error
• raise
• try

For example, consider the following program:

 . ls
 (
   (
     (fs.size) 
     (stack.pop 0)
   ) try
 ) map 
 1 (+) reduce

This program calculates the size in bytes of all files included in the current directory. Because the fs.size symbol throws an error if the argument provided is not a file (for example, if it is a directory), the try symbol is used to remove the error from the stack and push 0 on the stack instead.

Using the min Shell

The min executable also provide an interactive REPL (Read-Eval-Print Loop) when launched with no arguments:

Although not as advanced, the min REPL is not dissimilar from an OS system shell like Bash, and as a matter of fact, it provides many functionalities that are found in other shells or command prompts, such as:

• Auto-completion
• Persistent line history
• A customizable prompt
• Access to environment variables

…plus in can obviously leverage the entire min language for complex scripting.

Autocompletion and shortcuts

The min shell features smart tab autocompletion and keyboard shortcut implemented using the minline library.

The following behaviors are implemented when pressing the TAB key within:

Additionally, the following common shortcuts are also available:

Shell configuration files

When the min interpreter is first launched, the following files are created automatically in the $HOME directory (%USERPROFILE% on Windows).

.minrc

This file is interpreted first every time min is run. By default it is empty, but it can be used to define code to execute at startup.

.min_history

This file is used to persist all commands entered in the min shell, and it is loaded in memory at startup to provide line history support.

.min_symbols

This files contains all symbol definitions in JSON format that were previously-saved using the save-symbol symbol. Symbols can be loaded using the load-symbol symbol.

Extending min

min provides a fairly complete standard library with many useful modules. However, you may feel the need to extend min in order to perform more specialized tasks.

In such situations, you basically have the following options:

• Implementing new min modules using min itself
• Specifying your custom prelude program
• Embedding min in your Nim program

Implementing new min modules using min itself

When you just want to create more high-level min operator using functionalities that are already available in min, the easiest way is to create your own reusable min modules.

To create a new module, simply create a file containing your operator definitions implemented using either the operator operator or the lambda operator

(stack.dup *)       ^pow2
(stack.dup stack.dup * *) ^pow3
(stack.dup * stack.dup *) ^pow4

Save your code to a file (e.g. quickpows.min) and you can use it in other Nim files using the require operator and the import (if you want to import the operators in the current scope):

'quickpows require :qp

2 qp.pow3 qp.pow2 puts ;prints 64

Specifying a prelude program

If you want, you can execute the min executable with the -p option to specify a prelude program that will be executed when min is started. This can be useful to specify your custom behaviors, selectively import modules, and define your own symbols, like this:

Embedding min in your Nim program

If you’d like to use min as a scripting language within your own program, and maybe extend it by implementing additional operators, you can use min as a Nim library.

To do so:

1. Install min sources using Nifty as explained in the Download section.
2. Import it in your Nim file.
3. Implement a new proc to define the module.

The following code is taken from HastySite and shows how to define a new hastysite module containing some symbols (preprocess, postprocess, process-rules, …):

import min

proc hastysite_module*(i: In, hs1: HastySite) =
  var hs = hs1
  let def = i.define()

  def.symbol("preprocess") do (i: In):
    hs.preprocess()

   def.symbol("postprocess") do (i: In):
    hs.postprocess()

  def.symbol("process-rules") do (i: In):
    hs.interpret(hs.files.rules)

  # ...

  def.finalize("hastysite")

Then you need to:

1. Instantiate a new min interpreter using the newMinInterpreter proc.
2. Run the proc used to define the module.
3. Call the interpret method to interpret a min file or string:

proc interpret(hs: HastySite, file: string) =
  var i = newMinInterpreter(file, file.parentDir)
  i.hastysite_module(hs)
  i.interpret(newFileStream(file, fmRead))

Module Management

The min executable includes a minimal but practical package manager that can be used to initialize, install, uninstall, update, list and search managed min modules stored in remote git repositories.

The min commands that make up this module management functionality is often referred to as mmm, for min module management.

How mmm works

mmm borrows most of its design from Nim’s Nimble, but it is mcuh simpler. Here are the basics:

• mmm is not a standalone program, it is built-in into the min executable
• mmm has a central registry (a single JSON file really, and distributed storage (managed modules are hosted in remote github repositorues).
• managed modules can be installed both locally to a specific folder (another managed module) or globally, in the $HOME/mmm folder.
• each managed module relies on an mmm.json for its metadata, including dependencies on other managed modules.
• the version (git branch or tag) of a managed module must be always specified when installing or specifying a dependency. There is no concept of semantic versioning support, and that’s deliberate: it makes things simpler and leas error prone.

The registry

The registry of mmm is a single JSON file accessible here:

https://min-lang.org/mmm.json

The registry contains the metadata of all public managed modules and it is queried when running every mmm command (see below).

Module lookup

When requiring a module in your min file using the {[require}} symbol, min will attempt to lookup the module (for example module1) checking the following files (in order):

• module1.min
• mmm/module1/*/index.min
• $HOME/mmm/module1/*/index.min

Commands

The following sections explain how to use the mmm-related commands that are built-in into tbe min executable.

min init

Initializes a new managed min module in tbe current directory by creating a sample mmm.json file in the current folder.

min install [name version | name@version] [-g]

Install the specified managed module by specifying its name and version. By default, the module is installed in the mmm/<name>/<version> folder; if -g is specified, it is installed in $HOME/mmm/<name>/<version>.

If no version is specified, the version will be set to the HEAD branch of the git repository of the module.

If no name and no version are specified, all the managed modules (and their dependencies) specified as dependencies for the current managed module will be installed.

If the installation of one dependency fails, the installation of the module will be rolled back.

min uninstall [name version | name@version] [-g]

Uninstall the module specified by name and version either locally or globally (if -g is specified).

If no version is specified, the version will be set to the HEAD branch of the git repository of the module.

If no version is specified, all version of the module will be uninstalled (if the module is installed globally).

If no name and no version are specified, all dependencies of the current managed module (and their dependencies) will be uninstalled.

min update [name version | name@version] [-g]

Update the module specified by name and version either locally or globally (if -g is specified).

If no version is specified, the version will be set to the HEAD branch of the git repository of the module.

If no name and no version are specified, all dependencies of the current managed module (and their dependencies) will be updated.

min list

List all the installed dependencies of the current module, and their dependencies, recursively.

min search [arg1 arg2 … argN]

Search for a managed module matching the specified arguments. if no argument is specified, the metadata of all public managed modules will be printed.

Creating a managed min module

Creating a managed min module is easy. As a minimum, you need to create three files:

• an index.min file containing your code
• a license file
• an mmm.json file containing the module metadata

See min-highlight as an example.

Metadata

The mmm.json file of a managed min module must contain at least the following metadata:

• name
• description
• private set to true for private modules, or, if public:
  • method set to git
  • url set to the URL of the git repository containing the module
• license
• deps set to an object with the keys corresponding to module names and the values to their respective versions

Publishing

If you want to publish your module, just create a PR on the min git repository and modify this file by adding the metadata for your module.

Reference

min includes a small but powerful standard library organized into the following modules:

global Module

Defines the basic language constructs, such as control flow, type conversions, symbol definition and binding, exception handling, etc. This module is automatically imported (no need to prepend global. . to reference its symbols).

crypto Module

Provides operators to compute hashes (MD4, MD5, SHA1, SHA224, SHA256, SHA384, sha512), base64 encoding/decoding, and AES encryption/decryption.

dict Module

Defines operators for dictionaries, like dict.get, dict.dup, dict.set, etc. {#link-module](#min-operator-id-require}} symbol, min will attempt to lookup the module (for example module1) checking the following files (in order):

• module1.min
• mmm/module1/*/index.min
• $HOME/mmm/module1/*/index.min

Commands

The following sections explain how to use the mmm-related commands that are built-in into tbe min executable.

min init

Initializes a new managed min module in tbe current directory by creating a sample mmm.json file in the current folder.

min install [name version | name@version] [-g]

Install the specified managed module by specifying its name and version. By default, the module is installed in the mmm/<name>/<version> folder; if -g is specified, it is installed in $HOME/mmm/<name>/<version>.

If no version is specified, the version will be set to the HEAD branch of the git repository of the module.

If no name and no version are specified, all the managed modules (and their dependencies) specified as dependencies for the current managed module will be installed.

If the installation of one dependency fails, the installation of the module will be rolled back.

min uninstall [name version | name@version] [-g]

Uninstall the module specified by name and version either locally or globally (if -g is specified).

If no version is specified, the version will be set to the HEAD branch of the git repository of the module.

If no version is specified, all version of the module will be uninstalled (if the module is installed globally).

If no name and no version are specified, all dependencies of the current managed module (and their dependencies) will be uninstalled.

min update [name version | name@version] [-g]

Update the module specified by name and version either locally or globally (if -g is specified).

If no version is specified, the version will be set to the HEAD branch of the git repository of the module.

If no name and no version are specified, all dependencies of the current managed module (and their dependencies) will be updated.

min list

List all the installed dependencies of the current module, and their dependencies, recursively.

min search [arg1 arg2 … argN]

Search for a managed module matching the specified arguments. if no argument is specified, the metadata of all public managed modules will be printed.

Creating a managed min module

Creating a managed min module is easy. As a minimum, you need to create three files:

• an index.min file containing your code
• a license file
• an mmm.json file containing the module metadata

See min-highlight as an example.

Metadata

The mmm.json file of a managed min module must contain at least the following metadata:

• name
• description
• private set to true for private modules, or, if public:
  • method set to git
  • url set to the URL of the git repository containing the module
• license
• deps set to an object with the keys corresponding to module names and the values to their respective versions

Publishing

If you want to publish your module, just create a PR on the min git repository and modify this file by adding the metadata for your module.

Reference

min includes a small but powerful standard library organized into the following modules:

global Module

Defines the basic language constructs, such as control flow, type conversions, symbol definition and binding, exception handling, etc. This module is automatically imported (no need to prepend global. . to reference its symbols).

crypto Module

Provides operators to compute hashes (MD4, MD5, SHA1, SHA224, SHA256, SHA384, sha512), base64 encoding/decoding, and AES encryption/decryption.

dict Module

Defines operators for dictionaries, like dict.get, dict.dup, dict.set, etc.

{#link-module)

Provides operators for reading and writing files, and accessing file information and properties.

http Module

Provides operators to perform HTTP requests, download files and create basic HTTP servers.

io Module

Provides operators for writing to STDOUT, reading from STDIN, capturing key presses, etc.

math Module

Provides many mathematical operators and constants such as trigonometric functions, square root, logarithms, etc.

net Module

Provides basic supports for sockets (some features are not supported on Windows systems).

stack Module

Defines combinators and stack-shufflers like stack.pop, stack.dup, stack.swap, stack.cons, etc.

store Module

Provides support for simple, persistent, in-memory JSON stores.

sys Module

Provides operators to use as basic shell commands, access environment variables, and execute external commands.

time Module

Provides a few basic operators to manage dates, times, and timestamps.

xml Module

Provides operators for parsing, creating and querying XML/HTML code using CSS selectors.

Notation

The following notation is used in the signature of all min operators:

Types and Values

∅

No value.

null

null value

a

A value of any type.

bool

A boolean value

int

An integer value.

flt

A float value.

num

A numeric (integer or float) value.

str

A string value.

'sym

A string-like value (string or quoted symbol).

quot

A quotation (also expressed as parenthesis enclosing other values).

dict

A dictionary value.

dict:help

A help dictionary:

{
 "puts" :name
 "symbol" :kind
 "a ==>" :signature
 "Prints a and a new line to STDOUT." :description
 ;help
}

dict:url

An URL dictionary:

{
 "http" :scheme
 "h3rald" :hostname
 "" :port
 "" :username
 "" :password
 "/min" :path
 "" :anchor
 "" :query
 ;url
}

dict:timeinfo

A timeinfo dictionary:

{
 2017 :year
 7 :month
 8 :day
 6 :weekday
 188 :yearday
 15 :hour
 16 :minute
 25 :second
 true :dst
 -3600 :timezone ;UTC offset
 ;timeinfo
}

dict:error

An error dictionary:

{
 "MyError" :error
 "An error occurred" :message
 "symbol1" :symbol
 "dir1/file1.min" :filename
 3 :line
 13 :column
 ;error
}

dict:socket

A socket dictionary that must be created through the net.socket operator:

{
 "ipv4" :domain
 "stream" :type
 "tcp" :protocol
 ;socket
}

dict:rawval

A raw value dictionary obtained via the seq.get-raw or dict.dget-raw operators:

{
 "sym" :type
 "my-symbol" :str
 my-symbol :val
 ;rawval
}

dict:datastore

A datastore dictionary that must be created through the store.init or store.read operator:

{
 {} :data
 "path/to/file.json" :path
 ;datastore
}

dict:http-request

A request dictionary, representing an HTTP request to be performed through the operators exposed by the http Module:

{
 "http://httpbin.org/put" :url
 "PUT" :method
 "1.1" :version         ;optional
 "h3rald.com" :hostname ;optional
 {                      
  "it-id" :Accept-Language
  "httpbin.org" :Host
 } :headers             ;optional
 "test body" :body      ;optional
 ;http-request
}

dict:http-response

A response dictionary, representing an HTTP response returned by some of the operators exposed by the http Module:

{
  "1.1" :version ;optional
  200 :status    ;optional
  {
    "application/json" :Content-Type
  } :headers     ;optional
  "{\"test\": \"This is a test\"}" :body
  ;http-response
}

dict:xml-element

A dictionary representing an XML or HTML element, exposed by the xml Module

{
  {"https://min-lang.org" :href} :attributes
  ({"min web site" :text}) :children
  "a" :tag
  ;xml-element
}

dict:xml-comment

A dictionary representing an XML comment.

{
  "This is a comment" :text
  ;xml-comment
}

dict:xml-cdata

A dictionary representing XML CDATA text.

{
  "This is some text" :text
  ;xml-cdata
}

dict:xml-entity

A dictionary representing an XML entity.

{
  "amp" :text
  ;xml-entity
}

dict:xml-text

A dictionary representing XML text.

{
  "This is some text" :text
  ;xml-text
}

xml-node

A typealias to identify all XML dictionary types.

dict:xml-element||dict:xml-text||dict:xml-comment||dict:xml-entity||dict:xml-cdata

Suffixes

The following suffixes can be placed at the end of a value or type to indicate ordering or quantities.

₁

The first value of the specified type.

₂

The second value of the specified type.

₃

The third value of the specified type.

₄

The fourth value of the specified type.

_?

Zero or one.

_*

Zero or more.

₊

One or more

global Module

!=

$

$

%

&&

'

'

*

+

-

->

-inf

/

:

:

::

<

<=

=%

=-=

==

==>

=>

>

><

>=

>>

?

?

@

@

^

^

all?

and

any?

append

apply

apply-interpolate

args

avg

base

base?

bind

bitand

bitclear

bitflip

bitnot

bitor

bitparity

bitset

bitxor

boolean

boolean?

capitalize

case

(
   ((2 > 3) ("Greater than 3" put!))
   ((2 < 3) ("Smaller than 3" put!))
   ((true) ("Exactly 3" put!))
) case

chr

compiled?

concat

constructor

decode-url

define

define-sigil

defined-symbol?

defined-sigil?

delete-sigil

delete-symbol

dequote

dev

dev?

dictionary?

difference

(1 2 "test") ("test" "a" true 1) difference

div

drop

encode-url

escape

eval

even?

exit

expect

expect-all

expect-any

expect-empty-stack

filter

(1 37 34 2 6 8 12 21)
(stackdup 20 < stack.swap even? and) filter

find

(1 2 4 8 16)
(5 >) find

first

flatten

(1 (2 3 4) 5 (6 7) 8)
flatten

float

float?

foreach

format-error

 (
   (
      {"MyError" :error "This is a test error" :message} raise
   ) 
   (format-error)
 ) try

from-bin

from-dec

from-hex

from-json

from-oct

from-semver

from-yaml

get

gets

get-env

harvest

(1 () () () 2 () 3)
harvest

help

if

import

in?

indent

indexof

inf

infix-dequote

 (2 + (3 * 5)) infix-dequote

 (2 + 3 * 5) infix-dequote

insert

integer

integer?

interpolate

intersection

(1 2 "test") ("test" "a" true 1) intersection

join

lambda

lambda-bind

last

length

line-info

linrec

 5 (dup 0 ==) 'succ (dup pred) '* linrec

load

load-symbol

loglevel

loglevel?

lowercase

map

map-reduce

(1 3 5)
(stack.dup *) (+) map-reduce

match?

med

mod

nan

not

null?

number?

odd?

one?

operator

 (
   symbol pow
   (num :base int :exp ==> num :result)
   ( 
     (base 0 == exp 0 == and)
       (nan @result return)
     when
     (base 1 == exp inf == and)
       (nan @result return)
     when
     (base inf == exp 0 == and)
       (nan @result return)
     when
     exp 1 - :n
     base  (dup) n times (*) n times @result
   )
 ) ::

opts

or

ord

parent-scope

parse

parse-url

partition

(1 2 3 4 5 6)
(odd?) partition

pred

prefix

prefix-dequote

(* 8 4) prefix-dequote

prepend

print

product

prompt

("[$1]$$ " (sys.pwd) => %)

publish

put-env

puts

quit

quotation?

quote

quote-map

quotecmd

quoted-symbol?

quotesym

raise

raw-get

random

randomize

range

raw-args

reduce

(1 2 3 4 5)
1 (*) reduce

reject

remove

remove-symbol

repeat

replace

replace-apply

require

This symbol will attempt to locate the specified module in this way. Given the following min program:

 'my-module require :my-module

1. Check for a file named my-module in the same folder as the current file (with our without a .min extension).
2. Check for a file named index.min in the mmm/my-module/*/index.min folder relative to the current file (locally-installed managed-module).
3. Check for a file named index.min in the $HOME/mmm/my-module/*/index.min folder (globally-installed managed-module). If multiple versions of the same module are present, the first one will be loaded.

rest

return

If used outside of the body quotation of an operator definition, it raises an exception.

reverse

save-symbol

saved-symbols

scope

{} :myscope (2 :two scope @myscope) ->

scope-sigils

scope-symbols

seal-symbol

seal-sigil

sealed-symbol?

sealed-sigil?

search

search-all

semver-inc-major

semver-inc-minor

semver-inc-patch

semver?

set

set-sym

shl

shorten

shr

sigil

sigil-help

sigils

size

slice

(1 2 3 4 5 6)
2 4 slice

sort

(1 9 5 13 16 3 7) '> sort

source

split

string

string?

stringlike?

strip

substr

succ

suffix

sum

symbol

symbol-help

symbols

symmetric-difference

(1 2 "test") ("test" "a" true 1) symmetric-difference

take

tap

{1 :a 2 :b 3 :c} (
  (stack.dup 'a dict.get succ succ 'a dict.set)
  (stack.dup 'b dict.get succ 'b dict.set)
) tap

times

titleize

to-bin

to-dec

to-hex

to-json

to-oct

to-semver

to-yaml

tokenize

try

  (
    (stack.pop)
    (format-error puts)
    (0)
  ) try

type

type?

typealias

typeclass

union

(1 2 "test") ("test" "a" true 1) union

unless

unseal-sigil

unseal-symbol

uppercase

version

when

while

0 :count
(count 10 <=) 
(count puts succ @count) while

with

xor

||

~

~

crypto Module

aes

decode

encode

md4

md5

sha1

sha224

sha256

sha384

sha512

dict Module

del

dup

get

get-raw

has?

{true :a1 "aaa" :a2 false :a3} 'a2 dict.has?

keys

pick

{5 :q 4 :a 6 :c 7 :d "d" :a} ("a" "d") dict.pick

pairs

set

set-sym

type

values

fs Module

absolute-path

absolute-path?

append

atime

ctime

dir?

dirname

exists?

expand-filename

expand-symlink

file?

filename

hidden?

join-path

mtime

normalized-path

permissions

read

relative-path

size

stats

 {
   "min" :name
   16777220 :device
   50112479 :file
   "file" :type
   617068 :size
   755 :permissions
   1 :nlinks
   1496583112.0 :ctime
   1496584370.0 :atime
   1496583112.0 :mtime
 }

symlink?

type

unix-path

windows-path

write

http Module

download

get-content

request

{}
  "GET" 'method dict.get
  "http://httpbin.org/ip" 'url dict.set
request

start-server

; Define the request handler
(
  ; Assume there is a request on the stack, take it off and give it the name req
  :req
  ; Let's see what we got (print req to standard out)
  "THE REQUEST:" puts! req puts!
  ; The request is a dictionary, we retrieve the value for the key url, and give it the name url
  req /url :url
  "THE URL is '$1'." url quote % puts!
  ; Constuct response body
  (
    (("/datetime" url ==) (time.stamp time.datetime))
    (("/timestamp" url ==) (time.stamp string))
    (("/shutdown" url ==) ("Stopping server..." puts! stop-server))
    (("/" url ==) (
      ; this is a bit short, but works with Chrome, IE, Edge, Safari
      "<a href='/datetime'>datetime</a>, <a href='/timestamp'>timestamp</a>, <a href='/shutdown'>stop</a>"
    ))
    ((true) ("Invalid Request: $1" url quote %))
  ) case
  :body
  ; Prepare the response
  {} body 'body dict.set
  stack.dup puts!
)
; The request handler is ready, give it the name handler
:handler

; Create the parameter dictionary for the server
{}
handler 'handler dict.set
5555 'port dict.set

; Start server
"Server started on port 5555." puts!
"Press Ctrl+C to stop." puts!
start-server

stop-server

io Module

ask

choose

clear

color

column-print

confirm

debug

error

fatal

getchr

info

mapkey

(clear) 'ctrl+l io.mapkey

notice

password

putchr

unmapkey

warn

math Module

abs

acos

asin

atan

ceil

cos

cosh

d2r

e

floor

ln

log10

log2

pi

pow

r2d

round

sin

sinh

sqrt

tan

tanh

tau

trunc

net Module

accept

close

connect

{} net.socket "localhost" 7777 net.connect :cli

args 1 get :msg

"Sending message \"$1\" to localhost:7777..." (msg) => % puts!

cli "$1\n" (msg) => % net.send

"Done." puts!

cli net.close

listen

{} net.socket {"127.0.0.1" :address 7777 :port} net.listen :srv

"Server listening on localhost:7777" puts!

{} net.socket :cli
"" :line
(line "exit" !=)
(
  srv cli net.accept #cli
  cli net.recv-line @line
  "Received: $1" (line) => % puts!
) while

"Exiting..." puts!

srv net.close

recv

recv-line

{} net.socket "httpbin.org" 80 net.connect :cli

cli "GET /uuid HTTP/1.1\r\nHost: httpbin.org\r\n\r\n" net.send

cli net.recv-line puts :line
(line "}" match not) 
(
  cli net.recv-line puts @line
) while

send

socket

stack Module

clear

cleave

cons

dip

dup

get

keep

nip

over

pick

pop

rolldown

rollup

set

sip

spread

swap

swons

store Module

delete

get

has?

init

post

put

query

 ds "posts" ('author dget "h3rald" ==) dquery

read

write

sys Module

admin?

cd

chmod

cp

cpu

env?

hardlink

ls

ls-r

mkdir

mv

os

parent-dir

pwd

rm

rmdir

run

sleep

symlink

system

unzip

which

zip

time Module

datetime

format

info

now

stamp

to-timestamp

xml Module

cdata

comment

element

entity

entity2utf8

 ">" xml.entity xml.entity2utf8 puts!

escape

from-html

from-xml

"<a href='https://min-lang.org'>min web site</a>" from-xml

{
  {"https://min-lang.org" :href} :attributes
 ({"min web site" :text}) :children
 "a" :tag
 ;xml-element
}