>>> declare int i                                    # Integers are initialized to 0 by default. Characters to '\0', and logicals to False. 
>>> print i                                                        
0
>>> int j = 1                                        # A custom initialization is also possible.
>>> print j
1
>>> declare ints k, l                                # Using the type of the object in plural, multiple declarations can be made in one statement.
>>> print k, l                                       # Print multiple space-separated objects using commas. 
0 0

>>> int i = 2
>>> print (1 + (3 * i)) / 7                          # All the usual arithmetic operators work, but they have no order of precedence. Use parentheses.
1
>>> print i ^ 10                                     # The '^' signifies raising a number to an exponent (not the XOR operation).
1024
>>> let i += 2                                       # A simple update. One could similarly use -=, *=, ^= etc.
>>> print (i % 2) == 0                               # All comparative operators are supported (<, >, <= etc).
True
>>> print |14| + |-13|                               # |n| is the modulus of n. Use |(n)| for an expression.
27

>>> declare char null                                 # All characters are initialized to '\0' by default.
>>> print null == '\0'                                # To define an escape character, use a backslash.
True
>>> char brace = '\}'                                 # All braces, parentheses, and brackets also need to be preceded by the backslashes.
>>> print brace                                       # This is to make sure the parser doesn't confuse if for a closing brace of a set or something.
}
>>> printr brace                                      # To print a char in its 'raw' form, with quotes and all, use the printr command.
'\}'

>>> print |'a'|                                       # For characters, '|' prints the ASCII value.
97

>>> declare logical val                           # By default, logicals are initialized to False.
>>> print val
False
>>> logical comp = 1 < '1'                        # Custom initialization. ASCII value of '1' is used.
>>> print comp
True

>>> print True V False                            # The logical OR (disjunction).
True
>>> print True & False                            # The logical AND (conjunction).
False
>>> print !True                                   # Negation (a unary operator).
False
>>> logical val = (4 % 2) != 0                    # To illustrate the updates.
>>> print val                  
False
>>> let val V= True                               # Semantically equivalent to `val = val V True`
>>> print val
True
>>> let val &= False                              # Semantically equivalent to `val = val & False`
>>> print val
False
>>> print 23 ^ False                              # Another example of automatic casting. Will give a one.
1

>>> declare set A                                 # Declares an empty set A.
>>> print A
{}
>>> set easter = {27, 'J', 1996, A}               # Initializes a set with these elements. Identifiers as well as literals allowed.
>>> print easter
{27, J, 1996, {}}
>>> printr easter                                 # The printr command recursively prints the raw version of the elements. 
{27, 'J', 1996, {}}
>>> print exprset = { 1 + 2, 3 + 4 }              # The elements of a set can be expressions as well.
{3, 7}

>>> print {1, 2} U {1, 3}                         # Union of two sets.
{1, 2, 3}
>>> print {1, 2} & {1, 3}                         # Intersection.
{1}
>>> print {1, 2} \ {1, 3}                         # Exclusion.
{2}

>>> set A = {1, 2, 3} x {'A', 'B'}                # Cartesian Product. The result is a set of tuples.                              
>>> print A                          
{(1, A), (1, B), (2, A), (2, B), (3, A), (3, B)} 
>>> print |A|                                     # Print the cardinality of set A (an integer).
6

>>> print {(1, 'B')} c A                          # Is this set a subset of A?
True

>>> print A[1]                                    # Access the element of A at index 1.
{(1, B)}
>>> print A[(1, 3)]                               # Access the subset of A between [1, 3).
{(1, B), (2, A)}

>>> set A = {{1, 2}, {3, 4}}                      # A set of sets. 
>>> let A[1] \= {4}                               # Directly update the set at index 1 of A.
>>> print A
{{1, 2}, {3}}

>>> print ('2' in {1, {'2'}, 3}[1])                  # The 'in' and '[]' operators in action.
True

>>> tuple A = (1, )                                   # A single-element tuple needs a trailing comma.
>>> print A[0]
1
>>> declare tuple entry
>>> string given = "Tushar"
>>> string family = "Rakheja"
>>> let entry = (given, family)                       # Identifiers can be used as elements.
>>> print entry
("Tushar", "Rakheja")
>>> print |entry|                                     # Print the dimension of the tuple.
2

