Most basic classes and methods.

This module is the root of the module hierarchy. It provides a very minimal set of classes and services used as a foundation to define other classes and methods.

Introduced classes

enum Bool

core :: Bool

Native Booleans.
enum Byte

core :: Byte

Native bytes.
enum Char

core :: Char

Native characters.
interface Cloneable

core :: Cloneable

Something that can be cloned
interface Comparable

core :: Comparable

The ancestor of class where objects are in a total order.
interface Discrete

core :: Discrete

Discrete total orders.
enum Float

core :: Float

Native floating point numbers.
enum Int

core :: Int

Native integer numbers.
interface Numeric

core :: Numeric

A numeric value supporting mathematical operations
interface Object

core :: Object

The root of the class hierarchy.
extern class Pointer

core :: Pointer

Pointer classes are used to manipulate extern C structures.
class Sys

core :: Sys

The main class of the program.
interface Task

core :: Task

Task with a main method to be implemented by subclasses

All class definitions

enum Bool

core $ Bool

Native Booleans.
enum Byte

core $ Byte

Native bytes.
enum Char

core $ Char

Native characters.
interface Cloneable

core $ Cloneable

Something that can be cloned
interface Comparable

core $ Comparable

The ancestor of class where objects are in a total order.
interface Discrete

core $ Discrete

Discrete total orders.
enum Float

core $ Float

Native floating point numbers.
enum Int

core $ Int

Native integer numbers.
interface Numeric

core $ Numeric

A numeric value supporting mathematical operations
interface Object

core $ Object

The root of the class hierarchy.
extern class Pointer

core $ Pointer

Pointer classes are used to manipulate extern C structures.
class Sys

core $ Sys

The main class of the program.
interface Task

core $ Task

Task with a main method to be implemented by subclasses
package_diagram core::kernel kernel core::abstract_collection abstract_collection core::abstract_collection->core::kernel core::fixed_ints fixed_ints core::fixed_ints->core::kernel core::gc gc core::gc->core::kernel core::array array core::array->core::abstract_collection core::range range core::range->core::abstract_collection core::list list core::list->core::abstract_collection core::array... ... core::array...->core::array core::range... ... core::range...->core::range core::list... ... core::list...->core::list core::native native core::native->core::fixed_ints core::native... ... core::native...->core::native core::file file core::file->core::gc core::re re core::re->core::gc core::file... ... core::file...->core::file core::re... ... core::re...->core::re

Children

module abstract_collection

core :: abstract_collection

Abstract collection classes and services.
module fixed_ints

core :: fixed_ints

Basic integers of fixed-precision
module gc

core :: gc

Access to the Nit internal garbage collection mechanism

Descendants

module a_star

a_star :: a_star

A* pathfinding in graphs
module a_star-m

a_star-m

module abstract_text

core :: abstract_text

Abstract class for manipulation of sequences of characters
module abstract_tree

trees :: abstract_tree

Introduce tree structures abstraction
module activities

android :: activities

Android Activities wrapper
module actors

actors :: actors

Abstraction of the actors concepts
module agent_simulation

actors :: agent_simulation

a "Framework" to make Multi-Agent Simulations in Nit
module ai

ai :: ai

Simple toolkit for artificial intelligence.
module all

sdl2 :: all

Unites the main sdl2 module and its sister library sdl2::image
module android

android :: android

Android services and implementation of app.nit
module android19

gamnit :: android19

Variation using features from Android API 19
module angles

geometry :: angles

Angle related service using Float to represent an angle in radians
module api

github :: api

Nit object oriented interface to Github api.
module app

app :: app

app.nit is a framework to create cross-platform applications
module app

ios :: app

Basic structure for Nit apps on iOS
module app_base

app :: app_base

Base of the app.nit framework, defines App
module app_kit

cocoa :: app_kit

The Application Kit provides services to create GUI
module array

core :: array

This module introduces the standard array structure.
module array_debug

array_debug :: array_debug

Exposes functions to help profile or debug Arrays.
module assets

app :: assets

Portable services to load resources from the assets folder
module assets

ios :: assets

Implementation of app::assets
module assets

android :: assets

Implementation of app::assets
module assets_and_resources

android :: assets_and_resources

Android Assets and Resources Management
module at_boot

android :: at_boot

Import this module to launch Service at device boot
module attributes

sax :: attributes

Interface for a list of XML attributes.
module attributes_impl

sax :: attributes_impl

Default implementation of the Attributes interface.
module audio

ios :: audio

iOS implementation of app::audio using AVAudioPlayer
module audio

app :: audio

Services to load and play Sound and Music from the assets folder
module audio

android :: audio

Android audio services, wraps a part of android audio API
module audio

linux :: audio

app::audio implementation for GNU/Linux using SDL2 mixer
module aware

android :: aware

Android compatibility module
module backtrack

ai :: backtrack

Basic framework for active backtrack solver
module base64

base64 :: base64

Offers the base 64 encoding and decoding algorithms
module basic_ciphers

crypto :: basic_ciphers

Basic cryptographic ciphers and utilities.
module bcm2835

bcm2835 :: bcm2835

Services to control the bcm2835 chipset used in the Raspberry Pi
module binary

binary :: binary

Read and write binary data with any Reader and Writer
module bintree

trees :: bintree

Binary Tree data-structure
module bitmap

bitmap :: bitmap

The Bitmap class represents a 24-bit bitmap image. An instance can be constructed
module bitset

core :: bitset

Services to handle BitSet
module bktree

trees :: bktree

Implementation of BKTree
module bmfont

gamnit :: bmfont

Parse Angel Code BMFont format and draw text
module bootstrap

html :: bootstrap

HTML templates for Bootstrap components.
module boxes

geometry :: boxes

Provides interfaces and classes to represent basic geometry needs.
module bucketed_game

bucketed_game :: bucketed_game

Game framework with an emphasis on efficient event coordination
module bundle

android :: bundle

A mapping class of String to various value types used by the
module bytes

core :: bytes

Services for byte streams and arrays
module bytes

crypto :: bytes

Mix of utilities and services related to bytes
module c

c :: c

Structures and services for compatibility with the C language
module cache

github :: cache

Enable caching on Github API accesses.
module caching

serialization :: caching

Services for caching serialization engines
module camera_control

gamnit :: camera_control

Simple camera control for user, as the method accept_scroll_and_zoom
module camera_control_android

gamnit :: camera_control_android

Two fingers camera manipulation, pinch to zoom and slide to scroll
module camera_control_linux

gamnit :: camera_control_linux

Mouse wheel and middle mouse button to control camera
module cameras

gamnit :: cameras

Camera services producing Model-View-Projection matrices
module cameras_cache

gamnit :: cameras_cache

Cache the Matrix produced by Camera::mvp_matrix
module cardboard

android :: cardboard

Services from the Google Cardboard SDK for virtual reality on Android
module cardboard

gamnit :: cardboard

Update the orientation of world_camera at each frame using the head position given by android::cardboard
module cartesian

cartesian :: cartesian

Memory-efficient Cartesian products on heterogeneous collections.
module chameneosredux

actors :: chameneosredux

Example implemented from "The computer Language Benchmarks Game" - Chameneos-Redux
module checker

dom :: checker

Simple XML validity checker using the dom module
module circular_array

core :: circular_array

Efficient data structure to access both end of the sequence.
module client

gamnit :: client

Client-side network services for games and such
module clusters

dot :: clusters

Example from http://www.graphviz.org/content/cluster
module cocoa

cocoa :: cocoa

Cocoa API, the development layer of OS X
module cocoa_extern_types

cocoa :: cocoa_extern_types

Test extern classes from the Cocoa framework and extern factories
module cocoa_message_box

cocoa :: cocoa_message_box

Simple message box using the Cocoa framework
module codec_base

core :: codec_base

Base for codecs to use with streams
module codecs

core :: codecs

Group module for all codec-related manipulations
module collection

core :: collection

This module define several collection classes.
module collections

java :: collections

Basic Java collections
module combinations

combinations :: combinations

Memory-efficient Cartesian products, combinations and permutation on collections.
module common

gamnit :: common

Services common to the client and server modules
module commonmark_gen

markdown2 :: commonmark_gen

Generate Nitunit tests from commonmark specification.
module concurrent_array_and_barrier

