Visual APL v1.0

Visual APL v1.0 is now available!

Visual APL Release Candidate 6.5 (RC6.5 - 26mar07)

If you want to become a Beta Tester for this product, click here.

Visual APL RC 6.5 contains several general feature enhancements and updates. RC 6.5 also contains the new feature of referencing User Defined Functions using dot syntax. This brings substantial gains to code partitioning flexibility and object oriented programming to UDFs.

General updates to the Dynamic Syntax Checker
Casting the result of a call to an indexer on the same class that the call was made would mark an error in the Dynamic Syntax Checker. This has been fixed.
Nested classes would have an error marked on the closing brace of the last method in the sub class. This has been fixed.
)unload session command has been added. The )unload command disassociates a script file from the session, making it the inverse of )xload.
Constructors in script classes now work.
General Intellisense updates and fixes.
Intellisense for constructors has been updated.
Opening a script which was not associated with the CieloExplorer from the CieloSession project would add an additional comment string to the end of the
script file. This primarily affected the )edit command.
Return keyword would throw an error in constructors of classes defined by script files in the Cielo Explorer session.
Properties are now correctly regionized in apl files.
Operators can now be called at the class level using dot syntax. For instance, "class1.op1"

With RC 6.5, you now have the abillity to transparently use AplFunction attributed methods created in any .Net language.
Standard user defined functions created in Visual APL automatically receive the AplFunction attribute, and so they can be immediately used
in the context of this new feature.

Here is an example class create in C# which publishes three user defined functions:
using System;
using System.Collections.Generic;
using System.Text;
using APLNext.APL.Objects;
namespace aplfnclass {

    public class Class1 {
        [AplFunction]
        public static object add(object a) {
            return a;
        }
        [AplFunction]
        public static object add(object a, object b) {
            return b;
        }
        [AplFunction]
        public static object niadd() {
            return 100;
        }
    }
}

The following Visual APL example shows the use of the above C# user defined functions:

      using System

      refbyfile @"C:\aplfnclass\bin\Debug\aplfnclass.dll"
      using aplfnclass
      aplfnclass.Class1.add 100
100
      200 aplfnclass.Class1.add 100
200
      aplfnclass.Class1.niadd
100
      aplfnclass.Class1.niadd 300
100 300
      Class1.add 100
100
      200 Class1.add 100
200
      Class1.niadd
100
      Class1.niadd 300
100 300

The above example calls the UDFs with their fully qualified class and namespace name, as well as just the class and function name. This allows user
defined functions published on any class created in any .Net language to be used transparently and modularly with no additional commands or syntax.

This means that Dyadic, Monadic and Niladic APL user defined functions can be created in any .Net language, and be effortlessly used anywhere in your
Visual APL code!

UDF overloads are also fully supported. If a class publishes two UDF methods named ADD, one of which is dyadic and the other monadic, then the monadic
or dyadic overload of the ADD UDF will be called according to how the UDF is called in your Visual APL code.

The Class Level Using syntax is of course still fully supported, giving you more options then ever before on how to partition, import, and disperse
user defined functions into your APL applications.

As in previous RC releases of Visual APL, you can use the class level using syntax on a class which exposes user defined functions, and
those functions will be dispersed into your class, and can be called just as though they were locally defined. Now, you also have the option
of performing a normal using, and accessing the UDF with standard dot syntax for Dyadic, Monadic, and Niladic UDFs.

Any methods on a class which do not have the AplFunction attribute are called as a method with the parenthesized arguments syntax.

And as always, this feature is 100% CLS compliant.

The above examples and explainations demonstrate the calling of static UDFs using standard dot syntax. This new feature also supports the calling of UDFs on
class instances, which means that user defined functions can now take full advantage of the benefits of having instance state.

This means that both instance and static APL functions can be consumed, whether created in Visual APL or C#, or any other .Net language.

Here is a Visual APL class showing both instace and static UDFs:

using System

namespace nspfn {
    public class cs {
        public factor = 0
        public static ?r?a add b {
            r?a+b
        }
        public ?r?a minus b {
            r?this.factor×a-b
        }
        public ?r?a times b {
            r?factor×a×b
        }
        public ?r?mon a {
            r?factor×a
        }
        public ?r?nil {
            r?factor
        }
    }
}
Notice that the add function is static, the rest are instance.

Also notice the instance field factor. Since the instance methods use the instance field factor, each instance of these user defined functions can have a
different factor.

In the session:
      using nspfn
      )edit fn
function fn() {
    ??10 cs.add 20
    cs a = new cs()
    cs b = new cs()
    a.factor = 10
    b.factor = 100
    ??100 a.minus 10
    ??100 b.minus 10
    ??11 a.times 21
    ??11 b.times 21
    ??a.mon 31
    ??b.mon 31
    ??a.nil
    ??b.nil
}

      fn()
30
900
9000
2310
23100
310
3100
10
100
From this we see how an instance of a class can create state for a set of operators. You can also change the state for just the operators on a specific
instance by changing the value of any instance field.

To use instance user defined functions, the variable which holds the created instance of the class must be strongly typed. Otherwise, the user defined function
must be called as a function. This is because the user defined function on the class must be known to be an operator in advance, other wise there is no
way of knowing that what would appear to be a call to an operator would not actually be another operation with similar syntax, such as a field or property reference.

This means that UDFs which are on an instance of a class cannot be called directly from the run line of the session, because variables cannot be strongly
typed at the session level. Instance UDFs can be called from functions in script files from the session, and an example of this is shown by the "fn" method
in the example above.

The Base primitive returned incorrect results for some combinations of matrix/scalar arguments.
Run errors which occured in a script after pressing Ctrl+E+E would not be reported to the Error List. This has been fixed.

---------------------------------------------------------------------------------------

This download requires AplNext Activation version 1.0.4x or later.

Previous versions of the Visual APL RC install package required that a DOS command be manually executed after the install had completed. This version removes this requirement.

You will need to uninstall any previous versions of Visual APL before installing RC6.4 (note that the program to Uninstall is called VisualAPL in Control Panel / Add/Remove Programs; it used to be called APLNext), or several features will not be active in Visual Studio, such as the Visual APL Session. If you do install a version of Visual APL before uninstalling all previous versions, just reinstall Visual APL and all features will be active. To uninstall any previous versions of Visual APL:

