• Syntax:

try <expr>
catch
<triple pattern> -> <expr>
end

where the triple is:

• symbol

• message

• stacktrace

• Mapping of built in errors, such as match error, or bad argument error.

• match exception

• exceptions in promises

• allow cattching _

Ability to run system commands.

Syntax

system ["ls", "-al"]

Pipes

Allow redirecting input/output

(output, err_output) = input |> system []
(output, err_output) = system [] <| input

Or directly pipe system commands without language involvement

system [] |> system []

This feature allows importing and using modules.

Syntax

Calling a function from a module:

package.Module.function arg1 arg2

Functionality

let Module = package.Module in <expr>

Behaviour

Module call syntax locates the module from the cache or file system location, makes sure it's parsed and cached.

Module call syntax is to be extended in the future to allow reading a library manifest file (to be defined) and import module from specified library version/location.

• tuples represented as arrays of objects (this wouldn't allow for specific tuple extensions such as FileTuple)
• rewrite BinaryOperationNode using Specialization
• see if operations with constants can be be calculated in the parser (1 +2)
• check lambda lifting. Lift lambdas into non-closures unless necessary, so stack doesn't have to be restored when it is pure function
• check if lambdas capture any variables, if not, avoid materializing stack
• avoid using java collections in pattern matching
• allow let expression to be truly concurrent
• make sure promises are unwrapped whenever possible before calling map
• see if TruffleBoundary can be removed from FrameSlotAliasNode and FrameSlotAliasNode and AnyValueNode
• make module/function cache indexed by Seq, not String
• cache resolved dependencies in the PatternLetNode

• make sure you can't assign a proper function in let, only lambda
• package import uses slash, make sure division works fine too
• single letter identifiers
• end after case
• end after catch
• end after do
• backticks
• operators precedence

Algorithm: http://cyan4973.github.io/xxHash/
Java impl: https://github.com/OpenHFT/Zero-Allocation-Hashing
Might be useful as well: https://create.stephan-brumme.com/xxhash/

• simple types
• tuple
• sequence
• let expression
• function patterns
• lambdas
• guards
• non-linear patterns
• reverse sequence
• multiple head / tails
• combining head and tail in a single pattern
• dict
• modules

• multiple definitions of same functions, but different number of args
• binary operations
• nested case
• functions equality
• calling dynamic modules
• async modules
• string escape sequences
• unicode strings
• identity 5+3
• non-linear patterns in function definition + currying
• make sure stdlib functions and modules cannot be overridden
• pass yatta seq/dict/tuple to Java::new

Expose https://docs.oracle.com/en/java/javase/11/docs/api/java.net.http/java/net/http/HttpClient.html

Syntax

do
   res = whatever
   just_sideeffect
end

• getpid
• get_env
• args

Respect YATTA_PATH env variable for loading modules

Features:

• history
• incomplete input handling
• autocomplete

See:

• https://github.com/oranoran/antlr4-autosuggest
• https://github.com/jline/jline2/

Bitwise Complement () –
This operator is unary operator, denoted by ‘’. It returns the one’s compliment representation of the input value, i.e, with all bits inversed, means it makes every 0 to 1, and every 1 to 0.
For example,
a = 5 = 0101 (In Binary)

Bitwise Compliment Operation of 5

~ 0101

1010 = 10 (In decimal)
Note – Compiler will give 2’s complement of that number, i.e., 2’s compliment of 10 will be -6.

arithmetic

DONE

bitwise

DONE

• and = a & b
• or = a | b
• xor = a ^ b
• not = ~a
• leftShift = a << b
• signPropRightShift = a >> b
• zeroFillRightShift = a >>> b

logical

DONE

• and = expr && expr
• or = expr || expr
• not = !expr

sequence

DONE

• el in seq
• seq join = list ++ list
• seq prepend = el :> list
• seq append = list <: el

dict

DONE

• key in dict
• d < t | test whether every key in d is in t - proper
• d >= t | test whether every key in t is in d
• d < t | test whether every key in d is in t - proper
• d >= t | test whether every key in t is in d
• d | t | new set with elements from both s and t
• d & t | new set with elements common to s and t
• d ++ (k, e) | new dictionary with element e
• d -- t | new dictionary with keys in d but not in t
• d ^ t | new dictionary with keys in either s or t but not both

set

DONE

• el in set
• s < t | test whether every element in s is in t - proper
• s >= t | test whether every element in t is in s
• s < t | test whether every element in s is in t - proper
• s >= t | test whether every element in t is in s
• s | t | new set with elements from both s and t
• s & t | new set with elements common to s and t
• s ++ e | new set with element e
• s -- t | new set with elements in s but not in t
• s ^ t | new set with elements in either s or t but not both

pipeline

DONE

• |> and <|

Syntax: |> and <|

• tests

• move timeout from Time module to global functions
• timeout must accept a promise, yet it cannot, because promises are evaluated before a function is called...

• symbols

TBD similar to Python slices

(async \->{1}) ++ (2) translates to

InvokeNode{functionNode=IdentifierNode{name='async'}, function=null, argumentNodes=[FunctionNode{name='$lambda-0', cardinality=0, expression=CaseNode{expression=TupleNode{expressions=[]}, patternNodes=[PatternNode{matchExpression=TupleMatchNode{expressions=[]}, valueExpression=SetNode{expressions=[IntegerNode{value=1}]}}]}}]}

https://github.com/yatta-lang/yatta/blob/902c03890440da8891d970c770149251d68f958b/language/src/main/java/yatta/ast/binary/EqualsNode.java#L26

Loaded modules should be cached

• calling Java method
• instantiating a Java class
• exporting Yatta modules to polyglot API
• calling Yatta function from Java/JS
• dealing with Java exceptions inside Yatta
• dealing with Yatta exceptions in Java/JS

Allow not only built in functions but also modules.

Tasks:

• modules implemented in java
• modules implemented in the language
• modules combining both languages
• make sure module names are included in exception stack traces

dispatch.execute when called from a stdlib function bypasses arguments checks in InvokeNode. This is not great

• https://clojuredocs.org/clojure.core/cat
• https://clojuredocs.org/clojure.core/chunk

• Http\Server::handle should be able to handle binary body
• Http\Client should be able to receive binary body

Strings are on the surface represented as lists of characters. Character is a UTF-8 character.

Character represented using java int type.

Other features

• character represented as java int. In the language, it has a dedicated type: 'a'
• multi-line

  "
  The quick brown fox
  jumps over the lazy dog
  "

• interpolation
  "Hello {name}."

• pattern matching

Due to conflict with new syntax introduced in #15, rework module call to:

module::function

• add a docker image for yattanative
• automate deployment to https://hub.docker.com/r/akovari/yatta

• Implemented using tuples, where the first element is the name of the record

• Syntax sugar, derived from tuple syntax, that is removed during parsing

• Records are module scoped

• Declaration syntax:

record Person = (first_name, last_name)

• New record syntax:

let person = Person(first_name = "Adam") # at least one field is required, although it can technically be ()

• Field access syntax:

person.first_name

• Pattern matching syntax:

fun Person(first_name=f, last_name=l) # where f and l are bound to the values of first/last name from that record

fun p@Person # way to access the whole record in pattern matching, similar to sequences for example

• Update record field:

let new_record = old_record(field = value)

Allow pattern matching on strings, such as:

"hello {who}"

:> and <: replace with |- and -| where | is on the seq side

generate <| (Tuple::to_seq val)

this should not require parentheses

Modules for working with time/date and timezones

https://docs.oracle.com/javase/8/docs/jre/api/net/httpserver/spec/com/sun/net/httpserver/HttpServer.html

Introduce a new type of with expression. This expression will allow accessing and manipulating local context variables within the expression in the body of the with expression.

Standard library module will be necessary to allow reading/writing context variables.

Syntax

with <expr1> (as <identifier>)?
<expr2>
end

Usecases

• transaction context
• dict/set hasher, seed

Further considerations

• the context needs to be thread-safe and work across threads whenever necessary (such as calling async)
• the distinction between builtin functions context and user library context (so that for example STM TX id cannot be overridden by the user code - either intentionally or by mistake)

• Seq comprehension:
  [a * 2 | a <- [1, 2]]

• Seq comprehension with a filter:
  [a * 2 | a <- [1, 2] if a > 2]

• Dict comprehension:
  {a = 2 | a <- [1, 2]}

• Dict comprehension with a filter:
  {key = val * 2 | key = val <- {1: 2, 3: 4} if val > 2}

• Set comprehension:
  {a * 2 | a <- [1, 2]}

• Set comprehension with a filter:
  {a * 2 | a <- [1, 2] if a + b > 3}

• open
• close
• read file: binary / text
• read line: binary / text
• write file: binary / text
• seek
• create temp file
• delete file