pthreads :: concurrent_array_and_barrier

A basic usage example of the modules pthreads and pthreads::cocurrent_collections
module concurrent_collections

pthreads :: concurrent_collections

Introduces thread-safe concurrent collections
module config

config :: config

Configuration options for nit tools and apps
module console

console :: console

Defines some ANSI Terminal Control Escape Sequences.
module content_handler

sax :: content_handler

Receives notification of the logical content of a document.
module core

core :: core

Standard classes and methods used by default by Nit programs and libraries.
module counter

counter :: counter

Simple numerical statistical analysis and presentation
module cpp

cpp :: cpp

Services for compatibility with C++ code and libraries
module crapto

crapto :: crapto

Cryptographic attacks and utilities.
module crypto

crypto :: crypto

Mix of all things cryptography-related
module csv

csv :: csv

CSV document handling.
module curl

curl :: curl

Data transfer powered by the native curl library
module curl_http

curl :: curl_http

Example use of the Curl module
module curl_json

neo4j :: curl_json

cURL requests compatible with the JSON REST APIs.
module curl_rest

curl :: curl_rest

module curses

curses :: curses

Curses for Nit
module custom_serialization

serialization :: custom_serialization

Example of an ad hoc serializer that is tailored to transform business specific objects into customized representation.
module dalvik

android :: dalvik

Java related services specific to Android and its Dalvik VM
module data_store

android :: data_store

Implements app::data_store using shared_preferences
module data_store

app :: data_store

Key/value storage services
module data_store

ios :: data_store

Implements app::data_store using NSUserDefaults
module data_store

linux :: data_store

app::data_store implementation on GNU/Linux
module date

date :: date

Services to manipulate Date, Time and DateTime
module decl_handler

sax :: decl_handler

SAX2 extension handler for DTD declaration events.
module decorators

markdown :: decorators

Decorators for markdown parsing.
module depth

gamnit :: depth

Framework for 3D games in Nit
module depth_core

gamnit :: depth_core

Base entities of the depth 3D game framework
module deriving

deriving :: deriving

Automatic derivable implementations of standard basic methods.
module digraph

graph :: digraph

Implementation of directed graphs, also called digraphs.
module display

gamnit :: display

Abstract display services
module display_android

gamnit :: display_android

Gamnit display implementation for Android
module display_ios

gamnit :: display_ios

Gamnit display implementation for iOS
module display_linux

gamnit :: display_linux

Gamnit display implementation for GNU/Linux using egl, sdl and x11
module dom

dom :: dom

Easy XML DOM parser
module dot

dot :: dot

Dot rendering library
module drop_privileges

privileges :: drop_privileges

Example using the privileges module to drop privileges from root
module dtd_handler

sax :: dtd_handler

Receives notification of basic DTD-related events.
module dynamic

json :: dynamic

Dynamic interface to read values from JSON strings
module dynamic_resolution

gamnit :: dynamic_resolution

Virtual screen with a resolution independent from the real screen
module egl

egl :: egl

Interface between rendering APIs (OpenGL, OpenGL ES, etc.) and the native windowing system.
module egl

gamnit :: egl

Use of EGL to implement Gamnit on GNU/Linux and Android
module emscripten

emscripten :: emscripten

Platform for the emscripten framework
module engine_tools

serialization :: engine_tools

Advanced services for serialization engines
module english_utils

crapto :: english_utils

English language utilities for cryptographic purposes.
module entity_resolver

sax :: entity_resolver

Basic interface for resolving entities.
module environ

core :: environ

Access to the environment variables of the process
module error

neo4j :: error

Errors thrown by the neo4j library.
module error

core :: error

Standard error-management infrastructure.
module error

json :: error

Intro JsonParseError which is exposed by all JSON reading APIs
module error_handler

sax :: error_handler

Basic interface for SAX error handlers.
module event_queue

event_queue :: event_queue

Register, update and discard events in a timeline.
module events

sdl2 :: events

SDL 2 events and related services
module events

github :: events

Events are emitted by Github Hooks.
module example_angular

popcorn :: example_angular

This is an example of how to use angular.js with popcorn
module example_vsm

vsm :: example_vsm

Example using a FileIndex
module exec

core :: exec

Invocation and management of operating system sub-processes.
module ext

posix :: ext

Services not defined in POSIX but provided by most implementations
module ext

sax :: ext

Interfaces to optional SAX2 handlers.
module ext

msgpack :: ext

Application specific MessagePack extension MsgPackExt
module extra

pthreads :: extra

Offers some POSIX threads services that are not available on all platforms
module extra

curl :: extra

Shortcut services for scripts: http_get and http_download
module fannkuchredux

actors :: fannkuchredux

Example implemented from "The computer Language Benchmarks Game" - Fannkuch-Redux
module fca

fca :: fca

Formal Concept Analysis
module ffi_support

java :: ffi_support

Core supporting services for the FFI with Java
module file

core :: file

File manipulations (create, read, write, etc.)
module file_server

nitcorn :: file_server

Provides the FileServer action, which is a standard and minimal file server
module fixed_ints_text

core :: fixed_ints_text

Text services to complement fixed_ints
module flat

gamnit :: flat

Simple API for 2D games, built around Sprite and App::update
module flat

core :: flat

All the array-based text representations
module flat_core

gamnit :: flat_core

Core services for the flat API for 2D games
module font

gamnit :: font

Abstract font drawing services, implemented by bmfont and tileset
module for_abuse

for_abuse :: for_abuse

Service management through the for control structure.
module foundation

cocoa :: foundation

The Foundation Kit provides basic Objective-C classes and structures
module functional

functional :: functional

Functional types and functional API for Iterator
module functional_gen

functional :: functional_gen

This module is only used to generate functional_types.nit
module functional_types

functional :: functional_types

This module provides functional type to represents various function forms.
module game

android :: game

Android services and implementation of app.nit for gamnit and mnit
module gamepad

android :: gamepad

Support for gamepad events (over Bluetooth or USB)
module gamnit

gamnit :: gamnit

Game and multimedia framework for Nit
module gamnit_android

gamnit :: gamnit_android

Support services for Gamnit on Android
module gamnit_ios

gamnit :: gamnit_ios

Support services for gamnit on iOS
module gamnit_linux

gamnit :: gamnit_linux

Support services for Gamnit on GNU/Linux
module gdk

gtk :: gdk

Services from GDK
module gdk_enums

gtk :: gdk_enums

module gen_nit

gen_nit :: gen_nit

Support to generate and otherwise manipulate Nit code
module geometry

geometry :: geometry

Provides interfaces and classes to represent basic geometry needs.
module gettext

gettext :: gettext

Internationalization of Strings using gettext library
module github

github :: github

Nit wrapper for Github API
module glesv2

glesv2 :: glesv2

OpenGL graphics rendering library for embedded systems, version 2.0
module glkit

ios :: glkit

GLKit services to create an OpenGL ES context on iOS
module gmp

gmp :: gmp

Multi precision integer and rational number using gmp lib
module graph

neo4j :: graph

Provides an interface for services on a Neo4j graphs.
module gtk

gtk :: gtk

GTK+ widgets and services
module gtk_core

gtk :: gtk_core

Classes and services to use libGTK widgets
module gtk_enums

gtk :: gtk_enums

module hash_collection

core :: hash_collection

Introduce HashMap and HashSet.
module hash_debug

hash_debug :: hash_debug

Inject behavior analysis to hash-collections (HashMap, HashSet, etc.)
module hello

dot :: hello

Example from http://www.graphviz.org/content/hello
module hello_cocoa

cocoa :: hello_cocoa

Hello world using the Cocoa framework
module hello_ios

ios :: hello_ios

Simple iOS app with a single label
module helpers

sax :: helpers

Contains "helper" classes, including support for bootstrapping SAX-based applications.
module hooks

github :: hooks

Github hook event listening with nitcorn.
module htcpcp_server

nitcorn :: htcpcp_server

A server that implements HTCPCP. At the moment there are no additions.
module html

html :: html

HTML output facilities
module html_page

html :: html_page

module http_errors

nitcorn :: http_errors

Offers ErrorTemplate to display error pages
module http_request

nitcorn :: http_request

Provides the HttpRequest class and services to create it
module http_request

app :: http_request

