; Generic Foo definition
@Foo(?) = {
  i1  ; actual type. There can be only two types (Int32 or Float32), ~>, it's i1
  i8* ; pointer to the actual instance
}

; Specialized Foo(Int32) definition
@Foo(Int32) = {
  i32 ; @bar : Int32
  i64 ; @common : Int64
}

; Foo(Int32).initialize(@bar: Int32, @common : Int64)
define void @Foo(Int32).initialize(noalias sret @Foo(Int32) %ptr, i32 %bar, i64 %common) {

  ; Store @bar
  %bar.ptr = getelementptr @Foo(Int32), @Foo(Int32)* %ptr, i32 0
  store i32 %bar, i32* %bar.ptr

  ; Store @common
  %common.ptr = getelementptr @Foo(Int32), @Foo(Int32)* %ptr, i32 1
  store i64 %common, i64* %common.ptr

  ret void
}

; Specialized Foo(Float32) definition
@Foo(Float32) = {
  float ; @bar : Float32
  i64    ; @common : Int64
}

; Foo(Float32).initialize(@bar: Float32, @common : Int64)
define void @Foo(Float32).initialize(noalias sret @Foo(Float32) %ptr, float %bar, i64 %common) {
  ; ditto
}

@Bar = {
  @Foo(?), ; @foo : Foo(?)
}

; Bar.new(@foo : Foo(?))
define void @Bar.initialize(noalias sret @Bar %ptr, @Foo(?)* %foo) {

  ; Store @foo : Foo(?)
  %foo.ptr = getelementptr @Bar, @Bar* %ptr, i32 0
  store @Foo(?) %foo, @Foo(?)* %foo.ptr

  ret void
}

; Return Foo(Int32)@bar : Int32 value
define i32 @Foo(Int32)@bar(@Foo(?)* %foo.union) {
%entry:
  ; Get pointer to the type value
  %type.ptr = getelementptr @Foo(?), @Foo(?)* %foo.union, i32 0
  %type = load i1, i1* %type.ptr ; Load the type value

  ; Proceed if it's Foo(Int32), unreacheable otherwise
  switch i1 %type, %unreacheable [ i1 0, %proceed, i1 1 %unreacheable ]
%proceed:
  %bar.ptr = getelementptr @Foo(Int32), @Foo(Int32)* %foo.union, i32 1
  %bar = load i32, i32* %bar.ptr
  ret %bar
%unreacheable
  unreacheable
}

; Return Foo(?)@common : Int64 value, which offset depends on its actual type
define i64 @Foo(?)@common(@Foo(?)* %foo.union) {
%entry:
  ; Get pointer to the type value
  %type.ptr = getelementptr @Foo(?), @Foo(?)* %foo.union, i32 0
  %type = load i1, i1* %type.ptr ; Load the type value
  switch i1 %type, %unreacheable [ i1 0, %Foo(Int32), i1 1, %Foo(Float32) ]
%Foo(Int32):
  %common.ptr = getelementptr @Foo(Int32), @Foo(Int32)* %foo.union, i32 1
  %common = load i64, i64* %common.ptr
  ret %common
%Foo(Float32):
  %common.ptr = getelementptr @Foo(Float32), @Foo(Float32)* %foo.union, i32 1
  %common = load i64, i64* %common.ptr
  ret %common
%unreacheable
  unreacheable
}

; Main (entry) function
define i32 @main() {
  ; Skip a & b example

  %foo.union = alloca @Foo(?) ; Allocate Foo(?)
  %foo = alloca @Foo(Int32)   ; Allocate Foo(Int32), as revealed by the compiler

  ; Put the actual Foo type (which is 1st = 0) into the union
  %foo.union.type.ptr = getelementptr @Foo(?), @Foo(?)* %foo.union, i32 0
  store i1 0, i1* %foo.union.type.ptr

  ; Put the actual Foo(Int32) instance into the union
  %foo.union.instance.ptr = getelementptr @Foo(?), @Foo(?)* %foo.union, i32 1
  store i8* %foo, i8* %foo.union.instance.ptr

  ; Initialize @foo : Foo(Int32)
  call @Foo(Int32).initialize(@Foo(Int32)* %foo, i32 42, i64 100)

  %baz = alloca @Baz ; Allocate Baz

  ; Initialize baz : Baz
  call @Baz.initialize(@Baz* %baz, @Foo(?)* %foo.union)

  ; Get the baz.foo pointer of type Foo(?)
  %baz.foo.ptr = getelementptr @Baz, @Baz* %baz, i32 0

  ; Load baz.foo.bar
  %a = call i32 @Foo(Int32)@bar(%baz.foo.ptr)

  ; Load baz.foo.common
  %b = call i64 @Foo(?)@common(%baz.foo.ptr)

  ; Sum
  %sum = add i64 %a, %b

  ; Puts
  call @puts(i64 %sum)

  ; Return
  ret 0
}