SAC(ID:4989/sac005)

Single Assignment C 

for Single Assignment C

Combination of paradigms, a C-style functional language

Sven-Bodo Scholz
Related languages
C* => SAC   Evolution of
VAL => SAC   Influence
References:
  • Scholz, Sven-Bodo "Single Assignment C - Functional Programming Using Imperative Style" In Proceedings of the 6th International Workshop on Implementation of Functional Languages (IFL'94), Norwich, England, UK, pp.21.1-21.13, University of East Anglia, 1994. view details Abstract: This paper proposes a new functional programming language called Sac
    (Single Assignment
    C) which tries to combine the best of two worlds: the efficiency and
    portability of

    C (or Fortran) and the concurrency deducable from the functional
    paradigm. The major
    objectives in the design of Sac comprise support for high performance
    concurrent scientific
    applications (number crunching), a module concept which allows for
    the integration
    of non-funtional components, and a syntax as close as possible to C.
    1 Introduction

    Functional programming languages did not yet find a broad acceptance
    by application programmers
    outside the functional community. The reasons for this situation are
    manifold and differ
    depending on the field of application. Of primary interest in this
    paper are scientific applications
    involving complex manipulations of arrays.
  • Scholz, Sven-Bodo On programming scientific application in SAC -- a functional language extended by a subsystem for high-level array operations. In Wemer Kluge, editor, Proceedings of the 8th International Workshop on the Implementation of Functional Languages (IFL '96), pages 85-104, Bad Godesberg, Germany, September 1996. Springer-Vedag. view details
  • Scholz, S.-B. With-loop-folding in sac--Condensing Consecutive Array Operations. In C. Clack, T. Davie, and K. Hammond, editors, Proceedings of the 9th International Workshop on Implementation of Functional Languages, pages 225--242. University of St. Andrews, 1997 view details
    Resources
    • SAC homepage

      SAC (Single Assignment C) is a strict purely functional programming language
      whose design is focussed on the needs of numerical applications. Particular
      emphasis is laid on efficient support for array processing. Efficiency concerns
      are essentially twofold. On the one hand, efficiency in program development is
      to be improved by the opportunity to specify array operations on a high level of
      abstraction. On the other hand, efficiency in program execution, i.e. the
      runtime performance of programs both in time and memory consumption, is still to
      be achieved by sophisticated compilation schemes. Only as far as the latter
      succeeds, the high-level style of specifications can actually be called useful.


      In order to facilitate the compilation to efficiently executable code,
      certain functional language features which are not considered essential for
      numerical applications, e.g. higher-order functions, polymorphism, or lazy
      evaluation, are not (yet) supported by SAC. These may be found in
      general-purpose functional languages, e.g. href="http://www.haskell.org/">Haskell, href="http://www.cs.kun.nl/~clean/">Clean, href="http://cs.nott.ac.uk/Department/Staff/gmh/faq.html#miranda">Miranda,
      or ML.


      In order to overcome the acceptance problems encountered by other functional
      or array based languages intended for numerical / array intensive applications,
      e.g. Sisal,
      Nesl, href="http://www.nial.com/">Nial, href="http://chilton.com/~jimw/">APL, href="http://www.jsoftware.com/">J, or K,
      particular regard is paid to ease the transition from a C / Fortran like
      programming environment to SAC.


      In more detail, the basic language design goals of SAC are



      • to provide a purely functional language with a syntax very similar
        to that of C         in order to ease, for a large community of programmers,
        the transition from an imperative to a functional programming style;
      • to support multi-dimensional arrays as first class objects;

      • to allow the specification of shape- and dimension-invariant array
        operations        ;
      • to provide high-level array operations that liberate
        programming from tedious and error-prone specifications of starts, stops and
        strides for array traversals thereby improving code reusability and programming
        productivity, in general.
      • to incorporate a module system that allows for separate
        compilation, separate name spaces, and abstract data types, and, additionally,
        provides an interface to foreign languages in order to enable
        reuse of existing code;
      • to provide means for a smooth integration of states and state
        modifications         into the functional paradigm based on uniqueness types;
      • to use the module system, the foreign language interface, and the
        integration of states in order to create a standard library
        which provides a functionality similar to that of the standard C libraries, e.g.
        powerful I/O facilities or mathematical functions;
      • to facilitate the compilation to host machine code which can be
        efficiently executed both in terms of time and space demand;
      • to facilitate the compilation for non-sequential program
        execution         in multiprocessor environments.

      external link