>>> int A = 1                                        # We'll use these two elements to illustrate.
>>> int B = 2
>>> tuple shallow = (A, B)                           # We're making a tuple that has `A` and `B` as its elements. 
>>> tuple copy_AB = (.A, .B)                         # We're making a tuple that has 'copies' of A and B.
>>> tuple copy_shallow = . shallow                   # We're making a tuple that is a deep copy of shallow. 
>>> let A += 3                                       # This will modify the contents of `shallow`, but not those of the two `copy` tuples.
>>> print shallow                                    # This is because the tuple `shallow` has as its elements the 'objects' that A and B identify. 
(4, 2)
>>> print copy_AB                                    # Whereas, the tuple `copy_AB` was made with copies of those objects, which were not affected by the update. 
(1, 2)
>>> print copy_shallow                               # The tuple `copy_shallow` was a copy of `shallow` made before the update. Since the '.' operator is recursive, it made copies of the objects inside of `shallow` as well. 
(1, 2)

>>> declare string null                              # By default strings are initialized to "".
>>> print null == ""
True
>>> string str = "\(\n\)"                            # Just like in the case of characters, escape sequences are identified by \.
>>> print str
(
)
>>> printr str                                       # Raw printng. 
"\(\n\)"

>>> string hello = "Hello"      
>>> string world = "World"
>>> print hello + " " + world                         # Strings can be concatenated with the + operator.
>>> string hellow = hello           
>>> let hellow += " " + world                         # The += updater will work as expected. 
>>> let hellow += '!'                                 # One can also append characters with it.
>>> print hellow
Hello World!

>>> string test = "ABCD"
>>> print test[1]                                     # Returns the character at index 1.
B
>>> print |test|                                      # Returns an int = the size of the string.
4
>>> print test[(1, 3)]                                # Returns the substring between [1, 3).
BC
>>> logical val = ('A' in test) & ("BCD" in test)
>>> print val                                         # The 'in' op can take strings and chars both.
True

>>> print typeof 1
int
>>> printr typeof (True V False)
"logical"

>>> declare map fog                                  # Declare a map fog
>>> map f : {"One", "Zero"} -> {True, False}		 # Initialize a map with a given domain and codomain.
>>> under f : "One"  -> True					     # `Under f, "One" goes to True.`
>>> under f : "Zero" -> False		                 
>>> print f
{(One, True), (Zero, False)}

>>> print f["One"]					                 # Maps can be queried this way.	
True
>>> map g : {1, 0} -> {"One", "Zero"}				
>>> under g : 1 -> "One"
>>> under g : 0 -> "Zero"
>>> print |g|                                        # Prints the number of mappings in the map.
2
>>> let fog = f o g					                 # Let fog = the composition of maps f and g.
>>> print fog
{(1, True), (0, False)}				  
>>> let f o= g                                       # The compose-update. Equiv. to `f = f o g`.
>>> print f[1]
True

>>> declare map fcube                                # Will be used for illustration.
>>> map f : {1, 2, 3} -> {1, 2, 3}                  
>>> under f : 1 -> 2
>>> under f : 2 -> 3
>>> under f : 3 -> 1
>>> print f
{(1, 2), (2, 3), (3, 1)}
>>> let fcube = f ^ 3                                # `fcube` is the map `f` composed with itself once.
>>> print fcube
{(1, 1), (2, 2), (3, 3)} 
>>> let f ^= 2                                       # The power update also works on maps. 
>>> print f
{(1, 3), (2, 1), (3, 2)} 

>>> declare abstract set EvenP                       # Abstract sets are declared just like normal sets, but with the abstract keyword.
>>> let EvenP = { {a, b} | ((a * b) % 2) == 0 }      # This is an abstract set literal.
>>> print {1, 2} in EvenP
True
>>> print {1, 3} in EvenP
False
>>> print EvenP
{ {a, b} | ((a * b) % 2) == 0 }

>>> int l = 4000
>>> abstract set Test = { l | l < 2000 }
>>> print 3 in Test                                  # The local placeholder 'l' will override the int 'l'.
True

