First-class array support

Multidimensional arrays are the primary data structure of Nial, and much of its standard library is based around their usage and manipulation.

Multiparadigm

Nial allows both Imperative and Functional style programming to be used in conjunction with each other, allowing much more flexible use of its array programming lineage.

New features

Atlases, unification of prefix and infix notation, errors as data and much more.

Function Atlases Imperative support First-class errors

     % A simple atlas applies a list of functions: ;
     [+, opposite] 1
1 -1
     2 [+, opposite] 1
+-+-----+
|3|-2 -1|
+-+-----+
     % Defining an average function: ;
     average is /[sum, tally]
     average 1 2 3 4
2.5
     % Nested atlases! ;
     [sum, tally, [product, 7 times]] 1 2 3 4
+--+-+---------------+
|10|4|+--+----------+|
|  | ||24|7 14 21 28||
|  | |+--+----------+|
+--+-+---------------+

     % A simple for loop ;
     % An '!' symbol allows for multiline statements in the REPL: ;
     !
.... for i with 1 2 3 do
....     write [pass, 1 +] i
.... endfor
.... 
1 2
2 3
3 4
     % The same, except with a map: ;
     each (write [pass, 1 +]) 1 2 3
1 2
2 3
3 4

     % A basic divide by zero error: ;
     1 / 0
?div
     % Errors are values called faults.
       This allows for powerful error handling: ;
     5 / 5 10 0 8
1. 0.5 ?div 0.625
     each (op x (if isfault x then 0 else x endif)) (5 / 5 10 0 8)
1. 0.5 0 0.625

     % You can also define custom faults using 'fault': ;
     fault 'this_is_an_error'
?this_is_an_error

     % Or by using a fault literal: ;
     ?this_is_an_error
?this_is_an_error

See More ❯

About

Nial (Nested Interactive Array Language) is a general purpose programming language based on a formal model of Arrays developed by Trenchard More and Michael Jenkins.

Nial is part of the APL family of programming languages, with the philosophy that the best design could come from a combination of both functional and imperative styles in an array language. It differs from standard APL in that it offers a more traditional programming language syntax.

Nested arrays of multiple dimensions are the primary data type of Nial. Arrays together with an extensible core set of functions/operators to manipulate arrays and a programming language for the construction of more complex computations allow for the development of efficient programs that can take advantage of the characteristics of modern CPUs.

If Nial looks like a language you’d like to program in, Try it now!

Community

The main place for Nial discussion is the APL Farm, which you can join at these links:

Whether you are a newbie or have been using Nial for a while now, feel free to join!

The r/apljk subreddit also welcomes discussion relating to Nial.

If you would like to contribute to Nial or the Nial ecosystem, you can check out the niallang organization on github, which contains many active projects that are being worked on. Contributions are highly appreciated.