Close all running copies of Visual Studio 2005.

Open "Add/Remove Programs" from the Control Panel

Uninstall "APLNext" by clicking on its entry in the listview, and clicking "Remove"

Visual APL Release Candidate 6.4 (RC6.4 - 22mar07)

This is a minor update which contains the following fixes:

Fixed indentation bug where tab character at start of line would off set control structures when closing brace was typed.
Fixed indentation bug where typing the close brace if a statement would in some circumstances incorrectly indent the declaration line of the control structure.
Fixed Realtime Syntax Checking error where certain generic field variable declarations would mark as errors.
Fixed bug where new lines between the closing curly brace of one catch block and the "catch" keyword of the next catch block would mark an error in the Realtime Syntax Checker.
New shortcut: Ctrl+E+Q switches to the Cielo Explorer without saving the currenly open script file.
New shortcut: Ctrl+E+S switches to the Cielo Explorer saving the currenly open script file but without running it. Depending on the configuration of your copy of Visual Studio, Ctrl+E+S may instead enable visible white space in text editors. You can remap the Save script command through the Keyboard section of the Visual Studio options window.
As before, Ctrl+E+E switches to the Cielo Session and executes the currently focused script file.
Right clicking on a Script file in the CieloSession project shows possible actions you can take on that script file.
Improved intellisense.
Intellisense for classes in mscorlib.dll was not being displayed. This has been fixed.
Intellisense tooltips for methods now show number of overloads in same locations as C#.
The default method for which intellisense is shown when hovering over a method in an intellisense list has been changed to match C#. (The summary is shown for the method with the most arguments in an overloaded method list.)
Intellisense for XmlWriter class would show duplicate entries in the intellisense list.
Intellisense tooltip of "()" would show during the declaration of a control structure. This has been fixed.
Typing an open paren would inappropriately show an intellisense tooltip of "()" depending on where the open paren was typed. This has been fixed.
The intellisense list for the root level of the System namespace would incorrectly filter items after the first Usign directive in a script.
Some generic classes shown in intellisense lists would incorrectly show "`1" or "`2" where a "<>" should have been. This has been fixed.
Auto completion for generic types now correctly adds "<>" to the end of auto completed class names.
Items with non-usable names would sometimes be displayed in intellisense lists. This has been fixed.
Several new VS Keyboard Commands have been added to facilitate the creation of custom and international APL keyboard layouts.
Calling a static method from another static method in the same class without the full type name of the class would mark an error in the Realtime Syntax Checker. This has been fixed.

Visual APL Release Candidate 6.3 (RC6.3 - 16mar07)

RC 6.3 is a minor update which includes these features:

Some directory names created during the install were modified to reflect the VisualAPL product name.
APL2Unicode has been updated. It is a .Net DLL which is included with the install of Visual APL. The name of the dll is “AplNext.Utils.apl2unicode.dll”, and is located in the APL2UNICODE directory in the install path of Visual APL
Several locations which did not permit comments have been updated to allow comments.
Pick now treats non primitive type objects as scalar, which matches index.
Transpose in selective assignment was enclosing elements, this has been fixed.
The specification of arrays and vectors using {} syntax now matches 2.0 of C#. This is primarily used when creating strong typed variables, but can be used anywhere.
The Visual Studio character command mapping has been updated.
The ability to run statements in the directives has been added with the keyword prestmt. Examples of how to use this have been added to the documentation included with RC 6.3.
Publishing events has been updated.
Casting to arrays was updated.
The system function []fmt now matches the legacy behavior and []format provides array formatting using the new .Net format specifiers. See the Visual APL documetation for examples on using []format.
The legacy []fmt G specifier has been updated.
Updated toolbar in Cielo Explorer and added help button to the toolbar.
Resolved conflict in inheritance from interface type in same namespace and file.
Added further type optimizations to the XmlCvarSerializer.
Updated icons in Visual Studio.
[]favail now determines of the share file system has been referenced.

Visual APL Release Candidate 6.2 (RC6.2 - 09mar07)

This is a minor update which includes these features:

[]FMT and []CFMT have been renamed to []FORMAT and []FMT respectively.
[]SVxxx system functions would register errors in the Task List of Visual Studio. This has been fixed.
The “)xmlout“ session command would sometimes output two BOM sequences in the XML output. This has been fixed.
The SerializeToString method on the XmlCvarSerialzer object has been updated to take any arbitrary data.

Visual APL Release Candidate 6.1 (RC6.1 - 06mar07)

This is a minor update which includes these features:

High minus not displayed in some cases when data is displayed to the session, this is fixed
Transpose had been updated
Newline after catch and before showed syntax error, this has been fixed
A tie number of 0 to either the Native File System or the Share File System now ties the file to the next available tie number and returns that tie number.
This is the same functionality as providing the name of the file as the right argument.
Access attributes are now supported on the Native File System, for instance:

@”c:\name” []ntie ¯1 66

Grants read/write access and grants read/write access.
APL Functions and namespaces now have automatic regions in the Visual Studio Editors
0<reshape><enclose><zilde> has been fixed
[]fstream has been added to the Share File System and []nstream has been added to the Native File System. These return the file stream associated with the tie number and the file stream can be used for custom actions, such as:

      fs = []nstream ¯1
      fs.CanRead
true
      fs.CanWrite
true
Limits of 1 to 17 have been set for assigning to []pp
Quad <assign> now used the value of []pp for displaying information
Early bound enums, like TypeCode.Char in arrays have been updated
The XML Serializer has been updated
Opening a script from the session and then the solution no longer creates duplicate view

Visual APL Release Candidate 6.0 (RC6.0 - 01mar07)

With RC6.0 we’re taking programming to a whole new level!

Visual Studio Integration

This version, RC 6.0, concludes our integration with Visual Studio, and undoubtedly makes Visual APL the premiere .Net language.

This brings together all of the features of Visual Studio, the typing of C#, the wealth of tools available in the .Net framework and the rapid development and scripting capabilities of APL into one cohesive language and development environment.

