pdk.core

contains core structures

Any

superstructure for all structures

Superstructures: none

Object

superstructure for all not primitive structures.

Primitive structure can not contain properties

Superstructures: Any

Number

superstructure for all numbers

Superstructures: Any

Integer

data type used to represent whole numbers and to store numeric values without any fractional or decimal parts. These values can be both positive and negative.

Superstructures: Number <- Any

Float

represents floating-point numbers—numbers that contain a decimal point or fractional component. It's used to store approximate real numbers, both positive and negative, with decimal precision.

Superstructures: Number <- Any

String

represents a sequence of characters, typically intended to store and manipulate text. A string can contain letters, numbers, symbols, and whitespace characters.

Superstructures: Object <- Any

Boolean

represents a value that can be either true or false. It is named after the mathematician George Boole, who developed Boolean algebra, which deals with variables that can have only two possible values: true or false.

Superstructures: Any

Date

represents a specific instant in time, with millisecond precision.

Although the Date structure is intended to reflect coordinated universal time (UTC). Nearly all modern operating systems assume that 1 day = 24 × 60 × 60 = 86400 seconds in all cases. In UTC, however, about once every year or two there is an extra second, called a "leap second." The leap second is always added as the last second of the day, and always on December 31 or June 30. For example, the last minute of the year 1995 was 61 seconds long, thanks to an added leap second. Most computer clocks are not accurate enough to be able to reflect the leap-second distinction.

Some computer standards are defined in terms of Greenwich mean time (GMT), which is equivalent to universal time (UT). GMT is the "civil" name for the standard; UT is the "scientific" name for the same standard. The distinction between UTC and UT is that UTC is based on an atomic clock and UT is based on astronomical observations, which for all practical purposes is an invisibly fine hair to split. Because the earth's rotation is not uniform (it slows down and speeds up in complicated ways), UT does not always flow uniformly. Leap seconds are introduced as needed into UTC so as to keep UTC within 0.9 seconds of UT1, which is a version of UT with certain corrections applied. There are other time and date systems as well; for example, the time scale used by the satellite-based global positioning system (GPS) is synchronized to UTC but is not adjusted for leap seconds. An interesting source of further information is the U.S. Naval Observatory, particularly the Directorate of Time at:

and their definitions of "Systems of Time" at:

In all functions used structure Date that accept or return year, month, date, hours, minutes, and seconds values, the following representations are used:

  • A year y is represented by the integer y - 1900.

  • A month is represented by an integer from 0 to 11; 0 is January, 1 is February, and so forth; thus 11 is December.

  • A date (day of month) is represented by an integer from 1 to 31 in the usual manner.

  • An hour is represented by an integer from 0 to 23. Thus, the hour from midnight to 1 a.m. is hour 0, and the hour from noon to 1 p.m. is hour 12.

  • A minute is represented by an integer from 0 to 59 in the usual manner.

  • A second is represented by an integer from 0 to 61; the values 60 and 61 occur only for leap seconds. Because of the manner in which leap seconds are currently introduced, it is extremely unlikely that two leap seconds will occur in the same minute, but this specification follows the date and time conventions for ISO C.

In all cases, arguments given to methods for these purposes need not fall within the indicated ranges; for example, a date may be specified as January 32 and is interpreted as meaning February 1.

Superstructures: Any

Byte

Is an 8-bit signed two's complement integer. It has a minimum value of -128 and a maximum value of 127 (inclusive). The byte structure can be useful for saving memory in large arrays, where the memory savings actually matters.

Superstructures: Any

Array

data structure that stores a collection of items, such as a sequence of elements, of the same type. These elements are stored in contiguous memory locations, and each element in an array is accessed by its index.

Index starts with 0. 

numbers :: Array<string>
numbers = ['A', 'B', 'C']

index of 'A' = 0
index of 'B' = 1
index of 'C' = 2

Array is a parametrized type. It means that the type of the array item should be defined explicitly.

Example of parametrization:

Stuctures:
1. Zoo
2. Animal
3. Tiger that extends Animal
4. Capybara that extends Animal

Zoo staucture has properties:
1. all_animals :: Array<Animal>
2. cat_like_animals :: Array<Tiger>

all_animals can hold Tiger and Capybara
cat_like_animals can hold only Tiger

Superstructures: Object <- Any

Map

A structure that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value.

Keys in the map can only be of type pdk.core.String

Map is a parametrized type

orders :: Map<Order> = {} // empty map

// new book order
bookOrder :: Order = {
    "id": 1,
    "price": 10.99,
    "count": 5
}

// use function call node with Map.put function
Map.put(orders, "1", bookOrder) -> 
orders = {
    "1": {
        "id": 1,
        "price": 10.99,
        "count": 5
    }
}

Superstructures: Object <- Any

MapEntry

A pdk.core.Map entry (key-value pair)

MapEntry is a parametrized type

Properties:

UserObject

base structure for all custom created structures.

Superstructures: Object <- Any

Parametrizations are a facility of generic programming. They were designed to extend type system to allow "a type or method to operate on objects of various types while providing compile-time type safety".

Previouspdk.blockchainNextpdk.ex

Last updated