---
project
data
version
0.0.0
links
["foundation.tofg.js"]
unit
struct
info
`data` is a project comprising common and/or important data structures.
---
---
---
// ////////////////////////////////////////////////////////////////////////////////////////////////
---
unit
doc
header
**Data Structures**
---
---
unit
struct
name
Data
---
// ////////////////////////////////////////////////////////////////////////////////////////////////
---
---
---
unit
doc
name
Data
header
**Typed Versions of Native ECMAScript Data Structures**
---
---
---
// Data.Bit
---
unit
doc
name
Data
header
Bit value operations on (small/safe) integers
---
unit
struct
name
Data.Bit
info
For the [bitwise operations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators).
---
unit
function
name
Data.Bit.and
type
Type.lambda ([INT, INT, INT])
value
function (i1) {
return function (i2) {
return (i1 & i2);
}
}
info
....
---
unit
function
name
Data.Bit.or
type
Type.lambda ([INT, INT, INT])
value
function (i1) {
return function (i2) {
return (i1 | i2);
}
}
info
....
---
unit
function
name
Data.Bit.xor
type
Type.lambda ([INT, INT, INT])
value
function (i1) {
return function (i2) {
return (i1 ^ i2);
}
}
info
`Data.Bit.xor(x)(y)` is the wrapper function for the native ECMAScript XOR operation `x ^ y`.
[XOR](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR)
stands for _Exclusive OR__, i.e. `x` or `y`, but not both.
---
unit
function
name
Data.Bit.left
type
Type.lambda ([INT, INT, INT])
value
function (i1) {
return function (i2) {
return (i1 << i2);
}
}
info
[Left shift](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Left_shift)
---
unit
function
name
Data.Bit.right
type
Type.lambda ([INT, INT, INT])
value
function (i1) {
return function (i2) {
return (i1 >> i2);
}
}
info
[Sign-propagating right shift](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Right_shift)
---
unit
function
name
Data.Bit.right0
type
Type.lambda ([INT, INT, INT])
value
function (i1) {
return function (i2) {
return (i1 >>> i2);
}
}
info
[Zero-fill right shift](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Unsigned_right_shift)
---
---
// end Data.Bit
---
---
unit
doc
name
Data
header
Localizations
---
unit
struct
name
Data.Locale
---
unit
function
name
Data.Locale.comparison
type
Type.lambda ([STRING, STRING, STRING, Type.finite ([-1,0,1])])
value
function () {
return "..................Data.Locale.comparison....................................";
}
info
.....
See [`String::localeCompare`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare#Checking_for_support_for_locales_and_options_arguments)
---
unit
function
name
Data.Locale.toUpperCase
type
Type.lambda ([STRING, STRING])
value
function (s) {
return s.toLocaleUpperCase();
}
info
`Data.Locale.toUpperCase(s)` returns the `s`, converted to upper case, according to any locale-specific case mappings.
In most cases, the result is the same as `Str.toUpperCase(s)`.
See the native [`String::toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase).
---
unit
function
name
Data.Locale.toLowerCase
type
Type.lambda ([STRING, STRING])
value
function (s) {
return s.toLocaleLowerCase();
}
info
`Data.Locale.toLowerCase(s)` returns the `s`, converted to lower case, according to any locale-specific case mappings.
In most cases, the result is the same as `Str.toLowerCase(s)`.
See the native [`String::toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase).
---
---
// Dat.Locale
---
---
// Data.DateTime
---
unit
doc
name
Data
header
Date and Time
---
unit
type
name
Data.DATETIME
value
Type.fromRecord ({
complain:
function (x) {
if (x instanceof Date) { return ''; }
else { return "Not a date object." }
},
chi:
function (x) { return (x instanceof Date); },
name:
'Data.DATETIME',
cardinality:
function () { return null; }
})
---
unit
struct
name
Data.DateTime
info
....
Given UNIX time, then the range of dates is approximately 285,616 years from either side of midnight, January 1, 1970.
Negative numbers indicate dates prior to 1970.
....
comment
A structure comprising the data structures and functions to deal with date and time.
# Native ECMAScript `Date` objects and its three distinct representation formats
ECMAScript has a native `Date` class for the representation of date and time.
In our typology, these objects are the members of the `$inst('Date')` type.
Such a `Date` object has no native representation in ECMAScript, but there are a couple of built-in conversions into three distinct formats:
* A __POSIX time stamp__ (also called [Unix time](https://en.wikipedia.org/wiki/Unix_epoch) or Epoch time) is the representation of as the number of seconds that have elapsed since 00:00:00 UTC, 1 January 1970, not counting leap seconds. For example, `1401485902901` is the current time stamp.
* __date-time strings__, such as
* the __ISO notation__ (according to the [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) standard. For example, the current moment is given as `"2014-05-30T21:38:22.901Z"`.
* the __UTC__ (or [Greenwich Mean Time](https://en.wikipedia.org/wiki/Coordinated_Universal_Time) standard, where the same moment is given as `"Fri, 30 May 2014 21:38:22 GMT"`
* various __local time notations__, depending on the local settings, e.g. `"Fri May 30 2014 23:38:22 GMT+0200 (CEST)"`
* A __date-time record__, for example, `{year: 2014, month: 4, day: 30, hour: 23, minute: 38, second: 22, millisecond: 0}` (where `month:4` stands for "May", because the counting is zero-based and January is `0`.)
# The types
According to the four different data types for date and time, we have four different types, the last three are defined explicitly:
* `$inst('Date')` the instance objects of the `Date` class, native objects of ECMASCript
* `DATETIMENumber` which is just a synonym for `INT`,
* `DATETIMEString`, which is a synonym for `STRING`, and
* `DATETIME_RECORD`, which is type of all the models of the signature
{ year : INT,
month : $range ([0, 11]), // `0` is January, `1` is February, ..., `11` is December
day : $range ([1, 31]), // for day of the month
hour : $range ([0, 23]),
minute : $range ([0, 59]),
second : $range ([0, 59]),
millisecond : $range ([0, 999]) }
and the optional properties
{ week : $range ([0, 53]),
day : $range ([0, 6]) }
---
unit
local function
name
Data.DateTime.getWeek
type
Type.lambda ([DATETIME, Type.range ([1,53])])
info
`Data.DateTime.getWeek(d)` gets the week number of the `Date` object `d`.
comment
The implementation is taken from [weeknumber.net](http://weeknumber.net/how-to/javascript)
value
function (d) {
var date = new Date (d.getTime ());
date.setHours (0, 0, 0, 0);
// Thursday in current week decides the year.
date.setDate (date.getDate () + 3 - (date.getDay () + 6) % 7);
// January 4 is always in week 1.
var week1 = new Date (date.getFullYear (), 0, 4);
// Adjust to Thursday in week 1 and count number of weeks from date to week1.
return 1 + Math.round (((date.getTime () - week1.getTime ()) / 86400000 - 3 + (week1.getDay () + 6) % 7) / 7);
}
---
unit
value
name
Data.DateTime.now
type
Type.function ([NULL, DATETIME])
value
function () { return new Date(); }
info
A call of `Data.DateTime.now()` returns a `DATETIME` object with the current date and time.
For example,
> var dt = Data.DateTime.now()
> Data.DateTime.toString (dt)
Mon Jun 30 2014 18:02:06 GMT+0200 (CEST)
comment
ECMAScript has two versions to ask for the current Date/Time: `new Date()` returns a `Date` object and `Date.now()` returns the Posix time stamp (integer).
---
unit
value
name
Data.DateTime.localeOffset
type
Type.function ([NULL, INT])
value
function () {
var d = new Date ();
return d.getTimezoneOffset();
}
info
`Data.DateTime.localeOffset()` returns the difference between UTC and local time, given in minutes.
The number is positive, if the current local time is behind UTC (e.g. Pacific Daylight Time), and negative, if the local time is ahead of UTC (e.g. Japan). For example, if the local timezone is UTC+10 (Australian Eastern Standard Time), the offset is -600.
---
unit
function
name
Data.DateTime.fromInt
type
Type.lambda ([INT, DATETIME])
value
function (i) { return new Date (i); }
info
`Data.DateTime.fromInt(i)` returns the `DATETIME` object that has the [UNIX time](https://en.wikipedia.org/wiki/Unix_time) represented by the integer `i`, where `i` is the number of milliseconds that have elapsed since `00:00:00` [UTC](https://en.wikipedia.org/wiki/Coordinated_Universal_Time), Thurday, 1 January 1970, not counting leap seconds.
---
unit
function
name
Data.DateTime.toInt
type
Type.lambda ([DATETIME, INT])
value
function (d) { return d.getTime(); }
---
unit
function
name
Data.DateTime.fromString
type
Type.lambda ([STRING, DATETIME])
value
function (s) {
var n = Date.parse (s); // integer for the internal millisecond representation of `s`
var d = new Date (n);
if (isNaN (n)) {
throw Error ("`Data.DateTime.fromString(s)` error, the argument is not a string representation of a date/time: `" + Any.literal(s) + "`.");
} else {
if (d === undefined) {
throw Error ("`Data.DateTime.fromString(s)` error, the string argument cannot be converted `" + Any.literal(s) + "`.");
} else {
return d;
}
}
}
info
`Data.DateTime.fromString(s)` parses `s` and converts it into a `DATETIME` object.
Accepted `s` are in [ISO 8601](http://www.w3.org/TR/NOTE-datetime) or [RFC2822](http://tools.ietf.org/html/rfc2822#page-14) date/time syntax.
If `s` cannot be converted, an error is thrown.
For example,
> Data.DateTime.fromString ('Wed, 2 July 2014 23:30:00 GMT'); // RFC2822 syntax
Thu Jul 03 2014 01:30:00 GMT+0200 (CEST)
Note, that the string is converted according to the local time zone.
---
unit
function
name
Data.DateTime.toIsoString
type
Type.lambda ([DATETIME, STRING])
value
function (d) { return d.toISOString(); }
info
`Data.DateTime.toIsoString(d)` returns a string in [ISO 8601](http://en.wikipedia.org/wiki/ISO_8601) Extended Format, which has the form
YYYY-MM-DDTHH:mm:ss.sssZ
wheere `YYYY-MM-DD` is the date (e.g. `2014-07-02`), `T` is a constant belonging to the syntax, `HH:mm:ss.sss` is the time is seconds `ss` and milliseconds `sss`, and `Z` is a constant output here, standing for the UTC timezone.
For example,
> var d = Data.DateTime.now(null)
undefined
> d
Wed Jul 02 2014 23:33:08 GMT+0200 (CEST)
> d.toISOString()
'2014-07-02T21:33:08.775Z'
---
unit
function
name
Data.DateTime.toLocaleString
type
Type.lambda ([DATETIME, STRING])
value
function (d) { return d.toLocaleString(); }
info
...
---
unit
function
name
Data.DateTime.toLocaleDateString
type
Type.lambda ([DATETIME, STRING])
value
function (d) { return d.toLocaleDateString(); }
info
...
---
unit
function
name
Data.DateTime.toLocaleTimeString
type
Type.lambda ([DATETIME, STRING])
value
function (d) { return d.toLocaleTimeString(); }
info
...
---
unit
type
name
Data.DateTime.DATETIME_RECORD
value
undefined // DUMMY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
comment
The original value is this (but I don't understand what is going wrong!):
Type.modelPlus ({
year : INT,
month : $range ([0, 11]), // 0 is January, ..., 11 is December
date : $range ([1, 31]), // for day of the month
}) ({
hours : $range ([0, 23]),
minutes : $range ([0, 59]),
seconds : $range ([0, 59]),
milliseconds : $range ([0, 999]),
week : $range ([1, 53]),
day : $range ([0, 6]), // for day of the week, 0 is Sunday, ..., 6 is Saturday
offset : INT // difference, in minutes, between UTC and local time
})
info
...
The `offset` is the [timezone offset](https://en.wikipedia.org/wiki/Time_zone#Time_zones_and_time_offsets), which is the difference between UTC and local time, given in minutes.
The number is positive, if the current local time is behind UTC (e.g. Pacific Daylight Time), and negative, if the local time is ahead of UTC (e.g. Japan).
For example, if the local timezone is UTC+10 (Australian Eastern Standard Time), the `offset` is `-600`.
---
unit
function
name
Data.DateTime.toLocaleRecord
type
Type.lambda ([DATETIME, DATETIME_RECORD])
value
function (d) {
return Rec.create ({
year : d.getFullYear (),
month : d.getMonth (),
date : d.getDate (),
hours : d.getHours (),
minutes : d.getMinutes (),
seconds : d.getSeconds (),
milliseconds : d.getMilliseconds (),
week : getWeek (d),
offset : d.getTimezoneOffset (),
});
}
info
For example, on a machine in Amsterdam (Netherlands, so 1 hour ahead of UTC) and at summer time (another hour ahead of UTC), I obtain
> var d = Data.DateTime.now()
undefined
> Data.DateTime.toIsoString(d)
'2014-07-03T18:14:40.465Z'
> Data.DateTime.toLocaleRecord (d)
{ year: 2014,
month: 6, // July
date: 3,
hours: 20,
minutes: 14,
seconds: 40,
milliseconds: 465,
week: 27,
offset: -120 } // two hours ahead of UTC
---
unit
function
name
Data.DateTime.toUtcRecord
type
Type.lambda ([DATETIME, DATETIME_RECORD])
value
function (d) {
return Rec.create ({
year : d.getUTCFullYear (),
month : d.getUTCMonth (),
date : d.getUTCDate (),
hours : d.getUTCHours (),
minutes : d.getUTCMinutes (),
seconds : d.getUTCSeconds (),
milliseconds : d.getUTCMilliseconds (),
week : getWeek (d),
offset : 0,
});
}
info
For example, on a machine in Amsterdam (Netherlands, so 1 hour ahead of UTC) and at summer time (another hour ahead of UTC), I obtain
> var d = Data.DateTime.now()
undefined
> Data.DateTime.toIsoString(d)
'2014-07-03T18:14:40.465Z'
> Data.DateTime.toLocaleRecord (d)
{ year: 2014, month: 6, date: 3, hours: 20, minutes: 14, seconds: 40, milliseconds: 465, week: 27, offset: -120 }
> Data.DateTime.toUtcRecord (d)
{ year: 2014, month: 6, date: 3, hours: 18, minutes: 14, seconds: 40, milliseconds: 465, week: 27, offset: 0 }
---
unit
function
name
Data.DateTime.fromRecord
type
Type.lambda ([DATETIME_RECORD, DATETIME])
value
function (r) {
// the mandatory part of the date-time record `r`
var year = r.year;
var month = r.month;
var date = r.date;
// the optional part of `r`
var hours = r.hours || 0;
var minutes = r.minutes || 0;
var seconds = r.seconds || 0;
var milliseconds = r.milliseconds || 0;
var offset = r.offset || 0;
// correct the minutes by the offset
minutes = minutes + offset;
// define and return the result
var dateTime = new Date (
year,
month,
date,
hours,
minutes + offset,
seconds,
milliseconds
);
return dateTime;
}
info
.....
---
unit
function
name
Data.DateTime.normalRecord
type
Type.lambda ([DATETIME_RECORD, DATETIME_RECORD])
value
function (r) { return toUtcRecord (fromRecord (r)); }
info
For example,
....
---
// End Data.DateTime ///////////////////////////////////////////////////////////////////////////////////
---
---
// Data.Rex
---
unit
doc
name
Data
header
Regular Expressions
---
unit
type
name
Data.REGULAR_EXPRESSION
value
Type.object (RegExp)
---
unit
struct
name
Data.Rex
---
unit
doc
name
Data.Rex
header
Construction and deconstruction of regular expressions
---
unit
function
name
Data.Rex.create
type
Type.lambda ([STRING, STRING, REGULAR_EXPRESSION])
value
function (pattern) {
return function (flags) {
return new RegExp (pattern, flags);
}
}
info
`Data.Rex.create(pattern)(flags)` returns the regular expression object, made of the given `pattern` and `flags`.
---
unit
function
name
Data.Rex.pattern
type
Type.lambda ([REGULAR_EXPRESSION, STRING])
value
function (regex) {
return regex.source;
}
info
.....
---
unit
function
name
Data.Rex.flags
value
function (regex) {
var flags = '';
if (regex.global) { flags += 'g'; }
if (regex.ignoreCase) { flags += 'i'; }
if (regex.multiline) { flags += 'm'; }
if (regex.sticky) { flags += 'y'; }
return flags;
}
info
....
---
unit
doc
name
Data.Rex
header
Functions on regular expressions
---
unit
function
name
Data.Rex.search
type
Type.lambda ([STRING, REGULAR_EXPRESSION, INT])
value
function (str) {
return function (regex) {
return str.search (regex);
}
}
info
`Data.Rex.search(str)(regex)` returns the index of the first match of the `regex` inside the `str`. If there is no match, the result is `-1`.
---
unit
function
name
Data.Rex.replace
type
Type.lambda ([STRING, REGULAR_EXPRESSION, STRING, STRING])
value
function (str) {
return function (regex) {
return function (newStr) {
return str.replace (regex, newStr);
}
}
}
info
`Data.Rex.replace(str)(regex)(newStr)` returns the string `str`, where each match of `regex` in `str` is replaced by the `newStr`.
---
unit
function
name
Data.Rex.match
type
Type.lambda ([STRING, REGULAR_EXPRESSION, Type.nullify (ARRAY)])
value
function (str) {
return function (regex) {
return str.match (regex);
}
}
info
.....
See also the native [`String::match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) method.
---
unit
function
name
Data.Rex.exec
type
Type.lambda ([REGULAR_EXPRESSION, STRING, Type.nullify (ARRAY)])
value
function (regex) {
return function (str) {
return regex.exec (str);
}
}
info
.....
---
unit
function
name
Data.Rex.test
type
Type.lambda ([REGULAR_EXPRESSION, STRING, BOOLEAN])
value
function (regex) {
return function (str) {
return regex.test (str);
}
}
info
.....
---
---
// end Data.Rex
---
---
// Data.Math
---
unit
doc
name
Data
header
The built-in `Math` values and functions
---
unit
struct
name
Data.Maths
---
unit
doc
name
Data.Maths
header
Standard floating-point numbers
info
The are mainly the functions from the native ECMAScript [`Math`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math) object.
---
unit
value
name
Data.Maths.pi
type
NUMBER
value
Math.PI
info
`Data.Maths.pi` is the number [π](https://en.wikipedia.org/wiki/Pi), the ratio of a circle's circumfence to its diameter.
> Data.Maths.pi
3.141592653589793
`Data.Maths.pi` is the same and implemented as the native ECMAScript value `Math.PI`.
We changed the `PI` to `pi` to comply with the TofJs rules for naming values.
---
unit
value
name
Data.Maths.e
type
NUMBER
value
Math.E
info
`Data.Maths.e` is [Eulers's constant](https://en.wikipedia.org/wiki/E_(mathematical_constant)).
> Data.Maths.e
2.718281828459045
`Data.Maths.e` is the same and implemented as the native ECMAScript value `Math.E`.
We changed the `E` to `e` to comply with the TofJs rules for naming values.
---
unit
value
name
Data.Maths.ln2
type
NUMBER
value
Math.LN2
info
`Data.Maths.ln2` is the natural logarithm of `2`.
> Data.Maths.ln2
0.6931471805599453
`Data.Maths.ln2` is the same and implemented as the native ECMAScript value `Math.LN2`.
We changed the identifier `LN2` to `ln2` to comply with the TofJs rules for naming values.
---
unit
value
name
Data.Maths.ln10
type
NUMBER
value
Math.LN10
info
`Data.Maths.ln10` is the natural logarithm of `10`.
> Data.Maths.ln10
2.302585092994046
`Data.Maths.ln10` is the same and implemented as the native ECMAScript number `Math.LN10`.
We changed the identifier `LN10` to `ln10` to comply with the TofJs rules for naming values.
---
unit
value
name
Data.Maths.log2e
type
NUMBER
value
Math.LOG2E
info
`Data.Maths.log2e` is the base `2` logarithm of `e` (i.e. [`Data.Maths.e`](#Data.Maths.e)).
> Data.Maths.log2e
1.4426950408889634
`Data.Maths.log2e` is the same and implemented as the native ECMAScript number `Math.LOG2E`.
We changed the identifier `LOG2E` to `log2e` to comply with the TofJs rules for naming values.
---
unit
value
name
Data.Maths.log10e
type
NUMBER
value
Math.LOG10E
info
`Data.Maths.log10e` is the base `10` logarithm of `e` (i.e. [`Data.Maths.e`](#Data.Maths.e)).
> Data.Maths.log10e
0.4342944819032518
`Data.Maths.log10e` is the same and implemented as the native ECMAScript number `Math.LOG10E`.
We changed the identifier `LOG10E` to `log10e` to comply with the TofJs rules for naming values.
---
unit
value
name
Data.Maths.sqrt2
type
NUMBER
value
Math.SQRT2
info
`Data.Maths.sqrt2` is the square root of `2`.
> Data.Maths.sqrt2
1.4142135623730951
---
unit
value
name
Data.Maths.sqrt1_2
type
NUMBER
value
Math.SQRT1_2
info
`Data.Maths.sqrt1_2` is the square root of `1/2`, i.e. the inverse `1/Data.Maths.sqrt2` of the square root of `2`.
> Data.Maths.sqrt1_2
0.7071067811865476
---
unit
doc
name
Data.Maths
header
Standard functions on floating-point numbers
info
For a summary of the properties of the `Math` object, see the [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math).
---
unit
function
name
Data.Maths.abs
type
Type.lambda ([NUMBER, NUMBER])
value
Math.abs
info
`Data.Maths.abs(x)` returns the absolute value of `x`.
---
unit
function
name
Data.Maths.acos
type
Type.lambda ([NUMBER, NUMBER])
value
Math.acos
info
`Data.Maths.acos(x)` returns the arccosine of `x`.
---
unit
function
name
Data.Maths.acosh
type
Type.lambda ([NUMBER, NUMBER])
value
Math.acosh
info
`Data.Maths.acosh(x)` returns the hyperbolic arccosine of `x`.
---
unit
function
name
Data.Maths.asin
type
Type.lambda ([NUMBER, NUMBER])
value
Math.asin
info
`Data.Maths.asin(x)` returns the arcsine of `x`.
---
unit
function
name
Data.Maths.asinh
type
Type.lambda ([NUMBER, NUMBER])
value
Math.asinh
info
`Data.Maths.asinh(x)` returns the hyperbolic arcsine of `x`.
---
unit
function
name
Data.Maths.atan
type
Type.lambda ([NUMBER, NUMBER])
value
Math.atan
info
`Data.Maths.atan(x)` returns the arctangent of `x`.
---
unit
function
name
Data.Maths.atanh
type
Type.lambda ([NUMBER, NUMBER])
value
Math.atanh
info
`Data.Maths.atanh(x)` returns the hyperbolic arctangent of a number.
---
unit
function
name
Data.Maths.atan2
type
Type.lambda ([NUMBER, NUMBER, NUMBER])
value
function (y) {
return function (x) {
return Math.atan2 (y, x);
}
}
info
`Data.Maths.atan2(y)(x)` returns the aractangent of the quotient of its arguments
---
unit
function
name
Data.Maths.cbrt
type
Type.lambda ([NUMBER, NUMBER])
value
Math.cbrt
info
`Data.Maths.cbrt(x)` returns the cube root of `x`.
---
unit
function
name
Data.Maths.ceil
type
Type.lambda ([NUMBER, INT])
value
Math.ceil
info
`Data.Maths.ceil(x)` returns the smallest integer greater than or equal to `x`.
comment
see also `Int.ceil`
---
unit
function
name
Data.Maths.clz32
type
Type.lambda ([NUMBER, NUMBER])
value
Math.clz32
info
`Data.Maths.clz32(x)` returns the number of leading zeroes of a 32-bit integer.
comment
Maybe, this should also go to `Data.Bit.clz32`.
---
unit
function
name
Data.Maths.cos
type
Type.lambda ([NUMBER, NUMBER])
value
Math.cos
info
`Data.Maths.cos(x)` returns the cosine of `x`.
---
unit
function
name
Data.Maths.cosh
type
Type.lambda ([NUMBER, NUMBER])
value
Math.cosh
info
`Data.Maths.cosh(x)` returns the hyperbolic cosine of `x`.
---
unit
function
name
Data.Maths.exp
type
Type.lambda ([NUMBER, NUMBER])
value
Math.exp
info
`Data.Maths.exp(x)` returns `e^x`, where `e` is Euler's constant (`2.718...`, see [`Data.Maths.e`](#Data.Maths.e).
---
unit
function
name
Data.Maths.expm1
type
Type.lambda ([NUMBER, NUMBER])
value
Math.expm1
info
`Data.Maths.expm1(x)` returns `e^x-1`, i.e. `Data.Maths.exp(x) - 1`.
---
unit
function
name
Data.Maths.floor
type
Type.lambda ([NUMBER, NUMBER])
value
Math.floor
info
`Data.Maths.floor(x)` returns the largest integer less than or equal to `x`.
info
see `Int.floor`
---
unit
function
name
Data.Maths.fround
type
Type.lambda ([NUMBER, NUMBER])
value
Math.fround
info
`Data.Maths.fround(x)` returns the nearest [single precision](http://en.wikipedia.org/wiki/Single-precision_floating-point_format) float representation of `x`.
---
unit
function
name
Data.Maths.hypot
type
Type.lambda ([Type.list (NUMBER), NUMBER])
value
Math.hypot
info
`Data.Maths.hypot([x_1,...,x_n])` returns the square root of the sum of squares of its argument.
---
unit
function
name
Data.Maths.imul
type
Type.lambda ([NUMBER, NUMBER, NUMBER])
value
Math.imul
info
`Data.Maths.imul(x)(y)` returns the result of a 32-bit integer multiplication.
comment
Maybe, this should be moved to `Int` or `Data.Bit`??
---
unit
function
name
Data.Maths.log
type
Type.lambda ([NUMBER, NUMBER])
value
Math.log
info
`Data.Maths.log(x)` returns the natural logarithm of `x`.
---
unit
function
name
Data.Maths.log1p
type
Type.lambda ([NUMBER, NUMBER])
value
Math.log1p
info
`Data.Maths.log1p(x)` returns the natural logarithm of `x+1`.
---
unit
function
name
Data.Maths.log10
type
Type.lambda ([NUMBER, NUMBER])
value
Math.log10
info
`Data.Maths.log10(x)` returns the base 10 logarithm of `x`.
---
unit
function
name
Data.Maths.log2
type
Type.lambda ([NUMBER, NUMBER])
value
Math.log2
info
`Data.Maths.log2(x)` returns the binary logarithm of `x`.
---
unit
function
name
Data.Maths.max
type
Type.lambda ([Type.list (NUMBER), NUMBER])
value
function (xL) {
return Math.max.apply (null, xL);
}
info
`Data.Maths.max([x_1,...,x_n])` returns the greatest of the number `x_1`,...,`x_n`.
comment
see `Num.max` and `Num.maximum`
---
unit
function
name
Data.Maths.min
type
Type.lambda ([Type.list (NUMBER), NUMBER])
value
function (xL) {
return Math.min.apply (null, xL);
}
info
`Data.Maths.min([x_1,...,x_n]) returns the smallest of the numbers `x_1`,...,`x_n`.
comment
see `Num.mim` and `Num.minimum`
---
unit
function
name
Data.Maths.pow
type
Type.lambda ([NUMBER, NUMBER, NUMBER])
value
function (x) {
return function (y) {
return Math.pow (x) (y);
}
}
info
`Data.Maths.pow(x)(y)` returns base `x` to the exponent power `y`.
---
unit
function
name
Data.Maths.round
type
Type.lambda ([NUMBER, NUMBER])
value
Math.round
info
`Data.Maths.round(x)` returns the value of a number rounded to the nearest integer.
comment
See `Int.round`
---
unit
function
name
Data.Maths.sign
type
Type.lambda ([NUMBER, Type.finite ([-1,-0,0,1])])
value
Math.sign
info
`Data.Maths.sign(x)` returns the sign of `x`, i.e.
* `-1`, if `x` is negative
* `-0`, if `x` is negative zero
* `0`, if `x` is (positive) zero
* `1`, if `x` positive
The [real numbers](https://en.wikipedia.org/wiki/Real_number) only have one zero element `0`, and every bigger element is positive, i.e. signature `1`, and every smaller element is negative with signature `-1`. Accordingly, the __signature__ of every real number is either `-1`, `0`, or `1`.
Each real number `x` can be decomposed into its __signature__ `sign(x)` and __absolute value__ `abs(x)`, where
x === sign(x) * abs(x)
But the [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point) floating point standard has two zeros `0` and `-0`. And actually, they are really different values, because they can lead to different results:
> 7 / 0
Infinity
> 7 / -0
-Infinity
Accordingly, the signature of a floating point number is not one of three, but one of the four values `-1`, `-0`, `0` or '1`.
comment
The implementation is as [`Math.sign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign), introduced in ES6.
The polyfill for `Math.sign` on [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign) is suggested as
Math.sign = Math.sign || function(x) {
x = +x; // convert to a number
if (x === 0 || isNaN(x)) {
return x;
}
return x > 0 ? 1 : -1;
}
---
unit
function
name
Data.Maths.sin
type
Type.lambda ([NUMBER, NUMBER])
value
Math.sin
info
`Data.Maths.sin(x)` returns the sine of `x`.
---
unit
function
name
Data.Maths.sinh
type
Type.lambda ([NUMBER, NUMBER])
value
Math.sinh
info
`Data.Maths.sinh(x)` returns the hyperbolic sine of `x`.
---
unit
function
name
Data.Maths.sqrt
type
Type.lambda ([NUMBER, NUMBER])
value
Math.sqrt
info
`Data.Maths.sqrt(x)` returns the square root of `x`.
---
unit
function
name
Data.Maths.tan
type
Type.lambda ([NUMBER, NUMBER])
value
Math.tan
info
`Data.Maths.tan(x)` returns the tangent of `x`.
---
unit
function
name
Data.Maths.tanh
type
Type.lambda ([NUMBER, NUMBER])
value
Math.tanh
info
`Data.Maths.tanh(x)` returns the hyperbolic tangent of `x`.
---
unit
function
name
Data.Maths.trunc
type
Type.lambda ([NUMBER, NUMBER])
value
Math.trunc
info
`Data.Maths.trunc(x)` returns the integral part of `x`, removing any fractional digits.
---
---
unit
doc
name
Data.Maths
header
Random floating point numbers
---
unit
function
name
Data.Maths.random
type
Type.fun ([NULL, NUMBER])
value
function (x) { return Math.random(); }
info
`Data.Maths.random(null)` returns a pseudo-random number between 0 and 1.
---
---
// end Data.Maths
---
---
// Data.Json
---
---
unit
doc
name
Data
header
JSON (JavaScript Object Notation)
---
---
unit
struct
name
Data.Json
---
---
unit
doc
name
Data.Json
header
JSON values, JSON code, and their mutual conversion
---
---
unit
type
name
Data.Json.VALUE
value
Type.fromRecord ({
complain:
function (x) {
var y = JSON.stringify (JSON.parse (x));
if (Any.equal (x) (y)) { return ''; }
else { return "The value is not a JSON value."; }
},
name:
'Data.Json.VALUE',
cardinality:
function () { return null; }
})
info
...
comment
IMPROVE THE IMPLEMENTATION!!!
---
unit
type
name
Data.Json.CODE
value
STRING // dummy!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
info
...
comment
IMPROVE THE IMPLEMENTATION!!!!!!!!!!!!!!!!1
---
unit
function
name
Data.Json.code2value
type
Type.lambda ([CODE, VALUE])
value
function (code) {
try {
return JSON.parse (code);
} catch (e) {
throw Error ("Unable to convert the JSON code into a JSON value: " + e);
}
}
info
.....
---
unit
function
name
Data.Json.value2code
type
Type.lambda ([VALUE, CODE])
value
function (x) {
try {
return JSON.stringify (x, null, 2);
} catch (e) {
throw Error ("Unable to convert the JSON value into JSON code: " + e);
}
}
info
.....
---
---
unit
doc
name
Data.Json
header
Functions on JSON values
---
---
unit
function
name
Data.Json.urtype
type
Type.lambda ([Json.VALUE, URTYPE])
value
function (x) {
switch (typeof x) {
case 'boolean':
return BOOLEAN;
case 'number':
return NUMBER;
case 'string':
return STRING;
case 'object':
if (x === null) {
return NULL;
} else if (Array.isArray (x)) {
return LIST;
} else {
return RECORD;
}
default:
throw Error ("The given `" + (typeof x) + "` value is not a JSON value.");
}
}
info
Each JSON value is exactly of one of the following urtypes: `NULL`, `BOOLEAN`, `NUMBER`, `STRING`, `LIST`, or `RECORD`.
`Data.Json.urtype (x)` returns this urtype for the given JSON value `x`.
For example,
---
unit
function
name
Data.Json.compare
type
Type.lambda ([Json.VALUE, Json.VALUE, Type.finite ([-1,0,1])])
value
function (x) {
return function (y) {
return ".......................................Data.Json.compare(x)(y).........................................";
}
}
info
`Data.Json.compare` induces a [linear order] on the set of all JSON values.
`Data.Json.compare(x)(y)` is `-1`, `0`, or `1`, depending on whether `x` is smaller, equal, or bigger than `y`.
---
unit
function
name
Data.Json.equal
type
Type.lambda ([Json.VALUE, Json.VALUE, BOOLEAN])
value
function (x) {
return function (y) {
return ".............................Data.Json.equal(x)(y)...................................................";
}
}
info
.....
---
unit
function
name
Data.Json.comparisonValue
type
Type.lambda ([Json.VALUE, Json.VALUE, Json.VALUE])
value
function comparisonValue (x) {
return function (y) {
if (x === y) {
return 0;
} else {
if (Type.chi (LIST) (x) && Type.chi (LIST) (y)) {
var zL = [];
var isEqual = true;
for (var i = 0; i < Math.min (x.length, y.length); i++) {
var t = comparisonValue (x[i]) (y[i]);
if (typeof t === 'number' && t < 0) { isEqual = false; }
zL.push (t);
}
if (x.length > y.length) {
for (var i = 0; i < x.length - y.length; i++) {
zL.push (1);
}
return zL;
} else if (x.length < y.length) {
for (var i = 0; i < y.length - x.length; i++) {
zL.push (2);
}
return zL;
} else {
if (isEqual) { return 0; }
else { return zL; }
}
} else if (Type.chi (RECORD) (x) && Type.chi (RECORD) (y)) {
var o = {};
var isEqual = true;
for (var k in x) {
if (k in y) {
var t = comparisonValue (x[k]) (y[k]);
if (typeof t === 'number' && t < 0) { isEqual = false; }
o [k] = t;
} else {
isEqual = false;
o [k] = 1;
}
}
for (var k in y) {
if (! (k in x)) {
isEqual = false;
o [k] = 2;
}
}
if (isEqual) { return 0; }
else { return Rec.create (o); }
} else {
return -1;
}
}
}
}
info
`Data.Json.comparison (x) (y)` is a value which is recursively defined to be one of the following:
* either a primitive value, namely one of `-1` (for "not equal"), `0` (for "equal"),
* a list of those values
* a record of those value.
For example,
> Data.Json.comparisonValue (123.456) (123.456)
0
> Data.Json.comparisonValue ("Hello") ("Hello")
0
> Data.Json.comparisonValue ('Hi there!') (123.456)
-1
> Data.Json.comparisonValue (false) (null)
-1
> Data.Json.comparisonValue (['a', 'b', 'c']) ('Hello')
-1
> Data.Json.comparisonValue (['a', 'b', 'c', 'd', 'e']) (['a', 'b', 'x'])
[ 0, 0, -1, 1, 1 ]
> Data.Json.comparisonValue (['a', 'b', 'c']) (['a', 'b', 'c'])
0
> Data.Json.comparisonValue ({one: 123, three: 234, four: 345}) ({two: 123, three: 234, four: 789})
{ one: 1, three: 0, four: -1, two: 2 }
> Data.Json.comparisonValue ({}) ({one: 123, two: 234})
{ one: 2, two: 2 }
> Data.Json.comparisonValue ({one: null, two: [3,2,1]}) ({one: null, two: [1,2,3,4]})
0
> Data.Json.comparisonValue ({one: false, two: [1,2]}) ({one: false, two: [1,2]})
0
/***
Data.Json.comparisonValue (123.456) (123.456)
Data.Json.comparisonValue ("Hello") ("Hello")
Data.Json.comparisonValue ('Hi there!') (123.456)
Data.Json.comparisonValue (false) (null)
Data.Json.comparisonValue (['a', 'b', 'c']) ('Hello')
Data.Json.comparisonValue (['a', 'b', 'c', 'd', 'e']) (['a', 'b', 'x'])
Data.Json.comparisonValue (['a', 'b', 'c']) (['a', 'b', 'c'])
Data.Json.comparisonValue ({one: 123, three: 234, four: 345}) ({two: 123, three: 234, four: 789})
Data.Json.comparisonValue ({}) ({one: 123, two: 234})
Data.Json.comparisonValue ({one: null, two: [3,2,1]}) ({one: null, two: [1,2,3,4]})
Data.Json.comparisonValue ({one: false, two: [1,2]}) ({one: false, two: [1,2]})
.....
***/
---
---
// end Data.Json
---
---
// Url and Uri
---
unit
doc
name
Data
header
URL's and URI's
---
unit
type
name
Data.URL
value
Type.subType
(STRING)
(function (s) {
if (Data.Url.regex.test (s)) { return ""; } else { return "Not a valid URL: `" + Any.ellipsis(s) + "`."; };
})
info
A [Uniform Resource Locator](http://en.wikipedia.org/wiki/Uniform_resource_locator) has the following syntax:
scheme_name:hierarchical_part?query#fragment
... see [here](http://en.wikipedia.org/wiki/URI_scheme#Generic_syntax) ...
....................
For example,
....................
comment
Integrate this [demo page](https://mathiasbynens.be/demo/url-regex) as a session.
---
unit
struct
name
Data.Url
info
Implement something like
the [URL module in Node.js](http://nodejs.org/api/url.html)
or the [Location object](http://www.w3schools.com/jsref/obj_location.asp) in the DOM.
comment
IMPLEMENT THIS!!!!!!!!!!!!!!!!!!!!!!!!!!!!
---
unit
value
name
Data.Url.regex
value
new RegExp(
"^" +
// protocol identifier
"(?:(?:https?|ftp)://)" +
// user:pass authentication
"(?:\\S+(?::\\S*)?@)?" +
"(?:" +
// IP address exclusion
// private & local networks
"(?!(?:10|127)(?:\\.\\d{1,3}){3})" +
"(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})" +
"(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})" +
// IP address dotted notation octets
// excludes loopback network 0.0.0.0
// excludes reserved space >= 224.0.0.0
// excludes network & broacast addresses
// (first & last IP address of each class)
"(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])" +
"(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}" +
"(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))" +
"|" +
// host name
"(?:(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)" +
// domain name
"(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*" +
// TLD identifier
"(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))" +
")" +
// port number
"(?::\\d{2,5})?" +
// resource path
"(?:/\\S*)?" +
"$", "i"
);
info
This regular expression is a copy from [Diego Perini](https://gist.github.com/dperini/729294) from 2010/12/05.
---
---
---
unit
struct
name
Data.Uri
info
This structure
* redefines four [global JavaScript functions](http://www.w3schools.com/jsref/jsref_obj_global.asp)
`decodeURI`, `encodeURI`, `decodeURIComponent` and `encodeURIComponent`.
* defines an encoding/decoding pair of functions to turns string records (with optional `null` values) into a query
string part of a URL, and vice versa.
For example, the record `{one: "aaa", two: "bbb", three: "ccc"}` turns into `one=aaa&two=bbb&three=ccc`.
---
unit
function
name
Data.Uri.encode
type
Type.lambda ([STRING, STRING])
value
encodeURI
comment
In the table below, I write "dollar sign", because actually writing the dollar sign results in strange compiler errors.
info
`Uri.encode(s)` encodes a [Uniform Resource Identifier](http://en.wikipedia.org/wiki/Uniform_resource_identifier) (URI)
`s` by replacing each instance of certain characters by one, two, three, or four escape sequences representing the
[UTF-8](http://en.wikipedia.org/wiki/UTF-8) encoding of the character.
For example,
> Data.Uri.encode ('Schöne neue Welt!')
'Sch%C3%B6ne%20neue%20Welt!'
> encodeURI ('A λχ-type-system')
'A%20%CE%BB%CF%87-type-system'
> decodeURI (encodeURI ('A λχ-type-system'))
'A λχ-type-system'
`Data.Uri.encode` replaces all characters except the following with the appropriate [UTF-8](http://en.wikipedia.org/wiki/UTF-8)
escape sequences:
Type Includes
------------------------- -------------------------------------------------------------------
reserved characters `; , / ? : @ & = +` and dollar sign
unescaped characters alphabetic, decimal digits, and these ones: `- _ . ! ~ * ' ( )`
score `#`
Note that `Data.Uri.encode` by itself cannot form proper HTTP GET and POST requests, such as for XMLHTTPRequests, because
`&`, `+`, and `=` are not encoded, which are treated as special characters in GET and POST requests.
`Uri.encodeComponent`, however, does encode these characters.
For example,
> Data.Uri.encode ('http://localhost:55555/foo/bar?greeting=Hello world!&price=$500')
'http://localhost:55555/foo/bar?greeting=Hello%20world!&price=$500'
> Data.Uri.encodeComponent ('http://localhost:55555/foo/bar?greeting=Hello world!&price=$500')
'http%3A%2F%2Flocalhost%3A55555%2Ffoo%2Fbar%3Fgreeting%3DHello%20world!%26price%3D%24500'
`Data.Uri.encode` is implemented as a redefinition of the global
[`encodeURI`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURI)
function.
---
unit
function
name
Data.Uri.decode
type
Type.lambda ([STRING, STRING])
value
decodeURI
info
`Data.Uri.decode(s)` decodes a [Uniform Resource Identifier](http://en.wikipedia.org/wiki/Uniform_resource_identifier) (URI)
`s` previously creaed by `Data.Uri.encode(x)` or by a similar routine.
For example,
> Data.Uri.encode ('A λχ-type-system')
'A%20%CE%BB%CF%87-type-system'
> Data.Uri.decode ('A%20%CE%BB%CF%87-type-system')
'A λχ-type-system'
`Data.Uri.decode(s)` replaces each escape sequence in the encoded URI `s` with the character that it represents, but does not decode escape sequences that could not have been introduced by `Uri.encode`.
The character `#` is not decoded from escape sequences.
`Data.Uri.decode` is implemented as a redefinition of the global
[`decodeURI`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURI)
function.
---
unit
function
name
Data.Uri.encodeComponent
type
Type.lambda ([STRING, STRING])
value
encodeURIComponent
info
`Data.Uri.encodeComponent(s)` encodes a [Uniform Resource Identifier](http://en.wikipedia.org/wiki/Uniform_resource_identifier)
(URI) component by replacing each instance of certain characters by one, two, three, or four escape sequences representing
the [UTF-8](http://en.wikipedia.org/wiki/UTF-8) encoding of the character.
It escapes all characters except the following: alphabetic, decimal, digits, `-`, `_`, `.`, `!`, `~`, `*`, `'`, `(`, `)`.
`Data.Uri.encodeComponent` is implemented as a redefinition of the global
[`encodeURIComponent`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent)
function.
For example,
> Data.Uri.encodeComponent ('http://localhost:55555/foo/bar?greeting=Hello world!&price=$500')
'http%3A%2F%2Flocalhost%3A55555%2Ffoo%2Fbar%3Fgreeting%3DHello%20world!%26price%3D%24500'
---
unit
function
name
Data.Uri.decodeComponent
type
Type.lambda ([STRING, STRING])
value
decodeURIComponent
info
`Data.Uri.decodeComponent(s)` decodes a [Uniform Resource Identifier](http://en.wikipedia.org/wiki/Uniform_resource_identifier)
(URI) component `s` previously created by `Uri.encodeComponent(x)` or by a similar routine.
`Data.Uri.decodeComponent` is implemented as a redefinition of the global
[`decodeURIComponent`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent)
function.
For example,
......
---
unit
function
name
Data.Uri.record2queryString
type
Type.lambda ([Type.record (Type.nullify (STRING)), STRING])
value
function (r) {
var strL = [];
for (var k in r) {
if (Type.chi (STRING) (r [k])) {
strL.push (k + "=" + encodeComponent (r [k]));
} else if (Type.chi (NULL) (r [k])) {
strL.push (k);
} else {
throw Error ( "`Data.Uri.record2queryString(r)` error, `r` is not a nullified string record, its `"
+ k + "` value `" + r[k] + "` is neither a string nor `null`." );
}
}
return strL.join ("&");
}
info
`Data.Uri.record2queryString(r)` converts the record `r` that has either string or `null` values into a
[query string](http://en.wikipedia.org/wiki/Query_string).
The conversion rules are:
* each key-value pair `k:v` of the record is converted into a string `k=w`, where `w` is the URI-encoded value `v`.
* each key `k` with value `null` is converted into `k`, again.
* all there strings are joined with the `&` as separation symbol.
For example,
> Data.Uri.record2queryString ({first: '123', second: null, third: "Hello World!"})
'first=123&second&third=Hello%20World!'
> Data.Uri.record2queryString({})
''
> Data.Uri.record2queryString ({one:'123', two: null, three: 'null'})
'one=123&two&three=null'
> Data.Uri.record2queryString ({one: 123})
Error: ....
> Data.Uri.record2queryString ({greeting: "Hello there!", smiley: ":-)"})
'greeting=Hello%20there!&smiley=%3A-)'
---
unit
function
name
Data.Uri.queryString2record
type
Type.lambda ([STRING, Type.record (STRING)])
value
function (s) {
var r = {};
if (s.length > 0) {
var strL = s.split ("&");
for (var i = 0; i < strL.length; i++) {
var pair = strL[i].split ('=');
var key = pair[0];
var value = pair[1];
value = ( value
? decodeComponent (value)
: null );
r[key] = value;
}
}
return Rec.create (r);
}
info
`Data.Uri.queryString2record(s)` decodes the query string `s` into the original record `r`, so that `Uri.record2queryString(r)` is `s`, again.
For example,
> Data.Uri.queryString2record ('first=123&second&third=Hello%20World!')
{ first: '123', second: null, third: 'Hello World!' }
Note, that
> Data.Uri.queryString2record ('first&second=&third=null&=foo')
{ first: null, second: '', third: 'null', '': 'foo' }
which means that
* a key without a value (`first`) turns into a null value (`first: null`)
* a key with empty value (`second=`) turns into null value (`second: null`).
* a null value (`third=null`) turns into a string value (`third: 'null'`)
* an empty key (`=foo`) turns into the empty string key (`'': 'foo')
---
---
// end Url and Uri
---
---
---
unit
doc
name
Data
header
Email
---
---
unit
struct
name
Data.Email
---
---
unit
type
name
Data.Email.ADDRESS
value
Type.regularString ( '^\\w+@[a-zA-Z_]+?\\.[a-zA-Z]{2,3}$' )
info
`Data.Email.ADDRESS` is the type of all email addresses.
For example,
> Type.chi (Data.Email.ADDRESS) ('somebody@example.com');
true
> Type.chi (Data.Email.ADDRESS) ('somebody@example');
false
> Type.chi (Data.Email.ADDRESS) ('example.com');
false
The type is implemented by a regular expression, but one that is a little too simple to match all actually valid email addresses.
See the [wikipedia](https://en.wikipedia.org/wiki/Email_address) entry for more information.
---
---
// end Data.Email
---
---
---
unit
doc
name
Data
header
Maps and Sets
---
---
---
// Data.Map
---
---
unit
struct
name
Data.Map
info
see [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)
---
---
unit
doc
name
Data.Map
header
...........CONTINUEHERE TO IMPLEMENT MAPS.................................
---
---
// end Data.Map
---
---
---
// Data.Set
---
---
unit
struct
name
Data.Set
info
see [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set)
---
unit
doc
name
Data.Set
header
.............CONTINUEHERE TO IMPLEMENT SETS..............
---
---
// end Data.Set
---
---
---
unit
doc
name
Data
header
**HTML, CSS and Markdown**
---
---
---
// Data.Html
---
---
unit
doc
name
Data
header
HTML
---
---
unit
type
name
Data.HTML
value
Type.synonym (STRING)
info
.....
comment
Insert `Html` from `html.tofu`.
---
unit
struct
name
Data.Html
---
unit
doc
name
Data.Html
header
Native `String` methods
---
unit
function
name
Data.Html.anchor
type
Type.lambda ([HTML, URL, HTML])
value
function (h) {
return function (href) {
return h.anchor(href);
}
}
info
`Data.Html.anchor(h)(href)` returns a HTML anchor element `` that refers to the address `href`.
For example,
> Data.Html.anchor ('Look here!') ('http://example.com')
'Look here!'
---
unit
doc
name
Data.Html
header
........continuehere................
---
---
// Data.Html.anchor
// Data.Html.big
// Data.Html.blink
// Data.Html.bold
// Data.Html.fixed
// Data.Html.fontcolor
// Data.Html.fontsize
// Data.Html.italics
// Data.Html.link
// Data.Html.small
// Data.Html.strike
// Data.Html.sub
// Data.Html.sup
---
unit
doc
name
Data.Html
header
More functions
---
---
unit
function
name
Data.Html.entityify
type
Type.lambda ([STRING, STRING])
value
function (str) {
return String(str).replace(/&/g, '&').replace(//g, '>').replace(/"/g, '"');
};
info
`Data.Html.entityify(str)` returns a mutation of the argument `str`, where the following replacements have taken place:
character replacement
---------- --------------
`&` `&`
`<` `<`
`>` `>`
`"` `"`
For example,
> Data.Html.entityify ('
What is "Good & Bad"?
')
'<h1> What is "Good & Bad"? </h1>'
`Data.Html.entityify` is similar to the [`htmlentities()`](http://us2.php.net/manual/en/function.htmlentities.php) function of [PHP](http://php.net/manual/en/).
---
unit
doc
name
Data.Html
header
HTML Names [.............move this to Data.Name.............]
info
A `NAME` value is a name according to the syntax rule of ECMAScript: it may contain the dollar sign `$` and it is case-sensitive.
But names in HTML, i.e. values for the [`id` attribute](http://www.w3schools.com/tags/att_global_id.asp), are case-insensitive and must not contain `$`.
For that reason, we define `HTML_NAME`s as a separate type together with conversions between them
toHtmlName
NAME -------------------> HTML_NAME
fromHtmlName
HTML_NAME -------------------> NAME
---
unit
type
name
Data.Html.HTML_NAME
value
Type.subType (STRING) (function (s) {
var rex = /^[A-Za-z][A-Za-z0-9-]*$/;
if (rex.test (s)) {
return "";
} else {
return ( "`" + s + "` is not a non-empty string, beginning with a letter and only comprising letters, digits and hyphens.")
}
}
)
info
A __HTML name__, i.e. a `HTML_NAME` value, is a non-empty string, only made of letters (`A`,...,`Z`,`a`,...,`z`), digits (`0`,`1`,...,`9`) and hyphens (`-`), and beginning with a letter.
Examples of HTML names are:
`"this-is-a-HTML-name"` `"about-a-100-things"` `"section-2-7"`
Counterexamples are:
* `"this is not a HTML name"` is not a HTML name, because it contains spaces
* `"no_good_either"` is not a HTML name, because it contains underscores
* `"1000-years"` is not a HTML name, because it does not start with a letter
* `""` the empty string is not a HTML name.
* `"abc*$def"` is not a HTML name, because it contains a `*` and a `$`
Accordingly, we obtain
> Data.Html.HTML_NAME.chi ("this-is-a-HTML-name")
true
> Data.Html.HTML_NAME.chi ("about-a-100-things")
true
> Data.Html.HTML_NAME.chi ("section-2-7")
true
> Data.Html.HTML_NAME.chi ("this is not a HTML name")
false
> Data.Html.HTML_NAME.chi ("1000-years")
false
> Data.Html.HTML_NAME.chi ("")
false
> Data.Html.HTML_NAME.chi ("abc*$def")
false
Note, that the [official HTML4 definition of ID and NAME tokens](http://www.w3.org/TR/html4/types.html#type-id) are more permissive than our `HTML_NAME` type: they must begin with a letter (`A`,...,`Z`,`a`,...,`z`) and may be followed by any number of letters, digits (`0`,...,`9`), hyphens (`-`), underscores (`_`), colons (`:`) and periods (`.`).
[HTML5](http://www.w3.org/TR/html5/dom.html#the-id-attribute) is even more permissive and says it must start with an arbitrary character, followed by more characters, not containing space symbols.
Our `HTML_NAME` definition is more restrictive, because it avoids problems when the names are used in other contexts, like CSS, where colons and periods have a special and different meaning.
There is a nice stackoverflow post on the question [_What are vaid values for the id attribute in HTML?_](http://stackoverflow.com/questions/70579/what-are-valid-values-for-the-id-attribute-in-html)
---
unit
function
name
Data.Html.toHtmlName
type
Type.lambda ([Global.NAME, HTML_NAME])
value
function (name) {
if (name === '') { return 'ROOT'; }
var htmlName = name . replace (/\$/g, "DOLLAR") . replace (/\./g, "-");
if (htmlName === '') {
throw Error ("`Data.Html.toHtmlName(name)` error, the conversion leaves an empty string for the given argument `" + name + "`.");
} else {
return htmlName;
}
}
info
`Data.Html.toHtmlName("")`, the HTML name of the empty name is `'ROOT'`.
Otherwise, `Data.Html.toHtmlName(name)` is generated as follows:
Each dot `.` is replaced by a hyphen `-` and each dollar sign `$` is replaced by the word `DOLLAR`.
If the result would leave an empty string, an error is thrown.
For example
Data.Html.toHtmlName ('One_One.TwoTwo.$Three') === "One_One-TwoTwo-DOLLARThree"
Note, that a `NAME` may be an empty string, but a `HTML_NAME` must always be non-empty.
comment
UPDATE/CHANGE THIS!!! The `$` conversion is obsolete!!!
---
unit
function
name
Data.Html.fromHtmlName
type
Type.lambda ([HTML_NAME, Global.NAME])
value
function (htmlName) {
if (htmlName === 'ROOT') { return ''; }
var name = htmlName . replace ("DOLLAR", "\u0024") . replace (new RegExp ('-', 'g'), ".");
return name;
}
info
`Data.Html.fromHtmlName('ROOT')` is the empty name `''`.
Otherwise, `Data.Html.fromHtmlName(htmlName)` is generated as follows:
Each occurrence of the word `DOLLAR` is replaced by the dollar sign `$` and each hyphen `-` is replaced by a dot `.`.
For example,
..........................
comment
UPDATE/CHANGE THIS!!! The `$` conversion is obsolete!!!
In the implementation with used `"\u0024"` instead of `'$'` and `new RegExp ('-', 'g')` instead of `/-/g` because the unit compilation could not compile the regular expression literal correctly.
---
unit
function
name
Data.Html.htmlNameCompare
type
Type.lambda ([HTML_NAME, HTML_NAME, Type.finite ([-1, 0, 1])])
value
function (n1) {
return function (n2) {
return Str.compare (Str.toLowerCase (n1)) (Str.toLowerCase (n2));
}
}
info
.........
---
---
// HTML element creation
---
unit
doc
name
Data.Html
header
HTML creators
---
---
unit
type
name
Data.Html.HTML_DOC
value
Type.synonym (STRING)
---
unit
function
name
Data.Html.htmlDoc
type
Type.lambda ([RECORD, HTML, HTML_DOC])
value
function (parameter) {
return function (bodyContent) {
// Normalize the `parameter` record
var title = parameter.title || '';
var script = parameter.script || '';
var scriptLinks = parameter.scriptLinks || []; // type `Type.list(URL)`; later type `HTML`
var css = parameter.css || '';
var cssLinks = parameter.cssLinks || []; // of type `Type.list(URL)`; later type `HTML`
// turn the parameter values into HTML
if (title) {
title = '' + title + '\n';
}
if (css) {
css = '\n';
}
if (script) {
script = "<" + 'script' + ">" + "\n" + script + "\n" + "<" + '/' + 'script' + ">" + "\n";
}
if (scriptLinks.length > 0) {
for (var i = 0; i < scriptLinks.length; i++) {
scriptLinks[i] = "<" + "script src=\"" + scriptLinks[i] + "\"" + ">" + "<" + "/" + 'script' + ">\n";
}
}
scriptLinks = scriptLinks.join (""); // now, `scriptLinks` is of type `HTML`
if (cssLinks.length > 0) {
for (var i = 0; i < cssLinks.length; i++) {
cssLinks[i] = '\n'
}
}
cssLinks = cssLinks.join ("\n"); // now. `cssLinks` is of type `HTML`
// the resulting HTML document
return ( '\n'
+ '<' + 'html>\n'
+ '\n'
+ '\n'
+ title
+ css
+ cssLinks
+ script
+ scriptLinks
+ '\n'
+ '\n'
+ bodyContent + '\n'
+ '\n'
+ '