Fuzion • Fuzion Design • Feature Kinds

Feature Kinds

A major design goal of Fuzion is to unify different concepts into the single concept of a Fuzion feature. This makes a Fuzion feature a very powerful mechanism. Nevertheless, Fuzion features are not all the same, there are different kinds of features and what can be done with one feature might not be possible with a different kind of feature. The following table gives an overview of what can be done with features of different kinds.

But first, let's see what all features have in common

What all features have in common

Feature name

All features declared in Fuzion have a feature name. The name is typically just an identifier such as execute, or an operand such as postfix !.

Feature nesting

All features are declared within the context of an outer feature. This outer feature is the feature that syntactically surrounds the feature declaration. In case there is no explicit feature surrounding a feature declaration, the outer feature is an implicit feature called universe.

Differences between Feature Kinds

Fuzion Features are of one of several kinds and not all features can be used in every context. This gives an overview of the feature kinds and what they can do.

Feature Kind Property	Constructor	Routine	Field	Intrinsic/Native	Abstract	Choice	Function
Defines Type	✅ Yes	✅ Yes¹	❌ No	❌ No	❌ No	✅ Yes	✅ Yes
May contain code	✅ Yes	✅ Yes	❌ No	❌ No	❌ No	❌ No	✅ Yes
May contain declarations	✅ Yes	✅ Yes	❌ No	❌ No	❌ No	✅ Yes²	✅ Yes
May be redefined	❌ No³	✅ Yes	✅ Yes	✅ Yes	✅ Yes	❌ No	❌ No³
May redefine	❌ No	✅ Yes	✅ Yes	✅ Yes	✅ Yes	❌ No	✅ Yes⁴
May have formal arguments	✅ Yes	✅ Yes	❌ No	✅ Yes	✅ Yes	❌ No	✅ Yes
Has explicit result type	❌ No	✅ Yes⁵	✅ Yes⁵	✅ Yes	✅ Yes	❌ No	❌ No
May have formal type arguments	✅ Yes	✅ Yes	❌ No	✅ Yes	✅ Yes	✅ Yes	✅ Yes
May be called	✅ Yes	✅ Yes	✅ Yes	✅ Yes	❌ No	❌ No	✅ Yes⁶
May be assigned to	❌ No	❌ No	✅ Yes	❌ No	❌ No	❌ No	❌ No
May be called in inheritance clause	✅ Yes	❌ No	❌ No	❌ No	❌ No	❌ No	✅ Yes
May inherit	✅ Yes	✅ Yes	❌ No	❌ No	❌ No	❌ No	✅ Yes
¹The inner type of a routine is anonymous, so it cannot be used in declarations. ²Inner features may be constructors or routines, not fields. ³Redefinition would require dynamic binding in inherits call which results in trouble since different targets in that call would result in different inherited features. ⁴Requires type defined by constructor to be compatible to result type of redefined feature. ⁵Result type may be inferred from returned or assigned expression. ⁶There are two ways to call a function: Calling its constructor and calling its inner feature `call`.

Examples

Defining a Type

Constructor

# example using a constructor feature as a type
typ_const is

  # Declaring a constructor foo
  foo is

  # using foo as a result type
  test1 foo => abstract

  # using foo as an argument type
  test2 (arg foo) unit => abstract

  # using foo as a generic type
  _ list foo := nil

  # using foo as an element in a union type
  _ nil | foo | i32 := 42

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# example using a constructor feature as a type
typ_const is
  # Declaring a constructor foo
  foo is
  # using foo as a result type
  test1 foo => abstract
  # using foo as an argument type
  test2 (arg foo) unit => abstract
  # using foo as a generic type
  _ list foo := nil
  # using foo as an element in a union type
  _ nil | foo | i32 := 42
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

One restriction is that type names must not be ambiguous. Overloading of constructors results in the corresponding types to be no longer usable since Fuzion does not permit a means to disambiguate overloaded types:

# example using a constructor feature as an ambiguous type
typ_const is

  # Declaring a constructor foo
  foo is

  # Declaring another constructor foo with different arguments
  foo (x, y i32) is

  # using foo as a result type
  test1 foo => abstract    # error! foo is ambiguous.

1
2
3
4
5
6
7
8
9
10
11
12
# example using a constructor feature as an ambiguous type
typ_const is
  # Declaring a constructor foo
  foo is
  # Declaring another constructor foo with different arguments
  foo (x, y i32) is
  # using foo as a result type
  test1 foo => abstract    # error! foo is ambiguous.
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Routine

A routine does define a type, but this type is anonymous. It does not have a name that we could use in a declaration. However, type inference can be used to create features using a routine's type:

# example using a routine feature as inferred type
typ_routi is

  # Declaring a routine foo
  foo (arg String) unit =>
    inner is
      x => foo.this
    say "accessing foo.this via inner.x: {inner.x.arg}"

  foo "ok!"

1
2
3
4
5
6
7
8
9
10
11
# example using a routine feature as inferred type
typ_routi is
  # Declaring a routine foo
  foo (arg String) unit =>
    inner is
      x => foo.this
    say "accessing foo.this via inner.x: {inner.x.arg}"
  foo "ok!"
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

An instance of a routine's implicit type can even exist longer than the routine's call itself. Here is an example that shows a routine in a closure that extends the life span of the routine's instance until after the call to the routine has returned:

# example using a routine feature in a closure
typ_routi2 is

  # Declaring a routine foo
  foo (arg1 String, arg2 i32) () -> String =>
    v := arg2 * arg2
    () -> ("within foo: arg1 is {foo.this.arg1}" +
           ", arg2 is {foo.this.arg2}, v is $v")

  f1 := foo "f1" 42
  f2 := foo "f2" 4711
  say f1()
  say f2()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# example using a routine feature in a closure
typ_routi2 is
  # Declaring a routine foo
  foo (arg1 String, arg2 i32) () -> String =>
    v := arg2 * arg2
    () -> ("within foo: arg1 is {foo.this.arg1}" +
           ", arg2 is {foo.this.arg2}, v is $v")
  f1 := foo "f1" 42
  f2 := foo "f2" 4711
  say f1()
  say f2()
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Negative example: Using a routine's name explicitly as a type does not work since a routine does not define a name for its type:

# example using a routine feature as a type
typ_routi3 is

  # Declaring a routine foo
  foo unit =>

  # using foo as a result type
  test1 foo => abstract          # error!

  # using foo as an argument type
  test2 (arg foo) unit => abstract    # error!

  # using foo as a generic type
  test3 list foo := nil          # error!

  # using foo as an element in a union type
  test4 nil | foo | i32 := 42    # error!  (NYI: second error "Generics arguments to choice type must be disjoint types")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# example using a routine feature as a type
