Key features of the language include:
I am not sure being .NET compatible qualifies as "easy to use", but the rest sounds interesting. ;^/
Posted to object-functional by Patrick Logan on 2/20/04; 6:32:55 AM
Discuss (7 responses)
This paper presents Frappe, an implementation of FRP in the Java
progam- ming language. The primary contribution of Frappe is its
integration of the FRP event/behavior model with the Java Beans
event/property model. At the interface level, any Java Beans
component may be used as a source or sink for the FRP event and
behavior combinators. This provides a mechanism for extending Frappe
with new kinds of I/O connections and allows FRP to be used as a
high-level declarative model for composing applications from Java
Beans compo- nents. At the implementation level, the Java Beans event
model is used internally by Frappe to propagate FRP events and changes
to FRP behaviors. This allows Frappe applications to be packaged as
Java Beans components for use in other applications, and yields an
implementation of FRP well-suited to the requirements of event-driven
applications (such as graphical user interfaces).
Posted to object-functional by Patrick Logan on 12/4/03; 5:49:45 PM
Discuss (6 responses)
They provide a formal description of the operational semantics (evaluation) and statics semantics (type checking) of core ML and of several extensions starting from small variations on the core language to end up with the OCaml language ---one of the most popular incarnation of ML--- including its object-oriented layer.
A very approachable description of the OCaml language by one of its creators.
Posted to object-functional by Manuel Simoni on 6/30/03; 3:02:13 AM
Discuss (1 response)
A objectified Scheme is used for illustration.
Seems quite a few guys found this interesting. Since I know some of them read LtU, maybe they'll want to share their views.
Posted to object-functional by Ehud Lamm on 2/14/03; 2:33:15 PM
Discuss (1 response)
Objectives:
Project Timber is host to several sub-projects, most notably the Timbot, a robot that they program with the Timber language, which seems to be a direct descendant of O'Haskell.
Posted to object-functional by Bryn Keller on 12/30/02; 12:41:20 PM
Discuss
O'Haskell is currently being developed at Oregon Graduate Institute and Chalmers University of Technology by Johan Nordlander, Magnus Carlsson, and Bjorn von Sydow.
O'Haskell is
* the purely functional language Haskell,
conservatively extended with
o subtyping
o monadic objects
* an object-oriented imperative language,
enhanced with
o parameteric polymorphism
o automatic type inference
* a concurrent language, with
o a reactive communication model
o asynchronous and synchronous message-passing
all at the same time. The O in O'Haskell should be interpreted as standing for both Objects and what remains of IO when the Evil I is removed.
Posted to object-functional by Bryn Keller on 12/27/02; 12:15:42 PM
Discuss (1 response)
I wonder how problematic is the lack of principal types.
Posted to object-functional by Ehud Lamm on 12/8/02; 8:59:11 AM
Discuss (9 responses)
Needle is a new language that was discussed at LL2. The feature list reads like everything I've ever wanted in a language: multiple dispatch, continuations, macros and static typing plus the all usual features you'd expect. Impressive piece of work created by someone who's obviously got a great understanding of modern programming languages.
Posted to object-functional by Noel Welsh on 11/14/02; 9:45:25 AM
Discuss (10 responses)
Moby is an experiment in language design and implementation. Our goal is to combine support for class-based object-oriented programming and higher-order concurrency with the desirable features of ML-like languages: advanced module systems, parametric polymorphism, inductive datatypes, pattern matching, and first-class functions. The Moby project started out as a testbed for the design of ML2000.Moby is primarily a collaboration between Kathleen Fisher and John Reppy. Much of the work on Moby was done while John Reppy was an MTS at Bell Labs in the Computing Sciences Research Center.
Thought we'd discussed this here before, but I can't seem to find it in the searches. The Moby site seems to be be showing some new signs of growth, including a downloads page which mentions the compiler's implementation language (SML/NJ), though you still can't actually download the compiler. For a long time the Moby page just said "we're working on a compiler" without being more specific, so maybe this is progress.
I haven't had time to read any of the papers on the site, but there are several. Thought we ought to have a reference to the site here on LTU even if it's perhaps a bit premature.
Posted to object-functional by Bryn Keller on 10/31/02; 3:00:10 PM
Discuss
Many problems necessitate recursive data types and operations which manipulate values of these types. It often happens that the problem evolves, sometimes in the course of implementation, sometimes during maintenance, requiring an extension of the types and operations. Neither of these two models permits extension in both ways. In the functional/modular model, types are not extensible, but one can create new functions (operations) on the types. In the object model, one can extend the objects, but not the methods (by creating a new subclass on an abstract class which implements its methods.) In this respect, the two models are duals.
The advantage of uniting these two models in the same language is to be able to choose the most appropriate model for the resolution of the problem in question and to mix them in order to overcome the limitations of each model.
"Comparison of the Models of Organisation" (Chapter 16)
briefly discusses mixing the two paradigms.
In the
example
given, the conclusion is that,
"the extension of data and methods is easier in the object model when it is combined with the functional model."
To what extent is the approach taken here applicable to functional .NET languages?
You can download the book in a variety of formats.
Posted to object-functional by jon fernquest on 7/13/02; 7:48:13 AM
Discuss (2 responses)
A problem occurs in statically-typed languages because you can't specialize the return value as wanted/needed.
Also talking about multi-methods...
I tried this after some discussion on comp.lang.functional. I couldn't find a good C++ solution. Some help anyone?
(I hesitated between OOP and functional category, maybe we could
choose more than one? :p)
Posted to object-functional by pixel on 5/10/02; 1:36:02 PM
Discuss (4 responses)
Since we're talking about multimethods lately - Nice adds multimethods, parametric polymorphism, first-class functions, and an MLish type system to Java. Allows easy interop with Java (though it's harder to use Nice from Java than Java from Nice).
Posted to object-functional by Bryn Keller on 5/10/02; 1:18:45 PM
Discuss (5 responses)
Contains some interesting things like a continuation pattern.and call by need semantics.
I chose to put this in the OOP department, because these ideas are basically ways to get functional advantages in an OO language.
19 Dec. 2002: I moved this to the newly created object-functional department
Posted to object-functional by Ehud Lamm on 3/20/01; 7:57:20 AM
Discuss