One of the biggest advances with RC6.0 is that the session is now integrated with the solution. This means your session has state, can span solutions and you can switch between sessions, include new sessions, and you can bring specialized sessions into your solution at any time.

This advance also means that with RC6.0 the session now uses the VS Editor when you edit scripts. This provides the same feedback for creating scripts you now have when creating projects in Visual Studio. There are so many features this brings to script creation you really have to see it in action, so make sure you see this weeks webcast, either live or on continuous replay over the weekend!

To edit a script from the session simply type what you normally do:

)edit scriptname

Where scriptname is the name of your script.

This edit action takes you to an existing script file in your project or creates a new one if the script does not exist. With the scripts being included in the project, it is now simple to edit and modify the scripts using all of the tools in the VS Editor.

Remember that editing a script is roughly analogous to editing a function in the legacy APL systems, but with a script you can include variable definition, run functions, define functions, create classes, instantiate classes, and more! And you can do this in Visual Studio with all of the development features in VS integrated with the Visual APL session.

Once you have finished creating or editing your script simply press ctrl-e-e, that is, hold the control key down and press the E twice, and your script will be redefined in your session. It was necessary to use the e-e to be compatible with Visual Studio.

That’s all there is to it, you can create, modify, save and run your scripts while having them integrated with your .Net solutions.

When you click with the right mouse button on a script file in your session project you have the menu options to either load or xload the script into the session. The load will define any functions, classes etc. in the session and execute all code in the script. The xload adds the script to the script list in the session and you can )run the script at any time in the session.

With the advanced features of the Visual APL session, including the integration of script creation and management within the VS framework, we have taken development to a new level in Visual Studio not found in any other .Net language.

Editing APL variables, even nested data types, is also made simple and easy with RC6.0

Editing your data as XML

Now you can edit your APL variables using the VS XML Editor! You can make changes, modify the XML and then have those changes to your variable reflected in the variable in the session.

To edit a variable in your session, just type:

)xmlout variablename

Where variablename is the name of the variable in your session. This will create an XML representation of your APL variable and open the related VS XML Editor, from here you can edit, modify and update the APL variable in your session. Once you have finished editing your variable, just press ctrl e-e, the same as you used for placing your script in the session.

You will notice in the session that there is continual feedback which indicates that the script or variable have been updated in your session from your ctrl e-e action.

If you want to edit more than one variable at a time, you can do this using:

)xmlout var1 var2 xvar xq

Each variable is placed in a separate XML Editor window. You can even copy and paste from one XML variable to another and redefine the results in your session. How often have you wanted to visualize a complex data structure, and then be able to copy and paste parts between variables? Now it is a reality!

You can even edit variables that include Hashtables, Dictionaries and other .Net data collections!

To accomplish this integration with the VS XML Editor we have created an XML Serializer class for the variables you normally find in your session.

This XML Serializer is an assembly you can include in your project to create XML Serialization of your APL variables under program control and then redefine them from the XML under program control. This also includes the XML serialization of common .Net collections, such as Hashtables, Dictionaries, etc., which can be included in APL variables. For instance you might have a vector or matrix which includes Hashtables.

The session survives the changing of solutions if you want to retain information in the session between projects, or you can do a )clear to remove all of the previous data.

If you do an )off in the session, it clears your session and closes your current solution, but it does not exit Visual Studio.

You can also change your Session project by simply right clicking on the Session project and selecting Remove from the popup menu. Then right click on your solution and select “Add” and then choose “New Project” or “Existing Project”. If you choose existing project you can bring a completely different session into your project, with the associated scripts, xml variables, etc. This makes it possible to have sessions that are focused on specific tasks and swap them in and out depending on what part of your total solution you are developing.

You can also have more than one Session in your solution, and switch between the sessions by simply renaming the session project you want to use to CieloSession.

When you have Sessions in your solution, in many cases you will not want to have these included in your assembly, so you will need to check the do not compile check box for the session projects.

Whether it is creating a CLS compliant dll, exe or developing scripts you now have the continual feedback available with the VS editor while developing your code.

The Visual APL session provides you all of the benefits you expect from an APL session, while being integrated in Visual Studio and your project solution.

This integration of the session with the Visual Studio solution makes creation of scripts, testing and assembly creation one integrated development process. Truly moving Visual APL ahead of all other languages!

The Application Shared Datastore

Version RC6.0 also introduces the Application Shared Datastore

This Datastore makes it possible to share variables across dll’s in your application, creating shared variables which transcend a single dll or exe.

The keyword to add a variable to the Application Shared Datastore is:

svglobal

The syntax for svglobal is the same as for the keyword: global

For instance, to add a variable to the Application Shared Datastorre, include this statement in your function:

svglobal var1

Where var1 is the name of your variable.

Once the variable is added to the Application Shared Datastore, any other dll or exe included in your application will be able to reference the variable in the same way as any global variable.

To manage your Application Shared Datastore we have included the following quad functions.

[]svs - return the shared status of an entry: Shared in the Application Shared Datastore: 0/N 1/Y

[]svc - return the changed status of an entry: Assigned since the local-class's last assignment or reference: 0/N 1/Y

ehset []svset 'sv' - set the event handler function 'ehset' for the event that the value of the Application Shared Datastore entry 'sv' is about to be modified. The function 'ehset' can modify the value of the object before it is assigned to the Datastore, or throw an exception based on the value that is about to be assigned.

The signature of the event function for the setting of a value in the Application Shared Datastore is:

function ehset(name, oldvalue, newvalue)

Where name is the string name of the variable, oldvalue is the present value of the variable, and new value is the value about to be assigned to the variable, for instance, this example will add 10 to the values being assigned.

     function fn(name, oldvalue, newvalue) {
         return 10+newvalue
     }

efget []svget 'sv' - set the event handler function 'ehset' for the event that the value of the Application Shared Datastore entry 'sv' is about to be referenced. The function 'ehget' can modify the value of the object referenced in the Datastore before it is returned, or take any action possible in a method.

The signature of the event function which is run before a value is returned from a variable in the Datastore is:

function ehget(name, value)

Where name is the string name of the variable and value is the current value of the referenced variable.

