New in Kokogut-0.7.1, a release with preliminary PDF documentation:
* The Kogut Programming Language Reference in PDF (incomplete yet)
replaces the old language reference in HTML.
* A unit testing framework in module Testing.Units.
Define a structure of tests:
- TestGroup "name" {...} - define a group of test cases and
subgroups.
- TestCase "name" {...} - define a test case.
- SetUp "name" {...} {...} - define actions to be performed before
and after each test in the current group; the second action is
optional.
- SetUpOnce "name" {...} {...} - like SetUp, but do only once
instead of for each test.
- local TimeLimit n {...} - specify a different time limit for each
test defined here; default: 10 seconds.
Inside test cases and set up / tear down actions:
- TestMessage "message" {...} - give a message for test failures
inside this region.
- AssertFalse() - unconditional failure.
- Assert cond - failure unless cond is true.
- Assert obj cond - failure unless 'cond obj' is true.
- x->AssertIs y - failure unless 'x %Is y'
- AssertFails body cond - failure unless 'body()' fails with exn
such that 'cond exn' is true.
- Env - when set up actions set fields of this object, they are
available in the corresponding test cases and tear down actions;
Close is applied to them after tear down actions automatically.
Running tests:
- RunTests "name" - runs all tests, or tests specified by command
line parameters:
--help display program usage
--list show all test names (not implemented yet)
--test=NAME run these tests; can be given multiple times,
but no tests selected means to run all test;
NAME is a "/"-separated path of test groups,
possibly ending in a test case
--report=none do not display anything on stdout
--report=default display test failures only
--report=full display test passes and failures
--log=FILENAME write full report to this file; default: the
name given to RunTests with ".log" appended
NAME same as --test=NAME
* Created some basic tests of the Core library, run by 'make test'.
* Renamed:
- {Lock,Unlock,IsLocked}ReadWillWrite -> {Lock,Unlock,IsLocked}Update
- ChangeLockTo{Write,Read} -> {Lock,Unlock}WriteUpdating
Unified mutexes with read-write locks: mutexes now support
{Lock,Unlock,IsLocked}{Read,Update} and {Lock,Unlock}{WriteUpdating}
(plain locking means locking for writing). Removed the old
READ_WRITE_LOCK type.
IsLockedRead returns True also when the current thread has locked
the mutex for writing or updating. IsLockedUpdate - also for writing.
Wait can be used with any kind of lock, and unlocks all locks the
current thread holds for the mutex associated with the condition.
A read lock is always granted if the current thread already holds
a read lock, even if there are waiting writers. Otherwise an
unnecessary deadlock could occur.
* Changed the design of weak references such that removal of dead weak
references is synchronous:
DeadWeakRefs() creates a collection for dead weak references, of
type DEAD_WEAK_REFS.
Weak references of type WEAK_REF are created as follows:
- WeakRef key
- WeakRef key dead data...
- WeakPair key value
- WeakPair key value dead data...
where 'value' defaults to 'key', and 'dead' is a dead-weak-refs.
A weak-ref by itself doesn't keep its key nor value alive. It
enforces the relationship: as long as the weak ref and the key are
alive, the value is kept alive too.
'weakRef absent present' enters 'present value' if the key is alive,
or 'absent()' otherwise. By default 'present' is 'Identity' and
'absent' is '{Null}'.
If the key dies before its weak ref dies, and there is an associated
dead-weak-refs, the weak ref is added to the dead-weak-refs.
'EachDeadWeakRef dead body', for each contained weak-ref, applies
'body' to the weak-ref and its associated data. This is typically
used to remove dead weak references from the container they are
stored in, such as a weak dictionary.
Weak-ref functions are now exported by Prelude instead of Threads.
* Method dictionaries and the supertype cache do not keep entries for
local types which are garbage collected.
* Object-ids have observable unique indices (id.index). Indices can
be reused when object-ids die. As before, object-ids are hashable
(hashes are not necessarily unique) and comparable (the ordering
corresponds to indices). The ordering of object-ids no longer
corresponds to the time of their creation.
* Revised the rules of signal blocking: the state is (all, async) as
before, but both components have the full range of natural numbers.
Synchronous mode means all == 0 & async > 0.
Basic transitions of the blocking state (exported by Prelude now
instead of Threads):
- BlockSignals: all = all + 1
- UnblockSignals: all = all - 1
- BlockAsyncSignals: async = async + 1
- UnblockAsyncSignals: async = async - 1
- BlockSyncSignals: all = all + 1; async = async - 1
- UnblockSyncSignals: async = async + 1; all = all - 1
New read-only variable SignalBlockingState returns the blocking
state as a pair (all, async).
* Revised signal handling by lazy lists.
The following are basic building blocks of a lazy list:
- Lazy compute
- LazySync prepare complete
- LazySync prepare
- LazyAsync prepare complete
- LazyAsync prepare
The following calls can be put in 'complete':
- CommitLazySync prepare complete
- CommitLazySync prepare
- CommitLazyAsync prepare complete
- CommitLazyAsync prepare
As before, 'compute' is a nullary function which gives the value,
'prepare' is a nullary function which gives some data, and
'complete' is an unary function which transforms the data
to the value. An absent 'complete' defaults to 'Identity'.
CommitLazy{Sync,Async} reverts to the 'prepare' stage with new
computing functions stored in the variable.
'compute' and 'complete' are evaluated with signals blocked.
'prepare' is evaluated with async signals blocked (in sync variants)
or in unchanged signal blocking state (in async variabnts).
If 'compute' or 'complete' fails, the lazy list becomes broken.
If 'prepare' fails, the lazy list is reverted to the uncomputed
state (or another thread tries to compute it if it was waiting).
* A type may be final, which means that it may not have subtypes other
than those defined when it was not final. The final state is stored
in the field 'final' of a type, and can be set in the definition
of the type with 'final:True' or 'final:False' or later with
'MakeTypeFinal type'. The default is final when the type is not
abstract. A final type cannot be made nonfinal again.
Standard concrete types are final. Most standard abstract types are
nonfinal, but some are final too: BOOL, LIST, VIEW_PART.
Unnamed functions have a final concrete type UNNAMED_FUNCTION, with
a nonfinal abstract type FUNCTION as its supertype.
* Redesigned the method of passing Kogut names to C code:
An input to a C fragment can have one the following forms,
in addition to an expression:
- 'c_con Con index' - where Con is a constructor name, and index
is the 0-based case number, expands to the object descriptor
(type ko_descr_t)
- 'c_con Con' - equivalent to 'c_con Con 0'
- 'c_entry obj arity' - expands to the given fast entry (type
ko_code_t)
- 'c_entry obj' - expands to the list entry (type ko_code_t)
In all these cases the label providing the C name is optional,
defaulting to the concatenation of the arguments of c_con or
c_entry.
Removed c_type syntax in an input to a C fragment; c_con is used
instead.
c_type definition now defines both the type and the object
descriptor. The descriptor has a Kogut name so it can be exported
and imported by modules, but this name is usable only in c_con and
does not correspond to any Kogut object. The syntax of a C type
definition is:
- c_type NAME supertypes... Con defC...
- c_type NAME supertypes... {
c_con Con defC...;
...
}
where defC... is the C move code (a string literal), with an
optional C finalize code (a string literal), optional C save code
(a string literal), and optional behavior (a list containing
function cases).
c_export is similar to c_define, but the code is exported from the
module and will be inserted into any other module which imports this
module and contains any C fragments. It should include declarations
which would be suitable for a C header file. c_export is always
public. An imported c_export is reexported by a module which
contains any c_export itself. An empty 'c_export()' forces the
reexport without adding any new declarations.
c_defineName and c_exportName take C inputs, which are made global
with #define in the whole module, or also in importing modules in
the case of c_exportName. An imported c_exportName is reexported by
a module which contains any c_export. The C names should be chosen
to be reasonably unique. The C entity thus named is automatically
forced to be extern on the C level even if it is private in Kogut,
in the case of c_exportName.
If the --c-export-file=FILE option is given, the C exports are
written to the specified file instead of being put in *.koi files,
and this file will be included by importing modules instead of
copying declarations literally. If --c-export-dir=DIR is given,
the file will be created relative to this directory instead of the
current directory. A C export file has two purposes: reduce the size
of *.koi files, and make possible to include the declarations into
separately compiled C/C++ files. These options may also be given by
a *.kop file.
* Added kokoc option --trace to augment code with logging of various
operations (primarily function calls) to the filename given in the
KO_TRACE environment variable. Logging is enabled if this variable
is set. The file is appended if it already exists.
In the trace only values of some standard types are shown in detail.
Other objects are shown as '<type>', and parts of compound values
are generally replaced with '_'.
At the beginning of the trace various symbols are replaced with '_',
which happens when an object associated with the symbol (such as a
type with the given name) has been used before its module has been
initialized, and thus the symbol is not yet available to the tracing
machinery.
* Functions Real and Imag in module Math preserve inexactness of a
number as a whole: they return an inexact result if either component
of a complex number is inexact. Internally the components of a
complex number can still be inexact independentently from each
other.
New function InexactLike in module Math returns its first argument,
but forced to be inexact if the second argument is inexact. It is
dispatched on both arguments.
* Changed parameter order of HashSetBy and {,Weak}HashDictBy:
the transformation function is last.
* New function Compare for 3-way comparison, dispatched on both
arguments. Its methods should be consistent with the following
method which is the default:
method Compare x y {
if [
(x < y) {#'<'}
(x == y) {#'='}
(x > y) {#'>'}
_ {Fail (NotOrdered x y)}
]
};
* 'x->IsInRange max' is equivalent to 'x->IsInRange 0 max'.
* New immutable sets and dictionaries of types TREE_{SET,DICT}{,_BY}
with constructors Tree{Set,Dict}{,By} and constants
EmptyTree{Set,Dict}. Their keys must support ordering, and are
kept sorted. These collections support {,Get,Remove}{First,Last},
which mean the minimum or maximum key respectively.
They are implemented as left-leaning red-black trees.
Algorithms are based on the work of Robert Sedgewick:
<http://www.cs.princeton.edu/~rs/talks/LLRB/LLRB.pdf>,
<http://www.cs.princeton.edu/~rs/talks/LLRB/RedBlack.pdf>.
* New functions Remove{First,Last}Gen.
* VIEW_PART has two subtypes VIEW_PART_FLAT, VIEW_PART_NOT_FLAT which
reflect whether the underlying sequence is a flat-sequence.
Values of types VIEW_PART ensure that bounds are ints, and store
them in the normalized form (0 <= begin <= end <= size). Creating a
view-part with out of range bounds clips them. An attempt to access
elements outside the viewed part is properly detected.
Part or RemovePart of a view-part always does a copy of the
underlying sequence. ViewPart of a view-part is flattened to a
single-level view-part.
* Fill{,New}Inf return values of separate types FILL{,_NEW}_INF
instead of GENERATOR.
Values of types ALLOCATE and FILL{,_NEW} ensure that the size is an
int, and store it in the normalized form (size >= 0).
{Range,Between}Back are explicitly used for a negative step, instead
of overloading {Range,Between}.
{Range,Between}{,Back} with an explicit step work correctly even
when the range limit is near the limit of the domain of the values
and the next step would go outside the domain. An implicit step of 1
or -1 is assumed to not overstep the domain limit.
* New type INDEXED of flat dictionaries with a fixed set of keys.
Bounds specify the set of keys and must have the following generic
functions defined:
- 'KeyTranslation bounds' - returns a pair of the size and a
function with parameters: key absent present, which attempts to
convert 'key' to an unique index in the range of the size, and
enters 'present index' or 'absent()'.
- 'KeyRange bounds' - returns a sequence of the keys in the order
corresponding to the mapping.
In particular the following values can specify the bounds:
- an int - 0 to limit (exclusive).
- 'first %To last' - keys between first and last, which must
support binary '-' (returning and int), '_+1', '<', and '=='.
- 'FixedKeys keys' - a sequence of explicitly enumerated keys,
which must be hashable.
- 'bounds1, bounds2' - a Cartesian product of two bounds.
An indexed dictionary has the following fields:
- bounds - the bounds.
- values - a flat mutable sequence storing the values.
- keyToIndex - cached right component of 'KeyTranslation bounds'.
The following functions are provided:
- 'Indexed bounds values' - an indexed dictionary backed by the
given sequence of values. The 'values' object is used directly,
without copying. Its size must correspond to the bounds.
- 'AllocateIndexed con bounds srcs...' - an indexed dictionary
backed by 'con (Allocate size)', and then populated by 'srcs'.
- 'FillIndexed con bounds value srcs...' - an indexed dictionary
backed by 'con (Fill size value)', and then populated by 'srcs'.
- 'FillNewIndexed con bounds fun srcs...' - an indexed dictionary
backed by 'con (FillNew size fun)', and then populated by 'srcs'.
- 'NewIndexed con bounds fun' - an indexed dictionary backed by
'con (KeyRange bounds->MapGen fun)'.
In each case 'srcs' must be collections of pairs.
* New function RandomElement in module Random.
* New functions System.Processes:
- ProcessId - getpid
- ParentProcessId - getppid
- ProcessGroupId - getpgrp, getpgid
- NewProcessGroup, SetProcessGroup - setpgrp, setpgid
- SessionId - getsid
- NewSession - setsid
* Redesigned forking options. Retaining other threads in the child
process is no longer supported. There is one function ForkProcess
with an optional body and with keyword parameters.
ForkProcess locks an internal mutex to prevent concurrent forking.
Each function registered AtForkProcess is called with one argument
being a nullary function which calls the rest of the functions,
does the fork, and returns #child in the child process, or the PID
of the child process in the parent process.
Keyword parameter 'syncThreads' specifies whether to wait for other
threads to reach a safe point before forking. The default is True.
If it is true, each thread except the one doing the fork is sent
FORK_PROCESS_SIGNAL. The signal has a field 'sync' holding a nullary
function which waits until the fork is done, and returns in the
parent process; the thread no longer exists in the child thread.
The default handler of this signal calls the 'sync' function.
When ForkProcess is called without a body, its result is #child in
the child process, or the PID of the child process in the parent
process.
When ForkProcess is called with a body, the child process executes
the body and exits instead of returning from ForkProcess. In this
case an additional keyword parameter 'blockSignals' is supported,
which indicates whether signals in the child process should be
blocked once or unblocked, relative to complete unblocking rather
than to the state outside the fork. The default is False.
A default AtForkProcess handler flushes StdOut and StdErr. If this
might collide with a concurrently working thread, these streams
should be rebound to null output streams around the fork.
* New function RunProcess in module System.Processes: like RunProgram,
but applying the function supplied as the last argument instead of
running an external program.
Keyword parameters of RunProcess and RunProgram:
- mode - one of:
- #replace - just apply the function, don't fork at all
- #background - return the tuple of the child process pid and the
pipes created for redirection.
- #wait - wait until the process finishes, return the value of the
body of RunProcess if it completes normally, or the exit code of
the child process, or propagate the exception via serialization
if the body fails, or propagate the signal as an exception if it
was killed with a signal.
The default is #wait, unless redirect is not Null which forces the
mode to be #background.
- syncThreads, blockSignals - passed to ForkProcess. RunProgram
changes the default of syncThreads to False.
- processGroup - the process group for the child process, or #new
for a new one, or Null for leaving it in the same group as the
parent; Null by default.
- stdIn, stdOut, stdErr - a stream to redirect the given standard
stream to, closing the original in the both processes, or
leaveOpen:stream when it should be left open in both processes,
or Null for no redirection. A stream which is not left open is
changed into blocking mode.
- redirect - #stdIn, #stdOut, #stdErr, or a tuple of them, denoting
standard streams for which redirection pipes are created, or Null
for no redirections. This forces mode:#background.
- close - a list of streams to close in the child process.
- closeInParent - a list of streams to close in the parent process.
- directory - the directory name to change to in the child process,
or Null for no change.
- environment - a list of (name, value) pairs of additional
environment variables to set in the child process.
- prepare - an additional action to perform at the beginning of the
child process, or Null for nothing. The difference between prepare
and the body of RunProcess is that for mode #background the parent
process waits until prepare completes, and exceptions from prepare
are propagated to the parent process via serialization. If prepare
is not Null, the body takes a single argument which is the result
of prepare.
- passResult - for RunProcess in mode #wait, whether to serialize
the result of the body and return it instead of the exit code.
- signal - for mode #wait, the function to use to cancel the child
process if the thread of the parent process waiting for the child
process is canceled, or Null when it should not be canceled
automatically; Null by default. The function takes the child pid
and the exception as arguments.
* When an adopted thread exits, WaitForThread behaves as if the thread
finished returning Null.
* Variable DetectDeadlock exported by module Threads: if true (the
default, which behaves as before), the scheduler detects a deadlock
ands sends the thread handling system signals a Deadlock signal or
aborts the program if that thread does not respond to signals. This
behavior can be turned off because deadlock detection can have false
positives when foreign threads have not been adopted by Kogut yet.
* Changed the usage of EachThread:
- EachThread existing starting ending body
- EachThread existing ending body
All arguments except 'body' will be called with one argument: a
thread. 'existing' is called by the thread doing 'EachThread' for
each currently existing thread which has not yet completed nor has
not been garbage collected. Then 'body' is called with no arguments.
While 'body' is running, 'starting' (which is the same as 'existing'
if not given explicitly) is called by newly created threads, and
'ending' is called by threads going to complete.
EachThread now includes finalizer threads and adopted threads.
* Mutexes and read-write locks are now exported by Prelude instead of
Threads.
* New function IsLocked, and new functions in module Threads:
IsLockedRead, IsLockedWrite, IsLockedReadWillWrite. They check
whether the current thread has locked the mutex or read-write lock,
not whether some other thread has done it.
* Renamed Code to CharCode.
* Renamed ExitProgramImmediately to ExitProgramNow.
* Renamed exception RECURSIVE_LOCK to LOCK_ALREADY_LOCKED.
* Changed the module syntax to have module contents in braces.
* Removed 'pat1->fun args... = pat2' pattern syntax.
A pattern looking like an assignment to an application means to use
the source of the assignment as the last argument of the application,
like in expressions and definitions.
'where' syntax is back: 'pat1->where fun args... = pat2' means
'(pat1 & tmp)->match (fun tmp args...) = pat2'.
'pat1->maybe fun args... = pat2' means
'pat1->where fun args... {[]} [_] = pat2\_'.
In conditional patterns, 'where', and 'maybe' patterns, a '_' marker
as the function or as one of the arguments specifies the position to
put the subject, instead of inserting it as the first argument.
* Removed the pat^_ syntax for pat^OBJECT. Use just pat instead.
* Removed 'inc' and 'dec' syntax.
* Removed 'optional' syntax. Use 'if' with explicit lists instead.
* 'case' syntax is more similar to 'if':
- 'case expr... [pat... {then} ...]' remains unchanged.
- 'case expr... ?pat... {then} {else}' is equivalent to
'case expr... [pat... {then} _... {else}]'.
- 'case expr... ?pat... {then}' is now equivalent to
'case expr... ?pat... {then} {}'.
* 'IfNotNull obj notNull' is equivalent to
'if (obj %Is Null) {Null} {notNull obj}'.
Removed functions: EncodeCString{ASCII,Latin1}OrNull,
{Encode,Decode}CString{,Ptr}OrNull, {Encode,Decode}CCharOrNull.
* New pattern 'pat->ofType types...' ensures that the subject has one
of the given types, and fails with BAD_TYPE otherwise.
* The following functions are now defined for any number of arguments:
- '+', '*', BitOr, BitAnd (previously 2)
- Min, Max, GCD (previously >0)
* New functions for bit operations:
- x %BitAndNot y = x %BitAnd BitNot y
- x->TestBit i = x %BitAnd 1->BitShift i ~%Is 0
- x->SetBit i = x %BitOr 1->BitShift i
- x->ClearBit i = x %BitAndNot 1->BitShift i
- CountBits x - number of bits set in x (Inf for x<0)
- FindBit x i absent present - find the smallest j>=i such that
x->TestBit j; enter present j if it exists, absent() otherwise;
default i is 0, default present is Identity
SizeInBits 0 %Is 0. Redefined SizeInBits for negative numbers:
SizeInBits x %Is SizeInBits (BitNot x).
* Removed DefaultRational; Ratio is always used instead.
Context-sensitive division was not a good idea.
* Subtraction of times returns a ratio instead of using DefaultReal.
* Find and FindBack no longer have the starting index parameter.
Use them with PartGen or ViewPart instead.
Find, FindBack and FindPart take 'absent present' or 'absent' as
last parameters, and enter 'present index' when the index is found
or 'absent()' otherwise.
* Touch is exported from module Threads instead of Prelude.
* 'Touch result obj' is equivalent to 'let x = result; Touch obj; x'.
* A semicolon-separated sequence of definitions which denotes an
expression as a whole doesn't have to end with an expression. If it
ends with a proper definition, its value is Null. Looking for the
last definition descends into subsequences of definitions created
by 'define', 'public', 'private', 'ifDefined' etc.
'method' is treated as a definition instead of an expression.
* Function parameters and definitions on the toplevel of a function
body belong to the same scope: conflicts are disallowed, and forward
references are allowed.
* The syntax like 'arr@0.x' means the likely intended 'arr@(0).x'
rather than 'arr@(0.) x', by introducing a special token consisting
of '@' and an integer literal.
* Names introduced by --switch / -D without a definition are usable
only in 'ifDefined', without getting a dummy definition as Null.
The same effect can be obtained in the source by 'defined name'
(possibly with multiple names at once).
* Escape sequence "\_" in strings skips whitespace until end of line
and the end of line itself, but leaves the indentation of the next
line in the string. This is useful at the beginning of a multiline
indented string.
* '()' is treated as a single token instead of two.
* For clarity, there must be a space or comment between one of these
tokens:
name _ literal () .field @intLit %op op% ) ] } ... !
and one of these:
name _ literal label: %op op% ( [ { ? => ~
* Renamed CloseAll to EnsureAll.
* SigQuit (generated by Ctrl-\ on Unix by default) shows a stack trace
if propagated to the toplevel.
* Elements of AtUnhandledException receive only one argument:
the exception. The stack trace is available from StackTrace().
To enter the rest of the handlers, a handler should propagate
the exception.
* New functions MapList, MapPartialList, MapJoinList, SelectList,
RejectList, UniqueList, UniqueListBy - variants of old functions
which return the same result as a list.
* New function UnnamedFunction to complement NamedFunction.
* New dynamic variables for limiting the amount of information
returned by Show:
- MaxShowDepth - the maximum depth of nested parens or brackets in
Show output (parens around simple values like negative numbers
don't count); an integer or Infinity, Infinity by default
- MaxShowSize - the maximum number of collection elements in Show
output; an integer or Infinity, Infinity by default
New function 'ShowCompound parens body' for Show methods: "_" if the
number of nested parens would exceed MaxShowDepth, otherwise 'body()'
wrapped in parens if 'parens'.
Show format revised to use '_' or '_...' when the depth or the size
is getting too large. Strings are truncated with "\...". The stack
trace on unhandled exception is shown with MaxShowDepth=3 and
MaxShowSize=20.
* Printable characters in strings and symbols are shown unescaped if
they could be encoded using DefaultEncoding.
* Module Calendar:
- Renamed DATE to DATE_TIME, and Date to DateTime.
- New type DATE with constructor Date holds just the year, month,
and day, together with the computed day of year and day of week,
without a specific hour or time zone. Subtraction of dates gives
the diffrence in days.
* New functions: Numerator, Denominator, for integers and rationals.
* Floats and named functions are hashable.
* New field 'public' of symbols. Private symbols are serialized as
fresh symbols, preserving sharing within a serialized stream.
* Float Null is NaN. Int and Ratio return Null for NaN instead of
failing.
Removed InfFloat, NegInfFloat, and NaNFloat. Use Float Inf,
Float NegInf, and Float Null instead.
* DecodeFloat returns the sign as a separate field, encodes 0 with the
exponent of -Inf, and infinity and NaN with the exponent of Inf.
* Renamed Sqrt to SqRt.
* Renamed ScaleFloat to ScaleReal.
* Flush mode #sync replaced with #whole, which means to consume
the whole buffer passed to WriteSomeTo or FilterBlock, but not
necessarily write the output to the raw file.
The default flushLines of StdOut and sockets is now #sync instead of
#soft. The default flushAll of StdErr is #sync.
Copy{Byte,Char}Stream is applicable to FILTERED_{BYTE,CHAR}_OUTPUT.
Flushing an LZMA stream in mode #sync or #reset is equivalent to
flush mode #end. The original LZMA implementation does not provide
flushing more softly.
* Added a byte stream type TIED_OUTPUT which flushes another stream on
each write. StdErr is now tied to StdOut.
* Raw files have field fd: Unix file descriptor.
* FILE_MODE: fields usr, grp, oth contain triples of rusr, wusr, xusr;
rgrp, wgrp, xgrp; roth, woth, xoth.
* Replaced DOES_NOT_MATCH exception with NO_MATCH which includes the
objects which did not match, and split ALL_CONDITIONS_FALSE out of it.
Exception type BAD_ARGUMENTS unifies the old BAD_ARGUMENTS with
TOO_{FEW,MANY}_ARGUMENTS, and contains the argument values and
information about allowed arities. ShowException shows the argument
values if the arity matches, otherwise shows only information about
the arity.
Exceptions of types NO_METHOD, NO_SUPER_METHOD, NOT_DISPATCHED, and
METHOD_CONFLICT include the arity.
Exceptions of types NO_METHOD and NO_SUPER_METHOD include the key
arguments instead of their types.
Renamed NOT_VARIABLE to NOT_SETTABLE.
Swapped arguments of NOT_SUPERTYPE exception: now they are the
potential subtype and supertype.
* Read-write locks detect errors when the lock should be locked for
reading but it's not, or when it should not but it is.
* New library FAM providing a binding to File Access Monitor or Gamin.
* New library DBus providing a basic binding to D-Bus, usable but
incomplete.
* Module Network.Sockets in library Network: functions ServerSocket
and ClientSocket accept an additional keyword argument 'options'
which should be a list of (level, option, value) triples for
SocketOption.
* Option --module-root=ROOT (module-root in *.kop) allows to exclude a
common module name prefix from filenames. The root is a dot-separated
sequence of module name elements.
An --ifaces option (ifaces in *.kop) can include the common root of
modules in this directory, appended to the directory name after "=".
If --iface-dir=DIR option is given (iface-dir in *.kop), *.koi files
will be created relative to this directory, based on the module name
rather than the source filename. The directory can include a module
root after "="; if absent, the module root given by the module-root
option is assumed.
* Dependencies are generated for all interfaces, even those with
absolute paths.
* Compiler notes renamed to notices.
* The compiler issues a notice if the base filename does not match the
base module name, in case of a module which is not the main module.
* A separate --link-main option specifies a *.o file with C main()
function to link. Make it 'none' to remove the default. The option
is called 'link-main' in *.kop.
* Fractional seconds in file timestamps are supported on some systems.
* Python 3.0a2 is supported by the Python binding.
The IsPython3 variable is defined when the Python version is at
least Python3. This affects the semantics of various operations,
e.g. Python3 strings are Unicode.
The new 'bytes', 'bytearray' and 'memoryview' types are supported:
PyBYTES, PyBytes, FromPyBytes, PyBYTE_ARRAY, PyByteArray,
PyMEMORY_VIEW. In Python3 FromPyBytes supports anything which
supports the new getbuffer interface with PyBUF_SIMPLE. In Python2
PyBytes and FromPyBytes have the semantics of the now removed
functions ByteArrayToPyString and PyStringToByteArray.
In Python3 the following names are aliases of other names:
- PySTRING - PyUNICODE
- PyString - PyUnicode
- FromPyString - FromPyUnicode
- PyINT - PyLONG
- PyInt - PyLong
- FromPyInt - FromPyLong
PyCLASS and PyINSTANCE are present only in Python2.
Renamed:
- Py{Get,Set}{SpecialAttr} -> PySpecialAttr
- RawPyGet{,Special}Attr -> RawPy{,Special}Attr
- RawPyGetItem -> RawPyItem
When a Kogut function is stored in a Python class and is then
retrieved through an instance, it is transformed into a bound
method, like in Python.
Updated the set of Python exception types.
Finalization of Python objects wrapped in Kogut is no longer done
in foreign mode. This avoids a high thread switching overhead.
Renamed LetFromPython to MethodFromPython.
* Foreign.Perl: InitPerl function removed, initialization is now
called automatically.
* Unicode character properties and text segmentation rules updated
to Unicode 5.1.0.
* EncodeInt and DecodeInt treat the last bit of the byte array as the
sign bit instead of passing it as a separate value.
* Changed serialization format and some hash formulas.
* -ftree-vrp (enabled by -O2) is buggy in gcc-4.3.0.
We detect this and add -fno-tree-vrp if needed.
* pselect, ppoll, or epoll_pwait are used if available, for reliable
signal handling around polling.
* LZMA compressor and decompressor updated from version 4.43 to 4.53.
* Improved detection of dubious forward references which could never
be executed before the corresponding definition.
* kogut-mode.el: Improved indentation rules.
Characters inserted directly after line indenting command (TAB or
C-j) can change the indent which has just been made.
* KoCalc: new functions real, imag.
* New small example: MazeGen.
* Improved out of memory detection: on a 32-bit architecture we
proceed as if there were at most 1GB of RAM, because otherwise
address space fragmentation might prevent us from using the
available memory.
* License: updated the wording of the linking exception, as section 6
of LGPL version 2 corresponds to section 4 of LGPL version 3.
* Bugs fixed:
- Checking that a supertype is a type had the condition backwards
if the check was done at runtime (thanks for Pippijn van Steenhoven
for the report).
- Fixed a crash when GC shrinks a BOOL_ARRAY too much.
- Fixed exception handling and signal blocking when interrupting
a condition wait.
- Foreign threads and process forking now properly ensure epoll
initialization.
- A method is allowed to contain cases with different fixed arities.
- IsEmpty for HASH_SET_BY works.
- Fixed a possible failure in the optimizer for forward-referenced
'let name = {fun}' at the toplevel.
- Fixed a rare crash when a dying weak ref or readline keymap is the
key of a weak reference.
- Fixed a rare crash when a lazy variable uses local rebindings of
dynamic variables.
- Fixed memory management of readline keymaps.
- LZMA compressors and decompressors are closed properly.
- The mangler is more robust when faced with jumps. In particular
it works with code generated by gcc-4.3.0.
- If the boot directory is present, it takes preference over an
installed kokoc if no --with-ko-compiler=... is given.
New in Kokogut-0.7.0 (27 November 2006), a cleaned up release:
* Changed the syntax:
- 'if' and 'ifDefined' are written without 'else', and are limited
to one or two branches:
- if cond {expr1}
- if cond {expr1} {expr2}
Alternatively any number of cases can be written in brackets, with
'_' replacing 'else'. If no case matches in the bracketed variant,
'if' fails, and 'ifDefined' is an error.
- 'def' is used for functions, 'method' for methods; 'let' remains
only in the form 'let pat = expr'
- Dispatched parameters of generic functions are written without
parentheses:
- def DoRemove coll! key {};
and types of specialized parameters of methods are written with
'^' instead of '!', also without parentheses:
- method DoRemove coll^HASH_DICT key {...};
- Function cases are put in brackets if there is more than one case.
The opening bracket may be prefixed with a label, which specifies
an internal name for recursive calls, which is 'again' by default.
- Constructors are written without the equal sign between the type
name and the constructor name.
- A constructor name followed by brace-enclosed definitions defines
a singleton object with an explicitly specified behavior.
- 'subtypes T {definitions}' makes an existing type the implicit
supertype of definitions.
- '~' has a high priority, equal to 'label:', but when it's used
before a function being applied, it covers the whole application.
- A space in a string can be escaped by "\s" instead of "\ "
(reverted the change made in version 0.6.1), because a backslash
followed by spaces and then a newline should be ignored.
* New functions:
- ReverseGen, IterateBack
- DoReject
- TryRemove, TryCut
- GetLast, TryCutLast
- PartGen{,Back}, IteratePart{,Back}
- EndsWith
- Size{Is,AtMost}, Count{Is,AtMost,AtLeast}
- MapDictPartial
- SortGen{,By} - incremental sorting
- Shuffle{,List,Gen} in module Random
- FillInf, FillNewInf
- Variable{Byte,Char}{Input,Output} - change the underlying stream
at any time
- Partial{Byte,Char}Output - shield lower layers from flush:#end and
closing
- WantGarbageCollect in module Threads
- With{,Cancelable}AsyncExit in module Threads
- Ignore - ?_... {}
- Apply - ?f xs... {f xs...}
- Unsafe{Min,Max}{,Int}, UnsafeVector in module Unsafe
- EncodeInt, DecodeInt - conversion between ints and byte arrays
- WriteStackTrace
* Removed functions:
- IsNull
- JoinString
- MapNext
- MapPairs, MapPairsGen
- Join
- FinalizeWeakRef - use Close
* Renamed functions:
- Is -> HasType
- IsTrue -> Identity
- IsFalse -> '~'
- Using_ -> Ensure
- TouchObject -> Touch
- JoinGen -> Join
- ViewSequence -> PureIterator
- Intersect -> Intersection
- {BYTE,CHAR}_APPEND_INPUT -> APPEND_{BYTE,CHAR}_INPUT
- {Byte,Char}AppendInput -> Append{Byte,Char}Input
- {BYTE,CHAR}_COPY_INPUT -> PEEK_{BYTE,CHAR}_INPUT
- {Byte,Char}CopyInput -> Peek{Byte,Char}Input
- {BYTE,CHAR}_BUFFERED_{INPUT,OUTPUT} -> BUFFERED_{BYTE,CHAR}_{INPUT,OUTPUT}
- {Byte,Char}Buffered{Input,Output} -> Buffered{Byte,Char}{Input,Output}
- {BYTE,CHAR}_FILTERED_{INPUT,OUTPUT} -> FILTERED_{BYTE,CHAR}_{INPUT,OUTPUT}
- {Byte,Char}Filtered{Input,Output} -> Filtered{Byte,Char}{Input,Output}
- Escape -> WithExit
- {,Cancelable}TimeLimit -> With{,Cancelable}TimeLimit
- FileStatus -> TargetFileStatus
- FileOrLinkStatus -> FileStatus
- NamedFunction -> NamedCommand in module TextUI.ReadLine
* Changed standard equality predicates:
- 'Is' is strict equality. It compares the immutable structure of
two objects. It differs from 'IsSame' only by not distinguishing
the identity of value objects. An object is always equal to
itself, even NaN, and objects with different types are always
different. '0.0 ~%Is (-0.0)'.
Dictionary lookup, 'IsIn', 'IsEqual', and literal patterns use 'Is'.
A pattern 'is expr' is equivalent to 'when Is expr'.
'Is' is dispatched on the first argument only. The cases when both
arguments are the same object or when they have different types
are handled before dispatching. The default interpretation of 'Is'
for types without a specialization is 'IsSame'.
- '==' is arithmetic equality. It is defined for types which define
'<', and for complex numbers. The definition should be compatible
with '<' and '<='.
* Removed 'when', 'where', and 'is' patterns.
Changed the syntax of 'if', 'match', and 'define' patterns to
include a pattern to match the subject against:
- 'pat1->if cond'
- 'pat1->match expr pat2'
- 'pat1->define {def}'
New patterns:
- 'pat1->fun args...' (with an arbitrary predicate) - matches when
the subject matches 'pat1', and 'subj->fun args...' is true.
- 'pat1->fun args... = pat2' (with an arbitrary function) -
matches when the subject matches 'pat1', and 'subj->fun args...'
matches pat2.
- 'pat1->with fields' - matches when the subject matches 'pat1',
and each field matches. A field is either 'label:pat' which
specifies the symbol and a pattern to match the field value
against, or a name which specifies both at once.
The argument before '%op' or '->fun' can be omitted, defaulting
to '_'. This applies both to expressions (i.e. partial application)
and patterns.
If the keyword or function is negated with '~' in patterns with
'if', 'match', or a function, the negation doesn't apply to matching
the subject against 'pat1'. For example 'x ~%Is 0' binds the subject
to x if it's not 0, while '~(x %Is 0)' succeeds when x is not 0 but
doesn't bind anything.
* Using/4 and Ensure/4 have changed the argument order:
obtain commit rollback body.
* The first argument of Ensure is optional, defaulting to {}.
* Using and Ensure: if the body fails, and releasing the resource
fails too, the exception from the body has priority and is rethrown.
CloseAll: if several actions fail, the earliest exception has
priority.
* Revised the rules of signal blocking:
- The blocking state is still an (all, async) pair, but 'all' may
no longer be infinite.
- Explicit changes of the blocking state: BlockSignals increases 'all',
UnblockSignals decreases 'all', BlockAsyncSignals sets 'async' to 1,
UnblockSyncSignals sets 'async' to 1 and decreases 'all'.
- Trying to unblock signals which are already unblocked fails.
This is most likely an program error.
- Signal handlers, exception handlers, and the 'commit' part of
Using and Ensure increase 'all' by 1. The 'rollback' part of
Using and Ensure increases 'all' by 2. In the case of an exception
handler the state is changed wrt. the context of 'try'.
- ThreadBlockSignals starts with all=1 and async=0.
- Removed SignalsBlocked and AsyncSignalsBlocked.
- When relocking a mutex or read-write lock with signals unblocked,
signals are processed until a signal handler fails.
* FindPart returns the haystack size on failure instead of Null.
* Renamed 'start' to 'begin' when talking about index ranges,
in particular in fields of 'ViewPart'.
* EnvironmentVar{,s} renamed to EnvVar{,s}, moved from module
System.Environment to Prelude, and environment variable names
have been changed from strings to symbols.
* Renamed Unix functions to be more consistent with Unix names
or with one another:
- CreateDirectory -> MakeDirectory
- DeleteFile -> RemoveFile
- SymLink -> MakeSymLink
- ReadLink -> ReadSymLink
- GetCurrentDirectory -> CurrentDirectory
- SetCurrentDirectory -> ChangeDirectory
- IsFile -> IsRegularFile
- DirectoryContents{,Gen,Lazy} -> FileList{,Gen,Lazy}
- contents of modules System.Directories and System.FileStatus moved
to module System.Files
* ICONV_ENCODING and IConvEncoding moved from Prelude to
Encodings.IConv module (Core library).
BlockingMode moved from Prelude to System.Files module
(Unix library).
* CopyStream function has been split into CopyByteStream and
CopyCharStream.
* New functions in module System.Files:
- Make{Link,FIFO,Node}
- Change{Mode,Owner,Time}
* New library LZMA, providing LZMA compression scheme implemented by
Igor Pavlov, used in 7zip.
* When there is a name conflict between an implicitly imported
definition and some other definition, the explicit definition
is preferred and this is not an error. A note is shown though.
* '|' patterns bind names which are common to subpatterns.
* 'HasType' accepts multiple types and is true when the object
matches any of the types.
* Method definitions accept ','-separated sets of types. Multiple
methods are defined, for each combination of the types.
* 'private' and 'public' can be prefixes of definitions, e.g.
'private def F() {...};'.
* Added macros inc and dec: 'inc v d' is 'v = v + d' (but v is
computed only once), 'inc v' is 'inc v 1', and dec is analogous
with '-'.
* First-class modules are created by modules themselves instead of
each time they are used. The format of module contents has been
changed.
* Expression of the form 'module Module.Name' evaluates to the module
object of the given module. It can be used even before this module
has been compiled.
* Items of registered lists are unregistered only with 'Close' on the
key returned by 'Register'. Applying the key is no longer supported.
'RegisterEvent' returns an event object; it can be unregistered with
'Close' instead of by applying it directly.
* Old weak references has been split into two concepts: weak references
and finalizers, with a changed semantics.
'WeakRef' - create a weak reference from a key object, a value object
(which by default is the same as the key), and a close function.
A weak reference by itself doesn't keep its key nor value alive.
It enforces a relationship: as long as the weak reference and the
key are alive, the value is kept alive too.
'weakRef absent present' returns 'present value' if the key is alive
or 'absent()' otherwise. By default 'present' is 'Identity' and
'absent' is '{Null}'.
If the key dies before its weak reference dies, the associated close
function is scheduled for execution: it will be applied to the weak
reference. It is meant to remove the weak reference from a data
structure it is contained in. If the weak reference dies before the
key dies, the close function is not executed.
'Finalizer' - create a finalizer from a key object and a close
function. A finalizer doesn't keep its key alive; it is kept alive
by the key. When the key dies, the close function is scheduled for
execution: it will be applied to no arguments.
The 'Close' method of a finalizer executes its close function
immediately (or waits until it finishes if it's currently being
executed), making the finalizer inactive.
Collecting long chains of weak references is more efficient:
O(N) rather than O(N^2). This change was inspired by
http://www.haible.de/bruno/papers/cs/weak/WeakDatastructures-writeup.html
but uses a different algorithm.
Differences from the previous design: A weak reference is not kept
alive by its key. A finalizer doesn't have an associated value and
cannot be used to obtain a value. Explicit finalization is supported
only for finalizers. Killing (deactivation without executing the
close function) is not supported for either type. The close function
of a weak reference gets the weak reference as the argument.
A consequence of the change is that a value at a live key in a weak
dictionary, if it refers to the weak dictionary itself, no longer
keeps the dictionary alive.
* Spelling "FileName" changed to "Filename" in ReadLine functions:
FilenameCompletionFunction, FilenameQuoteCharacters,
FilenameCompletionDesired, FilenameQuotingDesired,
FilenameQuotingFunction, FilenameDequotingFunction.
* Find and FindBack accept multiple sequences. The starting index is
mandatory in this case.
* Implemented Union, Difference, and Intersection.
* Functions First, GetFirst, RemoveFirst, DoRemoveFirst, DoCutFirst,
TryCutFirst are applicable to all collections, not just sequences,
and in the case of sets and dictionaries operate on an arbitrarily
picked element.
* ReverseList can be applied to two collections:
ReverseList x y == List (ReverseList x) y
* Conversion of collections to strings and to character arrays
flattens them recursively.
* Generators and lazy lists are compared and hashed by elements.
* Get, GetFirst, and TryCutFirst don't have separate specializations
without explicit 'absent' argument.
IsEqual doesn't have separate specializations without explicit
element equality predicate.
Sort doesn't have separate specializations without explicit element
comparison predicate.
List doesn't have separate specializations without explicit 'rest'
argument.
* Functions Min and Max are separately dispatched generic functions
instead of always using '<'. When applied to numbers, they should be
understood as arithmetic operations. When any argument is inexact,
the result is inexact as well. They return the correct answer for
0.0 and -0.0. When any argument is NaN, the result is NaN.
* GCD takes an arbitrary number of arguments.
* The default Keys implementation is supposed to be the only one:
it's now a constructor instead of a generic function defaulting
to applying a private constructor.
* IsOdd doesn't have a separate specialization but is defined as
~IsEven.
* New syntax of expressions: 'match expression pattern' returns True
if the expression matches the pattern.
* Partial application is supported by '[]', '\', ',', 'if', 'case',
'match', and 'loop'.
* New type of variable 'forward x', which may not be read until
assigned, and which may be assigned only once.
* A dynamic variable with no initial value has no global value at all
instead of being initialized to Null.
* Unused names and imports are noted. A note is like a warning but
doesn't cause a non-zero exit code.
* The 'Touch' function ignores its argument. It has three roles:
- Silence the note about an unused name.
- Ensure that the object is not garbage collected at this point yet
(old 'TouchObject').
- Ensure that the name is available to C code.
* When a multithreaded program is exiting, all other threads are
canceled and waited for, and GC is performed.
* When a thread is about to be garbage collected, it is kicked using
ThreadKicked signal, so it has a chance to clean up. Threads with
signals blocked are garbage collected silently.
* ThreadBlockSignals blocks the signals once instead of absolutely,
so BlockSignalsLess in the body unblocks them.
* Event queues: EventReady can be called in two ways:
- EventReady commit
- EventReady commit rollback
The commit function is executed when this event is taken, and the
rollback function is executed when it is determined that it will not
be taken.
The rollback function may call EventNotReady if it determines that
the event is no longer ready, i.e. that something has happened
between it has notified that it's ready and it has been chosen as
the first event to be taken. The argument of EventNotReady is a
function which continues waiting.
* The last argument of Flush{,To} is now optional, defaulting to #sync.
* Supertypes of exceptions are used more consistently:
- PROGRAM_ERROR - should not happen in a correct program,
a library is used in a wrong way
- EXTERNAL_ERROR - data given to the program is corrupted
or the environment is uncooperative
- RESOURCE_ERROR - an operation needs more resources than
are currently available
- EXIT - a non-local exit is in progress
- SPECIAL_RESULT - this exception should be catched immediately
by the context, it carries out-of-band information
* Object ids are ordered. The order corresponds to the time of their
creation.
* ObjectId() creates an anonymous object id, not associated with
any object, but hashable and ordered like other object ids.
* Foreign threads are now more robust.
Renamed KO_{UNBLOCK,BLOCK}_OTHER_THREADS* to
KO_{ENTER,LEAVE}_FOREIGN*.
Removed KO_{UNBLOCK,BLOCK}_OTHER_THREADS_OR_{BLOCK,UNBLOCK}_TIMER.
KO_{ENTER,LEAVE}_FOREIGN* can be used instead, which now avoid
physical creation of a new thread if there are no other threads
which are running, waiting for I/O, sleeping, nor handling system
signals.
It is allowed to call KO_LEAVE_FOREIGN in an OS thread which has not
been created by Kogut. The thread is adopted as a Kogut thread, with
signals unblocked. The same Kogut thread is used to represent this
thread until it finishes.
New functions ko_{disallow,allow}_foreign_no_signals for disallowing
other threads temporarily to just acquire access to the runtime,
without running Kogut code.
Mismatched KO_{ENTER,LEAVE}_FOREIGN* are detected at runtime when
possible.
* c_eval has an optional name of the result, written before inputs.
If present, the result should be stored in this C variable, which is
protected against GC. If absent, result should be stored into the
unprotected KO_RESULT as before.
* FileExists, IsRegularFile and IsDirectory use lstat instead of stat.
* Unneeded symbols are freed from memory.
* Local variables which become dead at a particular point of code
are cleared, so the garbage collector doesn't unnecessarily retain
objects they pointed to.
* Renamed some environment variables controlling the runtime:
- KO_HEAP_LIMIT_RATIO -> KO_GC_FACTOR (default: 1.5)
- KO_MIN_HEAP_LIMIT -> KO_GC_SIZE (default: 4M)
- KO_HEAP_SIZE_RATIO -> KO_GROW_FACTOR (default: 1.5)
- KO_MIN_HEAP_SIZE -> KO_GROW_SIZE (default: 4M)
- KO_TICK_FREQUENCY -> KO_TIMER (default: 100)
* Improved detection of low memory condition:
- If more than KO_MAX_MEMORY (default: RAM minus 64M, or half of RAM,
whichever is larger) is used, OutOfMemory is signaled. This
replaces KO_MAX_HEAP_SIZE which measured live heap size rather
than allocated memory.
- If more than KO_MIN_MEMORY (default: 1/4 of RAM) is used, and less
than KO_MIN_FREE_MEMORY (default: 64M) is going to remain free
(including buffers and swap), OutOfMemory is signaled.
* KO_SHOW_STATS=1 and Kogut.Stats include GC time and maximum GC pause
as both real and CPU time.
* On Linux Kogut.Stats includes SystemStats which returns information
from sysinfo(), mostly memory sizes.
* If the 'inexact' option of Show is not Null, it means to show a
point when the number is not shown exactly, rather than when it
does not have an exact type.
* 'precision' and 'fracPrecision' options for Show may be 'Inf'.
* New show option showPrecision:True|False, default False - whether
to add trailing zeros to suggest the precision of inexact numbers.
* Conflicts in serialization unique names are reported.
* When an object could not be serialized, a deserializer will fail in
a predictable way.
* Names of types, functions, and singletons are symbols, not strings.
* Added functions which allow to locally extend or override
serialization rules:
- DefineSerializationRules {changes} - package serialization rules,
expressed by executable code which defines them, into an object.
- UseSerializationRules rules {body} - apply the packaged
serialization rules during evaluation of body.
* RecordSerialization accepts an optional argument: list of field
names. If it's present, the type doesn't have to be a record type.
* Changes in the Python binding:
- RawPyCall, RawPyGetAttr, and RawPyGetItem are almost the same as
the ordinary application and '@', but wrap the resulting Python
object in Kogut without trying to convert it.
- Removed RawPy{Set,Has,Del}Attr, RawPySetItem,
PyDef{Class,Init,Method}.
- Renamed PyIs -> PyHasType, PyExceptionIs -> PyExceptionHasType.
- Python types are called PyNONE, PyINT, PyLONG, PyFLOAT, PyBOOL,
PySTRING, PyUNICODE, PyTUPLE, PyLIST, PyDICT, PyTYPE, PyOBJECT,
PySUPER, PyCLASS, PyINSTANCE, PyMETHOD, PyCLASS_METHOD,
PySTATIC_METHOD, PyPROPERTY.
- New types PySET, PyFROZEN_SET, PyENUMERATE, PyREVERSED, PySLICE.
- Constructors of Python types have a Kogut-like interface.
They are called PyInt, PyLong, PyFloat, PyString, PyUnicode,
PyTuple, PyList, PyDict, PySet, PyFrozenSet, PyEnumerate,
PyReversed, PyClass, PyMethod, PySlice.
- New functions Py{Get,Set,Has,Del}SpecialAttr, PyCallSpecialMethod,
PyType, PySymbol, ByteArrayToPyString, PyStringToByteArray.
- Python exception types are available to Kogut: PyVALUE_ERROR etc.
'Fail (PyException type value)' raises a Python exception.
- Attributes of Kogut objects as seen from Python don't necessarily
correspond to Kogut fields, but can be defined per Kogut type with
PyDef{Get,Set,Del}{,Special}Attr and PyDef{,Raw}{,Special}Method.
- PyImport and PyAddModule take symbols, not strings.
- Translation of collection interfaces between Python and Kogut
is more consistent and more complete. In particular the semantics
of iteration over dictionaries respects the convention of the
language (key/value pairs in Kogut, keys only in Python).
- Serialization / pickling works across languages. Detection of
sharing works only within a subgraph of objects of one language
though.
* Python code can run concurrently with Kogut code. Python code may be
called from multiple Kogut threads and vice versa. It is now safe to
call Kogut from __del__ methods of Python objects.
Switching between Python and Kogut is much slower however, and
minimal supported version of Python is now 2.3.
* Fixed a few issues with Python 2.5.
* Perl code can run concurrently with Kogut code. Perl can only be
called from a single thread.
* KeyNotFound exception includes the key.
* 'local', 'try', and 'handle' don't require braces in their bodies,
and in the successful continuation of 'try'. These arguments may be
arbitrary expressions, where braces denote a function and thus have
the same meaning as before.
* Names which are defined but not used are reported, unless they start
with an underscore.
* Stack traces include exceptions thrown during stack unwinding.
* RunProgram passes the exception to the parent process if the program
could not be executed.
* Improved handling of the non-blocking mode of standard streams.
If pthreads are used, the mode is queried at startup and is used
to choose the method of ensuring that only the current thread is
blocked by I/O.
If pthreads are not used, standard streams are made non-blocking,
and the original mode is restored before exiting or before
ExecProgram (except when the current process is a child of
ForkProcess{,CloneThreads,KillThreads}).
* Unicode character database updated to Unicode 5.0.0.
* New example: Connect Four game (koc4).
* kocals supports variables, named functions, conditionals,
comparisons.
New kocalc constants: inff, nan, e. New functions: min, max,
isdivisible, iseven, rationalize, isnumber, isnull, ispair, isbool,
isexact, isfloat, isfinite, isinfinite, isnan, ratio, float.
Running kocalc with arguments evaluates them and exits.
* Small examples moved from directory tests to examples/small.
* New small examples: KnightsTour, Sudoku.
Sudoku was translated from a Lisp program by Frank Buß
<http://www.frank-buss.de/lisp/sudoku.html>
* ctags is a ctags config file to be put into ~/.ctags or included
from it.
* 'kokoc --depend' uses the real parser of the compiler instead of
matching lines with regexps.
* kokoc accepts C++ sources (extensions .cc, .cxx, .cpp, .c++).
Kokogut headers are compatible with C++. Communication between
Kogut and C++ must be done through extern "C" functions.
* kogut-mode.el: M-q fills paragraphs in comments and strings.
Automatic indentation reimplemented with slightly different rules.
Local variables which look like standard macros but are not applied
to arguments are highlighted as regular names.
* Changed hash formula for integers.
* Changed serialization format.
* More efficient code is generated: lots of minor improvements,
in particular related to loops (lambda-lifting, tighter tail
recursion, reduced chained calls), mutable variables (they are not
materialized as objects when possible), generic function dispatch
(inlined code), objects with lots of fields (symbol lookup) etc.
Option -O affects the generated C code by turning on some
optimizations; the code may be longer. -O and -O1 through -O9 are
equivalent (though they might be different for the C compiler),
-O0 reverts to the default.
* Fixed incorrect code generated by gcc-4.2.0 (gcc-4.1.0 was fine),
by reducing pointer type punning and making one function not inline.
Generated code still violates strict rules of pointer aliasing in C,
but this would be hard to avoid, and it works now.
* In version 0.6.1 the runtime was being compiled without optimization.
* Bugs fixed:
- Crash when a GC occurs during creating an IConv encoder or decoder.
- Sorting was not stable.
- Find for LIST with a non-zero starting index was wrong.
- Declared supertypes are checked for being actually types.
- Fixed QuotRem, Mod, and DivMod for mixed ints and floats.
- Fixed IsDivisible when the second argument is a literal power for 2.
- Fixed adding an already existing element to HASH_SET_BY.
- Pipes created for redirected processes are set to blocking mode.
- The timer is recreated after ForkProcess{,CloneThreads,KillThreads}.
- CPU time statistics have overflowed after 36 minutes.
New in Kokogut-0.6.1 (25 January 2006), a release with readline
interface and settable default numeric types:
* kokoc doesn't pass -O2 to gcc by default. It accepts options
beginning with -O and passes them to gcc.
* Assignment returns Null rather than the assigned value.
* The sigsafe library is used when available,
<http://www.slamb.org/projects/sigsafe/>.
It is recommended, otherwise signal handling will have race
conditions. When building sigsafe, set debug=0 in SConstruct.
* New functions:
- GetOrSet dict key absent - set dict@key to absent() if it did not
exist, and return it
- Unsafe{Eq,NE,LT,GT,LE,GE,Neg}Int in module Unsafe
- Cplx in module Math (replaced) - convert an arbitrary
representation of complex numbers into CPLX
- WithoutWaiting in module Threads
- CloseAll - execute all actions even if some of them fail
- ReadByteArrayFrom - read a fixed number of bytes
- ReadBlockAt, WriteBlockAt, ReadBlockAhead, CanReadAhead -
I/O at the specific position, without moving the file pointer
- AttachDynamic - attach the current dynamic environment to a
function, i.e. make a function which is executed with bindings
of dynamic variables taken from the place of AttachDynamic
* Renamed:
- HandlerOfSystemSignals -> SystemSignalHandler
- {Text,Binary}Reader -> {Text,Binary}Input
- {Text,Binary}Writer -> {Text,Binary}Output
- ReadBlock -> ReadSomeFrom
- WriteBlock -> WriteSomeTo
- FLUSHING_OTHER -> TIED_INPUT
- FlushingOther -> TiedInput
- {,BYTE_,CHAR_}INPUT_FILTER -> {,BYTE_,CHAR_}FILTERED_INPUT
- {Byte,Char}InputFilter -> {Byte,Char}FilteredInput
- INPUT_DECODER -> DECODING_INPUT
- InputDecoder -> DecodingInput
- {,BYTE_,CHAR_}OUTPUT_FILTER -> {,BYTE_,CHAR_}FILTERED_OUTPUT
- {Byte,Char}OutputFilter -> {Byte,Char}FilteredOutput
- OUTPUT_ENCODER -> ENCODING_OUTPUT
- OutputEncoder -> EncodingOutput
- {,BYTE_,CHAR_}INPUT_BUFFER -> {,BYTE_,CHAR_}BUFFERED_INPUT
- {Byte,Char}InputBuffer -> {Byte,Char}BufferedInput
- {,BYTE_,CHAR_}OUTPUT_BUFFER -> {,BYTE_,CHAR_}BUFFERED_OUTPUT
- {Byte,Char}OutputBuffer -> {Byte,Char}BufferedOutput
- Compress{GZip,BZip2} -> {GZip,BZip2}Output
- Decompress{GZip,BZip2} -> {GZip,BZip2}Input
* Removed:
- E in module Math; use Exp 1 instead
- Cplx in module Math (there is a different Cplx now); use a+b*I
instead
- HandleSystemSignals; use SystemSignalHandler variable instead
- ProcessSyncSignals; correct handling of synchronous signals is
generally done by waiting primitives
- WithInfiniteBuffer
* ByteCopyInput and CharCopyInput make a view of the given stream,
array or string, which can be read without changing the original.
The stream must support ReadBlockAhead, which in practice means
that it should be buffered (the buffer will grow) or seekable.
* Reversed the result of FilterBlock: it returns True when output
did overflow.
FilterBlock is no longer called with Null as the input buffer
(which used to be equivalent to an empty array).
Revised the meaning of flush. If it's not #none and there is room
in the output buffer, FilterBlock should not leave anything in the
input buffer.
* Non-Unix line separators are supported:
- 'LineSepDecodingInput input lineSep' wraps input such that
the given lineSep is translated to "\n"
- 'LineSepEncodingOutput output lineSep' wraps output such that
"\n" is translated to the given lineSep
- TextReader and TextWriter have a named parameter lineSep
An output lineSep is #lf (Unix), #cr (classic Mac), or #crlf (Windows).
The default is the value of the dynamic variable DefaultLineSep,
except that for sockets the default is #crlf. The default value of
DefaultLineSep is the local convention of the platform.
An input lineSep can be one of the above, or #auto which accepts
any of these separators. The default is #auto.
Setting lineSep to #cr in either direction actually swaps "\n" and
"\r".
Since setting an input lineSep to #crlf translates "\r\n" to "\n",
where the program treats "\n" after translation as line separator,
in this case either "\n" or "\r\n" separate lines.
* Elaborated the issue of specifying character encodings:
- supertype ENCODING for encodings
- function Encoding converts an encoding descriptor (i.e. either
encoding or encoding name) to an encoding
- dictionary NamedEncodings and function NamedEncoding are used
internally to convert names to encodings
* EncodingError and DecodingError store the encoding for debugging.
The other field of DecodingError is now called bytes, not byte, and
holds the list of bytes which caused the error, or the empty list in
case of an unexpected end of bytes. ReplaceCodingErrors skips its
size in input.
* "\0;" characters in strings passed to C (e.g. file names) are
detected and reported as errors of type NUL_ENCODING_ERROR.
* More encodings are supported natively, without using iconv
(in addition to Latin1Encoding):
- ASCIIEncoding
- UTF8Encoding
- UTF{16,32}{BE,LE}Encoding
- UTF{16,32}Encoding with an argument which is meaningful for the
encoder: #be (prepend the BE BOM and use BE), #le (prepend the
LE BOM and use LE), #noBOM (don't prepend any BOM unless needed
and use BE). The "UTF-16" and "UTF-32" names correspond to
UTF{16,32}Encoding #be.
* UTF8EscapedBytesEncoding is an extension of UTF-8 where any byte
sequence can be decoded into a string and yields the same byte
sequence when encoded again. Bytes which would be invalid in UTF-8
and 0 bytes are prefixed with U+0000 and stored as a character
between U+0080 and U+00FF or U+0000. On encoding only those
character sequences prefixed with U+0000 are valid which would be
invalid in true UTF-8, so different strings encode to different
byte sequences. Valid UTF-8 byte sequences which don't contain 0
bytes yield the same results as in true UTF-8. The idea is based
on UnixEncoding in Mono but slightly different.
If the environment variable KO_UTF8_ESCAPED_BYTES is set to 1 and
the default encoding (as determined by KO_DEFAULT_ENCODING or the
locale) is "UTF-8", then it means UTF8EscapedBytesEncoding instead
of UTF8Encoding. Specyfying "UTF-8" in the program explicitly always
means true UTF-8.
* Parameters of the default StdIn, StdOut and StdErr (encoding,
line separator, buffering) are determined the first time these
streams are used, rather than at the beginning of the program.
Global bindings of dynamic variables are consulted to determine the
parameters, i.e. they must be assigned to instead of being locally
rebound to take effect here. Accessing the default StdIn has a side
effect of accessing StdOut, because of OutputFlushingInput.
* ProgramName and Parameters are converted from byte strings using
DefaultEncoding each time they are accessed, until they have been
assigned or locally rebound. This implies that the program can catch
decoding errors.
* DefaultEncoding is determined the first time it is needed. This
implies that the program can install additional encodings before
the name of the default encoding is mapped to the actual encoding.
* The value of a lazy variable is computed in the dynamic environment
from the place of its definition.
* New library ReadLine provides an interface to GNU Readline.
* New library Digest with modules Digest, Digest.SHA1, and Digest.MD5.
SHA1 code is derived from RFC 3174. MD5 code is derived from the
RSA Data Security, Inc. MD5 Message-Digest Algorithm (RFC 1321).
* Removed library QSort. It was not useful (sorting is implemented
natively), just intended as an example of callbacks, which are
now better demonstrated in ReadLine, and it was subtly wrong with
respect to GC.
* It's easier to use optionally available libraries: appending "?"
to the name of a library silences the warning if the library is
not found.
* Inf and NegInf are considered REAL, and allowed as real and
imaginary parts of complex numbers.
They are stronger than InfFloat and NegInfFloat in comparisons
and arithmetic.
* New option for showing numbers: inexactSpecial. If not Null,
it overrides special for inexact infinity and inexact NaN.
* Transcendental functions return exact numbers when possible, e.g.
64 %Power (2/3) is exactly 16, Log (9/25) (125/27) is -2/3, and
Exp (-Inf) is 0. Not all cases of complex rationals are covered
though because the author doesn't know needed algorithms.
* Dynamic variable DefaultReal holds a function which converts a real
number to some specific type. The default is Float.
DefaultReal determines the type of irrational function results
derived from rational arguments, the type of literals with a decimal
point or exponent, and the conversion used in default implementations
of functions for real arguments.
Setting DefaultReal to Ratio works for literals but causes
transcendental functions to loop for most exact arguments, because
their definitions for INT and RATIO use DefaultReal if they are
unable to find a rational result.
* Similarly to DefaultReal, the dynamic variable DefaultRational holds
a function which converts a rational number to some specific type.
The default is Ratio.
DefaultRational determines the type of rational but non-integer
function results derived from integer arguments, and the conversion
used in default implementations of functions for rational arguments.
DefaultRational can be set to Float, in which case e.g. division of
integers produces a float instead of a ratio.
* Some arithmetic functions have default definitions which convert
arguments using Int, Ratio, DefaultReal and Cplx:
- Int, '+', '-', '*', Quot, Rem, QuotRem, Div, Mod, DivMod,
BitNot, BitAnd, BitOr, BitXor, BitShift, SizeInBits,
Ratio, '/', Float, ScaleFloat, Conj, Sqrt, Phase, Exp, Log, Power,
Sin, Cos, SinCos, Tan, SinH, CosH, SinCosH, TanH,
ASin, ACos, ATan, ASinH, ACosH, ATanH
Other arithmetic functions have default definitions in terms of
other operations rather than by conversion:
- Abs, Signum, Sqr, IsDivisible, IsEven, Floor, Ceiling, Trunc,
Round, GCD, Hypot
Special cases:
- '==', '<', '<=' - default implementations convert real numbers to
Ratio instead of DefaultFloat
- IsFinite, IsInfinite, IsNaN, SignBit, DecodeFloat - defined for
each concrete type separately, without default implementations
* Float arrays accept any real numbers as elements and convert them to
floats.
* Inferring regions where signals can be processed has been fixed and
made more consistent. In particular:
- Locking a mutex or read-write lock with signals unblocked is
interruptible.
- In synchronous mode only one signal at a time is handled. Any
further signals are handled only if the reason to wait still
holds.
- GarbageCollect, MaybeGarbageCollect and Close in synchronous mode
are no longer interruptible.
- WaitForProcess in synchronous mode processes a pending system
signal only if it would actually wait.
- If a signal is sent before the target thread started waiting in
synchronous mode, further signals are correctly blocked while
handling the signal.
- If a signal is sent before the target thread is going to wait for
opening a file or for a process in synchronous mode, the signal is
handled before waiting.
- The time window when handling a system signal sent just before a
blocking system call is delayed after the system call returns is
reduced in case of some functions. Unfortunately with standard
Unix APIs it cannot be entirely eliminated.
The following operations are interruptible in synchronous mode
when they have to wait:
- Wait
- WaitForThread
- accessing a lazy list
- Sleep
- SleepForever
- Take, TakeFirst
- opening a fifo
- reading from or writing to a pipe, fifo, socket, or a device which
may block (like a terminal)
- Connect, Accept
- WaitForProcess
The following operations may cause the thread to wait but are not
interruptible in synchronous mode:
- Lock
- Unlock, Wait (when relocking at the end)
- LockRead, LockWrite, LockReadWillWrite, ChangeLockToWrite
- UnlockRead, UnlockWrite, UnlockReadWillWrite, ChangeLockToRead
(when relocking at the end)
- accessing a lazy variable
- executing a module
- FinalizeWeakRef
- returning from a C callback in a wrong order, if pthreads are not
available
* Functions Using and Using_ accept also 4 arguments, with separate
functions for rollback and commit instead of the single release,
called depending on whether the body failed.
* Changed event queues:
- The event is specified as a single action which either returns,
or fails, or calls EventReady with an argument being an action
to be performed when this event is taken.
- There is no attempt to detect whether the final action waits.
* New algorithm for generating random numbers: ISAAC by Bob Jenkins
<http://burtleburtle.net/bob/rand/isaacafa.html>. Provided by
module Random.ISAAC. The constructor is RandomStateISAAC.
The constructor for Mersenne Twister in Random.MT got renamed
to RandomStateMT, but module Random reexports it under the name
RandomState.
* In strings \cX denotes a control character when X is an ASCII letter
or one of these characters: @ [ \ ] ^ _ ?
* In strings "\ " is a space instead of "\s". This is useful after
a backslash and line break.
* If libffi is available, we provide the LibFFI library which just
links to libffi and adds options to compiler invocations; it doesn't
provide any modules. Libffi is useful to wrap function closures in C
function pointers, among other things.
* Parsec no longer requires characters to be comparable, but they must
be hashable.
* CopyStream no longer flushes the output stream at the end.
* The Calc example moved to examples directory and installed under the
name kocalc. It now supports float constants and more functions.
Type '?' for help.
* Bugs fixed:
- SizeInBits returned wrong results for small negative numbers.
- IsEven was wrong with an earlier version of GMP than 3.1.
- Log was sometimes returning NaN instead of a complex number.
- Passing strings to C using EncodeSizedCString truncated the
last character if there were any non-ASCII characters.
- NextPermutation was repeating a permutation when some of inputs
were equal.
- There were memory leaks in dividing big integers into ratios.
- Get for WEAK_HASH_DICT{,_BY} no longer holds the lock when
applying absent and present.
- Fixed the logic of estimating the amount of external memory
(e.g. from malloc) to trigger GC earlier.
New in Kokogut-0.6.0 (29 October 2005), a release with imperative
iterators and number formatting:
* Changed the default iteration protocol and the nature of generators.
There were two major problems with old iterators: the primary
iteration function, Traverse, executed the same action for each
element, and thus too often clients needed to use a different
and less efficient mechanism (Next); and while the interface of
generators didn't rely on mutable state, some generators worked
correctly only when used linearly.
Now the function Iterate starts iteration and returns a stateful
iterator. When an iterator is applied to two arguments, by
convention called 'absent' and 'present', it checks whether there
are more elements; if yes, it cuts the next element and enters
'present elem', otherwise it enters 'absent()'. It may be called
again after the end.
The function Iterate can be applied to any number of collections.
In general it returns a multi-iterator which applies 'present'
to the appropriate number of elements, until any collection ends.
A generator is a "virtual" collection designed to be iterated over.
It's created by 'Generate {code}', where the code makes a new
iterator; when the generator is applied to no arguments or when
Iterate is applied to it, it executes the code.
Most generators may be iterated over multiple times, but some of
them (e.g. those reading from files) may not.
* New:
- GetFirst, TryCutFirst
- MapPartial, MapPartialGen - like Map and MapGen, but you may
Pass() instead of providing an element
- ReverseList, MapReverseList - reversing with the output going to
a list, more efficient than Reverse{,Gen} with conversion
- MapSepBy, MapEndBy
- Average, MapAverage
- MinimumBy, MaximumBy
- EmptyIterator, EmptyGenerator
- NextPermutation - takes a list and an optional less-than predicate,
returns the lexicographically next permutation or Null if it was
already the last one
- ReadBytes{,Gen,Lazy}From
- ReadChars{,From} - now returns an array
- ReadLines{,From} - now returns a list
- SkipLine{,From}
- AnyCharExcept in module Parsec
- DirectoryContents - now returns a list
- {,Neg}InfFloat, NaNFloat, IsInfinite, IsNaN, SignBit
- Hypot in module Math
- SizeInBits
- {Min,Max}SmallInt, IsSmallInt, Unsafe{Eq,NE,Quot,Rem,Div,Mod,
IsDivisible,IsEven,ShiftL,ShiftR,SizeVector,AtVector} in module Unsafe
* Renamed:
- Rest -> RemoveFirst
- Some -> Any
- ListSort{,By} -> SortList{,By}
- NextMany -> MapNext
- Iterator -> ViewSequence
- Generate -> Collect (new)
- Gen{Map,Join,MapJoin,MapPairs,Select,Reject,Unique,UniqueBy} ->
{Map,Join,MapJoin,MapPairs,Select,Reject,Unique,UniqueBy}Gen
- Read{Chars,Lines}{,From} (old) -> Read{Chars,Lines}Lazy{,From}
- GenRead{Chars,Lines}{,From} -> Read{Chars,Lines}Gen{,From}
- DirectoryContents (old) -> DirectoryContentsLazy
- GenDirectoryContents -> DirectoryContentsGen
- ProgramOutputLines (old) -> ProgramOutputLinesLazy
- GenProgramOutputLines -> ProgramOutputLinesGen
- COLLECTION_EMPTY, CollectionEmpty -> EMPTY_COLLECTION, EmptyCollection
- TimeAfter -> AbsoluteTime
* Removed:
- Unfold, Iterate (old), IterateIncl, Collect (old), GenCollect
- using macro; use Using and Using_ functions instead
- IsNegZero; compare with 0 and use SignBit instead
* Function String no longer converts elements of sequences with String
again. It used to be inconsistent, depending on the sequence type.
* {Select,Reject}{,Gen} may be applied to more than one collection.
Returned elements come from the first collection.
* Removed SetWhenAbsent. Added SetDefault instead, which applies the
given function to no arguments instead of to the key. This was the
most common usage.
* Function Sqr moved from module Math to Prelude.
* Options for Show for numbers (the implementation is based on
the paper "Printing Floating-Point Numbers Quickly and Accurately"
by Robert G. Burger and R. Kent Dybvig):
- base:b, default 10 - number base, between 2 and 36. This option
does not apply to the exponent which is always shown in decimal
if present at all. No base marker is added automatically, it can
be injected through the sign option if wanted.
- mixed:False|True, default True - when showing a vulgar fraction
with the absolute value greater than 1, whether to show the
integral part separately instead of writing an improper fraction.
- scientific:False|True|(min, max), default (-4, 15) for floats and
(-4, Inf) for ints and ratios - whether to use the scientific
format. If it's a pair and fixedDigits is not Null, it's treated
the same as False. Otherwise a pair determines the range of
exponents (corresponding to the range between b^min and b^max of
the absolute value of numbers) outside which the scientific format
it always used. Sufficiently large numbers inside the range still
use the scientific format if not all their integral digits would
be precise. Scientific format is never used with vulgar fractions.
- fixedDigits:n|Null, default Null - number of digits shown after
the point, either for the regular format (absolute precision) or
for the scientific format (relative precision). Trailing zeros are
added as needed. Null means to show as few digits as possible for
maintaining full precision.
- digits:n, default 1 - minimal number of digits shown before the
point. Leading zeros are added as needed. This option does not
apply to the scientific format. If digits == 0, the number 0 can
show no digits at all, unless other options imply otherwise.
- inexact:Null|0|1, default Null - if not Null, inexact numbers
always show the point and the given minimal number of digits after
the point. This allows to distinguish integers, ratios and floats
based on their printed representations.
- precision:n|Null, default Null - number of digits assumed to be
accurate (relative precision). Null means to assume the inherent
precision of the type. This option also limits the maximal number
of significant digits shown, unless overridden by fixedDigits.
- fracPrecision:n|Null, default Null - like precision, but expressed
in digits after the point (absolute precision).
- sign:(pos, neg), default ("", "-") - sign markers.
- imagSign:(add, sub, pos, neg), default ("+", "-", "", "-") - sign
markers for the imaginary part. First two are used when the real
part is shown, last two when not.
- imag:(timesI, i), default ("*I", "I") - timesI is added after
the imaginary part, except when it's 1 or -1, in which case i
is used.
- special:(inf, nan), default ("Inf", "NaN") - how to show infinity
and not-a-number.
- mixedSign:(pos, neg), default ("+", "-") - written between the
integral and fractional part, if the mixed fraction format is
used.
- slash:str, default "/" - written between numerator and denominator
if the vulgar fraction format is used.
- case:#upper|#lower, default #upper - the case of letters used as
digits above 9.
- point:str, default "." - how to show the point.
- insignificant:ch, default "0" - how to show trailing insignificant
digits. They might have to be shown if fixedDigits is big enough,
or if a large number is shown with scientific forced to False.
Scheme uses "#" for this purpose.
- exp:str, default "e" - the exponent marker.
- expSign:(pos, neg), default ("+", "-") - sign option for the
exponent.
- expDigits:n, default 2 - digits option for the exponent.
Ratios are shown as vulgar fractions when fixedDigits, precision
and fracPrecision are all Null, even if the scientific option would
imply the scientific format, because it would be unclear how many
digits to show.
For complex numbers the imaginary part is not shown if it's equal to
0; the real part is not shown if it's equal to 0 and the imaginary
part is shown; the absolute value of the imaginary part is shown as
a mere imaginary unit instead of a number multiplied by the
imaginary unit if the number is equal to 1. If inexact is Null,
equality here permits also floats, except negative zero.
* Changed rules of weak references. Previously a key of a weak
reference was considered dead if it was reachable only through
finalizers. This meant that one could safely reference a key from
its own finalizer, but finalizers could not rely on other objects
being usable when they are run.
Now the key keeps just the value alive, and finalizers are
considered strongly reachable until they are run, together with
everything they need. The finalizer may not refer to the key, or the
key will never be finalized. You can use finalizers to constrain the
order of finalization.
A consequence for usage is that an object might have to be split
into two parts: an outer part which has a weak reference attached
and refers to the inner part, and an inner part which is referenced
from the finalizer.
* In synchronous mode signals are only handled while waiting for a
thread, I/O, a timeout, or while sleeping forever; and only when
actually waiting. They are not handled while waiting for a mutex,
a read-write lock, a lazy variable, a weak reference finalizer;
or when the reason to wake up is true immediately.
Lazy variables no longer support CommitLazy with bouncing between
obtaining a resource (in synchronous mode) and computing the value
(with signals blocked).
Lazy lists however support the old semantics of lazy variables with
respect to signals, and support CommitLazy. Thus the obtaining phase
can wait for another lazy list while being interruptible.
* Event queues: a mechanism for serializing multiple sources of
events.
An event is in general handled in two phases: one function waits
until it is ready, and another one confirms that you want to handle
it now. Confirming some events has side effects (e.g. reading a line
from a text stream removes it from the stream) and thus it might be
important to confirm only one event at a time.
'EventQueue()' makes a new event queue, of type EVENT_QUEUE.
'RegisterEvent queue can do' adds to the queue a new source of an
event, where 'can' is a nullary function which waits until the event
is ready, and 'do' is a nullary function which confirms the event.
'TakeEvent queue' waits until one of the events happens, and returns
the result of the 'do' function of the first event which was ready.
A given event is handled at most once.
The 'do' function is applied with signals in synchronous mode, and
with one signal pending, of type NOT_YET. If it would have to wait
for the event, this means that the event is no longer ready, or that
it was only partially ready and we must wait for more data. In this
case the 'do' function will handle the signal and fail, and TakeEvent
will continue waiting.
This implies that 'do' should behave sensibly if restarted after
being interrupted synchronously. If the event needs no confirmation,
the 'do' function might not do anything but return a value; 'do'
will only be applied after 'can' returns. The 'do' function usually
tags the result so it can be distinguished from other events.
Examples of functions to be used in 'can' which are suitable for
various functions used in 'do' (they are new):
- CanReadFrom for ReadBlock, ReadByteFrom, ReadChar{,From}
- CanReadLineFrom for ReadLine{,From}
- CanWriteTo for WriteBlock, Flush{,To}; WithInfiniteBuffer can be
used before to fill the buffer with data for flushing
- CanPut for Put
- CanTake for Take
- CanTakeFirst for TakeFirst
- CanTakeEvent for TakeEvent
- CanConnect for Connect in module Network.Sockets; BeginConnect can
be used before to initiate asynchronous Connect
- CanAccept for Accept in module Network.Sockets; BeginAccept can be
used before to initiate asynchronous Accept
- CanReceive for Receive{,From} in module Network.Sockets
- CanSend for Send{,To} in module Network.Sockets
- CanReadFrom RawStdIn for GetCh in module TextUI.Curses
Examples of events which need no confirmation: Sleep, Wait (if we
know that the condition won't become false again), WaitForThread.
Examples of events where waiting for them to be ready without
confirming them is unimplementable, so they are always confirmed
when waiting finishes even if they are not handled immediately:
Open{Raw,Text,Binary}File, WaitForProcess.
* Registering a value in a registered list is done with the Register
function, instead of applying the registered list itself.
Registered lists are sequences: they are operated on using Iterate,
TryCutFirst and other generic sequence functions.
Iteration over a registered list now takes a snapshot of its state
from the beginning of the iteration; this round is not affected by
changes of the state after the iteration has started.
* If the body of a 'try' case is prefixed with 'handled:', the
exception is considered handled when the body is executed. This
means that the stack is unwound and the signal blocking state is
restored.
* If an object we extend or a feature we include is prefixed with
a label, the base object is available under this label instead of
'base'.
* New syntax of a definition: 'ref name = expr' is equivalent to
'let (ref name) = expr'.
New syntax of a pattern: 'set variable' is equivalent to
'private tmp & define {variable = tmp}'.
* 'case e ?x => ...' is equivalent to 'case e [x {...}]'.
* In character output buffers flushLines is #none by default, except
for StdOut, StdErr, and sockets, where it's #soft as before.
* DefaultBufferSize is a dynamic variable instead of a constant,
used by CopyStream.
* Swapped arguments of ShowParensIf.
* New functions ShowException and ShowSourceLoc instead of specializing
the generic Show. By default Show should format the value in a way
which is suitable as a subexpression of another value.
* DecodeFloat returns the mantissa normalized, such that changing it
by 1 yields the smallest increment of the original value.
* New test: Hamming.
* Unicode character database updated to Unicode 4.1.0.
* Programs which use a deep stack don't use so much time in GC because
minor GC now scans only the changed part of the stack.
* Detection of pthreads should be more portable.
* Bugs fixed:
- Functions operating on flat sequences where the sequence size is
a valid index (e.g. AddPart or IsGraphemeClusterBoundary) did not
accept that index in Kokogut-0.5.3.
- IsWordBoundary was True before control characters, should be False.
- Python sys.argv is set to Kogut Parameters. Not sure whether this
was a bug but pygtk crashed when there was no sys.argv.
New in Kokogut-0.5.3 (29 March 2005), a release with pthreads and
serialization:
* There are three variants of ForkProcess in module System.Processes:
- ForkProcess - other threads are stopped at a point where signals
are unblocked; the process is forked; in the child process threads
are canceled, and in the parent they are resumed
- ForkProcessCloneThreads - all threads continue running in both
processes
- ForkProcessKillThreads - other threads are killed immediately with
no cleanup (used before ExecProgram)
* Kogut threads can optionally make use of OS threads, like in Haskell,
to improve parallelism of foreign functions. The design is described
in a paper by Simon Marlow, Simon Peyton Jones, and Wolfgang Thaller
"Extending the Haskell Foreign Function Interface with Concurrency"
A Kogut thread can be bound to an OS thread or unbound; conversely,
an OS thread can be bound to a Kogut thread or be one of worker
threads for executing unbound Kogut threads. The main thread and
threads which currently run callbacks are bound.
C code can unblock other threads during a computation which doesn't
access the runtime, by bracketing it in KO_UNBLOCK_OTHER_THREADS() /
KO_BLOCK_OTHER_THREADS() (the latter processes signals if they were
unblocked and may throw an exception). These macros merely stop the
timer if pthreads are not used.
If ko_interrupt_by_signal(sig) is called before
KO_UNBLOCK_OTHER_THREADS(), then a Kogut signal sent to this thread
while it executes a foreign call will cause the given Unix signal to
be generated to wake it up from a syscall. This state lasts until
the next KO_BLOCK_OTHER_THREADS().
There is no problem with callbacks returning out of order when
pthreads are used because they are run in separate OS threads.
Since it's impossible to fork a process together with other pthreads,
in the child process after ForkProcess and ForkProcessCloneThreads
all threads other than the one doing the fork become unbound.
If such orphaned thread returns from a callback, or if it was
executing foreign code at the time of the fork, it is killed as with
ForkProcessKillThreads, because the code it was supposed to return to
was executing in another pthread which doesn't exist here.
Switching between different bound threads, or between a bound and
an unbound thread, is slower than switching between unbound threads.
Since the main thread is bound, it can be useful to run the main
computation in a different thread if it synchronizes with other
threads a lot.
* Serialization framework:
- SerializeContext / DeserializeContext create an object which
maintains serialization / deserialization of a sequence of
objects. Their argument is a byte stream to write / read
serialized objects to / from. A context manintains a dictionary
of objects seen so far, to preserve sharing and cycles. Using the
same context for several objects of the same type usually produces
a smaller result.
- 'Serialize context object' writes the object using the context.
'Deserialize context' reads an object using the context and
returns it.
- Function Serialization defines an unique name of a type and
specifies how to serialize / deserialize objects of this type.
SingletonSerialization and RecordSerialization allow to quickly
define serializers and deserializers for singletons and records.
Unique names should be globally unique (they are used to find the
deserializer), so for types outside Prelude they should be
qualified with a module name.
- Only type objects for which serialization has been defined,
or which have been registered with TypeSerialization, can be
serialized. Only functions registered with FunctionSerialization
can be serialized.
- Only objects of types for which serialization has been explicitly
defined are serializable. You cannot serialize lazy lists,
generators, threads, handles to external resources like files,
nor various transient objects like mutexes. Serializing a private
symbol gives back a public symbol with the same name.
- Serialized streams can be concatenated and read as one stream.
* The initializer of a lazy variable is run with signals blocked. This
is usually desirable, because otherwise an asynchronous exception
could destroy a lazy variable which happened to be evaluated at that
time. This semantics also applies to initializing modules other than
the main module.
For functions like ReadLines it would have an unhelpful effect of
blocking signals while waiting for a resource. For these cases there
is an additional way of constructing a lazy variable which avoids
this problem. The definition:
lazy name {obtain} ?resource {compute}
and the function for lazy lists:
Lazy {obtain} ?resource {compute}
split the computation of the value of the lazy variable into two
parts. The "obtain" part is run with only asynchronous signals
blocked. If it fails (possibly due to an asynchronous exception),
the exception is not recorded in the lazy variable, and the
computation will be restarted when the variable is later evaluated
again. If this part succeeds, the "compute" part is run as for a
plain lazy variable: with all signals blocked, and with an exception
being recorded in the variable forever.
In the "compute" part, or during computation of the value of a plain
lazy variable, you can call a new function CommitLazy with two
arguments: the new "obtain" and "compute". This function throws
a special exception which causes the lazy variable to go back to
obtaining and processing a resource using the new functions. If the
"obtain" part fails, any further restart will use the new functions.
Operations which transform lazy lists to other lazy lists generally
preserve the state of blocking signals. For example while Map waits
for the next element of the input, synchronous signals are not
blocked, and in the case of an exception the computation will resume
when the result is later evaluated again; and while Map evaluates
the function for some element, all signals are blocked and an
exception causes the result to always fail when evaluated again.
* Locking a read-write lock for reading blocks signals too, to avoid
a deadlock when a signal handler would lock it again for writing.
* New types BOOL_ARRAY and FLOAT_ARRAY.
* New functions:
- ReadByteFrom, PeekByteFrom, UnreadByteFrom, WriteByteTo - to be
used with byte streams; function names with Char now work on char
streams only
- Sqr in module Math - square of a number
- RandomBool and RandomBoolFrom in module Random
- QueueSignal in module Threads - put a signal at the beginning of
the signal queue of the current thread (SignalThread puts at end);
makes possible to implement Erlang-style processing of selected
signals while leaving other signals in the queue
- ExitProgramImmediately - with no cleanup, from any thread
- CloseOnExec in module System.Processes - get or set the FD_CLOEXEC
flag of a descriptor
- TouchObject in module Threads - takes one argument and does nothing,
ensures that the object not garbage collected at this point yet
* Virtual mutable variable HandlerOfSystemSignals in module Threads
holds the thread which handles system signals. It is automatically
changed to the main thread when the previous thread terminates.
* Removed function LazyAppend.
* New type REGISTERED_LIST which holds a list of registered items.
Function RegisteredList() return a new list. An item is added to the
beginning of a list by applying the list to the item. The result of
this application is an object which can be used to unregister the
item by applying it to no arguments. Adding an item is thread-safe.
There are two ways to process items:
- TraverseRegistered list nil cons - non-destructively - as long as
there are remaining items, apply cons to the next item and a
nullary function which traverses the rest of the list. otherwise
return nil(); registering items while TraverseRegistered is
running causes them to be processed this round, before remaining
items
- TraverseRegisteredUntilNow list nil cons - like TraverseRegistered,
but registering items while TraverseRegisteredUntilNow is running
doesn't cause them to be processed this round; this is faster
- CutRegistered list absent present - destructively - if there is
some item, remove the first item and apply present to it;
otherwise return absent()
If an item is registered multiple times, it is processed that many
times, in the reverse order of registration. Unregistering an item
while TraverseRegistered or TraverseRegisteredUntilNow is running
causes it to be skipped if it's not already too late.
Some existing registered lists of handlers:
- AtExit - all handlers are run at program exit (but not after the
body of ForkProcess nor before ExecProgram); a handler is a
nullary function applied for side effects
- AtUnhandledException - the first handler is run when an exception
has not been caught and is going to terminate the program (before
AtExit, and including the body of ForkProcess); a handler is a
function with three parameters: the exception, the stack trace,
and a nullary function which runs older handlers; a handler should
return the exit code of the process; if a handler itself fails,
older handlers handle its exception
- AtForkProcess - the first handler is run by ForkProcess and
ForkProcessCloneThreads (but not by ForkProcessKillThreads);
a handler is a function with one parameter: a nullary function
which runs older handlers and does the fork; the parameter
should be applied exactly once and its result should be returned
By default StdOut and StdErr are flushed at exit and fork.
* FinalizeWeakRef waits until the finalizer completes if it's called
during finalization.
* In synchronous mode signals are processed only when the thread is
actually going to block, not just when it calls a function which
might block.
* Threads which had to be preempted are penalized, so next time they
don't hog CPU so much and interactive threads can be more responsive.
As an exception, threads which are blocking signals are not
penalized (perhaps they hold a lock which should be released soon).
* A condition may be created without the predicate, but then a
predicate must be given for Wait.
* Importing under a changed name is changed back to newName:origName
from origName:newName.
* First-class module objects and a mechanism for qualifying imported
names with module names:
When a module is imported as 'use M:Full.Module.Name', then the
name M is bound to an object of type MODULE. It can be used to
access the contents of the module as a structure.
For M being such a module name, M.name is resolved at compile time
and 'ref M.name' exposes the original type of the variable object;
for an ordinary constant M such expression would have type FUNCTION,
even if the constant was bound to the same module value by 'let'.
Some functions for examining modules are provided:
- ModuleName module - the fully qualified name of the module as a
list of symbols
- ModuleContents module - contents of a module; for example if a
module looks like this:
module Some.Module;
reexport Original.Module; // 'Foo' is a constant defined there
dynamic Bar;
reexport Baz:Module.Baz [];
then its contents are presented like this: [
(#Foo, #const, Foo, [#Original #Module #Foo])
(#Bar, #var, ref Bar, [#Some #Module #Bar])
(#Baz, #module, Baz, [#Some #Module #Baz])
]
Modules are compared and hashed by their full names. When the same
module is imported several times, it doesn't necessarily yield the
same module object each time.
* Inside a method definition the name 'super' is bound to a function
which calls the next method, after the method it appears in.
It may be called with different arguments than the current method
was called with. The order of matching methods for the new arguments
determines which method is next.
* Types, generic functions, and modules can be built dynamically. This
is mainly for a future interpreter, details are not described here.
* The preferred forms of 'function' are:
- function [param... {body} ...]
- function ?param... {body}
The old form 'function param... {body} ...' is deprecated.
'handle' and 'receive' also accept the analogous syntax without
brackets when there is only one signal to handle.
* 'function', 'loop' and 'receive' accept 'label:' before the cases
which specifies a different name to be used instead of 'again'.
* Changed heuristics for tuning the old heap size. Important variables:
- KO_HEAP_LIMIT_RATIO, KO_MIN_HEAP_LIMIT (default: 2.0, 4MB) -
the amount of old data which will trigger the next GC depends on
the amount of live data after the previous GC:
limit = live * KO_HEAP_LIMIT_RATIO + KO_MIN_HEAP_LIMIT
- KO_HEAP_SIZE_RATIO, KO_MIN_HEAP_SIZE (default: 1.5, 4MB) -
the size of the newly allocated old heap depends on the amount
of used space before the GC:
size = used * KO_HEAP_SIZE_RATIO + KO_MIN_HEAP_SIZE
* New module Kogut.Stats for time, memory and thread statistics.
When KoTetris is started with -s, it displays current statistics.
* Documentation is licensed under the FDL.
* SigInfo is exported when SIGINFO is supported (BSD).
* Only interfaces intended for public use are installed
(the lists of files are in lib/*/interfaces).
* kogut-mode.el improvements: indentation is better; Emacs is
instructed how to locate errors reported by kokoc.
* Arrays which have much of their elements removed are physically
shrunk during GC.
* Bugs fixed:
- ProcessSyncSignals was not blocking signals in signal handlers
- The compiler failed on local types (thanks to Daniel Ehrenberg
for reporting)
New in Kokogut-0.5.2 (26 January 2005), a release with networking
and with improved threads:
* New type OBJECT_ID which is useful for dictionaries based on object
identity. 'ObjectId obj' returns a hashable value representing the
identity of obj, such that a given object each time yields the same
object id. This is similar to Haskell's stable names.
An object id doesn't keep the original object alive, can't be used
to access it, and is not kept alive by the object either. If an
object id is garbage collected, the new object id of the same object
will not necessarily have the same hash value.
The ObjectId function is primarily used as the key transformation
function of HashDictBy and HashSetBy.
* New types WEAK_HASH_DICT and WEAK_HASH_DICT_BY which do not keep
their keys alive: keys which become garbage collected magically
disappear from the dictionary.
* Threads are no longer hashable. You can use ObjectId for dictionaries
indexed by threads.
* Weak references may also be applied to 1 or 2 arguments to reliably
detect whether the key is dead:
- weakRef() - return the value or Null
- weakRef absent - return the value or 'absent()'
- weakRef absent present - return 'present value' or 'absent()'
* You can temporarily unlock a mutex using the Unlock function.
* New type READ_WRITE_LOCK of locks, created by ReadWriteLock().
Functions LockRead and LockWrite establish a region where multiple
readers or a single writer are allowed at a time. Functions
UnlockRead and UnlockWrite temporarily unlock a lock.
Function LockReadWillWrite locks a lock for reading, but declares
that later it will possibly be upgraded to writing. Function
UnlockReadWillWrite temporarily unlocks it. Only one thread at a
time can have this kind of lock, to avoid deadlocks. It differs from
a lock for writing in that it can be shared with regular readers.
Function ChangeLockToWrite upgrades this kind of lock to writing,
waiting for regular readers to exit the protected region first, and
preventing other threads from entering it. It atomically downgrades
the lock back at the end, without waiting. Function ChangeLockToRead
does the opposite. The state upgraded to writing is the same as the
state resulting from LockWrite. Neither upgrading nor downgrading
allows another writer to intervene.
This implementation does not keep track of which threads obtained
which locks for reading, and thus performing UnlockRead by a thread
which has not locked the lock for reading causes undefined behavior.
Locking a lock for writing by a thread which already has locked it
for reading causes a deadlock instead of an exception.
* New test ReadersWriters which demonstrates the semantics of
ReadWriteLock using curses animation.
* New test Elevator which demonstrates non-trivial use of conditions.
* The issue of blocking signals reworked again. The blocking state
now consists of two parts:
- all - the number of reasons for blocking all signals (a natural
number or Inf)
- async - whether asynchronous signals are blocked (0 or 1)
When all == 0 & async == 0 (the default), signals are handled
immediately. When all == 0 & async == 1, signals are handled only
when the thread is suspended. In other cases all signals are
blocked.
Primitive building blocks of changes of blocking state (scoped over
a subcomputation):
- BlockSignals: all = Inf, async = 1
- UnblockSignals: all = 0, async = 0
- BlockSignalsMore: all = all + 1
- BlockSignalsLess: all = all - 1 (stays at 0 if it was 0)
- BlockAsyncSignals: async = 1
- UnblockSyncSignals: all = 0
Implicit changes of blocking state by other operations:
- handling an exception: BlockSignals
- handling a signal: BlockSignals
- using, LockRead, UnlockRead, LockReadWillWrite, UnlockReadWillWrite:
- in the "acquire" part: BlockAsyncSignals
- in the main part: no change
- in the "release" part: BlockSignals
- Lock, LockWrite, ChangeLockToWrite:
- in the "lock" part: BlockAsyncSignals
- in the main part: BlockSignalsMore
- in the "unlock" part: BlockSignals
- Unlock, Wait, UnlockWrite, ChangeLockToRead:
- in the "unlock" part: BlockAsyncSignals
- in the main part: BlockSignalsLess
- in the "relock" part: BlockSignals
* Deadlock of all threads is detected and reported as a Deadlock
signal sent to the thread which handles system signals. If the
program intentionally waits for system signals and does nothing
else, it should do so only using 'receive' or 'SleepForever'.
* ForkProcesses called with a process body leaves only the current
thread in the child process. All others are killed immediately.
When the body finishes or fails, the child process is terminated
by _Exit(), without unwinding the stack.
* RunProgram has a new named parameter redirect which replaces
RunProgramRedirecting. If the redirect parameter is not Null, it
may be #stdIn, #stdOut, #stdErr, or a tuple of them. It causes
the return value to be a tuple of the pid and other ends of pipes
redirected to specified standard streams. In this case the mode
is ignored, it behaves as if it was #background.
* WaitForThread is used as follows:
- WaitForThread thread
- WaitForThread thread ?exn {failed}
- WaitForThread thread ?exn {failed} ?result {finished}
* TimeLimit is used as follows:
- TimeLimit {body} time {tooLong}
- TimeLimit {body} time {tooLong} ?result {finished}
The OUT_OF_TIME exception has been removed.
* System signals use type SYSTEM_SIGNAL with field 'code', instead of
INT.
* Basic networking support in the Network library, module
Network.Sockets, based on BSD sockets interface:
- Address families and protocol families of type FAMILY:
InetFamily, Inet6Family (optional), and UnixFamily.
- Socket types of type SOCKET_TYPE: AnyType, DgramType,
RawType (optional), SeqPacketType, and StreamType.
- Protocols are represented by strings or numbers. Function
GetProtocolInfo resolves a protocol to a record of type
PROTOCOL_INFO with fields code, name, and aliases.
- Sockets of type SOCKET. It may be the same as RAW_FILE (currently
it is always the same). Function Socket creates an unconnected
socket. It has keyword parameters family (default: DefaultFamily,
which is Inet6Family or InetFamily by default), type (default:
StreamType), and protocol (default: depends on the family and type).
- Function SocketPair creates a pair of sockets connected to each
other. It has the same arguments as Socket.
- Addresses of type ADDRESS with fields family and data. Data is
exposed as a byte array whose format depends on the family and on
the system. Data is also exposed as a set of fields which depend
on the address family:
- InetFamily: port (0..65535), addr (a list of 4 bytes);
some constants for the addr field: InetAddrAny,
InetAddrBroadcast and InetAddrLoopback
- Inet6Family: port (0..65535), flowInfo (0..2**31-1),
addr (a list of 16 bytes), scopeId (0..2**31-1);
some constants for the addr field: Inet6AddrAny,
Inet6AddrLoopback; some predicates on the addr field:
IsInet6AddrUnspecified, IsInet6AddrLoopback,
IsInet6AddrMulticast, IsInet6AddrLinkLocal,
IsInet6AddrSiteLocal, IsInet6AddrV4Mapped,
IsInet6AddrV4Compat, IsInet6AddrMcNodeLocal,
IsInet6AddrMcLinkLocal, IsInet6AddrMcSiteLocal,
IsInet6AddrMcOrgLocal, IsInet6AddrMcGlobal
- UnixFamily: path (string)
There is a constructor Address with parameter family and
named parameters: either data or family-dependent fields. The
UnspecAddress constant can be used with Connect for clearing
the default destination of datagram sockets. Even though data
is a mutable byte array, addresses are immutable; a new array
is created each time the data field is accessed. Addresses are
compared and hashed by value.
- Function GetAddrInfo resolves a host (string) and port (string or
number) to a list of records of type ADDR_INFO with fields family,
type, protocol, address, and canonName. Either the host or the
port may be missing, but not both. Other keyword parameters of
GetAddrInfo are family (default: find out automatically), type
(default: StreamType), protocol (default: depends on the family
and type), and flags: passive, canonName, numericHost, numericServ,
v4Mapped, all, addrConfig (default: v4Mapped and addrConfig are
True, others are False).
- Function GetFirstAddrInfo returns the first element of the list
returned by GetAddrInfo.
- Function GetNameInfo translates an address to a pair of strings:
host and port. It takes keyword parameters after the address:
noFQDN, numericHost, nameReqd, numericServ, numericScope, and
dgram.
- Functions Connect and Bind take a socket and keyword parameters:
either address, or arguments for GetFirstAddrInfo.
- Function Listen takes a socket and a keyword parameter backlog
(default: DefaultBacklog, which is 5 by default).
- Function Accept takes a socket and returns a pair: a socket for
the connection and the peer address.
- Function Shutdown takes a socket and a symbol #read, #write, or
#both.
- Functions GetSocketName and GetPeerName take a socket and return
an address.
- Function SocketOption takes a socket, protocol level (SocketLevel,
IPProtoIP, IPProtoIPv6, IPProtoICMP, IPProtoRAW, IPProtoTCP,
IPProtoUDP), option name (#acceptConn, #broadcast, #debug,
#dontRoute, #error, #keepAlive, #linger, #oobInline, #rcvBuf,
#rcvLoWat, #rcvTimeO, #reuseAddr, #sndBuf, #sndLoWat, #sndTimeO,
#type, #noDelay), and either gets the socket option, or takes the
new value as the last argument and sets the option. The type of
the value depends on the option name.
- Function Receive takes a socket, byte array to fill, maximum size,
and keyword parameters: peek, oob, and waitAll; it returns a
boolean indicating the end of transmission. Function ReceiveFrom
takes the same parameters and returns the sender address or Null
if the address is unavailable.
- Function Send takes a socket, byte array to send, maximum size,
and keyword parameters: eor and oob. Function SendTo additionally
takes the recipient address after the socket.
- Function SocketStreams exposes a socket as a pair of streams:
input stream and output stream of bytes. Closing both streams
closes the socket.
- Functions SocketTextStreams and SocketBinaryStreams expose a
socket as a pair of {Text,Binary}{Reader,Writer}. They ensure that
the writer is flushed before asking for input. They take keyword
parameters for readers and writers.
- Function ClientSocket is a convenience wrapper for Socket and
Connect. Function ServerSocket is a convenience wrapper for
Socket, Bind, and Listen. They take combined keyword parameters
for the functions they use. The family of the address (if the
address is given) or the result of resolving the name (if the host
or port are given) influences the family, type and protocol of the
socket.
- Functions {ClientSocket,Accept}{,Text,Binary}Streams are
convenience wrappers for {ClientSocket,Accept} and
Socket{,Text,Binary}Streams. They take combined keyword
parameters for the functions they use.
* The default encoding may be overridden by the environment variable
KO_DEFAULT_ENCODING.
* Generators should generally be assumed to be safe to be traversed
multiple times.
The Iterator function, which ensures that a generator performs the
work only once, should be treated as a hint for optimization rather
than a device for correctness.
Collect, ReadChars, ReadLines, ReadCharsFrom, ReadLinesFrom and
DirectoryContents return lazy lists instead of generators. Old
versions are available under names prefixed with Gen - they are
faster but should only be used when the resulting generator is known
to be consumed only once.
* Removed function KeywordAllowOther. New function KeywordAndRest
which is like Keyword, except that arguments which dit not match
any keyword are appended to the result instead of being an error.
* Renamed:
- ExtractKeyword -> SplitKeyword
- CollectGarbage -> GarbageCollect
- MaybeCollectGarbage -> MaybeGarbageCollect
* New functions:
- KillWeakRef - like FinalizeWeakRef but without actually running
the finalizer
- SignalsBlocked, AsyncSignalsBlocked - determine the status of
signal blocking (booleans only)
- ProcessSyncSignals() - process signals if synchronous signals are
unblocked
- CancelableTimeLimit - like TimeLimit, but allow the action to
cancel the timeout earlier, which is useful for ensuring a time
limit on entering a protected region (note: this function
establishes American spelling in Kogut names)
* New abstract type SYSTEM_ERROR, a supertype of IO_ERROR and other
similar errors. IO_ERROR is limited to errno codes, and you should
catch SYSTEM_ERROR to include errors from getaddrinfo, Windows
errors etc. (when they are implemented).
* New type C_PTR in module Foreign.C, used for passing raw C pointers
in Kogut code.
* Concurrent initialization of a module by separate threads works.
* New function StackTrace which returns the stack trace, currently in
the form of a list of locations on the stack from top to bottom. Its
argument is the number of top frames to skip (perhaps they belong to
error handling code).
* ForkProcess called with a block prints the stack trace if the block
fails.
* New module Unsafe with fast but unchecked operations on small ints
(Unsafe{LT,GT,LE,GE,Add,Sub,Neg,Abs,Mul,Mul2,Div2,Not,And,Or,Xor};
IsSame can be used for equality), pairs (Unsafe{Left,Right})
and lists (Unsafe{Cons,First,Rest}).
* New pattern syntax 'dynamic name', analogous to 'var name'.
* Exceptions of types NOT_A_FUNCTION, BAD_TYPE and NO_FIELD include
the bad object instead of its type.
* {Byte,Char}{Input,Output}Buffer take keyword parameters instead of
positional parameters. Added parameter flushAll, the level of
flushing performed automatically after WriteTo, default: #none.
Parameter flush renamed to flushLines, default changed to #soft.
Flushing parameters to input buffers are accepted but ignored, to
allow using the same set of options for input and output buffers.
FlushingOther take keyword parameter flush, default: #soft.
These parameters are dynamic variables.
* epoll can be used for multiplexing I/O, available since Linux 2.6.
epoll scales better than poll or select with lots of threads.
Since epoll had a memory leak in Linux versions 2.6.0 to 2.6.7,
Kokogut doesn't use it when ./configure is run on these kernels.
You can override this choice by --with-epoll or --without-epoll.
* Sleep is more accurate when using poll or epoll (near the end of
the delay gettimeofday is called in a loop).
* Garbage collection might be performed when all threads are idle.
* On Linux sysinfo() is used to tune GC parameters: KO_MAX_HEAP_SIZE
is set to half of totalram and KO_MAX_STACK_SIZE is set to a quarter
of totalram.
* In ncurses older than 5.4 patchlevel 20041002 wide character API
was broken, so it's not used even if present.
* Fixed NFC. Unicode specification had a bug in its NFC description:
<http://www.unicode.org/review/pr-29.html>. Our implementation was
affected.
* Bugs fixed:
- another weak reference bug which caused them to be sometimes
finalized when the key is alive
- when you close a file a thread is waiting for, the thread gets
an exception instead of trying to use a closed fd
- PyFormat did not work at all
New in Kokogut-0.5.1 (10 November 2004), a release with Tetris:
* New example: Tetris game.
* Dates are aware of time zones and daylight saving time. The format
of the timeZone field in DATE and the dynamic TimeZone variable is
(tz, dst), where tz is the offset from GMT in seconds (positive =
East) and dst is a flag which tells whether daylight saving time is
in effect. The tz value includes the change caused by dst, i.e. dst
doesn't affect interpretation of the time.
The TimeZone variable is used for the current date, for conversion
from TIME to DATE, and when making a date from fields with timeZone
field missing or Null. If the TimeZone variable is Null too, which
is the default, then the system-dependent default time zone for
the given time is used. If the default is used to interpret a date
composed of fields, rather than to set fields from a known time,
the result is inherently ambiguous near the autumn clock adjustment.
TimeNow() has been renamed to Time(), and DateNow() to Date(). The
same functions with more arguments perform conversions as before.
dayOfYear can no longer be provided in input. The equivalent effect
can be obtained by setting the corresponding day of January.
* The predicate associated with a condition variable is written
explicitly, as the second argument of the Condition constructor
or as the second argument of Wait. The Wait function begins by
evaluating the predicate, and waits until it becomes true.
* Reworked the issue of blocking signals. There are three states of
a thread:
- all signals are unblocked (the default)
- all signals are blocked
- synchronous mode: asynchronous signals are blocked, but they
will be temporarily unblocked during an operation which suspends
execution of the thread (other than obtaining a mutex or waiting
for a C callback to return in the right order), i.e. waiting for
a condition, waiting for a thread, waiting for a lazy variable,
sleeping for some time, sleeping forever, waiting for I/O.
Functions BlockSignals and UnblockSignals work as before, except
that nesting levels are no longer counted: they unconditionally
change the state during execution of their body. New function
BlockAsyncSignals enters synchronous mode if signals were unblocked,
and UnblockSyncSignals enters synchronous mode if they were blocked.
Locking a mutex, obtaining a resource, and releasing a resource
implicitly blocks asynchronous signals. Similarly, handling an
exception and handling a signal blocks all signals.
* Unknown signals are rethrown as exceptions directly instead of being
wrapped in the UnhandledSignal exception.
* A syntax for establising one-time signal handlers:
- receive [pat {expr} ...]
- receive [pat {expr} ...] time {expr}
This expression waits for an asynchronous signal to come, or process
the next signal immediately if it has been queued while signals were
blocked. If the signal matches one of the patterns, computation
continues with the corresponding expression. A timeout with a
timeout handler can be specified.
The name 'again' is implicitly defined in these expressions
as a nullary function which waits for signals again. A case
'sig {Signal sig; again()}' is implicitly added at the end in order
to process unmatched signals using their default handler. This
behavior differs from 'receive' in Erlang which leaves unmatched
signals in the queue.
Signal blocking status does not affect the behavior of 'receive',
but usually it only makes sense when signals are blocked.
* The default signal handler (initial value of the Signal dynamic
variable) is a generic function DefaultSignalHandler.
* Stack overflow and heap overflow can be handled:
When the stack of a thread grows too large (settable by the
KO_MAX_STACK_SIZE environment variable, default = 128M), the thread
receives StackOverflow signal.
When the old heap grows too large (settable by KO_MAX_HEAP_SIZE as
before, but the default is now 512M), the thread designated for
handling system signals receives OutOfMemory signal.
If the program does not reduce memory usage below limits despite
signals, the signals will continue to be generated from time to
time. But when the runtime really needs more memory and malloc()
fails, the program will die with a fatal error. It only has a chance
to handle these signals if limits are triggered before the memory is
actually exhausted.
* HandleSystemSignals is exported by the Threads module instead of
System.Signals from Unix library, because now it applies not only
to Unix signals.
* Recursive locking of a mutex and recursive computation of a lazy
variable are detected, and fail instead of deadlocking.
* New test: Monitor (a somewhat more convenient but slower alternative
to a mutex with conditions).
* Additional private variable definitions, typically used in
'ifDefined', can be provided on kokoc command line (-Dname
or -Dname=value) and in *.kop files ('switch = name' or
'switch = name=value').
* Functions ByteInputFilter, CharInputFilter, InputDecoder,
ByteOutputFilter, CharOutputFilter, OutputEncoder may be rarely
used explicitly. Instead, convenience wrappers have been added:
- CopyByteInput, CopyCharInput, CopyByteOutput, CopyCharOutput
(instead of ByteCopyingFilter and CharCopyingFilter)
- CompressGZip, DecompressGZip, CompressBZip2, DecompressBZip2
(in addition to GZipCompressor, GZipDecompressor, BZip2Compressor
and BZip2Decompressor, which are still useful with FilterArray).
* WaitForProcess changes:
- keyword parameter nonBlock has been renamed to block with the
opposite meaning (default is True)
- returns #wait (instead of Null) when the given process has not
finished yet (possible only when block is False), and Null
(instead of failing) when there are no processes to wait for.
* Curses module provides ResizeTerm function when the underlying API
is available, to be used in SigWinCh handler before redrawing the
screen.
* Renamed:
- c_inline -> c_define
- Timeout -> TimeAfter
- JoinThread -> WaitForThread (in Threads)
- {,W}Clear -> {,W}ClearScr (in Curses, to avoid name
conflict with Prelude)
- Box -> WBox (in Curses)
- Color{Black,Blue,...} -> {Black,Blue,...} (in Curses)
- Sleep is exported from Prelude rather than Threads
* New functions:
- TimeLimit (in Signals)
- Box (in Curses)
- {,Mv}{,W}{H,V}Line (in Curses)
- RestoreCurses (in Curses) - to be called after SigTStp handling
- UseDefaultColors, AssumeDefaultColors, DefaultColor (in Curses) -
mixing default colors with specified colors, if the underlying
curses library supports this
* Removed WaitForSignal (use receive), TimedWait (use TimeLimit with
Wait) and TimedJoinThread (use TimeLimit with WaitForThread).
* New module System.Errors (in Unix library) with IOError constants.
* Bugs fixed:
- scheduler could hang, or not wake up a thread when it should
- GZip library did not link in Kokogut-0.5.0
- AddChStr in Curses could crash
- WeakRef could be finalized when the key is still alive
- A thread started with ThreadBlockSignals could process signals
if preempted just after it began executing
* Improved portability with {Free,Net,Open}BSD, MacOS X, Solaris,
and old versions of curses and gmp.
New in Kokogut-0.5.0 (24 October 2004), a release with threads:
* Threads, exported by module Threads. Overview of the interface:
- Starting threads: Thread {body}, ThreadBlockSignals {body}
- Current thread ID: CurrentThread
- Mutexes: Mutex(), Lock mutex {body}
- Condition variables: Condition mutex, Wait condition,
TimedWait condition time, Notify condition, Notify1 condition
- Doing nothing for some time: Sleep time, Yield()
- Waiting for a thread to finish: JoinThread thread,
TimedJoinThread thread time
- Receiving asynchronous signals: BlockSignals {body},
UnblockSignals {body}, WaitForSignal(), SleepForever()
- Sending signals: SignalThread thread signal, CancelThread thread,
Signal signal; cancelling a thread throws ThreadExit exception in
it by default
- A box is empty or full, the thread will wait for the appropriate
state (Haskell's MVar): Box(), Box value, Put box value, Take box
- A queue with elements, the thread trying to take a value will wait
until it is available: Queue(), PutLast queue elem, TakeFirst queue
* Unix signals are translated to Kogut signals. They are represented
by integers. Named constants for signals are in the System.Signals
module from the Unix library. The function HandleSystemSignals()
designates the current thread for receiving Unix signals; if it
terminates, the main thread starts receiving them again.
* New syntax for establishing signal handlers:
- handle [pat {expr} ...] {body}
- handle [pat {expr} ...]
The old handler is available inside the new handler under the name
'super'. Signals which match no patterns are forwarded to the old
handler automatically.
If there is no handler for a signal, execution fails with the
UnhandledSignal exception, except when it's a ThreadCancel signal
as sent by CancelThread function (which is rethrown as ThreadCancel
exception), or a Unix signal (which causes the default Unix reaction
for that signal).
If a thread other than the main thread doesn't catch an exception,
and nobody joins the thread, the exception is silently dropped. If
somebody joins it, he will receive the same exception.
The program finishes when the main thread finishes. All other
threads are instantly killed in this case.
* New syntax for obtaining resources:
- using {obtain} ?x {release} ?x {body}
- using {obtain} ?x {body} // release defaults to Close
- using {changeState} {restoreState} {body}
This supersedes functions Using and Finally, which are usually unsafe
in the presence of asynchronous exceptions.
* Signals are automatically blocked during exception handling, signal
handling, obtaining and releasing resources, and using a mutex. They
are unblocked when the mutex is implicitly released for waiting for
a condition.
Nested blocking of signals requires the appropriate number of nested
unblocking. Unblocking signals when they are already unblocked is an
error.
* If the value of a lazy variable is being computed, other threads
trying to get the value will wait until it is available.
* Added dynamically scoped variables of type DYNAMIC, similar to
special variables in Lisp. They are defined by
'dynamic variable = value' or 'dynamic variable'; in the second form
Null is assumed as the initial value. They are read and written like
normal variables, and localized by 'local variable value {body}'.
A localized binding shadows the previous binding of the same
variable in the dynamic scope of the body. Dynamic bindings are
inherited by newly created threads.
Various global variables which set default parameters for some
operations, like StdIn/StdOut/StdErr and DefaultEncoding, have been
changed to dynamic variables. Language used for special case mapping
rules is passed in dynamic variable Language instead of explicit
parameter of case mapping functions. The name Signal actually refers
to a dynamic variable which holds a function.
* Type TIME represents a point of time. The current time is returned
by TimeNow(). You can add/subtract numbers of seconds to/from times
(of any real type), compare times, and subtract two times obtaining
the number of seconds between them as a FLOAT.
A time is internally represented by an integer number of ticks from
the epoch (1970-01-01). You can construct a time from the number
of ticks with the Time function, and get the number of ticks with
time.ticks. The constant TicksPerSecond is exported. In Kokogut
ticks are nanoseconds, but the resolution of TimeNow() is at most
microseconds (gettimeofday).
* A timeout (e.g. for Sleep) is specified as the duration in seconds
or as the wakeup time of type TIME. Unix FileInfo returns file times
as type TIME.
* Module Calendar provides operations on dates expressed in Grerorian
calendar. Type DATE represents a time with a time zone, split into
fields year, month, day, dayOfYear, dayOfWeek (0 = Sunday), hour,
minute, second, tick, and timeZone (difference in minutes). Dates
can be compared; representations of the same time which differ only
in the time zone compare as equal.
You can construct a date with the Date function with keyword
parameters corresponding to date fields. The Date function also
converts a time to a date, using the time zone stored in the dynamic
variable TimeZone. Conversely, the Time function converts a date to
a time. DateNow() returns the current date. The Change function,
generally used for records, supports changing fields in dates.
Fields of a date may be provided out of range. In the resulting
date they will be recalculated appropriately, causing adjustments
of other fields. You may specify either a month with a day, or
dayOfYear, and the other will be computed. You may not specify
dayOfWeek as input.
* KoScheme computation and input can be interrupted by ^C.
* New function Collect ?give {body}, which generates elements to which
give is applied inside body. Implementation of this function needs
control inversion, which is done here with threads.
* New pattern syntax 'is TYPE', equivalent to 'when Is TYPE'.
* Added weak references of type WEAK_REF, based on the design in
Glasgow Haskell. They are created by 'WeakRef key {finalizer}' or
'WeakRef key value {finalizer}'; in the first form the value is
assumed to be the same as the key. You can get the value back by
applying the weak reference to no arguments.
A weak reference by itself doesn't keep its key, value nor finalizer
alive. Instead it causes the key to keep the value and finalizer
alive; this relationship exists no matter whether the weak reference
is reachable.
When a key remains referenced only by weak references, their values
and finalizers, it is scheduled for finalization. Finalization
happens in a thread started by the garbage collector. The value in
the weak reference is reset to Null, the finalizer is detached from
it, and is applied to no arguments for side effects.
You can run the finalizer earlier manually by using FinalizeWeakRef
function. It closes the relationship between the involved objects
before the key becomes unreachable.
A finalizer may resurrect the key by storing it in some accessible
data structure. The finalizer will not be run again in this case.
You can use weak references for just attaching finalizers to objects:
make a weak reference and forget it. It's a bad idea to do that for
statically allocated objects or small integers, as they will never
be freed.
Finalizers are not necessarily run at program exit.
* Conditional compilation: the construct 'ifDefined cond {then} ...'
can be used as an expression, pattern, or definition. Available
forms of conditions:
- name - true when the name was defined above or outside
- module name - true when the module can be used
- _ - always true (useful in the last case)
- cond1 & cond2, cond1 | cond2, ~cond - combinations of conditions.
If no condition is true, this construct expands to Null in
expression context, a pattern which never matches in pattern
context, and the empty definition in definition context.
* Dynamic linking is supported on Linux/x86. The -fPIC flag is not
used because it makes Kogut programs run twice slower, at least
on x86; only some architectures permit building shared libraries
without -fPIC. Unfortunately startup of a program using shared
libraries built without -fPIC is slower, because it has to resolve
lots of references.
* Option --encoding on kokoc command line or encoding in *.kop
specifies the character encoding of the source.
* Non-ASCII characters may be used in names.
* New functions:
- MapMinimum, MapMaximum, MapSum, MapProduct - like composition of
Map with Minumum etc., but defined more efficiently using Fold
- Count - the number of elements of a collection satisfying
a predicate
* Renamed:
- VARIABLE -> VAR
- Persistent -> Iterator
- SendSignal -> SignalProcess (in Unix.Signals)
* Importing under a changed name is written origName:newName instead
of newName:origName.
* Fixed printing of stack traces which was broken almost forever.
A function was shown in a trace only during its suspension for the
first function call inside it.
* Record constructor applications are inlined, constant records are
allocated statically. Separate invocations of record constructors
don't necessarily produce distinct objects (this was always intended
as allowed behavior: records are pure structured value types).
* Major internal changes in the frontend of the compiler (a new
compilation phase has been added in the middle). Their effects -
other than improved maintainability of the compiler - are small;
sometimes slightly more efficient code is generated. Also other
optimizations in other parts of the compiler.
* Arithmetic on small ints is faster (avoids a function call).
* Named functions have 'again' defined inside them too, like functions
associated with 'loop', 'function' and specializations, even though
you could also use their own names. This makes possible to
consistently use the 'again' name for looping, including plain
recursion.
* kokoc-0.4.1 is now required for bootstrapping.
New in Kokogut-0.4.2 (27 August 2004), a release with Perl bridge and
complex numbers:
* Perl bridge (module Foreign.Perl in library Perl).
* Complex numbers (in module Math). Supported by KoScheme too.
* Emacs mode for Kogut: kogut-mode.el. Provides syntax highlighting and
automatic indentation.
* Operator ** renamed to Power function, to free the core language from the
dependency on complex numbers.
* New functions:
- Unfold - generate elements produced by a Next-like function
- MapPairs, GenMapPairs - process each pair of consecutive elements
(overlapped)
- CharEqIgnoreCase, StringEqIgnoreCase (in Parsec)
- Cons (in Parsec)
- IfNull - convenience wrapper for if and IsNull
- EncodingName - get the encoding name as a string; system encodings
are represented by strings themselves, but other encodings are
other objects
* Renamed functions:
- ReverseMap -> MapReverse (it applies the function in order
according to the input, not output, so it's map and then reverse)
* Curses binding uses the wide character API when it's available,
overridable by ./configure --with-curses-chars=narrow|wide. The Curses
module has been renamed to TextUI.Curses. Both variants yield the same
Kogut interface. Names on the Kogut side correspond to the narrow
character API, except one case: the interface of chtype values has been
changed to mimic cchar_t. The type is called CCHAR in Kogut, and it
conceptually includes an ATTR value instead of individual attributes.
Its constructor, CChar, takes positional parameters instead of named
parameters as before.
Wide character support in ncurses-5.4 is currently buggy: add_wch ignores
attributes and color of the character to be displayed, and get_wch
doesn't recode keys from the locale encoding if it's different from
UTF-8.
* Coding errors are handled differently. Instead of a separate argument of
functions which take an encoding, which used to specify how errors should
be handled, converters by default fail on error. There is a wrapper for
encodings, called ReplaceCodingErrors, which changes this behavior to
substitute "?" on encoding and "\xFFFD;" on decoding.
* OpenRawFile, CreateRawFile, OpenTextFile, CreateTextFile, and
CreateDirectory take 'mode' keyword parameter. Functions for creating
file modes are exported by System.FileStatus module from Unix library as
before. This module exports two additional variables: DefaultFileMode and
DefaultDirectoryMode.
* New abstract supertype OUT_OF_RESOURCE of NOT_SUPPORTED, OUT_OF_MEMORY,
and ARITHMETIC_OVERFLOW.
* Kokogut should work on MacOS X, thanks to Mike Edgar and Daniel
Ehrenberg.
New in Kokogut-0.4.1 (31 July 2004), a release with improved sequences
and random numbers:
* Renamed Has to IsIn with swapped parameters.
* Lazy lists are now "even", not "odd" -
<http://homepages.inf.ed.ac.uk/wadler/papers/lazyinstrict/lazyinstrict.txt>
That is, a lazy list does not known whether it's empty until it is
forced. And when it is forced, both its first and rest are evaluated.
This means that the head of a lazy list is lazy. There is a single
lazy list constructor called Lazy, which takes a function which
evaluates either to a pair of first & rest, or Null. A lazy list is
forced by taking its field called 'value'. There is no LazyCons, nor
LAZY_CONS & LAZY_NIL subtypes. LazyAppend is still supported but
perhaps it should be changed somehow.
* Changed the interface of Next function, which was possible since
lazy lists are even. It has one argument, and returns either a pair
of first & rest, or Null.
* Removed LookAheadWhich function from Parsec because a composition of
LookAhead and Which works without unwanted extra evaluation, since
lazy lists are now even.
* New function ViewPart and type VIEW_PART, which makes a virtual copy
of a part of a sequence. It's also used for iteration over indexed
sequences instead of a lazy list.
* Removed Iterator, IndexedIterator and LINKED_SEQUENCE. Renamed
INDEXED_SEQUENCE to FLAT_SEQUENCE. The primary ways of consuming
sequences are Traverse and Next. Collections except flat sequences
must implement Traverse. They may also implement Next if they offer
a more efficient implementation than conversion to a lazy list.
* New functions:
- FindPart - find a subsequence, return its index or Null
- SplitSep, SplitEnd, SplitSeps - split a sequence on elements
satisfying a predicate
- SepBy, EndBy - insert a separator between every pair of elements
or after every element - a generator
- Persistent - ensure that elements of a sequence can be evaluated
multiple times; it's usually the identity but it turns a generator
into a lazy list
- CutPart - functional equivalent of DoCutPart, i.e. the pair of
Part and RemovePart
- NextMany - iteration over many collections in parallel
- ReverseOrder - for sorting in descending order
- IsHSpace - horizontal whitespace
- ProgramOutputLines - like ProgramOutput, but split by lines -
a generator
* New functions in Parsec:
- ManyThen, ManyThen_, ManyBefore - parsing sequences until an end
is matched (manyTill in original Parsec is our ManyBefore)
- Somewhere, ReplaceAll, ReplaceFirst, ReplaceAtBegin, ReplaceAtEnd
- wrappers for common tasks
- Matches, Extract - convenience wrappers for Parse
- Except - negative lookahead
- OrReturn, OrCompute - more efficient than 'Or% Return x'
- AHSpace, HSpaces, HSpaces1 - horizontal whitespace
- NotSpace - Negation of ASpace
* Renamed functions:
- IterateWithLast -> IterateIncl
- HasPrefix -> BeginsWith
* Renamed functions in Parsec:
- Recurse -> CallParser
- FollowedBy -> Before
- NotFollowedBy -> NotBefore
- SepBy{,1} -> ManySep{,1}
- SepEndBy{,1} -> ManyEnd{,1}
- EndOfInput -> End
* Removed functions:
- JoinString (use SepBy and String)
- ReturnNil, ReturnNull, EndBy, EndBy1 (in Parsec)
* Modules for random numbers:
- Random.Common - functions RandomFrom and RandomFloatFrom
- Random.MT - implementation of the Mersenne Twister algorithm
<http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html>,
type RANDOM_STATE with a constructor RandomState
- Random - reexports the above modules, maintains a default random
state (seeded with time and process ID) in global variable
DefaultRandomState, provides functions Random and RandomFloat
which use the default state.
* Allocate, Fill and FillNew with a negative size are treated as empty.
* The second element of Find and FindBack is optional, defaulting to 0
and size of the sequence respectively.
* Functions ExecProgram, RunProgram, RunProgramRedirecting, ProgramOutput
and ProgramOutputLines (in System.Processes) accept a command as a
single string as an alternative to a program name with a list of
arguments. A command is equivalent to "/bin/sh" ["-c" command].
New in Kokogut-0.4.0 (21 July 2004), a floating point release with
Scheme:
* An example Kogut program: KoScheme, a Scheme interpreter.
Does not implement macros and complex numbers yet, but otherwise
should conform to R5RS.
* Type FLOAT, float literals, and arithmetic on floats is supported.
* Swapped 2nd and 3rd argument of Iterate function, it's now
'Iterate start stop next' - because next is usually the most complex
argument, and because it's consistent with Range.
* Renamed functions:
- Gcd -> GCD
- IsAlpha -> IsLetter
- IsAlphaNum -> IsLetterNum
* New types:
- EMPTY_INPUT (EmptyInput) - /dev/null
- APPEND_INPUT (ByteAppendInput, CharAppendInput) - cat
- COPYING_FILTER (ByteCopyingFilter, CharCopyingFilter) - tee
* New functions:
- iteration: 'Until start stop next' (iterates next on start until
it satisfies stop, and returns the final value)
- variant of Iterate which includes the last value: IterateWithLast
- lazy append for lazy lists: LazyAppend
- merge adjacent equivalent elements (Unix uniq): GenUnique, GenUniqueBy,
Unique, UniqueBy
- convert to list and sort: ListSort, ListSortBy
- Unicode normalization: NFC, NFD, NFKC, NFKD
- Unicode combining class: CombiningClass
- simple single-character case mapping: UpperCaseChar, LowerCaseChar,
TitleCaseChar
- convert to FLOAT: Float (not implemented for strings yet)
- round to a whole number or to a multiple of another number:
Floor, Ceiling, Trunc, Round
- find a simple rational which approximates a given number: Rationalize
- bit shifts (positive shift: left, negative: right): BitShift
- check the kind of a FLOAT number: IsFinite, IsNegZero
- conversion between a FLOAT number and an INT pair (base, exponent):
DecodeFloat, ScaleFloat
- check whether a sequence is a prefix of another: HasPrefix
* New modules:
- Math - Pi, E, Sqrt, Exp, Log, Sin, Cos, Tan, ASin, ACos, ATan
- Parsing.Parsec - a monadic parsing library, based on Haskell's Parsec
by Daan Leijen <http://www.cs.uu.nl/~daan/parsec.html>
* Shortcut syntax 'loop {body}' generalized to 'loop init...
?params... {body}' (equivalent to 'loop init... [params... {body}]',
similar to named let in Scheme).
* Show for INT supports new keyword arguments in addition to base:b
and case:(#upper|#lower):
- sign:(plus, minus) - how to show the sign; default: ("", "-")
- showBase:s - how to show the base; default: ""
- digits:n - minimal number of digits; default: 1
The implementation of Show for FLOAT is temporary, will be improved.
* New tests: Parsec, ParseLib, AlgolQueue.
New in Kokogut-0.3.0 (27 June 2004), a cleaned up release with
improved Unicode support:
* Kokogut-0.2.3 or newer is required to compile the compiler.
* Removed deprecated features:
- 'case' patterns (use 'match' or 'where')
- 'is' function (use 'Is')
- 'Conditionally' function (use 'optional' syntax)
* Renamed collection functions to use the Do prefix for mutable variants
instead of different verbs:
- Insert{,First,Last,Part} -> DoAdd{...}
- Delete{,First,Last,Part,Front,Back} -> DoRemove{...}
- Cut{,First,Last,Part,Front,Back} -> DoCut{...}
- Take{Front,Back} -> Cut{Front,Back}
- InsertAll -> DoUnion
- DeleteAll -> DoDifference
- CutWhole -> DoCutWhole
* New functions:
- string padding: Right, Left, Center
- sign of a number: Signum
- generate iterated applications of a function until the result
satisfies a predicate: Iterate
- generate values of a dictionary: Values
- character properties: CharCategory, IsAlpha, IsAlphaNum, IsControl,
IsDigit, IsGraph, IsLower, IsMark, IsPrint, IsPunct, IsSpace,
IsSymbol, IsUpper
- text boundaries: IsGraphemeClusterBoundary, IsWordBoundary
- case mapping: UpperCase, LowerCase, TitleCase, IgnoreCase
- digit values: DigitToInt, IntToDigit
* Renamed Iterate to Traverse.
* 'Range n' is equivalent to 'Range 0 n'.
* New functions: ',' and '\\', which generalize the corresponding
builtin syntax to any number of arguments (greater than zero in
the case of '\\').
* HashDict and HashSet are reimplemented, they are faster now.
* New types: HASH_DICT_BY and HASH_SET_BY, which transform keys by a
function for hashing and comparison with other keys.
* New kind of C snippet, c_case:
c_case [output] [input] [aux] "
C code which must goto one of the labels defined below
" [
label1:{branch1}
label2:{branch2}
]
* '=' can be used in patterns to visually separate the last argument
of a macro application, like in expressions.
* The generated code no longer needs the gcc extension of a non-empty
initialization of a flexible array member of a static object.
The code should now be easy to port to compilers other than GCC.
* The mangler supports Intel C Compiler in addition to GCC.
* A C compiler produces much less warnings even if they are enabled.
Some hard to avoid warnings have remained though.
* Maximum memory size defaults to 1024GB on 64-bit architectures.
New in Kokogut-0.2.3 (14 June 2004), a yet more portable release
with keyword parameters:
* Portability improved again, thanks to SourceForge's compile farm
and Arkadiusz Miskiewicz. Supported are yet earlier versions of gcc
(down to 2.95.4), gmp (down to 2.0), Perl (down to 5.005_03), and
bzip2 (down to 0.9.5). Actually it might work with even earlier
versions, I haven't had an opportunity to test.
* Fixed code which caused warnings on non-x86 architectures. The
mangler now supports x86_64 (amd64) in addition to x86. Various
fixes for FreeBSD have been applied. An embarrassing bug in Latin1
conversion has been fixed. Kokogut has been successfully built on
other x86-linux boxes, on alpha-linux, x86_64-linux, and
x86-freebsd.
* Parameters 'interface-dir', 'include-dir' and 'library-dir' in *.kop
and in kokoc invocation renamed to 'ifaces', 'includes' and 'libs'.
* Added ./configure options
--with-(gmp|iconv|gzip|bzip2|curses|python)-(includes|libs)=DIR
* Prelude no longer exports many names which are not an official part
of Kogut but implementation details of Kokogut. Foreign.C module
exports some of these names, those useful for interfacing with C.
* 'case' pattern renamed to 'match', to distinguish it visually from
'case' expression. 'case' is temporarily retained for compatibility
with compiler sources.
* A pattern 'where fun args... pat' is equivalent to
'x & match (fun x args...) pat', where x is a fresh name.
This is analogous to 'when fun args...' being equivalent to
'x & if (fun x args...)'.
* A Keyword function designed to be used in a pattern:
'(where Keyword param1:default1 param2:default2 [pat1 pat2])...'
which parses keyword arguments and binds patterns to their values,
or to the default values if arguments with appropriate names are not
given. If multiple arguments with the same name are given, the last
one wins.
* A KeywordAllowOther function which is similar to Keyword but does
not fail if an unknown keyword or a non-keyword argument is found.
* An ExtractKeyword function with two arguments, an argument list and
a list of symbols, which partitions the argument list into two parts:
arguments named with the given symbols, and other arguments.
* Function 'is' renamed to 'Is'. Consistency is more important than
the fact that 'when Is FOO' uses a funny combination of letter case.
The name 'is' is temporarily retained for compatibility with compiler
sources.
New in Kokogut-0.2.2 (8 June 2004), a portability fix release:
* Fixed a nasty bug in the mangler which manifested when kokogut was
compiled with gcc-3.3.2.
* Improved several portability issues: for earlier versions of gcc
(flexible array members, local definitions after statements, broken
stdbool.h included by other headers), GMP (mpz_ui_sub), zlib (Z_RLE),
and Python (support versions 2.2 and 2.3, disable building the Python
library on earlier versions).
* Daniel Ehrenberg has written the Kogut FAQ. Thanks!
* kogut.html includes a picture of a rooster that I've made.
This might become the logo of the language :-)
* TODO translated from Polish to English.
* Added construct 'use Module except:[name list]' and similarly with
reexport.
* In the System.FileStatus module added interface to inspecting and making
FileMode values (mode_t), and reading the mode and {a,m,c}time fields
of FileStatus (struct stat). Renamed fields of FileStatus to lowercase.
* In the System.Directories module added SymLink and ReadLink functions.
New in Kokogut-0.2.1 (4 June 2004), a GC tuning release:
* Environment variables can be used to tune the memory manager:
- KO_MIN_STACK_SIZE - Initial stack size. Will grow as needed.
Default: 64k.
- KO_YOUNG_HEAP_SIZE - Size of the young heap. A larger size reduces
the cost of garbage collection slightly, unless it causes things to
no longer fit in processor cache, where the effect starts to be the
opposite. Default: 64k.
- KO_HEAP_RATIO, KO_HEAP_INCREMENT - The size of the old heap is
approximately amount_of_live_data * KO_HEAP_RATIO + KO_HEAP_INCREMENT.
Larger values reduce the cost of garbage collection but use more
memory. The heap must fit twice in memory during a major garbage
collection. Default: ratio = 1.5, increment = 4M.
- KO_MIN_HEAP_SIZE, KO_MAX_HEAP_SIZE - Bounds of the old heap size.
If the amount of live data is more than the maximum, the program
is aborted. Default: min = 1M, max = 1G.
- KO_MARKED_SIZE, KO_MARKED_RESERVE, KO_CHANGED_OBJECTS_SIZE -
Initial sizes of various less important pools. Default:
marked_size = 64k, marked_reserve = 1k, changed_size = 1k.
- KO_SHOW_STATS - If set to 1, a statistics about time, memory and
garbage collection will be printed to stderr after the program
finishes. It also causes one extra major garbage collection, not
counted in the statistics (to make other figures more accurate).
Maximum memory used is sampled at major GCs.
Memory sizes can be specified as a decimal number of bytes, with
optional suffix k/M/G (case-insensitive, multipliers are 1024**N)
and a possible decimal point. The heap ratio should be a real number
from range 1..10.
* The compiler proper uses less memory and is faster (about 1/3 faster,
not counting the slowest stage: GCC).
* Added 'optional' macro: 'optional cond {then}' is equivalent to
'(if cond {[then]} else {[]})...'. Multiple conditions are allowed.
* Added options -vs, -va, -vq, -vc, -vall (--verbose-source,
--verbose-abstract, --verbose-sequential, --verbose-ccode,
--verbose-all) which dump particular intermediate results
of compiler phases to standard output.
New in Kokogut-0.2.0 (29 May 2004), a priority tweaking release:
* Added doc/NEWS file.
* You can regenerate complete contents of the boot subdirectory from
scratch using 'make install-boot'.
* '~' operator has higher priority, between '->' and '%'.
* '~foo _ 3' is interpreted as '?x {~foo x 3}' rather than '~?x {foo x 3}',
which would always fail anyway.
* 'label:' and '$' have the same priority.
'.field', '@key' and '...' also have the same priority.
This cuts down the number of priority levels, and it causes some
errors to be detected at expansion time instead of parsing time.
* Removed Not, All, Any. They were not used in practice, and now we have
more convenient ways for negating functions.
New in Kokogut-0.1.2 (25 May 2004), a release which can bootstrap from
the previous one:
* Package format changed from tar.gz to tar.bz2.
* You can also bootstrap from a previously installed version if it's
recent enough. The release is split into two packages:
- kokogut-<version>.tar.bz2 - only real sources, requires having
a previously installed version to build.
- kokogut-<version>-boot.tar.bz2 - includes also the boot subdirectory
which contains C files to be usef for bootstrap.
* Added script ./make-package to build tarballs automatically.
* Project registered at SourceForge, awaiting approval.
New in Kokogut-0.1.1 (25 May 2004), a portable bootstrapping release:
* Reorganized bootstrapping. The version used for bootstrap consists
of generated C files rather than Linux binaries.
* 'make install' is implemented.
* You can override various things ./configure tries to detect, e.g.
which libraries to build and how to determine the default character
encoding.
New in Kokogut-0.1 (21 May 2004), a release for langsmiths:
* First somewhat public release, announced only on langsmiths for now.