typ_routi3 is
  # Declaring a routine foo
  foo unit =>
  # using foo as a result type
  test1 foo => abstract          # error!
  # using foo as an argument type
  test2 (arg foo) unit => abstract    # error!
  # using foo as a generic type
  test3 list foo := nil          # error!
  # using foo as an element in a union type
  test4 nil | foo | i32 := 42    # error!  (NYI: second error "Generics arguments to choice type must be disjoint types")
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Field

# example using a field feature as a type
typ_field is

  # Declaring a field foo
  foo i32 := 42

  # using foo as a result type
  test1 foo => abstract          # error!

  # using foo as an argument type
  test2 (arg foo) unit => abstract    # error!

  # using foo as a generic type
  test3 list foo := nil         # error!

  # using foo as an element in a union type
  test4 nil | foo | i32 := 42    # error!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# example using a field feature as a type
typ_field is
  # Declaring a field foo
  foo i32 := 42
  # using foo as a result type
  test1 foo => abstract          # error!
  # using foo as an argument type
  test2 (arg foo) unit => abstract    # error!
  # using foo as a generic type
  test3 list foo := nil         # error!
  # using foo as an element in a union type
  test4 nil | foo | i32 := 42    # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Intrinsic

# example using an intrinsic feature as a type
typ_intri is

  # Declaring an intrinsic feature foo
  foo unit => intrinsic

  # using foo as a result type
  test1 foo => abstract          # error!

  # using foo as an argument type
  test2 (arg foo) unit => abstract    # error!

  # using foo as a generic type
  test3 list foo := nil         # error!

  # using foo as an element in a union type
  test4 nil | foo | i32 := 42    # error!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# example using an intrinsic feature as a type
typ_intri is
  # Declaring an intrinsic feature foo
  foo unit => intrinsic
  # using foo as a result type
  test1 foo => abstract          # error!
  # using foo as an argument type
  test2 (arg foo) unit => abstract    # error!
  # using foo as a generic type
  test3 list foo := nil         # error!
  # using foo as an element in a union type
  test4 nil | foo | i32 := 42    # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Abstract

# example using an abstract feature as a type
typ_abstr is

  # Declaring an abstract feature foo
  foo unit => abstract

  # using foo as a result type
  test1 foo => abstract          # error!

  # using foo as an argument type
  test2 (arg foo) unit => abstract    # error!

  # using foo as a generic type
  test3 list foo := nil          # error!

  # using foo as an element in a union type
  test4 nil | foo | i32 := 42    # error!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# example using an abstract feature as a type
typ_abstr is
  # Declaring an abstract feature foo
  foo unit => abstract
  # using foo as a result type
  test1 foo => abstract          # error!
  # using foo as an argument type
  test2 (arg foo) unit => abstract    # error!
  # using foo as a generic type
  test3 list foo := nil          # error!
  # using foo as an element in a union type
  test4 nil | foo | i32 := 42    # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Choice

# example using an abstract feature as a type
typ_choic is

  # Declaring a choice feature foo
  foo : choice unit i64 true_ is

  # using foo as a result type
  test1 foo => abstract

  # using foo as an argument type
  test2 (arg foo) unit => abstract

  # using foo as a generic type
  _ list foo := nil

  # using foo as an element in a union type
  _ nil | foo | i32 := 42

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# example using an abstract feature as a type
typ_choic is
  # Declaring a choice feature foo
  foo : choice unit i64 true_ is
  # using foo as a result type
  test1 foo => abstract
  # using foo as an argument type
  test2 (arg foo) unit => abstract
  # using foo as a generic type
  _ list foo := nil
  # using foo as an element in a union type
  _ nil | foo | i32 := 42
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Containing code

Constructor

# example using a constructor feature that contains code
cod_const is

  # Declaring a constructor foo
  foo is
    say "Hello!"

  _ := foo

1
2
3
4
5
6
7
8
9
# example using a constructor feature that contains code
cod_const is
  # Declaring a constructor foo
  foo is
    say "Hello!"
  _ := foo
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Routine

# example using a routine feature that contains code
cod_routi is

  # Declaring a routine foo
  foo unit =>
    say "Hello!"

  foo

1
2
3
4
5
6
7
8
9
# example using a routine feature that contains code
cod_routi is
  # Declaring a routine foo
  foo unit =>
    say "Hello!"
  foo
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Field

# example using a field feature that contains code
cod_field is

  # Declaring a field foo
  foo i32 := 42
    say "Hello!"                 # error!

1
2
3
4
5
6
7
# example using a field feature that contains code
cod_field is
  # Declaring a field foo
  foo i32 := 42
    say "Hello!"                 # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Intrinsic

# example using an intrinstic feature that contains code
cod_intri is

  # Declaring an intrinsic feature foo
  foo unit => intrinsic
    say "Hello!"                 # error!

1
2
3
4
5
6
7
# example using an intrinstic feature that contains code
cod_intri is
  # Declaring an intrinsic feature foo
  foo unit => intrinsic
    say "Hello!"                 # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Abstract

# example using an abstract feature that contains code
cod_abstr is

  # Declaring an abstract feature foo
  foo unit => abstract
    say "Hello!"                 # error!

1
2
3
4
5
6
7
# example using an abstract feature that contains code
cod_abstr is
  # Declaring an abstract feature foo
  foo unit => abstract
    say "Hello!"                 # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Choice

# example using a choice feature that contains code
cod_choic is

  # Declaring an choice feature foo
  foo : choice unit i64 true_ is
    say "Hello!"                 # error!

1
2
3
4
5
6
7
# example using a choice feature that contains code
cod_choic is
  # Declaring an choice feature foo
  foo : choice unit i64 true_ is
    say "Hello!"                 # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Containing declarations

Constructor

# example using a constructor feature that contains declarations
dec_const is

  # Declaring a constructor foo
  foo is

    # declaring an inner constructor
    constr is

    # declaring an inner routine
    routi i32 => 42

    # declaring an inner field
    _ i32 := 42

    # declaring an inner intrinsic feature
    intri unit => intrinsic

    # declaring an inner abstract feature
    abstr unit => abstract

    # declaring an inner choice type
    choic : choice i32 nil bool is

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# example using a constructor feature that contains declarations
dec_const is
  # Declaring a constructor foo
  foo is
    # declaring an inner constructor
    constr is
    # declaring an inner routine
    routi i32 => 42
    # declaring an inner field
    _ i32 := 42
    # declaring an inner intrinsic feature
    intri unit => intrinsic
    # declaring an inner abstract feature
    abstr unit => abstract
    # declaring an inner choice type
    choic : choice i32 nil bool is
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Routine

