Golang: package setup to orchestrate initialization

Using Action as a map key seems dubious. As I understand it, a pointer to a function can only be compared to nil, not other function pointers, so I'm not sure how this would work with a map. I'd be very interested to see some unit tests showing this working as expected if you have some time.

Addressing the code shown, this could potentially be a lot simpler, but I'm not sure I follow what you're trying to accomplish with ranking. Custom types like you have defined (not type aliases) can have methods, so you can attach a method to any given Func and use it to chain multiple Func together.

// Given the Func type you have defined in your code.
func (f Func) Then(others ...Func) Func {
    // func() is implicitly cast to Func.
    // This cast works with return values and parameters.
    return func() {
        f()
        // Call all other Func, if any.
        for _, other := range others {
            other()
        }
    }
}

Edit: Including a DependsOn method to Func for "happens before" type relationships.

func (f Func) DependsOn(dependencies ...Func) Func {
    return func() {
        // Call all other Func, if any.
        for _, other := range others {
            other()
        }
        f()
    }
}

You could use this pattern to add things before or after a Func executes to construct whatever logic your heart desires. Since Func is really a function under the hood, you can just call it with all of its embedded functions, and they'll all execute in the order specified.

Also, it looks like you might be coming from a C background (guessing from the *_t). In Go, we really try to avoid global state. This could potentially be done using a constructor function and methods for setup_t.

// A list of actions and their dependencies.
type setup_t struct {
    sequence     sequence_t
    sernos       sernos_t
    dependencies dependencies_t
}

// No longer needed! :)
// var setup *setup_t = new(setup_t)

// NewSetup allows constructing and initializing a setup_t.
func NewSetup() *setup_t {
    i := -1
    setup.sequence = func() int { i = i + 1; return i }
    setup.sernos = make(sernos_t)
    setup.dependencies = make(dependencies_t)
}

// Using 'setup' as the method receiver means you wouldn't have to change any
// code inside these methods, and you wouldn't be referencing global state.
// After this, you could refactor to make the receiver more idiomatic.

func (setup *setup_t) Add(init Func, dependencies ...Action) Action {
    /* ... */
}

func (setup *setup_t) Exec() {
    /* ... */
}

This change could make your main code look something like this.

func main() {
    // Alternative using only Func with Then chaining.
    abcd := setup.Func(func(){fmt.Println("a")}).
        // Showing multiple Funcs in Then.
        Then(func(){fmt.Println("b")}, func(){fmt.Println("c")}).
        Then(func(){fmt.Println("d")})
    abcd()
    // Prints: a, b, c, d

    // EDIT: Using DependsOn, with underscore identifiers to prevent issues later in the code.
    // The receiver type is still a function, and these methods produce a closure that calls parameters, so there's no issue with the receiver being singular.
    _a := setup.Func(func() {fmt.Println("a")})
    _b := setup.Func(func() {fmt.Println("b")})
    _c := setup.Func(func() {fmt.Println("c")})
    _d := setup.Func(func() {fmt.Println("d")})
    abdc := _d.DependsOn(_a, _b).Then(_c)
    abdc()
    // Prints: a, b, d, c

    // Intentionally shadowing the 'setup' package name here.
    // Everything below this can remain the same with this shadowing.
    // I'd recommend changing this name with a refactor though.
    setup := setup.NewSetup()
    // a depends on nothing
    a := setup.Add(func() { fmt.Println("a") })
    // b depends on a
    b := setup.Add(func() { fmt.Println("b") }, a)
    // c depends on b
    c := setup.Add(func() { fmt.Println("c") }, b)
    // d depends on a
    d := setup.Add(func() { fmt.Println("d") }, a)
    _, _ = c, d
    setup.Exec()
    // Prints: a, b, d, c
}

A practical example of setting up function method chaining can be seen here.

// Task is a convenient way to make a function that satisfies the Runner interface, and allows for more flexible invocation options.
type Task func(ctx context.Context) error

/* ... */

func (t Task) Run(ctx context.Context) error {
    return t(ctx)
}

/* ... */

func (t Task) Then(other Runner) Task {
    return func(ctx context.Context) error {
        if err := t(ctx); err != nil {
            return err
        }
        return other.Run(ctx)
    }
}

// Catch runs the catch function if this Task returns an error.
func (t Task) Catch(catch func(error) error) Task {
    return func(ctx context.Context) error {
        if err := t(ctx); err != nil {
            return catch(err)
        }
        return nil
    }
}