F-Script is an open-source interactive and scripting environment for Cocoa. Click here to download F-Script now. For more informations, see the project home at http://www.fscript.org.

F-Script 1.3.5 Release Notes

F-Script can now be compiled and run on Leopard with Xcode 3 (tested with build 9a410). Advanced Leopard support (including 64 bits support) is being worked on.

The new clear and clear: methods, provided by the System class, let you remove (i.e., undefine) variables from your workspace. The clear method removes all user-defined variables. The clear: method lets you specify the name of the variable you want to remove. Example:
> x := 2. y := 4. > {x, y} {2, 4} > sys clear:'y' "Remove the y variable from the workspace" > y error: undefined identifier "y" > sys clear "Remove all user-defined variables from the workspace" > x error: undefined identifier "x"

A multiple assignment syntax has been added, as an experimental feature. Example:

{x,y} := {2,4}

Now x is equal to 2 and y is equal to 4.

{x,y} := {y,x}

Now x is equal to 4 and y is equal to 2.

The right-hand side of the multiple assignment must evaluate to an array. The left-hand side must have the syntactic form of a literal array of identifiers (i.e., a list of identifiers between { and }, separated by commas).
New math methods on numbers:
- arcCosh computes the principle value of the inverse hyperbolic cosine of the receiver.
- arcSinh computes the inverse hyperbolic sine of the receiver.
- arcTanh computes the inverse hyperbolic tangent of the receiver.
- erf computes the error function of the receiver.
- erfc computes the complementary error function of the receiver.
Minor bug fixes.

Thanks to Ken Ferry (multiple assignment support).

F-Script 1.3.4 Release Notes

A bug in the log method that could lead to incorrect evaluation of logarithms for arrays of numbers has been fixed. You are advised to upgrade.

Updated documentation.

Minor UI improvements.

Minor internal improvements.

F-Script 1.3.3 Release Notes

F-Script is now Universal. It runs natively on both PowerPC and Intel-based Macintosh computers.

The object browser displays Cocoa bindings.

Rectangles are now printed using their extent (i.e. size) instead of their corner coordinates.

Minor UI improvements have been implemented.

This distribution of F-Script includes F-Script Anywhere 1.3, an amazing tool developed by Robert Chin and Nicholas Riley. F-Script Anywhere lets you dynamically inject F-Script into any Cocoa application and lets you take control of the objects inside the application and freely play with them. This new version of F-Script Anywhere requires Mac OS X 10.4 or later.

F-Script 1.3.2 Release Notes

The performance of the object browser has been considerably improved.

The object browser now displays the class hierarchy.

The code completion system, invoked by pressing F5, now inserts placeholders for method arguments. You can move to the next argument placeholder by typing Control–slash.

The examples in Documentation/EmbeddingFScriptExamples/ have been updated.

This version fixes a serious bug that could lead to a crash in some situations when running F-Script on Intel in native mode.

F-Script 1.3.1 Release Notes

F-Script has been modified to compile with GCC 4.0. The F-Script distribution is now built using GCC 4.0 and Xcode 2.2.1.
Re-objectification: in F-Script, the value of a managed object's property can now be set by direct message sending (without having to explicitly use KVC) even if the managed object does not implement the corresponding method.

For instance, if anEmployee is a managed object with a salary property, you can write:

anEmployee setSalary:2000

instead of:

anEmployee setValue:2000 forKey:'salary'
It is now possible to throw and handle any Objective-C object as an exception object (you are no more limited to NSException objects). To let you throw an object, the throw method has been added to FSNSObject, a category of NSObject. Example:

['hello' throw] onException:[:exception| sys log:exception]

The F-Script code above is equivalent to the following Objective-C code:
```
@try
{
  @throw @"hello";
}
catch (id exception)
{
  NSLog(exception);
}
```

The executeWithArguments: method has been added to the Block class. This method executes a block and returns an FSInterpreterResult object describing the outcome of the execution. This is primarily useful when you want to use F-Script from Objective-C code. The FSinterpreterResult object lets you access either the result of the execution or a precise description of the error that resulted from the execution. Example:

// Create an F-Script block
Block *myBlock = [@"[:a :b| a/b]" asBlock];

// Prepare the arguments for block execution
NSArray *arguments = [NSArray arrayWithObjects:[NSNumber numberWithInt:10], [NSNumber numberWithInt:0], nil];

// Execute the block and get back an FSInterpreterResult instance
FSInterpreterResult *interpreterResult = [myBlock executeWithArguments:arguments];

// Deal with the result of the execution  
if ([interpreterResult isOK])
  NSLog(@"Execution OK. Result = %@", [interpreterResult result]);
else
  NSLog([interpreterResult errorMessage]);

When executed, this code will log "error: division by zero".

It is now possible to call methods that take or return CGPoint, CGSize or CGRect structs. F-Script uses the same mapping rules as the ones used for NSPoint, NSSize and NSRect structs.
- A CGPoint is automatically mapped to an NSValue containing an NSPoint.
- A CGSize is automatically mapped to an NSValue containing an NSSize.
- A CGRect is automatically mapped to an NSValue containing an NSRect.

Support for AppleScript has been improved. The "eval" command, which can be used to evaluate an F-Script expression from AppleScript, now maps NSNumbers, NSArray, NSDate, NSDictionary, NSData, NSString and NSAttributedString objects to their AppleScript equivalents instead of just returning a text based description of the object.

The key handling model in the F-Script command line interface has been improved. Standard key combinations like ctrl+p or ctrl+n are now supported, and the system integrates better with the standard Mac OS X key bindings system.
The display of dictionaries in the object browser has been improved.

The object browser has been extended to displays more information about several Cocoa classes.

A descriptive error message is now displayed when an error occurs while processing the latent block.

A number of internal improvements have been made (complete rewrite of the exception system, code refactoring etc.). As part of these internal changes, several deprecated classes and methods have been removed:
- The enclose and enclose: methods in the FSNSObject category.
- The replication: and rotation: methods in the Array class.
- The transposition: and fsmap methods in the FSNSArray category.
- The fsmap method in the FSNSNumber category.
- The asMutableString method in the FSNSString category.
- The mod: method in the Number class.
- The installTutorial method in the System class.
- The FSPoint, FSSize, Range and Rectangle classes.

Several minor bugs have been fixed.
F-Script 1.3.1 requires Mac OS X 10.3 or later. F-Script 1.3 is still available for Mac OS X 10.2 users.
Thanks to:
- Phil Bellalouna for improving the startup sequence.
- Stephen C. Gilardi for his contribution to the key handling model.
- Alykhan Jetha for improving to the AppleScript interface.
- Jonathan 'Wolf' Rentzsch for his help testing F-Script.
- Andy Stark for editing the bookmarked documentation.

F-Script 1.3 Release Notes

The purpose of this version is to let you make the most out of Mac OS X 10.4. F-Script has been enhanced on many levels to provide interactive access to the new technologies in Mac OS X 10.4. For example, the object browser can now display rich information about new components in the Application Kit, the symbols defined in the Objective-C-based frameworks of Mac OS X 10.4 are available from F-Script, etc. In addition, F-Script.app is now automatically linked with a number of new frameworks found in Mac OS X 10.4. The complete list of frameworks F-Script.app is now automatically linked with is:

AddressBook
Automator
Cocoa
CoreData
CoreAudioKit
ExceptionHandling
DiscRecording
InstallerPlugins
InstantMessage
IOBluetooth
IOBluetoothUI
JavaVM
OSAKit
PDFKit
PreferencePanes
QTKit
QuartzCore
QuartzComposer
ScreenSaver
SecurityFoundation
SecurityInterface
WebKit
XgridFoundation

Loading other frameworks or bundles is easy. See section 11 of the F-Script guide.
Various UI improvements have been implemented (e.g. displaying a sort indicator image in the collection inspector, remembering window size and position etc.)

A QTMovie inspector has been implemented.

A sign method has been added in the FSNSNumber category. This method answer 1 if the receiver is positive, 0 if the receiver equals 0, and -1 if it is negative.

Several bugs have been fixed.

Thanks to Andy Stark, this version comes with a convenient bookmarked guide.