# example using a routine feature that contains declarations
dec_routi is

  # Declaring a routine foo
  foo unit =>

    # declaring an inner constructor
    constr is

    # declaring an inner routine
    routi i32 => 42

    # declaring an inner field
    _ i32 := 42

    # declaring an inner intrinsic feature
    intri unit => intrinsic

    # declaring an inner abstract feature
    abstr unit => abstract

    # declaring an inner choice type
    choic : choice i32 nil bool is

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# example using a routine feature that contains declarations
dec_routi is
  # Declaring a routine foo
  foo unit =>
    # declaring an inner constructor
    constr is
    # declaring an inner routine
    routi i32 => 42
    # declaring an inner field
    _ i32 := 42
    # declaring an inner intrinsic feature
    intri unit => intrinsic
    # declaring an inner abstract feature
    abstr unit => abstract
    # declaring an inner choice type
    choic : choice i32 nil bool is
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Field

# example using a field that contains declarations
dec_field is

  # Declaring a field foo
  foo i32 := 42

    # declaring an inner constructor
    constr is                    # error!

    # declaring an inner routine
    routi i32 => 42              # error!

    # declaring an inner field
    _ i32 := 42              # error!

    # declaring an inner intrinsic feature
    intri unit => intrinsic           # error!

    # declaring an inner abstract feature
    abstr unit => abstract            # error!

    # declaring an inner choice type
    choic : choice i32 nil bool is      # error!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# example using a field that contains declarations
dec_field is
  # Declaring a field foo
  foo i32 := 42
    # declaring an inner constructor
    constr is                    # error!
    # declaring an inner routine
    routi i32 => 42              # error!
    # declaring an inner field
    _ i32 := 42              # error!
    # declaring an inner intrinsic feature
    intri unit => intrinsic           # error!
    # declaring an inner abstract feature
    abstr unit => abstract            # error!
    # declaring an inner choice type
    choic : choice i32 nil bool is      # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Intrinsic

# example using an intrinstic feature that contains declarations
dec_intri is

  # Declaring an intrinsic feature foo
  foo unit => intrinsic

    # declaring an inner constructor
    constr is                    # error!

    # declaring an inner routine
    routi i32 => 42              # error!

    # declaring an inner field
    _ i32 := 42              # error!

    # declaring an inner intrinsic feature
    intri unit => intrinsic           # error!

    # declaring an inner abstract feature
    abstr unit => abstract            # error!

    # declaring an inner choice type
    choic : choice i32 nil bool is      # error!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# example using an intrinstic feature that contains declarations
dec_intri is
  # Declaring an intrinsic feature foo
  foo unit => intrinsic
    # declaring an inner constructor
    constr is                    # error!
    # declaring an inner routine
    routi i32 => 42              # error!
    # declaring an inner field
    _ i32 := 42              # error!
    # declaring an inner intrinsic feature
    intri unit => intrinsic           # error!
    # declaring an inner abstract feature
    abstr unit => abstract            # error!
    # declaring an inner choice type
    choic : choice i32 nil bool is      # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Abstract

# example using an abstract feature that contains declarations
dec_abstr is

  # Declaring an abstract feature foo
  foo unit => abstract

    # declaring an inner constructor
    constr is                    # error!

    # declaring an inner routine
    routi i32 => 42              # error!

    # declaring an inner field
    _ i32 := 42              # error!

    # declaring an inner intrinsic feature
    intri unit => intrinsic           # error!

    # declaring an inner abstract feature
    abstr unit => abstract            # error!

    # declaring an inner choice type
    choic : choice i32 nil bool is      # error!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# example using an abstract feature that contains declarations
dec_abstr is
  # Declaring an abstract feature foo
  foo unit => abstract
    # declaring an inner constructor
    constr is                    # error!
    # declaring an inner routine
    routi i32 => 42              # error!
    # declaring an inner field
    _ i32 := 42              # error!
    # declaring an inner intrinsic feature
    intri unit => intrinsic           # error!
    # declaring an inner abstract feature
    abstr unit => abstract            # error!
    # declaring an inner choice type
    choic : choice i32 nil bool is      # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Choice

Positive example declarations:

# example using a choice feature that contains declarations
dec_choic is

  # Declaring a choice feature foo
  foo : choice unit i64 true_ is

    # declaring an inner constructor
    constr is
      say "foo.constr"

    # declaring an inner routine
    routi String =>
      "foo.routi"

    # declaring an inner intrinsic feature
    intri unit => intrinsic

    # declaring an inner abstract feature
    abstr unit => abstract

    # declaring an inner choice type
    choic : choice i32 nil bool is

  f foo := unit
  _ := f.constr
  say f.routi

  say "calling f.abstr will cause error."
  _ := f.abstr                  # error!

  say "calling f.intri will cause error."
  _ := f.intri                  # error!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# example using a choice feature that contains declarations
dec_choic is
  # Declaring a choice feature foo
  foo : choice unit i64 true_ is
    # declaring an inner constructor
    constr is
      say "foo.constr"
    # declaring an inner routine
    routi String =>
      "foo.routi"
    # declaring an inner intrinsic feature
    intri unit => intrinsic
    # declaring an inner abstract feature
    abstr unit => abstract
    # declaring an inner choice type
    choic : choice i32 nil bool is
  f foo := unit
  _ := f.constr
  say f.routi
  say "calling f.abstr will cause error."
  _ := f.abstr                  # error!
  say "calling f.intri will cause error."
  _ := f.intri                  # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Negative example declaring a field:

# example using a choice feature that contains a field declarations
dec_choic2 is

  # Declaring a choice feature foo
  foo : choice unit i64 true_ is

    # declaring an inner field
    _ i32 := 42               # error!

1
2
3
4
5
6
7
8
9
# example using a choice feature that contains a field declarations
dec_choic2 is
  # Declaring a choice feature foo
  foo : choice unit i64 true_ is
    # declaring an inner field
    _ i32 := 42               # error!
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Being redefined

Constructor

# example using a constructor feature that is redefined
brd_const is

  parent is
    # Declaring a constructor foo
    foo unit =>
      say "parent.foo"

  rparent ref : parent is

  heir : rparent is
    redef foo unit =>            # error! (NYI)
      say "heir.foo"

  # test calling foo dynamically
  test (r rparent) unit =>

    # using normal call
    r.foo

    # using inheritance call
    q unit : r.foo =>            # NYI: currently causes 'Could not find called feature 'r', need to check why
    q

  test rparent
  test heir

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# example using a constructor feature that is redefined
brd_const is
  parent is
    # Declaring a constructor foo
    foo unit =>
      say "parent.foo"
  rparent ref : parent is
  heir : rparent is
    redef foo unit =>            # error! (NYI)
      say "heir.foo"
  # test calling foo dynamically
  test (r rparent) unit =>
    # using normal call
    r.foo
    # using inheritance call
    q unit : r.foo =>            # NYI: currently causes 'Could not find called feature 'r', need to check why
    q
  test rparent
  test heir
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Routine