HTTP request services: AsyncHttpRequest and Text::http_get
module http_request

ios :: http_request

Implementation of app::http_request for iOS
module http_request

linux :: http_request

Implementation of app::http_request using GDK and Curl
module http_request

android :: http_request

Android implementation of app:http_request
module http_request_buffer

nitcorn :: http_request_buffer

Http request parsing for buffered inputs.
module http_request_example

app :: http_request_example

Example for the app::http_request main service AsyncHttpRequest
module http_response

nitcorn :: http_response

Provides the HttpResponse class and http_status_codes
module image

sdl2 :: image

Services of the SDL_image 2.0 library
module ini

ini :: ini

Read and write INI configuration files
module input

mnit :: input

Defines abstract classes for user and general inputs to the application.
module input

bcm2835 :: input

module input_events

android :: input_events

Pointer and hardware key events
module input_ios

gamnit :: input_ios

Gamnit event support for iOS
module input_source

sax :: input_source

A single input source for an XML entity.
module inspect

serialization :: inspect

Refine Serializable::inspect to show more useful information
module intent

android :: intent

Services allowing to launch activities and start/stop services using
module intent_api10

android :: intent_api10

Services allowing to launch activities and start/stop services using
module intent_api11

android :: intent_api11

Refines intent module to add API 11 services
module intent_api12

android :: intent_api12

Refines intent module to add API 12 services
module intent_api14

android :: intent_api14

Refines intent module to add API 14 services
module intent_api15

android :: intent_api15

Refines intent module to add API 15 services
module intent_api16

android :: intent_api16

Refines intent module to add API 16 services
module intent_api17

android :: intent_api17

Refines intent module to add API 17 services
module intent_api18

android :: intent_api18

Refines intent module to add API 18 services
module intent_api19

android :: intent_api19

Refines intent module to add API 19 services
module io

java :: io

Services from the java.io package
module ios

ios :: ios

iOS platform support
module iso8859_1

core :: iso8859_1

Codec for ISO8859-1 I/O
module iter_extras

functional :: iter_extras

This modules provides a new functional interface for Iterator.
module java

java :: java

Supporting services for the FFI with Java and to access Java libraries
module jointask_example

pthreads :: jointask_example

Simple example of joinable task using threadpool
module json

json :: json

Read and write JSON formatted text using the standard serialization services
module json_graph_store

neo4j :: json_graph_store

Provides JSON as a mean to store graphs.
module jvm

jvm :: jvm

Java Virtual Machine invocation API and others services from the JNI C API
module keys

gamnit :: keys

Simple service keeping track of which keys are currently pressed
module landscape

android :: landscape

Lock the application in the landscape orientation
module landscape

gamnit :: landscape

Lock the application in the landscape orientation
module langannot

gettext :: langannot

Sample module showing the use of the i18n annotation
module lexer

saxophonit :: lexer

SAXophoNit’s lexer
module lexical_handler

sax :: lexical_handler

SAX2 extension handler for lexical events.
module lexpr

logic :: lexpr

Logical expression.
module libevent

libevent :: libevent

Low-level wrapper around the libevent library to manage events on file descriptors
module libevent_example

libevent :: libevent_example

Minimal usage example of libevent
module limit_fps

gamnit :: limit_fps

Frame-rate control for applications
module linux

linux :: linux

Implementation of app.nit for the Linux platform
module list

core :: list

This module handle double linked lists
module load_image

android :: load_image

Low-level services to load pixel data from the assets
module loader

github :: loader

module log

nitcorn :: log

Services inserting a timestamp in all prints and to log each requests
module log

android :: log

Advanced Android logging services
module logger

logger :: logger

A simple logger for Nit
module logic

logic :: logic

First-order logic data structure and algorithm.
module macro

template :: macro

String templating using macros.
module man

markdown :: man

Simple groff decorator restricted for manpages.
module mandelbrot

actors :: mandelbrot

Example implemented from "The computer Language Benchmarks Game" - Mandelbrot
module markdown

markdown :: markdown

Markdown parsing.
module markdown_ast

markdown2 :: markdown_ast

Markdown AST representation
module markdown_block_parsing

markdown2 :: markdown_block_parsing

Markdown blocks parsing
module markdown_github

markdown2 :: markdown_github

Markdown Github mode
module markdown_html_rendering

markdown2 :: markdown_html_rendering

HTML rendering of Markdown documents
module markdown_inline_parsing

markdown2 :: markdown_inline_parsing

Parser for inline markdown
module markdown_latex_rendering

markdown2 :: markdown_latex_rendering

LaTeX rendering of Markdown documents
module markdown_man_rendering

markdown2 :: markdown_man_rendering

Manpages rendering of Markdown documents
module markdown_md_rendering

markdown2 :: markdown_md_rendering

Markdown rendering of Markdown documents
module markdown_rendering

markdown2 :: markdown_rendering

Markdown document rendering
module math

core :: math

Mathematical operations
module matrix

matrix :: matrix

Services for matrices of Float values
module md5

md5 :: md5

Native MD5 digest implementation as Text::md5
module media_types

nitcorn :: media_types

Services to identify Internet media types (or MIME types, Content-types)
module meta

meta :: meta

Simple user-defined meta-level to manipulate types of instances as object.
module minimal

sdl2 :: minimal

An example to test and demonstrate the sdl2 lib with image and events
module mixer

sdl2 :: mixer

SDL2 mixer with sample/sounds and music
module model_dimensions

gamnit :: model_dimensions

Dimensions related services for Model and Mesh
module model_parser_base

gamnit :: model_parser_base

Services to parse models from a text description
module mongodb

mongodb :: mongodb

MongoDB Nit Driver.
module more_collections

more_collections :: more_collections

Highly specific, but useful, collections-related classes.
module more_lights

gamnit :: more_lights

More implementations of Light
module more_materials

gamnit :: more_materials

Various material implementations
module more_meshes

gamnit :: more_meshes

More simple geometric meshes
module more_models

gamnit :: more_models

Services to load models from the assets folder
module mpd

mpd :: mpd

Music Player Daemon client library
module mpi

mpi :: mpi

Implementation of the Message Passing Interface protocol by wrapping OpenMPI
module msgpack

msgpack :: msgpack

MessagePack, an efficient binary serialization format
module msgpack_to_json

msgpack :: msgpack_to_json

Convert MessagePack format to JSON
module mtl

gamnit :: mtl

Services to parse .mtl material files
module namespace_support

sax :: namespace_support

Encapsulates Namespace logic for use by applications using SAX, or internally by SAX drivers.
module native

core :: native

Native structures for text and bytes
module native_app_glue

android :: native_app_glue

Wrapper of the Android native_app_glue framework to implement app.nit
module native_curl

curl :: native_curl

Binding of C libCurl which allow us to interact with network.
module native_gmp

gmp :: native_gmp

Low-level GMP features
module native_mongodb

mongodb :: native_mongodb

Native wrapper for the MongoDB C Driver
module native_notification

android :: native_notification

Native Java classes for notifications
module native_postgres

postgresql :: native_postgres

A native wrapper ove the postgres c api
module native_sqlite3

sqlite3 :: native_sqlite3

Low-level Sqlite3 features
module native_ui

android :: native_ui

Native services from the android.view and android.widget namespaces
module neo4j

neo4j :: neo4j

Neo4j connector through its JSON REST API using curl.
module network

gamnit :: network

Easy client/server logic for games and simple distributed applications
module nit_activity

android :: nit_activity

Core implementation of app.nit on Android using a custom Java entry point
module nitcc_runtime

nitcc_runtime :: nitcc_runtime

Runtime library required by parsers and lexers generated by nitcc
module nitcorn

nitcorn :: nitcorn

The nitcorn Web server framework creates server-side Web apps in Nit
module nitcorn_hello_world

nitcorn :: nitcorn_hello_world

Hello World Web server example
module nitcorn_reverse_proxy

nitcorn :: nitcorn_reverse_proxy

Minimal example using a ProxyAction
module niti_runtime

niti_runtime :: niti_runtime

Runtime library to loop around the main program for each line in file-name arguments
module nitmd

markdown :: nitmd

A Markdown parser for Nit.
module nitmd

markdown2 :: nitmd

A Markdown parser for Nit.
module nlp

nlp :: nlp

Natural Language Processor based on the StanfordNLP core.
module nlp_index

