wit-component 0.246.2

Tooling for working with `*.wit` and component files together.
Documentation 
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

package foo:bar;

interface foo {
  resource bar {
    constructor();
    a: static func();
    b: func();
  }

  a: func(x: bar) -> bar;
  type t = bar;
  type t2 = own<bar>;
}

interface baz {
  use foo.{bar,t};
  a: func(x: bar) -> bar;

  b: func() -> t;
}


world some-world {
  use baz.{bar};

  resource a {
    constructor();
  }

  resource b {
    constructor() -> result<b, string>;
  }

  export x: func() -> a;
  export y: func() -> bar;

  import anon: interface {
    resource a {
      constructor();

      b: static func();

      c: func();
    }
  }
}

interface implicit-own-handles {
  resource a;

  b: func(a1: a, a2: a) -> own<a>;
  c: func() -> list<own<a>>;
}

interface implicit-own-handles2 {
  /// the `own` return and list param should be the same `own`
  resource a {
    constructor(a: list<a>);
  }

  /// same as above, even when the `list<b>` implicitly-defined `own` comes
  /// before an explicitly defined `own`
  resource b {
    constructor(a: list<b>, b: own<b>);
  }

  /// same as the above, the `own` argument should have the same type as the
  /// return value
  resource c {
    a: static func(a: own<c>) -> c;
  }
}

world implicit-own-handles3 {
  /// there should only be one `list` type despite there looking like two
  /// list types here
  resource a {
    constructor(a: list<a>, b: list<own<a>>);
  }
}