# example using a routine feature that is redefined
brd_routi is

  parent is
    # Declaring a constructor foo
    foo unit =>
      say "parent.foo"

  rparent ref : parent is

  heir : rparent is
    redef foo unit =>
      say "heir.foo"

  # test calling foo dynamically
  test (r rparent) unit =>

    # using normal call
    r.foo

    # using inheritance call
    q unit : r.foo =>            # NYI: currently causes 'Could not find called feature 'foo', need to check why
    q

  test rparent
  test heir

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# example using a routine feature that is redefined
brd_routi is
  parent is
    # Declaring a constructor foo
    foo unit =>
      say "parent.foo"
  rparent ref : parent is
  heir : rparent is
    redef foo unit =>
      say "heir.foo"
  # test calling foo dynamically
  test (r rparent) unit =>
    # using normal call
    r.foo
    # using inheritance call
    q unit : r.foo =>            # NYI: currently causes 'Could not find called feature 'foo', need to check why
    q
  test rparent
  test heir
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Field

# example using a field that is redefined
brd_field is

  parent is
    # Declaring a constructor foo
    foo String := "parent.foo"

  rparent ref : parent is

  heir : rparent is
    # redefine foo as a routine
    redef foo String => "heir.foo"

  heir2 : rparent is
    # redefine foo as another field
    redef foo String := "heir.foo"  # NYI: should cause an error

  # test calling foo dynamically
  test (r rparent) unit =>

    # using normal call
    _ := r.foo

    # using inheritance call
    q unit : r.foo =>              # NYI: currently causes 'Could not find called feature 'r', need to check why
    q

  test rparent
  test heir
  test heir2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# example using a field that is redefined
brd_field is
  parent is
    # Declaring a constructor foo
    foo String := "parent.foo"
  rparent ref : parent is
  heir : rparent is
    # redefine foo as a routine
    redef foo String => "heir.foo"
  heir2 : rparent is
    # redefine foo as another field
    redef foo String := "heir.foo"  # NYI: should cause an error
  # test calling foo dynamically
  test (r rparent) unit =>
    # using normal call
    _ := r.foo
    # using inheritance call
    q unit : r.foo =>              # NYI: currently causes 'Could not find called feature 'r', need to check why
    q
  test rparent
  test heir
  test heir2
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Intrinsic

# example using an intrinsic feature that is redefined
brd_intri is

  parent is
    # Declaring an intrinsic feature foo
    foo unit => intrinsic             # error! compiler complains about unknown intrinsics...

  rparent ref : parent is

  heir : rparent is
    redef foo unit =>
      say "heir.foo"

  # test calling foo dynamically
  test (r rparent) unit =>

    # using normal call
    r.foo

    # using inheritance call
    q unit : r.foo =>            # NYI: currently causes 'Could not find called feature 'r', need to check why
    q

  test rparent
  test heir

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# example using an intrinsic feature that is redefined
brd_intri is
  parent is
    # Declaring an intrinsic feature foo
    foo unit => intrinsic             # error! compiler complains about unknown intrinsics...
  rparent ref : parent is
  heir : rparent is
    redef foo unit =>
      say "heir.foo"
  # test calling foo dynamically
  test (r rparent) unit =>
    # using normal call
    r.foo
    # using inheritance call
    q unit : r.foo =>            # NYI: currently causes 'Could not find called feature 'r', need to check why
    q
  test rparent
  test heir
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Abstract

# example using an abstract feature that is redefined
brd_abstr is

  parent is
    # Declaring an abstract feature foo
    foo unit => abstract

  rparent ref : parent is

  heir : rparent is
    redef foo unit =>
      say "heir.foo"

  # test calling foo dynamically
  test (r rparent) unit =>

    # using normal call
    r.foo

    # using inheritance call
    q unit : r.foo => {}         # NYI: currently causes 'Could not find called feature 'foo', need to check why
    q

  test heir
                                  # NYI: this error is only emitted in middleend. since frontend already errors,
                                  # this error is currently not shown.
  test rparent                    # error! will result in calling abstract feature

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# example using an abstract feature that is redefined
brd_abstr is
  parent is
    # Declaring an abstract feature foo
    foo unit => abstract
  rparent ref : parent is
  heir : rparent is
    redef foo unit =>
      say "heir.foo"
  # test calling foo dynamically
  test (r rparent) unit =>
    # using normal call
    r.foo
    # using inheritance call
    q unit : r.foo => {}         # NYI: currently causes 'Could not find called feature 'foo', need to check why
    q
  test heir
                                  # NYI: this error is only emitted in middleend. since frontend already errors,
                                  # this error is currently not shown.
  test rparent                    # error! will result in calling abstract feature
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Choice

# example using a choice feature that is redefined
brd_choic is

  parent is
    # Declaring a choice feature foo
    foo : choice unit i64 true_ is

  heir : parent is
    redef foo parent.foo =>   # error! choice cannot be redefined
      say "heir.foo"
      i64 23

  _ := parent.foo     # error! choice cannot be called.
  _ := heir.foo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# example using a choice feature that is redefined
brd_choic is
  parent is
    # Declaring a choice feature foo
    foo : choice unit i64 true_ is
  heir : parent is
    redef foo parent.foo =>   # error! choice cannot be redefined
      say "heir.foo"
      i64 23
  _ := parent.foo     # error! choice cannot be called.
  _ := heir.foo
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Redefining

Constructor

Negative example with compatible types that could be permitted, but is forbidden:

# example using a constructor feature to redefine another feature
red_const is

  parent is
    # foo has result type equal to result of heir.foo2
    foo red_const.heir.foo => abstract

    # foo2 has result type compatible to result of heir.foo2
    foo2 String => abstract

  rparent ref : parent is

  fixed heir : rparent is  # must be fixed to fix outer type to red_const
    # redefine foo using a constructor with equal result type
    redef foo is                  # error! Even though this could work in this
                                  # special case, a redefinition cannot be a constructor
      say "heir.foo"

    # redefine foo2 using a constructor with compatible result type
    redef foo2 ref : String is    # error! Even though this could work in this
                                  # special case, a redefinition cannot be a constructor
      public redef utf8 => "heir.foo2".utf8

  p red_const.rparent := heir
  _ := heir.foo
  say heir.foo2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# example using a constructor feature to redefine another feature