nlp :: nlp_index

Example showing how to use a NLPFileIndex.
module noise

noise :: noise

Noise generators PerlinNoise and InterpolatedNoise
module notification

android :: notification

Services to show notification in the Android status bar
module numeric

core :: numeric

Advanced services for Numeric types
module obj

gamnit :: obj

Services to parse .obj geometry files
module opengles2_hello_triangle

glesv2 :: opengles2_hello_triangle

Basic example of OpenGL ES 2.0 usage using SDL 2
module opts

opts :: opts

Management of options on the command line
module ordered_tree

ordered_tree :: ordered_tree

Manipulation and presentation of ordered trees.
module pagerank

graph :: pagerank

Add PageRank computation for vertices in Digraph.
module parser

dom :: parser

XML DOM-parsing facilities
module parser_base

parser_base :: parser_base

Simple base for hand-made parsers of all kinds
module particles

gamnit :: particles

Particle effects
module perfect_hashing

perfect_hashing :: perfect_hashing

Perfect hashing and perfect numbering
module performance_analysis

performance_analysis :: performance_analysis

Services to gather information on the performance of events by categories
module pipeline

pipeline :: pipeline

Pipelined filters and operations on iterators.
module platform

android :: platform

Triggers compilation for the android platform
module platform

ios :: platform

Triggers compilation for the iOS platform
module points_and_lines

geometry :: points_and_lines

Interfaces and classes to represent basic geometry needs.
module polygon

geometry :: polygon

Convex Polygons manipulations
module pop_auth

popcorn :: pop_auth

Authentification handlers.
module pop_config

popcorn :: pop_config

Configuration file and options for Popcorn apps
module pop_handlers

popcorn :: pop_handlers

Route handlers.
module pop_json

popcorn :: pop_json

Introduce useful services for JSON REST API handlers.
module pop_repos

popcorn :: pop_repos

Repositories for data management.
module pop_routes

popcorn :: pop_routes

Internal routes representation.
module pop_sessions

popcorn :: pop_sessions

Session handlers
module pop_tasks

popcorn :: pop_tasks

Popcorn threaded tasks
module pop_templates

popcorn :: pop_templates

Template rendering for popcorn
module pop_tests

popcorn :: pop_tests

Popcorn testing services
module pop_validation

popcorn :: pop_validation

Quick and easy validation framework for Json inputs
module popcorn

popcorn :: popcorn

Application server abstraction on top of nitcorn.
module portrait

android :: portrait

Config to set the portrait orientation
module portrait

gamnit :: portrait

Lock the application in the portrait orientation
module poset

poset :: poset

Pre order sets and partial order set (ie hierarchies)
module posix

posix :: posix

Services conforming to POSIX
module postgres

postgresql :: postgres

Services to manipulate a Postgres database
module privileges

privileges :: privileges

Process privileges management utilities
module programs

gamnit :: programs

Services for graphical programs with shaders, attributes and uniforms
module progression

progression :: progression

Event-based interface to track the progression of an operation.
module projection

matrix :: projection

Services on Matrix to transform and project 3D coordinates
module prompt

prompt :: prompt

Basic services to display a prompt
module protocol

core :: protocol

module proxy

nitcorn :: proxy

Provides the ProxyAction action, which redirects requests to another interface
module pthreads

pthreads :: pthreads

Main POSIX threads support and intro the classes Thread, Mutex and Barrier
module pthreads

nitcorn :: pthreads

Activate the use of pthreads with nitcorn
module puzzle

ai :: puzzle

The N-puzzle problem, modeled naively as a SearchProblem.
module quadtree

geometry :: quadtree

QuadTree API mostly used for 2 dimensional collision detection
module queens

ai :: queens

Example of the famous eight-queens problem solved with the ai::backtrack module.
module queries

mongodb :: queries

Mongo queries framework
module queue

core :: queue

Queuing data structures and wrappers
module range

core :: range

Module for range of discrete objects.
module rbtree

trees :: rbtree

A red–black tree is a data structure which is a type of self-balancing binary search tree.
module re

core :: re

Regular expression support for all services based on Pattern
module reactor

nitcorn :: reactor

Core of the nitcorn project, provides HttpFactory and Action
module read

msgpack :: read

Low-level read MessagePack format from Reader streams
module reader_model

saxophonit :: reader_model

Reader’s model.
module readline

readline :: readline

GNU readline library wrapper
module realtime

realtime :: realtime

Services to keep time of the wall clock time
module redef_collections

pthreads :: redef_collections

Redef some basic collections to be thread-safe
module restful

nitcorn :: restful

Support module for the nitrestful tool and the restful annotation
module restful_annot

nitcorn :: restful_annot

Example for the restful annotation documented at lib/nitcorn/restful.nit
module ropes

core :: ropes

Tree-based representation of a String.
module ropes_debug

ropes_debug :: ropes_debug

Exposes methods for debugging ropes when needed.
module rubix

rubix :: rubix

Rubix-cube modelization library
module safe

serialization :: safe

Services for safer deserialization engines
module sax

sax :: sax

Core SAX APIs.
module sax_locator

sax :: sax_locator

Interface for associating a SAX event with a document location.
module sax_locator_impl

sax :: sax_locator_impl

Provides an optional convenience implementation of Locator.
module sax_parse_exception

sax :: sax_parse_exception

Encapsulates an XML parse error or warning.
module saxophonit

saxophonit :: saxophonit

A SAX 2 parser in Nit.
module scene2d

scene2d :: scene2d

Framework for 2D management of game elements
module sdl2

sdl2 :: sdl2

Simple DirectMedia Layer (SDL) 2.0 services for easy window creation and 2D drawing
module sdl2_base

sdl2 :: sdl2_base

Basic SDL 2 features
module search

ai :: search

Basic framework for search problems and solver.
module selection

gamnit :: selection

Select Actor from a screen coordinate
module sendmail

sendmail :: sendmail

Send emails using the sendmail program
module sensors

android :: sensors

Access Android sensors
module sequential_id

neo4j :: sequential_id

Provides a sequential identification scheme for Neo4j nodes.
module serialization

serialization :: serialization

General serialization services
module serialization_common

msgpack :: serialization_common

Serialization services for serialization_write and serialization_read
module serialization_core

serialization :: serialization_core

Abstract services to serialize Nit objects to different formats
module serialization_read

json :: serialization_read

Services to read JSON: deserialize_json and JsonDeserializer
module serialization_read

msgpack :: serialization_read

Deserialize full Nit objects from MessagePack format
module serialization_write

json :: serialization_write

Services to write Nit objects to JSON strings: serialize_to_json and JsonSerializer
module serialization_write

msgpack :: serialization_write

Serialize full Nit objects to MessagePack format
module server

gamnit :: server

Server-side network services for games and such
module server_config

nitcorn :: server_config

Classes and services to configure the server
module service

android :: service

Android service support for app.nit centered around the class Service
module sessions

nitcorn :: sessions

Automated session management
module sexp

sexp :: sexp

S-Expression parsing facilities
module sha1

sha1 :: sha1

Provides methods to compute the SHA1 hash of a String
module shadow

gamnit :: shadow

Shadow mapping using a depth texture
module shared_preferences

android :: shared_preferences

Services allowing to save and load datas to internal android device
module shared_preferences_api10

android :: shared_preferences_api10

Services to save/load data using android.content.SharedPreferences for the android platform
module shared_preferences_api11

android :: shared_preferences_api11

Refines shared_preferences module to add API 11 services
module show_basedir

xdg_basedir :: show_basedir

Prints the local base directories as per the XDG Base Directory specification
module signal_handler

nitcorn :: signal_handler

Handle SIGINT and SIGTERM to close the server after all active events
module signals

signals :: signals

ANSI C signal handling
module simple

actors :: simple

A very simple example of the actor model
module simple_file_server

nitcorn :: simple_file_server

Basic file server on port 80 by default, may require root to execute
module simple_simulation

actors :: simple_simulation

Using agent_simulation by refining the Agent class to make
module socket

socket :: socket

Socket services
module socket_c

socket :: socket_c

Low-level socket functionalities
module socket_client

socket :: socket_client

Client sample using the Socket module which connect to the server sample.
module socket_server

socket :: socket_server

