Language Reference/Built-in entities/Domains - Revision history

Thomas Linder Puls: string8 literals

2025-08-21T09:13:05Z

string8 literals

SergeMukhin: remove ()

2023-11-12T12:33:23Z

remove ()

← Older revision		Revision as of 14:33, 12 November 2023
Line 349:		Line 349:

	<vip>domains		<vip>domains
	boolean = false(); true().</vip>		boolean = false; true.</vip>

	==== factDB ====		==== factDB ====

Thomas Linder Puls: clarification

2023-11-09T09:36:12Z

clarification

← Older revision		Revision as of 11:36, 9 November 2023
Line 140:		Line 140:
	==== symbol ====		==== symbol ====

	~~Wide zero terminated sequence of wide characters~~.		Utf-16 strings with same representation as <vp>string</vp>, but they are also stored in a global symbol table.

	<vip>symbol</vip>		<vip>symbol</vip>

	~~Similar to a string, a~~ symbol is ~~also~~ a ~~sequence~~ of the ~~UNICODE characters~~. ~~It's implemented as a pointer to an entry in~~ a symbol table ~~that contains strings~~. ~~The operations that can~~ be ~~applied to symbols are the same as~~ for ~~strings~~.		A <vp>symbol</vp> is stored in a global symbol table, and that storage guarenties that the pointer value of symbols will be the same for the same symbol. Once a <vp>symbol</vp> is put into the symbol table it is never removed again, so <vp>symbol</vp>s are never reclaimed. Their storage will live untill the program terminates. So the <vp>symbol</vp> data type should not be used for large documents, etc.

	The ~~image~~ of a symbol is ~~represented with~~ a ''<~~string_literal~~>'' (~~any string surrounded by~~ the ~~double quotes~~).		The <vp>symbol</vp> domain is a subtype of the <vp>string</vp> domain, so a symbol can be used everywhere instead of a string. The opposite is not the case because a <vp>string</vp> will have to be found or inserted in the global symbol table to become a <vp>symbol</vp>. So to create a symbol from a string you will have to <vp>convert</vp> the string to the symbol domain (or a subtype of the <vp>symbol</vp> domain).

	~~Symbols and strings are largely interchangeable but they are stored differently~~. ~~Symbols are kept in a look-up table and their addresses, rather than~~ the ~~symbols themselves, are stored~~ to ~~represent objects~~. ~~This means that symbols can be matched very quickly and~~, ~~if a symbol occurs repeatedly in a program~~, ~~it can be stored very compactly. Strings~~ are ~~not kept~~ in ~~a look-up table. Visual Prolog examines strings character-~~by~~-character whenever they are to be matched~~.		The equality operation is very efficient for <vp>symbol</vp>s since their pointer value will be the same if the <vp>symbol</vp> is the same. I.e. there is no need to compare the actual characters to determine equality.

			Other comparison operations (less than, case insensitive comparison, etc) are the same as for <vp>string</vp> in fact all other operations on <vp>symbol</vp> is simply carried out by the corresponding string operations.

	==== binary ====		==== binary ====

Thomas Linder Puls: clarification

2023-11-09T09:15:55Z

clarification

← Older revision		Revision as of 11:15, 9 November 2023
Line 107:		Line 107:
	==== string ====		==== string ====

	~~Wide zero terminated sequence of wide characters~~.		Utf-16 strings.

	<vip>string</vip>		<vip>string</vip>

	A string ~~is a sequence of UNICODE characters. It's implemented~~ as a pointer to ~~the wide~~ zero-terminated ~~array~~ of ~~wide~~ characters. ~~Only assignment and comparison (~~in the ~~lexicographical sense~~) ~~operations~~ are ~~applied to~~ values ~~of this domain~~.		A string represented as a pointer to a zero terminated sequence of characters in utf-16 encoding. Values in the sequence are 16 bits, but certain rare characters (code points) are encoded using two such values. Strings are immutable.

	In source code a string literal can be specified as a set of sequences of characters surrounded by the double quotes.		In source code a string literal can be specified as a set of sequences of characters surrounded by the double quotes.

Thomas Linder Puls: pointerTo

2023-10-24T15:10:05Z

pointerTo

← Older revision		Revision as of 17:10, 24 October 2023
Line 322:		Line 322:

	A pointer directly corresponds to memory addresses. Only the equality operation can be applied to the values of this domain. There is a built-in '''null''' constant for this type		A pointer directly corresponds to memory addresses. Only the equality operation can be applied to the values of this domain. There is a built-in '''null''' constant for this type

			==== pointerTo ====

			<vp>pointerTo{Type}</vp> represents a pointer to a value of type <vp>Type</vp>. It's definition is like this (but it is built-in):

			<vip>domains
			pointerTo{Type} = pointerTo(Type Value).</vip>

	==== handle ====		==== handle ====

Joachim Tilsted Kristensen: /* compareResult */

2020-12-19T16:23:49Z

compareResult

← Older revision		Revision as of 18:23, 19 December 2020
Line 100:		Line 100:
	==== compareResult ====		==== compareResult ====

	~~A built-in domain that represents the~~ result of a comparison. For instance, the built-in procedure {{lang2\|Built-in entities\|compare\|compare/2->}} has "compareResult" as the domain of its result.		The result of a comparison. For instance, the built-in procedure {{lang2\|Built-in entities\|compare\|compare/2->}} has "compareResult" as the domain of its result.
	<vip>domains		<vip>domains
	compareResult = less; equal; greater.		compareResult = less; equal; greater.

Joachim Tilsted Kristensen: /* integer64 */

2020-12-19T16:18:26Z

integer64

← Older revision		Revision as of 18:18, 19 December 2020
Line 222:		Line 222:
	==== integer64 ====		==== integer64 ====

	64 bit signed ~~integer~~.		64 bit signed integers.

	<vip>integer64</vip>		<vip>integer64</vip>

Joachim Tilsted Kristensen: /* binaryNonAtomic */

2020-12-19T16:18:02Z

binaryNonAtomic

← Older revision		Revision as of 18:18, 19 December 2020
Line 182:		Line 182:
	==== binaryNonAtomic ====		==== binaryNonAtomic ====

	Sequence of N bytes.		Sequence of bytes.

	<vip>binaryNonAtomic</vip>		<vip>binaryNonAtomic</vip>

Joachim Tilsted Kristensen: /* binary */

2020-12-19T16:17:46Z

binary

← Older revision		Revision as of 18:17, 19 December 2020
Line 152:		Line 152:
	==== binary ====		==== binary ====

	Sequence of N bytes.		Sequence of bytes.

	<vip>binary</vip>		<vip>binary</vip>

Joachim Tilsted Kristensen: /* string8 */

2020-12-19T16:17:13Z

string8

← Older revision		Revision as of 18:17, 19 December 2020
Line 136:		Line 136:
	==== string8 ====		==== string8 ====

	A built-in domain ~~inhabited by~~ sequences of (one-byte) ASCII-characters. It is implemented as a pointer to the zero terminated array of ASCII characters. Only assignment and comparison for equality (in the lexicographical sense) operations are applied to the values of this domain. Currently no literals are allowed for this domain.		A built-in domain who's elements are sequences of (one-byte) ASCII-characters. It is implemented as a pointer to the zero terminated array of ASCII characters. Only assignment and comparison for equality (in the lexicographical sense) operations are applied to the values of this domain. Currently no literals are allowed for this domain.

	==== symbol ====		==== symbol ====