For instance, we can add 10 to the variable when it is returned:

      function ehget(name, value) {
          return 10+value
      }

[]svd - delete an entry from the Application Shared Datastore

If we were to look at an example of using the Datastore:

      function fn() {
          svglobal sv
          sv = 10
          [] = sv // this will print 10 to the screen
          ehset []svset “sv”
          ehget []svget “sv”
          sv = 10 // the value in sv at this moment is 20, as the ehset added 10 to the value
          [] = sv // the value returned is 30, as 10 is added to the value being returned
      }

Variables defined using the svglobal keyword are placed in the Application Shared Datastore which can be accessed by any dll or exe in the same application or domain.

Variables in the Datastore are global to all functions in an application, and only need to be defined using svglobal one time in a class.

The order of name resolution for the Datatstore Variables, is as you would expect, local variables first, then global, then Shared Variables. A dll only sees those Shared Variables it specifies with the keyword: svglobal

This powerful tool makes creating and sharing data between dll’s and exe’s trivial, manageable and easy to implement.

Share File System

RC6.0 includes a significant update to the ShareFileSystem plugin.

The ShareFileSystem in Visual APL is a next generation component file system.

Not only does the ShareFileSystem support the legacy syntax common to share file systems, but it extends share file systems with virtual directories. This means you can place more than one share file in a single physical file.

Additionally because we use the ISerializer for the IO of nested or object data types, shared and native files can read and write not only simple APL variables, but nested APL variables which even include Hashtables, Dictionaries, etc. You can also write out the Hashtables or Dictionaries without including them in an APL variable. Any class that inherits from ISerializable can be written to the share or native files and retrieved with the instance being automatically recreated.

In addition to picking up a couple of minor bugs, we have also added []fdup, []libdup, []fdrop, []fremove

[]libdup duplicates an entire virtual directory based on the associated library number, for instance:

@”2 c:\test\testnew” []libdup 101

Where 101 is the library number for the existing virtual directory. This will duplicate all of the files in the 101 virtual directory and place them in c:\test\testnew which is associated with the library number 2.

To create a virtual directory:

[]libd @”3 c:\test\testvdir”

This creates a virtual directory named testdir in the c:\test directory. []lib, etc work on virtual directories.

Using the legacy syntax, when you create a share file:

@”c:\test\myfile” []fcreate 1

To support legacy systems, this creates a vitualdirectory with the same name as the fileid specified, myfile, in the c:\test directory, and then creates a share file in the virtual directory with the same name.

The advantage of the new share file system is that not only can you place more than one share file in the virtual directories, but the share file system recovers data as it becomes available, thus avoiding the explosion of size common in some legacy share file systems.

This version also includes []fdup for legacy support and duplicates a single file. This will only duplicate share files whose name matches the virtual directory and the virtual directory contains on the file being duplicated. The legacy syntax works for []fdup.

Because the ShareFileSystem recovers data, it is possible to enhance []fdrop and add []fremove as outlined below.

[]fdrop duplicates the syntax of the legacy, but has one difference, when you drop components from the front of a file, the components that remain are renumbered from 1 instead of retaining their original numbers. Since we give data back to the virtual pool, this was easy to do, and adding the artificial first component offset after a drop would have been difficult.
[]fremove removes a component from a share file and the remaining components are renumbered.
The more share files that are placed in a virtual directory the better the space management becomes.
We have also fixed some minor bugs in the ShareFileSystem in this version.
General errors and omissions in 5.1 have been fixed and enhanced, following is a short list.
Enclosing a nested vector of scalars could promote to char[] in some cases, this has been fixed.
Reduction with prototypes has been enhanced.
[]dr has been enhanced to better address unsigned types like uint, ulong, ushort
Casting using implicit conversion between data types has been enhanced. This particularly applies when returning a strong typed value when the return type of the function is different, but will implicitly cast from the return object type.
Early emission of constant fields has been fixed. This applies to constants such as Double.MaxValue, Double.MinValue etc.
[]type now accepts each
Use of the static and instance modules have been enhanced.
[]repl now matches the legacy behavior.
The DateTime stamp associated with dynamically created functions would was not properly localized for international DateTime formats. This has been fixed.

Visual APL Release Candidate 5.1 (RC5.1 - 22feb07)

This version represents a milestone in our integration with Visual Studio.

This includes:

Dynamic realtime syntax feedback while developing code with the exceptions being displayed in the Error List task pane.
Introduction of squiggles to highlight problems in code.
Realtime syntax feedback also applies to code which is pasted into the VS editor or to new APL files added to projects.

These features eliminate the need to create an assembly to determine errors in code.

Further enhancements available in RC 5.1 include:

Some configurations of Visual Studio would still require the VSPackage refreash dos command to be run after the install had completed. This has been fixed, and this means that the dos command never has to be manually run.
Closing a brace in-line for a strong typed variable initializer would sometimes duplicate the line of code. This has been fixed.
Intellisense now includes descriptions when available.
Intellisense now includes descriptions per function argument, when available.
Intellisense for the “this“ object has been greatly enhanced.
Intellisense for inter-project references has been greatly enhanced.
Enhanced symbol selection during code debugging when using stops and stepping through code.
Enhanced Intellisense for objects which have a type which can be determined.
Full implementation of all development and management features in Visual Studio for Visual APL.
Snippets are now supported in the Visual Studio editor.
Improved syntax coloring and indentation.
Significantly improved error messages.

With this version RC5.1 you should find Visual APL development in Visual Studio to be a real pleasure!

