Path: utzoo!utgpu!news-server.csri.toronto.edu!rutgers!apple!usc!samsung!umich!ox.com!emv From: cspw@quagga.ru.ac.za (Peter Wentworth) Newsgroups: comp.archives Subject: [comp.lang.functional...] functional language available. Message-ID: <1990Dec29.003604.23522@ox.com> Date: 29 Dec 90 00:36:04 GMT References: <1990Dec26.142431.9259@quagga.ru.ac.za> Sender: emv@ox.com (Edward Vielmetti) Reply-To: cspw@quagga.ru.ac.za (Peter Wentworth) Followup-To: comp.lang.functional,comp.sys.transputer Organization: Dept. of Computer Science, Rhodes University Lines: 217 Approved: emv@ox.com (Edward Vielmetti) X-Original-Newsgroups: comp.lang.functional,comp.sys.transputer Archive-name: languages/functional/rufl/1990-12-26 Original-posting-by: cspw@quagga.ru.ac.za (Peter Wentworth) Original-subject: functional language available. Reposted-by: emv@ox.com (Edward Vielmetti) I have a small functional language, RUFL (The Rhodes University Functional Language) which is yet another variation on the Miranda theme. The alpha release is now available. The implementation is via an intermediate SECD-like fixed machine code (called FLFM code), which can either be compiled down to native code for the target machine, or it can be interpreted. There are three versions currently available: an IBM PC version, a VAX VMS version, and a T800 transputer version running under Helios. The native PC version generates *.obj files directly. These must be linked with the Turbo C v2.0, or Turbo C++ 1.0 libraries, so you'll need to already have one of these products installed. The native T800 version generates transputer assembler code which must be assembled and linked with the Helios C libraries. The native VAX version generates assembler mnemonics which must be assembled via MACRO (together with the macro definitions), and linked with the standard VAX libraries. The linking is slow on this implementation. In addition to producing native code or assembler code, the compiler can also generate the intermediate FLFM code directly. An interpreter which will execute this intermediate code is provided on all three systems. The compiler is a traditional command-line system which produces ouput objects from input files. (i.e. is not like the ML system which allows you line-at-a-time compilation and interpretation.) Performance (Times in secs) ---------------------------- 8Mz AT 20Mz T800 VAX 6000 (Native code versions) 8 Queens 61.7 37.8 19.8 Nfib 24 * 5.2 3.1 1.8 Nfibr 24 ** 249.0 10.6 5.2 100 Primes 1.8 1.3 1.0 8Mz AT 20MZ T800 VAX 6000 (Interpreted versions) 8 Queens 430.0 278.7 88.9 Nfib 24 * 70.8 47.0 13.5 Nfibr 24 ** 379.0 89.5 27.6 100 Primes 11.9 7.6 2.6 * On the AT version, nfib 24 is too big for our 15-bit integers, so we compute Nfib 19 eight times, and Nfib 18 five times instead. (This is how the nfib 24 tree expands.) ** No 80287 coprocessor available for the real numbers on the AT. Ordering Info ------------- My only distribution medium is 5-1/4" IBM floppy diskettes. I hope to get an anonymous FTP distribution point soon, but we cannot FTP from or to our site yet. The package consists of the compiler (executables only), the interpreter (sources and executables) and a number of examples. Two technical documents are provided: A 110 pg. introductory course to functional programming using RUFL, A 14 pg. document about the FLFM intermediate machine. The system is shareware, but if you want us to do the hard work of packaging and posting document and diskettes, the $30 shareware donation is required up front. Cheques or money orders should be made payable to Rhodes University. PLEASE SAY WHICH VERSION YOU REQUIRE: PC VAX HELIOS T800 Order from: The Secretary Department of Computer Science Rhodes University Grahamstown 6140 South Africa. E-Mail Contact info ------------------- My internet address is cspw@quagga.ru.ac.za If that does not work, we have a backup route via fidonet: cspw.quagga@f4.n494.z5.fidonet.org APPENDIX: Example code ----------------------- The four programs described in the performance timings are given here, mainly to give some idea of the syntax of RUFL. One other example which uses type constructors is given too. Type declarations are mandatory for all global level functions. Most lexical conventions (operator names, indentation and offside rule, capitalized/lowercase identifiers for Types/Dataconstructors/Function names, strings, reals, ints) follow the Haskell conventions. The type system is Milner-type parametric polymorphism (i.e. no Haskell 'derived' types, and no overloading except some special built-in cases for + -, etc.) --------------------------------------------------------------- -- Nfib. import Library dec nfib :: Int => Int def nfib n = 1, if n < 2 = 1 + nfib(n - 1) + nfib(n - 2), otherwise def main = writeInt (nfib 24) --------------------------------------------------------------- -- Nfibr. import Library dec nfib :: Real => Real def nfib n = 1.0, if n < 2.0 = 1.0 + nfib(n - 1.0) + nfib(n - 2.0), otherwise def main = writeReal (nfib 24.0) --------------------------------------------------------------- -- Primes. import Library dec primes :: [Int] dec sieve :: [Int] => [Int] def primes = sieve [2 .. ] def sieve (p:x) = p : sieve [ n | n <- x, n % p != 0] def main = writeInts (take 100 primes) --------------------------------------------------------------- -- Queens. import Library type Board = [Int] dec queens :: Int => [Board] dec safe :: Int => Board => Int => Bool -- Is q safe on b hdist cols away? def safe q [] hdist = True safe q (a:x) hdist = False, if q == a = False, if q-hdist == a = False, if q+hdist == a = safe q x (hdist + 1), otherwise def queens bdSize = queens1 bdSize where queens1 0 = [[]] queens1 n = [q:b | b <- queens1(n-1) | q <- [1..bdSize] , safe q b 1] def main = let q = (queens 8) in seq writelnString "Searching for positions of queens ..." forcemap writelnInts q writeString "Number of solutions " writeInt (length q) --------------------------------------------------------------- -- Some binary tree examples. import Library data Tree alpha = Empty | Leaf alpha | Node (Tree alpha) alpha (Tree alpha) dec sumtree :: Tree Int -> Int def sumtree Empty = 0 sumtree (Leaf n) = n sumtree (Node l v r) = sumtree l + v + sumtree r dec flatten :: Tree alpha -> [alpha] def flatten Empty = [] flatten (Leaf n) = [n] flatten (Node l v r) = flatten l ++ [v] ++ flatten r -- EP Wentworth - Dept. of Computer Science - Rhodes University - Grahamstown. cspw@quagga.ru.ac.za (If that fails, try cspw.quagga@f4.n494.z5.fidonet.org)