Server sample using the Socket module which allow client to connect
module socket_simple_server

socket :: socket_simple_server

Simple server example using a non-blocking TCPServer
module sorter

core :: sorter

This module contains classes used to compare things and sorts arrays.
module sqlite3

sqlite3 :: sqlite3

Services to manipulate a Sqlite3 database
module standard

standard :: standard

Old module implicitly imported by the old compiler.
module stanford

nlp :: stanford

Natural Language Processor based on the StanfordNLP core.
module static

json :: static

Static interface to read Nit objects from JSON strings
module stereoscopic_view

gamnit :: stereoscopic_view

Refine EulerCamera and App::frame_core_draw to get a stereoscopic view
module store

json :: store

Store and load json data.
module stream

core :: stream

Input and output streams of characters
module symbol

symbol :: symbol

Library for simple interning of strings
module syswm

sdl2 :: syswm

Window manager related SDL 2 services
module template

template :: template

Basic template system
module test_markdown

markdown2 :: test_markdown

Test suites for module markdown
module testing

saxophonit :: testing

Various utilities to help testing SAXophoNit (and SAX parsers in general).
module text

core :: text

All the classes and methods related to the manipulation of text entities
module text_stat

text_stat :: text_stat

Injects stat-calculating functionalities to Text and its variants
module texture_atlas_parser

gamnit :: texture_atlas_parser

Tool to parse XML texture atlas and generated Nit code to access subtextures
module textures

gamnit :: textures

Load textures, create subtextures and manage their life-cycle
module thread_ring

actors :: thread_ring

Example implemented from "The computer Language Benchmarks Game" - Thread-Ring
module threaded_example

pthreads :: threaded_example

test for threaded annotation
module threadpool

pthreads :: threadpool

Introduces a minimal ThreadPool implementation using Tasks
module threadpool_example

pthreads :: threadpool_example

Simple example using threadpool
module tileset

gamnit :: tileset

Support for TileSet, TileSetFont and drawing text with TextSprites
module time

core :: time

Management of time and dates
module toast

android :: toast

Services to display a toast, a small popup on Android
module token

nitcorn :: token

Simple generate_token service, independent of the rest of the nitcorn framework
module trees

trees :: trees

General module for tree data structures
module trie

trees :: trie

A trie (or prefix tree) is a datastructure used to perform prefix searches.
module u16_string

core :: u16_string

Wrapper of ICU's UTF-16 encoded strings and conversion
module ui

linux :: ui

Implementation of the app.nit UI module for GNU/Linux
module ui

ios :: ui

Implementation of app::ui for iOS
module ui

android :: ui

Views and services to use the Android native user interface
module ui

app :: ui

Portable UI controls for mobiles apps
module ui_example

app :: ui_example

User interface example using app::ui
module ui_test

android :: ui_test

Test for app.nit's UI services
module uikit

ios :: uikit

File generated by objcwrapper
module undirected_clusters

dot :: undirected_clusters

Example from http://www.graphviz.org/Gallery/undirected/fdpclust.html
module union_find

core :: union_find

union–find algorithm using an efficient disjoint-set data structure
module utf8

core :: utf8

Codec for UTF-8 I/O
module v3_10

gtk :: v3_10

GTK+ services added at version 3.10
module v3_4

gtk :: v3_4

module v3_6

gtk :: v3_6

GTK+ services added at version 3.6
module v3_8

gtk :: v3_8

GTK+ services added at version 3.8
module vararg_routes

nitcorn :: vararg_routes

Routes with parameters.
module vibration

android :: vibration

Vibration services for Android
module virtual_gamepad

gamnit :: virtual_gamepad

Virtual gamepad mapped to keyboard keys for quick and dirty mobile support
module vr

gamnit :: vr

VR support for gamnit depth, for Android only
module vsm

vsm :: vsm

Vector Space Model
module wallet

github :: wallet

Github OAuth tokens management
module websocket

websocket :: websocket

Adds support for a websocket connection in Nit
module websocket_server

websocket :: websocket_server

Sample module for a minimal chat server using Websockets on port 8088
module wifi

android :: wifi

Simple wrapper of the Android WiFi services
module write

msgpack :: write

Low-level write in MessagePack format to Writer streams
module x11

x11 :: x11

Services from the X11 library
module xdg_basedir

xdg_basedir :: xdg_basedir

Services for using the XDG Base Directory specification
module xml_entities

dom :: xml_entities

Basic blocks for DOM-XML representation
module xml_filter

sax :: xml_filter

Interface for an XML filter.
module xml_filter_impl

sax :: xml_filter_impl

Base class for deriving an XML filter.
module xml_reader

sax :: xml_reader

Interface for reading an XML document using callbacks.
module xor

crapto :: xor

Cryptographic attacks and utilities for XOR-based algorithms.
module xor_ciphers

crypto :: xor_ciphers

XOR oriented cryptographic ciphers and utilities.
# Most basic classes and methods.
#
# This module is the root of the module hierarchy.
# It provides a very minimal set of classes and services used as a
# foundation to define other classes and methods.
module kernel

import end # Mark this module is a top level one. (must be only one)

in "C" `{
	#include <stdlib.h>
	#include <errno.h>
`}

###############################################################################
# System Classes                                                              #
###############################################################################