Core Data Explorer 1.0.

F-Script now includes Core Data Explorer 1.0, a technology providing interactive access to the new Core Data layer in Mac OS X 10.4.

With Core Data Explorer you can:
- Explore whole managed objects graphs with a powerful graphical object browser.
- Delve into collections of managed objects with a graphical collection inspector.
- Enter and evaluate Core Data queries interactively.
- Manipulate managed objects with OOPAL, the high level object-oriented programming model of F-Script.
- Programmatically access the Core Data API interactively from the F-Script environment.
You can use Core Data Explorer from the F-Script application or your own applications. You can also inject it into any third-party Cocoa application by using F-Script Anywhere.

The object browser let you freely explore and manipulate the object graph and the Core Data stack. In addition, inspecting a collection of managed objects brings up a fully configured collection inspector with which you can further delve into your objects. A managed object context inspector lets you interactively query an NSObjectContext using the predicate language introduced in Mac OS X 10.4.

OOPAL, the high-level programming model of F-Script, let you easily manipulate Core Data managed objects. Example: attaching a managed object context to the current F-Script workspace and manipulating it using OOPAL

F-Script 1.2.8 Release Notes

By default, F-Script now opens an object browser at launch time, in addition to the command line interface. This behavior can be changed from the preference panel.

The NSSearchField-based filter in the object browser has been extended to act on every entry in the browser, including entries in the "object info" sections and in the workspace column.

The object browser now displays object description, information, properties and methods in the same column. This makes it easier to browse object graphs.

The support for pointers has been improved. This version introduces three new classes for pointer management. These classes are FSPointer, a semi-abstract class, and its two concrete subclasses: FSGenericPointer and FSObjectPointer. The old Pointer class is now deprecated.

Here is an example of how a method taking an NSError** as argument can be used from an F-Script interactive section. In this example, we call the hypothetical -(id)dataWithContentsOfFile:(NSString *)path error:(NSError **)error method and then look at the generated NSError object.

> errorPtr := FSPointer objectPointer > data := myObject dataWithContentsOfFile:'wrongPath' error:errorPtr > errorPtr at:0 NSError "File “wrongPath” does not exist." Domain=NSCocoaErrorDomain Code=260 UserInfo={ NSFilePath = wrongPath; NSUnderlyingError = NSError "POSIX error: No such file or directory" Domain=NSPOSIXErrorDomain Code=2; }

JGType, a new module contributed by Jörg Garbers, provides the ability to create new classes from within F-Script. The support for this feature is experimental in F-Script and is likely to evolve in future versions. (Documentation forthcoming)

Most of the new symbolic constant names defined in Tiger's Objective-C based frameworks are now available in F-Script.

Various minor UI and stability improvements have been implemented.

CoreData Explorer (Tiger only) gains the following features:

In the object browser, the values of a managed object's properties are now displayed in the same column as the managed object itself. Thus, the entire content of a managed object can be visualized directly.

With the introduction of CoreData specific "object info" sections, the object browser lets you easily access and explore the whole CoreData stack (object models, object contexts, predicates etc.)

In F-Script, the value of a managed object's property can be obtained by direct message sending (without having to explicitly use KVC) even if the managed object does not implement the corresponding method.

For instance, if anEmployee is a managed object with a salary property, you can write:

anEmployee salary

instead of:

anEmployee valueForKey:'salary'

The System class provides an instance method, named attach:, which takes a managed object context as argument. For each entity associated with the managed object context, this method defines, in the workspace associated with the receiver, an NSArray which is given the same name as the entity and which contains all the managed objects corresponding to the entity at the time of invocation.

For instance, if myObjectContext is a managed object context associated with an Employee entity and a Department entity, then, after executing:

sys attach:myObjectContext

the F-Script workspace will contains two new arrays, named Employee and Department. These arrays will contain the managed objects for their corresponding entities: the Employee array will contain all the employees and the Department array will contain all the departments.

This method is likely to bring in memory the whole persistent object graph associated with the object context. In practice this should not be a problem, unless you deal with very large data-sets. In such cases you should avoid using this method.

