kc3-lang/kc3/doc/1_KC3/1.1_Introduction.en.md

• Show log

  Commit

• Hash : ef195ae9
  Author : Thomas de Grivel
  Date : 2024-10-14T17:14:30
  

  doc

Download

defmodule Test do
  def one = 1
  def double = fn (x) { x * 2 }
  def add = cfn Tag "tag_add" (Tag, Tag, Result)
end

ikc3> defmodule Test do
ikc3>   defstruct [x: (F32) 0.0,
ikc3>              y: (F32) 0.0]
ikc3> end
ikc3> a = %Test{}
%Test{x: (F32) 0.0,
      y: (F32) 0.0}
ikc3> a.x
(F32) 0.0
ikc3> a.y
(F32) 0.0

Source

• doc/1_KC3/1.1_Introduction.en.md

• # 1.1 Introduction
  
  KC3 is currently a programming language project, inspired by C, Elixir
  and Common Lisp. It could be described as C with Elixir modules,
  pattern matching, and a semantic object system. The idea is to plug
  modules, closures, pattern matching, a graph database and
  metaprogramming into C99 with an extremely small set of dependencies.
  
  Supported operating systems (additionnal dependencies) :
   - BSD
   - Linux (libbsd, libmd)
   - MacOS X (libmd)
   - Windows (MSys2)
  
  Supported architectures :
   - aarch64 (arm64, Apple M1, Apple M2)
   - amd64
   - i386
   - sparc64
  
  
  ## 1.1.1 Modules
  
  Everything in KC3 is in a module. A module is a namespace,
  and is named with a symbol starting with a uppercase character.
  For instance `Sym` and `Str` are valid module names.
  
  Use defmodule to define a module. Example :
  ```elixir
  defmodule Test do
    def one = 1
    def double = fn (x) { x * 2 }
    def add = cfn Tag "tag_add" (Tag, Tag, Result)
  end
  ```
  
  Each module can define a type and a module name can also be a
  type name if the corresponding module defines a type.
  
  Use defstruct to define a struct type in a module. The struct will have
  the same name as the module. Example :
  ```elixir
  ikc3> defmodule Test do
  ikc3>   defstruct [x: (F32) 0.0,
  ikc3>              y: (F32) 0.0]
  ikc3> end
  ikc3> a = %Test{}
  %Test{x: (F32) 0.0,
        y: (F32) 0.0}
  ikc3> a.x
  (F32) 0.0
  ikc3> a.y
  (F32) 0.0
  ```
  
  The module can also include definitions for constants or functions for
  operating on the module type or other types.
  
  The default module is `KC3`, which is defined as facts (triples)
  in `lib/kc3/0.1/kc3.facts`.
  
  
  ## 1.1.2 Data types
  
  Basic data types in KC3 are :
   - Strings : `Str`, e.g. `"Hello, world !"`
   - Symbols : `Sym`, e.g. `:hello` or `Hello`
   - Booleans : `Bool`, `true` or `false`
   - Numbers
     - Integers
       - Small integers
         - Signed small integers : `S8`, `S16`, `S32`, `S64`, `Sw`
         - Unsigned small integers : `U8`, `U16`, `U32`, `U64`, `Uw`
       - Large integers : `Integer`
     - Rational numbers (fractions of integers) : `Ratio`, e.g. `-2/3`
     - Floating point numbers : `F32`, `F64`, `F128`
     - Complex numbers (i = √(-1)) : `Complex`, e.g. `1 +i 2`
   - Lists : `List`, e.g. `[1, 2, 3]`
   - Tuples : `Tuple`, e.g. `{:ok, 123}`
   - Maps : `Map`, e.g. `%{id: 1, login: "dx"}`
   - Structs : e.g. `%GL.Sphere{}`
   - Quoted code : `Quote`, e.g. `quote quote 1 + 2`
   - Identifiers : `Ident`, e.g. `quote List.map`
   - Function or operator call : `Call`, e.g. `quote sqrt(1)`, `quote 1 + 2`
   - Code blocks : `Block`, e.g. `{ 1 + 2; 3 + 4 }`
   - Function : `Fn`, e.g. `fn (x) { x * 2 }`
   - C function : `Cfn`, e.g. `cfn Tag "tag_add" (Tag, Tag, Result)`
   - Unquoted code: `Unquote`, e.g. `quote 1 + unquote(x)`
   - Variables : `Var`, e.g. `?`
   - Void : `Void`, e.g. `void`
  
  ---
  
  Top : [KC3 documentation](/doc/)
  
  Previous : [1 KC3](/doc/1_KC3)
  
  Next : [1.2 Integer](1.2_Integer)
  

Download