# The root of the class hierarchy.
#
# Each other class implicitly specializes Object,
# therefore the services of Object are inherited by every other class and are usable
# on each value, including primitive types like integers (`Int`), strings (`String`) and arrays (`Array`).
#
# Note that `nullable Object`, not `Object`, is the root of the type hierarchy
# since the special value `null` is not considered as an instance of Object.
interface Object
	# Type of this instance, automatically specialized in every class
	#
	# A common use case of the virtual type `SELF` is to type an attribute and
	# store another instance of the same type as `self`. It can also be used as as
	# return type to a method producing a copy of `self` or returning an instance
	# expected to be the exact same type as self.
	#
	# This virtual type must be used with caution as it can hinder specialization.
	# In fact, it imposes strict restrictions on all sub-classes and their usage.
	# For example, using `SELF` as a return type of a method `foo`
	# forces all subclasses to ensure that `foo` returns the correct and updated
	# type.
	# A dangerous usage take the form of a method typed by `SELF` which creates
	# and returns a new instance.
	# If not correctly specialized, this method would break when invoked on a
	# sub-class.
	#
	# A general rule for safe usage of `SELF` is to ensure that inputs typed
	# `SELF` are stored in attributes typed `SELF` and returned by methods typed
	# `SELF`, pretty much the same things as you would do with parameter types.
	type SELF: Object

	# An internal hash code for the object based on its identity.
	#
	# Unless specific code, you should not use this method but
	# use `hash` instead.
	#
	# As its name hints it, the internal hash code, is used internally
	# to provide a hash value.
	# It is also used by the `inspect` method to loosely identify objects
	# and helps debugging.
	#
	# ~~~
	# var a = "Hello"
	# var b = a
	# assert a.object_id == b.object_id
	# ~~~
	#
	# The specific details of the internal hash code it let to the specific
	# engine. The rules are the following:
	#
	# * The `object_id` MUST be invariant for the whole life of the object.
	# * Two living instances of the same classes SHOULD NOT share the same `object_id`.
	# * Two instances of different classes MIGHT share the same `object_id`.
	# * The `object_id` of a garbage-collected instance MIGHT be reused by new instances.
	# * The `object_id` of an object MIGHT be non constant across different executions.
	#
	# For instance, the `nitc` compiler uses the address of the object in memory
	# as its `object_id`.
	#
	# TODO rename in something like `internal_hash_code`
	fun object_id: Int is intern

	# Return true if `self` and `other` have the same dynamic type.
	#
	# ~~~
	# assert 1.is_same_type(2)
	# assert "Hello".is_same_type("World")
	# assert not "Hello".is_same_type(2)
	# ~~~
	#
	# The method returns false if the dynamic type of `other` is a subtype of the dynamic type of `self`
	# (or the other way around).
	#
	# Unless specific code, you should not use this method because it is inconsistent
	# with the fact that a subclass can be used in lieu of a superclass.
	fun is_same_type(other: Object): Bool is intern

	# Return true if `self` and `other` are the same instance (i.e. same identity).
	#
	# ~~~
	# var a = new Buffer
	# var b = a
	# var c = new Buffer
	# assert a.is_same_instance(b)
	# assert not a.is_same_instance(c)
	# assert a == c # because both buffers are empty
	# ~~~
	#
	# Obviously, the identity of an object is preserved even if the object is mutated.
	#
	# ~~~
	# var x = [1]
	# var y = x
	# x.add 2
	# assert x.is_same_instance(y)
	# ~~~
	#
	# Unless specific code, you should use `==` instead of `is_same_instance` because
	# most of the time is it the semantic (and user-defined) comparison that make sense.
	#
	# Moreover, relying on `is_same_instance` on objects you do not control
	# might have unexpected effects when libraries reuse objects or intern them.
	fun is_same_instance(other: nullable Object): Bool is intern

	# Have `self` and `other` the same value?
	#
	# ~~~
	# assert 1 + 1 == 2
	# assert not 1 == "1"
	# assert 1.to_s == "1"
	# ~~~
	#
	# The exact meaning of *same value* is left to the subclasses.
	# Implicitly, the default implementation, is `is_same_instance`.
	#
	# The laws of `==` are the following:
	#
	# * reflexivity `a.is_same_instance(b) implies a == b`
	# * symmetry: `(a == b) == (b == a)`
	# * transitivity: `(a == b) and (b == c) implies (a == c)`
	#
	# `==` might not be constant on some objects overtime because of their evolution.
	#
	# ~~~
	# var a = [1]
	# var b = [1]
	# var c = [1,2]
	# assert a == b and not a == c
	# a.add 2
	# assert not a == b and a == c
	# ~~~
	#
	# Lastly, `==` is highly linked with `hash` and a specific redefinition of `==` should
	# usually be associated with a specific redefinition of `hash`.
	#
	# ENSURE `result implies self.hash == other.hash`
	fun ==(other: nullable Object): Bool do return self.is_same_instance(other)

	# Have `self` and `other` different values?
	#
	# `!=` is equivalent with `not ==`.
	fun !=(other: nullable Object): Bool do return not (self == other)

	# Display self on stdout (debug only).
	#
	# This method MUST not be used by programs, it is here for debugging
	# only and can be removed without any notice.
	#
	# TODO: rename to avoid blocking a good identifier like `output`.
	fun output
	do
		'<'.output
		object_id.output
		'>'.output
	end

	# Display class name on stdout (debug only).
	#
	# This method MUST not be used by programs, it is here for debugging
	# only and can be removed without any notice.
	#
	# TODO: rename to avoid blocking a good identifier like `output`.
	fun output_class_name is intern

	# The hash code of the object.
	#
	# The hash code is used in many data-structures and algorithms to identify objects that might be equal.
	# Therefore, the precise semantic of `hash` is highly linked with the semantic of `==`
	# and the only law of `hash` is that `a == b implies a.hash == b.hash`.
	#
	# ~~~
	# assert (1+1).hash == 2.hash
	# assert 1.to_s.hash == "1".hash
	# ~~~
	#
	# `hash` (like `==`) might not be constant on some objects over time because of their evolution.
	#
	# ~~~
	# var a = [1]
	# var b = [1]
	# var c = [1,2]
	# assert a.hash == b.hash
	# a.add 2
	# assert a.hash == c.hash
	# # There is a very high probability that `b.hash != c.hash`
	# ~~~
	#
	# A specific redefinition of `==` should usually be associated with a specific redefinition of `hash`.
	# Note that, unfortunately, a correct definition of `hash` that is lawful with `==` is sometime tricky
	# and a cause of bugs.
	#
	# Without redefinition, `hash` is based on the `object_id` of the instance.
	fun hash: Int do return object_id
end

# The main class of the program.
#
# `Sys` is a singleton class, its only instance is accessible from everywhere with `sys`.
#
# Because of this, methods that should be accessible from everywhere, like `print` or `exit`,
# are defined in `Sys`.
# Moreover, unless there is an ambiguity with `self`, the receiver of a call to these methods is implicitly `sys`.
# Basically it means that the two following instructions are equivalent.
#
# ~~~nit
# print "Hello World"
# sys.print "Hello World"
# ~~~
#
# ## Methods Implicitly Defined in Sys
#
# `Sys` is the class where are defined top-level methods,
# i.e. those defined outside of any class like in a procedural language.
# Basically it means that
#
# ~~~nitish
# redef class Sys
#    fun foo do print "hello"
# end
# ~~~
#
# is equivalent with
#
# ~~~nitish
# fun foo print "hello"
# ~~~
#
# As a corollary, in a top-level method, `self` (the current receiver) is always `sys`.
class Sys
	# The main method of a program.
	#
	# In a module, the instructions defined outside any classes or methods
	# (usually called the *main* of the module) is
	# an implicit definition of this `main` method.
	# Basically it means that the following program
	#
	# ~~~nit
	# print "Hello World"
	# ~~~
	#
	# is equivalent with
	#
	# ~~~nit
	# redef class Sys
	#    redef fun main do
	#       print "Hello World"
	#    end
	# end
	# ~~~
	fun main do end

	# The entry point for the execution of the whole program.
	#
	# When a program starts, the following implicit sequence of instructions is executed
	#
	# ~~~nitish
	# sys = new Sys
	# sys.run
	# ~~~
	#
	# Whereas the job of the `run` method is just to execute `main`.
	#
	# The only reason of the existence of `run` is to allow modules to refine it
	# and inject specific work before or after the main part.
	fun run do main

	# Number of the last error
	fun errno: Int `{ return errno; `}
end

# Quit the program with a specific return code
fun exit(exit_value: Int) is intern

# Return the global sys object, the only instance of the `Sys` class.
fun sys: Sys is intern


###############################################################################
# Abstract Classes                                                            #
###############################################################################

# The ancestor of class where objects are in a total order.
# In order to work, the method '<' has to be redefined.
interface Comparable
	# What `self` can be compared to?
	type OTHER: Comparable

	# Is `self` lesser than `other`?
	fun <(other: OTHER): Bool is abstract

	# not `other` < `self`
	# Note, the implementation must ensure that: `(x<=y) == (x<y or x==y)`
	fun <=(other: OTHER): Bool do return not other < self

	# not `self` < `other`
	# Note, the implementation must ensure that: `(x>=y) == (x>y or x==y)`
	fun >=(other: OTHER): Bool do return not self < other

	# `other` < `self`
	fun >(other: OTHER): Bool do return other < self

	# -1 if <, +1 if > and 0 otherwise
	# Note, the implementation must ensure that: (x<=>y == 0) == (x==y)
	fun <=>(other: OTHER): Int
	do
		if self < other then
			return -1
		else if other < self then
			return 1
		else
			return 0
		end
	end

	# c <= self <= d
	fun is_between(c: OTHER, d: OTHER): Bool
	do
		return c <= self and self <= d
	end

	# The maximum between `self` and `other` (prefers `self` if equals).
	fun max(other: OTHER): OTHER
	do
		if self < other then
			return other
		else
			return self
		end
	end

	# The minimum between `self` and `c` (prefer `self` if equals)
	fun min(c: OTHER): OTHER
	do
		if c < self then
			return c
		else
			return self
		end
	end
end

# Discrete total orders.
interface Discrete
	super Comparable

	redef type OTHER: Discrete

	# The next element.
	fun successor(i: Int): OTHER is abstract

	# The previous element.
	fun predecessor(i: Int): OTHER is abstract

	# The distance between self and d.
	#
	#     assert 10.distance(15)	     ==  5
	#     assert 'Z'.distance('A')	     ==  25
	fun distance(d: OTHER): Int
	do
		var cursor: OTHER
		var stop: OTHER
		if self < d then
			cursor = self
			stop = d
		else if self > d then
			cursor = d
			stop = self
		else
			return 0
		end

		var nb = 0
		while cursor < stop do
			cursor = cursor.successor(1)
			nb += 1
		end
		return nb
	end
end

# Something that can be cloned
#
# This interface introduces the `clone` method used to duplicate an instance
# Its specific semantic is left to the subclasses.
interface Cloneable
	# Duplicate `self`
	#
	# The specific semantic of this method is left to the subclasses;
	# Especially, if (and how) attributes are cloned (depth vs. shallow).
	#
	# As a rule of thumb, the principle of least astonishment should
	# be used to guide the semantic.
	#
	# Note that as the returned clone depends on the semantic,
	# the `==` method, if redefined, should ensure the equality
	# between an object and its clone.
	fun clone: SELF is abstract