Note that attach: is a convenience method. You still have full access to the CoreData framework and can use its various APIs to get access to managed objects.

F-Script 1.2.7 Release Notes

The collection inspector has been improved in the following ways:
- In order to improve readability, the collection inspector no longer uses enclosing quotes when displaying the value of a string.
- Compact blocks attached to columns are now displayed without the starting "#" character in column's headers.
- Blocks of the form [:object| object valueForKey:'akey'] are displayed as aKey in column's headers.
- The collection inspector now provides an easy to use multi-step, multi-criteria searching and sorting facility. A new button in the toolbar, titled "Narrow", creates a new collection containing the selected objects (or all the currently filtered objects if the selection is empty) and opens a new inspector for this collection. It is then possible to further refine the exploration.

The NSSearchField-based filter in the object browser will now filter class names (when browsing classes using the "Classes" button), in addition to methods.

The object browser is able to display more information about several common Cocoa classes.

The object browser now automatically fills the argument sheet's form with templates for some argument types (currently including NSRange, NSSize, NSPoint, NSRect, and SEL).

A new button, titled "Browse", has been added to the object browser. It opens a new browser for the selected object.
F-Script 1.2.7 introduces CoreData Explorer, a new technology available when running on Mac OS X Tiger. In this version, CoreData Explorer is available through the following features:
- The object browser now displays properties of CoreData managed objects and lets you easily interact with and explore the object graph.
- When a collection contains CoreData managed objects of the same type, the collection inspector automatically configures itself for displaying the properties of the objects.
The Pointer class has been extended and refined in several ways. In particular, Pointer objects can now be dereferenced, using the new at: and at:put: methods. This makes F-Script more effective for dealing with Objective-C APIs involving custom C pointers.

The method at: defined for NSArrays by the FSNSArray category can now be invoked with an NSIndexSet as argument (in addition to the already supported argument types).

The method at:put: defined for NSMutableArrays by the FSNSMutableArray category now accepts whole arrays of indices, Boolean arrays and NSIndexSets, like the at: method. This makes it easy to replace several elements of the receiver at once.


> a := {10, 20, 30, 40, 50}

> a at:{0, 2} put:{'hello', 'world'}

> a
{'hello', 20, 'world', 40, 50}

> a at:{true, false, true, true, false} put:{999, -111, 66}

> a
{999, 20, -111, 66, 50}

> a at:(a > 40) put:0

> a
{0, 20, -111, 0, 0}

> indexSet := NSMutableIndexSet indexSet. indexSet addIndex:0. indexSet addIndex:3.

> a at:indexSet put:{'Hi', 'mom'}

> a
{'Hi', 20, -111, 'mom', 0}

> a at:indexSet put:33

> a
{33, 20, -111, 33, 0}

The method removeAt: defined for NSMutableArrays by the FSNSMutableArray category now accepts whole arrays of indices, Boolean arrays and NSIndexSets, like the at: method. This makes it easy to remove several elements of the receiver at once.

New bit manipulation methods, defined for NSNumbers by the FSNSNumber category, are available:
- The method bitAnd: returns the result of the bit-wise logical AND of the binary representation of the receiver and the binary representation of the argument.
- The method bitOr: returns the result of the bit-wise logical OR of the binary representation of the receiver and the binary representation of the argument.
- The method bitXor: returns the result of the bit-wise exclusive OR of the binary representation of the receiver and the binary representation of the argument.

A timesRepeat: method is now defined for NSNumbers by the FSNSNumber category. This method evaluates the argument, a block, the number of times represented by the receiver. An example is:

> i := 0 > 10 timesRepeat:[i := i + 1] > i 10

A set of new methods for generating random numbers has been defined on NSNumber by the FSNSNumber category:
- The method random returns a random integer between 0 and the receiver - 1 (e.g., 5 random will return either 0,1, 2, 3, or 4).
- The method random: wich takes an number as argument, returns an array of size equal to the argument, of random integers between 0 and the receiver - 1. All the elements of the result have a different value and are returned in a random order.
- The method seedRandom sets the value of the receiver as the seed for a new sequence of pseudo-random numbers to be used by random and random: to compute their results.
The old rand method is now deprecated.