red_const is
  parent is
    # foo has result type equal to result of heir.foo2
    foo red_const.heir.foo => abstract
    # foo2 has result type compatible to result of heir.foo2
    foo2 String => abstract
  rparent ref : parent is
  fixed heir : rparent is  # must be fixed to fix outer type to red_const
    # redefine foo using a constructor with equal result type
    redef foo is                  # error! Even though this could work in this
                                  # special case, a redefinition cannot be a constructor
      say "heir.foo"
    # redefine foo2 using a constructor with compatible result type
    redef foo2 ref : String is    # error! Even though this could work in this
                                  # special case, a redefinition cannot be a constructor
      public redef utf8 => "heir.foo2".utf8
  p red_const.rparent := heir
  _ := heir.foo
  say heir.foo2
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Negative example with incompatible types:

# example using a constructor feature to redefine another feature
red_const2 is

  parent is
    foo unit => abstract

  rparent ref : parent is

  heir : rparent is
    # redefine foo using a constructor
    # result type (heir.foo) is incompatible, would cause an error:
    redef foo is                 # error!
      say "heir.foo"

  p rparent := heir
  f := heir.foo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# example using a constructor feature to redefine another feature
red_const2 is
  parent is
    foo unit => abstract
  rparent ref : parent is
  heir : rparent is
    # redefine foo using a constructor
    # result type (heir.foo) is incompatible, would cause an error:
    redef foo is                 # error!
      say "heir.foo"
  p rparent := heir
  f := heir.foo
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Routine

# example using a routine feature to redefine another feature
red_routi is

  parent is
    foo unit => abstract

    foo2 String => abstract

    foo3 Any => abstract

  rparent ref : parent is

  heir : rparent is
    # redefine foo using a routine with same unit result type
    redef foo unit =>
      say "heir.foo"

    # redefine foo2 using a routine with same result type
    redef foo2 String =>
      "heir.foo2"

    # redefine foo3 using a routine with compatible result type
    redef foo3 String =>
      "heir.foo3"

  p rparent := heir
  p.foo
  say p.foo2
  say p.foo3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# example using a routine feature to redefine another feature
red_routi is
  parent is
    foo unit => abstract
    foo2 String => abstract
    foo3 Any => abstract
  rparent ref : parent is
  heir : rparent is
    # redefine foo using a routine with same unit result type
    redef foo unit =>
      say "heir.foo"
    # redefine foo2 using a routine with same result type
    redef foo2 String =>
      "heir.foo2"
    # redefine foo3 using a routine with compatible result type
    redef foo3 String =>
      "heir.foo3"
  p rparent := heir
  p.foo
  say p.foo2
  say p.foo3
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Field

# example using a field feature to redefine another feature
red_field is

  parent is
    foo unit => abstract

    foo2 String => abstract

    foo3 Any => abstract

  rparent ref : parent is

  heir : rparent is
    # redefine foo as a field with same unit result type
    redef foo := unit

    # redefine foo2 as a field with same result type
    redef foo2 := "heir.foo2"

    # redefine foo3 as a field with compatible result type
    redef foo3 := "heir.foo3"

  p rparent := heir
  say p.foo
  say p.foo2
  say p.foo3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# example using a field feature to redefine another feature
red_field is
  parent is
    foo unit => abstract
    foo2 String => abstract
    foo3 Any => abstract
  rparent ref : parent is
  heir : rparent is
    # redefine foo as a field with same unit result type
    redef foo := unit
    # redefine foo2 as a field with same result type
    redef foo2 := "heir.foo2"
    # redefine foo3 as a field with compatible result type
    redef foo3 := "heir.foo3"
  p rparent := heir
  say p.foo
  say p.foo2
  say p.foo3
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Intrinsic

# example using an intrinsic feature to redefines another feature
red_intri is

  parent is
    foo unit => abstract

    foo2 String => abstract

    foo3 Any => abstract

  rparent ref : parent is

  heir : rparent is
    # redefine foo as an intrinsic with same unit result type
    redef foo unit => intrinsic         # error! compiler does not know this intrinsic

    # redefine foo2 as an intrinsic with same result type
    redef foo2 String => intrinsic      # error! compiler does not know this intrinsic

    # redefine foo3 as an intrinsic with compatible result type
    redef foo3 String => intrinsic  # error! compiler does not know this intrinsic

  p rparent := heir
  say p.foo
  say p.foo2
  say p.foo3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# example using an intrinsic feature to redefines another feature
red_intri is
  parent is
    foo unit => abstract
    foo2 String => abstract
    foo3 Any => abstract
  rparent ref : parent is
  heir : rparent is
    # redefine foo as an intrinsic with same unit result type
    redef foo unit => intrinsic         # error! compiler does not know this intrinsic
    # redefine foo2 as an intrinsic with same result type
    redef foo2 String => intrinsic      # error! compiler does not know this intrinsic
    # redefine foo3 as an intrinsic with compatible result type
    redef foo3 String => intrinsic  # error! compiler does not know this intrinsic
  p rparent := heir
  say p.foo
  say p.foo2
  say p.foo3
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Abstract

# example using an abstract feature to redefines another feature
red_abstr is

  parent is
    foo unit => abstract

    foo2 String => abstract

    foo3 Any => abstract

  rparent ref : parent is

  heir : rparent is
    # redefine foo as an abstract with same unit result type
    redef foo unit => abstract

    # redefine foo2 as an abstract with same result type
    redef foo2 String => abstract

    # redefine foo3 as an abstract with compatible result type
    redef foo3 String => abstract

  p rparent := heir
  say p.foo      # error! abstract called
  say p.foo2     # error! abstract called
  say p.foo3     # error! abstract called

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# example using an abstract feature to redefines another feature
red_abstr is
  parent is
    foo unit => abstract
    foo2 String => abstract
    foo3 Any => abstract
  rparent ref : parent is
  heir : rparent is
    # redefine foo as an abstract with same unit result type
    redef foo unit => abstract
    # redefine foo2 as an abstract with same result type
    redef foo2 String => abstract
    # redefine foo3 as an abstract with compatible result type
    redef foo3 String => abstract
  p rparent := heir
  say p.foo      # error! abstract called
  say p.foo2     # error! abstract called
  say p.foo3     # error! abstract called
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Choice

# example using an choice feature to redefines another feature
red_choic is

  parent is
    foo unit => abstract

    foo2 String => abstract

    foo3 Any => abstract

  rparent ref : parent is

  heir : rparent is
    # redefine foo as choice
    redef foo unit : choice i32 bool => unit

    # redefine foo2 as a choice with same result type
    redef foo2 String : choice i32 bool => "heir.foo2"

    # redefine foo3 as a choice with compatible result type
    redef foo3 String : choice i32 bool => "heir.foo3"

  p rparent := heir
  say p.foo
  say p.foo2
  say p.foo3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# example using an choice feature to redefines another feature