end

# A numeric value supporting mathematical operations
interface Numeric
	super Comparable

	redef type OTHER: Numeric

	# Addition of `self` with `i`
	fun +(i: OTHER): OTHER is abstract

	# Substraction of `i` from `self`
	fun -(i: OTHER): OTHER is abstract

	# Inverse of `self`
	fun -: OTHER is abstract

	# Multiplication of `self` with `i`
	fun *(i: OTHER): OTHER is abstract

	# Division of `self` with `i`
	fun /(i: OTHER): OTHER is abstract

	# The integer part of `self`.
	#
	#     assert (0.0).to_i      == 0
	#     assert (0.9).to_i      == 0
	#     assert (-0.9).to_i     == 0
	#     assert (9.9).to_i      == 9
	#     assert (-9.9).to_i     == -9
	fun to_i: Int is abstract

	# The float equivalent of `self`
	#
	#     assert 5.to_f         == 5.0
	#     assert 5.to_f         != 5 # Float and Int are not equals
	fun to_f: Float is abstract

	# The byte equivalent of `self`
	#
	#     assert (-1).to_b == 0xFF.to_b
	#     assert (1.9).to_b == 1.to_b
	fun to_b: Byte is abstract

	# Is this the value of zero in its domain?
	fun is_zero: Bool do return self == zero

	# The value of zero in the domain of `self`
	fun zero: OTHER is abstract

	# The value of `val` in the domain of `self`
	#
	#     assert 1.0.value_of(2) == 2.0
	#     assert 1.0.value_of(2.0) == 2.0
	#     assert 1.value_of(2) == 2
	#     assert 1.value_of(2.0) == 2
	fun value_of(val: Numeric): OTHER is abstract
end

###############################################################################
# Native classes                                                              #
###############################################################################

# Native Booleans.
# `true` and `false` are the only instances.
#
# Boolean are manipulated trough three special operators:
# `and`, `or`, `not`.
#
# Booleans are mainly used by conditional statement and loops.
universal Bool
	redef fun object_id is intern
	redef fun ==(b) is intern
	redef fun !=(b) is intern
	redef fun output is intern
	redef fun hash do return to_i

	# 1 if true and 0 if false
	fun to_i: Int
	do
		if self then
			return 1
		else
			return 0
		end
	end
end

# Native floating point numbers.
# Corresponds to C float.
universal Float
	super Numeric

	redef type OTHER: Float

	redef fun object_id is intern
	redef fun ==(i) is intern
	redef fun !=(i) is intern
	redef fun output is intern

	redef fun <=(i) is intern
	redef fun <(i) is intern
	redef fun >=(i) is intern
	redef fun >(i) is intern

	redef fun +(i) is intern
	redef fun - is intern
	redef fun -(i) is intern
	redef fun *(i) is intern
	redef fun /(i) is intern

	redef fun to_i is intern
	redef fun to_f do return self
	redef fun to_b is intern

	redef fun zero do return 0.0
	redef fun value_of(val) do return val.to_f

	redef fun <=>(other)
	do
		if self < other then
			return -1
		else if other < self then
			return 1
		else
			return 0
		end
	end

	redef fun is_between(c, d)
	do
		if self < c or d < self then
			return false
		else
			return true
		end
	end

	# Compare float numbers with a given precision.
	#
	# Because of the loss of precision in floating numbers,
	# the `==` method is often not the best way to compare them.
	#
	# ~~~
	# assert 0.01.is_approx(0.02, 0.1)   == true
	# assert 0.01.is_approx(0.02, 0.001) == false
	# ~~~
	fun is_approx(other, precision: Float): Bool
	do
		assert precision >= 0.0
		return self <= other + precision and self >= other - precision
	end

	redef fun max(other)
	do
		if self < other then
			return other
		else
			return self
		end
	end

	redef fun min(c)
	do
		if c < self then
			return c
		else
			return self
		end
	end
end

# Native bytes.
# Same as a C `unsigned char`
universal Byte
	super Discrete
	super Numeric

	redef type OTHER: Byte

	redef fun successor(i) do return self + i.to_b
	redef fun predecessor(i) do return self - i.to_b

	redef fun object_id is intern
	redef fun hash do return self.to_i
	redef fun ==(i) is intern
	redef fun !=(i) is intern
	redef fun output is intern

	redef fun <=(i) is intern
	redef fun <(i) is intern
	redef fun >=(i) is intern
	redef fun >(i) is intern
	redef fun +(i) is intern

	# On an Byte, unary minus will return `(256 - self) % 256`
	#
	#     assert -1u8 == 0xFFu8
	#     assert -0u8 == 0x00u8
	redef fun - is intern
	redef fun -(i) is intern
	redef fun *(i) is intern
	redef fun /(i) is intern

	# Modulo of `self` with `i`.
	#
	# Finds the remainder of division of `self` by `i`.
	#
	#     assert 5u8 % 2u8		== 1u8
	#     assert 10u8 % 2u8		== 0u8
	fun %(i: Byte): Byte is intern

	redef fun zero do return 0.to_b
	redef fun value_of(val) do return val.to_b

	# `i` bits shift fo the left
	#
	#     assert 5u8 << 1    == 10u8
	fun <<(i: Int): Byte is intern `{ return self << i; `}

	# `i` bits shift fo the right
	#
	#     assert 5u8 >> 1    == 2u8
	fun >>(i: Int): Byte is intern `{ return self >> i; `}

	redef fun to_i is intern
	redef fun to_f is intern
	redef fun to_b do return self

	redef fun distance(i) do return (self - i).to_i

	redef fun <=>(other)
	do
		if self < other then
			return -1
		else if other < self then
			return 1
		else
			return 0
		end
	end

	redef fun is_between(c, d)
	do
		if self < c or d < self then
			return false
		else
			return true
		end
	end

	redef fun max(other)
	do
		if self < other then
			return other
		else
			return self
		end
	end

	redef fun min(c)
	do
		if c < self then
			return c
		else
			return self
		end
	end

	# Is `self` an ASCII whitespace ?
	fun is_whitespace: Bool do return self == 0x7Fu8 or self <= 0x20u8
end

# Native integer numbers.
# Correspond to C int.
universal Int
	super Discrete
	super Numeric

	redef type OTHER: Int

	redef fun successor(i) do return self + i
	redef fun predecessor(i) do return self - i

	redef fun object_id is intern
	redef fun hash do return self
	redef fun ==(i) is intern
	redef fun !=(i) is intern
	redef fun output is intern

	redef fun <=(i) is intern
	redef fun <(i) is intern
	redef fun >=(i) is intern
	redef fun >(i) is intern
	redef fun +(i) is intern

	redef fun - is intern
	redef fun -(i) is intern
	redef fun *(i) is intern
	redef fun /(i) is intern

	# Modulo of `self` with `i`.
	#
	# Finds the remainder of division of `self` by `i`.
	#
	#     assert 5 % 2			== 1
	#     assert 10 % 2			== 0
	fun %(i: Int): Int is intern

	redef fun zero do return 0
	redef fun value_of(val) do return val.to_i

	# `i` bits shift fo the left
	#
	#     assert 5 << 1    == 10
	fun <<(i: Int): Int is intern `{ return self << i; `}

	# `i` bits shift fo the right
	#
	#     assert 5 >> 1    == 2
	fun >>(i: Int): Int is intern `{ return self >> i; `}

	redef fun to_i do return self
	redef fun to_f is intern
	redef fun to_b is intern

	redef fun distance(i)
	do
		var d = self - i
		if d >= 0 then
			return d
		else
			return -d
		end
	end

	redef fun <=>(other)
	do
		if self < other then
			return -1
		else if other < self then
			return 1
		else
			return 0
		end
	end

	redef fun is_between(c, d)
	do
		if self < c or d < self then
			return false
		else
			return true
		end
	end

	redef fun max(other)
	do
		if self < other then
			return other
		else
			return self
		end
	end

	redef fun min(c)
	do
		if c < self then
			return c
		else
			return self
		end
	end

	# The character which code point (unicode-wise) is `self`
	#
	#     assert 65.code_point == 'A'
	#     assert 10.code_point == '\n'
	#     assert 0x220B.code_point == '∋'
	fun code_point: Char is intern `{ return (uint32_t)self; `}

	# Number of digits of an integer in base `b` (plus one if negative)
	#
	#     assert 123.digit_count(10) == 3
	#     assert 123.digit_count(2) == 7 # 1111011 in binary
	fun digit_count(b: Int): Int
	do
		if b == 10 then return digit_count_base_10
		var d: Int # number of digits
		var n: Int # current number
		# Sign
		if self < 0 then
			d = 1
			n = - self
		else if self == 0 then
			return 1
		else
			d = 0
			n = self
		end
		# count digits
		while n > 0 do
			d += 1
			n = n / b	# euclidian division /
		end
		return d
	end

	# Optimized version for base 10
	fun digit_count_base_10: Int
	do
		var val: Int
		var result: Int
		if self < 0 then
			result = 2
			val = -self
		else
			result = 1
			val = self
		end
		loop
			if val < 10 then return result
			if val < 100 then return result+1
			if val < 1000 then return result+2
			if val < 10000 then return result+3
			val = val / 10000
			result += 4
		end
	end

	# Return the corresponding digit character
	# If 0 <= `self` <= 9, return the corresponding character.
	#
	#     assert 5.to_c    == '5'
	#
	# If 10 <= `self` <= 36, return the corresponding letter [a..z].
	#
	#     assert 15.to_c   == 'f'
	fun to_c: Char
	do
		assert self >= 0 and self <= 36 # TODO plan for this
		if self < 10 then
			return (self + '0'.code_point).code_point
		else
			return (self - 10 + 'a'.code_point).code_point
		end
	end

	# The absolute value of self
	#
	#     assert (-10).abs   == 10
	#     assert 10.abs    == 10
	#     assert 0.abs     == 0
	fun abs: Int do return if self >= 0 then self else -self

	# Is `self` an ASCII whitespace ?
	fun is_whitespace: Bool do return self == 0x7F or self <= 0x20
