Nemerle is a new hybrid (functional, object-oriented and imperative) programming language for the .NET platform.
Key features of the language include:
- C#-like syntax,
- easy to use object system (derived directly from the .NET),
- easy access to both functional and imperative features,
- powerful code-generating macros,
- pattern matching,
- static and on-demand dynamic typing,
- type inference
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)
|Frappe: Functional Reactive Programming in Java
I found no reference to this in the annals of LtU. Given the recent Scheme implementation of FRP, this one seems timely. It may be of interest to other OOP hackers as well... Smalltalk, Python, Ruby would have less boilerplate to deal with than JavaBeans do.
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)
|Using, Understanding, and Unraveling The OCaml Language
These course notes are addressed to a wide audience of people interested in modern programming languages in general, ML-like languages in particular, or simply in OCaml, whether they are programmers or language designers, beginners or knowledgeable readers ---little prerequiresite is actually assumed.
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)
Time as a basis for embedded real-time systems
Project Timber is a research project at the OGI School of Science & Engineering at OHSU, and is part of the DARPA program on Program Composition for Embedded Systems (PCES).
- Facilitate construction and analysis
of high-assurance, and portable real-time
systems from high-level descriptions
- Allow dynamic adaptation: replace
outright failure by Graceful Degradation
- Reduce development and maintenance costs
through reuse and composition
- Exploit OGI expertise and experience in both:
- QoS-aware, adaptive systems
- Domain-specific languages: "language middleware"
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
From the "things we ought to have references to but somehow don't" department:
* the purely functional language Haskell,
conservatively extended with
o monadic objects
* an object-oriented imperative language,
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.
O'Haskell is currently being developed at Oregon Graduate Institute and Chalmers University of Technology by Johan Nordlander, Magnus Carlsson, and Bjorn von Sydow.
Posted to object-functional by Bryn Keller on 12/27/02; 12:15:42 PM
Discuss (1 response)
|Needle, An OO FP Language
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
|Developing Applications with Objective CAML
On the mixed use of the object-oriented and functional programming
paradigms in OCAML:
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.
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)
|Using Functional Objects in various languages
Functional Objects are non-mutable objects. When you modify an object
it returns the modified object instead of doing it in place.
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)
|The Nice Programming Language
Nice is a new object-oriented programming language based on Java. It incorporates features from functional programming, and puts into practice state-of-the-art results from academic research. This results in more expressivity, modularity and safety.
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)