Zoomba: A Micro-Language For Jvms .
Uploaded by
San DeeptiZoomba: A Micro-Language For Jvms .
Uploaded by
San DeeptiZoomBA
Programming Language
A Micro-Language For JVMs
Version : .
By : zoomba-lang.org
Co n t e n t s
Contents i
Preface ix
A brief History ix
About The Language ix
The Philosophy of the Logo x
Thanks x
About Z o o m BA
. ZoomBA Philosophy
. Design Features
.. ZoomBA is Embeddable
.. Interpreted by JVM
.. ZoomBA can Execute any Java Code
.. ZoomBA can be used Functionally
.. ZoomBA is Dynamically Typed
.. ZoomBA Vs Java
. Setting up Environment
.. Installing Java Run Time
.. Download ZoomBA one jar
.. Add to Path
.. Test Setup
.. Maven Setup for Java Integration
.. Setting up Editors
.. The Proverbial “Hello, World”
ZoomBA S y n ta x i n M i n u t e s
. Building Blocks
.. Identifiers & Reserved Keywords
.. Assignments
.. Comments
.. Basic Types
.. Multiple Assignment
. operators
.. Arithmetic
.. Logical
.. Comparison
.. Ternary
. Conditions
i
ii conten t s
.. If
.. Else
.. Else If
. Loops
.. While
.. For
. Functions
.. Defining
.. Function Calling
.. Global Variables
. Anonymous Function as a Function Parameter
.. Why it is needed?
.. Some Use Cases
. Available Data Structures
.. Range
.. List
.. Set
.. Dict
.. Multi Set
.. Mutability
Formal Co n s t ru c t s
. Conditional Building Blocks
.. Formalism
.. Relation between “there exists” and “for all”
.. There Exist In Containers
.. Size of Containers : empty, size, cardinality
.. There Exist element with Condition : index, rindex , exists
.. For All elements with Condition : select
.. Partition a collection on Condition : partition
.. Collecting value on Condition : select, from
.. Inversion of Logic
. Operators from Set Algebra
.. Set Algebra
.. Set Operations on Collections
.. Collection Cross Product and Power
.. Collection Relation Comparisons
.. Mixing Collections
.. Collections as Tuples
. Assertions
.. Existence of Variables
.. Verifying Truth about Expressions
Collec t i o n s A n d Co m p r e h e n s i o n
. Using Anonymous Argument
.. List
.. Set
.. Dict
.. Multi Set
.. Stack And Queue
.. JVM Arrays
. Constructs Altering the Iteration Flow
contents iii
.. Continue and Break
.. Continue
.. Break
.. Substitute for Select
.. Uses of Partial
. Comprehensions using Multiple Collections : Join
.. Formalism
.. As Nested Loops
.. Join Function
.. Permutations
.. Combinations
.. Searching for a Tuple
.. All Possible Sub Collections
.. Projection on Collections
Types a n d Co n v e r s i o n s
. Integer Family
.. Boolean
.. Integer
.. Arbitrary Large Integer
. Rational Numbers Family
.. Float
.. FLOAT
. Generic Numeric Functions
.. num()
.. size()
.. Float to Integers
.. Signs and Absolute
.. log()
. The Chrono Family
.. time()
.. Adjusting Timezones
.. Comparison on Chronos
.. Arithmetic on Chronos
. String : Using str
.. Types of Strings
.. Null
.. Integer
.. Floating Point
.. Chrono
.. Collections
.. Generalised toString()
.. JSON
.. Yaml
. Playing with Types : Reflection
.. type() function
.. The === Operator
.. The isa operator
.. Field Access
.. Nested Field Access
Reusin g Co d e
iv conten t s
. The Import Directive
.. Syntax
.. Examples
. Using Existing Java Classes
.. Load Jar and Create Instance
.. Import Enum
.. Import Static Field
.. Import Inner Class or Enum
. Using ZoomBA Scripts
.. Creating a Script
.. Relative Path
.. Calling Functions
Functi o n a l St y l e
. Functions : In Depth
.. Function Types
.. Default Parameters
.. Named Arguments
.. Arbitrary Number of Arguments
.. Arguments Overwriting
.. Recursion
.. Closure
.. Partial Function
.. Functions as Parameters : Lambda
.. Composition of Functions
.. Operation on Function
.. Eventing
. Strings as Functions : Currying
.. Rationale
.. Minimum Description Length
.. Examples
.. Reflection
.. Referencing
. Avoiding Conditions
.. Theory of the Equivalence Class
.. Dictionaries and Functions
.. An Application : FizzBuzz
. Avoiding Iterations
.. Range Objects in Detail
.. The Fold Functions
.. Matching
.. Sequences
Input a n d O u t p u t
. Reading
.. read() function
.. Reading from url : HTTP GET
.. Reading All Lines
. Writing
.. write(), println(), printf() function family
. File Processing
.. open() function
contents v
.. Reading
.. Writing
. Web IO
.. open() for web
.. get() , post()
.. Sending to url : send() function
. Working with JSON
.. What is JSON?
.. json() function
.. Accessing Fields
.. Yaml Processing
. Working with XML
.. xml() function
.. Converting to Other Formats
.. Accessing Elements
.. XPATH Formulation
. Generic XPath, XElement
.. xpath()
.. xelem()
. DataMatrix
.. matrix() function
.. Accessing Data
.. Tuple Formulation
.. Project and Select
.. The matrix() function
.. Keys
.. Aggregate
Interac t i n g w i t h E n v i r o n m e n t
. Process and Threads
.. system() function
.. popen() function
.. thread() function
.. poll() function
.. Atomic Operations
.. The clock Block
. Handling of Errors
.. error() function
.. Multiple Assignment
.. Error Assignment
. Order and Randomness
.. Lexical matching : tokens()
.. hash() function
.. Anonymous Comparators
.. Sort Functions
.. Heap
.. Priority Queue
.. sum() function
.. minmax() function
.. shuffle() function
.. The random() function
vi conten t s
. Errors in ZoomBA
.. Unknown Variable Error
.. Unknown Property Error
.. Function Errors
.. Stack Trace
.. Arithmetic Errors
.. LValue Error
.. Stack OverFlow
.. Null Error
. Debugging
.. Simple Breakpoint
.. Conditional Breakpoint
Object O r i e n tat i o n
. Introduction to Classes
.. Defining and Creating
.. Instance Fields
.. Constructor
.. Instance Methods
. Statics & Prototype Based Inheritence
.. Static Fields
. Operators
.. Example : Complex Number
Practi c a l Z o o m BA
. A Note in Style
.. Comments
.. Naming Conventions
.. Explicit Conditionals and Iteration
.. Assertions
. Assorted Theoretical Examples
.. A Game of Scramble
.. Find Anagrams of a String
.. Sublist Sum Problem
.. Sublist Predicate Problem
.. List Closeness Problem
.. Shuffling Problem
.. Reverse Words in a Sentence
.. Recursive Range Sum
.. String from Signed Integer
.. Permutation Graph
.. Find Perfect Squares
.. Max Substring with no Duplicate
.. Maximum Product of Ascending Subsequence
.. Minimal Sum of Integers in Digit Array
.. Ramanujan Partitions
.. Consecutive Elements in Subset
.. Competitive Array
.. Sum of Permutations
.. Print a String Multiple times
.. Next Higher Permutation
.. Maximal Longest Substring Problem
contents vii
.. Partitions which are Palindromes
.. Triple Sum
.. Pythagorean Triplet
.. Substring as Permutation
.. Pivot Partition
.. Find all subsequences where Predicate
. Assorted Practical Examples
.. Generic Result Comparison
.. Verifying Filter Results
.. Storing Positions of Elements in a String
.. Find Largest N : heap()
.. Rational Number Representation
.. Maximum Span of Stock Prices
.. Recognising String from Languages
.. Globally Unique ID
.. Inversions In A Pair of Collections
.. Summation of Binary Integers
.. Generating System Response Curve
.. Shuffling in a Media Player
.. Ordering Thread Execution
.. Asynchronous Computation
.. Computation of Query
.. Generating Strings
.. First Unique URL
.. Conditional Assignment : Casing
.. Parking Rearrangement Problem
.. Interleaving of Strings
Java Co n n e c t i v i t y
. How to Embed
.. Dependencies
.. Programming Model
.. Example Embedding
. Programming ZoomBA
. Extending ZoomBA
.. Implementing Named Arguments
.. Using Anonymous Arguments
Bibliogra p h y
Index
Index
P r e f ac e
ZoomBA is motivated by Apache Jexl project. Scripting based on JVM is necessary, and
the existing scripting languages were not simply not effective enough for glue purposes. We
believed that world needed a scripting language for JVM, but at the same time, it’s purpose
should be isolated scripting, and with very limited scope. And, ZoomBA was born.
A brief History
Need of the hour was a language where one can write business logic for data processing freely.
There was no language available which lets intermingle with Java POJO.
Worse still - one can not write business logic freely using Java, the whole spring MVC is
a challenge. Given almost all of modern enterprise application are written using Java, it is
impossible to avoid Java and write Enterprise code : in many cases you would need to call
appropriate Java methods to automate APIs.
Thus, one really needs a JVM scripting language that can freely call and act on POJOs, the
inherent historical baggage of JavaScript disables Nashorn from being a suitable choice. But
with Nashorn out of default scripting Engine now, scripting on JVM looks bleak.
A micro language like ZoomBA fills up the gap. When we decided to invent ZoomBA, we
imagined a language where one can freely code data manipulation logic, as a gluing between
multiple web service API calls. It was built to connect the dots, dots being plethora of micro-
services.
About The Language
It is an interpreted language. It is asymptotically as fast as Python , with a general lag of
ms of reading and parsing files, where native python is faster. After that the speed is the same.
It is modern, unlike MVEL, it has JVM flavour in it, it is essentially very short Kotlin or
Scala. Type safety is sacrificed for it being a configuration language. A JSON is a valid ZoomBA
literal, thus making data transfer natural.
It is a multi-paradigm language. It supports functionals ( i.e. functions taking functions
as input or returning a function as output) out of the box, and every function by design can
take function as input. There are tons of in built methods which uses these functionals. One
massive departure from functional style however, the lack of immutable containers. ZoomBA
has none. It altogether avoids the problem by tighter scoping of variable.
It also supports prototype based OOP. There is no reason to do object modelling in ZoomBA,
plain old Java/Scala works well. ZoomBA is more like a band-aid language, it has multiple
features copied from many other languages. The heavy use of __xxx__ literals, and def is out
and out python.
The space and tab debate is very religious, and hence ZoomBA is decidedly " blocked "
: Brace yourself. Pick tab/space to indent - none bothers here. You can use ";" to separate
statements in a line. Lines are statements.
ix
x prefac e
The Philosophy of the Logo
The thunder symbol in the logo signifies what precisely it was meant to do, fast forward time
to prod. It is apparent that ZoomBA is a slow language, while the current implementation is
concerned, but then, for business processes, the flexibility is the key. For example, ZoomBA
can, and does replace Spring’s DI system, works as glue between any database command line
interfaces and JVM (thereby not requiring any library support), act as configurations.
Thanks
And finally, all of these pages were typed using TexShop-. So, thanks to Richard Koch, Max
Horn Dirk Olmes. For MacTex, thanks MacTex. You guys are great! Thanks to Apple for
creating such a beautiful system to work on. Steve, we love you. RIP.
Thanks to Gabriel Hjort Blindell - for the beautiful style file he created which can be found
here. Gabriel, thanks a ton. The ZoomBA logo was created using freelogoservices. Keep up the
amazing work.
chapter 1
A b o u t Z o o m BA
A philosophy is needed to guide the design of any system. ZoomBA is not much different.
Here we discuss the rationale behind the language, and showcase how it is distinct from its first
cousin Java. While has similarity to Scala should not come as a surprise, that is an example of
convergent evolution. But just as every modern animal is highly evolved, and there is really
no general purpose animal, we sincerely believe there is no real general purpose language. All
languages are special purpose, some special purposes may seem generic in nature. However,
ZoomBA preaches a different philosophy than scala, kotlin and even python.
. z o o mba philosophy
To begin with, our own experience in Industry is aptly summarised by Ryan Dahl in here , the
creator of Node.js :
I hate almost all software. It’s unnecessary and complicated at almost every layer. At best I can
congratulate someone for quickly and simply solving a problem on top of the shit that they are given.
The only software that I like is one that I can easily understand and solves my problems. The amount
of complexity I’m willing to tolerate is proportional to the size of the problem being
solved...(continued)... Those of you who still find it enjoyable to learn the details of, say, a
programming language - being able to happily recite off if NaN equals or does not equal null - you
just don’t yet understand how utterly fucked the whole thing is. If you think it would be cute to align
all of the equals signs in your code, if you spend time configuring your window manager or editor, if
put unicode check marks in your test runner, if you add unnecessary hierarchies in your code
directories, if you are doing anything beyond just solving the problem - you don’t understand how
fucked the whole thing is. No one gives a fuck about the glib object model. The only thing that
matters in software is the experience of the user. - Ryan Dahl
Thus, ZoomBA comes with it’s tenets, which are :
. Reduce the number of lines in the code; Principle of Percimony
. If possible, in every line, reduce the number of characters;
. Get out of the cycle of bugs and fixes by writing scientific and provable code Provability
( see Minimum Description length ).
. The final statement is : Good code is only once written, and then forever forgotten, i.e. :
limiting to maintenance. Maintainability is lack of need to Maintain
chapter . about zoom ba
That is,
To boldly go where no developer has gone before - attaining Nirvana in terms of coding
Thus we made ZoomBA so that a language exists with it’s full focus on Business Process Automa-
tion & Validation, not on commercial fads that sucks the profit out of business. Hence it has one
singular focus in mind : brevity but not at the cost of maintainability. What can be done with
people, in days, get it done in day by one person.
It is being demonstrated by firms adapting to it.
. d e s ign features
Here is the important list of features, which make ZoomBA a first choice of the business
developers and software testers, alike.
.. ZoomBA is Embeddable
ZoomBA scripts are easy to be invoked as stand alone scripts, also from within java code, thus
making integration of external logic into proper code base easy. Thus Java code can call ZoomBA
scripts very easily, and all of ZoomBA functionality is programmatically accessible by Java caller
code. This makes it distinct from Scala, where it is almost impossible to call scala code from
Java. Lots of code of how to call ZoomBA can be found in the test directory. Many scripts are
there as samples in samples folder. In chapter we would showcase how to embed ZoomBA
in Java code.
.. Interpreted by JVM
ZoomBA is interpreted by a program written in Java, and uses Java runtime. This means that
ZoomBA and Java have a common runtime platform. You can easily move from Java to ZoomBA
and vice versa.
.. ZoomBA can Execute any Java Code
ZoomBA enables you to use all the classes of the Java SDK’s in ZoomBA, and also your own,
custom Java classes, or your favourite Java open source projects. There are trivial ways to load a
jar from path directly from ZoomBA script, and then loading a class as as trivial as importing
the class.
.. ZoomBA can be used Functionally
ZoomBA is also a functional language in the sense that every function is a value and because
every value is an object so ultimately every function is an object. Functions are first class
citizens.
ZoomBA provides a lightweight syntax for defining anonymous functions, it supports
higher-order functions, it allows functions to be nested, and supports currying and Closures. It
also supports Operator Overloading.
.. ZoomBA is Dynamically Typed
ZoomBA, unlike statically typed languages, does not expect you to provide type information.
You don’t have to specify a type in most cases, and you certainly don’t have to repeat it.
. . s e t t i n g up environment
.. ZoomBA Vs Java
Most of the time one can treat ZoomBA as a very tiny shorthand for incredibly fast programming
using JVM. However, ZoomBA has a set of features, which completely differs from Java. Some
of these are:
. All types are objects. An assignment of the form x = 1 makes actually an Integer object
in JVM, not a int.
. Type inference : by that one does not need to cast a variable to a type before accessing
its functions. This makes reflective calls intuitive, as a.b.f () can be written as a[0 b0 ].f ()
and thus, the value of 0 b0 itself can come from another variable. Objects are treated like
property buckets, as in Dictionaries.
. Nested Functions : functions can be nested :
def parent_function( a ) {
def child_function (b) {
// child can use parents args: happily.
a + b
}
if ( a != null ) {
return child_function
}
}
. Functions are objects, as the above example aptly shows, they can be returned, and
assigned :
fp = parent_function(10)
r = fp(32 ) // result will be 42.
. Closures : the above example demonstrates the closure using partial functions, and this
is something that is syntactically new to Java land.
. s e t ting up environment
.. Installing Java Run Time
You need to install Java runtime . ( bit ) at minimum ( It supports all the way up to Java
) To test whether or not you have successfully installed it try this in your command prompt :
$ java -version
java version "1.8.0_60"
Java(TM) SE Runtime Environment (build 1.8.0_60-b27)
Java HotSpot(TM) 64-Bit Server VM (build 25.60-b23, mixed mode)
.. Download ZoomBA one jar
Download the latest one-jar.jar file from here.
.. Add to Path
If you are using nix platform, then you should create an alias :
alias zmb="java -jar ZoomBA.lang.core-0.1-onejar.jar"
chapter . about zoom ba
in your .login file.
If you are using Windows, then you should create a batch file that looks like this:
@echo off
rem init.cmd: to be run on every login
doskey zmb=java -jar ZoomBA.lang.core-0.1-onejar.jar $*
and then follow the steps as shown here.
.. Test Setup
Open a command prompt, and type :
$ZoomBA
//h brings this help.
//h key_word : shows help about the keyword
//q quits REPL. In debug mode runs till next BreakPoint
//v shows variables.
//c In debug mode, clear this Breakpoint.
//r loads and runs a script from REPL.
Enjoy ZoomBA...(0.1-2019-Sep-17 14:47)
(zoomba)
It should produce the prompt of REPL of (ZoomBA).
.. Maven Setup for Java Integration
In the dependency section (latest release is . ) :
<dependency>
<groupId>org.zoomba-lang</groupId>
<artifactId>zoomba.lang.core</artifactId>
<version>0.1</version> <!-- or 0.2-SNAPSHOT -->
</dependency>
That should immediately make your project a ZoomBA supported one.
.. Setting up Editors
IDEs are good - and that is why we have minimal editor support, Sublime Text is my favourite
one. You also have access to the syntax highlight file for zoomba and a specially made theme
for zoomba editing - ( ES ) both of them can be found : here. There is also a vim syntax file. If
you use them with your sublime text editor - then typical zoomba script file looks like this :
To include for vim :
Create these two files :
$HOME/.vim/ftdetect/zmb.vim
$HOME/.vim/syntax/zmb.vim
For most nix systems it would be same as :
mkdir -p ~/.vim/ftdetect/
touch ~/.vim/ftdetect/zmb.vim
touch ~/.vim/syntax/zmb.vim
Now on the $HOME/.vim/ftdetect/zmb.vim file, put this line :
autocmd BufRead,BufNewFile *.zmb,*.z, *.zm set filetype=zmb
Note that you should not have blanks between commas. And then, copy the content of the
vim syntax file here in the $HOME/.vim/syntax/zmb.vim file as is.
If everything is fine, you can now open zmb scripts in vim!
. . s e t t i n g up environment
Figure . – Using Sublime Text.
.. The Proverbial “Hello, World”
In any editor of your choice, save this line in a file ‘hello.zmb’ :
println(’Hello, World!’)
and go to the command prompt, and run :
$ zmb hello.zmb
Hello, World
$
and that would be the proverbial starting code.
chapter . about zoom ba
Figure . – Using Vim (MacVim).
chapter 2
Z o o m BA S y n tax in Minutes
With some understanding on any of C,C++, Java, Kotlin, Scala, Python or JavaScript then it
will be very easy for you to learn ZoomBA. The biggest syntactic difference between ZoomBA
and other languages is that the ’;’ statement end character is optional. When we consider a
ZoomBA program it can be defined as a collection of functions that communicate via taking
input from the previous and producing output which is to be taken as input to another, next in
line.
. b u i lding blocks
.. Identifiers & Reserved Keywords
ZoomBA is case-sensitive, which means identifier Hello and hello would have different meaning.
All ZoomBA components require names. Names used for objects, classes, variables and methods
are called identifiers. A keyword cannot be used as an identifier and identifiers are case-
sensitive.
. Fully Reserved : you can not use these identifiers as variables.
if, else, for, while, where, size, empty, def, isa , null, type
. Partially Reserved : you should not use these as variables.
atomic, xml, thread, system, lines, list, dict, type , println, read, send, random, hash ,
minmax, fold, index, rindex, int, float, INT, FOAT, bool, num, str.
. Specially Reserved : you should not use these as variables.
@,$, anything with ‘__’.
.. Assignments
Most basic syntax of ZoomBA is, like any other language : assignment.
chapter . zoomba syntax in minut e s
a = 1 // assigns local variable a to Integer 1
b = 1.0 //assigns local variable a to b float 1.0
c = ’Hello, ZoomBA’ // assigns local variable c to String ’Hello, ZoomBA’
d = "Hello, ZoomBA" // same, strings are either single or double quoted
/*
assigns the *then* value of a to e,
subsequent change in a wont reflect in e
*/
e = a
.. Comments
See from the previous subsection "//" used as line comments. Along with the multiline comment
"/*" with "*/" :
// this is line comment
/* this is multiline
comment, for large and long lines!
*/
.. Basic Types
Basic types are :
a = 1 // Integer
c = ’Hello, ZoomBA’ // String
d = 1.0 // Double
l = 1l // long integer
L = 1L // Large Integer
D = 1.0D // Large Floating
tt = true // boolean
tf = false // boolean
null_literal = null // special null type
.. Multiple Assignment
ZoomBA supports multiple assignment. It has various usage:
a = 1 // Integer
b = 1.0 // float
c = ’Hello, ZoomBA’ // String
// instead, do this straight :
#(a,b,c ) = [ 1 , 1.0 , ’Hello, ZoomBA’ ]
. . o p e r ators
. o p e rators
.. Arithmetic
a = 1 + 1 // addition : a <- 2
z = 1 - 1 // subtraction : z <- 0
m = 2 * 3 // multiply : m <- 6
d = 3.0 / 2.0 // divide d <- 1.5
x = 2 ** 10 // Exponentiation x <- 1024
y = -x // negation, y <- -1024
r = 3 % 2 // modulo, r <- 1
a += 1 // increment and assign
z -= 1 // decrement and assign
x *= 2 // multiply and assign
y /= 3 // divide and assign
a /? b // does a divide b?
2 /? 4 // true
5 /? 13 // false
.. Logical
o = true || true // true , or operator
a = true && false // false , and operator
defined_a = is(a) // true if a is defined, false otherwise
o = (10 != 20 ) // not, true
o = ! ( 10 = 20 ) // true
o = (10 == 20) // false
o = ( true ^ false ) // true : xor operator for boolean
o = ( true ^ true ) // false : xor operator for boolean
.. Comparison
t = 10 < 20 // true, less than
f = 10 > 20 // false, greater then
t = 10 <= 10 // true, less than or equal to
t = 10 >= 10 // true, greater then or equal to
t = ( 10 == 10 ) // true, equal to
f = ( 10 != 10 ) // false, not equal to
.. Ternary
// basic ternary
min = a < b ? a : b // general form (expression)?option1:option2
// try fixing null with it
non_null = a == null? b : a
// or use the null coalescing operator
non_null = a ?? b
// same can be used as definition coalescing
defined = is(a) ? a : b
//same as above
defined = a ?? b
chapter . zoomba syntax in minut e s
. c o n ditions
People coming from any other language would find them trivial.
.. If
x = 10
if ( x < 100 ){
x = x**2
}
println(x) // printlns back x to standard output : 100
.. Else
x = 1000
if ( x < 100 ){
x = x**2
}else{
x = x/10
}
println(x) // printlns back x to standard output : 100
.. Else If
x = 100
if ( x < 10 ){
x = x**2
} else if( x > 80 ){
x = x/10
} else {
x = x/100
}
println(x) // printlns back x to standard output : 10
. l o o ps
.. While
i = 0
while ( i < 42 ){
println(i)
i += 1
}
.. For
For can iterate over any iterable, in short, it can iterate over string, any collection of objects, a
list, a dictionary or a range. That is the first type of for :
. . f u n c t i ons
for ( i : [0:42] ){ // [a:b] is a range type
println(i)
}
The result is the same as the while loop. A standard way, from C/C++/Java is to println the
same as in :
for ( i = 0 ; i < 42 ; i+= 1 ){ // assignment, condition, after
println(i)
}
There is support for implicit variable for a loop. This variable is called $ :
for ( [0:42] ){ // [a:b] is a range type
println($)
}
Just like in Python, we also have a tuple passed as parameter, first one being the index,
second one being the object in question for the iteration:
for ( idx, obj : [10:13] ){ // [a:b] is a range type
printf("Index is %d and Object is %d %n", idx, obj )
}
Similar way, we have implicit for index, and object :
for ( [10:13] ){ // [a:b] is a range type
printf("Index is %d and Object is %d %n", _$, $ )
}
Scoping rules are simple. foreach is effectively a closed function call. Thus if the iterator
variables references are there outside scope, they gets replaced inside, it is hidden. Once outside
the for loop, they can be accessed again.
. f u n ctions
.. Defining
Functions are defined using the def keyword. And they can be assigned to variables, if one may
wish to.
def count_to_num(n){
for ( i : [0:n] ){
println(i)
}
}
// just assign it
fp = count_to_num
One can obviously return a value from function :
def say_something(word){
return ( "Hello " + word )
}
chapter . zoomba syntax in minut e s
But it is overkill. The last executed statement of a function is the return value, thus :
def say_something(word){
( "Hello " + word ) // returns it
}
.. Function Calling
Calling a function is trivial :
// calls the function with parameter
count_to_num(42)
// calls the function at the variable with parameter
fp(42)
// calls and assigns the return value
greeting = say_something("Homo Erectus!" )
.. Global Variables
As you would be knowing that the functions create their local scope, so if you want to use
variables - they must be defined in global scope. Every external variable is readonly to the local
scope, but to println to it, use global variables, which starts with $.
$a = 0
x = 0
def use_var(){
$a = 42
println(a) // prints 42
println(x) // prints 0, can access global
x = 42
println(x) // prints 42
}
// call the method
use_var()
println($a) // global a, prints 42
println(x) // local x, prints 0 still
The result would be :
42
0
42
42
0
. a n onymous function as a function parameter
A basic idea about what it is can be found here. As most of the Utility functions use a specific
type of anonymous function, which is nick-named as "Anonymous Parameter" to a utility
function.
.. Why it is needed?
Consider a simple problem of creating a list from an existing one, by modifying individual
elements in some way. This comes under map , but the idea can be shared much simply:
. . a n o n y mous function as a function parameter
l = list()
for ( x : [0:n] ){
l.add ( x * x )
}
return l // yep, here...
Observe that the block inside the *for loop* takes minimal two parameters, in case we println it
like this :
// return is not really required, last executed line is return
def map(x){ x * x }
l = list()
for ( x : [0:n] ){
l.add ( map(x) )
}
return l // more general
Observe now that we can now create another function, lets call it list_from_list :
def map(x){ x * x }
def list_from_list(fp, old_list)
l = list()
for ( x : old_list ){
// use the function *reference* which was passed
l.add( fp(x) )
}
return l // great...
}
list_from_list(map,[0:n]) // same as previous 2 implementations
The same can be achieved in a much sorter way, with this :
list([0:n]) as { $.item * $.item }
// if you like short-symbols
list([0:n]) -> { $.o * $.o }
The curious block construct after the list function arguments is called anonymous (function)
parameter, which takes over the map function. The loop stays implicit, and the result is
equivalent from the other examples.
This reads as follows : create a list from arguments using the block as ...
The explanation is as follows. For an anonymous function parameter, there are implicit
guaranteed arguments :
. $ –> signifies the iteration object. This has the fields :
. $.o, $.item –> Signifies the item of the collection , we call it the IT EM
. $.c, $.context –> The context, or the collection itself , we call it the CON T EXT
. $.i, $.index –> The index of the item in the collection, we call it the ID of iteration
. Another case to case parameter is : $.p, $.partial –> Signifies the partial result of the
processing , we call it P ART IAL
The ideas can be simply put into examples by taking this particular case :
l = list([1:5]) as {
printf(’item : %s , index : %s , partial %s\n’, $.o,$.i,$.p)
$.o*$.o }
which produces this :
chapter . zoomba syntax in minut e s
item : 1 , index : 0 , partial []
item : 2 , index : 1 , partial [1]
item : 3 , index : 2 , partial [1, 4]
item : 4 , index : 3 , partial [1, 4, 9]
Observe that partial is the partial result of the iteration, which would finally yield to the
final result.
.. Some Use Cases
The data structure section would showcase some use cases. But we would use a utility function
to showcase the use of this anonymous function. Suppose there is this function minmax() which
takes a collection and returns the (min,max) tuple. In short :
#(min,max) = minmax(1,10,-1,2,4,11)
println(min) // prints -1
println(max) // prints 11
But now, suppose we want to find the minimum and maximum by length of a list of strings. To
do so, there has to be a way to pass the comparison done by length. That is easy :
#(min,max) = minmax( "" , "aa" , "abc" , "aa", "bbbbb" ) as {
size($.0) < size($.1) }
println(min) // prints empty string
println(max) // prints bbbbb
. ava ilable data structures
.. Range
A range is basically an iterable, with start and end separated by colon : [a : b]. We already have
seen this in action. "a" is inclusive while "b" is exclusive, this was designed the standard for loop
in mind. There can also be an optional spacing parameter "s", thus the range type in general is
[a : b : s], as described below:
/*
when r = [a:b:s]
the equivalent for loop is :
for ( i = a ; i < b ; i+= s ){
... body now ...
}
*/
r1 = [0:10] // a range from 0 to 9 with default spacing 1
//a range from 1 to 9 with spacing 2
r2 = [1:10:2] //1,3,5,7,9
.. List
To solve the problem of adding and deleting item from an array, list were invented.
fll = [0,1,2,3,4] // fixed length list (not an array, but a list)
fll += 50 // will do nothing, no modification, no error.
l = list ( 0,1,2,3 ) // a list
l += 10 // now the list is : 0,1,2,3,10
. . ava i l a ble data structures
l -= 0 // now the list is : 1,2,3,10
x = l[0] // x is 1 now
l[1] = 100 // now the list is : 1,100,3,10
.. Set
A set is a collection of elements such that the elements do not repeat. Thus :
// now the set is : 0,1,2,3
s = set ( 0,1,2,3,1,2,3 ) // a set
s += 5 // now the set is : 0,1,2,3,5
s -= 0 // now the set is : 1,2,3
... Ordered Set
In Set, elements are not present by their insertion order. To fix that problem, oset() exists :
os = oset(12,1,2,3, 10) // if we now print
println( os ) // you would find them in the same order...
It is a wrapper over LinkedHashSet.
... Sorted Set
In Set, elements are not sorted by their values. To fix that problem, sset() exists :
ss = sset(12,1,2,3, 10) // if we now print
println( ss ) // you would find them in { 1,2,3,10,12 }
It is a wrapper over TreeSet.
.. Dict
A dictionary is a collection ( a list of ) (key,value) pairs. The keys are unique, they are the
keySet(). Here is how one defines a dict:
d1 = { ’a’ : 1 , ’b’ : 2 } // a dictionary
d2 = dict( [’a’,’b’] , [1,2] ) // same dictionary
x = d1[’a’] // x is 1
x = d1.a // x is 1
d1.a = 10 // now d1[’a’] --> 10
... Ordered Map
In Map, tuples are not present by their insertion order. To fix that problem, odict() exists :
od = odict() //
od[100] = 1
od[2] = 2
od[199] = 42
println( od ) // you would find them in the same order...
It is a wrapper over LinkedHashMap.
chapter . zoomba syntax in minut e s
... Sorted Dict
In Set, elements are not sorted by their keys. To fix that problem, sdict() exists :
sd = sdict()
sd[100] = 1
sd[10] = 2
sd[-10] = 42
println( sd ) // you would find them in in sorted key order
It is a wrapper over TreeMap.
.. Multi Set
Many a times, it is necessary to group sets out of a collection. For example, consider the problem
of how many unique integers are there in a collection, along with their frequencies. To solve
this, ZoomBA has mset() :
l = [ 1,3,4,3,2,1,1,5]
ms = mset(l)
{1=3, 2=1, 3=2, 4=1, 5=1} // MultiSet
What it is depicting is, key has occurred times, occurred once, etc etc This seats in
somewhere between set and a collection, a frequency bucket. mset() and it’s close cousin group()
has other usage, which we will discuss later when we discuss comprehensions on collections.
.. Mutability
Data structures are not generally mutable in ZoomBA. What does that mean?
x = [1,2,3]
x + 10 // add some
println(x) // @[1,2,3] : x did not change
Thus, a variables value never gets changed, unless someone assigns back something to it. The
only way a variable state can get change is through assignment. This is known as Immutability.
See more of a discussion here.
The mutable additive operators : “+=” and “-=” are the ones which do not follow it, because
they are also assignment operators. If the object is part of collection types, they would modify
the left hand object itself, instead of creating a new instance of the object. Thus :
a = [1,2,3]
a + 10 // creates a new array object
s = set(1,2,3)
s+= 42 // simply : s.add(42)
s-= 1 // s.remove(1)
s += [2,3,4] // s.addAll( list(2,3,4) )
s-= [3,4] // s.removeAll( list(3,4) )
m = {1:2, 3:4}
m += {5:6} // m.putAll( {5:6} )
m -= 3 // m.remove(3)
chapter 3
Fo r m a l Co n s tructs
Formalism is the last thing that stays in a software developers mind nowadays. This is a result
of mismanaging expectation of how software and coding is taught and practiced in industry.
The majority view in the Industry is :
Software is a form of art, and is not science at all.
It is easy to showcase that this is the prevailing feeling. When the last time people actually did
any mathematics to reach any conclusion like - what would be the optimal object hierarchy
size if any? What should be the optimal pool size for an application? How one can optimally
transform the data?
Most of these cases, a bit of formal thinking solves a lot of the problems that can come due
to bad design, if there was a design in the first place (for most parts, there are none). That
is, because software is nothing but formally applied computer science, and industry lacks
computer science. What can be done by can also be done by people, and no, they do not
have to be really really smart, they only have to be understanding the underlying structure. In
reality software is :
Software is to Applied Computation is what Architecture is to applied sciences, i.e. Engineering.
Unless you have an idea of the underlying mechanism, most won’t work, and those who would
luckily work - would simply fail in a slightly longer timeframe. Moreover, user does not care
about brilliant design and optimal code, user care about getting his/her problem solved, fast. It
is business who should care about how to do things optimally and repeatedly, otherwise, the
business model won’t sustain.
This section would be specifically to understand what sort of formalism from computation
we can use in practice to develop and test software to aid business. Because in the end, profit
and revenue runs the show.
. c o n ditional building blocks
.. Formalism
In a formal logic like FOPL, the statements can be made from the basic ingredients, “there exist”
and “for all”. We need to of course put some logical stuff like AN D, OR, and some arithmetic
here and there, but that is what it is.
chapter . formal construc t s
If we have noted down the sorting problem in chapter , we would have restated the problem
as :
There does not exist an element which is less than that of the previous one.
In mathematical logic, “there exists” becomes : ∃ and “for all” becomes ∀. and logical not is
shown as ¬ , So, the same formulation goes in : let
S = {0, 1, 2, ..., size(a) − 1} = {x ∈ N|x < size(a)}
then :
i ∈ S; ∀ i¬ (∃ a[i] s.t. a[i] < a[i − 1])
And the precise formulation of what is a sorted array/list is done in the second order logic.
The problem of programming and validation generally is expressive in terms of higher order
logic.
.. Relation between “there exists” and “for all”
There is a nice dual relationship between there exists ∃ and ∀. Given we have the negation
operation defined, ∀ and ∃ are interchangeable. Suppose we ask :
Are every element in the collection C greater than ?
∀x ∈ C ; x > 0 ?
This can be reformulated as the negation of:
Does there exist any element in the collection C less than or equal to ?
∃x ∈ C ; x ≤ 0 ?
Hence, the transformation law is :
∀x ∈ C ; P (x) ? ⇐⇒ ¬(∃x ∈ C ; ¬P (x) )?
.. There Exist In Containers
To check, if some element is, in some sense exists inside a container ( list, set, dict, array, heap )
one needs to use the IN operator, which is @.
. . c o n d i t ional building blocks
l = [1,2,3,4] // l is an array
in = 1 @ l // in is true
in = 10 @ l // in is false
d = { ’a’ : 10 , ’b’ : 20 }
in = ’a’ @ d // in is true
in = ’c’ @ d // in is false
in = 10 @ d // in is false
in = 10 @ d.values() // in is true
/* division over a dictionary gives the keyset
where the value of the key is the operand */
in = size( d / 10 ) > 0 // in is true
s = "hello"
in = "o" @ s // in is true
/* This works for linear collections even */
m = [2,3]
in = m @ l // true
in = l @ l // true
// the not in operator is defined as such
10 !@ l // true : not in
1 !@ l // false : not in
This was not simply put in the place simply because we simply dislike x.contains(y). In fact
we do dislike the form of object orientation where there is no guarantee that x would be null or
not. Worse, it is impossible to test for null always, such is the prevailing nature of the bad code
in Industry. Formally, then :
// equivalent function
def in_function(x,y){
!empty(x) && x.contains(y)
}
// or one can use simply
y @ x // same result
How about regular expressions? There are two operators related to regular expressions, the
match operator, and then not match operator. See the guide to regular expressions.
re = "^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$"
s = "hello"
match = ( s =~ re ) // false
match = ( s !~ re ) // true
f = "12.3456"
match = ( f =~ re ) // true
match = ( f !~ re ) // false
Thus, the operator “=~” is the match operator, while “!~” is the not match operator.
Regex can be specified verbatim:
me = ’cool!’
me =~ ##^c.*$# // true
me =~ ##c.*# // false
me =~ ##co#g // global match, true
me =~ ##Co#ig // ignore case, global match, true
The right side of the operator, the # operand returns a pattern. It is obvious that the ‘g’ is
for global, ‘i’ is for ignore case. ‘m’ is used for being multiline.
Moreover, to substitute pattern, that is replace with a variable, start with a question mark.
chapter . formal construc t s
me = ’cool!’
p = ’Co’
me =~ ##p#ig // false, p is verbatim
me =~ ##? p#ig // true, p is executed as script first, then substituted
.. Size of Containers : empty, size, cardinality
To check whether a container is empty or not, use the empty() function, just mentioned above.
Hence:
n = null
e = empty(n) // true
n = []
e = empty(n) // true
n = list()
e = empty(n) // true
d = { : }
e = empty(d) // true
nn = [ null ]
e = empty(nn) // false
For the actual size of it, there are two alternatives. One is the size() function :
n = null
e = size(n) // -1
n = []
e = size(n) // 0
n = list()
e = size(n) // 0
d = { : }
e = size(d) // 0
nn = [ null ]
e = size(nn) // 1
Observe that it returns negative given input null. That is a very nice way of checking null.
The other one is the cardinal operator :
n = null
e = #|n| // 0
n = []
e = #|n| // 0
n = list()
e = #|n| // 0
d = { : }
e = #|d| // 0
nn = [ null ]
e = #|nn| // 1
This operator in some sense gives a measure. It can not be negative, so cardinality of null is
also .
. . c o n d i t ional building blocks
.. There Exist element with Condition : index, rindex , exists
Given we have if “y in container x” or not, what if when asked a question like : “is there a x
in Collection C such that predicate P(x) is true” ? Formally, then, given a predicate P (x), and a
collection C, we ask :
∃x ∈ C s.t. P (x) = T rue
This pose a delicate problem.
Notice this is the same problem we asked about sorting. Is there an element ‘x’ in C, such
that the sorting order is violated? If not, the collection is sorted. This brings back the index
function . We are already familiar with the usage of index() function from chapter . But we
would showcase some usage :
l = [ 1, 2, 3, 4, 5, 6 ]
// search an element such that double of it is 6
i = index(l) where { $.o * 2 == 6 } // i : 2
// search an element such that it is between 3 and 5
i = index(l) where { $.o < 5 && $.o > 3 } // i : 3
// search an element such that it is greater than 42
i = index(l) where { $.o > 42 }// i : -1, failed
The way index function operates is: the statements inside the anonymous block are executed.
If the result of the execution is true, the index function returns the index in the collection. If
for none of the elements the anonymous block assumes the true value, it returns a failure by
returning −1.
NOTE that in the ZoomBA negative indices are proper indices into a collection. Thus, a
code like this is tantamount to be a disaster waiting to happen:
l = [ 1, 2, 3, 4, 5, 6 ]
// search an element
i = index(l) where { $.o > 42 } // i : -1
// now we have found the element, so :
x = l[i] // no, x is 6. we must check the index value for >=0
This brings to the problem of actually finding the element, which is solved using find()
function.
l = [ 1, 2, 3, 4, 5, 6 ]
// search an element
mc = find(l) where { $.o > 3 } // result is MonadicContainer
// now we have found the element, so :
r = mc.nil ? mc.value : null // r is 4
Index function runs from left to right, and there is a variation rindex() which runs from
right to left.
l = [ 1, 2, 3, 4, 5, 6 ]
// search an element such that it is greater than 3
i = index(l) :: { $.o > 3 } // i : 3, :: is the where clause
// search an element such that it is greater than 3
i = rindex(l) :: { $.o > 3 } // i : 5
// search an element such that it is greater than 42
i = rindex(l) :: { $.o > 42 } // i : -1, failed
Thus, the there exists formalism is taken care by these operators and functions together.
The function exists() to ensure simpler usage on collections where index is kind of mean-
ingless.
chapter . formal construc t s
l = [ 1, 2, 3, 4, 5, 6 ]
// search an element such that it is greater than 3
// reads there exists item in collection where clause
exists(l) where { $.o > 3 } // true
.. For All elements with Condition : select
We need to solve the problem of for all. This is done by select() function . The way select
function works is : executes the anonymous statement block, and if the condition is true, then
select and collect that particular element, and returns a list of collected elements.
l = [ 1, 2, 3, 4, 5, 6 ]
// select all even elements
evens = select(l) where { $.o % 2 == 0 }
// for math folks
evens = select(l) :: { 2 /? $.o } // reads : where 2 divides the number
// select all odd elements
odds = select (l) :: { $.o % 2 == 1 }
.. Partition a collection on Condition : partition
Given a select(), we are effectively partitioning the collection into two halves, select() selects
the matching partition. In case we want both the partitions, then we can use the partition()
function .
l = [ 1, 2, 3, 4, 5, 6 ]
#(evens,odds) = partition(l) :: { $.o % 2 == 0 }
println(evens) // prints 2, 4, 6
println(odds) // prints 1, 3, 5
.. Collecting value on Condition : select, from
Given a select() or partition(), we are collecting the values already in the collection. What about
we want to change the values we are collecting, or what about the container we want to collect
into?
These scenarios can be translated into:
collector = collection()
def condition(item){/* some predicate */}
def map(item){/* some mapping */}
// now the loop
for ( item : collection ){
if ( condition(item) ){
collector.add( map(item ) )
}
}
// use collector
Or, one can use the standard:
. . o p e r ators from set algebra
l = [ 1, 2, 3, 4, 5, 6 ]
evens = select(l) where { $.o % 2 == 0 } as { $.o ** 2 }
println(evens) // prints 4, 16, 36
where is the condition function, while as is the mapper function. You can pass the collector
collection also:
select([0:5],set()) where { 2 /? $.o }
this, of course will collect the items in a set. While select() only supports two levels of composi-
tion, one predicate and one mapper, from() supports full functional composition:
from([0:11],set()) where { 3 /? $.o } as { $.o % 3 }
.. Inversion of Logic
As we have discussed there is a relation between ∃ and ∀, we can use them for practical
applications. We would be using them everywhere, and as Kurt Lewin said :
There is nothing so practical as a good theory.
So, we would start with all these examples in inverted logic. Observe that select() mandates a
guaranteed runtime of Θ(n), while index() has a probabilistic runtime of Θ(n/2). So, we should
generally choose index() over select(). For example, take the problem of are all numbers in a list
larger than , it can be solve in two ways:
l = [10,2,3,10, 2, 0 , 9 ]
// forall method 1
size(l) == size ( select(l) :: { $.o > 0 } )
// forall method 2 : note the inversion of logic
empty ( select(l) :: { $.o <= 0 } )
// there exists method : note the inversion of condition from 1
!exists(l) :: { $.o <= 0 }
Please choose the rd one, that makes sense, takes less memory, and is optimal.
. o p e rators from set algebra
.. Set Algebra
Set algebra , in essence runs with the notions of the following ideas :
. There is an unique empty set.
. The following operations are defined :
a. Set Union is defined as :
UAB = A ∪ B := {x ∈ A or x ∈ B} := UBA
chapter . formal construc t s
b. Set Intersection is defined as :
IAB = A ∩ B := {x ∈ A and x ∈ B} := IBA
c. Set Minus is defined as :
MAB := A \ B := {x ∈ A and x < B}
thus, MAB , MBA .
d. Set Symmetric Difference is defined as :
∆AB := (A \ B) ∪ (B \ A) := ∆BA
e. Set Cross Product is defined as :
XAB = {(a, b) | a ∈ A and b ∈ B}
thus, XAB , XBA
. The following relations are defined:
a. Subset Equals :
A ⊆ B when x ∈ A =⇒ x ∈ B
b. Equals :
A = B when A ⊆ B and B ⊆ A
c. Proper Subset :
A ⊂ B when A ⊆ B and ∃x ∈ B s.t. x < A
d. Superset Equals:
A ⊇ B when B ⊆ A
e. Superset :
A ⊃ B when B ⊂ A
.. Set Operations on Collections
For the sets, the operations are trivial.
s1 = set(1,2,3,4)
s2 = set(3,4,5,6)
u = s1 | s2 // union is or : u = { 1,2,3,4,5,6}
i = s1 & s2 // intersection is and : i = { 3,4 }
m12 = s1 - s2 // m12 ={1,2}
m21 = s2 - s1 // m12 ={5,6}
delta = s1 ^ s2 // delta = { 1,2,5,6}
For the lists or arrays, where there can be multiple elements present, this means a newer
formal operation. Suppose in both the lists, an element ‘e’ is present, in n and m times. So,
when we calculate the following :
. Intersection : the count of e would be min(n, m).
. Union : the count of e would be max(n, m).
. . o p e r ators from set algebra
. Minus : the count of e would be max(0, n − m).
With this, we go on for lists:
l1 = list(1,2,3,3,4,4)
l2 = list(3,4,5,6)
u = l1 | l2 // union is or : u = { 1,2,3,3,4,4,5,6}
i = l1 & l2 // intersection is and : i = { 3,4 }
m12 = l1 - l2 // m12 ={1,2,3,4}
m21 = l2 - l1 // m12 ={5,6}
delta = l1 ^ l2 // delta = { 1,2,3,4,5,6}
Now, for dictionaries, the definition is same as lists, because there the dictionary can be
treated as a list of key-value pairs. So, for one pair to be equal to another, both the key and the
value must match. Thus:
d1 = {’a’ : 10, ’b’ : 20 , ’c’ : 30 }
d2 = {’c’ : 20 , ’d’ : 40 }
// union is or : u = { ’a’ : 10, ’b’ : 20, ’c’ : [ 30,20] , ’d’ : 40 }
u = d1 | d2
i = d1 & d2 // intersection is and : i = { : }
m12 = d1 - d2 // m12 = d1
m21 = d2 - d1 // m12 = d2
delta = d1 ^ d2 // delta = {’a’ : 10, ’b’ : 20, ’d’: 40}
.. Collection Cross Product and Power
The cross product, as defined, with the multiply operator:
l1 = [1,2,3]
l2 = [’a’,’b’ ]
cp = l1 * l2
/* [[1, a], [1, b], [2, a], [2, b], [3, a], [3, b]] := cp */
Obviously we can think of power operation or exponentiation on a collection itself. That
would be easy (we use ‘:=‘ to say defined as ) :
A0 := {} , A1 := A , A2 := A × A
and thus :
An := An−1 × A
For general collection power can not be negative. Here are some examples now:
b = [0,1]
gate_2 = b*b // [ [0,0],[0,1],[1,0],[1,1] ]
another_gate_2 = b ** 2 // same as b*b
gate_3 = b ** 3 // well, all truth values for 3 input gate
gate_4 = b ** 4 // all truth values for 4 input gate
b ** 0 // [] : power zero is empty collection
String is also a collection, and all of these are applicable for string too. But it is a special
collection, so only power operation is allowed.
chapter . formal construc t s
s = "Hello"
s2 = s**2 // "HelloHello"
s_1 = s**-1 // "olleH"
s_2 = s**-2 // "olleHolleH"
One interesting case is that of negative power, which simply reverses a collection, if such
thing is possible :
b = [0,1]
rb = b** -1 // [1 , 0 ]
s = "hello"
rs = s**-1 // "olleh"
A negative power is a valid power, thus:
b = [0,1]
rb = b** -2 // [[1, 0], [1, 1], [0, 0], [0, 1]]
s = "hello"
rs = s**-2 // "olleholleh"
these are simply not there, in the examples section we will see how they ease out some
interesting algorithms. A very practical use case of power operator for string is padding by
zeros for a binary integer of a fixed size:
n = 23
bn = str(n,2) // convert into binary string
padded_8 = "0" ** (8 - #|bn| ) + bn // 00010111 : convert to 8 bit
.. Collection Relation Comparisons
The operators are defined as such:
. A ⊂ B is defined as A < B
. A ⊆ B is defined as A <= B
. A ⊃ B is defined as A > B
. A ⊇ B is defined as A >= B
. A = B is defined as A == B
Note that when collections can not be compared at all, it would return false to showcase
that the relation fails.
So, we go again with sets:
s1 = set(1,2,3)
s2 = set(1,3)
sub = s2 < s1 // true
sup = s1 > s2 // true
sube = ( s2 <= s1 ) // true
supe = (s1 >= s2) // true
s3 = set(5,6)
s1 < s3 // false
s3 > s1 // false
s1 != s3 // true
So, we go again with lists:
. . o p e r ators from set algebra
l1 = list(1,2,3,3,4)
l2 = list(1,3,2)
sub = l2 < l1 // true
sup = l1 > l2 // true
sube = ( l2 <= l1 ) // true
supe = (l1 >= l2) // true
l3 = list(5,6)
l1 < l3 // false
l3 > l1 // false
l1 != l3 // true
And finally with dictionaries:
d1 = {’a’ : 10, ’b’ : 20 , ’c’ : 30 }
d2 = {’c’ : 30 , ’a’ : 10 }
sub = ( d2 < d1) // true
sup = ( d1 > d2) // true
.. Mixing Collections
One can choose to intermingle set with list, that promotes the set to list. Thus :
s = set(1,2,3)
l = list(1,3,3,2)
sub = s < l // true
sup = l > s // true
s == l // false : promotes both to list and checks
u = l | s // u = [1,2,3,3 ]
.. Collections as Tuples
When we say [1, 2] < [1, 2, 3, 4] we obviously mean as collection itself. But what about we start
thinking as tuples? Does a tuple contains in another tuple? That is we can find the items in
order? "@" operator solves that too :
l = [1,2]
m = [ [1,2],3,4]
in = l @ m // true
The index(), and rindex() generates the index of where the match occurred:
l = [1,2]
m = [1,2,3,4,1,2]
// read which : index is l in m?
forward = index( l , m) // 0
backward = rindex( l , m) // 4
Sometimes it is of importance to get the notion of starts_with and ends_with. There are two
special operators :
chapter . formal construc t s
// read m starts_with l
sw = m #^ l // true
// read m ends with l
ew = m #$ l // true
Note that this is also true for strings, as they are collections of characters. So, these are legal:
s = ’abracadabra’
prefix = ’abra’
suffix = prefix
i = index ( prefix, s ) // 0
r = rindex( suffix, s ) // 7
sw = s #^ prefix // true
ew = s #$ suffix // true
These are not fancy stuffs. These are necessary to move over from the stupidity that is
known as null based programming where lots of efforts gets nullified by the stupidity of null.
Observe, the same null thing:
s = ’abracadabra’
prefix = ’abra’
null #^ s // false
prefix #^ null // false
[null,null] #^ null // true
and thus, we can see where it does the value add. Python fails in this case, because none of
it’s syntaxes permits None type to be used as collection to yield True/False for in or matches.
There is this other operator called InOrder : #@ which tells whether a sub collection exists
in order, as tuple in the larger collection when the larger collection is considered as tuple:
l = [0,1,2,3,4]
[1,2] #@ l // true
[2] #@ l // true
[2,1] #@ l // false
as usual, they are all null ready. The in : @ operator is different from in order, because clearly :
l = [0,1,2,3,4]
[2,1] #@ l // false
[2,1] @ l // true
Thus, in order is precisely what it is, if the items from the passed collection occurs as sub
tuples ( can be build by projection operations ) of the parent collection. Formally, let’s end this
with a bit of formalism as we have started it.
Define a projection operation Πi,j (C) with i ≤ j which slice the collection C from index i to
index j, or rather a sub() function. The following are defined as such :
. In Order :
x #@ C iff ∃(i, j) such that Πi,j (C) = x.
. Starts With :
C #ˆ x iff ∃j such that Π0,j (C) = x.
. Ends With :
C #$ x iff ∃i such that Πi,|C|−1 (C) = x, where |C| is the cardinality of collection C.
. . a s s e rt ions
. a s s ertions
It of utmost important that we do protective coding. What does that mean? That means, for any
function, verify the inputs, and decides, what needs to be done. For the same purpose, there
are some very specific functions which are in place.
.. Existence of Variables
There are one specific function which is in place: is() .
is( x ) // false, x does not exist in Context
x = 10
is( x ) // true, x exists
is( null ) // true, x exists and is null
del x // removes the variable name ’x’
is(x) // false, x does not exist any more
A related operator is ?? which is read as :
val = try_expression ?? default_expression
d = { ’a’ : 11 }
val = d.y ?? 42 // val is 42
val = d.a ?? 42 // val is 11
If try_expression fails or is null, then assign val to default, else val is try expression.
.. Verifying Truth about Expressions
Sometimes, most of the time, we need to check if some expression is true or false. Most of the
time, that might lead you do to throw exceptions or errors. ZoomBA handles it in a neat way.
There are in built constructs one can try upon assert(), panic(), test(). Here are examples of
the same:
x = 42
// expression true, so error will not be thrown
assert( x == 42, ’Why x is not 42?’ )
// expression false, so error will not be thrown
panic( x != 42, ’Why x is not 42?’ )
// expression false, so error will BE thrown
assert( x != 42, ’Why x is not 42?’ )
// expression true, so error will BE thrown
panic( x == 42, ’Why x is not 42?’ )
// true, so nothing will happen
test(x == 42, ’I am good’ )
// false, so would log it to standard error
test(x != 42, ’I am not good’ )
All of these functions are arbitrary valued arguments, with one mandatory argument, the
expression which evaluates to true, false. Rest all are processed in, and passed to the runtime, if
the assertion fails. Thus, all passed extra arguments can be used by runtime, thereby extending
the functionality if it is intended to be.
There are guard blocks around each of them. One example is :
assert( ’"x" does not exist’ ) where { x }
chapter . formal construc t s
What is the difference from the original form? If we use the basic expression form, then, we
do get a variable error that ’x’ does not exist. Which is entirely a different problem. The where
clause is called a guard block, there, expression can be safely executed, to produce true,false.
Obviously, for assert() and test() the clause must return false to fire error, and for panic() it is to
be true.
chapter 4
Co l l e c t i o n s And Comprehension
Comprehension is a method which lets one create newer collection from older ones. In this
chapter we would see how different collections can be made from existing collections.
. u s i ng anonymous argument
.. List
The general form for list and arrays can be written ( as from chapter ):
def map(item) {/* does some magic */}
def comprehension(function, items){
c = collection()
for ( item : items ){
c_m = function(c)
c.add( c_m )
}
return c
}
// finally :
comprehension(map, items)
//or this way :
c = collection( items ) as { map($.o) }
Obviously list() generates list and list.array() generates array. Any collection structure can be
used as a collector : list, set, oset, sset, dict, sdict, odict, mset . Hence, these are valid :
ln = list(1,2,3,4) as { $.o ** 2 } // [1,4,9,16 ]
So, the result of the anonymous block is taken as a function to map the item into a newer
item, and finally added to the final collection.
One can use standard function also in case of anonymous function :
def square( inx, itm, partial, context ){
itm ** 2
}
ln = list(1,2,3,4) as square // same !
ln = list(1,2,3,4) as def(inx,itm) { itm ** 2 } // same!
chapter . collections and comprehensio n
.. Set
Set also follows the same behavioural pattern just like list(), but one needs to remember that
the set collection does not allow duplicates. Thus:
s = set( 1,2,3,4,5 ) as { $.o % 3 } // [0,1,2]
Basically, the map function for the set construct, defines the key for the item. Thus, unlike
its cousins list() and array(), the set() function may return a collection with size less than the
input collection.
.. Dict
Dictionaries are special kind of a collection with (key, value) pair with unique keys. Thus,
creating a dictionary would mean uniquely specifying the key, value pair. That can be specified
either in a dictionary tuple way, or simply a pair way:
// range can be passed in for collection
d = dict([0:4]) as { t = { $.o : $.o **2 } }
/* d = {0 : 0, 1 : 1, 2 : 4, 3:9 } */
d = dict([0:4]) as { [ $.o , $.o **2 ] } // same as previous
There is another way of creating a dictionary, that is, passing two collections of same size,
and making first collection as keys, mapping it to the corresponding second collection as values:
k = [’a’,’b’,’c’ ]
v = [1,2,3]
d = dict(k,v)
/* d = { ’a’ : 1 , ’b’ : 2, ’c’ : 3 } */
This is formally the operation called pairing:
D : (K, V ) → T ; ti = (ki , vi ) ; ki ∈ K ; vi ∈ V
.. Multi Set
We got introduced to mset() sometimes back. One can think it is as a frequency counter for
elements of a collection. But that is not what it does. mset() can also group items under a key,
as demonstrated :
l = [0:10].list() // generate a list from this range
ms = mset( l ) as { 2 /? $.o } // group them under "even" and "odd"
// {false=[1, 3, 5, 7, 9], true=[0, 2, 4, 6, 8]} // HashMap
In essence, what it did is to ‘group’ the collections under multiple groups, all items in the same
group must have same key.
A related problem is to run another function with the collection of each group. This is done
by the group() function. For examples:
. . c o n s t ructs altering the iteration flow
l = [0:10].list() // generate a list from this range
// group them under "even" and "odd",
//and then count the list of items in each group,
// making it the value under the key
g = group( l ) as { 2 /? $.o } as { size($.value) }
// results in : {false=5, true=5} // HashMap
.. Stack And Queue
Collection list() can be used as both Stack and the Queue. For example :
// use as queue
q = list()
for ( x : [0:10] ) { q.enqeue(x) } // enqueue
q.dequeue() // we get back 0
// use as stack
s = list()
for ( x : [0:10] ) { s.push(x) } // push to stak
s.pop() // we get back 10
.. JVM Arrays
Collection collection.array(type) can be used to create arrays: For example :
x = [0,1,2,3]
//@[ 0,1,2,3 ] // ZArray
x.array(’int’)
//0,1,2,3 // int[]
//x.array(’double’)
//0.0,1.0,2.0,3.0 // double[]
x.array(’float’)
//0.0,1.0,2.0,3.0 // float[]
x.array(’long’)
//0,1,2,3 // long[]
x = [true, false]
//@[ true,false ] // ZArray
x.array(’bool’)
//true,false // boolean[]
. c o n structs altering the iteration flow
In normal iterative languages, there are continue and break. The ideas are borrowed from them,
and improved to give a declarative feel onto it.
.. Continue and Break
The idea of continue would be as follows :
for ( i : items ){
if ( condition(i) ){
// execute some code
continue
}
// do something else
}
chapter . collections and comprehensio n
That is, when the condition is true, execute the code block, and then continue without going
down further ( not going to do something else ). The idea of the break is :
for ( i : items ){
if ( condition(i) ){
/* execute some code */
break
}
// do something else here
}
That is, when the condition is true, execute the code block, and then break without proceed-
ing with the loop further. Evidently they change the flow of control of the iterations.
.. Continue
As we can see, the condition() is implicit in both break and continue, in ZoomBA this has
become explicit. Observe that:
for ( i : items ){
continue( condition(i) ){ /* continue after executing this */}
// do something else
}
is equivalent of what was being shown in the previous subsection. As a practical example, lets
have some fun with the problem of FizzBuzz, that is, given a list of integers, if n is divisible by
3 print Fizz, if something is divisible by 5, print Buzz, and for anything else print the number
n. A solution is :
for ( n : integers ){ // note that "x /? y" implies x divides y ?
continue( n /? 15 ){ println(’FizzBuzz’) }
continue( n /? 3 ){ println(’Fizz’) }
continue( n /? 5 ){ println(’Buzz’) }
println(n)
}
Obviously, the block of the continue is optional. Thus, one can freely code the way it was
mentioned in the earlier subsection.
.. Break
As mentioned in the previous subsection, break also has the same features as continue.
for ( i : items ){
break( condition(i) ){ /* break loop after executing this */}
// do something else
}
is equivalent of what was being shown in the previous subsection. As a practical example, lets
find if two elements of two lists when added together generates a given value or not. Formally :
∃(a, b) ∈ A × B ; s.t. a + b = c
. . c o n s t ructs altering the iteration flow
A = [ 1, 4, 10, 3, 8 ]
B = [ 2, 11, 6 , 9 ]
c = 10
for ( p : A*B ){
break( p[0] + p[1] == c ){ printf( ’%d %d\n’ , p[0] , p[1] ) }
}
Obviously, the block of the break is optional.
.. Substitute for Select
One can readily use the break and continue in larger scheme of comprehensions. Observe this :
l_e1 = select([0:10]) :: { $.o % 2 == 0 }
l_e2 = list([0:10]) -> { continue($.o % 2 != 0) ; $.o }
Both are the same list. Thus, a theoretical conversion rule is :
ls = select(collection) where { <condition> }
lc = list(collection) as { continue( ! ( <condition> ) ) ; $.o }
now, the ls == lc, by definition. More precisely, for a generic select with where clause:
ls = select(collection) where { <condition body> }
lc = list(collection) as { continue( !(<condition>) ) ; <body> }
Obviously, the list function can be replaced with any collection type : set, dict.
Similarly, break can be used to simplify conditions :
l_e1 = select([0:10]) :: { $.o % 2 == 0 && $.o < 5 }
l_e2 = list([0:10]) -> { break( $.o > 5 ) ;
continue($.o % 2 != 0) ; $.o }
Note that Break body is inclusive:
l = list([0:10]) as { break( $.o > 3 ) ; $.o }
/* l = [ 0, 1,2,3 ] */
l = list([0:10]) as { break( $.o > 3 ) { $.o } ; $.o }
/* l = [ 0, 1,2,3, 4] */
So, with a body, the boundary value is included into break.
.. Uses of Partial
One can use the PARTIAL for using one one function to substitute another, albeit loosing
efficiency. Below, we use list to create effectively a set:
l = list( 1,1,2,3,1,3,4 ) as { continue( $.o @ $.p ) ; $.o }
/* l = [ 1,2,3, 4] */
But it gets used properly in more interesting of cases. What about finding the prime numbers
using the Sieve of Eratosthenes? We all know the drill imperatively:
chapter . collections and comprehensio n
def is_prime( n ){
primes = set(2,3,5)
for ( x : [6:n+1] ){
x_is_prime = true
for ( p : primes ) {
break( x % p == 0 ){ x_is_prime = false }
}
if ( x_is_prime ){
if ( x == n ) return true
primes += x
}
}
return false
}
Now, a declarative style coding :
def is_prime( n ){
primes = list( [2:n+1] ) as {
// store the current number
me = $.o
// check : *me* is not prime - using partial set of primes
not_prime_me = exists( $.p ) where { me % $.o == 0 }
// if not a prime, continue
continue( not_prime_me )
me // collect me, if I am prime
}
// simply check if n is last of the primes
( n == primes[-1] )
}
Observe that, if we remove the comments, it is a one liner. It really is. Hence, declarative style
is indeed succinct, and very powerful. The one reason why we need to create the me variable is
due to the implicit parameter $. The implicit loop variable also as a field $ which access the
parent’s loop parameter. Thus, the same code can be written in a line :
n == (select([2:n+1]) where{ exists($.p) where{ $.o /? $.$.o } })[-1]
. c o mprehensions using multiple collections : join
In the previous sections we talked about the comprehensions using a single collection. But we
know that there is this most general purpose comprehension, that is, using multiple collections.
This section we introduce the join() function.
.. Formalism
Suppose we have multiple sets S1 , S2 , ...Sn . Now, we want to generate this collection of tuples
e =< e1 , e2 , ..., en > ∈ S1 × S2 × ... × Sn
such that the condition ( predicate ) P (e) = true. This is what join really means. Formally, then :
J(P , e) := {e ∈ S1 × S2 × ... × Sn | P (e)}
. . c o m p r ehensions using multiple collections : join
.. As Nested Loops
Observe this, to generate a cross product of collection A, B, we must go for nested loops like
this:
for ( a : A ){
for ( b : B ) {
printf ( ’(%s,%s)’, a,b )
}
}
This is generalised for a cross product of A, B, C, and generally into any cross product. Hence,
the idea behind generating a tuple is nested loop.
Thus, the join() operation with condition() predicate with a mapper() essentially is :
collect = collection()
for ( a : A ){
for ( b : B ) {
tuple = [a,b]
if ( condition ( tuple ) ) { collect += map(tuple) }
}
}
.. Join Function
Observe that the free join, that is a join without any predicate, or rather join with predicate
defaults to true is really a full cross product, and is available using the power operator :
A = [’a’,’b’]
B = [ 0, 1 ]
j1 = A * B // [ [a,0] , [a,1] ,[b,0], [b,1] ]
j2 = join( A , B ) // [ [a,0] , [a,1] ,[b,0], [b,1] ]
But the power of join() comes from the predicate expression one can pass in the anonymous
block. Observe now, if we need permutations of a list of : 3 P2 :
A = [’a’,’b’, ’c’ ]
// generate 2 permutations, when $.o is collection
// one can access the items by index like this
p2 = join( A , A ) where { $.0 != $.1 }
.. Permutations
In the last subsection we figured out how to find permutation. The problem is when we move
beyond , the condition can not be aptly specified as $.0 , $.1. It has to move beyond. So, for
3 P we have :
3
A = [’a’,’b’, ’c’ ]
// generate 3 permutations
p2 = join( A , A, A ) where { #|set($.o)| == #|$.o| }
which is the declarative form for permutation, given all elements are unique. This can be
simply created by the pre-defined perm() function :
chapter . collections and comprehensio n
A = [’a’,’b’, ’c’ ]
// generate 3 permutations
p2 = perm( A, 2 ) // From collection A, generate 2 permutations
// @[ a,b ],@[ b,a ],@[ a,c ],@[ c,a ],@[ b,c ],@[ c,b ] //
CombinatoricsIterable
// hence,
perm(collection, number) // generates an iterable
.. Combinations
What about combinations then? Difference between permutation and combination is, in
combination, order does not matter, hence (1, 2) is same combination as (2, 1), while they are
two distinct permutations.
A = [’a’, ’b’, ’c’ ]
c2 = join( A, A ) where {
c = sorta( list($.o) )
c !@ $.p && #|set(c)| == #|c|
}
which is the declarative form for combination, given all elements are unique. This can be
simply created by the pre-defined comb() function :
A = [’a’,’b’, ’c’ ]
// generate 3 combinations
c2 = comb( A, 2 ) // From collection A, generate 2 combinations
@[ a,b ],@[ a,c ],@[ b,c ] // CombinatoricsIterable
comb(collection, number) // generates an iterable
.. Searching for a Tuple
In the last section we were searching for a tuple t from two collections A, B, such that c = t.0+t.1.
We did that using power and break, now we can do slightly better:
A = [ 1, 4, 10, 3, 8 ]
B = [ 2, 11, 6 , 9 ]
c = 10
v = join(A,B) :: { break( $.0 + $.1 == c) }
/* v := [[1,9]] */
which is the declarative form of the problem.
.. All Possible Sub Collections
Suppose, given a collection C, we want to find out all possible sub collection inside that
collection. This tantamount to what is known as Power Set or 2C . One way to solve this problem
is to imagine that each sub collection from the original collection is created by a bitmap with
means select that index, and means do not select the index. If the |C| = n, then clearly 2n of
those sub collections possible. This can be coded as in:
def all_sub_collection( col ){
power_col = list()
n = size(col)
. . c o m p r ehensions using multiple collections : join
for ( b : [0 : 2 ** n ] ){
bit_map = str(b,2) // binary rep of integer b
bit_map = ’0’ ** ( n - size( bit_map) ) + bit_map
sub_col = list()
for ( i : [0:n] ){
if ( bit_map[i] == _’1’ ){
sub_col += col[i]
}
}
power_col.add( sub_col )
}
println( power_col )
}
This is too much of non declarative hodge-podge. This can be simply coded in as :
a =[0, 1, 2]
// generates all possible combination sequences possible using collection
sequences(a)
.. Projection on Collections
Sometimes it is needed to create a sub-collection from the collection. This, is known as
projection ( choosing specific columns of a row vector ).
While project works on a range (from,to), the generic idea can be expanded. What if we
want to create a newer collection from a collection using a range type? We can :
a =[0, 1, 2, 3, 4]
a[0:2] // @[0, 1, 2]
Now, given a set of indices, one can define a generic project operation, but that is very easy
to do using collection comprehensions :
a = [0, 1, 2, 3, 4]
indices = [0,2]
p_a = list(indices) as { continue( $.i != $.o ) ; a[$.o] }
This simply selects those indices in order from the collection a. In fact, defining project() or
tuple() is easy :
a = [0, 1, 2, 3, 4]
indices = [from_index,to_index]
p_a = select(a) where { $.i >= indices.0 && $.i < indices.1 ) }
chapter 5
Ty p e s a n d Co nversions
Types are not much useful for general purpose programming, save that they avoid errors.
Sometimes they are necessary, and some types are indeed useful because they let us do many
useful stuff. In this chapter we shall talk about these types and how to convert one to another.
The general form for type casting can be written :
val = type_function(value, optional_default_value = null )
How does this work? The system would try to cast value into the specific type. If it failed,
and there is no default value, it would return null. However, if default is passed, it would
return that when conversion fails. This neat design saves a tonnage of try ... catch stuff.
. i n t eger family
This section is dedicated to the natural numbers family. We have :
. bool : Boolean
. int : Integer family, automatic size.
. INT : LargeInteger
Every type is under the hood is an object in ZoomBA, there is really no primitive here.
.. Boolean
The syntax is :
val = bool(value, optional_default_value = null )
val = bool(value, optional_matching_values[2])
Observe both in action :
val = bool("hello") // val is null
val = bool("hello",false) // val is false
val = bool(’hi’, [’hi’ , ’bye’ ] ) // val is true
val = bool(’bye’, [’hi’ , ’bye’ ] ) // val is false
chapter . types and conversio n s
.. Integer
This is very useful and the syntax is :
val = int(value, optional_default_value = null )
Usage is :
val = int("hello") // val is null
val = int("hello",0) // val is 0
val = int(’42’) // val is 42
val = int(42) // val is 42
val = int ( 10.1 ) // val is 10
val = int ( 10.9 ) // val is 10
val = int(’100’,2, null ) // val is 4, ( string, base, default )
.. Arbitrary Large Integer
This is sometimes required, and the syntax is :
val = INT(value, base=10, default_value = null )
Usage is :
val = INT("hello") // val is null
val = INT(’hi’,10,42 )// base 10, default 42, val is 42
val = INT(’42’) // val is 42
val = INT(54,13 ) // val is 42
. r at ional numbers family
This section is dedicated to the floating point numbers family. We have :
. float : minimal container for floating point.
. FLOAT : Real
.. Float
The syntax is :
val = float(value, optional_default_value = null )
Usage is :
val = float("hello") // val is null
val = float("hello",0) // val is 0.0
val = float(’42’) // val is 42.0
val = float(42) // val is 42.0
val = float ( 10.1 ) // val is 10.1
val = float ( 10.9 ) // val is 10.9
Note that, ZoomBA will automatically shrink floating point data into double, given it can fit the
precision in :
. . g e n e r ic numeric functions
val = 0.01 // val is a double type, automatic
.. FLOAT
This is sometimes required, and the syntax is :
val = FLOAT(value,default_value = null )
Usage is :
val = FLOAT("hello") // val is null
val = FLOAT(’hi’, 42 )// val is 42.0
val = FLOAT(’42’) // val is 42.0
val = FLOAT(42.00001 ) // val is 42.00001
. g e n eric numeric functions
.. num()
For generic numeric conversions, there is num() function, whose job is to convert data types
into proper numeric type, with least storage. Thus :
val = num(value,default_value)
Usage is :
val = num("hello") // val is null
val = num(’hi’, 42 )// val is 42 int
val = num(’42.00’) // val is 42 int
val = num(42.00001 ) // val is 42.00001 double
val = num(42.000014201014 ) // val is double
// val is Real
val = num(42.00001420101410801980981092101 )
.. size()
size() function finds out digits length for an integer, in a given base:
x = 100
size(x) // 100 in ’unary’ base : imagine 100s of 1’s written
size(x,2) // 7, base 2
size(x,10) // 3 , base 10
size(x,16) // 2 , base 16
chapter . types and conversio n s
.. Float to Integers
To convert floating points to integers or pure rationals there are functions : floor(), ceil(),
round() as shown below:
// floor of f: max( all integers less than of equal to f )
x = floor(1.1) // x = 1
x = floor(0.0) // x = 0
x = floor(-1.5) // x = -2
// ceil of f: min ( all integers greater than or equal to f )
y = ceil(1.1) // x = 2
y = ceil(-1.1) // x = -1
y = ceil(-1.0) // x = -1
// now round function, with number of digit after decimal precision
round(0.5) // 0 digits, produces 1
round(0.51239,3) // 0.512
round(0.51239,4) // 0.5124
These functions takes care of the sign of the number also, and adjusted.
.. Signs and Absolute
Sign function for any number is defined as :
def _sign_(x ){
if ( x < 0 ) return -1
if ( x > 0 ) return 1
0 // else return 0
}
// or we can use :
sign(x) // same as _sign_ function
Absolute of a number is given by either the size() or the operator #|x| to be read as mod-x.
x = -100
#|x| // 100, absolute value of x
size(x) // 100, same
#|null| // 0, mod of nothing is 0
size(null) // -1, shows that the container is un-initialized
.. log()
log() function takes logarithm of a number in Napier’s base, by default, or if base is provided,
on that base:
x = 100
log(x) // 4.6051701859880918 Real
log(10) // 2.0 Double
. t h e chrono family
Handling date and time has been a problem, that too with timezones. ZoomBA simplifies the
stuff. We have Java DateTime to handle date/time:
. . t h e c h rono family
.. time()
This is how you create a DateTime LocalDateTime:
val = time([ value, date_format , time_zone] )
With no arguments, it gives the current date time:
today = time()
The default date format is yyyyMMdd, so :
dt = time(’20160218’) // 2016-02-18T00:00:00.000+05:30
For all the date formats on dates which are supported, see DateTimeFormat.
Take for example :
dt = time(’2016/02/18’, ’yyyy/MM/dd’ )
// dt := 2016-02-18T00:00:00.000+05:30
dt = time(’2016-02-18’, ’yyyy-MM-dd’ )
// dt := 2016-02-18T00:00:00.000+05:30
.. Adjusting Timezones
The at() function of the ZDate object handles the timezones properly. If you want to convert
one time to another timezone, you need to give the time, and the timezone:
dt = time()
dt_honolulu = dt.at( ’Pacific/Honolulu’ )
// dt_honolulu := 2016-02-17T17:23:02.754-10:00
dt_ny = dt.at( ’America/New_York’ )
// dt_ny := 2016-02-17T22:23:02.754-05:00
There is a date() function to convert into a Date object in older Java, as well as timezone:
t = time()
dt = t.date() // convert into Date
dt_honolulu = t.date( ’Pacific/Honolulu’ ) // timezone and covert
.. Comparison on Chronos
All these date time types are freely mixable, and all comparison operations are defined with
them. Thus :
t1 = time()
thread().sleep(1000) // wait for some time
t2 = time()
// now compare
c = ( t1 < t2 ) // true
c = ( t2 > t1 ) // true
chapter . types and conversio n s
Tow dates can be equal to one another, but not two instances, that is a very low probability
event, almost never. Thus, equality makes sense when we know it is date, and not instant :
t1 = time(’19470815’) // Indian Day of Independence
t2 = time(’19470815’) // Indian Day of Independence
// now compare
c = ( t1 == t2 ) // true
.. Arithmetic on Chronos
Dates, obviously can not be multiplied or divided. That would be a sin. However, dates can be
added with other reasonable values, dates can be subtracted from one another, and time() can
be added or subtracted by days, months or even year. More of what all date time supports, see
the manual of LocalDateTime.
To add time to a date, there is another nifty method :
d = time(’19470815’) // Indian Day of Independence
time_delta_in_millis = 24 * 60 * 60 * 1000 // next day
nd = time( d.time + time_delta_in_millis )
// nd := Sat Aug 16 00:00:00 IST 1947
Same can easily be achieved by the Durations string :
d = time(’19470815’) // Indian Day of Independence
nd = d + ’P1D’ // 1947-08-16T00:00:00.000+05:30
And times can be subtracted :
d = time(’19470815’) // Indian Day of Independence
nd = d + ’P1D’ // 1947-08-16T00:00:00.000+05:30
diff = nd - d
//diff := PT24H ## Duration between two dates!
diff.toMillis // long number of millisecs
So we can see it generates Duration gap between two chrono instances.
. s t r ing : using str
Everything is just a string. It is. Thus every object should be able to be converted to and from
out of strings. There are types of strings in ZoomBA:
.. Types of Strings
There are types of strings:
general_string = "I am a string"
exec_string = #"2 + 3" // produces string 5
sub_string = #"variable substitution with #{exec_string}"
// append scripts folder path to the string
relocable_string = _/"some_path/some/other/path"
char = _"I" // character literal
. . s t r i n g : using str
Converting an object to a string representation is called Serialization, and converting a
string back to the object format is called DeSerialization. This is generally done in ZoomBA by
the function str().
.. Null
str() never returns null, by design. Thus:
s = str(null)
s == ’null’ // true
.. Integer
For general integers family, str() acts normally. However, it takes overload in case of IN T () or
BigInteger :
bi = INT(42)
s = str(bi) // ’42’
s = str(bi,2) // base 2 representation : 101010
.. Floating Point
For general floating point family, str() acts normally. However, it takes overload, which is
defined as :
precise_string = str( float_value, num_of_digits_after_decimal )
To illustrate the point:
d = 101.091891011
str( d, 0 ) // 101
str(d,1) // 101.1
str(d,2) // 101.09
str(d,3) // 101.092
.. Chrono
Given a chrono family instance, str() can convert them to a format of your choice. These formats
have been already discussed earlier, here they are again: SimpleDateFormat.
The syntax is :
formatted_chrono = str( chrono_value , chrono_format )
Now, some examples :
t = time()
str( t ) // default is ’yyyyMMdd’ : 20160218
str( t , ’dd - MM - yyyy’ ) // 18 - 02 - 2016
str( t , ’dd-MMM-yyyy’ ) // 18-Feb-2016
chapter . types and conversio n s
.. Collections
Collections are formatted by str by default using ‘,’. The idea is same for all of the collections,
thus we would simply showcase some:
l = [1,2,3,4]
s = str(l) // ’1,2,3,4’
s == ’1,2,3,4’ // true
s = str(l,’#’) // ’1#2#3#4’
s == ’1#2#3#4’ // true
So, in essence, for str(), serialising the collection, the syntax is :
s = str( collection [ , seperation_string ] )
.. Generalised toString()
This brings to the point that we can linearise a collection of collections using str(). Observe
how:
l = [1,2,3,4]
m = [ ’a’ , ’b’ , ’c’ ]
j = l * m // now this is a list of lists, really
s_form = str(j, ’&’) as { str($.o,’#’) } // lineraize
// This generates 1#a&1#b&1#c&2#a&2#b&2#c&3#a&3#b&3#c&4#a&4#b&4#c
.. JSON
Given we have a complex object comprise of primitive types and collection types, the jstr()
function returns a JSON representation of the complex object. This way, it is very easy to
inter-operate with JavaScript type of languages.
d = { ’a’ : 10 , ’b’ : 20 }
s = jstr(d) // as json string
/* { "a" : 10 , "b" : 20 } */
// pretty print json string using ZoomBA native capability
jstr(d,false)
jstr(d,true) // pretty print, using Jsoner capability
.. Yaml
Given we have a complex object comprise of primitive types and collection types, the ystr()
function returns a Yaml representation of the complex object.
d = { ’a’ : 10 , ’b’ : 20 }
s = ystr(d) // as Yaml string
/* Yaml String ...
a: 10
b: 20
*/
. . p l ay i n g with types : reflection
. p l aying with types : reflection
It is essential for a dynamic language to dynamically inspect types, if at all. Doing so, is termed
as reflection. In this section, we would discuss different constructs that lets one move along the
types.
.. type() function
The function type() gets the type of an object. In essence it gets the getClass() of any POJO.
Notice that the class object is loaded only once under a class loader, so equality can be done by
simply “==”. Thus, the following constructs are of importance:
d = { : }
c1 = type(d) // c1 := java.util.HashMap
i = 42
c2 = type(i) // c2 := java.lang.Integer
c3 = type(20) // c3 := java.lang.Integer
c3 == c2 // true
c1 == c2 // false
.. The === Operator
From the earlier section, suppose someone wants to equal something with another thing, under
the condition that both the objects are of the same type. Under the tenet of ZoomBA which
reads : “find a type at runtime, kill the type” , we are pretty open into the type business :
a = [1,2,3]
ca = type(a) // ZArray
b = list(1,3,2)
cb = type(b) // ZList type
a == b // true
ca == cb // false
// type equals would be :
ca == cb && a == b // false
But that is a long haul. One should be succinct, so there is this borrowed operator from
JavaScript, known as “===” which let’s its job in a single go :
a = [1,2,3]
b = list(1,3,2)
a === b // false
c = [3,1,2]
c === a // true
.. The isa operator
Arguably, finding a type and matching a type is a tough job. Given that we need to care about
who got derived from whatsoever. That is an issue a language should take care of, and for that
reason, we do have isa operator.
null isa null // true
a = [1,2,3]
a isa [] // true : a is a type of ZArray?
chapter . types and conversio n s
a isa [0] // true : a is a type of ZArray?
b = list(1,3,2)
b isa ’list’ // true : b is a type of list ?
a isa b // false
{:} isa ’map’
true isa ’bool’
1 isa ’int’
1.0 isa ’float’
"abc".toCharArray() isa ’array’
This also showcase the issues of completely overhauling the type structure found in a JVM. The
first two lines are significantly quirky.
There is a distinctly better way of handling isa, by using patternmatcher strings, strings
that starts with ## and has a type information as expression match: e.g. ##map#ig :
b = list(1,3,2)
b isa ##list#ig // true : b is a type of list ?
{:} isa ##map#ig // true
4.2 isa ##double##ig // the double
s = set(1,2,3)
s isa ##set#ig // true
t = time()
t is a ##date#ig // true : for ZDate
This regex also is case insensitive, and matches from anywhere, so be careful.
.. Field Access
Once we have found the fields to access upon, there should be some way to get to the field,
other than this :
d = time()
d.date().fastTime // some value
There is obvious way to access properties as if the object is a dictionary, or rather than a
property bucket:
d = time().date()
d[’fastTime’] == d.fastTime // true
This opens up countless possibilities of all what one can do with this. Observe however,
monsters like spring and hibernate is not required given the property injection is this simple.
.. Nested Field Access
For a simple field like this, it is good. But what happens when we need to access to nested
properties? For example, take this :
m = { "a" : { "b" : 10 }, "c" : { "b" : 20 } }
Of course, it can actually be a proper java object ( we are simply using JSON map ). How to
access upto the level ‘m.a.b’ ? Or rather, how to get back the list of all nested fields "b" ? This is
the precise reason ZoomBA has xpath() and xelem() functions.
One can actually parameterize the access "m.a.b" using the xpath() function:
. . p l ay i n g with types : reflection
m = { "a" : { "b" : 10 }, "c" : { "b" : 20 } }
// from "m" get me the path b, followed by a property
v = xpath(m, "/a/b" ) // v := 10
v = xpath(m, "/a/x" ) // v := null
What about there are multiple matches? This is done by optional third argument sending a
boolean ‘true’ :
// from "m" get me the path b, followed by a property, as list, true
v = xpath(m, "//b", true ) // v := [10, 20]
But this pose a little problem of the setting property side of the things. Moreover, the power
to traverse the object tree wanes off with only values. For this, there is the xelem() function:
// from "m" get me the path b, followed by a property, as list, true
p = xelem(m, "/a/x" ) // p := /.[@name=’a’][@name=’x’] //
DynamicPropertyPointer
Now we can readily set any value pointed by ‘p’:
p.value = 42
// now if we print m :
println(m) // prints {"a" : {"b" : 10, "x" : 42}, "c" : {"b" : 20} }
xelem() also takes another optional parameter to get back a list of pointers:
// from "m" get me the path b, followed by a property, as list, true
pa = xelem(m, "//b", true )
// pa := [ /.[@name=’a’][@name=’b’],/.[@name=’c’][@name=’b’] ]
And now we can go about merry ways of getting and setting values in them.
chapter 6
R e u s i n g Co d e
The tenet of ZoomBA is : “write once, forget”. That essentially means that the code written has
to be sufficiently robust. It also means that, we need to rely upon code written by other people.
How does this work? The system must be able to reuse any code from Java SDK, and should
be able to use any code that we ourselves wrote. This chapter would be elaborating on this.
. t h e import directive
.. Syntax
Most of the languages choose to use a non linear, tree oriented import. ZoomBA focuses on
minimising pain, so the import directive is linear. The syntax is simple enough :
import ’import_path’ as unique_import_identifer
The directive imports the stuff specified in the import_path and create an alias for it, which
is :
unique_import_identifer, Thus, there is no name collision at all in the imported script. This
unique_import_identifer is known as the namespace.
.. Examples
Observe, if you want to import the class java.lang.Integer :
import ’java.lang.Integer’ as Int // works, string literal
import java.lang.Integer as Int // works, standard form
x = ’java.lang.Integer’ // well, programmatic access
import x as Int // works, again. Try avoiding it, please.
This directive would import the class, and create an alias which is Int. To use this class
further, now, we should be using :
Int.parseInt(’20’) // int : 20
Int.valueOf(’20’) // int : 20
chapter . reusing cod e
In the same way, one can import an ZoomBA script :
// w/o any extension it would find the script automatically
import ’from/some/folder/awesome’ as KungFuPanda
// call a function in the script
KungFuPanda.showAwesomeness()
. u s i ng existing java classes
.. Load Jar and Create Instance
The example of outer class, or rather a proper class has been furnished already. So, we would
try to import a class which is not there in the CLASS_P AT H at all.
// put all dependencies of xmlbeans.jar in there
success = load(’path/to/xmlbeans_jar_folder’) // true/false
import ’org.apache.xmlbeans.GDate’ as AGDate
Once we have this class now, we can choose to instantiate it, See the manual of this class
here:
//create the class instance : use new()
gd1 = new ( AGDate, date() )
// 2016-02-18T21:13:19+05:30
// or even this works
gd2 = new ( ’org.apache.xmlbeans.GDate’ , date() )
// 2016-02-18T21:13:19+05:30
And thus, we just created a Java class instance. This is how we call Java objects, in general
from ZoomBA.
Calling methods now is easy:
cal = gd1.getCalendar() // calls a method
/* 2016-02-18T21:13:19+05:30 */
Note that thanks to the way ZoomBA works, a method of the form getXyz is equivalent to a
field call xyz so :
cal = gd1.calendar // calls the method but like a field!
/* 2016-02-18T21:13:19+05:30 */
.. Import Enum
Enums can be imported just like classes. However, to use one, one should use the enum()
function:
// creates a wrapper for the enum
rms = enum(’java.math.RoundingMode’)
rms.0 // UP
rms.UP // UP
. . u s i n g zoomba scripts
The same thing can be achieved by :
// gets the value for the enum
v = enum(’java.math.RoundingMode’,
’UP’ )
v = enum(’java.math.RoundingMode’, 0 )
.. Import Static Field
Import lets you import static fields too. For example :
// put all dependencies of xmlbeans.jar in there
import ’java.lang.System.out’ as OUT
// now call println
OUT.println("Hello,World") // prints it!
However, another way of achieving the same is :
// put all dependencies of xmlbeans.jar in there
import ’java.lang.System’ as SYS
// now call println
SYS.out.println("Hello,World") // prints it!
// something like reflection
SYS[’out’].println("Hello,World") // prints it!
.. Import Inner Class or Enum
Inner classes can be accessed with the "$" separator. For example, observe from the SDK code
of HashMap, that there is this inner static class EntrySet. So to import that:
// note that $ symbol for the inner class
import ’java.util.HashMap$EntrySet’ as ES
. u s i ng zoomba scripts
We have already discussed how to import an ZoomBA script, so in this section we would discuss
how to create a re-usable script.
.. Creating a Script
We start with a basic script, let’s call it hello.zm :
/* hello.zm */
def say_hello(arg){
println(’Hello, ’ + str(arg) )
}
s = "Some one"
say_hello(s)
/* end of script */
This script is ready to be re-used.
chapter . reusing cod e
.. Relative Path
Suppose now we need to use this script, from another script, which shares the same folder as
the “hello.zm”. Let’s call this script caller.zm. So, to import “hello.zm” in caller.zm we can do
the following :
import ’./hello’ as Hello
but, the issue is when the runtime loads it, the relative path would with respect to the
runtimes run directory. So, relative path, relative to the caller would become a mess. To solve
this problem, relative import is invented.
import _/’hello’ as Hello
Hello.say_hello(’Awesome!" )
In this scenario, the runtime notices the “_/”, and starts looking from the directory the
caller.zm was loaded! Thus, without any P AT H hacks, the ZoomBA system works perfectly
fine.
.. Calling Functions
Functions can be called by using the namespace identifier, the syntax is :
import ’some/path/file’ as NS
NS.function(args,... )
If one needs to call the whole script, as a function, that is also possible, and that is done
using the execute() function:
import ’some/path/file’ as NS
NS.execute(args,... )
We will get back passing arguments to a function in a later chapter. But in short, to call hello.zm,
as a function, the code would be :
import _/’hello’ as Hello
Hello.execute()
// or if you like succinct stuff
Hello()// yep, good to go...
Just as python has the implicit variable __name__ ==0 __main__0 to identify if a script is
running as ‘main’ script or not, ZoomBA has the implicit variable @SCRIP T . This stores the
current script. Thus :
@SCRIPT.main // true if it is main script, false it is not
@SCRIPT.location // location of the currently running script
Thus, say we have two files ‘a.zm’ and ‘b.zm‘ as follows:
// a.zm
import ’b’ as B
B.say_something("hello!") // this is how you call a function
. . u s i n g zoomba scripts
// b.zm
def say_something(arg){
println("I am from B!" + arg )
}
// body will be executed only when the script is main
if ( @SCRIPT.main ){
say_something(@ARGS)
}
Note the omission of ‘.zm’ while importing.
When we run this code, we see : ‘I am from B!hello!’ This is how we call functions from
other imported modules.
Point to be noted that the body of the imported script gets executed while importing, thus,
any stray method calls not protected by the ‘@SCRIPT.main’ functionality will be executed. For
example, if we have the ‘b.zm’ to be modified by :
// b.zm
println("I am being called - from B!")
def say_something(arg){
println("I am from B!" + arg )
}
// body will be executed only when the script is main
if ( @SCRIPT.main ){
say_something(@ARGS)
}
Now, if we run the ‘a.zm’ file we see the line "I am being called - from B!". This has very
interesting implications. It means all executable blocks will be executed, and all variables
which are associated with the imported scripts block, will be initialised and accessible from the
importing module. For all practical purpose, an imported module acts same as an object :
// a.zm
import ’b’ as B
println( B.TI ) // this is how you access free variables defined on imported
module
// b.zm
TI = time() // time of import ?
if ( @SCRIPT.main ){
println("From B : " + TI)
}
Naturally, we can extend an module import with initialisation of arguments, which will not
be trivial, and hence, there is no need to invent Objects over imported modules.
chapter 7
Fu n c t i o n a l Style
Functional style is a misnomer, in essence it boils down to some tenets:
. Functions as first class citizens, they can be used as variables.
. Avoid modifying objects by calling methods on them. Only method calls returning
create objects.
. Avoid conditional statements, replace them with alternatives.
. Avoid explicit iteration, replace them with recursion or other higher order functions.
. f u n ctions : in depth
As the functional style is attributed to functions, in this section we would discuss functions in
depth.
.. Function Types
ZoomBA has types of functions.
. Explicit Functions : This functions are defined using the def keywords. They are the
normal sort of functions, which everyone is aware of. As an example take this :
def my_function( a, b ){ a + b }
. Anonymous Functions : This functions are defined as a side-kick to another function,
other languages generally calls them Lambda functions, but they do very specific task,
specific to the host function. All the collection comprehension functions takes them :
l = list([0:10] ) as { $.o ** 2}
// same with a name-less function ( against anonymous )
l = list([0:10]) as def(_index, _item,_partial,_context) { _item** 2 }
// note that , all arguments are optional, so :
l = list([0:10]) as def() { item = @ARGS[1] ; item **2 } // works too
. Implicit Functions : This functions are not even functions, they are the whole script
body, to be treated as functions. Importing a script and calling it as a function qualifies
as one :
chapter . functional sty l e
import ’foo’ as FOO
FOO()
.. Default Parameters
Every defined function in ZoomBA is capable of taking default values for the parameters. For
example :
// default values passed
def my_function( a = 40 , b = 2 ){ a + b }
// call with no parameters :
println ( my_function() ) // prints 42
println ( my_function(10) ) // prints 12
println ( my_function(1,2) ) // prints 3
Note that, one can not mix the default and non default arbitrarily. That is, all the default
arguments must be specified from the right side. Thus, it is legal :
// one of the default values passed
def my_function( a, b = 2 ){ a + b }
But it is not :
// default values passed in the wrong order
def my_function( a = 10 , b ){ a + b }
.. Named Arguments
In ZoomBA, one can change the order of the parameters passed, provided one uses the named
arguments. See the example:
def my_function( a , b ){ printf(’(a,b) = (%s ,%s)\n’ ,a , b ) }
my_function(1,2) // prints (a,b) = (1,2)
my_function(b=11,a=10) // prints (a,b) = (10,11)
Note that, named args can not be mixed with unnamed args, that is, it is illegal to call the
method this way :
// only one named values passed
my_function(b=11,10) // illegal
.. Arbitrary Number of Arguments
Every ZoomBA function can take arbitrary no of arguments. To access the arguments, one must
use the @ARGS construct, as shown :
. . f u n c t i ons : in depth
// this can take any no. of arguments
def my_function(){
// access the arguments, they are collection
s = str ( @ARGS , ’#’ )
println(s)
}
my_function(1,2,3,4)
/* prints 1#2#3#4 */
This means that, when a function expects n parameters, but is only provided with m < n
parameters, the rest of the expected parameters not passed is passed as null.
// this can take any no. of arguments, but named are 3
def my_function(a,b,c){
// access the arguments, they are collection
s = str ( @ARGS , ’#’ )
println(s)
}
my_function(1,2)
/* prints 1#2#null */
In the same way when a function expects n parameters, but is provided with m > n parame-
ters, the rest of the passed parameters can be accessed by the @ARGS construct which was the
first example.
.. Arguments Overwriting
How to generate permutations from a list of object with n Pr ? Given a list l of size 3 We did 3 P3 :
l = [’a’,’b’,’c’ ]
perm_3_from_3 = join(l,l,l) where { #|set($.o)| == #|$.o| }
l = [’a’,’b’,’c’ ,’d’ ]
perm_4_from_4 = join(l,l,l,l) where { #|set($.o)| == #|$.o| }
perm_2_from_4 = join(l,l) where { #|set($.o)| == #|$.o| }
Thus, how to generate the general permutation? As we can see, the arguments to the
permutation is always varying. To fix this problem, argument overwriting was invented. That, in
general, all the arguments to a function can be taken in runtime from a collection.
l = [’a’,’b’,’c’ ,’d’ ]
// this call overprintlns the args :
perm_2_from_4 = join( @ARGS = [l,l] ) where{ #|set($.o)| == #|$.o| }
Thus, to collect and permutate r elements from a list l is :
perm_r = join(@ARGS = list([0:r]) as {l}) where{ #|set($.o)| == #|$.o| }
and we are done. This is as declarative as one can get.
chapter . functional sty l e
.. Recursion
It is customary to introduce recursion with factorial. We would not do that, we would introduce
the concept delving the very heart of the foundation of mathematics, by introducing Peano
Axioms. Thus, we take the most trivial of them all : Addition is a function that maps two
natural numbers (two elements of N) to another one. It is defined recursively as:
/* successor function */
def s( n ){
if ( n == 0 ) return 1
return ( s(n-1) + 1 )
}
/* addition function */
def add(a,b){
if ( b == 0 ) return a
return s ( add(a,b-1) )
}
These functions do not only show the trivial addition in a non trivial manner, it also shows
that the natural number system is recursive. Thus, a system is recursive if and only if it is in -
correspondence with the natural number system. Observe that the function add() does not even
have any addition symbol anywhere! This is obviously cheating, because one can not use minus
operator to define plus operation. A better less cheating solution is to use function composition
and power operator : a + b := s(...s(s(a))) b times, that is sb (a), which we would discuss later.
Now we test the functions:
println(s(0)) // prints 1
println(s(1)) // prints 2
println(s(5)) // prints 6
println(add(1,0)) // prints 1
println(add(1,5)) // prints 6
println(s(5,1)) // prints 6
Now, obviously we can do factorial :
def fact(n){
if ( n <= 0 ) return 1
return n * fact( n - 1 )
}
.. Closure
A closure is a function, whose return value depends on the value of one or more variables
declared outside this function. Consider the following piece of code with anonymous function:
multiplier = def(i) { i * 10 }
Here the only variable used in the function body, i ∗ 0, is i, which is defined as a parameter
to the function. Now let us take another piece of code:
multiplier = def (i) { i * factor }
. . f u n c t i ons : in depth
There are two free variables in multiplier: i and factor. One of them, i, is a formal parameter
to the function. Hence, it is bound to a new value each time multiplier is called. However, factor
is not a formal parameter, then what is this? Let us add one more line of code:
factor = 3
multiplier = def (i) { i * factor }
Now, factor has a reference to a variable outside the function but in the enclosing scope. Let
us try the following example:
println ( multiplier(1) ) // prints 3
println ( multiplier(14) ) // prints 42
Above function references factor and reads its current value each time. If a function has no
external references, then it is trivially closed over itself. No external context is required.
.. Partial Function
Partial functions are functions which lets one implement closure, w/o getting into the global
variable way. Observe :
// this shows the nested function
def func(a){
// here it is : note the name-less-ness of the function
r = def(b){ // which gets assigned to the variable "r"
printf("%s + %s ==> %s\n", a,b,a+b)
}
return r // returning a function
}
// get the partial function returned
x = func(4)
// now, call the partial function
x(2)
//finally, the answer to life, universe and everything :
x = func("4")
x("2")
This shows nested functions, as well as partial function.
.. Functions as Parameters : Lambda
From the theory perspective, lambdas are defined in Lambda Calculus. As usual, the jargon
guys made a fuss out of it, but as of now, we are using lambdas all along, for example :
list(1,2,3,4) as { $.o ** 2 }
The {$.o ∗ ∗2} is a lambda. The parameter is implicit albeit, because it is meaningful that way.
However, sometimes we need to pass named parameters. Suppose we now want to create a
function composition, first step would be to apply it to a single function :
def apply ( param , a_function ){
a_function(param)
}
So, suppose we want to now apply arbitrary function :
chapter . functional sty l e
apply( 10, def(a){ a** 2 } )
And now, we just created a lambda! The result of such an application would make apply
function returning .
.. Composition of Functions
To demonstrate a composition, observe :
def compose (param, a_function , b_function ){
// first apply a to param, then apply b to the result
// b of a
b_function ( a_function( param ) )
}
Now the application :
compose( 10, def(a){ a ** 2 } , def(b){ b - 58 } )
As usual, the result would be !
Now, composition can be taken to extreme ... this is possible due to the arbitrary length
argument passing :
def compose(value, func_list){
for ( f : func_list ){
value = f(@ARGS=[value])
}
value // return it
}
Formally this is a potential infinite function composition! Thus, this call :
// note the nameless-ness :)
r = compose(6, [def (a){ a** 2} , def (b){ b + 6 }] )
println(r)
generates, the answer to life, universe, and everything, as expected.
.. Operation on Function
Functions support composition to generate a new function : The operator for function composi-
tion :
# < f |g > (x) := g(f (x))
Let’s have a simple demonstration :
. . s t r i n g s as functions : currying
def f(){
println(str(@ARGS,’#’))
[ @ARGS[0] ** 2 ]
}
def g(){
println(str(@ARGS,’#’))
[ @ARGS[0] - 2 ]
}
h = #< f | g > // g of f
println( h(10) )
The result is :
10
100
@[ 98 ]
.. Eventing
All ZoomBA functions are Eventing ready. What are events? For all practical purposes, an event
is nothing but a hook before or after a method call. This can easily be achieved by the default
handlers for ZoomBA functions. See the object Event.
Here is a sample demonstration of the eventing:
def my_func(){
printf(’ARGS : %s %n’, str(@ARGS,’#’))
}
def event_hook(event){
printf(’%s %s %n’, event.method.name , event.when )
}
my_func.before += event_hook
my_func.after += event_hook
my_func(’hello’, ’world’)
When one runs it, this is what we will get :
my_func BEFORE
ARGS : hello#world
my_func AFTER
. s t r ings as functions : currying
All these idea started first with Alan Turing’s Machine, and then the rd implementation of a
Turing Machine, whose innovator Von Neumann said data is same as executable code. Read
more on : Von Neumann Architecture. Thus, one can execute arbitrary string, and call it code,
if one may. That brings in how functions are actually executed, or rather what are functions.
.. Rationale
The idea of Von Neumann is situated under the primitive notion of alphabets as symbols, and
the intuition that any data is representable by a finite collections of them. The formalisation of
such an idea was first done by Kurt Godel, and bears his name in Gödelization.
For those who came from the Computer Science background, thinks in terms of data as
binary streams, which is a general idea of Kleene Closure : {0, 1}∗ . Even in this form, data is
nothing but a binary String.
chapter . functional sty l e
Standard languages has String in code. In ‘C’ , we have “string” as “constant char*”. C++
gives us std:string , while Java has “String”. ZoomBA uses Java String. But, curiously, the whole
source code, the entire JVM assembly listing can be treated as a String by it’s own right! So,
while codes has string, code itself is nothing but a string, which is suitable interpreted by a
machine, more generally known as a Turing Machine. For example, take a look around this :
(zoomba)println(’Hello, World!’)
This code printlns ‘Hello, World!’ to the console. From the interpreter perspective, it
identifies that it needs to call a function called println, and pass the string literal “Hello, World!”
to it. But observe that the whole line is nothing but a string.
This brings the next idea, that can strings be, dynamically be interpreted as code? When
interpreter reads the file which it wants to interpret, it reads the instructions as strings. So, any
string can be suitable interpreted by a suitable interpreter, and thus data which are strings can
be interpreted as code.
.. Minimum Description Length
With this idea, we now consider this. Given a program is a String, by definition, can program
complexity be measured as the length of the string proper? Turns out one can, and that
complexity has a name, it is called : Chatin Solomonoff Kolmogorov Complexity.
The study of such is known as Algorithmic Information Theory and the goal of a software
developer becomes to println code that reduces this complexity.
As an example, take a look about this string :
(zoomba)s = ’ababababababababababababababababab’
=>ababababababababababababababababab ## String
(zoomba)#|s|
=>34 ## Integer
Now, the string ’s’ can be easily generated by :
(zoomba)s1 = ’ab’**17
=>ababababababababababababababababab ## String
(zoomba)s == s1
=>true ## Boolean
Thus, in ZoomBA, the minimum description length of the string ’s’ is : :
(zoomba)code="’ab’**17"
=>’ab’**17 ## String
(zoomba)#|code|
=>8 ## Integer
.. Examples
First problem we would take is that of comparing two doubles to a fixed decimal place. Thus:
(zoomba)x=1.01125
=>1.01125
(zoomba)y=1.0113
=>1.0113
(zoomba)x == y
=>false
How about we need to compare these two doubles with till th digit of precision (rounding)
? How it would work? Well, we can use String format :
(zoomba)str("%.4f",x)
=>1.0113
(zoomba)str("%.4f",y)
=>1.0113
. . s t r i n g s as functions : currying
But wait, the idea of precision, that is "." should it not be a parameter? Thus, one needs to
pass the precision along, something like this :
(zoomba)c_string = "%%.%df" ## This is the original one
=>%%.%df
## apply precision, makes the string into a function
(zoomba)p_string = str(c_string,4)
=>%.4f
## apply a number, makes the function evaluate into a proper value
(zoomba)str(p_string,y)
=>1.0113 # and now we have the result!
All we really did, are bloated string substitution, and in the end, that produced what we
need. Thus in a single line, we have :
(zoomba)str(str(c_string,4),x)
=>1.0113
(zoomba)str(str(c_string,4),y)
=>1.0113
In this form, observe that the comparison function takes parameters :
. The precision, int, no of digits after decimal
. Float
. Float
as the last time, but at the same time, the function is in effect generated by application of
partial functions, one function taking the precision as input, generating the actual format string
that would be used to format the float further. These sort of taking one parameter at a time and
generating partial functions or rather string as function is known as Currying, immortalized
the name of Haskell Curry, another tribute to him is the name of the pure functional language
Haskell.
Now to the nd problem. Suppose the task is given to verify calculator functionality. A
Calculator can do ‘+’ , ‘-’, ‘*’ , ... etc all math operations. In this case, how one proposes to
println the corresponding test code? The test code would be, invariably messy :
if ( operation == ’+’ ) {
do_plus_check();
} else if ( operation == ’-’ ) {
do_minus_check();
}
// some more code ...
In case the one is slightly smarter, the code would be :
switch ( operation ){
case ’+’ :
do_plus_check(); break;
case ’-’ :
do_minus_check(); break;
...
}
The insight of the solution to the problem is finding the following :
We need to test something of the form we call a "binary operator" is working "fine" or not:
operand1 < operator > operand2
chapter . functional sty l e
That is a general binary operator. If someone can abstract the operation out - and replace
the operation with the symbol - and then someone can actually execute that resultant string
as code (remember JVMA?) the problem would be solved. This is facilitated by the back-tick
operator ( executable strings) :
(zoomba)c_string = #’#{a} #{op} #{b}’
=>#{a} #{op} #{b}
(zoomba)a=10
=>10
(zoomba)c_string = #’#{a} #{op} #{b}’
=>10 #{op} #{b}
(zoomba)op=’+’
=>+
(zoomba)c_string = #’#{a} #{op} #{b}’
=>10 + #{b}
(zoomba)b=10
=>10
(zoomba)c_string = #’#{a} #{op} #{b}’
=>20
.. Reflection
Calling methods can be accomplished using currying.
import ’java.lang.System.out’ as out
def func_taking_other_function( func ){
#"#{func}( ’hello!’ )"
}
func_taking_other_function(’out.println’)
The f unc is just the name of the function, not the function object at all. Thus, we can use this
to call methods using reflection.
.. Referencing
Let’s see how to have a reference like behaviour in ZoomBA.
(zoomba)x = [1,2]
@[1, 2]
(zoomba)y = { ’x’ : x }
{x=@[ 1,2 ]}
(zoomba)x = [1,3,4]
@[1, 3, 4]
(zoomba)y.x // x is not updated
@[1, 2]
Suppose you want a different behaviour, and that can be achieved using Pointers/References.
What you want is this :
(zoomba)x = [1,2]
@[1, 2]
(zoomba)y = { ’x’ : ’x’ }
{x=x}
(zoomba)#’#{y.x}’ // access as in currying stuff
@[1, 2]
(zoomba)x = [1,3,4]
@[1, 3, 4]
(zoomba)#’#{y.x}’ // as currying stuff, always updated
@[1, 3, 4]
So, in effect we are using a dictionary to hold name of a variable, instead of having a hard
variable reference, thus, when we are dereferencing it, we would get back the value if such a
value exists!
. . avo i d i ng conditions
. avo iding conditions
As we can see the tenets of functional programming says to avoid conditional statements. In
the previous section, we have seen some of the applications, how to get rid of the conditional
statements. In this section, we would see in more general how to avoid conditional blocks.
.. Theory of the Equivalence Class
Conditionals boils down to if − else construct. Observe the situation for a valid date in the
format of ddMMyyyy.
is_valid_date(d_str){
num = int(d_str)
days = num/1000000
rest = num % 1000000
mon = rest /10000
year = rest % 10000
max_days = get_days(mon,year)
return ( 0 < days && days <= max_days &&
0 < mon && mon < 13 &&
year > 0 )
}
get_days(month,year){
if ( month == 2 and leap_year(year){
return 29
}
return days_in_month[month]
}
days_in_month = [31,28,31,... ]
This code generates a decision tree. The leaf node of the decision tree are called Equivalent
Classes, their path through the source code are truly independent of one another. Thus, we can
see there are equivalence classes for the days:
. Months with days
. Months with days
. Month with days : Feb - non leap
. Months with days : Feb -leap
And the if − else simply ensures that the correct path is being taken while reaching the
equivalent class. Observe that for two inputs belonging to the same equivalent class, the code
path remains the same. That is why they are called equivalent class.
Note from the previous subsection, that the days of the months were simply stored in an
array. That avoided some unnecessary conditional blocks. Can it be improved further? Can we
remove all the other conditionals too? That can be done, by intelligently tweaking the code.
Observe, we can replace the ifs with this :
get_days(month,year){
max_days = days_in_month[month] +
( (month == 2 and leap_year(year) )? 1 : 0 )
}
But some condition can never be removed even in this way.
chapter . functional sty l e
.. Dictionaries and Functions
Suppose we are given the charter to verify a sorting function. Observe that we have already
verified it, but this time, it comes with a twist, sorting can be both ascending and descending.
So, the conditions to verify ascending/descending are :
sort_a = !exists(collection) where { $.i > 0 and $.c[$.i - 1 ] > $.o }
sort_d = !exists(collection) where { $.i > 0 and $.c[$.i - 1 ] < $.o }
Note that both the conditions are the same, except the switch of > in the ascending to <
in the descending. How to incorporate such a change? The answer lies in the dictionary and
currying :
op = { ’ascending’ : ’>’ , ’descending’ : ’<’ }
sorted = !exists(collection) where {
$.i > 0 and #’$.c[$.i - 1 ] #{op} $.o’ }
In this form, the code written is absolutely generic and devoid of any explicit conditions.
Dictionaries can be used to store functions.
.. An Application : FizzBuzz
We already aquatinted ourselves with FizzBuzz. here, is a purely conditional version:
/* Pure If/Else */
def fbI(range){
for ( i : range ){
if ( i % 3 == 0 ){
if ( i % 5 == 0 ){
println(’FizzBuzz’)
} else {
println(’Fizz’)
}
}else{
if ( i % 5 == 0 ){
println(’Buzz’)
}else{
println(i)
}
}
}
}
However, it can be written in a purely declarative way. Here is how one can do it, Compare this
with the other one:
def fbD(range){
d = { 0 : ’FizzBuzz’ ,
3 : ’Fizz’ ,
5 : ’Buzz’ ,
6 : ’Fizz’,
10 : ’Buzz’ ,
12 : ’Fizz’ }
for ( x : range ){
r = x % 15
continue ( r @ d ){ println( d[r] ) }
println(x)
. . avo i d i ng iterations
}
}
. avo iding iterations
The last tenet is avoiding loops, and thus in this section we would discuss how to avoid loops.
We start with some functions we have discussed, and some functionalities which we did not.
.. Range Objects in Detail
The for loop becomes declarative, the moment we put a range in it. Till this time we only
discussed part of the range type, only the numerical one. We would discuss the Date and the
Symbol type range.
A date range can be established by :
d_start = time()
d_end = d_start + "PD10"
// a range from current to future
d_range = [d_start : d_end ]
// another range with 2 days spacing
d_range_2 = [d_start : d_end : 2 ]
and this way, we can iterate over the dates or rather time. The spacing is to be either an
integer, in which case it would be taken as days, or rather in string as the ISO-TimeInterval-
Format. The general format is given by : P yY mMwW dDT hHmMsS.
The other one is the sequence of symbols, the Symbol range :
s_s = "A"
s_e = "Z"
// symbol range is inclusive
s_r = [s_s : s_e ]
// str field holds the symbols in a string
s_r.str == ’ABCDEFGHIJKLMNOPQRSTUVWXYZ’ // true
All the range types have some specific functions.
r = [0:5]
// a list of the elements
r.list()
// reverse of the same [a:b]
r.reverse() // [4, 3, 2, 1, 0]
// inverse of the range : reversed into [b:a]
r.inverse() // [5:0:-1]
There is the ‘XRange’. X Range stands for extended range, which goes beyond standard size
of JVM. This can be created by using long types for one or more end points of a range :
xr = [0L:5000000000000000000L] // yep, huge range
xrr = [0D:10D:0.00000001D] // precise range
It is obvious that list() and related functions may or may not be possible with XRange.
chapter . functional sty l e
.. The Fold Functions
The rationale of the fold function is as follows :
def do_something(item){ /* some code here */ }
for ( i : items ){
do_something(i)
}
// or use fold
fold(items) as { do_something($.o) }
The idea can be found here in a more elaborative way. We must remember that the partial exists,
and the general fold function is defined as : f old() folds from left, so it is also called lf old().
// folds from left side of the collection
lfold(items[, seed_value ]) as { /* body */ }
// folds from right side of the collection
rfold(items[, seed_value ]) as { /* body */ }
First we showcase what right to left means in case of rf old() :
items = [0,1,2,3,4]
rfold( items ) as { printf( ’%s ’, $.o) }
This prints :
4 3 2 1 0
Let us showcase some functionalities using fold functions, we start with factorial :
fact_n = lfold( [2:n+1] , 1 ) as { $.p * $.o }
We move onto find Fibonacci :
fib_n = fold([0:n+1],[0,1]) as { #(p, c) = $.p; [c, p + c] }
We now sum the elements up:
sum_n = rfold([2:n+1], 0) as { $.p + $.o }
Generate a set from a list :
my_set = lfold( [1,2,1,2,3,4,5], set() ) as { $.p += $.o }
Finding min/max of a collection :
l = [1,8,1,2,3,4,5]
#(min,max) = lfold( l , [l.0, l.0] ) as {
#(m,M) = $.p
continue( $.o > M ){ $.p = [ m, $.o] }
continue( $.o < m ){ $.p = [ $.o, M] }
$.p // return it off, when nothing matches
}
// (1,8)
. . avo i d i ng iterations
Finding match index of a collection :
inx = fold( [1,2,1,2,3,4,5] , -1 ) as {
break ( $.o > 3 ){ $.p = $.i } ; $.p
}
So, as we can see, the fold functions are the basis of every other functions that we have seen.
We show how to replace select function using fold:
// selects all elements less than than equal to 3
selected = fold( [1,2,1,2,3,4,5] , list() ) as {
continue ( $.o > 3 )
$.p += $.o
}
To do an index() function :
// first find the element greater than 3
selected = fold( [1,2,1,2,3,4,5] , -1){
break ( $.o > 3 ) { $.i }
$.p }
And to do an rindex() function :
// first find the element less than 3
selected = rfold( [1,2,1,2,3,4,5] , -1){
break ( $.o < 3 ) { $.i }
$.p }
.. Matching
There is if, and there is else and switch-case seems to be missing in ZoomBA. Fear not, the
omniscient #match exists. To demonstrate :
// match item
item = 10
selected = switch(item){
case 1 : "I am one"
case @$ < 5 : "I am less than 5"
/* Default match is @$ itself, note that :
inside match you must use block comments */
case @$ : "yes, I could not match anything!"
}
Observe these important things about match:
. Match works with case expression after colon, evaluating to true or expression using
Object.equals(expr,item). Thus, string won’t match ‘’. This is a design decision chosen
to be compatible with switch case. To match such stuff, use @$ == expr , which would
use ZoomBA expression evaluation.
. The only comments which are allowed are block comments.
. The @$ signifies the item, and thus a case like case @$ must be the last item.
chapter . functional sty l e
. Any expression is permitted in the case statement, switch returns the body value of the
matching case. Thus, unlike ordinary switch-case, it returns a proper value. Thus, it is
more succinct to put it at the end of a choice function.
.. Sequences
Iteration is key component of multitude of algorithms. Let’s start with Factorial, Fibonacci,
which are recursively defined. We did find out how to do it with basic function style. Observe,
the recursion pattern Fn+1 = nFn , with base case F(0) = 1.
This is done by the seq() function in ZoomBA, which generates the iterator:
factorial = seq( 1 ) as { size( $.item ) * $.item[-1] }
for ( i : [ 1 : 10 ] ){
// Java Iterator: hasNext() and next() :: prints factorials of 1 to 9
printf( ’%d %d %n’ , i, factorial.next )
}
println( factorial.history ) // shows the history till this point
And that is how we can generate a never ending sequence of factorials. Moreover, we can see
the ‘history’. Formally, seq() is a function that is capable of computing fixed point iteration :
Xn+1 = F(Xn , Xn−1 , ...), each of these Xn−i can be tracked by the $.item term, or history.
While Factorial only use one past history term to calculate next, Fibonacci, uses :
Fibn = Fibn−1 + Fibn−2
with base cases Fib(0) = Fib(1) = 1 and a straightforward mapping is possible using se-
quences:
fib = seq( 1 , 1 ) as { $.item[-1] + $.item[-2] }
for ( i : [ 2 : 10 ] ){
printf( ’%d %d %n’ , i, fib.next )
}
println( fib.history )
It concludes the sequences. One has to remember that a sequence is a never ending iterator.
chapter 8
I n p u t a n d O u tput
IO is of very importance for software testing and business development. There are two parts
to it, the generic IO, which deals with how to read/write from disk, and to and from url. There
is another part of the data stuff, that is structured data. ZoomBA let’s you do both, and those
are the topic of this chapter.
. r e ading
.. read() function
Reading is done by this versatile read() function. The general syntax is :
value = read(source_to_read)
The source can actually be a file, an UNC path, an url. Note that given it is a file, read() reads
the whole of it at a single go, so, be careful with the file size.
value = read(’my_file.txt’) // value contains all the text in my_file.txt
lines = read(’my_file.txt’, true) // lines contains lines in the file
bytes = read(’my_file.txt’, ’b’) // bytes contains all bytes of the file
.. Reading from url : HTTP GET
Read can be used to read from an url. Simply :
resp = read(’http://www.google.co.in’)
/* value contains response of the google home page */
resp.body() // string of HTML
resp.bytes // response bytes
resp.code // responce code
resp.headers // response headers
To handle the timeouts, it comes with overloads:
chapter . input and outpu t
// url, connection timeout, read timeout, all in millisec
resp = read(’http://www.google.co.in’, 10000, 10000 )
/* resp contains all the response data from google */
// it supports named parameters :
resp = read(’path’ = ’https://www.google.co.in’,
’conTo’=1000, ’readTo’=1000, headers={:} )
// conTo : Connection Timeout, readTo : Read Timeout,
// headers : http headers you want to send
To generate the url to get, the fold function comes handy:
_url_ = ’https://httpbin.org/get’
params = { ’foo’ : ’bar’ , ’complexity’ : ’sucks’ }
// str: is the namespace alias for ’java.lang.String’
data = str(params.entries,’&’) as {
str(’%s=%s’,$.key,$.value)
}
response = read( str("%s?%s", _url_ , data ) )
And that is how you do a restful api call, using get.
.. Reading All Lines
The function f ile() reads all the lines, and puts them into different strings, so that it returns a
list of strings, each string a line. With no other arguments, it defers the reading of next line, so
it does not read the whole bunch together.
for ( line : file(’my_file.txt’) ){
println(line) // proverbial cat program
}
In short, the f ile() method yields an iterator. But with this, it reads the whole file together as
list of string lines:
ll = read ( ’my_file.txt’ , true )
This is again a synchronous call, and thus, it would be advisable to take care.
. w r i ting
.. write(), println(), printf() function family
We are already familiar with the write function. With a single argument, it writes the data
back to the standard output. The function is aliased as print() which is same as write():
println(’Hello,World!’) ; // prints it
printf("%d", 10) // formatted print
eprintln("This goes to error stream!" )
eprintf("This goes to error : %d", 10 ) // formatter
Given that the first argument does not contain a "%" symbol, the write functionality also
writes the whole string to a file with the name :
. . f i l e p rocessing
// creates my_file.txt, writes the string to it
write(’my_file.txt’, ’Hello,World!’)
// appends to the file
write(’my_file.txt’, ’Another line appended’, true)
// write binary to file
write(’my_binary_file.bin’, ’This is string data as payload’, ’b’)
The formatting guide for printf() can be found here.
. f i l e processing
We talked about a bit of file processing in read and write. But if we want to read a file line by
line, then we have to use something else.
.. open() function
In some rare scenarios, to write optimal code, one may choose to read, write, append on files.
The idea is then, using open() function. The syntax is :
fp = open( path [, mode_string ] )
The mode strings are defined as such: There are modes :
. Read : default mode : specified by "r"
. Write : write mode : specified by "w"
. Append : append mode : specified by "a"
. Binary : binary mode : specified by "b"
.. Reading
To read, one must open the file in read mode. This returns a java BufferedReader object. Now,
something like readLine can be called to read the file line by line, in a traditional way to
implement the cat command :
// open in read mode : get a reader
fp = open( path ,"r" )
while ( !empty( line = fp.readLine() ) ){
// call the standard java functions
println(line)
}
// close the reader
fp.close()
.. Writing
To write, one must open the file in write or append mode. This returns a java PrintStream
object. Now, something like println() can be called to write to the file :
// open in read mode : get a reader
fp = open( "hi.txt" ,"w" )
// call the standard java functions
fp.println("Hi")
// close the Stream
fp.close()
chapter . input and outpu t
. w e b io
.. open() for web
open() function is used to open a http or https connection:
// open web connection
wcon = open( "https://www.google.co.in" )
// wcon has multiple fields:
wcon.readTo // Read timeout
wcon.conTo // Connection timeout
.. get() , post()
Once we have open() a http or https connection, one can get or post into it by appropriate
functions :
resp = wcon.get("/", {:} ) // path, headers to send
resp = wcon.post("/", {:} ) // path, header map
resp = wcon.post("/", {:}, body ) // path, headers, body
.. Sending to url : send() function
To write back to url, or rather for sending anything to a server, there is a specialised send()
function.
_url_ = ’https://httpbin.org’
path = "/post"
wcon = open(_url_)
params = { ’foo’ : ’bar’ , ’complexity’ : ’sucks’ }
// path , protocol, headers, body
resp = wcon.send( post , "POST" , {:} , jstr(params) )
The SOAP XML stuff can be easily done with send. See the example soap body we will send
to :
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<GetWeather xmlns="http://www.webserviceX.NET">
<CityName>%s</CityName>
<CountryName>%s</CountryName>
</GetWeather>
</soap:Body>
</soap:Envelope>
And this is how we send the SOAP:
. . w o r k i ng with json
template_pay_load = read(’samples/soap_body.xml’)
pay_load = str( template_pay_load , ’Hyderabad’, ’India’ )
headers = { "SOAPAction" : "http://www.webserviceX.NET/GetWeather" ,
"Content-Type" : "text/xml; charset=utf-8" }
wcon = open( "http://www.webservicex.net")
resp = wcon.send( "/globalweather.asmx" , "POST" , headers , pay_load )
x = xml(resp.body() )
sr = x.element("//GetWeatherResult")
write(sr.text)
. w o rking with json
.. What is JSON?
JSON is being defined formally in here. The idea behind JSON stems from : JavaScript Object
Notation. There are many ways to define an object, one of them is very practical :
Objects are property buckets.
That definition ensures that the ordering layout of the properties does not matter at all.
Clearly :
{“x00 : 10, “y 00 : 42} == {“y 00 : 42, “x00 : 10}
Thus, we reach the evident conclusion, JSON are nothing but Dictionaries. Hence in ZoomBA
they are always casted back to a dictionary.
.. json() function
Suppose the json string is there in a file:
/* sample.json file */
{
"zooomba": {
"dbName": "zooomba",
"url": "jdbc:postgresql://localhost:5432/zoomba",
"driverClass" : "org.postgresql.Driver",
"user": "zooomba",
"pass": ""
},
"some2": {
"dbName": "dummy",
"url": "dummy",
"driverClass" : "class",
"user": "u",
"pass": "p"
},
}
To read the file ( or the text which has json) :
jo = json(’sample.json’, true)
The json() function can read also from the string argument. The return result object is either a
Dictionary object, or an array object, based on what sort of json structure was passed.
chapter . input and outpu t
.. Accessing Fields
Now, to access any field:
jo.noga.dbName // "zoomba"
jo.some2.driverClass // "class"
In effect, one can imagine this is nothing but a big property bucket. For some, there is this thing
called JSONPath, which is clearly not implemented in ZoomBA, because that is not a standard.
In any case, given json is a string, to check whether a text exists or not is a regular string search.
Given whether a particular value is in the hierarchy of the things or not, that is where the stuff
gets interesting.
For parameterised access, Currying is a better choice:
prop_value = ’zoomba.dbName’
value = #‘jo.#{prop_value}‘ // same thing, "zoomba"
In this way, one can remove the hard coding of accessing JSON objects.
.. Yaml Processing
ZoomBA supports yaml processing by the same way:
jo = yaml(string) // loads the yaml string into json object
jo = yaml(’file.yaml’, true ) // loads the yaml file into json object
Only important distinction is, for Yaml processing, the parser does not support automatic
type conversion into primitive type, thus, type hints are needed.
. w o rking with xml
Please, do not work with xml. There are many reasons why xml is a terrible idea. The best of
course is :
XML combines the efficiency of text files with the readability of binary files – unknown
But thanks to many big enterprise companies - it became a norm to abused human intellect
- the last are obviously Java EE usage in Hibernate, Springs and Struts. Notwithstanding the
complexity and loss of precise network bandwidth - it is a very popular format. Thus - against
my better judgment we could not avoid XML.
.. xml() function
Suppose, we have an xml in a file sample.xml :
<slideshow
title="Sample Slide Show"
date="Date of publication"
author="Yours Truly" >
<!-- TITLE SLIDE -->
<slide type="all">
<title>Wake up to WonderWidgets!</title>
</slide>
<!-- OVERVIEW -->
<slide type="all">
<title>Overview</title>
. . w o r k i ng with xml
<item>Why <em>WonderWidgets</em> are great</item>
<item/>
<item>Who <em>buys</em> WonderWidgets</item>
</slide>
</slideshow>
Call xml() To load the xml file ( or a string ) into an ZXml object :
x = xml(’sample.xml’, true , ’UTF-8’ ) // x is a ZXml object
The encoding string ( UTF- ) is optional. Default is UTF-. The full syntax of xml() is :
// x is a ZXml object
x = xml( source [, is_source_file? false , encoding=UTF-8, validate? false )
.. Converting to Other Formats
Given an Xml object, there are handy ways to convert them into other formats.
// x is a ZXml object
x = xml( ... )
json_object = json(x) // converts xml to json object
json_string = jstr(x) // converts xml to json string
yaml_string = ystr(x) // converts xml to yaml string
.. Accessing Elements
Given we now have the ZXml object, we should be able to find elements in it. The elements can
be accessed in two different ways. The first is, using the xml as a tree with root and children.
That is easy, for example, for the previous json to xml generated :
// XmlMap of the x
y = xml(x)
y.root.children[0].name //glossary
y.root.children[0].children[0].text // example glossary
For the slideshow xml:
// XmlMap of the x
x = xml(’sample.xml’,true) // slideshow xml
x.root.name //slideshow
// access attributes
x.root.children[0].attr.type // "all"
x.root.children[0].attr[’type’] // "all"
The other way of accessing elements, is to use the element() function, which uses XPATH :
// XmlMap of the x
x = xml(’sample.xml’, true ) // slideshow xml
// get one element
e = x.element("//slide/title")// first title element
e.text // "Wake up to WonderWidgets!"
chapter . input and outpu t
e = x.element("//slide[2]/title" ) // second element
e.text // "Overview"
In the same way, for selecting multiple elements, elements() function is used :
// XmlMap of the x
x = xml(’sample.xml’) // slideshow xml
// get all the elements called titles
es = x.elements("//slide/title" ) // a list of elements
// print all titles ?
fold(es) as { println( $.text ) }
.. XPATH Formulation
For evaluation of xpath directly, there is xpath() function defined. For example, to find the text
of any element, one can use the following :
// XmlMap of the x
x = xml(’sample.xml’,true) // slideshow xml
// text of the title element
s = x.xpath("//slide/title/text()" )
For a list of all xpath functions see the specification in wc.
To check if a condition exists or not, one can use the exists() function.
// XmlMap of the x
x = xml(’sample.xml’,true) // slideshow xml
// text of the title element, exists?
b = x.exists("//slide/title/text()" ) // bool : true
b = x.exists("//slide/title" ) // bool : true
b = x.exists("//foobar" ) // bool : false
Obviously, one can mix and match, that is, give a default to the xpath() function :
// string : text comes
t = x.xpath("//slide/title/text()" , ’NONE_EXISTS’ )
// string : ’NONE_EXISTS’
t = x.xpath("//foobar/text()", ’NONE_EXISTS’ )
. g e n eric xpath, xelement
In any declarative flavoured language, it is imperative that automatic discovery of fields and
dynamic accessing of fields to be supported. For XML, people do have xpath, while for JSON a
non standard json path is coming recently to the foray. ZoomBA uses apache jxpath to simplify
the whole problem.
JXPath can be used for any complex objects, including Maps and Collections. The syntax is
trivially same like xpath.
.. xpath()
To access value of an element we use the function xpath() :
. . data m atrix
v = xpath( object, xpath , [all_items=false] )
// this is how it works out
d = {’x’ : 42 }
v = xpath(d,’/x’, false ) // 42 a value
v = xpath(d,’/x’, true ) // [ 42 ] List
There is no way to pass a default, when in doubt, use all switch to true, to ensure that when
a field is not there, it returns an empty list.
.. xelem()
To access an element using an xpath we use the function xelem() :
v = xelem( object, xpath , [all_items=false] )
// this is how it works out
d = {’x’ : [ 0,1,2] }
e = xelem(d,’/x’, false ) // /.[@name=’x’] // DynamicPropertyPointer
e.value // [0,1,2]
See more about DynamicPropertyPointer.
As usual, pass true to generate a list.
. datamatrix
A DataMatrix is an abstraction for a table with tuples of data as rows. Formally, then a data
matrix M = (C, R) where C a tuple of columns, and R a list of rows, such that ∀ri ∈ R , ri is a
tuple of size |ri | = |C|. In specificity, ri [Cj ] → rij , that is, the i’th rows j’th cell contains value
which is under column Cj .
In software such abstraction is natural for taking data out of data base tables, or from
spreadsheets, or comma or tab separated values file.
.. matrix() function
To read a data matrix from a location one needs to use the matrix() function :
m = matrix(data_file_path [, column_separator_string = ’\t’
[, header_is_there_boolean = true ]] )
For example, suppose we have a tab delimited file “test.tsv” like this:
Number First Name Last Name Points Extra
Eve Jackson
John Doe x
Adam Johnson
Jill Smith xx
To load this table, we should :
m = matrix("test.tsv", ’\t’, true ) // loads the matrix
m.columns // the set of columns
m.rows // the list of data values
chapter . input and outpu t
The field columns is a Set of string values, depicting the columns. rows, however are the list
of data values.
.. Accessing Data
A data matrix can be accessed by rows or by columns. For example :
x = m.rows[0][1] // x is "Eve"
x = m.rows[1][2] // x is "Doe"
Now, using column function c()
y = (m.c(1))[1] // y is "Eve"
y = (m.c(2))[1] // y is "Doe"
.. Tuple Formulation
Every row in a data matrix is actually a tuple. This tuple can be accessed using the tuple()
function which returns a specific data structure called a Tuple:
t = m.tuple(1) // 2nd row as a Tuple
t.0 // 2
t["First Name"] // John
t.Points // 80
This tuple object is the one which gets returned as implicit row, when select operations on
matrices are performed.
.. Project and Select
The project operation is defined here. In essence it can be used to slice the matrix using the
columns function c(). The column function c() takes an integer, the column index of slicing,
and can take aggregated rows, which are a list of objects, which individually can be :
. An integer, the row index
. A range: [a : b] , the row indices are between a to b.
Thus :
m.c(0,1) // selects first column, and a cell of 3rd row
m.c(0, [0:2]) // selects first column, and two cells : 1st and 2nd row
But that is not all we want. We want to run SQL like select query, where we can specify
the columns to pass and appear. That is done using select() function. It takes the anonymous
parameter as an argument. The other normal arguments are objects which individually can be :
. An integer, the column index to project
. A String, the column name to project
. A range: [a : b] , the column indices to project, between a to b.
Thus :
x = m.select(0,2)
// x := [[1, Jackson], [2, Doe], [3, Johnson], [4, Smith]]
. . data m atrix
Same thing can be accomplished by :
x = m.select(’Number’ , ’Last Name’ )
// x := [[1, Jackson], [2, Doe], [3, Johnson], [4, Smith]]
Changing the order of the columns results in a different Tuple, as it should :
x = m.select(2 , 0 )
// x := [[Jackson, 1], [Doe, 2], [Johnson, 3], [Smith, 4]]
As always, select() works with condition, so :
x = m.select(2 , 0 , where { $.Number > 2 } )
// x := [[Johnson, 3], [Smith, 4]]
which demonstrates the conditional aspect of the select() function.
The tuples generated can be transformed, while being selected. For example, we can change
the Last Name to be lowercased :
x = m.select(2 , 0 , where {
( $.Number > 2 ){
$[2] = $[2].toLowerCase()
}
} ) // x := [[johnson, 3], [smith, 4]]
.. The matrix() function
One can create a matrix out of an existing one. Observe that, using project and select generates
only the list of data values, not a new matrix itself. If one wants to create a matrix out of an
existing one :
m2 = m.matrix(2 , 0 , where ( $.Number > 2 ){
$[2] = $[2].toLowerCase()
}
)
This generates a new matrix named m2, with columns starting from “Last Name” and “Number”.
The rows values are exactly the same as the select query done.
.. Keys
Given we have matrices (m1, m2) , we can try to figure out if they differ or not. A Classic
case is comparing two database tables from two different databases. A very naive code can be
written as such :
chapter . input and outpu t
def match_all_rows(m1,m2){
count = 0
for ( r1 : m1.rows ){
// linearise the left tuple
st1 = str(r1,’#’)
for ( r2 : m2.rows ){
// linearise the right tuple
st2 = str(r2,’#’)
// they match
if ( r1 == r2 ){ count += 1 }
}
}
( count == size(r1.rows) && count == size(r2.rows) )
}
The complexity of this algorithm, with respect to the size of the rows of the matrices is :
Θ(n2 ), given n is the rows size of the matrices. Given both the matrices have m columns, the
complexity would become Θ(n2 m2 ), a huge amount considering a typical (n, m) := (10000, 10).
We can obviously improve this setting:
def match_all_rows(m1,m2){
// exactly m * n
l1 = list(m1.rows ) as { str($.o,’#’) }
// exactly m * n
l2 = list(m2.rows ) as { str($.o,’#’) }
// exactly n
diff = l1 ^ l2
empty(diff) // return
}
The new complexity comes to Θ(nm). The thing we are implicitly using is known as key. We
are not really using the key, but, stating that key uniquely represents a row. The criterion for a
set of attributes to be qualified as key can be described as :
// a set of attribute indices
key_attrs = [ index_1 , index_2 , ... ]
def is_key( m, key_attrs){
s = set(m.rows) as {
r = $.o // store the row
// generate a list by projecting the attributes
l = fold(key_attrs) as { r[$.o] }
// linearise the tuple
str(l,’#’)
}
size(s) == size(m.rows)
}
What happens when the keys are non unique? That boils down to the list, but then we
should be able to remember, which rows have the same keys, or rather what all rows are marked
by the same key. So, we may have a keys function, assuming keys are not unique :
. . data m atrix
// a set of attribute indices
key_attrs = [ index_1 , index_2 , ... ]
def key( m, key_attrs, sep){
keys = fold (m.rows, dict() ) as {
r = $.o // store the row
// generate a list by projecting the attributes
l = fold(key_attrs) as { r[$.o] }
// linearise the tuple
k = str(l, sep)
if ( k @ $.p ){ // the key already exists
$.p[k] += $.i // append the current row index to the rows
}else{
// key does not exist, create one and then append
$.p[k] = list($.i) // key is the row id
}
$.p
}
}
This idea is already in-built in the DataMatrix, and is known as the keys() function :
m.keys{ /* how to generate one */ }( args... )
m.keys( columns_for_keys )
So, to simply put, keys() generate a key dict for the matrix, as shown below, using the matrix
in (..) :
// the key is the column Number
m.keys( ’Number’ )
// see what the keys are ?
m.keys /* {4?=[3], 3?=[2], 2?=[1], 1?=[0]} */
We can generate a non unique key too, just to show the practical application :
// the key is the column Number modulo 2: [0,1]
m.keys( as { $.Number % 2 } )
// see what the keys are ?
m.keys /* {0=[1, 3], 1=[0, 2]} */
.. Aggregate
Once we establish that the keys function did not generate unique keys, one may want to
consolidate the rows to ensure that the key points to unique rows. This is done by the aggregate()
function. This function can be surmised to generate a new matrix from the old matrix, where
the same keys pointing to different rows must be aggregated based on columns.
chapter . input and outpu t
def aggregate(m,columns , aggregate_function ){
agg_rows = list()
for ( key : m.keys ){
row = list()
rows_list = m.keys[key]
for ( c : columns ){
// aggregate the rows on a single column
col_data = m.c( c, rows_list )
agg_data = aggregate_function( col_data )
row += agg_data // add a replacement for all the rows
}
// add to the newer row
agg_rows += row
}
// now we have the new matrix data rows
}
chapter 9
I n t e r ac t i n g with Environment
Environment is needed to run any system. In this chapter we discuss about that environment,
which is aptly called the Operating System. We would discuss about how to make calls to the
operating system, how to create threads, and how to operate in linear ways in case of error
happened, and how to have random shuffling generated.
. p r o cess and threads
.. system() function
To run any operating system command from ZoomBA, use the system() function. It comes
in two varieties, one where the whole command is given as single string, and in another the
commands are separated as words :
status = system(command_to_os)
status = system(word1, word2,...)
The return status is the exit status of the command. It returns for success and non zero for
failure. For example, here is the sample :
status = system("whoami") // system prints "noga"
/* status code is 0 */
In case of unknown command, it would throw an error:
status = system("unknown command")
/* error will be thrown */
In case of command is found, but command execution reported an error, it status would be
non zero:
status = system("ls -l thisDoesNotExist")
/* os reprots
ls: thisDoesNotExist: No such file or directory
status := 1
chapter . interacting with environmen t
*/
In the same way, multiple words can be put into system, which is of some usefulness when
one needs to pass quoted arguments :
// the result of "ls -al ." is not shown at all, use popen()
status = system("ls" , "-al" , "." )
/* status code is 0 */
.. popen() function
If you want to work with processes, use popen() function.
p = popen("ls" , "-al" , "." )
p.waitOn(10000) // timeout
p.status().out // stdout
p.status().err // stderr
p.status().code // exit code
popen() comes with multiple command line arguments, as in :
p = popen(args=["ls" , "-al", "/" ],
redirect={ "out" : "out_file" , "err" : "err_file" , "in" : "in_file" }
)
This way, one can redirect input, output and error. A call to popen() w/o any input yields a
dummy abstraction of the current running process, which then can be used to extract the pid by
:
cur = popen( ) // dummy current ZProcess
cur.process.pid // current process id
.. thread() function
thread() function, creates a thread. The syntax is simple :
t = thread( args_to_be_passed ) as { /* thread function body */ }
current_thread = thread() // gets current thread
Thus, simply, use thread() to create a thread:
t = thread( "Hello", "world" ) as {
printf(’My Id is %d\n’, $.i )
printf(’My args are: %s\n’, str($.c,’\n’ ) )
printf(’I am %s\n’, $.o )
}
/* java isAlive() maps to alive */
while ( t.alive ){
cur_thread = thread() // returns current thread
cur_thread.sleep(1000)
}
. . p r o c e s s and threads
This would produce some kind of output as below:
My Id is 10
My args are Hello
world
I am Thread[Thread-1,5,main]
.. poll() function
Observe the last example where we used a while to wait for a condition to be true. That would
generate an infinite loop if the condition was not true. So, many times we need to write this
custom waiter, where the idea is to wait till a condition is satisfied. Of course we need to have a
timeout, and of course we need a polling interval. To make this work easy, we have poll().
The syntax is :
poll ( [ timeout-in-ms = 3000, [ polling-interval-in-ms = 100] ]) [ where {
condition-body-of-function } ]
So these are explanations :
poll() // this is ok : simple default wait
poll (4000) // ok too !
poll (4000, 300 ) // not cool : 300 is rejected , no condition!
A very mundane example would be :
i = 3
poll( 1000, 200 ) where { i-= 1 ; i == 0 }// induce a bit of wait
// this returns true : the operation did not timeout
i = 100
poll( 1000, 200 ) where { i+= 1 ; i == 0 } // induce a bit of wait
// this returns false : timeout happened
and, finally, we replace the while statement of the thread example using poll() :
t = thread() as {
/* do anything one needs */
}
/* java isAlive() maps to alive */
poll( 10000, 300 ) where { ! t.alive }
.. Atomic Operations
Given there are threads, being atomic is of importance. The definition of being atomic is :
Either the block gets totally executed, or it does not at all.
Observe the problem here :
$count = 0
// create a list of threads to do something?
l = list( [0:10] ) as { thread() as { $count+= 1 } } // increase count...
poll ( 10000, 50 ) where {
running = select(l) where { $.o.isAlive } ; empty(running) }
println($count) // what is the value here?
chapter . interacting with environmen t
You would expect it to be , but it would be any number x ≤ 10, because of the threading
and non-atomic issue. To resolve it, put it inside an atomic block (#atomic{} ) :
$count = 0
// create a list of threads to do something?
l = list( [0:10] ) as { thread() as { #atomic{ $count+= 1 } } }
// above tries to increase count...
poll( 10000, 50 ) where {
running = select(l) as { $.isAlive } ; empty(running)
}
println($count) // the value is 10
and now, the count is always .
Atomic can be used to revert back any changes in the variables :
x = 0
#atomic{
x = 2 + 2
}
#atomic{
x = 10
println(x) // prints 10
/* error, no variable as "p’, x should revert back to 4 */
t = p
}
println(x) // x is 4
.. The clock Block
Timing is of essence. If one does not grab hold of time, that is the biggest failure one can be. So,
to measure how much time a block of code is taking, there is clock() function. The syntax is
simple :
// times the body
#(time_taken_in_sec_double, result ) = #clock{ /* body */}
Thus this is how you tune a long running code:
m1 = 0
#(t,r) = #clock{
// load a large matrix, 0.2 million rows
m1 = matrix(’test.csv’, ’,’ , false)
0 // return 0
}
println(t) // writes the timing in seconds ( double )
println(r) // writes the result : 0
The clock block never throws an error. That is, if any error gets raised in the block inside,
the error gets assigned to the result variable.
#(t,r) = #clock{ x = foobar_not_defined_var }
// r would be ZoomBA variable exception
. . h a n d l ing of errors
Note that the timing would always be there, no matter what. Even in the case of an error,
the timing variable would be populated.
. h a ndling of errors
We toyed with the idea of try-catch, and then found that : Why Exception Handling is Bad? ;
GO does not have exception handling. And we came to believe it is OK not to have exceptions
in a language that has no business becoming a system design language. In a glue language like
ZoomBA, we should code for everything, and never ever eat up error like situations. For this
specific need, Asserts are in place. In particular - the multi part arguments and the return story
- should ensure that there is really no exceptional thing that happens. After all, trying to build
a fool-proof solution is never full-proof. And one of the return values should then be asserted.
.. error() function
But we need errors to be raised. This is done by the error() function.
error( args... ) where [ { /* body, when evaluates to true raise error */} ]
The function error() can have multiple modes, for example this is how one raise an error with a
message :
error( "error message")
This is how one raise an error on condition :
error( condition , "error message")
when condition would be true, error would raised. If the condition is false, error() returns
f alse. In case we want to execute complex logic, and guards it against failure:
error("error message") where { /* error condition */ }
.. Multiple Assignment
GoLang supports multiple assignments. This feature is picked from GoLang. Observe the
following :
#(a,b) = [ 0 , 1 , 2 ] // a = 0, b = 1
#(,a,b) = [ 0 , 1 , 2 ] // a = 1, b = 2
The idea is that one can assign a collection directly mapped to a tuple with proper variable
names, either from left or from right.
Note the quirky “,” before a in the nd assignment, it tells you that the splicing of the array
should happen from right, not from left.
chapter . interacting with environmen t
.. Error Assignment
A variant of multiple assignment is error assignment. The idea is to make the code look as
much linear as possible. The issue with the try() function is that, there is no way to know that
error was raised, actually. It lets one go ahead with the default value. To solve this issue, there
is multiple return, on error.
import ’java.lang.Integer’ as Int
#(n ? e) = Int.parseInt(’42’) //n := 42 int, e := null
// error will be raised and caught
#(n ? e) = Int.parseInt(’xx42’) //n := null, e:= NumberFormatException
Observe the “?” before the last argument e, to tag it as the error container. Thus, the system
knows that the error needs to be filled into that specific variable. Thus, one can write almost
linear code like this:
import ’java.lang.Integer’ as Int
#(n ? e) = Int.parseInt(str_val)
empty(e) || bye(’failure in parsing ’, str_val )
The bye() function, when called, returns from the current calling function or script, with
the same array of argument it was passed with.
. o r d er and randomness
.. Lexical matching : tokens()
In some scenarios, one needs to read from a stream of characters (String) and then do something
about it. One such typical problem is to take CSV data, and process it. Suppose one needs to
parse CSV into a list of integers. e.g.
s = ’11,12,31,34,78,90’ // CSV integers
l = select( s.split(’,’) ) where { !empty( int($.o) ) } as { int($.o) }
// l := [11, 12, 31, 34, 78, 90] // above works
But then, the issue here is : the code iterates over the string once to generate the split array, and
then again over that array to generate the list of integers, selecting only when it is applicable.
Clearly then, a better approach would be to do it in a single pass, so :
s = ’11,12,31,34,78,90’
tmp = ’’
l = list()
for ( c : s ){
continue ( c == ’,’ ){
l += int(tmp)
tmp = ’’
}
tmp += c
}
l += int(tmp)
println(l)
However, this is a problem, because we are using too much coding. Real developers abhor
extra coding. The idea is to generate a state machine model based on lexer, in which case, the
best idea is to use the tokens() function :
. . o r d e r and randomness
tokens( <string> , <regex> ,
match-case = [true|false] )
// returns a matcher object
tokens ( <string> , <regex> , match-case = [true|false] ) as { anon-block }
// calls the anon-block for every matching group
Thus, using this, we can have:
// what to do : string : regex
l = tokens(s, ’\d+’) as { int($.o) }
and we are done. That is precisely how code is meant to be written.
.. hash() function
Sometimes it is important to generate hash from a string. To do so :
h = hash(’abc’)
// h := 900150983cd24fb0d6963f7d28e17f72
It defaults to "MD", so :
hash( ’MD5’ ,’abc’)
// h := 900150983cd24fb0d6963f7d28e17f72
They are the same. One can obviously change the algorithm used :
hash([algo-string , ] <string> )
There are these two specific algorithms that one can use to convert to and from base
encoding. They are “e” to encode and “d” to decode. Thus, to encode a string in the base
:
h = hash(’e64’, ’hello, world’)
//h := aGVsbG8sIHdvcmxk
//And to decode it back :
s = hash(’d64’, ’aGVsbG8sIHdvcmxk’ )
// s:= "hello, world"
// url encode and decode
s = hash(’eu’, string)
hash(’du’, s) // decode
.. Anonymous Comparators
Ordering requires to compare two elements. The standard style of Java comparator is to code
something like this :
def compare( a, b ) {
if ( a < b ) return -1
if ( a > b ) return 1
return 0
}
// or in short, with sign function :
chapter . interacting with environmen t
def compare(a,b) { sign(a - b) }
Obviously, one needs to define the relation operator accordingly. For example, suppose we have
student objects :
student1 = { ’name’ : ’Anakin’ , ’id’ : 42 }
student2 = { ’name’ : ’Mace’ , ’id’ : 24 }
And we need to compare these two. We can choose a particular field, say “id” to compare
these :
def compare( a, b ) {
if ( a.id < b.id ) return -1
if ( a.id > b.id ) return 1
return 0
}
Or, there is another way to represent the same thing :
def compare( a, b ) {
( a.id < b.id )
}
In ZoomBA compare functions can be of both the types. Either one choose to generate a
triplet of (−1, 0, 1), or one can simply return true when lef t < right and false otherwise. The
triplet is not precisely defined, that is, when the comparator returns an integer :
. The result < 0 =⇒ lef t < right
. The result = 0 =⇒ lef t = right
. The result > 0 =⇒ lef t > right
when it returns a boolean however, the code is :
cmp = comparator(a,b)
if ( cmp ) {
println( ’a<b’ )
}else{
println( ’a >= b’ )
}
In the subsequent section anonymous comparators would be used heavily. The basic syntax
of these functions are :
order_function(args... ) where { /* anonymous comparator block */ }
As always $.0 is the left argument (a) and $.1 is the right argument (b). Thus, one can define
the suitable comparator function to be used in order.
.. Sort Functions
Sorting is trivial:
cards = [’B’,’C’,’A’,’D’ ]
sa = sorta(cards) // ascending
// sa := [A, B, C, D]
. . o r d e r and randomness
sd = sortd(cards) //descending
// sd := [D, C, B, A]
Now, sorting is anonymous block ( function ) ready, hence we can sort on specific attributes.
Suppose we want to sort a list of complex objects, like a Student with Name and Ids. And now
we are to sort based on "name" attribute:
students = [ {’roll’ : 1, ’name’ : ’X’ } ,
{’roll’ : 3, ’name’ : ’C’ } ,
{’roll’ : 2, ’name’ : ’Z’ } ]
sa = sorta(students) where { $[0].name < $[1].name }
/* sa := [{roll=3, name=C}, {roll=1, name=X},
{roll=2, name=Z}] */
Obviously we can do it using the roll too:
sa = sorta(students) where { $[0].roll < $[1].roll }
// sa := [{roll=1, name=X}, {roll=2, name=Z}, {roll=3, name=C}]
.. Heap
A heap is an entirely different matter. Heap stores the ‘k’ largest or smallest entries in a
collection that is given to it. This structure let’s you find top ‘k’ or bottom ‘k’ as you wish. heap()
function in ZoomBA creates the Heap.
h = heap(3) // It is a min-heap, 3 elements
for ( [0:10] ) { h += $ } // add stuff up : h<0|[ 2,1,0 ]> // ZHeap
h.top // 0 // Integer
In case we want to create a max-heap :
h = heap(3,true) // It is a max-heap, 3 elements
for ( [0:10] ) { h += $ } // add stuff up : h<9|[ 7,8,9 ]> // ZHeap
h.top // 9 // Integer
One can, of course index into a heap :
h[0] // 7
h[-1] // 9 : last element
And finally, one can always use a comparator to create the Heap, because that comparison is
needed to compare elements:
l = [ [1,2] , [4,1] , [2,10 ], [0,40] , [-1,-3] ]
h = heap(2) where { $.l.1 < $.r.1 }
h += l // consume all of it
h.top // @[-1,-3] is the top element
chapter . interacting with environmen t
.. Priority Queue
While Heap is a neat structure for top-k, it is a specialisation of Priority Queue. In heap there
are only some ‘k’ items while in Priority Queue, there can be as many. ZoomBA implementation
wraps around Java Priority Queue.
pq = pqueue() [ where { /* comparator function */ } ]
For example :
l = [10,1,23,12,15,0,3]
pq = pqueue()
for ( l ) { pq += $ } // consume
pq.peek // 0
while ( !empty(pq) ){ println(pq.poll) } // 0 1 3 10 12 15 23
.. sum() function
Sometimes it is of importance to generate sum of a collection. That is precisely what sum()
achieves :
l = [0,-1,-3,3,4,10 ]
s = sum(l)
/* sum := 9 */
Obviously, the function takes anonymous function as argument, thus, given we have :
x = [ 2,3,1,0,1,4,9,13]
s = sum(x) as { $.o * $.o }
/* 281 */
Thus, it would be very easy to define on what we need to sum over or min or max. Essentially
the anonymous function must define a scalar to transfer the object into.
.. minmax() function
It is sometimes important to find min and max of items which can not be cast into numbers
directly. For example one may need to find if an item is within some range or not, and then
finding min and max becomes important. Thus, we can have :
x = [ 2,3,1,0,1,4,9,13]
#(m,M) = minmax(x)
// [0, 13]
This also supports anonymous functions,thus :
students = [ {’roll’ : 1, ’name’ : ’X’ } ,
{’roll’ : 3, ’name’ : ’C’ } ,
{’roll’ : 2, ’name’ : ’Z’ } ]
#(m,M) = minmax(students) where { $[0].name < $[1].name }
// [{roll=3, name=C}, {roll=2, name=Z}]
. . o r d e r and randomness
.. shuffle() function
In general, testing requires shuffling of data values. Thus, the function comes handy:
cards = [ ’A’, ’B’ , ’C’ , ’D’ ]
// inline shuffling
happened = shuffle(cards)
// happened := true , returns true/false stating if shuffled
cards
// order changed : [D, A, C, B]
.. The random() function
The random() function is multi-utility function. With no arguments it returns a SecureRandom
:
sr = random() // ZRandom instance, a SecureRandom implementation
random() function can be used in selecting a single value at random from a collection :
l = [0,1,2,3,4]
rs = random(l) // rs is a randomly selected element
It can also be used to select a random sub collection from a collection, we just need to pass
the number of elements we want from collection :
a = [0,1,2,3,4]
rs = random(a,3) // pick 3 items at random without replacement
// works on strings too....just to array
rs = random("abcdefghijklmpon".toCharArray ,10)
Given a seed data type, it generates the next random value from the same data type. Behold
the behaviour:
rand_bool_value = random(true) // generates random boolean
random_within_0_9 = random(10) // a random integer between 0 to 9
Random instance supports multitudes of other randomized functions like :
r = random() // get the random instance
r.string("\\d+", 10 ) //string matching regex with min size 10
r.string("[abc]+", 10, 20 ) // string matching regex with min size 10 , max 20
// now various numeric ones
r.num() // next random integer
r.num(0.0) // next double
seed = 1
r.num(seed.longValue()) // gets a long random number
r.num( "2" ) // 2 size large integer as random
r.num(true) // Next Gaussian
chapter . interacting with environmen t
. e r r ors in zoomba
ZoomBA was written as a glue language. Therefore, utmost care is taken to report any error, in
a precise manner. For reference, we have used this file called t.zm for all the examples.
.. Unknown Variable Error
Let’s start with a very simple error :
println(x) // x is not defined
You would see the error comes in as :
zoomba.lang.core.types.ZException$Variable: x : -->
/Codes/zoomba/image_scraper/t.zm at line 1, cols 9:9
|- println --> /Codes/zoomba/image_scraper/t.zm at line 1, cols 1:10
This is the most common type of error one is going to get.
.. Unknown Property Error
In a dynamic language, this is the next error one gets:
obj = { ’a’ : 10 }
println( obj.x ) // but there is no property called ’x’ !!!
You would see the error comes in as :
zoomba.lang.core.types.ZException$Property:
Object {a=10} does not have property ’x’ of class java.lang.String :
--> /Codes/zoomba/image_scraper/t.zm at line 2, cols 14:14
|- println --> /Codes/zoomba/image_scraper/t.zm at line 2, cols 1:16
Note that the error also tries to showcase what all properties the object has.
.. Function Errors
This happens, when you are calling a function that does not exist:
val = 10
func( val ) // where is this function?
The error says that there is no such function:
zoomba.lang.core.types.ZException$Function: func :
--> /Codes/zoomba/image_scraper/t.zm at line 2, cols 1:11
|- func --> /Codes/zoomba/image_scraper/t.zm at line 2, cols 1:11
It is simply stating that the function does not exist. Now, there can be issue with parameter
passing, as in below:
def func( x ){
println(x)
}
func() // parameter is not passed!
Related error is:
. . e r r o r s in zoomba
zoomba.lang.core.types.ZException$Function:
parameter ’x’ is not assigned!: in method : func :
--> /Codes/zoomba/image_scraper/t.zm at line 4, cols 1:6
|- func --> /Codes/zoomba/image_scraper/t.zm at line 4, cols 1:6
Wait a bit here. It is OK to have a function where we use implicit args @ARGS, but not ok to
have a parameter and then not using it.
Another related errr is method mismatch, which happens because ZoomBA is a dynamic
language:
s ="foobar"
s.foo()
Clearly, no such method foo() exists in the String class and hence, the error comes to be:
zoomba.lang.core.types.ZException$Function: foo : no such method! :
foo : in class : class java.lang.String :
--> /Codes/zoomba/image_scraper/t.zm at line 2, cols 3:7
|- foo --> /Codes/zoomba/image_scraper/t.zm at line 2, cols 3:7
What happens when a method exists, but the parameters do not match?
s ="foobar"
s.toString("boohahah")
Clearly, no such method toString(String ) exists in the String class and hence, the error comes
to be:
zoomba.lang.core.types.ZException$Function: toString : args did not match any known method! :
toString : in class : class java.lang.String :
--> /Codes/zoomba/image_scraper/t.zm at li
ne 2, cols 3:20
|- toString --> /Codes/zoomba/image_scraper/t.zm at line 2, cols 3:20
.. Stack Trace
While we are at functions, functions can and do call other functions.
def funky(z){
println(y)
}
def func( x ){
funky( x )
}
func(42)
In this case, ZoomBA shows the stack trace:
zoomba.lang.core.types.ZException$Variable: y :
--> /Codes/zoomba/image_scraper/t.zm at line 2, cols 11:11
|- println --> /Codes/zoomba/image_scraper/t.zm at line 2, cols 3:12
|- funky --> /Codes/zoomba/image_scraper/t.zm at line 6, cols 3:12
|- func --> /Codes/zoomba/image_scraper/t.zm at line 8, cols 1:8
Even a for iterated loop comes under this scheme, that is because for-iterator is actually a
function, calling Java’s hasNext() and next() over an iterator.
chapter . interacting with environmen t
.. Arithmetic Errors
Naturally, there can be arithmetic errors, when some operator we use on some object, that does
not support it. Starting with the trivial :
q = 0
p = 42
println( p/q )
which is classic divide by zero, culminates in:
zoomba.lang.core.types.ZException$ArithmeticLogicOperation:
Invalid Arithmetic Logical Operation [/] :
--> /Codes/zoomba/image_scraper/t.zm at line 3, cols 12:12
--> ( Can not do operation ( DIVISION ) : ( 42 ) with ( 0 ) ! )
|- println --> /Codes/zoomba/image_scraper/t.zm at line 3, cols 1:14
.. LValue Error
What happens when we try to assign value to a constant term?
12 = 42
this culminates in :
zoomba.lang.core.types.ZException$Variable:
Assignment not possible into ASTNumberLiteral :
--> /Codes/zoomba/image_scraper/t.zm at line 1, cols 1:2
.. Stack OverFlow
Pretty common to do:
def fact( n ){
if ( n == 1 ) return 1
n * fact( n ) // missed the : n - 1
}
fact(2)
this will produce :
zoomba.lang.core.types.ZException$Function: StackOverFlow: in method : fact :
--> /Codes/zoomba/image_scraper/t.zm at line 3, cols 9:18
|- fact --> /Codes/zoomba/image_scraper/t.zm at line 3, cols 9:18
|- fact --> /Codes/zoomba/image_scraper/t.zm at line 3, cols 9:18
|- fact --> /Codes/zoomba/image_scraper/t.zm at line 3, cols 9:18
|- fact --> /Codes/zoomba/image_scraper/t.zm at line 3, cols 9:18
|- fact --> /Codes/zoomba/image_scraper/t.zm at line 3, cols 9:18
.... <many lines of repeat>
.. Null Error
From Java standpoint, pretty common to reference null:
x = null
println( x.method() ) // imagine there is actually something
this will auto-panic :
. . d e b u g ging
Panic --> [ --> /Codes/zoomba/image_scraper/t.zm at line 2, cols 12:19 ]
caused by : zoomba.lang.core.types.ZAssertionException: null reference : x
|- println --> /Codes/zoomba/image_scraper/t.zm at line 2, cols 1:21
Null is treated differently, hence, a Panic gets generated, because it is curable.
. d e b ugging
It is essential to have debug support in a language. ZoomBA is no exception. ZoomBA sup-
ports debugging programmatically. What does that mean? It means, the breakpoint can be
programmatically introduced to the script itself, or manually inserted.
.. Simple Breakpoint
x = 10
#bp // here is how we add a breakpoint as statement!
println(x)
when we run this with the interpreter ( or even programmatically ) this will happen:
============= With Power, Comes Responsibility ========
BreakPoint hit: --> /Codes/zoomba/image_scraper/t.zm at line 2, cols 1:3
============= Please use Power, Carefully..... ========
//h brings this help.
//h key_word : shows help about the keyword
//q quits REPL. In debug mode runs till next BreakPoint
//v shows variables.
//c In debug mode, clear this Breakpoint.
//r loads and runs a script from REPL.
Enjoy ZoomBA...(0.1-beta5-SNAPSHOT-2019-Feb-01 16:58)
(zoomba)
We are now in the debugger. In here, we can fire any expression, check any variables, upto this
point:
(zoomba)//v
context : {
x => 42 /* class java.lang.Integer */
}
.. Conditional Breakpoint
What happens when you want to put a condition on the breakpoint?
x = int(@ARGS[0]) // from command line
#bp empty(x) // breakpoint when x is empty ! need to check how it happened...
println(x)
when we run this with the interpreter ( or even programmatically ) this will happen: Syntax of
the conditional break point is #bp [condition] .
chapter 10
O b j e c t O r i e n tation
Objects are essential, programmatically. It can be argued that a map or a dictionary can work
perfectly well instead of “fully blown” objects in multitude of languages.
The idea of hiding states is bad, because it assumes the incompetency of a programmer,
rather all of them. A philosophy which assumes philosophers are incompetent is contradictory
onto itself.
However, that is a philosophical debate, and is not needed to be played down. There is no
denial of facts, that modern computing world is object oriented. Thus, ZoomBA has objects,
even if we never intended it to have “language specific” objects in ZoomBA.
. i n troduction to classes
.. Defining and Creating
A class is defined by the keyword def , just like a method definition. The difference is, the
method definition must have a () after the keyword, while the class definition does not. Thus :
def Hello{}
creates a class called Hello. Obviously one needs to create a class, that is created by the new()
function :
// reflection style creation
h1 = new ( ’Hello’ )
// hard coded creation, Hello resolves to current script
h2 = new ( Hello )
That is all it takes to create classes in ZoomBA. We sincerely thought about the Pythonic way of
resolving class name as the creation of new classes, and then decided to go against it. In the
pythonic way, it becomes impossible to tell, whether or not this is a class constructor call, or
rather a generic function call. Observe this :
chapter . object orientatio n
/* a function call or object creation?
In ZoomBA, function call. In Python, anything! */
h = Hello()
// clear object creation in ZoomBA
h = new ( Hello )
and this is why we do believe the Pythonic way is ambiguous. The ZoomBA tenet of
minimisation of code footprint must also abide by the tenet of maintainability. Moreover,
ZoomBA is prototype based, hence none of the ZoomBA objects are actually a JVM class objects.
They are, in the truest sense, dictionaries holding functions and properties.
.. Instance Fields
Objects are property buckets. I choose to design ZoomBA precisely this way, the JavaScript way.
Pitfalls are obvious, and see a nice discussion here. Those are not a problem for us here much,
and subsequent discussion would show why. In any case, object without any fields or rather say
properties are meaningless objects. Any object can be given any property at runtime. Observe
the following :
// object creation in ZoomBA
h = new ( Hello )
h.greet_string = "hello, world" // create a field : greet_string
println( h.greet_string ) // access the field at runtime
Every field is public, and we are Pythonic. As the proverb goes “Never design a tool for fools,
while you were designing version ., the fools upgraded themselves to version .” . The Java naked
field access without any getter and setter is . times faster than that of the getters and setters.
But we all agree that is a bad way of randomly assigning properties to an object. Thus, we
want to somewhat put properties inside the object in the time of creation.
One easy way out is as follows:
def SomeClass : { ’a’ : 42, b : false }
// now, instance is based on SomeClass
instance = new ( SomeClass )
One should also note that, both normal and string literals are allowed, much like JavaScript.
This is the easiest way to create a prototype based object. In the runtime, we can actually change
the values, if we desire:
instance = new ( SomeClass , b = true )
// now a is 42, but b is true
But this is not what we really want. We want something which can programmatically
initialize the instance, while it is being prepared. That is next.
. . i n t r oduction to classes
.. Constructor
This brings to us the notion of constructor. There is no constructor in ZoomBA, nothing actually
constructs the class. There is obviously an instance initialiser. This is defined as such :
def Hello{
def $$(){
$.greet_string = ’Hello, World!’
}
}
h = new ( Hello )
println( h.greet_string )
Now, this $$() is a specific function, which is the instance initialiser. The special identifier $
in the context in a class also is a specific identifier, identifying the instance of the class being
passed, this is pythons self. One obviously can pass arguments to the constructor :
def Hello{
def $$(greetings=’Hello, World’){
$.greet_string = greetings
}
}
// the ordinary folks
h1 = new ( Hello )
println( h1.greet_string )
// from the Penguins of Madagascar
h2 = new ( Hello , "Hey, Higher Mammal! Do you read?" )
println( h2.greet_string )
.. Instance Methods
This brings the question of how do we encapsulate the state of the object. Sometimes, you do not
want to let people access stuff. You want to handle the properties of an instance yourself. Those
are done with the instance methods, constructor method is one special type of instance method:
def Hello{
def $$(greetings=’Hello, World’){
$.greet_string = greetings
}
def greet(){
println( $.greet_string )
}
}
h1 = new ( Hello )
h1.greet()
Obviously one can pass arguments to any instance method:
chapter . object orientatio n
def Hello{
def $$(greetings=’Hello, World’){
$.greet_string = greetings
}
def greet(person="Everyone"){
println( ’To @%s : %s\n’, person , $.greet_string )
}
}
h1 = new ( Hello )
h1.greet("ZoomBA")
. s tatics & prototype ba sed inheritence
To have class level properties and methods, which gets initialised only once, we must have static
constructs, which are indistinguishable from prototype.
.. Static Fields
These are class level fields, and can not be accessed using instances. This can be accessed by
class level accessors :
def MyClass{}
MyClass.foo = "bar"
println( MyClass.foo )
If we try to access the static field using instances :
mc = new ( MyClass )
mc.foo // "bar"
. o p erators
ZoomBA supports operator overloading. The following operators and functions can be over-
loaded :
. . o p e r ators
operator method
toString $str
hashCode $hc
equals $eq
compareTo $cmp
+ $add
- $sub
* $mult
/ $div
+= $add$
-= $sub$
*= $mult$
/= $div$
** $pow
unary - $neg
| $or
& $and
^ $xor
|= $or$
&= $and$
^= $xor$
.. Example : Complex Number
As an example, we present the class Complex number, which overloads lots of operators :
chapter . object orientatio n
def Complex {
def $$ (x=0.0,y=0.0){
$.x = Q(x)
$.y = Q(y)
}
def $str(){
str(’(%f,i %f)’, $.x, $.y)
}
def $eq(o){
( $.x == o.x && $.y == o.y )
}
def $hc(){
31 * $.x.hashCode() + $.y.hashCode()
}
def $neg(){
new (Complex , -$.x , -$.y)
}
def $add(o){
new (Complex , $.x + o.x , $.y + o.y )
}
def $sub(o){
new (Complex , $.x - o.x , $.y - o.y )
}
def $mul(o){
new (Complex , $.x * o.x - $.y * o.y , $.x * o.y + $.y * o.x )
}
def $div(o){
mod = ( o.x **2 + o.y **2 )
x = ( $.x * o.x + $.y * o.y )/mod
y = ( $.y * o.x - $.x * o.y )/mod
new (Complex , x, y )
}
}
// test it out :
c0 = new (Complex )
c12 = new (Complex , 1, 2)
c21 = new (Complex , 2, 1)
// test some?
println( -c12 )
println ( c0 == -c0 )
chapter 11
P r ac t i c a l Z o omBA
Examples should be abundant, and this chapter is massively inspired from Programming
Pearls. The idea behind this chapter is many examples that happens practically, and how to
solve the problems in least possible code, in the best possible way. Although the whole book is
pretty abundant in examples - this chapter has its own advantages.
. a note in style
Standards are for humans, and not otherwise. Being said that : A guideline is a guideline
and is not a law of a country or nature that one abides by. Being said that, it is more of the
matter of taste, readability, and understandability and something called reproducibility of a
bug. Therefore the notion of test flow is of utmost importance. Test cases should fail when app
failed, and should pass only when app is working. This tenet drives the guidelines of coding.
Therefore, the following subsections are for both the author and the reviewer.
.. Comments
Comments are not after thought. For any standard library use, comment why and what we are
trying to accomplish. ZoomBA has a minimalistic syntax, so it is better to explain why we are
doing what we are doing. This is a NO GO :
assert ( size( @ARGS ) >= 2 , ’boom!’ )
#(some_param, some_other) = @ARGS
This, for example is a GO:
assert ( size( @ARGS ) >= 2 , ’Problem : Args are less than 2!’ )
#(some_param, some_other) = @ARGS // storing the args into two params as tuple
.. Naming Conventions
Naming are to be done by very simple Pareto optimality. If looking at the name, out of ,
developers can not figure out what it is for, then that name is useless. Change it, continually till
% developers can understand what something means.
chapter . practical zoom ba
One can use caml casing or can use underscore, but mixing them in a single file produces
readability problem. So, please do not use it. thisIsABigName and this_is_a_big_name both are
acceptable, as long as they are not in the same file. But, iamamoron is not acceptable as any
name.
When in doubt, please use expanded names rather than the cryptic ones. Don’t be shy of
using variables, because variable assignment and get value is fast. By design, it is not possible
to write a ZoomBA code beyond lines, unless you are using it for System design, which you
should not.
.. Explicit Conditionals and Iteration
ZoomBA goes for provable, correct coding, rather than code that feels like “Let there be Code!”.
Therefore, it is advised to use functional style where it suits. If it means twice the runtime,
sometimes, it is OK to have twice the runtime. In short, we generally do not want this :
// sum up even and odd numbers in a collection col
tot_even = 0
tot_odd = 0
for ( x : col ) {
if ( 2 /? x ) {
tot_even += x
} else {
tot_odd += x
}
}
Instead, this is preferable :
#( total_even, total_odd ) = fold ( col, [0,0] ) as {
// generate an index mapping which collector to be used
inx = $.item % 2
$.partial[inx] += $.item // add the item up
$.partial // return
}
.. Assertions
Raise assertions, and raise it fast. ZoomBA is a dynamically typed, declarative language. It is of
utmost important to check for errors as soon as it happens, and try not to manage pass it. That
means :
def some_brilliant_function(x=42,y=false){
assert( x isa ’int’ , ’Wrong type of x : needs int’ )
assert( y isa ’bool’ , ’Wrong type of y : needs bool’ )
//... now proceed...
}
This should not be taken as The Type Debate but a way to mitigate what is expected. In the
same way, this paves the way for :
def function_accepting_json( json_string ){
#( json_obj, err ) = json( json_string)
panic ( empty(json_obj) , ’Parse error in Json! ’ + str(err) )
assert ( "field1" @ json_obj , "Why field1 is not passed?" )
// continue the rest...
}
. . a s s o rted theoretical examples
. a s sorted theoretical examples
.. A Game of Scramble
We are sure you guys have know the game of jumbled up words. For example, someone gives
you “Bonrw” and you need to say : “Brown” ! Suppose we ask you to write a program to do it.
The simplest solution is this :
if we sort the all the words in a dictionary letter by letter and then use that sorted word as a key?
Then we can easily solve the problem by sorting on the letters of the word given and then checking if
that as key exist in the dictionary, then, find all possible matches !
word_dict = mset(file(’words.txt’)) as {
// generate char array
ca = $.o.toCharArray()
// generate a key by sorting and concatenating
key = str(sorta(ca),’’)
}
// now a jumbled up word exists ?
ca = jumbled_word.toCharArray()
key = str( sorta( ca ) , ’’)
matches = word_dict[key] ?? [] // in case key is not found?
println(matches)
.. Find Anagrams of a String
The problem is, suppose someone gave you a string : “zoomba” say. The idea is to list all
possible words with the letters in it. The letters may or may not have meaning, but that is ok.
How to solve this problem?
The easy method is to generate permutation of all the letters, and check if it occurred before.
Thus, given word is the string :
// create a set of words
words = set()
// get the sorted version in an array
letters = sorta ( word.toCharArray() )
// generate the args for permutations
args = list( [0 : #|letters|] ) as { letters }
join(@ARGS = args ) where {
continue ( $.o != letters )
v = str($.o,’’)
// add the permutation to the words
words += v
// no need to store anything
false
}
// now words has all the anagrams
and this solves the problem. Notice that many advanced concepts are being used in the solution.
A related question is this :
Given a list of strings, return a list of lists of strings that groups all anagrams.
Ex. given [ trees, bike, cars, steer, arcs ]
return [ [cars, arcs] , [bike], [trees, steer] ]
To solve the problem, use the same approach :
chapter . practical zoom ba
strings = [ ’trees’ , ’bike’ , ’cars’, ’steer’, ’arcs’ ]
words = dict()
lfold (strings) as {
key = str( sorta( $.o.toCharArray() ),’’)
if ( key !@ words ){ words[key] = list() }
words[key] += $.o
}
println( words.values() )
.. Sublist Sum Problem
Given a list of integers, and a value sum, determine if there is a sublist of the given list with sum
equal to given sum. There is a dynamic programming solution - which is left for the reader to
figure out. Our solution would be minimalist. Observe that the solution is finding all possible
combinations of the list, and check where the sum comes up. So, we notice that the previous
anagram problem is the building block of this problem too! So, suppose the list of integers are
stored in li :
// create a set for solutions
solutions = set()
// get the sorted version of the list
li = sorta ( li )
// generate the args for permutations
args = list( [0 : #|li|] ) as { li }
join(@ARGS = args ) where {
continue ( $.o != li )
// we need the sum
sm = sum($.o)
continue( sm != sum )
sa = sorta($.o) // we need combinations
v = str(sa)
continue( v @ solutions )
// add the combination to the solutions
solutions += v ; false // store nothing
}
// now solutions has all the solutions to the problem
.. Sublist Predicate Problem
Observe that, the most generic way to represent all of the above problems is by introducing a
predicate P ($) , and stating the problem as such :
Given a list , and a predicate P ($), determine if there is a sublist of the given list where P ($) is True.
Thus, the generic solution becomes :
. . a s s o rted theoretical examples
// create a set for solutions
solutions = set()
// get the sorted version of the list
li = sorta ( li )
// generate the args for permutations
args = array{ li }( [0 : #|li|] )
perms = join( @ARGS = args ) where { continue ( $.o != li )
continue( !P( $.o ) )
l = sorta( list( $.o) ) // we need combinations
v = str(l,’#’) ; continue( v @ solutions )
// add the combination to the solutions
solutions += v ; false // store nothing
}
// now solutions has all the solutions to the problem
.. List Closeness Problem
Suppose there are points in a metric space, collected in a list. There are two such lists, and
we need to check if these lists are sufficiently close to one another or not. Formally, given the
distance function d(, ), and two collections ( of same size N ) A, B, they are close iff there exists
permutations of A, B defined as πm (A) and πn (B) such that :
∀i ∈ {0, ..., N − 1} ; d(πm (A[i]), πn (B[i])) <
where m and n represents the Permutation Index, and is the closeness. In simple english,
given two list of numbers of the same size, and a closeness number , this looks:
∀i ∈ {0, ..., N − 1} ; |πm (A[i]) − πn (B[i])| <
This is not a hard problem, but is formulated as such. To solve it, observe that given the
distance metric, one can calculate the distance of all the points from a base point, in case of
numbers, that would be . That would let us create an order relation over the numbers. Thus,
we can order the numbers in the ascending order, and then i’th element of A must be close to
i’th element of B. That is, suppose As , Bs are the sorted versions of A, B, then :
∀i ∈ {0, ..., N − 1} ; |As [i] − Bs [i]| <
and thus, the ZoomBA solution is :
AS = sorta(A)
BS = sorta(B)
e = 0.01 // say?
s = #|AS| // the size
close = !exists( [0:s] ) where { #| AS[$.o] - BS[$.o] | > e }
.. Shuffling Problem
The problem statement is :
Given a string e.g. “ABCDAABCD”. Shuffle the string so that no two similar letters together. E.g.
AABC can be shuffled as ABAC.
So, how to solve this? As always, we formalise the problem. First we find that how many
same alphabets are present, and make a group. Then, we go round robin over all the groups and
exhaust the groups. When there would be no solutions? Clearly using the Pigeonhole Principle
one can say, when one group would have more characters than the rest of the characters plus .
For example, there can not be any solution for the string “AAA” : trivial, and “AAAB”.
chapter . practical zoom ba
word = ’ABCDAABCD’
m = mset(word.toCharArray() )
#(min,Max) = minmax(m) where { size($.l.value) < size($.r.value) }
solvable = ( #|word| + 1 < 2 * #|Max.value| )
! ( solvable ) || bye(’sorry, no solution exists!’)
keys = list(m.keySet())
shuffle(keys)
len = #|keys|
result = fold ([0:#|word|],’’) as {
i = $.index
key = keys[i % len]
$.partial + m[key][0]
}
println(result)
Observe the use of the bye() function. When it is called, it simply returns from the calling
function, with the string as return value. Wonder where it can be practically applied? We can
think of one. Suppose we are going to go at a diner where girls and boys came. Now, there
would be ( if the soap operas are slightly true ) boys and girls who were involved with one
another. Thus a relationship existed is defined by x EXy which means x, y were emotionally
attached. Now, an extended relationship can be found, extending R, so that x EXy and y EXz
implies x EXz where N stands for do not talk. Clearly, N is a set generate by EX. Clearly none
in the same N set wants to talk to one another, and thus do not want to seat side by side.
That brings the problem, and now you see, how emotional stuff can generate a nice computer
algorithm, that Microsoft asks in Interviews.
.. Reverse Words in a Sentence
Suppose a sentence reads : “This is an utter waste of time”, we should reverse the order of the
words.
line = ’This is an utter waste of time’
words = tokens( line, ’\\S+’) as { $.o }
words = words ** -1
result = str(words, ’ ’)
We can reduce it further :
line = ’This is an utter waste of time’
$result = ’’
tokens( line, ’\\S+’) as { $result += ’ ’ + $.o ; continue }
$result = $result[1:-1] // substring with index 1
.. Recursive Range Sum
Write a recursive function: sum(x,max ) that calculates the sum of the numbers from x to max
(inclusive). For example, sum(4, 7) would compute 4 + 5 + 6 + 7 and return the value 22. The
function must be recursive so you are not allowed to use any conventional loop constructs.
. . a s s o rted theoretical examples
def sum(x,max){
dif = max - x
x*(diff + 1) + diff*(diff+1)/2
}
This function uses integer arithmetic, and hence is recursive. Add and subtract are actually
recursion. Lets solve it in another way :
def sum_func(x,max){
if ( max == x ) return x
return ( max + sum_func(x, max - 1 ) )
}
size( @ARGS ) > 1 || bye(’I need two arguments!’)
#( x , max ) = [ int(@ARGS[0]) , int( @ARGS[1] ) ]
println (sum_func(x,max))
.. String from Signed Integer
With input as a integer, write an algorithm to convert that to string without using any built in
functions. It may be a signed number.
def to_str(i){
if ( i == 0 ) return "0"
sign_val = (i < 0 )?’-’:’’ // same here, not using standard
i = ( i> 0 )?i:-i // not using any standard function at all
s = ’’
for ( ; i > 0 ; i /= 10 ){
s = str( i % 10) + s
}
sign_val + s
}
println ( to_str( int(@ARGS[0] ) ))
.. Permutation Graph
Given an integer "n" and pair of "I" swapping indices, generate the largest number. Swapping
indices can be reused any number times.
n : 1243
Indices:
(0,3)
(2,3)
Answer:
3421, 3214, 4213, 4231,...
The result is 4231 which is the largest.
The problem is that of Permutation Graph. Observe, then, the rules lets you generate nodes
from the starting node. Also observe that the size of the graph generated by the rules is finite,
the graph generated is strictly a subgraph of the overall permutation graph, which is finite by
definition. A subset of a finite set is finite.
So, how to generate the graph? Obviously we need to apply the rules again and again. But
there is a chance of a cycle.
chapter . practical zoom ba
Figure . – Permutation Graph.
The problem here, is a very well known problem: Graph Exploration. Given this problem
came from Facebook is quite apt. So, how do we solve it?
. Keep a dictionary of traversed nodes, or say integers : nodes := { node : traversed ? false }
. Initialise nodes to starting seed ().
. Pick one item from the node set, which is not traversed, and apply both the rules.
. If the results generates new nodes, not already in nodes, then add them to nodes
. If traversal yield old nodes, mark the node as traversed : true
. check if there is any nodes left to pick and traverse
. The exploration is done, now go over all the nodes and check which one is the largest.
And here is the ZoomBA code :
. . a s s o rted theoretical examples
nodes = { 1243 : false }
rules = [ [0,3] ,[2,3] ]
/* generate the permutation */
def get_node(cur,rule){
c_array = str(cur).toCharArray()
t = c_array[rule.0]
c_array[rule.0] = c_array[rule.1]
c_array[rule.1] = t
int ( str(c_array,’’))
}
/* Explore the Graph */
while (true){
/* observe the division over a dictionary
This generates a set of keys where
value is the right operand */
not_traversed = nodes / false
break(empty(not_traversed))
// mark as true
nodes[ not_traversed[0] ] = true
// get the current node
cur = not_traversed[0]
lfold (rules) as {
// generate the next node
nn = get_node( cur, $.o )
// in case it exists, continue
continue(nn @ nodes )
// add to the dictionary for nodes
nodes[nn] = false
}
}
// generate the min, max
#(m,M) = minmax(nodes) where { $.l.key < $.r.key }
println(M)
.. Find Perfect Squares
Find the list of perfect squares between two given numbers. So, how do we solve it? We go back
to formalism : the perfect squares are:
s = {x|∃n ∈ N s.t. x = n2 and b ≤ x ≤ e}
Thus, to solve it :
def find_all_perfect_squares( begin, end ){
b = floor ( begin ** 0.5 )
e = ceil ( end ** 0.5 )
select ( [b:e+1] ) where {
sq = $.o ** 2
sq <= end && sq >= begin
} as { $.o ** 2 }
}
println( find_all_perfect_squares(10,100) )
.. Max Substring with no Duplicate
Given “s” a string, find max size of a sub-string, in which no duplicate chars present. To solve
the problem, observe that a substring is defined by the start index : i and end index : j, given
the string. Thus, all possible substrings are nothing but all possible combinations of (i, j). Thus,
chapter . practical zoom ba
a very simple solution would be to find all possible substrings and see which one is the highest
size. The base case is finding if the given string has no duplicates. Hence the code :
s = ’abacdefghabk’
def vals: { large_size : 1 , substring : ’a’ } // create a container
indices = [0:#|s|].list()
result = join ( indices, indices ) where {
continue($.0 >= $.1)
ss = s[$.0 : $.1]
l = size(ss)
continue(large_size > l )
set_size = #|set(ss.toCharArray())|
continue( set_size != l )
vals.substring = ss
vals.large_size = l
false
}
println(’%s with size %d\n’, vals.substring, vals.large_size )
.. Maximum Product of Ascending Subsequence
Given a sequence of non-negative integers find a subsequence of length having maximum
product with the numbers of the subsequence being in ascending order. As an example: with
input 6, 7, 8, 1, 2, 3, 9, 10 the result would be 8, 9, 10. Thus, here is the solution :
l = [ 6,7, 8, 1, 2, 3, 9, 10 ]
i = [0:#|l|].list()
ans = l[0] * l[1] * l[2]
result = [l[0],l[1],l[2] ]
join(i,i,i) where {
// we need subsequences so...
continue( $.0 >= $.1 or $.1 >= $.2 )
// we need ascending, so
continue( l[$.0] > l[$.1] or l[$.1] > l[$.2] )
r = l[$.0] * l[$.1] * l[$.2]
continue(r <= ans)
result = [l[$.0], l[$.1], l[$.2] ]
ans = r ; false
}
printf(’Values %s with product %d %n’, str(result) , ans )
In this form, we can generalise it, to any number of items instead of . Suppose the same
problem was asked and the size of the tuple was fixed at m. The function, instead of making
it a multiply, one can generalise to any f ($). The reader should code that general problem,
accordingly.
.. Minimal Sum of Integers in Digit Array
Given the array of digits ( is also allowed), what is the minimal sum of two integers that are
made of the digits contained in the array. For example, array: 1, 2, 7, 8, 9. The min sum (129+78)
should be 207. To solve this, note that a partition of digits would split the digits into halves.
Sort the halves so that the integers generated by the halves are smallest. Now, check the result,
and continue. Observe that a partition is nothing but a binary string of same size as the array,
’s defining left partition, while ’s defining right partition. Thus :
. . a s s o rted theoretical examples
d = [1, 2, 7, 8, 9]
l = ’1278’
r = ’9’
min = int(l) + int(r)
// observe that a partitions are done using bits
n = #|d|
upto = 2 ** (n+1)
lfold [1:upto] as {
selection = $.o
left = list() ; right = list()
bitmask = 1
lfold( [ 0 : n ] , bitmask ) as {
bitmask = $.o
// bitwise and operation
b = selection & bitmask
if ( b == 0 ){
left += d[ $.index ]
} else {
right += d[ $.index ]
}
bitmask = bitmask * 2
}
// obvious
continue ( empty(left) || empty(right) )
// if any starts with 0
continue ( left #^ 0 || right ^# 0 )
// due stuff
left = str(sorta(left),’’) ; right = str(sorta(right),’’)
v = Z(left) + Z(right)
continue ( v >= min )
min = v ; l = left ; r = right
}
printf(’%s + %s = %d\n’ , l, r, min )
.. Ramanujan Partitions
Given a number N , write a program that returns all possible combinations of numbers that add
up to N , as lists. (Exclude the N+=N) . For example, if N = 4 return [[1, 1, 1, 1], [1, 1, 2], [2, 2], [1, 3]]
See more about the problem here. One of Indian greats, rather worlds finest who worked beyond
this problem.
To systematically generate the partitions, observe that one needs to select groups of “”s
from the list of N “” :
[[1], [1], [1], [1]] := [[1], [1, 1, 1]] := [[1, 1], [1, 1]] := [[1], [1], [1, 1]]
Thus, the problem is selecting the gaps between these “”s, and there are N − 1 of them.
Thus we must systematically select between [1 : N ] gaps, numbered between 0 and N − 1. Sum
the resulting groups, and keep them sorted as the key. To select a number between 0 and N − 1
use the binary encoding of numbers between 1 to 2N −1 .
chapter . practical zoom ba
def ramanujan_partition(N){
// imagine N-1 + symbols
// 1+1+...+1
// select + symbols
max = 2 ** ( N - 1 )
partitions = set()
for ( n : [1: max] ) { // avoid trivial partition
s_rep = str(n,2)
s_rep = ’0’ ** ( N -1 - #|s_rep| ) + s_rep
// in s_rep, ’1’ means select partition from that ’+’ symbol
// for N = 5, 1 + 1 + 1 + 1 + 1
// 0001 means 0 0 0 1 => 4 + 1
current_partitions = list()
cur_val = 1
for ( c : s_rep ){
continue ( c == _’1’ ){
current_partitions += cur_val
cur_val = 1
}
cur_val += 1
}
current_partitions += cur_val
sorta( current_partitions )
partitions += str(current_partitions )
}
partitions // return
}
println( ramanujan_partition(5))
.. Consecutive Elements in Subset
Given a set of numbers, find the longest subset with consecutive numbers be it any order.
Input: S = [5, 1, 9, 3, 8, 20, 4, 10, 2, 11, 3] , we have consecutive sets : s1 = [1, 2, 3, 4, 5] and
s2 = [8, 9, 10, 11]. Ans is s1 .
S = [5, 1, 9, 3, 8, 20, 4, 10, 2, 11, 3]
S = set(S)
S = sorta(S)
write(S)
max_size = 1
indices = list(0,1)
r = [0:#|S|]
join( r,r ) where {
i = $.l
j = $.r
continue( i >= j )
consecutive = ( index{ S[$-1] + 1 != S[$] }([i+1:j]) < 0 )
continue( not consecutive )
continue( max_size > j - i )
max_size = j - i
indices[0] = i ; indices[1] = j
false
}
write( S[[indices.0 : indices.1]] )
.. Competitive Array
Given an array of elements, return an array of values pertaining to how many elements are
greater than that element remaining in the array. Ex. for [3, 4, 5, 9, 2, 1, 3] Return [3, 2, 1, 0, 1, 1, 0].
. . a s s o rted theoretical examples
First element is 3 because 3 < 4, 5, 9. Second element is 2 because 4 < 5, 9.
items = [3,4,5,9,2,1, 3]
d = mset(items)
lfold ( d ) as { d[$.key] = [ size($.value) , 0 ] }
keys = list(d.keySet())
keys = sorta(keys)
higher_count = 0
rfold(keys) as {
t = d[$.o]
t[1] = higher_count
higher_count += t[0]
}
result = list(items) as { (d[$.o])[1] }
println(result)
This is so trivial that no explanation is given for the code.
.. Sum of Permutations
Find the sum of all digit numbers formed from 1, 2, 3, 4 without repetition. The easy way is to
do the permutations and then summing them up.
d = [1,2,3,4]
p = join ( @ARGS = list( [0:size(d)] ) as { d } ) where {
d == $.o } as { int( str($.o,’’) ) }
S = sum(p)
println(S)
The result can be found algebraically. Observe that the summation would be over the digits
1, 2, 3, 4 and the integers created would have the power places as 103 + 102 + 10 + 1 = 1111, so,
each for every permutation starting with digit d would sum up to 1111 × (1 + 2 + 3 + 4) = 11110.
Now, how many permutations stating with a digit d ? That would be found by taking that digit
out of the permutation, and permutating the rest of the digits : (4 − 1)! = 3! = 6, hence the total
would be 66660.
.. Print a String Multiple times
Print a character times without using loop and recursion. Sometimes, I also, get astonished
by the amount of IM that an interview can produce. The one who asked this question probably
never heard of recursively enumerable languages. In any case, I just could not avoid this,
because, in ZoomBA, you actually can. I mean seriously, you can.
s = ’Moron asked me this’ // stands for what it is, precisely
println( s** 1000 ) // prints s a 1000 times
.. Next Higher Permutation
How do we generate next permutation? By swapping two indices, and we have n C2 options. So,
one solution would be simply to iterate over and find the minimum of all next permutations
which is higher than the current one:
chapter . practical zoom ba
string_val = @ARGS[0]
nu = int( string_val )
num_arr = string_val .toCharArray()
r = [0 : #| string_val | ]
// pick the highest one
nhp = int ( str( sortd(num_arr) ,’’) )
nhp != nu || bye(’Dude, got to be kidding me!’)
join (r,r) where {
i = $.0 ; j = $.1
continue( i >= j )
num_arr = string_val.toCharArray()
t = num_arr[i]
num_arr[i] = num_arr[j]
num_arr[j] = t
nn = int ( str(num_arr,’’))
continue( nn < nu )
if ( nn < nhp ){ nhp = nn }
false
}
println(nhp)
Now, this works, so, question is, can we make it any faster? Turns out, we can. Given next
higher permutation is possible, there has to be one discrepancy where Di < Dj with i < j. The
objective would be to find minimum of such a span |i − j| is minimum, with maximum value of i.
So, we can start from the right, with i = n − 2 and j = n − 1, and then searching left for a match.
def next_higher_perm( n ){
digits = str(n).toCharArray()
len = #|digits|
j = len - 1
while ( j > 0 ){
i = j - 1
while ( i >= 0 ){
if ( digits[i] < digits[j] ){
// swap and we are done
t = digits[i]
digits[i] = digits[j]
digits[j] = t
return int( str(digits,’’) )
}
i -= 1
}
j -= 1
}
n // nothing can be done so...
}
println ( next_higher_perm( @ARGS[0] ) )
.. Maximal Longest Substring Problem
Given a string S , print the longest substring P such that lexicographically : P > S. One may
assume that such substring exists.
. . a s s o rted theoretical examples
S = "hello , world"
def max_large_sub(s){
len = #|s|
j = index([1:len]) where { s[0] < s[$.o] }
j > 0 ? s[0:j+1] : ’’
}
println(max_large_sub(S))
.. Partitions which are Palindromes
Given a string, print all possible palindromic partitions.
s = @ARGS[0]
r = [0 : #|s|]
partitions = join( r, r ) where {
i = $.0 ; j = $.1
// do not consider trivial one chars
continue( i >= j )
ss = s[ i : j ]
// replace the join with reassignment of item
( (ss ** -1) == ss )
} as { s[$.0:$.1] }
println(partitions)
.. Triple Sum
Count triplets in a collection with sum smaller than a given value. One must read the theory
behind here. Without much ado, one can solve this problem by using the joins :
items = tokens( @ARGS[0] , ’\d+’ ) as { int( $.o ) }
items = sorta(items)
num = int( @ARGS[1], 0 )
r = [ 0 : #|items| ]
results = join(r,r,r) where {
// preserve order
continue( $.0 >= $.1 || $.1 >= $.2 )
sum = items[$.0] + items[$.1] + items[$.2]
sum < num
} as { [ items[$.0] , items[$.1] , items[$.2] ] }
println(results)
.. Pythagorean Triplet
Find if there exists Pythagorean Triplets in an array. That is, given an array of integers, write a
function that returns true if there is a triplet (a, b, c) that satisfies a2 + b2 = c2 . In another word,
find all of them. This is what we find here.
chapter . practical zoom ba
items = tokens( @ARGS[0] , ’\d+’ ) as { int( $.o ) }
items_set = set(items)
r = [ 0 : #|items| ]
results = join (r,r) where {
// preserve order
continue( $.0 >= $.1 )
tot= items[$.0] ** 2 + items[$.1] **2
// note the use of num() function
t = tot ** 0.5 ; t = num(t)
t @ items_set
} as { [ items[$.0] , items[$.1] , t ] }
println(results)
.. Substring as Permutation
Given a string, find whether it has any permutation of another string. For example, given
“abcdefg” and “ba”, it should return true, because “abcdefg” has substring “ab”, which is a
permutation of “ba”.
def perm_exists(s1,s2){
small = s1 ; large = s2
if ( #|s1| > #|s2| ){ small = s2 ; large = s1 }
small_arr = small.toCharArray()
small_set = set(small_arr)
large_len = #|large| ; small_len = #|small|
i = 0
while( i < large_len ){
if ( i + small_len > large_len ) { return false }
continue( large[i] !@ small_set ){ i += 1 }
ss = large[ i : i + small_len - 1]
if ( ss.toCharArray() == small_arr ){ return true }
i += 1
}
return false
}
Note the usage of A == B for the checking of collection A is a permutation of collection B
.. Pivot Partition
Given an unsorted array of integers, you need to return maximum possible n such that the
array consists at least n values greater than or equals to n. Array can contain duplicate values.
Sample input : [1, 2, 3, 4] , output : . Sample input : [900, 2, 901, 3, 1000] , output: .
def pivot_partition(a){
ma = mset(a)
ma = dict(ma) as { [ $.key , size($.value)] }
keys = list( ma.keySet() )
keys = sortd(keys)
greater_eq = 0
i = index(keys) where {
greater_eq += ma[$.o]
greater_eq >= $.o
}
( i > 0 ) ? keys[i] : ’None’
}
. . a s s o rted practical examples
Note the use of body variable. . Observe this behaviour:
x = 0
fold ( [0:10] ) as {
x+= 1
println(x) // goes from 0,1,2,... 9
}
println("But x is... " + x ) // prints 0
One can see that the variable ’x’ was not eventually modified. But repeated iteration of the
fold will preserve the state of the variable.
.. Find all subsequences where Predicate
One problem statement is, given a list l, find all possible sublists such that the sum of elements
in the sublists is a number N . Formally, find the list lN such that:
X
lN = {x | x ⊂ l and y = N}
y∈x
that is, lN ⊂ 2l where 2l is the power list(set) of list l. We use the same idea as Ramanujan
Partition, but this time use the index set as the bitmap . We also generalise the notion of sum
using a generic predicate:
// define the predicate
P = def(a, N ){ sum(a) == N }
def find_sublists(l,P){
L = size(l)
// total no of subsets ( cardinality of power set)
n = 2 ** L
fold( [1:n],set() ) as {
// right bitmap
bit_map = str($.o,2)
items = rfold(bit_map.toCharArray() , list() ) as {
// that is why read from right
continue($.o == ’0’)
/* put items whose indices are to be selected
-ve indices read from right! */
$.p.add(0, l[- $.index - 1] ) ; $.p
}
continue( ! P(items, N ) )
// add them up
$.p.add( items ) ; $.p
}
}
. a s sorted practical examples
This section contains examples which would probably never be asked in any interviews, if
anyone asks the in an interview, please join that firm immediately.
.. Generic Result Comparison
Most of the time, it is of importance that we compare results coming from an older and a newer
system. Both are to be somehow equivalent. Obviously these results are list of complex objects,
which differs with the versions. Thus, the objects which comprise of the old list ol would be
slightly different than that of the new list nl.
chapter . practical zoom ba
Thus, the only way to handle these sort of thing would be using the projection operator. That
is, isolate the set of fields which are equivalent , that would be a list of tuple : Ci = (O Ci ,N Ci )
where O Ci is the old field, while N Ci is the new field. That is really not the most generic way,
but let’s assume it is. Now, it boils down to doing the projection on these :
to = πO C (Oo )
and
tn = πN C (On )
and now, there are lists of it. Thus, now, these two list should be equal. Hence, in ZoomBA, here
is the code one would write :
// old tuple list , generated by projecting old columns
otl = list (ol) as { o = $.o ; str( OC , ’’ ) as { o[$.o] ?? ’’ } }
// new tuple list , generated by projecting new columns
ntl = list (nl) as { o = $.o ; str( NC , ’’ ) as { o[$.o] ?? ’’ } }
// now compare 2 list of strings!
matches = ( otl == ntl )
.. Verifying Filter Results
Sometimes people tend to write imperative code to apply filter on search results. That is, given
the result is a list of objects, all the objects would be yielding true while applying predicate P ().
Thus, formally, a filtered collection F over a collection C is :
∀x ∈ F ; P (x) = T rue and @y ∈ C s.t. P (y) and y < F
and this F ⊆ C. The question is how to test for filtering? Given we already have a predicate P ()
defined :
// the dev code:
Fd = select(C) where { P($.o) }
// thus, this is legal but bad
filtered = (F == Fd)
// instead, we do it the negated way
filtered = ( exists(F) where { ! P($.o) } ) &&
( exists(C - F) where { P($.o) } ) && F <= C
But this has a problem. The solution loops over both F and C. Will there be a way to reduce the
looping? Given C, F are sets, it is easy :
filtered = ( exists(F) where { !P($.o) && $.o !@ C } ) &&
( exists(C - F) where { P($.o) } )
.. Storing Positions of Elements in a String
Given a string where there are numbers and some numbers are repeated, e.g. 13413124...,
design a data structure for it and the data structure should store positions of each number. Such
a problem requires simple data structure, a map with a list as value would do just fine :
. . a s s o rted practical examples
s = "13413124"
d = lfold (s.toCharArray(),dict()) as {
k = int($.o)
if ( k !@ $.p ){ $.p[k] = list() }
$.p[k] += $.i // store the index
}
println(d)
.. Find Largest N : heap()
You are given a large set of integers, which are not sorted. Figure out a method to retrieve the
largest N elements, in Θ(n) run time. For this, we use heap() .
N = 10
l = list([0:100]) as { random(1000) }
// create a max-heap
h = heap(N,false)
lfold (l) as {
h+= $.o
}
println(h)
To create a min-heap, just use the argument as false to heap() function. The first argument is the
heap size.
.. Rational Number Representation
Write a function which, given two integers (a numerator and a denominator), prints the decimal
representation of the rational number “numerator/denominator”. Since all rational numbers
end with a repeating section, print the repeating section of digits inside parentheses; the
decimal printout will be/must be. Examples: (1, 3) = 0.(3) , (2, 4) = 0.5(0) ; (22, 7) = 3.(142857).
chapter . practical zoom ba
def rational(n,d ){
// these are stored in list
digits = list()
// in case there is a loop/recurrence
visited = dict()
// find the integer part
int_part = str(n/d )
// rest is the new numerator
n %= d
// index is there to find the spot for each : n
// where "(" is needed to be inserted
i = 0
while(n != 0 ){
n = n * 10
while ( n < d ){
// append 0, only when
digits += ’0’
n *= 10
i+= 1
}
break ( n @ visited ){
// found a recurrence
digits.add( visited[n] , ’(’)
digits += ’)’
}
// mark the visit of n
visited[n] = i
// add to the digits
digits += (n/d)
n %= d
i+= 1
}
str (’%s.%s’, int_part , str(digits,’’) )
}
print ( rational(1,2) )
.. Maximum Span of Stock Prices
Given a stock price for some consecutive days, find the maximum span of each day’s stock price.
Span is the amount of days before the given day where the stock price is less than that of given
day. Hence, given the input : [2, 4, 6, 9, 5, 1] the output would be : [−1, 1, 2, 3, 4, −1] The solution
is trivial :
l = [2,4,6,9,5,1]
n = size(l)
result = rfold (l,list()) as {
cur_index = n - $.i - 1
continue(cur_index == 0 )
v = $.o
#(m,M) = minmax([0:cur_index]) where { l[$.0] < l[$.1] }
if ( l[m] < v ){
$.p.add(0, cur_index - m )
}else{
$.p.add(0,-1)
}
$.p
}
// for the first element
result.add(0,-1)
println(result)
. . a s s o rted practical examples
.. Recognising String from Languages
Suppose there is a nice formal grammar from which we need to match strings. Such a formal
grammar (a context free one ), see here for more disucssion, (you should, because this was one
of Google’s question) can be easily made by using bitstream alphabet :
Σ = {0, 1}
the definition of the language is :
L = {w | w = 0n 1n ; n ∈ N}
Now, we need to write a function f such that, it accepts a string from that language L, and
rejects any other string. How do we envision such a thing? We know there must be abstraction
of a stack to solve it, because it is context free. The abstraction is easy :
// stack based implementation
def in_lang(s){
c_1 = _’1’ ; c_0 = _’0’
len = #|s| ; i = 0
while ( i < len && s[i] == c_1 ){ i +=1 }
if ( i == len ){ return (len == 0 || false) }
count = i
while ( i < len && s[i] == c_0 ){ i += 1 }
if ( i != len ) { return false }
( count* 2 == len ) // return
}
println( in_lang( @ARGS[0] ) )
.. Globally Unique ID
Design a system to return an unique ID for each request. For most of requests, the ID value
should increase as time goes, the system should handle requests per second at least.
Timestamps alone is not valid since there might be multiple requests with same timestamps.
The solution is not that hard, this works perfectly fine :
import java.lang.System as SYS
def GUID(){
s = str( [0:3], ’’ ) as {
l = SYS.nanoTime()
str(l)
}
}
.. Inversions In A Pair of Collections
You are given two integer arrays A and B. 0 ≤ i < len(A) so i is iterator of array A. 0 ≤ j < len(B)
so j is iterator of array B. Find all the pairs (i, j) such that : i < j and A[i] > B[j].
i_a = [0:#|A|]
i_b = [0:#|B|]
inversions = join (i_a,i_b) where {
$.0 < $.1 && A[$.0] > B[$.1]
}
chapter . practical zoom ba
Actually, no explanation needed!
.. Summation of Binary Integers
Given two binary numbers each represented as a string write a method that sums up the
binary numbers and returns a result in the form of binary number represented as a string.
One may assume that input fits in the memory and the input strings are, in general, of dif-
ferent length. Optimize your solution, do not use unnecessary ‘if’ branching. As an example:
sumBinary(’’, ’’) returns 1001010.
In ZoomBA, the solution would be cheating:
def sumBinary(a,b){
i = int(a,2,null) // specify base 2, and default
j = int(b,2,null)
x = i + j
str(x,2)
}
But we decided to un-cheat, and give a slightly less cheat :
bits = { 0 : ’0’ , 1 : ’1’ }
def to_int(a){
lfold (a.toCharArray(), 0 ) as {
$.p = 2 * $.p + int($.o)
}
}
def to_bin_str(a){
r = a % 2
n = a / 2
bin_rep = bits[r]
while ( n > 0 ) {
r = n % 2
n = n / 2
bin_rep = bits[r] + bin_rep
}
bin_rep
}
def sum_binary(a,b){
x = to_int(a)
y = to_int(b)
to_bin_str( x + y)
}
s = sum_binary(@ARGS = @ARGS )
println(s)
Which works out. However, purists would still argue that we cheated, and did not actually sum
it up bit by bit. So, to appease them, as Amazon ordered :
. . a s s o rted practical examples
// ABC : RC
bin_add_logic = { ’000’ : ’00’ ,
’010’ : ’10’ ,
’100’ : ’10’ ,
’110’ : ’01’ ,
’001’ : ’10’ ,
’011’ : ’01’ ,
’101’ : ’01’ ,
’111’ : ’11’ }
// when carry is 0 append empty...else...1
carry_string = { ’0’ :’’ , ’1’ : ’1’ }
def bin_add(a,b){
size_a = #|a|
size_b = #|b|
#(m,M) = minmax(size_a,size_b)
// pad both of them up to max : M with 0
a = ’0’ ** (M - size_a) + a
b = ’0’ ** (M - size_b) + b
carry = ’0’
tot = fold ( [M-1:-1] , ’’ ) as {
key = a[$.o] + b[$.o] + carry
add_result = bin_add_logic[key]
carry = str(add_result[1])
$.p = add_result[0] + $.p
}
tot = carry_string[carry] + tot
}
#(a,b) = @ARGS
println ( bin_add(a,b) )
.. Generating System Response Curve
Most of the performance testing done are totally wrong, because most of these rely on a single
metric : average, and if someone is lucky, then standard deviation. But that is wrong way to
look at it. The right way is using system response curve, which is a pdf. Thus, the algorithm to
generate such a curve from log files is this :
. Start with a bucket size of of a time slice ∆T .
. A response time tr belongs to bucket Bk iff k∆T ≤ tr < (k + 1)∆T .
. Count all the response times within each bucket Bk , and divide it by total no of response,
store it to each bucket
. Print all the buckets Bk with the fraction frequency of each bucket.
This, when plotted, with a sufficient thin ∆T produces the nice distribution diagram of the
systems response. The code for this is minimal in ZoomBA :
data = lines(’log_file.txt’,true)
data = list(data) as { float( $.o ) }
#(m,M) = minmax(data)
print(’Min : %f , Max : %f\n’, m, M )
bucket_size = 0.001
stat = mset(data) as { int ( ($.o - m )/ bucket_size ) }
keys = list ( stat.keySet() )
keys = sorta( keys )
T = float(size(data))
print(’Bucket\tTiming’)
lfold(keys) as {
printf(’%f\t%f%n’ , m + ($.o + 1) * bucket_size ,
size(stat[$.o]) * 100.0 / T )
}
chapter . practical zoom ba
.. Shuffling in a Media Player
If I am designing a media player and I want to store songs and play them in random order,
how will select the next song to play in a way which prevents the same song being played in
consecutive turn?
// you get the idea
songs = { 1 : ’Track1’ , 2 : ’Track2’ , 3 : ’Track3’ }
// shuffles and plays songs
def play_songs_after_shuffle( songs ){
keys = list( songs.keySet())
// while at least one swap did not happen
shuffle(keys)
lfold(keys) as { println ( songs[$.o] ) }
}
play_songs_after_shuffle( songs )
.. Ordering Thread Execution
Print series 010203040506... using multi-threading. st thread will print only nd thread will
print only even numbers and rd thread print only odd numbers. Here is how we do it:
// use global to lock over #atomic
$state = 0
// do state management
def function(exec_str, cur_state , next_state ){
n = 1
while(true){
// wait for the state to be mine
while( state != cur_state );
#atomic{
// crown jewel of ZoomBA is currying
println( #‘#{exec_str}‘ ) ; $state = next_state ; n+= 1
}
}
}
// spawn these children
t0 = thread() as { function(’0’ , 0 , 1) }
t1 = thread() as { function(’2*n - 1’ , 1 , 2) }
t2 = thread() as { function(’2*n’ , 2 , 0) }
tc = thread()
// a bit of wait to display results
tc.sleep(300)
// do not care...
.. Asynchronous Computation
Suppose, we are trying to call a web api, which returns large chunks of data, and we can not call
it synchronously. Therefore, we need to ensure that after the method was successfully executed,
there is a callback method that should get called. This problem is trivial in ZoomBA and here is
how to get it done :
. . a s s o rted practical examples
var done = false
def asynch_call(url){
read(url)
}
def call_back(event){
print(’I am done reading’)
if ( empty(event.error ) ){
printf(’Execution : OK, Result is %n %s %n’, event.result )
}else{
eprintf(’Execution : FAILED, Error is %n %s %n’, event.error )
}
done = true
}
// register call back
asynch_call.after += call_back
thread() as { asynch_call( ’http://www.redit.com’ ) }
// current thread
tc = thread()
while( !done ){
tc.sleep(1000)
}
Note that we are using the eventing mechanism.
.. Computation of Query
Suppose, the problem is that of generation of queries. As an example, take this query :
Find all the customers who spent > minutes on Page "XYZ" & purchased > items of coffee_X
& gave a review of >.
The POJOs given are :
class PageView {
private String URL;
private String customerID;
private Integer timeSpent;}
class Purchase {
private String productID;
private String customerID;
private Integer itemsPurchased;}
class Review {
private String productID;
private String customerID;
private Integer reviewPoints;}
How does one code it? Here is the query:
chapter . practical zoom ba
page_url = pages[’XYZ’]
customer_ids_pv = set (page_views) as {
continue ( ! ( $.URL == page_url &&
$.timeSpent > 2 ))
$.customerID }
product_id = products[’coffee_X’]
customer_ids_pur = set(purchases) as {
continue( ! ( $.customerID @ customer_ids_pv &&
$.productID == product_id &&
$.itemsPurchased > 2 ))
$.customerID }
customers = set (reviews) {
continue( ! ( $.customerID @ customer_ids_pur &&
$.productID == product_id &&
$.reviewPoints > 3 ))
$.customerID }
lfold(customers) as { println( $.o ) }
.. Generating Strings
Given a string (for example: “a?bc?def?g”), write a program to generate all the possible strings
by replacing ‘?’ with ‘’ and ‘’.
Example: Input : a?b?c?
Output: abc, abc, abc, abc, abc, abc, abc, abc.
Observe that, given there are are n question marks (?), the problem is that of generating binary
integers from to 2n − 1, all should be padded up with ‘’s to make it n digits. Then, look at the
occurrence of the bits in position for the question mark, and replacing them. Thus, a solution is
:
def generate_strings(template){
ta = template.toCharArray()
n = sum (ta , 0) as { ( $.o == ’?’ ) ? 1 : 0 }
p = 2**n
lfold ([0:p]) as {
s = str($.o, 2)
s = ’0’ ** ( n - #|s| ) + s
count = 0
r = lfold( ta, ’’) as {
if ( $.o == ’?’ ){
$.p += s[count]
count += 1
}else{
$.p += $.o
}
$.p
}
println(r)
}
}
The use of such a program is obvious for anyone who wants to make a finite decision game.
.. First Unique URL
Given a very long list of URLs, find the first URL which is unique ( occurred exactly once ).
. . a s s o rted practical examples
existing = set()
i = index ( file( ’urls.txt’ ) ) where {
u = $.o
continue( u !@ existing ){ existing += u }
true }
println( urls[i] )
.. Conditional Assignment : Casing
You are given four integers ‘a’, ‘b’, ‘y’ and ‘x’, where ‘x’ can only be either zero or one. Your task
is as follows: If ‘x’ is zero assign value ‘a’ to the variable ’y’, if ‘x’ is one assign value ‘b’ to the
variable ’y’. You are not allowed to use any conditional operator (including ternary operator).
Follow up: Solve the problem without utilising arithmetic operators ‘+ - * /’.
This is one of the founding stone of the declarative paradigm, therefore, it qualifies as a
practical problem. The solution, of course can be done using what we explained in chapter :
conditionals = { 0 : a , 1 : b }
y = conditionals[x]
But, observe that hash is complex structure, we can simplify the problem by :
conditionals = [a, b ]
y = conditionals[x]
And that works perfectly well.
.. Parking Rearrangement Problem
Suppose there is a parking with slots named as 1, 2, ..., n with a free slot designated as 0. How
can one rearrange the cars from a source configuration to a target configuration? The problem
is that every swapping of the cars must be via the empty slot. For example, if src is [1, 3, 0, 2, 4],
then to move a car 1 to the position of 3, one must go through the 0’th slot :
[1, 3, 0, 2, 4] → [1, 0, 3, 2, 4] → [0, 1, 3, 2, 4]
The code is as follows:
chapter . practical zoom ba
def park(i,src,tgt, map_src,map_tgt){
pos_fut = map_tgt[i]
j = src[pos_fut]
if ( j == 0 ) return 0
// move j out to 0 position
pos_0 = map_src[0]
src[pos_fut] = 0
src[pos_0] = j
// store new address
map_src[j] = pos_0
println(str(src))
// now move i to that position
pos_i = map_src[i]
src[pos_i] = 0
src[pos_fut] = i
map_src[i] = pos_fut
map_src[0] = pos_i
println(str(src))
j
}
def transform(src,tgt){
println(str(src))
map_src = dict(src) as { [$.o , $.i ] }
map_tgt = dict(tgt) as { [$.o , $.i ] }
visited = set()
i = 1
while( i !@ visited ){
visited += i
i = park(i,src,tgt,map_src,map_tgt )
}
// out of here, swap the 0 and the last no now
pos_0 = map_src[0]
next = tgt[pos_0]
next_pos = map_src[next]
src[next_pos] = 0
src[pos_0] = next
println(str(src))
println(str(tgt))
}
src = [ 1, 3, 0, 2, 4 ]
tgt = [ 3, 2, 4, 1, 0]
transform(src,tgt)
.. Interleaving of Strings
Given two strings, print all the inter leavings of the two strings. Interleaving means that
the if B comes after A , it should also come after A in the interleaved string. As an example,
with AB and CD we have : [ABCD, ACBD, ACDB, CABD, CADB, CDAB]. This has application :
DNA cross and sequencing. The solution is clearly non optimal - and must use grammar and
language generators to generate the specific strings in question, but the solution displays the
awesomeness of ZoomBA, so it is presented here.
. . a s s o rted practical examples
def in_order(s,arr){
len = #|s|
j = lfold(arr, 0 ){
break( $.p == len )
continue( s[$.p] != $.c[ $.i ] )
$.p +=1
}
(j == len)
}
s1 = "AB" ; s2 = "CD"
tot = s1 + s2
arr = tot.toCharArray()
arg = list{ arr }( [0 : #|arr| ] )
results = join ( @ARGS = arg ) where {
( in_order(s1,$.o) && in_order(s2,$.o)
} as { str($.o,’’)}
println(results)
A better strategy would be thinking about what interleaving would mean, and that brings
to the newer problem of finding all possible partitions of a string. What is a partition of a
string? Given a string S, a partition of size k is a k-tuple of substrings < s1 , s2 , ..., sk > such that
: S = s1 s2 ...sk , and none of the si is empty string. Thus, given a string aba, possible partitions
would be : [a, b, a], [ab, a], [a, ba]. This is very close the Ramanujan Partition Problem, and the
code to solve it shows why :
def partition_string(s,bi){
len = #|s|
def seed : { start : 0, l : list() }
seed = lfold ([1:len] , seed ) as {
if ( bi[$.o -1] == ’1’ ){
$.p.l += s[start : $.o-1]
$.p.start = $.o
}
$.p
}
l = seed.l
l += s[start:len-1]
}
def generate_partitions(s){
N = #|s|
n = 2 ** (N - 1)
p = lfold ([1:n] , list() ) as {
bi = str($.o, 2)
bi = ’0’ ** ( N - #|bi| - 1 ) + bi
$.p.add( partition_string(s,bi) )
$.p
}
}
The function generate_partitions generates partitions for a string. Now, how this problem is
related to interleaving problem? Start with a partition p1 from a string S1 . This partition
suppose has n1 substrings. Thus, there are n1 gaps available to interleave partitions from the
second string S2 .
Start with an example : given string abc and partition [a, b, c], and any other string to
interleave, we can choose to exploit the inner positions shown as ∗ as follows:
∗a ∗ b ∗ c∗
chapter . practical zoom ba
Thus, the interleaving partitions required can be of sizes n1 , n1 + 1, n1 − 1. Thus, interleaving
between partition p1 of size n1 of string S1 , and p2 of size n2 of string S2 is only possible if the
partition sizes are not differing by more than , hence yielding the condition :
|n1 − n2 | < 2
and this, is the join condition! After this, what we need to do? We know, if the lengths differ,
then we need to pick the smaller, and fit that into the larger partition. We will call this function
insert(large,small). Now, if the sizes are the same, there are two different partitions from strings
“abc” and “ABC” :
AaBbCc and aAbBcC
and we would call it a function place(left,right). Thus, how these functions look?
def insert(large, small){
lfold([1:#|large|], large[0]) as {
$.p += small[ $.o - 1 ] + large[$.o]
}
}
def place(left, right){
lfold ([1:#|right|] , left[0] ) as {
$.p += right[ $.o - 1 ] + left[$.o]
} + right[-1]
}
They should not really be functions, but then it introduces the awesome notion called readability.
That is not entirely fad, there are meaning to the madness. Observe now, thanks to all these
modularisation of the source code, the final, interleaving code is now a piece of cake, or rather
very close to what is one:
def interleave(s1,s2){
partition_1 = generate_partitions(s1)
partition_2 = generate_partitions(s2)
join (partition_1,partition_2) where {
#(p1,p2) = $.o // assign
len1 = #|p1| ; len2 = #|p2|
continue( #|len1 - len2 | > 1 )
if ( len1 < len2 ){
println ( insert(len2, len1 ) )
} else if ( len2 < len1 ){
println ( insert(len1, len2 ) )
}else {
println ( place(p1,p2 ) )
println ( place(p2,p1 ) )
}
false // do not add them at all!
}
}
and thus, we end this section.
chapter 12
Java Co n ne c t ivity
JVM is the powering force behind ZoomBA. This chapter illustrates various usage scenarios
where ZoomBA can be embedded inside a plain Java Program.
. h o w to embed
.. Dependencies
In the dependency section (latest release is . ) :
<dependency>
<groupId>org.zoomba-lang</groupId>
<artifactId>zoomba.lang.core</artifactId>
<version>0.1-beta5-SNAPSHOT</version>
</dependency>
That should immediately make your project a ZoomBA supported one.
.. Programming Model
ZoomBA has a random access memory model. The script interpreter is generally single threaded,
but each thread is given its own engine to avoid the interpreter problem of GIL.
The memory comes in two varieties, default registers, which are used for global variables.
There is also this purely abstract ZContext type, which abstracts how local storage gets used.
This design makes pretty neat to integrate with any other JVM language, specifically Java.
Here is an example embedding.
.. Example Embedding
One sample embedding is furnished here :
chapter . java connectivi t y
/* How to use ZoomBA Natively, i.e. not using JSR-232 */
import zoomba.lang.core.interpreter.ZContext;
import zoomba.lang.core.interpreter.ZContext.*;
import zoomba.lang.core.interpreter.ZInterpret;
import zoomba.lang.core.interpreter.ZScript;
import zoomba.lang.core.operations.Function;
import zoomba.lang.core.types.ZException;
import zoomba.lang.core.types.ZTypes;
//... can be more...
public static void dance(String[] args) {
String file = args[0];
ZScript zs = null;
try {
zs = new ZScript(file, null);
}catch (Throwable t){
if ( t.getCause() instanceof ZException.Parsing ){
ZException.Parsing p = (ZException.Parsing)t.getCause();
System.err.printf("Parse Error: %s\n", p.errorMessage );
System.err.printf("Options were : %s\n", ZTypes.string(p.
correctionOptions) );
}else{
System.err.printf("Error in parsing due to : %s\n", t.getCause() );
}
System.exit(2);
}
Object[] scripArgs = ZTypes.shiftArgsLeft(args);
Function.MonadicContainer mc = zs.execute(scripArgs);
if (mc.isNil()) {
// handle when return is ... Nil
} else {
if (mc.value() instanceof Throwable) {
Throwable underlying = (Throwable) mc.value();
if ( underlying instanceof ZException){
if ( underlying instanceof ZException.ZTerminateException ){
System.exit(3);
}
System.err.println(underlying);
zs.consumeTrace(System.err::println);
System.exit(4);
}
if ( underlying instanceof StackOverflowError ){
zs.consumeTrace(System.err::println);
System.err.println("---> Resulted in ’Stack OverFlow’ Error!");
System.exit(4);
}
underlying.printStackTrace();
System.exit(1);
}
}
System.exit(0);
}
. p r ogramming zoomba
Because it is JSR- compliant you can do this :
. . e x t e nding zoomba
public void javaxScripting() throws Exception {
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine engine = scriptEngineManager.getEngineByName("zoomba");
assertNotNull(engine);
Object result = engine.eval("2+2");
assertEquals(4,result);
Bindings bindings = engine.createBindings();
bindings.put("x", 2 );
bindings.put("y", 2 );
result = engine.eval("x+y", bindings);
assertEquals(4,result);
ScriptContext scriptContext = engine.getContext();
scriptContext.setAttribute("x", 2, ScriptContext.ENGINE_SCOPE );
scriptContext.setAttribute("y", 2, ScriptContext.GLOBAL_SCOPE );
result = engine.eval("x+y");
assertEquals(4,result);
CompiledScript compiledScript = ((Compilable)engine).compile("x+y");
assertEquals( engine, compiledScript.getEngine());
result = compiledScript.eval(bindings);
assertEquals(4,result);
// function invoke ?
engine.eval("def add(a,b){ a + b }",scriptContext);
result = ((Invocable)engine).invokeFunction("add", 2, 2);
assertEquals(4,result);
// method invoke ?
Object zo = engine.eval(new StringReader("def ZO{ def add(a,b){ a + b } } ;
new(ZO) ") ,scriptContext);
assertNotNull(zo);
assertTrue(zo instanceof ZObject);
result = ((Invocable)engine).invokeMethod(zo,"add", 2, 2);
assertEquals(4,result);
// now attributes stuff
assertEquals( 2, scriptContext.getScopes().size());
assertNotNull(scriptContext.getAttribute("x"));
final int scope = scriptContext.getAttributesScope("x");
assertEquals(ScriptContext.ENGINE_SCOPE , scope);
assertNotNull(scriptContext.getAttribute("y", ScriptContext.GLOBAL_SCOPE));
scriptContext.removeAttribute("y", ScriptContext.GLOBAL_SCOPE);
assertNull(scriptContext.getAttribute("y", ScriptContext.GLOBAL_SCOPE));
assertNull(scriptContext.getAttribute("y"));
assertEquals(-1, scriptContext.getAttributesScope("y"));
// now let’s eval a script... from external file
zo = engine.eval("@samples/test/date.zm",scriptContext);
assertNotNull(zo);
compiledScript = ((Compilable)engine).compile("@samples/test/date.zm");
assertNotNull(compiledScript);
engine.put("y",10);
assertEquals(10,engine.get("y"));
}
. e x tending zoomba
There are two extension points for Java developers who are going to make their classes and
functions ZoomBA ready.
.. Implementing Named Arguments
If one wants to implement a method which would mix properly with ZoomBA named arguments,
then one must accept a Java Map, whose keys are the name of the parameters while values are
the values passed.
Thus, once we know that the argument is Map, we can extract the value, and do the due
diligence. Here is example from language itself:
chapter . java connectivi t y
.. Using Anonymous Arguments
If one wants to implement the anonymous blocks like almost all the ZoomBA functions do,
one needs to expect the first argument to be an AnonymousP aram which is also found in the
Interpreter.java. The standard way to process the argument can be said as :
Bibliography
[] Donald E. Knuth, The Art of Computer Programming . Addison-Wesley, .
[] Alfred V. Aho, Monica S. Lam, Ravi Shethi , Jeffery D. Ullman, Compilers: Principles,
Techniques, and Tools . Prentice Hall, .
[] Kanglin Li, Mengqi Wu, Sybex, Effective Software Test Automation: Developing an Automated
Software Testing Tool . Sybex , .
[] Guido van Rossum, Fred L. Drake, Python Language Reference Manual PythonLabs .
[] Martin Odersky, The Scala Language Specification Version . PROGRAMMING METHODS
LABORATORY EPFL, SWITZERLAND, .
bibliograph y
Index
anonymous comparator , multiset ,
atomic : block , number : absolute ,
atomic : block : reverting states , oop : $ ,
binary read file , oop : $$ ,
body variable, oop : constructor ,
ceil() , oop : fields ,
clock : error , oop : methods ,
coding guidelines , oop : operator overloading,
DataMatrix : key() , oop : static fields ,
DataMatrix : matrix(), operator : ~,
examples : anagrams , operator : division over dictionary ,
examples : competitive array, operator : regex : match ,
examples : ex seating problem , operator : regex : not match ,
examples : list closeness , pid : current process ,
examples : Scramble , Power Collection : sequences() ,
examples : scramble , pqueue() Priority Queue,
examples : shuffling in media player , round() ,
examples : sublist predicate problem , sign() ,
examples : sublist sum problem , str : collections ,
examples : substring as permutation , str : replacing toString() ,
file() , table comparison ,
floor() , table comparison : key ,
function : arbitrary no. of args , table comparison : key : non unique ,
function : composition operation, table comparison : O(n) ,
guard block , timezones ,
heap() , Von Neumann Architecture,
ystr() : yaml ,
is() ,
ZoomBA : about , ix
java connectivity : function : anonymous
ZoomBA : history , ix
argument ,
ZoomBA : thanks , x
java connectivity : functions : named argu-
ment, apache jexl, ix
java connectivity : programming model , arithmetic : chorono,
assert(), panic(), test() ,
java connectivity : sample embedding , assignment,
join() : reassignment of item , atomic,
json string pretty print ,
jstr() : json , bitmap,
log() number , bool(),
matrix() , bye(), ,
ind e x
case, examples : binary integer summation ,
cat, examples : casing ,
Chatin Solomonoff Kolmogorov Complexity, examples : consecutive element subset ,
examples : find perfect squares,
chrono : subtraction, examples : first unique url,
clock, examples : generating strings ,
collection : slicing , examples : generating system response curve
collections : in order, from logs,
collections : reverse, examples : generic result comparison,
Combinations, comb(), examples : GUID ,
comments, examples : inversions in a pair of collections,
Comprehensions,
Comprehensions : dict(), examples : max span of stock prices,
Comprehensions : list() , examples : maximal longest substring,
Comprehensions : mset(), group(), examples : maximum product with ascend-
Comprehensions : set(), ing subsequence ,
Conditionals, examples : maximum substring with no du-
Conditionals : else, plicates ,
Conditionals : else if, examples : minimal sum of integers in digit
Conditionals : if, array ,
conditions : avoiding, examples : next higher permutation,
currying : back tick operator, examples : ordering threads,
currying : referencing, examples : parking rearrangement,
currying : reflection, examples : parsing grammar ,
examples : partition of palindromes ,
DataMatrix, examples : partitions of string,
DataMatrix : aggregate() , examples : permutation graph,
DataMatrix : c() , examples : positions of elements in a string ,
DataMatrix : columns,
DataMatrix : data access by column , examples : pythagorean triplet,
DataMatrix : data access by row , examples : query computation,
DataMatrix : project, c() , examples : ramanujan problem,
DataMatrix : rows, examples : recursive range sum,
DataMatrix : select condition , examples : representation of rational,
DataMatrix : select transform , examples : reverse words ,
DataMatrix : select, select() , examples : string from signed integer ,
DataMatrix : tuple() , examples : sum of permutations,
design, examples : triple sum,
dict : order , examples : verifying filter results,
dict : sorted ,
dict(), factorial,
FizzBuzz : conditional,
empty(), FizzBuzz : declarative,
enum(), FLOAT(),
Equivalence Class Partitioning, float(),
error(), Flow Control : break,
event : args, Flow Control : continue,
event : error, Flow Control : continue, break ,
event : result, Flow Control : usage of continue,
event : when, fold : factorial,
example : interleaving of strings, fold : Fibonacci,
examples : asynchronous computation, fold : index,
index
fold : min,max, import : ZoomBA Script,
fold : rindex, index(),
fold : select, INT(),
fold : set, int(),
fold : sum,
fold functions, join(),
fold(), lfold(),rfold(), json,
format : date and time, json : jstr() ,
function : __args__ , JSONPath,
function : anonymous,
function : argument overwriting, list(),
function : as parameter, lambda , logic : nd order,
function : closure, logic : higher order,
function : composition, Loops,
function : default parameters, Loops : for,
function : eventing , Loops : for, conditioned,
function : eventing : after, Loops : for, range,
function : eventing : before, Loops : while,
function : excess parameters,
function : explicit, match,
function : implicit, maven,
function : in a dictionary, Minimum Description Length,
function : nested, partial, minmax(), ,
function : Peano Axioms, multiple assignment,
function : recursion, multiple assignment : splicing left, right,
function : unassigned parameters, Multiple Collection Comprehension : join(),
functional style,
functions, multiple return : error,
functions : anonymous, mutability,
functions : calling,
namespace,
functions : define,
namespace : my,
functions : named args ,
new(),
generic numeric conversion, num(),
global variables,
oop : def,
Gödelization,
oop : new(),
hash : base , open(),
hash(), open() : open modes,
heap(), open() : reading,
Hello, World, open() : writing,
operator : === ,
identifiers, operator : at ,
import, operator : cardinality ,
import : enum, operator : compare, chrono ,
import : function call, operator : division on dictionary ,
import : inner class, inner enum, operator : isa ,
import : java, operators,
import : load(), operators : Arithmetic,
import : relative, operators : Comparison,
import : script as function, operators : Logical,
import : static field, operators : Ternary,
ind e x
partial : $.p , Set Algebra : Subset Equals,
partition(), Set Algebra : Subset,Proper,
permutation, Set Algebra : Superset Equals,
Permutations, perm(), Set Algebra : Superset,Proper,
poll(), Set Algebra : Symmetric Difference,
predicate, Set Algebra : Union,
Predicate Logic, Set Operations : Collection,
Predicate Logic : Find : find() , Set Operations : there exist : Collections,
Predicate Logic : for all : select() , Set Relations : Collection,
Predicate Logic : there exist : exists() , set(),
Predicate Logic : there exist : index() , shuffle(),
Predicate Logic : there exist : rindex() , Sieve of Eratosthenes : declarative,
Predicate Logic : there exists, Sieve of Eratosthenes : imperativel,
print(), printf(), eprintf(), eprintln() , size(),
project, size() : integers ,
python, ix SOAP,
sorta(),
random() : random value with types , sortd(),
random() : select many, sorting,
random() : select one, sorting : custom comparator ,
random.num(), random.string() , str : float,double,DEC,
range, str : int,INT,
range : char , str : time ,
range : chrono interval format, str(),
range : date, Sublime Text,
range : symbol, sublist predicate,
range(), sum(),
range: list(), reverse(), inverse() , system(),
range: xrange ,
read(), tenet : good code,
read() : http get, thread(),
read() : http get : url generation , time,
read() : url timeout , time(),
reflection : field access, tokens(),
reflection : Nested field access, Tuple Operation : Starts With, Ends With,
reflection : property bucket,
regular expressions, Turing Machine,
relation between exists and forall, type(),
reserved words,
Vim,
restful api : get,
web get() post() ,
scala, web open(),
Searching for a tuple, write(),
select(), write() : file ,
send(),
seq(), xml,
set : order , xml : attribute,
set : sorted , xml : element(),
Set Algebra, xml : elements(),
Set Algebra : Equals, xml : encoding,
Set Algebra : Intersection, xml : exists(),
Set Algebra : Minus, xml : json,
index
xml : json and yaml string,
xml : pojo,
xml : xpath(),
xml : xpath() default ,
xml(),
xpath(),
yaml : string, file, numerics,
yaml : ystr() ,
ZoomBA : philosophy,
ZoomBA : repl,
ZoomBA : tenets,
You might also like
- Test Bank For Big Java Early Objects 6th Edition by HorstmannNo ratings yetTest Bank For Big Java Early Objects 6th Edition by Horstmann29 pages
- Java Multithreading Interview Questions And AnswersFrom EverandJava Multithreading Interview Questions And AnswersNo ratings yet
- getting started with java 1st Edition Jonathan Jackson - Download the ebook and start exploring right away100% (1)getting started with java 1st Edition Jonathan Jackson - Download the ebook and start exploring right away47 pages
- [Ebooks PDF] download (Ebook) getting started with java by Jonathan Jackson ISBN 9781430227847, 1430227842 full chapters100% (1)[Ebooks PDF] download (Ebook) getting started with java by Jonathan Jackson ISBN 9781430227847, 1430227842 full chapters77 pages
- Introduction To Programming Using Java, Part IINo ratings yetIntroduction To Programming Using Java, Part II374 pages
- Introduction To Computer Science in C Sharp Release 2No ratings yetIntroduction To Computer Science in C Sharp Release 2252 pages
- Contents at A Glance: Assessment Tests LixNo ratings yetContents at A Glance: Assessment Tests Lix19 pages
- Introduction To Programming Using Java: Version 5.0, December 2006No ratings yetIntroduction To Programming Using Java: Version 5.0, December 2006699 pages
- Introduction To Programming Using Java - TextbookNo ratings yetIntroduction To Programming Using Java - Textbook790 pages
- Introduction To Programming Using Java by David EckNo ratings yetIntroduction To Programming Using Java by David Eck734 pages
- Ankit Mahato - Learn Python 3-EdPunk (2022)No ratings yetAnkit Mahato - Learn Python 3-EdPunk (2022)149 pages
- Basics of Python Programming: A Quick Guide for BeginnersFrom EverandBasics of Python Programming: A Quick Guide for BeginnersNo ratings yet
- Beyond the Basic Stuff with Python: Best Practices for Writing Clean CodeFrom EverandBeyond the Basic Stuff with Python: Best Practices for Writing Clean CodeNo ratings yet
- Mastering Python: A Comprehensive Crash Course for BeginnersFrom EverandMastering Python: A Comprehensive Crash Course for BeginnersNo ratings yet
- Java Hibernate Cookbook: Over 50 recipes to help you build dynamic and powerful real-time Java Hibernate applicationsFrom EverandJava Hibernate Cookbook: Over 50 recipes to help you build dynamic and powerful real-time Java Hibernate applicationsNo ratings yet
- Java Core Interview in Australia. Questions and Answers. Tech interviewer’s notesFrom EverandJava Core Interview in Australia. Questions and Answers. Tech interviewer’s notesNo ratings yet
- Re-Thinking Software As Engineering: Why This DocumentNo ratings yetRe-Thinking Software As Engineering: Why This Document21 pages
- Spotify - Large Scale, Low Latency, P2P Music-on-Demand StreamingNo ratings yetSpotify - Large Scale, Low Latency, P2P Music-on-Demand Streaming10 pages
- Understanding Document For Update The ZISP6UPHR ProgramNo ratings yetUnderstanding Document For Update The ZISP6UPHR Program15 pages
- Reviewer in Operations Management & TQM, MidtermsNo ratings yetReviewer in Operations Management & TQM, Midterms6 pages
- Integrate Cisco Intersight Managed Cisco UCS X - SeriesNo ratings yetIntegrate Cisco Intersight Managed Cisco UCS X - Series44 pages
- Guide From Base Install For Fully Unattended Windows Installs Using TFTPD32No ratings yetGuide From Base Install For Fully Unattended Windows Installs Using TFTPD3223 pages
- CS 389 - Software Engineering: Lecture 2 - Part 2 Chapter 2 - Software ProcessesNo ratings yetCS 389 - Software Engineering: Lecture 2 - Part 2 Chapter 2 - Software Processes26 pages
- Integrated Remote Tap Changer Module Model: iRTM-05: BangaloreNo ratings yetIntegrated Remote Tap Changer Module Model: iRTM-05: Bangalore2 pages
- Infineon-AN2008 03 Thermal Equivalent Circuit models-AN-v1.0-en PDFNo ratings yetInfineon-AN2008 03 Thermal Equivalent Circuit models-AN-v1.0-en PDF10 pages
- Approval: Design and Implementation of Single Phase Pure Sine Inverter100% (1)Approval: Design and Implementation of Single Phase Pure Sine Inverter59 pages
- Automatic Purchase Order Creation During Goods Receipt 1707405037No ratings yetAutomatic Purchase Order Creation During Goods Receipt 170740503714 pages
- Hands-On Labs For Identity and Access Management (IAM) :channelsNo ratings yetHands-On Labs For Identity and Access Management (IAM) :channels1 page
- The Impact of Technology On Modern Society and The Implications For The FutureNo ratings yetThe Impact of Technology On Modern Society and The Implications For The Future3 pages