kc3-lang/kc3/test/httpd/doc/1_KC3/1.21_Struct.en.md

Branch - branch -masterpdfv0.1configurefnfractionsfractions-rebaselinuxratio-rebase- tag -v0.1.9v0.1.8v0.1.7v0.1.6v0.1.5v0.1.4v0.1.3v0.1.2v0.1.15v0.1.14v0.1.13v0.1.12v0.1.11v0.1.10v0.1.1v0.1.0v0HTTPd-v0.2.0HTTPd-v0.1.1HTTPd-v0.1.0

• Show log

  Commit

• Hash : 6244fe3b
  Author : Thomas de Grivel
  Date : 2025-10-21T18:32:49
  

  Make doc
  

Download

ikc3> a = %KC3.Op{sym: :dot,
                  precedence: 10,
                  callable: fn (a, b) { a.x * b.y + a.y * b.y }}
%KC3.Op{sym: :dot,
        arity: 2,
        special: false,
        precedence: 10,
        associativity: 1,
        callable: fn (a, b) { a.x * b.y + a.y * b.y }}

defmodule Vec2D do

  defstruct [x: 0.0,
             y: 0.0]

end

ikc3> %KC3.Op{sym: sym} = ^ a
%KC3.Op{sym: :dot,
        arity: 2,
        special: false,
        precedence: 10,
        associativity: 1,
        callable: fn (a, b) { a.x * b.y + a.y * b.y }}
ikc3> sym
:dot

ikc3> a = %KC3.Op{sym: :dot,
                  precedence: 10,
                  callable: fn (a, b) { a.x * b.y + a.y * b.y }}
%KC3.Op{sym: :dot,
        arity: 2,
        special: false,
        precedence: 10,
        associativity: 1,
        callable: fn (a, b) { a.x * b.y + a.y * b.y }}
ikc3> a.sym
:dot
ikc3> a.arity
2
ikc3> a.callable
fn (a, b) { a.x * b.y + a.y * b.y }

ikc3> a[:sym]
:dot
ikc3> a[:arity]
2
ikc3> a[:callable]
fn (a, b) { a.x * b.y + a.y * b.y }

ikc3> a = %KC3.Op{sym: :dot,
                  precedence: 10,
                  callable: fn (a, b) { a.x * b.y + a.y * b.y }}
%KC3.Op{sym: :dot,
        arity: 2,
        special: false,
        precedence: 10,
        associativity: 1,
        callable: fn (a, b) { a.x * b.y + a.y * b.y }}
ikc3> access(a, [:sym])
:dot
ikc3> access(a, [:arity])
2
ikc3> access(a, [:callable])
fn (a, b) { a.x * b.y + a.y * b.y }

ikc3> a = %KC3.Op{sym: :dot,
                  precedence: 10,
                  callable: fn (a, b) { a.x * b.y + a.y * b.y }}
%KC3.Op{sym: :dot,
        arity: 2,
        special: false,
        precedence: 10,
        associativity: 1,
        callable: fn (a, b) { a.x * b.y + a.y * b.y }}
b = Struct.put(a, :sym, :·)
%KC3.Op{sym: :·,
        arity: 2,
        special: false,
        precedence: 10,
        associativity: 1,
        callable: fn (a, b) { a.x * b.y + a.y * b.y }}

Source

• test/httpd/doc/1_KC3/1.21_Struct.en.md

• # 1.21 Struct
  
  KC3 structs are a key value associative data structure with default
  values and arbitrary property order.
  
  They are compatible with C structs of the same type.
  
  ```elixir
  ikc3> a = %KC3.Op{sym: :dot,
                    precedence: 10,
                    callable: fn (a, b) { a.x * b.y + a.y * b.y }}
  %KC3.Op{sym: :dot,
          arity: 2,
          special: false,
          precedence: 10,
          associativity: 1,
          callable: fn (a, b) { a.x * b.y + a.y * b.y }}
  ```
  
  You can define one _struct type_ per module with `defstruct` for
  example in `vec2d.kc3` :
  
  ```elixir
  defmodule Vec2D do
  
    defstruct [x: 0.0,
               y: 0.0]
  
  end
  ```
  
  Destructuring works with structs to extract values :
  
  ```elixir
  ikc3> %KC3.Op{sym: sym} = ^ a
  %KC3.Op{sym: :dot,
          arity: 2,
          special: false,
          precedence: 10,
          associativity: 1,
          callable: fn (a, b) { a.x * b.y + a.y * b.y }}
  ikc3> sym
  :dot
  ```
  
  You can use the dot syntax to access struct values from a `Sym` key :
  
  ```elixir
  ikc3> a = %KC3.Op{sym: :dot,
                    precedence: 10,
                    callable: fn (a, b) { a.x * b.y + a.y * b.y }}
  %KC3.Op{sym: :dot,
          arity: 2,
          special: false,
          precedence: 10,
          associativity: 1,
          callable: fn (a, b) { a.x * b.y + a.y * b.y }}
  ikc3> a.sym
  :dot
  ikc3> a.arity
  2
  ikc3> a.callable
  fn (a, b) { a.x * b.y + a.y * b.y }
  ```
  
  The bracket syntax allows you to query structs the same as maps :
  
  ```elixir
  ikc3> a[:sym]
  :dot
  ikc3> a[:arity]
  2
  ikc3> a[:callable]
  fn (a, b) { a.x * b.y + a.y * b.y }
  ```
  
  You can also use the `KC3.access` function for the same result :
  
  ```elixir
  ikc3> a = %KC3.Op{sym: :dot,
                    precedence: 10,
                    callable: fn (a, b) { a.x * b.y + a.y * b.y }}
  %KC3.Op{sym: :dot,
          arity: 2,
          special: false,
          precedence: 10,
          associativity: 1,
          callable: fn (a, b) { a.x * b.y + a.y * b.y }}
  ikc3> access(a, [:sym])
  :dot
  ikc3> access(a, [:arity])
  2
  ikc3> access(a, [:callable])
  fn (a, b) { a.x * b.y + a.y * b.y }
  ```
  
  To update an existing struct property you can use Struct.put, a new
  struct with modified properties will be returned. E.g. :
  
  ```elixir
  ikc3> a = %KC3.Op{sym: :dot,
                    precedence: 10,
                    callable: fn (a, b) { a.x * b.y + a.y * b.y }}
  %KC3.Op{sym: :dot,
          arity: 2,
          special: false,
          precedence: 10,
          associativity: 1,
          callable: fn (a, b) { a.x * b.y + a.y * b.y }}
  b = Struct.put(a, :sym, :·)
  %KC3.Op{sym: :·,
          arity: 2,
          special: false,
          precedence: 10,
          associativity: 1,
          callable: fn (a, b) { a.x * b.y + a.y * b.y }}
  ```
  
  ---
  
  Top : [KC3 documentation](../)
  
  Previous : [1.20 Str](1.20_Str)
  
  Next : [1.22 Sym](1.22_Sym)
  

Download