>>> set A = {1, 2, 3} 		                         # Autolang also supports the notion of 'abstract' sets.
>>> abstract set PowA = { elem | elem c A }          # Define the PowA as the power set of A.
>>> print {1, 3} in PowA
True
>>> print {1, 4} in PowA
False

>>> abstract set Inter = PowA & EvenP               # Take the intersection of two abstract sets.
>>> print {1, 2} in Inter
True
>>> print {1, 3} in Inter
False
>>> print {{1, 2}, {2, 3}} c Inter                  # A subset op between a normal and an abstract set.
True

>>> print ASet in ASet 
True

>>> abstract set S = { obj | ! (obj in obj) }  

>>> declare abstract map add                         # Abstract maps can be declared the same way as normal maps, with the 'abstract' keyword.
>>> under add : (a, b) -> a + b                      # Take in a tuple of two objects, add them up.
>>> print add[(1, 2)]
3
>>> print add[("A", "B")]
AB

>>> abstract map fact : Int -> Int                   # The domain and codomain of abstract maps have to be abstract sets.
>>> under fact : n -> (n < 2) ? 1 : (n * fact[n - 1])
>>> print fact[5]
120

>>> declare abstract maps square, octa                 # If the domain and range are not specified, no restriction on input/output.
>>> set pmaps = { square, octa }                       # Make a set of abstract maps.
>>> under pmaps[0] : n -> n ^ 2                        # Assign a mapping scheme to pmaps[0], which is the map `square`.
>>> print pmaps[0][3]                                  # Print the square of 3.
9
>>> let pmaps[1] = pmaps[0] ^ 3                        # Let the map `octa` be the cube of the map `square`.
>>> print octa[2]                                      # Query the abstract map.
256

>>> declare auto binall                                # We'll use it later.
>>> set states = { "S", "1", "0" }                     # The set of states for the automaton.
>>> set sigma = { '1', '0' }                           # The input alphabet.
>>> map delta : states x sigma -> states               # The transition map for the automaton.
>>> under delta : ("S", '0') -> "0"                    # The mappings are such that ...
>>> under delta : ("S", '1') -> "1"                    # ... the resulting automaton ...
>>> under delta : ("0", '0') -> "0"                    # ... will accept all strings ...
>>> under delta : ("0", '1') -> "1"                    # ... that are binary representations ...
>>> under delta : ("1", '0') -> "0"                    # ... of even integers, and ...
>>> under delta : ("1", '1') -> "1"                    # ... will reject all others.
>>> auto bineven = (states, sigma, states[0], delta, states[(2, 3)]) 

>>> print bineven["100"]                               # Automata can be queried using the [] operator.
True
>>> print bineven["101"]                               # If a string is accepted, the result is True. Else False.
False
>>> auto binodd = (states, sigma, states[0], delta, states[(1, 2)]) 
>>> let binall = bineven U binodd                      # Let binall accept L(bineven) U L(binodd).
>>> print binall["100"]
True
>>> print binall["101"]
True

>>> abstract set l_even = { elem | bineven[elem] }     # Will evaluate to true for strings accepted by bineven.
>>> print "100" in l_even
True
>>> print "101" in l_even
False

>>> source data = ("data.txt", '\n')            # (filepath, delimiter)
>>> print data                                  # Prints all the file's contents.
1 minute.
{4, 'l'}
(5, 'l')
True | story.

>>> print !data                            # Prints True if the source is in an unreadable state.
True
>>> let data += 0                          # The += and -= operators offset the source by the specified number of bytes, and reset it if needed.
>>> print |data|                           # The source should now ready to read, from the very top. So the number of bytes we've already is 0.                     
0
>>> int readone <- data                    # Variables can be initialized directly with data coming from a source, using the `<-` updater.
>>> print readone                          # The delimiter is not used when reading ints and chars.
1
>>> let data[1] = '.'                      # The delimiter is a part of the source's tuple and can be accessed intuitively.
>>> declare string sample                  # To read data into pre-existing variables,
>>> get sample <- data                     # the '<-' updater can be used with the 'get' keyword.
>>> print sample                           # The delimiter is not read into the string, and the source moves past it. 
 minute
