kc3-lang/kc3/doc/1_KC3/1.21_Struct.fr.md

• Show log

  Commit

• Hash : ce10e043
  Author : Thomas de Grivel
  Date : 2025-05-19T12:47:56
  

  Translate using ChatGPT
  

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

Source

• doc/1_KC3/1.21_Struct.fr.md

• # 1.21 Structure
  
  Les structures KC3 sont des structures associatives clé-valeur
  avec des valeurs par défaut et un ordre arbitraire des propriétés.
  
  Elles sont compatibles avec les structures C du même 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 }}
  ```
  
  Vous pouvez définir un _type de structure_ par module avec `defstruct`,
  par exemple dans `vec2d.kc3` :
  
  ```elixir
  defmodule Vec2D do
  
    defstruct [x: 0.0,
               y: 0.0]
  
  end
  ```
  
  La déstructuration fonctionne avec les structures pour extraire les
  valeurs :
  
  ```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
  ```
  
  Vous pouvez utiliser la syntaxe pointée pour accéder aux champs
  depuis une clé `Sym` :
  
  ```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 }
  ```
  
  La syntaxe avec crochets permet d'interroger une structure comme un
  map :
  
  ```elixir
  ikc3> a[:sym]
  :dot
  ```
  
  ---
  
  Top : [Documentation KC3](../)
  
  Précédent : [1.20 Ratio](1.20_Ratio)
  
  Suivant : [1.22 Sym](1.22_Sym)
  

Download