end

# Native characters.
# Characters are denoted with simple quote.
# eg. `'a'` or `'\n'`.
universal Char
	super Discrete
	redef type OTHER: Char

	redef fun object_id is intern
	redef fun output `{
		if(self < 128){
			printf("%c", self);
		}else if(self < 2048){
			printf("%c%c", 0xC0 | ((0x7C0 & self) >> 6), 0x80 | (0x3F & self));
		}else if(self < 65536){
			printf("%c%c%c", 0xE0 | ((0xF000 & self) >> 12), 0x80 | ((0xFC0 & self) >> 6) ,0x80 | (0x3F & self));
		}else if(self < 2097152){
			printf("%c%c%c%c", 0xF0 | ((0x1C0000 & self) >> 18), 0x80 | ((0x3F000 & self) >> 12), 0x80 | ((0xFC0 & self) >> 6), 0x80 | (0x3F & self));
		}else{
			// Bad char
			printf("%c", self);
		}
	`}
	redef fun hash do return code_point
	redef fun ==(o) is intern
	redef fun !=(o) is intern

	redef fun <=(i) is intern
	redef fun <(i) is intern
	redef fun >=(i) is intern
	redef fun >(i) is intern

	redef fun successor(i) is intern
	redef fun predecessor(i) is intern

	# The `i`-th char after self (in code point)
	#
	# ~~~
	# assert 'A' + 5 == 'F'
	# ~~~
	#
	# Alias of `successor`.
	fun +(i: Int): Char do return successor(i)

	# The `i`-th char before self (in code point)
	#
	# ~~~
	# assert 'F' - 5 == 'A'
	# ~~~
	#
	# Alias of `predecessor`.
	fun -(i: Int): Char do return predecessor(i)

	redef fun distance(c)
	do
		var d = self.code_point - c.code_point
		if d >= 0 then
			return d
		else
			return -d
		end
	end

	# If `self` is a digit then return this digit else return -1.
	#
	#     assert '5'.to_i    == 5
	fun to_i: Int
	do

		if self == '-' then
			return -1
		else if is_digit then
			return self.code_point - '0'.code_point
		else
			return self.to_lower.code_point - 'a'.code_point + 10
		end
	end

	# The unicode code point value of `self`
	#
	#     assert 'A'.code_point == 65
	#     assert '\n'.code_point == 10
	#     assert '∋'.code_point == 0x220B
	fun code_point: Int is intern `{ return (long)self; `}

	# Is `self` an ASCII character ?
	#
	#     assert 'x'.is_ascii
	#     assert not 'ま'.is_ascii
	fun is_ascii: Bool do return code_point <= 127

	# Return the lower case version of self.
	# If self is not a letter, then return self
	#
	#     assert 'A'.to_lower  == 'a'
	#     assert 'a'.to_lower  == 'a'
	#     assert '$'.to_lower  == '$'
	fun to_lower: Char
	do
		if is_upper then
			return (code_point + ('a'.distance('A'))).code_point
		else
			return self
		end
	end

	# Return the upper case version of self.
	# If self is not a letter, then return self
	#
	#     assert 'a'.to_upper  == 'A'
	#     assert 'A'.to_upper  == 'A'
	#     assert '$'.to_upper  == '$'
	fun to_upper: Char
	do
		if is_lower then
			return (code_point - ('a'.distance('A'))).code_point
		else
			return self
		end
	end

	# Is self a digit? (from '0' to '9')
	#
	#     assert '0'.is_digit   == true
	#     assert '9'.is_digit   == true
	#     assert 'a'.is_digit   == false
	fun is_digit : Bool
	do
		return self >= '0' and self <= '9'
	end

	# Is self a lower case letter? (from 'a' to 'z')
	#
	#     assert 'a'.is_lower   == true
	#     assert 'z'.is_lower   == true
	#     assert 'A'.is_lower   == false
	#     assert '$'.is_lower   == false
	fun is_lower : Bool
	do
		return self >= 'a' and self <= 'z'
	end

	# Is self a upper case letter? (from 'A' to 'Z')
	#
	#     assert 'A'.is_upper   == true
	#     assert 'A'.is_upper   == true
	#     assert 'z'.is_upper   == false
	#     assert '$'.is_upper   == false
	fun is_upper : Bool
	do
		return self >= 'A' and self <= 'Z'
	end

	# Is self a letter? (from 'A' to 'Z' and 'a' to 'z')
	#
	#     assert 'A'.is_letter  == true
	#     assert 'A'.is_letter  == true
	#     assert 'z'.is_letter  == true
	#     assert '$'.is_letter  == false
	fun is_letter : Bool
	do
		return is_lower or is_upper
	end

	# Is self a whitespace character?
	#
	# These correspond to the "Other" and "Separator" groups of the Unicode.
	#
	# In the ASCII encoding, this is those <= to space (0x20) plus delete (0x7F).
	#
	#     assert 'A'.is_whitespace  == false
	#     assert ','.is_whitespace  == false
	#     assert ' '.is_whitespace  == true # space
	#     assert ' '.is_whitespace  == true # non-breaking space
	#     assert '\t'.is_whitespace == true
	fun is_whitespace: Bool
	do
		var i = code_point
		return i <= 0x20 or i == 0x7F or i == 0xA0
	end
end

# Pointer classes are used to manipulate extern C structures.
extern class Pointer
	# C `NULL` pointer
	new nul `{ return NULL; `}

	# Is the address behind this Object at NULL?
	fun address_is_null: Bool `{ return self == NULL; `}

	# Free the memory pointed by this pointer
	fun free `{ free(self); `}

	# Use the address value
	redef fun hash `{ return (long)(intptr_t)self; `}

	# Is equal to any instance pointing to the same address
	redef fun ==(o) do return o isa Pointer and native_equals(o)
	private fun native_equals(o: Pointer): Bool `{ return self == o; `}
end

# Task with a `main` method to be implemented by subclasses
#
# This class is provided for compatibility between different parallelization systems.
# It can be used to run a fragment of code on a different thread and
# to register a reaction to UI events.
interface Task

	# Main method of this task
	fun main do end
end

# Is this program currently running in a Windows OS?
fun is_windows: Bool `{
#ifdef _WIN32
	return 1;
#else
	return 0;
#endif
`}
lib/core/kernel.nit:14,1--1106,2