Significant improvements in typing for fields, properties and enums, particularly for static members.
Improvements in casting, both implicit and explicit, for typed returns from methods.
Module references could be modified inadvertently when doing an execute, this has been fixed.
Module references could also be modified inadvertently on event handlers with []wi, this has been fixed.
There was a problem with execute and event handlers when referencing User Defined APL Functions. If you use methods (such as fn() ) it works ok. This has been fixed.
The legacy Qwi, Share File and Native File assemblies have been enhanced to only show the class which applies to the APL environment.
There was a problem with the Index Function (squad) when indexing vectors. This has been fixed.
The []fmt system function now supports composite format strings for dates.
The []chdir system function now accepts zilde as well as '' (empty char vector)
[]fi and []vi were returning an error when the second character in a non numeric value was a strong type identifier. This has been fixed. For instance: []fi 'od' returned an error.
Comparisons with == to niladic/monadic quads with the quad as the left argument threw an error, this has been fixed.
Multiple assignment to variables, fields and properties has been enhanced, such as: (a nfi.ns c) = 10 11 12
Strong type casting errors now provides better error information.
For strong typed methods with a single argument which is not a valuetype will now be selected with default null argument.
Strong typed fields and properties emit enhanced.
Fixed mismatched mapping in []wi for several controls (Listview, Tree, Menu, and related events)
Error in style for all objects has been fixed.
Enhanced classes in scripts to better support instance and static methods.
The addition of []idlist introduced an error in labels, this is fixed.
Common quads related to file access, like []chdir, have been added to both the ShareFile and NativefFile classes.
Keyword list in CodeDom has been updated.
[]xlib now returns directories and file names to match legacy code.
The ShareFileSystem, NativeFileSystem and WindowsInterface external dlls now have consistent public classes.
[]cfmt now handles each correctly.
refbyname in a class produced an error in some cases, this has been fixed.
[]reference and []using were causing exceptions in event handlers in some cases, this has been fixed.
Event handlers which are in classes which inherit from Form now correctly deal with either instance or static.
Inline assignment is now supported for quad, such as <quad>io and <quad>ct
Enhanced error reporting when calling a static method from “this” context.
To conform to the MS methodology for creating scoped disposable objects we have added the using statement, not to be confused with the using directive. Please see the related screencast on this subject. (soon to be posted. The screencast will be posted later today, and a link will be added here to the posted screencast.)
[]ts for left argument to []def is now supported.
[]at is now supported.
Labels can be localized using:

int L1

if there is a potential name conflict
module inspection enhanced.
<zilde><shape> var1 and ‘’<shape> var1 was not maintaining depth, this was fixed
System variables, like []ct and []io now fully support inline assignment

Visual APL Release Candidate 5 (RC5 - 9feb07)

Debugging, mouse over variable, object visualizer.
Also supports custom visualizers.
Debug visualizers now work in ".apl" files. Visualizers display tooltips describing the contents of a variable when you are stopped at a break point in your application. To activate the visualizer for a variable while stopped, just hold your mouse over the variable for a few moments.
The visualizer you will see is usually the default data visualizer in Visual Studio, and if you create your own custom visualizer it will be used instead.
The legacy external operators []N, []F, and []WI operators can now be imported by their strong assembly name, as well as their DLL path.
Here is an example of importing []WI using its strong assembly name:

refbyname APLNext.Qwi
using APLNext
using APLNext.Qwi.WindowsInterface
Here is an example of importing []WI by its DLL path on the disc:

refbyfile @"c:\Program Files\APLNext\APLNext\APLNext.Qwi.dll"
using APLNext
using APLNext.Qwi.WindowsInterface
Importing []N and []F functions using the strong assembly name:

refbyname APLNext.APL.LegacyOps
using APLNext
using APLNext.Legacy.NativeFileSystem
using APLNext.Legacy.ShareFileSystem
Importing []N and []F by their DLL path:

refbyfile @"c:\Program Files\APLNext\APLNext\APLNext.APL.LegacyOps.dll"
using APLNext
using APLNext.Legacy.NativeFileSystem
using APLNext.Legacy.ShareFileSystem
There was a bug where both the Design view and Code view of the same Form could not be displayed at the same time. This has been fixed.
There were several colorization anomalies in the Session and .APL files. These have been fixed, and colorization significantly enhanced.
Icons were updated.
Stand alone version and the Session now correctly build EXE assemblies.
The cursor is more accurately positioned on error locations in code when double clicking debug error messages.
Event handlers are now created with correctly typed arguments.
Available event handlers are now shown in event drop down lists of the events pane in the properties window of the forms designer.
Closing the Design view of a form would sometimes lose the mapping for jumping to the associated event handler by double clicking a control. This has been fixed.
[]idlist is now supported.
Indentation on close brace improved.
Blank lines in functions would not be correctly auto indented. This has been fixed.
Defining a field using on the type attribute, without public or other attributes, for instance:

Int fld1 = 100
Created a static field, this now correctly creates an instance field.
Fix made to use Special methods, typically used with operator overloads, previously using the Special method directly would throw an exception regarding argument count. This has been fixed.
For instance:

       a = DateTime.Now
       b = DateTime.Now
       ts = a.Subtract(b)

or:

       ts = a – b

Both work.
There was an error when using the return or :return in a function with a void as the return type, this has been fixed.
[]pp now determines the display of data to the session as well as the pattern formatter.
The nfi (NumberFormatInfo), which is set using []nfi, has been moved to the ApplicationState
So, nfi is now on the ApplicationState, and applies to the formatters and the general display of data in the session.
Ravel with axis has been enhanced to accept zilde and fractional axis identifiers
There was a conflict between class contexts during compiliation which has been resolved.
[]nl now supports dyadic calls
[] <assign> b <assign> 10 now works correctly
Fixed overwrite problem when multiple references to the same dll were made.
Quads are not supported in the signature of functions or methods as the quad is not valid outside of APL.
Resolved conflict in scoping between local variables and user defined functions.
We now support:

      / / (1 0 1) (1 2 3)
1 3

      []repl / (1 0 1) (1 2 3)
1 3

      / \ (0 1 1) (1 2 3)
0 1 1    2 3

     / / (2 2 2 ) (1 1 1)
1 1 1 1 1 1

      []expand / (1 1 0 1) (1 2 3)
1 2 0 3
And all the other permutations, just remember to put the space between the //, or a comment will be created. Also notice that a space must exist before parenthesised elements or the left parenthesis will be considered an identifier for a method call.
Niladic functions in arrays are now parsed correctly.
Significantly improved reporting of error locations.
The for-to-step construct had an error when the “to” was a strong type, this was fixed.
Improved error message when duplicate labels exist in function
General Note: The global keyword specifies variables which are global, for instance:

global a, b, var1, var2
A variable can be declared explicitly local by declaring it with type. For cases where the variable is to be local but have no type, use object:

object a, b, var1, var2

Or you can declare a variable to have an explicit type, but remember that once a variable is typed, it can only be that type, and that rank and scalar count in typing. You can always assign typed to untyped and untyped to typed, but the conversion is not free, so you should avoid doing this in a loop. Also, remember that typed variables can not exist in the session, but only within a scope, for instance a function, a class, etc.
Fixed column offset error effecting location reported in errors
Improved error reporting on strong types
:leave in a :select :case syntax error fixed
We have also added two quads which make it possible to reference and use dll’s during execution.
The refbyfile, refbyname, refdynamic and using keywords are directives and are only referenced during creation of the dll or exe assembly. For late binding to an assembly, we have added two quads:

[]reference
[]using

[]reference adds a late bound reference to the specified assembly, whether it is given as a file or as a name, and does this during execution. Arguments to []reference can be any valid APL expression which produces a string. For instance:

      a = @"c:\myprojects\myutils.dll"
      []reference a

Or to reference by name:

      []reference "System.Windows.Forms"
Both will return true if successful and false if it fails to load the assembly.
Once an assembly has been loaded, you can then use the namespaces in that assembly, for example:

[]using "myutils"
[]using "System.Windows.Forms"
You can also specify an alias for a using like this:

[]using win = "System.Windows.Forms"
The variable win will now contain the System.Windows.Forms assembly information. Aliases are used to avoid name conflicts between assemblies.
As these are evaluated during execution, any valid apl expression can create the input to these new quads. However, if you are using an alias it must be the first assignment in the expression before the []using.
We have also added []cfmt which supports the syntax of the legacy []fmt, returning character matrices. See the reference for the legacy support which []cfmt provides
A full list of the supported legacy feature set of []cfmt can be found here:
http://www.aplnext.com/community/blogs/reference/archive/2007/02/08/223.aspx
We have also significantly enhanced the []wi plugin which now implements the vast majority of the legacy []wi
A full list of supported legacy features of []wi can be found here:
http://www.aplnext.com/community/blogs/reference/archive/2007/02/08/222.aspx
In particular, we now support the use of arbitrary APL expressions for event handlers. You no longer have to provide a function with a .Net type signature.
In addition, we also now support onNew, onAction, Defer and Event
This makes creation of user defined controls possible.
See the reference for the complete list of supported features for the legacy []wi
Execute now supports inline assignment

Visual APL Release Candidate 4.3 (RC4.3 - 25jan07)

This version fixes all problems and issues found in RC 4.2, which updates a wide set of features, ranging from a few operator optimizations to missing keyword colorization. The system function []xlib has been added, and its description in the update list below also mentions some very useful .Net System calls for gaining even more information about directory structures.

Auto-Indentation in Visual Studio code editor window updated. “for“ and “while“ structures would not indent properly on close brace.
Fixes overwriting of debug information for multiple files in a project and for partial classes.
Calling imported functions with each in some cases failed to honor the each
Improved error reporting
Fixed order of static constructor initialization
shiftright >> and shiftleft << for typed scalars has been optimized
Enhanced strong typing generics
Updates to strong type array instantiation and initialization (check on newexpr type of element)
Enhanced casting to strong types
Setup now registers .apl and .aplproj extensions on install, so that these files will open in Visual Studio automatically when they are double clicked.
Fixed []wself which was broken when we moved qwi out of the core project.
Fixed error when comma was second token on line after label.
Updated monadic nor and nand.
Fixed local variable with same name as user defined apl function conflict.
global keyword is now highlighted.
Fixed selective assignment for case where a single element was selected and a vector of one element was assigned.
Multiple files are not opened when double clicking on a file in the solution explorer
[]xlib has been added - see .doc in aplnext directory for info.
[]xlib has been included for legacy compatibility. It reveals the underlying .Net Directory.GetFiles Method.
[]xlib takes a string right argument which can be either the directory only, terminated by a backslash, or a searchPattern trailing the directory or alone.
The .Net Directory namespace provides reasonably complete tools for directory management.
Use Directory with the Path class for manipulating the path and file strings.

The following wildcard specifiers are permitted in searchPattern.

Wildcard character	Description
*	Zero or more characters
?	Exactly zero or one character

To investigate the Directory namespace, you can do this:
using System
using System.IO
Directory.GetFiles( this has three overloads which you will want to look at )
Directory.GetFiles(directory)
Directory.GetFiles(directory, searchPattern)
Directory.GetFiles(directory, searchPattern, SearchOptions.AllDirectories)
Directory.GetFiles(directory, searchPattern, SearchOptions.TopDirectoryOnly)

Visual APL Release Candidate 4.2 (RC4.2 - 22jan07)

This version of Visual APL has numerous enhancements and fixes all bugs and problems reported in RC 4.0 and RC 4.1.

Enhancements have been added to support the creation of Visual Studio “Web Site” solutions. Web Application project integration has also been greatly improved. This allows Visual APL to be seamlessly used for inline scripting inside ASPX pages. The most notable of these enhancements are much better Intellisense for inline script blocks, and improved debugging integration.
Fixed code outlining in .apl files. (methods did not retain indentation when braces were matched.)
Updated emitted “for” loop.
Double click on error message in Visual Studio now jumps to error again.
Comments are now supported between control structure condition tests and “:andif” or “:orif“
Added “:endrepeat“ structure.
Equivalence in prototype comparison updated.
Scalar catenation/lamenation enhanced.
Fixed hash table collision in symbol table.
Updated closing block set in “:elseif“.
Inline assignment in control structure tests now supported.
Directives now supported inside of classes and at end of file.
Plus and minus scan return correct identities now.
Fixed error in :repeat/:until/:andif or :orif
Resolved conflict in certain cases where local variable and class name were identical.
Fixed error in increment and decrement expressions.

Visual APL Release Candidate 4.1 (RC4.1 - 17jan07)

Updates in Release Candidate Version 4.1:

We knew we would have some issues with the new importation of quads, and we want to thank everyone for the quick feedback on 4.0

