Lambda the Ultimate

ObjectiveCLIPS, a programming environment specifically designed for Cocoa, the native Mac OS X object system, has been updated to version 1.7. The new release includes a number of significant performance improvements along with a new execution trace feature that provides extensive logging of trace information during development.

ObjectiveCLIPS integrates the popular NASA-developed CLIPS expert system shell with Apple's Core Data technology and F-Script, allowing the creation of intelligent Cocoa applications with persistent object models and complex business rules. Developers can easily embed ObjectiveCLIPS in their application and take advantage of its powerful inference engine and associated tools to implement their application logic.

ObjectiveCLIPS unifies CLIPS facts with Core Data Objective-C objects, and allows for the manipulation of these objects with the Cocoa-based F-Script language in rules. By bringing the latest innovations in Mac OS X and object-oriented scripting together with the power of the CLIPS artificial intelligence environment, ObjectiveCLIPS provides a unique foundation for building smart Mac OS X applications.

ObjectiveCLIPS is open source software. It can be downloaded from http://www.ObjectiveCLIPS.com

Hi all,
I wanted to make a simple little language where I would simply be able to define and apply expansions in strings, something like:

bonjour: return {hello, namaste}

eval hellothisisatextstringbonjursomemoreenglishtext

output: {hellothisisatextstringhellosomemoreenglishtext, hellothisisatextstringnamastesomemoreenglishtext}

Perl regular expressions would've been sufficient, nice and clean, but I can't return lists like above.

Just scratching my head, there may be something obivous I am missing.

Hi,
I'm interested in languages which do compile time restrictions on the values of variables. Specifically, does anything like the following exist:

x : int [0, 2, ... 10]
x = 50 //error
x = 3 // error
x = 2 // ok

x = rand() // error, rand() : [0.0 ... 1.0] doesn't match [0, 2, ... 10]
x = floor(rand() * 2) * 2 // ok [0, 2, 4] is a subset of [0, 2, ...10]

Thanks,

Alex

Reading this I got curious, so I did some googling (natrually). This is what I came up with.

If someone knows more, please share!

Macromedia flex has a very powerfull data-binding mechanism. When we started to use Flex we had heaps of code to manage events. We were also suspicious about mixing content and behaviour. What a mistake!
Progressivly we've been using the declarative syntax of data-binding and our amount of code has reduced enourmously.
In fact we don't event think of it as code, we think of it as magic statements that just glue everything :)

(I posted this initially to comp.lang.misc and was told to try here instead)

I'm implementing a vaguely scheme-like scripting language and I'm a
unclear on how to make multimethods work (not just within an object
system, but with all the language types). Are "types" just symbols or
do they require their own namespace?

(defun f ( (x 'int) (y 'string)) (...code))
-or-
(defun f ( (x (resolve-type int)) (y (resolve-type string)) ) (...code))

Should I combine the concept of class and and type? This seems
problematic since I want objects to be runtime-modifiable (add/remove
methods). I was also considering making predicate types as the basis
for method resolution (obj has_method x, etc..), but then how do I fit
in primitive types?

I guess I'm a bit overwhelmed with type systems and would appreciate
some direction.

Thanks,
-Alex

I just read this post from Paul Graham's new blog. It turns out he has a patent for using continuations to make page transitions look like function calls. The patent number is 6,205,469. Makes me a little sad.

Python has a language feature that's been brought up here a couple of times before, whereby a function can return a value, but remember it's current point of execution, and restart execution from there the next time the function is called. Here's a simple example:

def myrange(a, b):
   while a <= b:
      yield a
      a += 1

I'm curious if any work has been done looking into making generators more arbitrarily maniputable. If I want to define a function reverse(myrange(1, 10)), Python will have to do the entire generation at once and then perform the reversal. This eliminates one of the key advantages of generators -- making only one object at a time, and thus saving memory and potentially latency.

What I'm curious about is if anyone's done any work into what constraints would be necessary on generators (obviously they couldn't have arbitrary python code as they can now) to make it so that a reverse() would be possible that would still have each value be generated once a time, just in reverse. Presumably such a solution would be powerful enough to implement things like step too (currently to get the effect of step with a generator you have to just throw values out).

I've been reading van Roy and Haridi's Concepts, Techniques, and Models of Computer Programming. It is an exciting and thought-provoking work. I have one major criticism of it that I thought LtU participants might be interested in discussing. While Oz does a great job of incorporating multiple programming models into a single language, to me what it lacks is a way of constraining oneself to a particular model or set of models, and demonstrating to others that these constraints have been met.

For example, I would like a way to assert that a function is declarative (i.e. is truly a function), and have this be enforced. I suppose this would have to be enforced at run-time to fit with the dynamically typed language design. Also, I'm not sure how this would be enforced; a conservative strategy would be to consider any use of NewCell or Exchange as non-declarative, but this would yield "false positives" in cases where state is used in a function that is still observationally declarative (e.g. is just using state for memoization).

Perhaps I want something more like monads in Haskell, where the fact that function that is not observationally declarative will be reflected in its type (and the way must be used). But this may be an inappropriate comparison because Haskell is a one-model language and is only simulating a stateful model via monads. And of course it is statically typed. In fact the CTM authors specifically mention (page xxi) that they disfavor the monadic approach to state because it is too explicit, violating modularity by making the use of state change the interface to a function (if I understand them correctly).

On the flip side, I'd say modularity is better supported by a language in which design contracts (e.g. do you use state) can be enforced. It all comes down to whether you think the use of state is a private or public manner, or perhaps under the choice of the programmer whether to make it private or public (and if the programmer chooses to keep that choice private, we are forced to make the conservative assumption that he did use state).