The core library contains all the built-in methods and global functions.
Import Axiom source code from another location. The code is executed in the global context. Subsequent calls with the same source do nothing.
If source is a URL, the source code is downloaded and cached in a folder named ".axiom".
If source is a file path, it is automatically converted to an absolute path for de-duplication.
If source starts with '$', everything from the '$' to the first '/' is interpreted as an environment variable. If the variable does not exist, it is replaced with "." (current directory).
To share code among your Axiom projects, it is recommended that you create an environment variable named AXIOM_PATH, kind of like NODE_PATH in NodeJS or CPLUS_INCLUDE_PATH in g++. However, Axiom does not support multiple paths in an environment variable, so AXIOM_PATH can only contain a single path.
import('https://axm.dev/example.axm') #import URL
import('test.axm') #import file
import('$AXIOM_PATH/asdf/test.axm') #import file with environment variable
Get absolute path of calling file.
The return value changes depending on the source file. This can be used to build paths relative to the source file.
Generate a Universally Unique Identifier (UUID). This is just a random number that is so large that it is probabilistically guaranteed to be unique.
Uses an algorithm to increase randomness at the cost of time.
Generate a random number in the range [0,1).
Generate a random number in the range [min,max].
Generate a random number from a standard normal distribution.
Generate a random string with length len. Characters are chosen from the set of 52 characters "abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRTUVWXY346789", which is the set of alphanumeric characters with ambiguous characters removed (o/0/O, 1/I/l, 2/Z, 5/S).
Generate a timestamp from the specified date.
A timestamp is the number of seconds since the January 1, 1970 UTC (the Unix epoch).
If no arguments are passed, returns a timestamp corresponding to the current time.
Get scope at path.
This is useful for reflection or reverting monkey patches. The path of a scope can be seen by printing the scope.
:hello()
pass
print scope(':hello')==hello #true
print hello #:hello
#reflection
name = 'foo'
import(name+'.axm') #assume foo.axm contains a function :foo()
f = scope(':'+name) #get function :foo()
f() #call function :foo()
#monkey
:my_time()
return 0
time = my_time #patch
#...
time = scope(':time') #revert
Call a function by scope.
@cat
:meow()
print 'meow'
c = cat()
c.meow() #"meow"
call(cat.meow,c) #"meow"
call(scope('@cat:meow'),c) #"meow"
Get the type of the variable.
The possible types are 'null', 'number', 'boolean', 'string', 'array', 'object'.
print (null).type() #null
print (true).type() #boolean
print (2).type() #number
print ''.type() #string
print [].type() #array
print {}.type() #object
Convert variable to boolean.
Convert variable to number.
Convert variable to string.
For all variable types besides string, this is equivalent to :json(). For variables of type string, this does nothing (just returns the same string).
Convert variable to a JSON string.
This is like :string(), except for strings, the string is escaped and quoted in JSON format.
print 'hello\nthere'.json() #"hello\nthere"
Compare this variable to another variable.
Two variables of different types are never equivalent. This is so that variables are stratified by type when using any of the array.sort*() methods. The types are sorted in this order: null < boolean < number < string < array < object.
Two arrays are equivalent if they contain equivalent elements in the same order. Two objects are equivalent if they contain equivalent pairs in the same order.
Get the absolute value of a number.
Get the arc cosine (inverse cosine) in radians.
Get the arc sine (inverse sine) in radians.
Get the arc tangent (inverse tangent) in radians.
Get the cosine of a number in radians.
Get the sine of a number in radians.
Get the tangent of a number in radians.
Get the area (inverse) hyperbolic cosine.
Get the area (inverse) hyperbolic sine.
Get the area (inverse) hyperbolic tangent.
Get the hyperbolic cosine.
Get the hyperbolic sine.
Get the hyperbolic tangent.
Get the natural exponent of a number.
Get the natural logarithm of a number.
Get the base-10 logarithm of a number.
Get the square root of a number.
Get the cubic root of a number.
Raise this number to the exponent power.
Get the minimum of this number and other
Get the maximum of this number and other
Round number down to nearest integer.
Negative numbers get rounded up in absolute value.
print (1234.5).floor() #1234 print (-1234.5).floor() #-1235
Round number up to nearest integer.
Negative numbers get rounded down in absolute value.
print (1234.5).ceil() #1235 print (-1234.5).ceil() #-1234
Round number to nearest integer.
Rounds away from 0 for cases where fractional part is 0.5 or greater.
Get integer part of a number.
This is equivalent to rounding towards 0 (rather than towards negative/positive like :floor()/:ceil()).
print (1234.5).int() #1234 print (-1234.5).int() #-1234
Get fractional part of a number
print (1234.5).frac() #0.5 print (-1234.5).frac() #-0.5
Determine whether or not this number is invalid (not a number).
print (-1).sqrt().is_nan() #true
Determine whether or not this number is infinite.
print (1/0).is_inf() #true
Get the sign of a number.
Insert commas into a number.
Commas are inserted every 3 decimal places. If precision is negative, the shortest accurate precision is used (equivalent to when the number is printed).
print (1234.1).comma() #1,234 print (1234.1).comma(2) #1,234.10 print (1234.1).comma(-1) #1,234.1
Format this number as a size in bytes.
Units go from B (bytes) to PB (petabytes).
print (1234).bytes() #1.2 KB
Format this number as a duration specified in seconds.
The unit abbreviations are y = years, d = days, h = hours, m = minutes, s = seconds, ms = milliseconds. If any unit is 0, it is omitted from the output. For simplicity, a year is exactly 365 days. Milliseconds can be slightly off due to holes in the floating point number line.
print (1.23).duration() #1s 229ms print (100000).duration() #1d 3h 46m 40s print (100020).duration() #1d 3h 47m print (100020*365).duration() #1y 57d 12h 55m print (100020*365*1000).duration() #1157y 233d 4h 40m print (365*24*3600+24*3600+3600+60+1+0.0011).duration() #1y 1d 1h 1m 1s 1ms print (365*24*3600+1).duration() #1y 1s
Apply the local UTC offset including DST, assuming this number is a timestamp.
This is useful to apply before passing to :date() or :calendar() to produce localized output.
Daylight savings time is not consistent between years, and so the offset is calculated based on this timestamp.
# Assuming operating system is set to Los Angeles time
t = time(2020,6,6)
print 'UTC offset on',t.date('%x'),'=',(t.local()-t)/3600
t = time(2020,1,1)
print 'UTC offset on',t.date('%x'),'=',(t.local()-t)/3600
##
UTC offset on 2020/06/06 = -7
UTC offset on 2020/01/01 = -8
##
Format this number (timestamp) as a calendar date.
The format string is a string with any combination of the following flags:
Flag Description Example ---- ----------- ------- %a - Abbreviated weekday name [Thu] %A - Full weekday name [Thursday] %b - Abbreviated month name [Aug] %B - Full month name [August] %d - Day of the month, zero-padded (01-31) [23] %H - Hour in 24h format (00-23) [14] %I - Hour in 12h format (01-12) [02] %m - Month as a decimal number (01-12) [08] %M - Minute (00-59) [55] %p - AM or PM designation [PM] %S - Second (00-61) [02] %w - Weekday number with Sunday as 0 (0-6) [4] %x - Date representation [2016/06/21] %X - Time representation [14:55:02] %y - Year, last two digits (00-99) [01] %Y - Year [2001]
t = time(2000,1,2,3,45,56)
print t.date() #2000/01/02 03:45:56 Sun
print t.date('%B %d, %Y %I:%M %p') #January 02, 2000 03:45 AM
Format this number using printf-like syntax.
This function takes a format string similar to printf() in C++. The format string is a string like:
%[flags][width][.precision]specifier
The format string must begin with '%' and end with a valid specifier. The other fields in brackets are optional.
Valid specifiers are:
specifier output example --------- ------ ------- d or i Signed decimal integer 392 u Unsigned decimal integer 7235 o Unsigned octal 610 x Unsigned hexadecimal integer 7fa X Unsigned hexadecimal integer (uppercase) 7FA f Decimal floating point, lowercase 392.65 F Decimal floating point, uppercase 392.65 e Scientific notation (mantissa/exponent), lowercase 3.9265e+2 E Scientific notation (mantissa/exponent), uppercase 3.9265E+2 g Use the shortest representation: %e or %f 392.65 G Use the shortest representation: %E or %F 392.65 a Hexadecimal floating point, lowercase -0xc.90fep-2 A Hexadecimal floating point, uppercase -0XC.90FEP-2 c Character a p Pointer address b8000000
Valid flags are:
'-' — Left-justify within the given field width. Right justification is the default.
'+' — Prefix result with a plus or minus sign (+ or -) even for positive numbers.
By default, only negative numbers are preceded with a - sign.
' ' — Prefix positive numbers with blank space.
'0' — Left-pad the number with zeroes (0) instead of spaces when padding is specified (via width).
'#' — Depends on specifier:
Width is a number specifying the minimum number of characters to print. Remaining space is filled with either spaces or 0's depending on flag.
Precision depends on specifier:
(0.666).format('%.1d') #0.7
(97).format('%c') #a
Convert this number to a string in specified base (also called radix).
The radix can be in range [2,36]. For digits beyond 9, the uppercase alphabet is used. The opposite of this function is :parse_base(). If the number can be represented with a shorter precision, the shorter form is returned.
print (9).base(2) #1001 print (255).base(16) #FF print (1.625).base(2) #1.101 print (1.1).base(16) #1.19999999
Get length of string.
Find index of str in this string.
Find index of str in this string, searching from right to left.
Split string into an array of strings.
If delims is not specified, the behavior is to split the string along newlines. This will handle '\r\n' as a single character.
Slice this string into a smaller string.
If end is not specified, the string is sliced from start to the end of the string.
Remove leading and trailing whitespace from this string.
Whitespace characters are space (' '), tab (' '), carriage return ('\r'), and newline ('\n').
Convert this string to lower case.
Only English letters (A-Z) are supported.
Convert this string to upper case.
Only English letters (a-z) are supported.
Check if this string matches wildcard pattern.
A wildcard pattern is a string where '*' is used to match zero or more characters, and '?' is used to match any single character. Wildcard patterns are case-insensitive.
Search for wildcard pattern within string.
A wildcard pattern is a string where '*' is used to match zero or more characters, and '?' is used to match any single character. Wildcard patterns are case-insensitive.
print 'the quick brown fox'.search('b*x')
##
{
"index" : 10,
"token" : "brown fox"
}
##
Extract the substring from this string that falls between two wildcard patterns.
A wildcard pattern is a string where '*' is used to match zero or more characters, and '?' is used to match any single character. Wildcard patterns are case-insensitive.
print '<a href="http://example.com">test</a>'.extract('<a*href="','"') #http://example.com
Perform mass extraction on string.
Multiple tokens (multiple '$' in pattern) are supported.
print `
<ul>
<li>a</li>
<li>b</li>
<li>c</li>
</ul>
`.skim('<li>$</li>')
#output:
#[ "a", "b", "c" ]
Remove all instances of a single character from this string.
Replace all instances of string old with string new within this string.
Encode the bytes of this string as hexadecimal.
The hexadecimal output is lower case.
Decode this string as hexadecimal into bytes.
The hexadecimals input can be either upper or lower case.
Encode the bytes of this string as base64.
Decode this string as unbase64 into bytes.
Encode the bytes of this string as an Axiom string literal.
Axiom string literals are compatible with C-style string literals (C, C++, Python, Java, Javascript, etc.). See the Language Manual for details.
Decode this string as an Axiom string literal into bytes.
Axiom string literals are compatible with C-style string literals (C, C++, Python, Java, Javascript, etc.). See the Language Manual for details.
Encode the bytes of this string as a URL.
If component is false or not specified, this is equivalent to encodeURI() in Javascript. If component is true, this is equivalent to encodeURIComponent() in Javascript.
Decode this string as a URL into bytes.
Equivalent to decodeURI() in Javascript.
Get the Jenkin's hash of this string.
Jenkin's hash is faster and results in a smaller hash than the other hash function (like sha1). It is intended for use as an array index (when modded) for use in certain algorithms.
Get the SHA1 hash of this string.
Get the MD5 hash of this string.
Get the SHA256 hash of this string.
Sign this string using the HMAC algorithm with hash function SHA1.
The key should be kept secret. To verify an incoming message, sign the message again and compare the signature with the incoming signature.
Sign this string using the HMAC algorithm with hash function MD5.
The key should be kept secret. To verify an incoming message, sign the message again and compare the signature with the incoming signature.
Sign this string using the HMAC algorithm with hash function SHA256.
The key should be kept secret. To verify an incoming message, sign the message again and compare the signature with the incoming signature.
Encrypt or decrypt a string using key. The algorithm is the same both ways.
For better security and validation, use :encrypt() and :decrypt()
Encrypt a string using key, with salting and validation.
Decrypt a string using key, with salting and validation.
Check if this string starts with str.
Check if this string ends with str.
Check if this string contains str.
Sort the bytes of this string in specified order.
The bytes are sorted in place (the string is modified).
Shuffle the bytes of this string randomly.
The bytes are shuffled in place (the string is modified).
Reverse the bytes in this string.
This reverses the bytes in a string, not the characters.
To intepret the string as Unicode and reverse the characters, one should decode as Unicode first,
like: s.decode().reverse().encode()
Decode this string as UTF-8 into array of code points.
This is used to do character-level manipulation of strings, since strings are just bytes in Axiom.
This is similar to converting a std::string to a std::wstring in C++.
This is the opposite of the array method :encode().
Get the byte value of the nth element.
To set the byte value of the nth element, simply use the index and assignment operators with a number on the right-hand side.
s = 'abc' print s[0] #'a' print s.byte(0) #97 s[0] = 98 #how to set the byte value of an element print s #'bbc'
Parse this string as JSON.
Parse this string as a date and return a timestamp.
A variety of date formats are supported via fuzzy matching. Most common formats should work, including:
A variety of other formats should work as well, too many to enumerate.
Parse this string as a number in specified base (also called radix).
The radix can be in range [2,36]. The digits beyond 9 are represented by the alphabet, and both lowercase and uppercase character are accepted. The parsing stops at the first invalid digit, which can be a non-digit character or digit with value greater than or equal to radix. The opposite of this function is :base().
print '1001'.parse_base(2) #9 print 'fF'.parse_base(16) #255 (case doesn't matter) print '13'.parse_base(2) #1 (stops parsing at '3') print '1.19999999'.parse_base(16) # 1.1 (works)
Convert this string to Punycode.
If this string contains only ASCII, the returned string is identical. This function doesn't add trailing hyphens.
To use the Punycode string as part of a host name, the ASCII Compatible Encoding (ACE) prefix ("xn--") must be prepended. Consider using :web.url() to convert entire host names.
print 'δΎ'.punycode() #"fsq" print 'π'.punycode() #"n28h"
Get length of array.
Get the last element of array.
Remove the last element of array.
Append item to array.
Find index of item in this array.
Find index of item in this array, searching from right to left.
Do binary search for value, assuming this array is sorted.
If the value is not found, [lower,upper] corresponds to the indexes of the closest two elements.
Sort the elements of this array in specified order.
The items are sorted in place (the array is modified).
Sort the elements of this array by the specified key, assuming each element is an object.
The items are sorted in place (the array is modified).
Sort the elements of this array by the specified index, assuming each element is also an array.
The items are sorted in place (the array is modified).
Sort the elements of this array using the specified comparator function.
The items are sorted in place (the array is modified).
Combine the elements of the array into a single string.
Slice this array into a smaller array.
If end is not specified, the array is sliced from start to the end of the array.
Remove element at index.
Elements after index are downshifted to fill hole.
Get column of elements, assuming this is a two-dimensional array.
Flip this array along the diagonal, assuming this is a two-dimensional array.
Get the set of unique elements in this array.
Shuffle the elements of this array randomly.
The elements are shuffled in place (the array is modified).
Reverse the elements of this array.
Encode this array as a UTF-8 byte string, assuming it is an array of numbers representing Unicode code points.
This is the opposite of the string method :decode().
Convert this array to table (an array of arrays where the first row is headers), assuming this is an array of objects.
t = [
{
a: 1,
b: 2,
c: 3
},
{
a: 4,
b: 5,
c: 6
}
]
print t.table()
##
[
[ "a", "b", "c" ],
[ 1, 2, 3 ],
[ 4, 5, 6 ]
]
##
Convert this array to an array of objects, assuming this is a table (an array of arrays where the first row is headers).
t = [
['a','b','c'],
[1,2,3],
[4,5,6]
]
print t.untable()
##
[
{
"a" : 1,
"b" : 2,
"c" : 3
},
{
"a" : 4,
"b" : 5,
"c" : 6
} ]
##
Apply the function fn to all elements of this array.
The function fn takes three parameters:
The return value of fn should be the desired element in the new array.
:abs(x) return x.abs() print [-1,1,2,-3].apply(abs) #[ 1, 1, 2, 3 ]
Filter this array using function fn.
The function fn takes three parameters:
If fn returns true, the element is kept in the resulting array. If fn returns false, the element is omitted from the resulting array.
:pos(x) return x>0 print [-1,1,2,-3].filter(pos) #[ 1, 2 ]
Get sorted item counts from this array.
print ['a','b','c','a','a','c'].counts()
##
{
"a" : 3,
"c" : 2,
"b" : 1
}
##
Create object from this array, assuming it is an array of key-value pairs.
The term "map" is overloaded in many other languages. In Python it refers to applying the same function to every element of an array. To do this in Axiom, use :apply(). In C++ it refers to an unordered dictionary. In Javascript it refers and ordered dictionary, but also applying a function to each element of an array, depending on the context. To solve this confusion, in Axiom "map" strictly refers to mapping key-value pairs to create an object. (All objects in Axiom are also dictionaries, and are always ordered.)
This method is the opposite of object.pairs() with no arguments specified.
print [['a',1],['b',2]].map()
##
{
"a" : 1,
"b" : 2
}
##
Get number of pairs in object.
Check for key within object.
Get all keys within object, or a specific key by index.
Key/value pair order is preserved within objects in Axiom (unlike most other programming languages). The key/value pair order is the order in which the key was first added.
Negative values for n are relative to the number of keys.
Get all key/value pairs within object, or a specific pair by index.
Key/value pair order is preserved within objects in Axiom (unlike most other programming languages). The key/value pair order is the order in which the key was first added.
Negative values for n are relative to the number of keys.
If n is omitted, this method is the opposite of array.map().
Get all values within object, or a specific value by index.
Key/value pair order is preserved within objects in Axiom (unlike most other programming languages). The key/value pair order is the order in which the key was first added.
Negative values for n are relative to the number of keys.
Remove pair with key key from object.