mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-24 01:51:38 +00:00
Merge pull request #3404 from z3ugma/master
[M (MUMPS)/en] Add M/MUMPS language
This commit is contained in:
Divay Prakash
GitHub
commit
65a25a7178
370
m.html.markdown
Normal file
370
m.html.markdown
Normal file
@ -0,0 +1,370 @@
|
||||
---
|
||||
language: M (MUMPS)
|
||||
contributors:
|
||||
- ["Fred Turkington", "http://z3ugma.github.io"]
|
||||
filename: LEARNM.m
|
||||
---
|
||||
|
||||
M, or MUMPS (Massachusetts General Hospital Utility Multi-Programming System) is
|
||||
a procedural language with a built-in NoSQL database. Or, it’s a database with
|
||||
an integrated language optimized for accessing and manipulating that database.
|
||||
A key feature of M is that accessing local variables in memory and persistent
|
||||
storage use the same basic syntax, so there's no separate query
|
||||
language to remember. This makes it fast to program with, especially for
|
||||
beginners. M's syntax was designed to be concise in an era where
|
||||
computer memory was expensive and limited. This concise style means that a lot
|
||||
more fits on one screen without scrolling.
|
||||
|
||||
The M database is a hierarchical key-value store designed for high-throughput
|
||||
transaction processing. The database is organized into tree structures called
|
||||
"globals", which are sparse data structures with parallels to modern formats
|
||||
like JSON.
|
||||
|
||||
Originally designed in 1966 for the healthcare applications, M continues to be
|
||||
used widely by healthcare systems and financial institutions for high-throughput
|
||||
real-time applications.
|
||||
|
||||
### Example
|
||||
|
||||
Here's an example M program to calculate the Fibonacci series:
|
||||
|
||||
```
|
||||
fib ; compute the first few Fibonacci terms
|
||||
new i,a,b,sum
|
||||
set (a,b)=1 ; Initial conditions
|
||||
for i=1:1 do quit:sum>1000
|
||||
. set sum=a+b
|
||||
. write !,sum
|
||||
. set a=b,b=sum
|
||||
```
|
||||
|
||||
### Comments
|
||||
|
||||
```
|
||||
; Comments start with a semicolon (;)
|
||||
```
|
||||
### Data Types
|
||||
|
||||
M has two data types:
|
||||
|
||||
```
|
||||
; Numbers - no commas, leading and trailing 0 removed.
|
||||
; Scientific notation with 'E'.
|
||||
; Floats with IEEE 754 double-precision values (15 digits of precision)
|
||||
; Examples: 20, 1e3 (stored as 1000), 0500.20 (stored as 500.2)
|
||||
; Strings - Characters enclosed in double quotes.
|
||||
; "" is the null string. Use "" within a string for "
|
||||
; Examples: "hello", "Scrooge said, ""Bah, Humbug!"""
|
||||
```
|
||||
### Commands
|
||||
|
||||
Commands are case insensitive, and have a shortened abbreviation, often the first letter. Commands have zero or more arguments,depending on the command. M is whitespace-aware. Spaces are treated as a delimiter between commands and arguments. Each command is separated from its arguments by 1 space. Commands with zero arguments are followed by 2 spaces.
|
||||
|
||||
#### W(rite)
|
||||
|
||||
Print data to the current device.
|
||||
|
||||
```
|
||||
WRITE !,"hello world"
|
||||
```
|
||||
|
||||
! is syntax for a new line. Multiple statements can be provided as additional arguments:
|
||||
|
||||
```
|
||||
w !,"foo bar"," ","baz"
|
||||
```
|
||||
|
||||
#### R(ead)
|
||||
|
||||
Retrieve input from the user
|
||||
|
||||
```
|
||||
READ var
|
||||
r !,"Wherefore art thou Romeo? ",why
|
||||
```
|
||||
Multiple arguments can be passed to a read command. Constants are outputted. Variables are retrieved from the user. The terminal waits for the user to enter the first variable before displaying the second prompt.
|
||||
|
||||
```
|
||||
r !,"Better one, or two? ",lorem," Better two, or three? ",ipsum
|
||||
```
|
||||
|
||||
#### S(et)
|
||||
|
||||
Assign a value to a variable
|
||||
|
||||
```
|
||||
SET name="Benjamin Franklin"
|
||||
s centi=0.01,micro=10E-6
|
||||
w !,centi,!,micro
|
||||
|
||||
;.01
|
||||
;.00001
|
||||
```
|
||||
#### K(ill)
|
||||
|
||||
Remove a variable from memory or remove a database entry from disk.
|
||||
|
||||
```
|
||||
KILL centi
|
||||
k micro
|
||||
```
|
||||
### Globals and Arrays
|
||||
|
||||
In addition to local variables, M has persistent variables stored to disk called _globals_. Global names must start with a __caret__ (__^__). Globals are the built-in database of M.
|
||||
|
||||
Any variable can be an array with the assignment of a _subscript_. Arrays are sparse and do not have a predefined size. Arrays should be visualized like trees, where subscripts are branches and assigned values are leaves. Not all nodes in an array need to have a value.
|
||||
|
||||
```
|
||||
s ^cars=20
|
||||
s ^cars("Tesla",1,"Name")="Model 3"
|
||||
s ^cars("Tesla",2,"Name")="Model X"
|
||||
s ^cars("Tesla",2,"Doors")=5
|
||||
|
||||
w !,^cars
|
||||
; 20
|
||||
w !,^cars("Tesla")
|
||||
; null value - there's no value assigned to this node but it has children
|
||||
w !,^cars("Tesla",1,"Name")
|
||||
; Model X
|
||||
```
|
||||
|
||||
Arrays are automatically sorted in order. Take advantage of the built-in sorting by setting your value of interest as the last child subscript of an array rather than its value.
|
||||
|
||||
```
|
||||
; A log of temperatures by date and time
|
||||
s ^TEMPS("11/12","0600",32)=""
|
||||
s ^TEMPS("11/12","1030",48)=""
|
||||
s ^TEMPS("11/12","1400",49)=""
|
||||
s ^TEMPS("11/12","1700",43)=""
|
||||
```
|
||||
### Operators
|
||||
```jinja
|
||||
; Assignment: =
|
||||
; Unary: + Convert a string value into a numeric value.
|
||||
; Arthmetic:
|
||||
; + addition
|
||||
; - subtraction
|
||||
; * multiplication
|
||||
; / floating-point division
|
||||
; \ integer division
|
||||
; # modulo
|
||||
; ** exponentiation
|
||||
; Logical:
|
||||
; & and
|
||||
; ! or
|
||||
; ' not
|
||||
; Comparison:
|
||||
; = equal
|
||||
; '= not equal
|
||||
; > greater than
|
||||
; < less than
|
||||
; '> not greater / less than or equal to
|
||||
; '< not less / greater than or equal to
|
||||
; String operators:
|
||||
; _ concatenate
|
||||
; [ contains a contains b
|
||||
; ]] sorts after a comes after b
|
||||
; '[ does not contain
|
||||
; ']] does not sort after
|
||||
```
|
||||
|
||||
#### Order of operations
|
||||
|
||||
Operations in M are _strictly_ evaluated left to right. No operator has precedence over any other.
|
||||
You should use parentheses to group expressions.
|
||||
|
||||
```
|
||||
w 5+3*20
|
||||
;160
|
||||
;You probably wanted 65
|
||||
w 5+(3*20)
|
||||
```
|
||||
|
||||
### Flow Control, Blocks, & Code Structure
|
||||
|
||||
A single M file is called a _routine_. Within a given routine, you can break your code up into smaller chunks with _tags_. The tag starts in column 1 and the commands pertaining to that tag are indented.
|
||||
|
||||
A tag can accept parameters and return a value, this is a function. A function is called with '$$':
|
||||
|
||||
```
|
||||
; Execute the 'tag' function, which has two parameters, and write the result.
|
||||
w !,$$tag^routine(a,b)
|
||||
```
|
||||
|
||||
M has an execution stack. When all levels of the stack have returned, the program ends. Levels are added to the stack with _do_ commands and removed with _quit_ commands.
|
||||
|
||||
#### D(o)
|
||||
|
||||
With an argument: execute a block of code & add a level to the stack.
|
||||
|
||||
```
|
||||
d ^routine ;run a routine from the begining.
|
||||
; ;routines are identified by a caret.
|
||||
d tag ;run a tag in the current routine
|
||||
d tag^routine ;run a tag in different routine
|
||||
```
|
||||
|
||||
Argumentless do: used to create blocks of code. The block is indented with a period for each level of the block:
|
||||
|
||||
```
|
||||
set a=1
|
||||
if a=1 do
|
||||
. write !,a
|
||||
. read b
|
||||
. if b > 10 d
|
||||
. . w !, b
|
||||
w "hello"
|
||||
```
|
||||
|
||||
#### Q(uit)
|
||||
Stop executing this block and return to the previous stack level.
|
||||
Quit can return a value.
|
||||
|
||||
#### N(ew)
|
||||
Clear a given variable's value _for just this stack level_. Useful for preventing side effects.
|
||||
|
||||
Putting all this together, we can create a full example of an M routine:
|
||||
|
||||
```
|
||||
; RECTANGLE - a routine to deal with rectangle math
|
||||
q ; quit if a specific tag is not called
|
||||
|
||||
main
|
||||
n length,width ; New length and width so any previous value doesn't persist
|
||||
w !,"Welcome to RECTANGLE. Enter the dimensions of your rectangle."
|
||||
r !,"Length? ",length,!,"Width? ",width
|
||||
d area(length,width) ;Do a tag
|
||||
s per=$$perimeter(length,width) ;Get the value of a function
|
||||
w !,"Perimeter: ",per
|
||||
q
|
||||
|
||||
area(length,width) ; This is a tag that accepts parameters.
|
||||
; It's not a function since it quits with no value.
|
||||
w !, "Area: ",length*width
|
||||
q ; Quit: return to the previous level of the stack.
|
||||
|
||||
perimeter(length,width)
|
||||
q 2*(length+width) ; Quits with a value; thus a function
|
||||
```
|
||||
|
||||
### Conditionals, Looping and $Order()
|
||||
|
||||
F(or) loops can follow a few different patterns:
|
||||
|
||||
```jinja
|
||||
;Finite loop with counter
|
||||
;f var=start:increment:stop
|
||||
|
||||
f i=0:5:25 w i," " ;0 5 10 15 20 25
|
||||
|
||||
; Infinite loop with counter
|
||||
; The counter will keep incrementing forever. Use a conditional with Quit to get out of the loop.
|
||||
;f var=start:increment
|
||||
|
||||
f j=1:1 w j," " i j>1E3 q ; Print 1-1000 separated by a space
|
||||
|
||||
;Argumentless for - infinite loop. Use a conditional with Quit.
|
||||
; Also read as "forever" - f or for followed by two spaces.
|
||||
s var=""
|
||||
f s var=var_"%" w !,var i var="%%%%%%%%%%" q
|
||||
; %
|
||||
; %%
|
||||
; %%%
|
||||
; %%%%
|
||||
; %%%%%
|
||||
; %%%%%%
|
||||
; %%%%%%%
|
||||
; %%%%%%%%
|
||||
; %%%%%%%%%
|
||||
; %%%%%%%%%%
|
||||
|
||||
```
|
||||
|
||||
#### I(f), E(lse), Postconditionals
|
||||
|
||||
M has an if/else construct for conditional evaluation, but any command can be conditionally executed without an extra if statement using a _postconditional_. This is a condition that occurs immediately after the command, separated with a colon (:).
|
||||
|
||||
```jinja
|
||||
; Conditional using traditional if/else
|
||||
r "Enter a number: ",num
|
||||
i num>100 w !,"huge"
|
||||
e i num>10 w !,"big"
|
||||
e w !,"small"
|
||||
|
||||
; Postconditionals are especially useful in a for loop.
|
||||
; This is the dominant for loop construct:
|
||||
; a 'for' statement
|
||||
; that tests for a 'quit' condition with a postconditional
|
||||
; then 'do'es an indented block for each iteration
|
||||
|
||||
s var=""
|
||||
f s var=var_"%" q:var="%%%%%%%%%%" d ;Read as "Quit if var equals "%%%%%%%%%%"
|
||||
. w !,var
|
||||
|
||||
;Bonus points - the $L(ength) built-in function makes this even terser
|
||||
|
||||
s var=""
|
||||
f s var=var_"%" q:$L(var)>10 d ;
|
||||
. w !,var
|
||||
|
||||
```
|
||||
#### Array Looping - $Order
|
||||
As we saw in the previous example, M has built-in functions called with a single $, compared to user-defined functions called with $$. These functions have shortened abbreviations, like commands.
|
||||
One of the most useful is __$Order()__ / $O(). When given an array subscript, $O returns the next subscript in that array. When it reaches the last subscript, it returns "".
|
||||
|
||||
```jinja
|
||||
;Let's call back to our ^TEMPS global from earlier:
|
||||
; A log of temperatures by date and time
|
||||
s ^TEMPS("11/12","0600",32)=""
|
||||
s ^TEMPS("11/12","0600",48)=""
|
||||
s ^TEMPS("11/12","1400",49)=""
|
||||
s ^TEMPS("11/12","1700",43)=""
|
||||
; Some more
|
||||
s ^TEMPS("11/16","0300",27)=""
|
||||
s ^TEMPS("11/16","1130",32)=""
|
||||
s ^TEMPS("11/16","1300",47)=""
|
||||
|
||||
;Here's a loop to print out all the dates we have temperatures for:
|
||||
n date,time ; Initialize these variables with ""
|
||||
|
||||
; This line reads: forever; set date as the next date in ^TEMPS.
|
||||
; If date was set to "", it means we're at the end, so quit.
|
||||
; Do the block below
|
||||
f s date=$ORDER(^TEMPS(date)) q:date="" d
|
||||
. w !,date
|
||||
|
||||
; Add in times too:
|
||||
f s date=$ORDER(^TEMPS(date)) q:date="" d
|
||||
. w !,"Date: ",date
|
||||
. f s time=$O(^TEMPS(date,time)) q:time="" d
|
||||
. . w !,"Time: ",time
|
||||
|
||||
; Build an index that sorts first by temperature -
|
||||
; what dates and times had a given temperature?
|
||||
n date,time,temp
|
||||
f s date=$ORDER(^TEMPS(date)) q:date="" d
|
||||
. f s time=$O(^TEMPS(date,time)) q:time="" d
|
||||
. . f s temp=$O(^TEMPS(date,time,temp)) q:temp="" d
|
||||
. . . s ^TEMPINDEX(temp,date,time)=""
|
||||
|
||||
;This will produce a global like
|
||||
^TEMPINDEX(27,"11/16","0300")
|
||||
^TEMPINDEX(32,"11/12","0600")
|
||||
^TEMPINDEX(32,"11/16","1130")
|
||||
```
|
||||
|
||||
## Further Reading
|
||||
|
||||
There's lots more to learn about M. A great short tutorial comes from the University of Northern Iowa and Professor Kevin O'Kane's [Introduction to the MUMPS Language][1] presentation.
|
||||
|
||||
To install an M interpreter / database on your computer, try a [YottaDB Docker image][2].
|
||||
|
||||
YottaDB and its precursor, GT.M, have thorough documentation on all the language features including database transactions, locking, and replication:
|
||||
|
||||
* [YottaDB Programmer's Guide][3]
|
||||
* [GT.M Programmer's Guide][4]
|
||||
|
||||
[1]: https://www.cs.uni.edu/~okane/source/MUMPS-MDH/MumpsTutorial.pdf
|
||||
[2]: https://yottadb.com/product/get-started/
|
||||
[3]: https://docs.yottadb.com/ProgrammersGuide/langfeat.html
|
||||
[4]: http://tinco.pair.com/bhaskar/gtm/doc/books/pg/UNIX_manual/index.html
|
||||
Loading…
Reference in New Issue
Block a user