Performance of the F-Script interpreter has been widely improved when dealing with blocks that take arguments or have local variables, which is a common situation.

Note that as a result of changes in the implementation, blocks archived using this version of F-Script will not work correctly when loaded in older versions. However, blocks archived with older version of F-Script will work correctly with this version.

Performance of search operations in arrays (e.g., indexOfObject:, containsObject: etc.) has been improved.

The display of very large arrays in the object browser has been made faster.

F-Script can now be used through the "Services" menu from other applications (code submited by Joerg Garbers).

The objects supporting the F-Script "Flight" tutorial have been made KVC compliant and have been extended in order to support the examples used in the OOPAL paper.

The "Flight" tutorial is no longer installed automatically at launch time. To install it, one must invoke the method -(void)installFlightTutorial on the predefined sys object (note that this method replaces the -(void)installTutorial method, which is now deprecated).

One-line Objective-C-like comments (i.e. comments starting with //), which have been deprecated a long time ago, are no longer supported.

Messages with selectors starting with ":" are now supported.

The following initialization methods have been implemented for the Number class:
- (id)initWithChar:(char)value; - (id)initWithUnsignedChar:(unsigned char)value; - (id)initWithShort:(short)value; - (id)initWithUnsignedShort:(unsigned short)value; - (id)initWithInt:(int)value; - (id)initWithUnsignedInt:(unsigned int)value; - (id)initWithLong:(long)value; - (id)initWithUnsignedLong:(unsigned long)value; - (id)initWithLongLong:(long long)value; - (id)initWithUnsignedLongLong:(unsigned long long)value; - (id)initWithFloat:(float)value; - (id)initWithBool:(BOOL)value; These methods come in addition to the existing initWithDouble: method, which is the designated initializer for this class.

F-Script.app is no longer automatically linked to the Message framework.

The documentation has been improved, consolidated and simplified (in particular, there is no longer any distinction between user and developer sections in the reference documentation).

Several bugs have been fixed.

F-Script 1.2.6 Release Notes

The object browser has been widely improved. In particular:
An NSSearchField-based method filter has been added to the toolbar (on Mac OS X 10.3 and later only).
The object browser has more built-in knowledge of common Cocoa classes and design patterns.

A collection inspector has been implemented. The inspector lets you graphically inspect NSArray, NSDictionary and NSSet objects. It is based on an evolution of the graphical array inspector introduced in version 1.2.3, and comes with new features (including, on Mac OS X 10.3 and later, an NSSearchField-based row filter). You can open it from the object browser by double clicking on a collection or sending the inspectIn: or inspectIn:with: messages to a collection.

The code completion system has been improved and is now based on Panther's NSTextView completion layer, which provides a better user interface (on Mac OS X 10.3 and later only). Note: code completion is invoked by pressing the F5 key.

F-Script now uses the new standard Find panel (on Mac OS X 10.3 and later only).

Undo/redo is now available in block inspectors (on Mac OS X 10.3 and later only).

An NSAttributedString inspector has been implemented. It shows the interpreted attributed string and also displays the description of the attributed string as returned by the printString method.

The block inspector now has a "Run" button in its toolbar. This button makes it possible to evaluate the block from the inspector itself. The result of the evaluation is shown in the object browser.

FScriptMenuItem, a new public subclass of NSMenuItem, lets you easily embed a complete F-Script environment into an application.
The F-Script palette for Interface Builder now contains an FScriptMenuItem.
An NSFont inspector has been implemented. It opens the font panel and shows the font.

The F-Script run-time has been made thread safe. It is now possible to use F-Script concurrently from multiple threads in the same process. Note that classes provided by the F-Script framework (e.g. Array, Block, etc.) are generally not thread safe when sharing instances: you should synchronize appropriately if you share instances of these classes between multiple threads. However, note that the following F-Script classes are thread safe: FSBoolean, FSVoid, Number.
F-Script includes several categories adding methods to standards Cocoa classes. Categories that apply to Cocoa classes documented as thread safe do not break thread safety.
Note that you should not share workspaces or block environments between multiple threads. If you need to execute multiple chunks of F-Script code concurrently, you should use a different FSInterpreter instance for each one.

Local variables in a block are now automatically initialized to nil when the block is evaluated. This is in line with the ANSI Smalltalk standard.

Methods taking arguments of type _Bool or returning a value of this type can now be invoked from F-Script. FSBooleans objects are automatically mapped to _Bool values by F-Script. _Bool is a new type introduced by the ISA/IEC 9899 (aka C99) standard and now supported by GCC.

In previous versions, the F9 and F10 function keys were used for Parenthesizing and Switching the paste parsing modes. We now use the F8 and F7 function keys instead.

The methods enclose and enclose: defined in FSNSObject are deprecated, use enlist and enlist: instead (same semantics).

In order to improve integration with Cocoa (in particular, in the context of key-value coding), this version introduces a new way of dealing with the NSRange, NSPoint, NSRect and NSSize data types.

Values of these types are now represented in F-Script using NSValue objects. The wrapping and unwrapping of such values in/from NSValues object is performed automatically by F-Script when needed, allowing one to invoke, from F-Script, methods that take or return such values.

In previous versions, F-Script provided separate classes to represent NSRange, NSPoint, NSRect and NSSize values. These classes (i.e., Range, FSPoint, Rectangle and FSSize) are still provided for backward compatibility, and automatic unwrapping from instances of these classes to corresponding C structs is still performed. The new FSNSValue category adds to the NSValue class a set of methods similar to the methods provided by the four old classes. This provides a good support for backward compatibility and transparent migration. However, a few of the methods implemented by the old classes are not provided by the FSNSValue category. Thus, you may have to modify your code if it makes use of these methods; either by eliminating the need to call these methods or by ensuring your code invokes them on an instance of the correct old class instead of on an NSValue.
See the F-Script documentation for a complete description of the old classes and the new FSNSValue category.

F-Script.app is now automatically linked with the WebKit (on Mac OS X 10.3 and later only).

The open source license applying to F-Script has been changed and is now based on the modified BSD license.

F-Script 1.2.5 Release Notes

The main new feature in F-Script 1.2.5 is support for Mac OS X 10.3. The previous version would launch on 10.3 but crash on some operations.

A few bugs have been fixed.

The documentation has been improved, with a widely enhanced version of the OOPAL paper.

WARNING -> BACKWARD INCOMPATIBLE CHANGE: In the previous version, when a method's return type was char * (or unsigned char *), F-Script automatically mapped the returned char pointer to an NSString object when this method was invoked from F-Script. Also, in the previous version, when a method's argument type was char * (or unsigned char *), you had to provides an NSString object for this argument when invoking this method from F-Script. Starting with F-Script 1.2.5, this mapping between char * (and unsigned char *) and NSString no longer happens. Now, char * (and unsigned char *) are mapped to Pointers objects.

Example:

F-Script 1.2.4

> 'foo' cString 'foo' > NSString stringWithCString:'foo' 'foo'
F-Script 1.2.5

> 'foo' cString Pointer to 0x1223629 > NSString stringWithCString:'foo' cString 'foo'
This change is not backward compatible. If your current F-Script code calls methods that return or take pointers to characters as arguments, you may have to modify it.

You can use the user default mapCharPointerToNSString, on a per application basis, to restore the old mapping behavior. For instance, in the Mac OS X terminal, type defaults write org.fscript.fscriptapp mapCharPointerToNSString YES to restore the old mapping behavior for the F-Script application, and type defaults write org.fscript.fscriptapp mapCharPointerToNSString NO to get back to the new behavior.

The user default logWhenMappingCharPointerToNSString may help you determine where you are dependent on the old behavior in your current F-Script code. Setting this default to YES will configure F-Script to log a message (using NSLog()) of the form "Deprecated mapping of char * to NSString when calling method methodName". For instance, in the Mac OS X terminal, type defaults write org.fscript.fscriptapp logWhenMappingCharPointerToNSString YES to activate logging by the F-Script application, and type defaults write org.fscript.fscriptapp logWhenMappingCharPointerToNSString NO to disable logging. This user default is only useful when the mapCharPointerToNSString user default is also set to YES.

F-Script 1.2.4 Release Notes

The integration between F-Script and Cocoa has been improved. These changes are backward compatible.
- F-Script now uses Cocoa's NSNumber class cluster to represent numbers. All the methods previously defined by the Number class have been added to NSNumber through the FSNSNumber category. All the public APIs previously using the Number class (for argument and/or return values) now use the NSNumber class. The Number class is now a subclass of NSNumber.
- F-Script's array programming model can now be used on any NSArray object. All the methods previously implemented by the Array class have been implemented for NSArray and NSMutableArray, through the FSNSArray and FSNSMutableArray categories.
The documentation has been extended with a new paper OOPAL: Integrating Array Programming in Object-Oriented Programming (note: this is a preliminary draft. The final version of the paper will be presented at OOPSLA this fall).
Inter-framework dependencies have been greatly reduced for FScript.framework and FScriptPalette.palette. These modules are now only statically linked with the Foundation, AppKit, ExceptionHandling, JavaVM and InterfaceBuilder (FScriptPalette.palette only) frameworks. In the previous version they were statically linked with several other frameworks including AddressBook, DiscRecording, IOBluetooth, etc.
The repository is now created by default at "~/Library/Application Support/F-Script".
The method -(FSSize *)size has been added to class Rectangle. Returns a Rectangle's extent as an FSSize object.
The method -(id)fsmap of category FSNSNumber is deprecated.
The method -(id)fsmap of category FSNSArray is deprecated.
The method -(BOOL)hasFrac_bool of category FSNSNumber is deprecated.
Several bugs have been fixed.

F-Script 1.2.3 Release Notes

A graphical array inspector has been implemented. You can open it from the object browser by double clicking on an NSArray or sending the inspectIn: or inspectIn:with: messages to an NSArray.

Example 1: P inspectIn:sys

Example 2: P inspectIn:sys with:{#name, #salary, [:pilot | pilot salary >200000]}

As you see, each column (except the "index" column) is associated with a one-argument block. Each block is evaluated for each element of the array and the result is displayed in the inspector.

The Add button lets you add and configure a new column. The Modify button lets you modify the block associated with the selected column. You will have the possibility to enter the code of the block through the graphical block inspector.

The Remove button lets you remove the selected column. The Sort button lets you sort the rows according to the values associated with the selected column. The Inspect button opens an inspector for the array's element associated with the selected row (you can also double click on a row). The Browse button opens an object browser for the array's element associated with the selected row. The Refresh button re-compute and redisplay the table.
The stunning "Associate with interface" feature of F-Script Anywhere is now available in F-Script as well. A new button, called "Select View" has been added to the object browser. This button lets you select an NSView graphically by just clicking on it on-screen! The selected view is then displayed in the object browser.

Step 1: Click on the "Select View" button -> the cursor change to a cross.
Step 2: Click on a visual part of the current application -> F-Script finds the view object that has been clicked on, and selects it in the object browser.

Idea and part of the code borrowed from Nicholas Riley's F-Script Anywhere.
For easier navigation, the object browser now displays additional information (target, subviews etc.) when browsing some classes like NSView, NSWindows, NSCell and others.
Whenever possible, the object browser now gives indications about the kind of the arguments you have to provide to the selected method.
An advanced customization feature has been added to the object browser toolbar, implemented from an idea and first prototype by Joerg Garbers. As an F-Script user, you can now completely customize up to ten buttons that can be added to the object browser toolbar. This specific customization process is initiated by the standard toolbar customization process (e.g. selecting the "Customize toolbar" menu item).

Double-clicking an object in the object browser opens an inspector for this object.
An NSImage inspector has been added.

Example: (NSImage alloc initWithContentsOfFile:'/Library/Desktop Pictures/Nature/Ladybug.jpg') inspect
The preference panel of the F-Script application now allows setting whether F-Script should ask for confirmation when quitting.
F-Script is now automatically linked with a number of the new frameworks found in Jaguar. The complete list of frameworks F-Script is now automatically linked with is:

AddressBook
AppKit
ExceptionHandling
DiscRecording
Foundation
IOBluetooth
IOBluetoothUI
JavaVM
Message
PreferencePanes
ScreenSaver

APIs in these frameworks can be accessed from F-Script without requiring any configuration. For instance, typing ABAddressBook sharedAddressBook people valueForProperty:kABLastNameProperty returns the names of people registered in your address book.

Here is another example, using the new array inspector to display the first name, last name and organization of people registered in your address book:
ABAddressBook sharedAddressBook people inspectIn:sys with:{ [:p| p valueForProperty:kABFirstNameProperty] ,[:p| p valueForProperty:kABLastNameProperty] ,[:p| p valueForProperty:kABOrganizationProperty]}

Loading other frameworks or bundles is easy. See section 11 of the F-Script guide.
In previous versions, it was not possible, from F-Script, to call methods taking pointers as arguments or returning a pointer (other than object pointers and char *). F-Script now supports these methods, thanks to the new user class Pointer. C pointers are now automatically mapped to Pointer instances. See the user guide for more about the Pointer class.
The user method guardedValue: has been added to class Block. This method executes the receiver and returns the result. If an error occurs during execution, it displays the block call stack to the user and returns nil. This method is useful when you want a block to be the target of an NSControl (for instance a button). Instead of using value: as the action method, you may use this method in order to have the block inspector pops-up automatically in case of error.
The sort method of the Array class has been rewritten. The previous version of sort was not preserving pre-existing order among equal elements (that is, if two elements compared as equal, the order of their indices in the sorted array was undefined). The new version is "stable": it preserves pre-existing order among elements that are equal, which is quite useful in typical data-analysis use-cases.
The class method +(BOOL)validateSyntaxForIdentifier:(NSString *)identifier has been added to FSInterpreter. Returns YES if the argument conforms to the syntax of identifiers in the F-Script language.
Support for the new keyed archiving system introduced in Jaguar has been implemented. Archives created by the save and save: method will use keyed archiving. The load and load: methods are able to read keyed archives, as well as old-style archives. F-Script public classes support both archiving styles.
A number of goodies from Joerg Garbers have been added -> see the directory JGAdditions in the source code distribution.
The user method < has been added to class FSBoolean.
The user method < has been added to class NSNumber (through the FSNSNumber category)
The user methods browse and browse: have been added to the FSInterpreter class. Opens an object browser.
The user methods browseKV and browseKV: have been added to the FSInterpreter class. Opens a key value object browser.
The user method truncated has been added to class Number. Answer an integer equal to the receiver truncated towards zero.
The user method prefix of class Array is deprecated. Use the prefixes method instead (same semantics).
The user method mod: of class Number is deprecated. Use the rem: method instead (same semantics).
The user method replication: is deprecated. Use replicate: instead. (same semantics).
The user method \\ of class Array and FSNSArray category is deprecated. Use the scan: method instead (same semantics).
The user method rotation: of class Array is deprecated. Use rotatedBy: instead (same semantics).
The user method transposition: of class Array is deprecated. Use transposedBy: instead (same semantics).
The user method asMutableString (provided by FSNSString) is deprecated.
Various UI improvements not described here have been implemented.
Several bugs have been fixed.
This note shows how to use the Java bridge from F-Script. This is not an officially supported feature and it requires you to know about the Java bridge usage and limitations.

The Java bridge lets you access Java objects. You first need to enable Java access in F-Script. This is done by invoking the enableJava method on the current System object: sys enableJava

You can then ask F-Script for objects representing Java classes, using the method asClass on a string. For instance, to get an object representing the java.util.Stack class, you just have to type the expression: 'java.util.Stack' asClass

You can then create a Java Stack instance using the new method and play with it. Example:
> myStack := 'java.util.Stack' asClass new > myStack [] > myStack push:'hello' 'hello' > myStack ['hello'] > myStack push:55 55 > myStack push:NSApplication sharedApplication NSApplication: 0x4459e0 > myStack [hello, 55.0, NSApplication: 0x4459e0] > myStack peek NSApplication: 0x4459e0 > myStack empty false > myStack contains:55 true You can even manipulate Java objects with the object browser.
Example: sys browse:myStack