We have fixed all of the known issues in this version, 4.1, including the issue with the importation of quads overwriting existing quads. In our test suite, we added this to the end of the tests, and of course everything ran great, however, had we placed these new features at the top of our test suite, we would have discovered our problem. Again, thanks for the quick feedback.

We also fixed some issues with placing using directives inside of classes. This is now fully supported.

Added better error reporting when refbyfile is given an unknown or invalid dll
We have also implemented some additional quads:

[]fx
[]dl
[]erase

Remember, that when erasing strong typed objects, the variable value is set to the default for the type as it is not possible to actually erase the strong typed variable name. However, the result in terms of memory use is the same as if it were erased.
We have updated []chdir to accept zilde
The DataObjects dll is now easily accessible.
Updated selection of imported apl functions
Enhanced colorization in Visual Studio editor windows.

----------------------------------------------------------
Lines below are an update of the same information provided for RC4.0

This version is a major upgrade for us and includes significant updates to the all aspects of the Visual APL system.
The use of system file access, through the share file system and the native file system, as well as the use of the system windows classes has been moved to dll's which are not referenced in the Visual APL core system.
The use of the quads associated with these classes, such as [quad]fread, [quad]nread, and [quad]wi, can be included in a project by simply referencing and using the associated dll in your project. Using these associated quads without first including the associated dll will result in a syntax error.
This means that the assemblies created with Visual APL can be created without requiring access to either the file system or the windows systems. This is important when creating applications which will be installed in an environment where access to system resources is restricted.
To use the Visual APL File Systems in your project, add a reference to the Visual APL File System dll, or use the refbyfile keyword under program control:
Using the default path to the Visual APL File System, the following would make the quads available to your project:

refbyfile @"c:\Program Files\APLNext\APLNext\APLNext.APL.LegacyOps.dll"
using APLNext
using APLNext.Legacy.NativeFileSystem
using APLNext.Legacy.ShareFileSystem

Note: On x64 versions of Windows, the APLNext directory will be located in the "Program Files (x86)" directory.
This will provide both the share file and native file system quads. You can include either of the NativeFileSystem or the ShareFileSystem or both in your project.
To include the [qaud]wi interface in your project:

refbyfile @"c:\Program Files\APLNext\APLNext\APLNext.Qwi.dll"
using APLNext
using APLNext.Qwi.WindowsInterface
This will provide access to the WI windows quads.
In addition to these quads, additional quads and primitives can be created and included in a project. For those who want to either create new quads or primitives, or simply override existing ones, this can be done using either Visual APL or any other .Net language.
The open source Colossal File System we have under way will be incorporated into Visual APL using this technique using the [quad]cfread, [quad]cfappend, etc. For additional information on this process, or if you would like to be involved in this project and obtrain more information about creating quads and primitives and other utilities for the Visual APL system please contact us. This entire structure is CLS compliant and works with all .Net languages.
For those who are building Visual APL systems which will be used by other .Net languages, such as C#, we have broken the APL variable dll out of the core Visual APL assembly. This means that the C# projects can reference the APL variable and then understand and easliy cast the data returned from Visual APL. This is of course CLS compliant.
In general, all of the primitives have been updated to address issues involving prototypes and identities. Significant effort has been put into making these compliant with the legacy APL systems.
In addition to being able to build new quads and primitives it is also possible to include apl functions and methods in your project. The using keyword has been extended to support classes. This is done to provide a mechanism for importing classes which contain both methods and APL functions and having the methods and APL functions locally available. This using extension supports both Visual APL classes and classes created in other .Net languages, such as C#, making it CLS compliant.
This capability also includes the ability to have the module of the class referencing the imported APL functions and methods automatically passed to the referenced method. This means that state information, such as index origin, random link, etc will be available to methods and APL functions created in any .Net language. Please see the screencast related to this capability for examples of how this can be done.
The primitives have been updated to include more legacy compatibility.
The Windows Designer now supports UserControls with the Windows Control Library template. This makes it possible to create UserControls using the Designer and then incorporate those controls in other windows forms either using the Designers or under program control. Check the screencasts for examples of how to create and implement UserControls.
Legacy APL control structures are now complete with this version. Including :andif, :orif, and :caselist.
Selective assignment has been fully implemneted to match the legacy APL systems.
Bracket indexing includes support for Choose Indexing (NARS)
Indexing using squad is now completely supported and matches legacy APL systems.
Inline assignment has been updated.
The CodeDom and Designers have been significantly updated. The improved CodeDom means that the designers are now far more reliable. The Designers also support the APL function signatures.
The documentation has been updated, but of course we have more to do on this. The online documentaion at www.VisualAPL.com has also been updated to match the documentation included in this version.
APL Function signatures now support specifying globals on the signature line where locals used to be defined. Keep in mind that you can mimick many of the legacy scoping scenarios for variables by implementing classes.

Visual APL Release Candidate 4.0 (RC4.0 - 15jan07)

Updates in Release Candidate Version 4.0:

This version is a major upgrade for us and includes significant updates to the all aspects of the Visual APL system.

The use of system file access, through the share file system and the native file system, as well as the use of the system windows classes has been moved to dll's which are not referenced in the Visual APL core system.
The use of the quads associated with these classes, such as [quad]fread, [quad]nread, and [quad]wi, can be included in a project by simply referencing and using the associated dll in your project. Using these associated quads without first including the associated dll will result in a syntax error.
This means that the assemblies created with Visual APL can be created without requiring access to either the file system or the windows systems. This is important when creating applications which will be installed in an environment where access to system resources is restricted.
To use the Visual APL File Systems in your project, add a reference to the Visual APL File System dll, or use the refbyfile keyword under program control:
Using the default path to the Visual APL File System, the following would make the quads available to your project:

refbyfile @"c:\Program Files\APLNext\APLNext\APLNext.APL.LegacyOps.dll"
using APLNext
using APLNext.Legacy.NativeFileSystem
using APLNext.Legacy.ShareFileSystem
Note: On x64 versions of Windows, the APLNext directory will be located in the "Program Files (x86)" directory.
This will provide both the share file and native file system quads. You can include either of the NativeFileSystem or the ShareFileSystem or both in your project.
To include the [quad]wi interface in your project:

refbyfile @"c:\Program Files\APLNext\APLNext\APLNext.Qwi.dll"
using APLNext
using APLNext.Qwi.WindowsInterface

This will provide access to the WI windows quads.
In addition to these quads, additional quads and primitives can be created and included in a project. For those who want to either create new quads or primitives, or simply override existing ones, this can be done using either Visual APL or any other .Net language.
The open source Colossal File System we have under way will be incorporated into Visual APL using this technique using the [quad]cfread, [quad]cfappend, etc. For additional information on this process, or if you would like to be involved in this project and obtrain more information about creating quads and primitives and other utilities for the Visual APL system please contact us. This entire structure is CLS compliant and works with all .Net languages.
For those who are building Visual APL systems which will be used by other .Net languages, such as C#, we have broken the APL variable dll out of the core Visual APL assembly. This means that the C# projects can reference the APL variable and then understand and easliy cast the data returned from Visual APL. This is of course CLS compliant.
In general, all of the primitives have been updated to address issues involving prototypes and identities. Significant effort has been put into making these compliant with the legacy APL systems.
In addition to being able to build new quads and primitives it is also possible to include apl functions and methods in your project. The using keyword has been extended to support classes. This is done to provide a mechanism for importing classes which contain both methods and APL functions and having the methods and APL functions locally available. This using extension supports both Visual APL classes and classes created in other .Net languages, such as C#, making it CLS compliant.
This capability also includes the ability to have the module of the class referencing the imported APL functions and methods automatically passed to the referenced method. This means that state information, such as index origin, random link, etc will be available to methods and APL functions created in any .Net language. Please see the screencast related to this capability for examples of how this can be done.
The primitives have been updated to include more legacy compatibility.
The Windows Designer now supports UserControls with the Windows Control Library template. This makes it possible to create UserControls using the Designer and then incorporate those controls in other windows forms either using the Designers or under program control. Check the screencasts for examples of how to create and implement UserControls.
Legacy APL control structures are now complete with this version. Including :andif, :orif, and :caselist.
Selective assignment has been fully implemneted to match the legacy APL systems.
Bracket indexing includes support for Choose Indexing (NARS)
Indexing using squad is now completely supported and matches legacy APL systems.
Inline assignment has been updated.
The CodeDom and Designers have been significantly updated. The improved CodeDom means that the designers are now far more reliable. The Designers also support the APL function signatures.
The documentation has been updated, but of course we have more to do on this. The online documentaion at www.VisualAPL.com has also been updated to match the documentation included in this version.
APL Function signatures now support specifying globals on the signature line where locals used to be defined. Keep in mind that you can mimick many of the legacy scoping scenarios for variables by implementing classes.

Visual APL Release Candidate 3.2 (RC3.2 - 19dec06)

Updates in Release Candidate Version 3.2:

Enhanced auto indentation and formatting in scripts
Pattern format puts a space at the end of scalars, this has been fixed
[]enlist of 807 array now correctly displays to the session.
Added []pp which sets NumberDecimalDigits property on the NumberFormatInfo class ([]nfi)
[]nfi enhanced and applied more generally
Updated display of mixed type data structures.
Fix for Intellisense where not all supported [] functions were diaplayed.
Fixed conflict where namespace and classname were the same
Fixed indent issue with diamond separators and control structures on one line
:while :until support added
Fixed indent issues in script editor.
:andif and :orif are now supported
These provide a subset of the standard && and || available for condition tests.
Conditional branch to labels is now supported
[]ncopy is now dyadic with source on left and destination on the right
[]nmove moves source file to target file, and if the source was tied, ties new target to the same tie number.
[]av updated
refdynamic supports loading a dll without exclusively tieing the dll
References added using Visual Studio project References are added using the refdynamic, which means you can edit a dll in other projects without having them exclusively tied.
High minus override for display of int and double added
[]nexists now returns 1 for existence of file or directory
[]NEXISTS on a name without a trailing slash/backslash reports if that name is in use at all (whether it's a file or directory). But if you explicitly put a slash or backslash on the end of the name, that's a signal to ONLY detect directories and will only return 1 if it is a real directory. That way you can easily detect if the name is in use, and a second call to []NEXISTS can then distinguish between a file or directory name if desired. (Description by Davin)
Assignment in indexing is now permitted as in: a[b=3] = 100
Display of nested arrays updated
Fixed dot in namespace related to APL function definition in classes
Fixed public keyword attribute with APL functions in classes
Comments are now preserved in the codedom.
And reduction Zilde and Or reduction Zilde updated
Pattern Format did not respect []NFI in some cases.
[]matiota updated.
Calling []NTIE monadically with a file name which was already tied would retie that same file to a different tie number. Fixed.
[]FERASE updated to properly delete component file and virtual directory of that virtual directory only contains the one component file and has the same name.
Negative take on scalars and matrices updated.
Extension for Visual APL files changed from cv to apl.
Support for menus, imagelist, statusbar enhanced in Windows Forms Designer
Paste Special in the Visual Studio Visual APL session now supports pasting of multiple lines.
Script window now remembers location and size
Enhanced support for prototypes
*/ and \ updated
boolean primitives updated to match .Net standard for true and false
Representation updated to promote to double if either argument is double
Without with scalars updated
Depth updated for prototypes
Rho updated for prototypes
Depth updated for nested string types.
Catenate/Laminate for zilde scalar combination updated
Updated shy results from execute
String literals with unicode escapes now matches .Net standard
string literals still support the u prefix and when combined with the @ prefix permits unicode escapes in raw strings
Enhanced syntax error reporting
Max and Min reduction of zilde now returns the miniumn and maximum datatypes
Fixed problem in Assign operator where nested scalar nested data would not have all references unlinked.
ToString of recursively self referencing variable fixed.

APLNext likes to thank everyone in the RC program for their suggestions and bug reports which have helped so much in creating RC3.2. Merry Christmas!

Visual APL Release Candidate 3.1 (RC3.1 - 5dec06)

The Visual APL MSI contains documentation, Visual Studio templates, libraries, and tools designed to help you develop Microsoft® Windows applications using Visual APL.