VBEX

VBA Extension Library

Intro

Ease production of VBA code with the VBEX library of rich idiomatic containers and some functional programing capabilities to bring VBA into the new millenium. With VBEX you can:

1. Use Class Constructors for immutable classes.

2. Print meaningful debug methods that reveal a datastructures contents

   Console.PrintLine List.Create(1, 2, 3, 4) ' Note usage of class constructors List(1, 2, 3, 4)

3. Create functional objects to use with higher order functions. With those we have created some monadic classes (List, Maybe, Try) that implement the traditonal Map, FlatMap or Bind methods.

4. Access a growing library of Containers.

5. Perform file-system operations.

   • These will later be replaced or enhanced with an object-oriented model

6. Later there will be APIs for ADODB (SQL) and Windows Scripting Host 2. ADODB/SQL implemented with SqlConnection, SqlCommand, and SqlResult!

Install

Once you acquire the source by either cloning this repo or downloading zip and extracting

1. Run the Make.ps1 script to build VBEXsrc.xlam and VBEXtest.xlam.
   • VBEXtest.xlam contains unit-testing code and is only relevant to development.
2. Reference VBEXsrc.xlam in projects to use VBEX
   • From the VBE from the menu tools >> References >> Browse.
3. Enable "Programmatic access to Office VBA project"
   • This is required for the Lambda class as it auto-generates code in a blank module.

Usage

VBEX is not a normal VBA library, before you start using you should understand the following aspects about VBEX.

Predeclared Objects

All public classes have a predeclared instance of that class called the "predeclared object".

• The predeclared object has the same name as the class, e.g.

Dim xs As List ' word "List" as a type
Set xs = List.Create(1, 2, 3) ' word "List" here is the predeclared object

• All creatable classes are created from the predeclared object.
• Predeclared objects of mutable classes can be mutated, but there is no reason for one to ever do so.

Inheritance

Since VBA has only Interface Inheritance, code that would be put in parent or abstract classesis instead put into def* modules. While this reduces code duplication, it only reduces it to trivial code like,

Public Function IsSubSetOf(ByVal other As SetLike) As Boolean
    
    IsSubSetOf = defSetLike.IsSubSetOf(Me, other)
    
End Function
Private Function SetLike_IsSubSetOf(ByVal other As SetLike) As Boolean

    SetLike_IsSubSetOf = IsSubSetOf(other)

End Function

This screams for some macro or preprocessing system, but that doesn't exist yet.

Applicable

Implementations of the Applicable interface allow methods and functions to be treated as objects.

• All Applicable objects are immutable.
• The Lambda class writes functions to a VBEX modules and allows you to execute that code.
  • Using the Lambda class will sometimes disable the debugger.
  • A lambda has no reference to environment in it was created.
    • Lambda.FromShort("_ + x") will always error even if x is in the current scope.
• OnArgs and OnObject are complementary.
  • OnArgs.Make(myObject, "method", vbMethod) is (x) => myObject.method(x)
  • OnObject.Make("method", vbMethod, myArgs) is (o) => o.method(myArgs)
  • These are the only applicable objects that have references to the current environment.