>>> let data -= |sample|                   # To re-read some data we just read, we can use the -= update to send the source back by some amount.
>>> get sample <- data                     # And then simply read it again.
>>> print sample
 minute
>>> let data += 1                          # We can just skip/move past the '\n' in the file after '.'.
>>> let data[1] = '\n'                     # The next data we read will be read till a newline.
>>> set newsample <- data                  # Sets can also be initialized with data coming in from a stream. 
>>> print newsample
{4, l}
>>> tuple another <- data                  # Tuples also, obviously. 
>>> print another
(5, l)
>>> let data[1] = '|'                      # Even though logicals 'can' be read in from sources, it's not advised. At all.
>>> logical true <- True                   # If you must, set the delimiter to something you're sure will give a clean literal.
>>> print true                             # I suggest reading integers instead of logicals and casting.
True
>>> print |data|                           # Phew, we've read in 65 bytes of data!
65
>>> quit                                   # Quitting is advisable. If you exit your terminal directly, the next time you source this file, it'll have weird bits. You'll need to reset it. 

>>> sink data = ("data.txt", True, False)  # (filepath, append?, raw print?)
>>> string putdata = "\nSee?"              # We'll append this string to the file.
>>> let data += putdata                    # Print the string in it's processed format.
>>> let data[2] = True                     # Set the raw flag to True.
>>> let data += putdata                    # Now the string will be written in it's raw format. 
>>> quit                                   # And that's it! Sinks offer only this interfact for now.

>>> string num = "123"
>>> int getnum <- num
>>> print getnum
123
>>> char getch <- num      # Semantically equivalent to char getch = num[0] 
>>> print getch           
1
>>> logical g1 <- num      # True iff the source string 'contains' "True".
>>> print g1
False

>>> print :: (a, b) -> a + b ::[(9, 9)]        
18

>>> declare abstract map add
>>> let add = :: (a, b) -> a + b ::
>>> print add[("Brooklyn", " Nine-Nine")]             
>>> Brooklyn Nine-Nine

>>> print fold[(add, {1, 2, 3, 4})]               # computes 1 + 2 + 3 + 4.
10
>>> print fold[(mult, {1, 2, 3, 4})]              # computes 1 * 2 * 3 * 4.
24
>>> print apply[(:: n -> n ^ 2 ::, {1, 2, 3, 4})] # A λ in place of a map will do just fine. 
{1, 4, 9, 16}

>>> under apply : (am, s) -> (|s| == 1) ? { am[s[0]] } : ({ am[s[0]] } U apply[(am, s[(1, |s|)])])
>>> under fold : (am, s) -> (|s| == 1) ? (s[0]) : (am[(s[0], fold[(am, s[(1, |s|)])])])

>>> declare abstract map binop
>>> under binop : name -> (name == "mult") ? mult : ::(a, b) -> a + b:: 
>>> print binop["mult"][(3, 3)]
9
>>> print binop["dflt"][(3, 3)]      # A lambda expression can be returned as well.
6

>>> source maps = ("unpack.txt", '\n')           # Open file.
>>> string junk <- maps                          # Eat comments and blank lines.
>>> let maps[1] = ';'                            # Now it's time to read a scheme.
>>> abstract map unpack <- maps                  # Make an abstract map using the scheme.
>>> let maps[1] = '\n'                           # Time to read more junk.
>>> get junk <- maps                             # Eat the '\n' after the previous ';'
>>> get junk <- maps                             # Eat the blank line.
>>> get junk <- maps                             # Eat the comment.
>>> let maps[1] = ';'                            # Time to read another scheme.
>>> abstract map unpackall <- maps               # Make the map.
>>> print unpack[(1, (2, 3))]                    # Time to test, yay!
(1, 2, 3)
>>> print unpackall[{1, 2} x {'A', 'B'} x {True}]
{(1, A, True), (1, B, True), (2, A, True), (2, B, True)}

>>> set P = {1, 2} x {'a', 'b'} x {True}    # We have tuples of the form (e, (f, g)), not (e, f, g) as expected.
>>> print P
{(1, ('a', True)), (1, ('b', True)), (2, ('a', True)), (2, ('b', True))}
>>> print |(P[0])|                                                         # Will not print 3, but 2.
2