red_choic is
  parent is
    foo unit => abstract
    foo2 String => abstract
    foo3 Any => abstract
  rparent ref : parent is
  heir : rparent is
    # redefine foo as choice
    redef foo unit : choice i32 bool => unit
    # redefine foo2 as a choice with same result type
    redef foo2 String : choice i32 bool => "heir.foo2"
    # redefine foo3 as a choice with compatible result type
    redef foo3 String : choice i32 bool => "heir.foo3"
  p rparent := heir
  say p.foo
  say p.foo2
  say p.foo3
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Having formal arguments

Constructor

# example of a constructor feature with formal arguments
arg_const is

  # foo has formal arguments
  foo (i i32, j u64, b bool) is
    say "foo: i is $i j is $j b is $b"

  # foo2 has many formal arguments
  foo2 (a,b,c,d,e,f,g,h,i,j,k,l,m i32) is
    say "foo2: g is $g"

  # foo3 is an absurd constructor
  foo3 (absurd void) is
    say "foo3: nobody calls me..."

  _ := foo 42 9999999.as_u64 true
  _ := foo2 1 2 3 4 5 6 7 8 9 10 11 12 13
  _ := foo3 (exit 0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# example of a constructor feature with formal arguments
arg_const is
  # foo has formal arguments
  foo (i i32, j u64, b bool) is
    say "foo: i is $i j is $j b is $b"
  # foo2 has many formal arguments
  foo2 (a,b,c,d,e,f,g,h,i,j,k,l,m i32) is
    say "foo2: g is $g"
  # foo3 is an absurd constructor
  foo3 (absurd void) is
    say "foo3: nobody calls me..."
  _ := foo 42 9999999.as_u64 true
  _ := foo2 1 2 3 4 5 6 7 8 9 10 11 12 13
  _ := foo3 (exit 0)
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Routine

# example of a routine feature with formal arguments
arg_routi is

  # foo has formal arguments
  foo (i i32, j u64, b bool) String =>
    "foo: i is $i j is $j b is $b"

  # foo2 has many formal arguments
  foo2 (a,b,c,d,e,f,g,h,i,j,k,l,m i32) String =>
    "foo2: g is $g"

  # foo3 is an absurd routine
  foo3 (absurd void) String =>
    "foo3: nobody calls me..."

  say (foo 42 9999999.as_u64 true)
  say (foo2 1 2 3 4 5 6 7 8 9 10 11 12 13)
  say (foo3 (exit 0))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# example of a routine feature with formal arguments
arg_routi is
  # foo has formal arguments
  foo (i i32, j u64, b bool) String =>
    "foo: i is $i j is $j b is $b"
  # foo2 has many formal arguments
  foo2 (a,b,c,d,e,f,g,h,i,j,k,l,m i32) String =>
    "foo2: g is $g"
  # foo3 is an absurd routine
  foo3 (absurd void) String =>
    "foo3: nobody calls me..."
  say (foo 42 9999999.as_u64 true)
  say (foo2 1 2 3 4 5 6 7 8 9 10 11 12 13)
  say (foo3 (exit 0))
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Field

# example of a field with formal arguments
arg_field is

  # field foo with formal arguments
  foo(i i32, j u64, b bool) String

  # field foo2 has many formal arguments
  foo2(a,b,c,d,e,f,g,h,i,j,k,l,m i32) String

  # field foo3 has absurd argument
  foo3(absurd void) String

  say(foo 42 9999999.as_u64 true)
  say(foo2 1 2 3 4 5 6 7 8 9 10 11 12 13)
  say(foo3 (do {}))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# example of a field with formal arguments
arg_field is
  # field foo with formal arguments
  foo(i i32, j u64, b bool) String
  # field foo2 has many formal arguments
  foo2(a,b,c,d,e,f,g,h,i,j,k,l,m i32) String
  # field foo3 has absurd argument
  foo3(absurd void) String
  say(foo 42 9999999.as_u64 true)
  say(foo2 1 2 3 4 5 6 7 8 9 10 11 12 13)
  say(foo3 (do {}))
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Intrinsic

# example of an intrinsic feature with formal arguments
arg_intri is

  # foo has formal arguments
  foo (i i32, j u64, b bool) String => intrinsic            # error! compiler does not know this intrinsic

  # foo2 has many formal arguments
  foo2 (a,b,c,d,e,f,g,h,i,j,k,l,m i32) String => intrinsic  # error! compiler does not know this intrinsic

  # foo3 is an absurd intrinsic
  foo3 (absurd void) String => intrinsic                    # error! compiler does not know this intrinsic

  say (foo 42 9999999.as_u64 true)
  say (foo2 1 2 3 4 5 6 7 8 9 10 11 12 13)
  say (foo3 (do {}))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# example of an intrinsic feature with formal arguments
arg_intri is
  # foo has formal arguments
  foo (i i32, j u64, b bool) String => intrinsic            # error! compiler does not know this intrinsic
  # foo2 has many formal arguments
  foo2 (a,b,c,d,e,f,g,h,i,j,k,l,m i32) String => intrinsic  # error! compiler does not know this intrinsic
  # foo3 is an absurd intrinsic
  foo3 (absurd void) String => intrinsic                    # error! compiler does not know this intrinsic
  say (foo 42 9999999.as_u64 true)
  say (foo2 1 2 3 4 5 6 7 8 9 10 11 12 13)
  say (foo3 (do {}))
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Abstract

# example of an abstract feature with formal arguments
arg_abstr is

  # foo has formal arguments
  foo (i i32, j u64, b bool) String => abstract

  # foo2 has many formal arguments
  foo2 (a,b,c,d,e,f,g,h,i,j,k,l,m i32) String => abstract

  # foo3 is an absurd abstract
  foo3 (absurd void) String => abstract

  say (foo 42 9999999.as_u64 true)             # will cause runtime error (NYI: compile time analysis missing)
  say (foo2 1 2 3 4 5 6 7 8 9 10 11 12 13)     # will cause runtime error (NYI: compile time analysis missing)
  say (foo3 (do {}))                           # will cause runtime error (NYI: compile time analysis missing)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# example of an abstract feature with formal arguments
arg_abstr is
  # foo has formal arguments
  foo (i i32, j u64, b bool) String => abstract
  # foo2 has many formal arguments
  foo2 (a,b,c,d,e,f,g,h,i,j,k,l,m i32) String => abstract
  # foo3 is an absurd abstract
  foo3 (absurd void) String => abstract
  say (foo 42 9999999.as_u64 true)             # will cause runtime error (NYI: compile time analysis missing)
  say (foo2 1 2 3 4 5 6 7 8 9 10 11 12 13)     # will cause runtime error (NYI: compile time analysis missing)
  say (foo3 (do {}))                           # will cause runtime error (NYI: compile time analysis missing)
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Choice

# example of a choice feature with formal arguments
arg_choic is

  # foo has formal arguments
  foo (i i32, j u64, b bool) : choice i32 bool is

  # foo2 has many formal arguments
  foo2 (a,b,c,d,e,f,g,h,i,j,k,l,m i32) : choice i32 bool is

  # foo3 is an absurd choice
  foo3 (absurd void) String : choice i32 bool =>

1
2
3
4
5
6
7
8
9
10
11
12
# example of a choice feature with formal arguments
arg_choic is
  # foo has formal arguments
  foo (i i32, j u64, b bool) : choice i32 bool is
  # foo2 has many formal arguments
  foo2 (a,b,c,d,e,f,g,h,i,j,k,l,m i32) : choice i32 bool is
  # foo3 is an absurd choice
  foo3 (absurd void) String : choice i32 bool =>
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Having explicit result type

Constructor

# example of a constructor feature with explicit result type
res_const is

  # foo has explicit result type, so it is not a constructor
  foo i32 =>
    # will cause error: constructor returns foo.this, but we have declared a routine

  # foo2 has unit result, so it is not a constructor
  foo2 unit =>  # NYI: error position for error in foo is shown here

  # foo3 has void result, so it is not a constructor
  foo3 void =>
    do

  f1 foo := foo   # will cause error, foo is not a constructor
  f2 foo2 := foo2  # will cause error, foo2 is not a constructor
  f3 foo3 := foo3  # will cause error, foo3 is not a constructor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# example of a constructor feature with explicit result type
res_const is
  # foo has explicit result type, so it is not a constructor
  foo i32 =>
    # will cause error: constructor returns foo.this, but we have declared a routine
  # foo2 has unit result, so it is not a constructor
  foo2 unit =>  # NYI: error position for error in foo is shown here
  # foo3 has void result, so it is not a constructor
  foo3 void =>
    do
  f1 foo := foo   # will cause error, foo is not a constructor
  f2 foo2 := foo2  # will cause error, foo2 is not a constructor
  f3 foo3 := foo3  # will cause error, foo3 is not a constructor
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Routine

# example of a routine feature with explicit result type
res_const is

  # foo has explicit result type i32
  foo i32 =>
    42

  # foo1 has implicit result type i32
  foo2 =>
    42

  # foo3 has unit result
  foo3 unit =>

  # foo4 has implicit unit result
  foo4 =>

  # foo5 has void result, so it cannot return
  foo5 void =>
    do  # will get stuck in endless loop

  # foo6 cannot return, so it has implicit void result
  foo6 =>
    do  # will get stuck in endless loop

  _ i32 := foo
  _ i32 := foo2
  _ unit := foo3
  _ unit := foo4
  _ void := foo5
  _ void := foo6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# example of a routine feature with explicit result type
res_const is
  # foo has explicit result type i32
  foo i32 =>
    42
  # foo1 has implicit result type i32
  foo2 =>
    42
  # foo3 has unit result
  foo3 unit =>
  # foo4 has implicit unit result
  foo4 =>
  # foo5 has void result, so it cannot return
  foo5 void =>
    do  # will get stuck in endless loop
  # foo6 cannot return, so it has implicit void result
  foo6 =>
    do  # will get stuck in endless loop
  _ i32 := foo
  _ i32 := foo2
  _ unit := foo3
  _ unit := foo4
  _ void := foo5
  _ void := foo6
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Field

# example of a field feature with explicit result type
res_field is

  # foo has explicit result type i32
  public foo i32 := 42

  # foo1 has implicit result type i32
  public foo1 := 42

  # foo3 has unit result
  public foo3 unit := {}

  # foo4 has implicit unit result
  foo4 => {}

  # foo5 has void result, so it cannot be set
  public foo5 void := { do }  # will get stuck in endless loop

  # foo6 has implicitt void result, so it cannot be set
  public foo6 := { do }  # will get stuck in endless loop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# example of a field feature with explicit result type
res_field is
  # foo has explicit result type i32
  public foo i32 := 42
  # foo1 has implicit result type i32
  public foo1 := 42
  # foo3 has unit result
  public foo3 unit := {}
  # foo4 has implicit unit result
  foo4 => {}
  # foo5 has void result, so it cannot be set
  public foo5 void := { do }  # will get stuck in endless loop
  # foo6 has implicitt void result, so it cannot be set
  public foo6 := { do }  # will get stuck in endless loop
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Intrinsic

# example of intrinsic feature with explicit result type
res_intri is

  # foo has explicit result type i32
  foo i32 => intrinsic

  # foo2 has unit result
  foo2 unit => intrinsic

  # foo3 has void result, so it better does not return
  foo3 void => intrinsic

  _ i32 := foo
  _ unit := foo2
  _ void := foo3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# example of intrinsic feature with explicit result type
res_intri is
  # foo has explicit result type i32
  foo i32 => intrinsic
  # foo2 has unit result
  foo2 unit => intrinsic
  # foo3 has void result, so it better does not return
  foo3 void => intrinsic
  _ i32 := foo
  _ unit := foo2
  _ void := foo3
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Abstract

# example of absttract feature with explicit result type
res_abstr is

  # foo has explicit result type i32
  foo i32 => abstract

  # foo2 has unit result
  foo2 unit => abstract

  # foo3 has void result, so it better does not return
  foo3 void => abstract

1
2
3
4
5
6
7
8
9
10
11
12
# example of absttract feature with explicit result type
res_abstr is
  # foo has explicit result type i32
  foo i32 => abstract
  # foo2 has unit result
  foo2 unit => abstract
  # foo3 has void result, so it better does not return
  foo3 void => abstract
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Choice

# example of choice feature with explicit result type
res_choic is

  # foo has explicit result type i32
  foo i32 : choice i32 bool =>

  # foo2 has unit result
  foo2 unit : choice i32 bool =>

  # foo3 has void result, so it better does not return
  foo3 void : choice i32 bool =>

  # foo4 has ref result, so it better does not return
  foo4 ref : choice i32 bool is

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# example of choice feature with explicit result type
res_choic is
  # foo has explicit result type i32
  foo i32 : choice i32 bool =>
  # foo2 has unit result
  foo2 unit : choice i32 bool =>
  # foo3 has void result, so it better does not return
  foo3 void : choice i32 bool =>
  # foo4 has ref result, so it better does not return
  foo4 ref : choice i32 bool is
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Having formal type arguments

Constructor

# example of a constructor feature with type arguemnts
tya_const is

  # foo has type argument
  foo(S, T type) is

  # foo2 has type arguments and uses them for fields
  foo2(S, T type, s S, t T) is

  # foo3 has type arguments and uses them for args and results
  foo3(S, T type, t1, t2 T) is
    x(b bool) T =>
      if (b) t1 else t2

  _ := foo i32 bool
  _ := foo2 i32 bool 42 true
  _ := foo2 42 true  # using inference for type arguments
  _ := foo3 String Any Any Any

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# example of a constructor feature with type arguemnts
tya_const is
  # foo has type argument
  foo(S, T type) is
  # foo2 has type arguments and uses them for fields
  foo2(S, T type, s S, t T) is
  # foo3 has type arguments and uses them for args and results
  foo3(S, T type, t1, t2 T) is
    x(b bool) T =>
      if (b) t1 else t2
  _ := foo i32 bool
  _ := foo2 i32 bool 42 true
  _ := foo2 42 true  # using inference for type arguments
  _ := foo3 String Any Any Any
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Routine

# example of a routine feature with type arguemnts
tya_routi is

  # foo has type argument
  foo(S, T type) i32 => 42

  # foo2 has type arguments and uses them for fields
  foo2(S, T type, s S, t T) bool => true

  # foo3 has type arguments and uses them for fields and results
  foo3(S, T type, b bool, s S, t1, t2 T) T =>
    if (b) t1 else t2

  _ := foo i32 bool
  _ := foo2 i32 bool 42 true
  _ := foo2 42 true              # using inference for type arguments
  _ := foo3 String i32 true "Hi" 42 4711
  _ := foo3 true "Hi" 42 4711    # using inference for type arguments

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# example of a routine feature with type arguemnts
tya_routi is
  # foo has type argument
  foo(S, T type) i32 => 42
  # foo2 has type arguments and uses them for fields
  foo2(S, T type, s S, t T) bool => true
  # foo3 has type arguments and uses them for fields and results
  foo3(S, T type, b bool, s S, t1, t2 T) T =>
    if (b) t1 else t2
  _ := foo i32 bool
  _ := foo2 i32 bool 42 true
  _ := foo2 42 true              # using inference for type arguments
  _ := foo3 String i32 true "Hi" 42 4711
  _ := foo3 true "Hi" 42 4711    # using inference for type arguments
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Field

# example of a field feature with type arguemnts
tya_field is

  # foo has type argument
  foo(S, T type) i32 := 42   # error!

  # foo2 has type arguments and uses them for fields
  foo2(S, T type) := 4711    # error!


  _ := foo
  _ := foo2

1
2
3
4
5
6
7
8
9
10
11
12
13
# example of a field feature with type arguemnts
tya_field is
  # foo has type argument
  foo(S, T type) i32 := 42   # error!
  # foo2 has type arguments and uses them for fields
  foo2(S, T type) := 4711    # error!
  _ := foo
  _ := foo2
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Intrinsic

# example of an intrinsic feature with type arguemnts
tya_intri is

  # foo has type argument
  foo(S, T type) i32 => intrinsic

  # foo2 has type arguments and uses them for fields
  foo2(S, T type, s S, t T) bool => intrinsic

  # foo3 has type arguments and uses them for fields and results
  foo3(S, T type, b bool, s S, t1, t2 T) T => intrinsic

  _ := foo i32 bool
  _ := foo2 i32 bool 42 true
  _ := foo2 42 true              # using inference for type arguments
  _ := foo3 String i32 true "Hi" 42 4711
  _ := foo3 true "Hi" 42 4711    # using inference for type arguments

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# example of an intrinsic feature with type arguemnts
tya_intri is
  # foo has type argument
  foo(S, T type) i32 => intrinsic
  # foo2 has type arguments and uses them for fields
  foo2(S, T type, s S, t T) bool => intrinsic
  # foo3 has type arguments and uses them for fields and results
  foo3(S, T type, b bool, s S, t1, t2 T) T => intrinsic
  _ := foo i32 bool
  _ := foo2 i32 bool 42 true
  _ := foo2 42 true              # using inference for type arguments
  _ := foo3 String i32 true "Hi" 42 4711
  _ := foo3 true "Hi" 42 4711    # using inference for type arguments
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Abstract

# example of an intrinsic feature with type arguemnts
tya_abstr is

  # foo has type argument
  foo (S, T type) i32 => abstract

  # foo2 has type arguments and uses them for fields
  foo2 (S, T type, s S, t T) bool => abstract

  # foo3 has type arguments and uses them for fields and results
  foo3 (S, T type, b bool, s S, t1, t2 T) T => abstract

  _ := foo i32 bool
  _ := foo2 i32 bool 42 true
  _ := foo2 42 true               # using inference for type arguments
  _ := foo3 String i32 true "Hi" 42 4711
  _ := foo3 true "Hi" 42 4711     # using inference for type arguments

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# example of an intrinsic feature with type arguemnts
tya_abstr is
  # foo has type argument
  foo (S, T type) i32 => abstract
  # foo2 has type arguments and uses them for fields
  foo2 (S, T type, s S, t T) bool => abstract
  # foo3 has type arguments and uses them for fields and results
  foo3 (S, T type, b bool, s S, t1, t2 T) T => abstract
  _ := foo i32 bool
  _ := foo2 i32 bool 42 true
  _ := foo2 42 true               # using inference for type arguments
  _ := foo3 String i32 true "Hi" 42 4711
  _ := foo3 true "Hi" 42 4711     # using inference for type arguments
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Choice

# example of a choice feature with type arguemnts
tya_choic is

  # foo has type argument
  foo(S, T type) : choice S i32 T is

  _ foo String bool := "hello"
  _ foo String bool := 42
  _ foo String bool := false

1
2
3
4
5
6
7
8
9
10
# example of a choice feature with type arguemnts
tya_choic is
  # foo has type argument
  foo(S, T type) : choice S i32 T is
  _ foo String bool := "hello"
  _ foo String bool := 42
  _ foo String bool := false
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Being called

Constructor

Routine

Field

Intrinsic

Abstract

Choice

Being assigned to

Constructor

Routine

Field

Intrinsic

Abstract

Choice

Being target of inheritance call

Constructor

Routine

Field

Intrinsic

Abstract

Choice

May inherit

Constructor

Routine

Field

Intrinsic

Abstract

Choice

last changed: 2025-01-30

next: Visibility