Clean 3.1 available for Windows, Linux and Mac OS X

Clean 3.1 is now available for Windows (64 and 32 bit), Linux
(64 and 32 bit Intel/AMD64 and ARM64) and Mac OS X (64 bit Intel) at:

https://wiki.clean.cs.ru.nl/Download_Clean


New in version 3.1:

- added Platform library

- added itask branch Clean compiler with some added features for iTasks

- ARM64 Linux version

- added command line build tool cpm.exe on Windows


Language additions:

- strict, lazy, unboxed and overloaded maybe types:
  ? a, ?^ a, ?# a | UMaybe a and m a | Maybe m a
  with constructors:
  ?Just, ?^Just, ?#Just, ?|Just and ?None, ?^None, ?#None, ?|None.
  For example:

  m_strict_boxed :: (? x) -> ? x
  m_strict_boxed (?Just x) = ?Just x
  m_strict_boxed ?None = ?None

  m_lazy :: (?^ x) -> ?^ x
  m_lazy (?^Just x) = ?^Just x
  m_lazy ?^None = ?^None

  m_strict_unboxed :: (?# x) -> ?# x | UMaybe x
  m_strict_unboxed (?#Just x) = ?#Just x
  m_strict_unboxed ?#None = ?#None

  m_overloaded :: (ma x) -> mr x | Maybe ma x & Maybe mr x
  m_overloaded (?|Just x) = ?|Just x
  m_overloaded ?|None = ?|None

- 32 bit unboxed signed integer and real arrays:
    f :: ( *{32#Int}, *{32#Real} )
    f = ( {32# 1} , {32# 3.5} )

- lazy array value expression: {^array_elements}

- head strict list generator: [e \\ e <!- list]

- generic derive for unboxed list and maybe, for example:

  derive gEq [#!]

- omit some generic classes when deriving generic superclasses
  from a class, for example:

    derive class G \ gEq,gPrint T

    class G a | gEq{|*|} a & gPrint{|*|} a & gDefault {|*|} a

  derives gDefault for T, but not gEq and gPrint

- derive a member of an instance using a generic function with
  the same type, for example

  instance == T where
    derive == gEq

  derives an == member of type T using generic function gEq.

  If there is only one member, this can also be written as:

  instance == T derive gEq

  The default member of a class can also be derived, for example:

  class equal a where
    equal :: a a -> Bool
    derive equal gEq

  instance equal T

- improved detection of overlapping instances.
  These are rejected except for default instances.

- add abc code for primitive functions to definition modules, instead of
  searching abc files of system modules, for example:

    instance + Int :: !Int !Int -> Int :== code { addI }


Optimisations:

- more efficient overloaded calls of members of instances (that have not
  been specialized). The calling convention is now determined by the
  type and strictness annotations in the class definition.
  Strict arguments are evaluated before the call and arguments and
  result may be passed unboxed.

- for generic derive: a program transformation reduces the number of
  allocated partial applications, FIELD and OBJECT nodes are not
  allocated any more and in more cases specialized code is used
  instead of bimap, bimap was changed and can be optimised better
  by generic fusion.

- optimised code for some dynamics with a simple type.

- fewer compare instructions are generated for some pattern matches.


Changes to StdEnv:

- added module _SystemStrictMaybes and modified module StdMaybe

- added to module StdReal: Infinity,NaN,isNaN,isInfinity,isFinite

- moved modules StdDynamic and _SystemDynamic from StdDynamicEnv
  to the StdEnv

- changed generic bimap in module StdGeneric

_______________________________________________
clean-list mailing list
[email protected]
https://mailman.science.ru.nl/mailman/listinfo/clean-list