Store a collection of constructors for types that all conform to the same interface

I'm making an app that'll need sets of rules to run a job. The app offers the possibility to express the rules in one of several different languages. I therefore have defined an interface to a live rules engine, that offers the methods that the app will need to query the current set of rules. Behind this interface, there will be one different type of engine, according to the source language.

Now I'd like to instantiate a rules engine according to the rule file's extension. But I get some errors which I have a hard time to overcome.

Let me first offer this simplified skeleton :

package main

//
//
// The interface

type RulesEngine interface {
	SomeRuleEvaluator(string) bool
}

//
//
// An implementation, with its constructor

type ASimpleRulesEngine struct {
	// I've also tried with :
	// RulesEngine
}

func NewASimpleRulesEngine(context string) *ASimpleRulesEngine {
	re := ASimpleRulesEngine{}
	return &re
}

func (re *ASimpleRulesEngine) SomeRuleEvaluator(dummy string) bool {
	return true
}

//
//
// A client, that'll want to be able to choose a constructor

var rulesEngineConstructorsPerExtension map[string](func(string) RulesEngine)

func init() {
    rulesEngineConstructorsPerExtension = make(map[string](func(string)RulesEngine))
	rulesEngineConstructorsPerExtension[".ini"] = NewASimpleRulesEngine
}

func main() {
}

When I try to build this, I get 35: cannot use NewASimpleRulesEngine (type func(string) *ASimpleRulesEngine) as type func(string) RulesEngine in assignment

I've also tried :

• assigning without a pointer, although I felt stupid while trying it
• having an intermediate step in the initfunction, where I'd create a new(func (string) RulesEngine) and then assign to it, with and without pointer.
• storing function pointers like in C, but the compiler said it could not take the adress of my function.

I'm not that familiar with Go and this felt a bit surprising. What would be the proper type signature to use ? Is this possible at all ? If it's unavoidable, I'll obviously have a simple array of extensions on one side (to check if a file is potentially a rules file), and a big switch on the other side to provide the adequate constructor, but as much possible I'd like to avoid such duplication.

Thank you for any insight !

(edited : I've accepted my own answer for lack of any other, but its most relevant part is @seh 's comment below)

Following @JorgeMarey 's comment, and not wanting to sacrifice the constructor's type signature, I came up with this. But it does feel very tacky to me. I'll be glad to hear about a cleaner way.

func init() {
    rulesEngineConstructorsPerExtension = make(map[string](func(string)RulesEngine))

	cast_NewASimpleRulesEngine := func(content string) RulesEngine {
	    return NewASimpleRulesEngine(content)
    }

	rulesEngineConstructorsPerExtension[".ini"] = cast_NewASimpleRulesEngine
}

(an attempt to explicitly cast with (func(string)RulesEngine)( NewASimpleRulesEngine) was deemed unfit by the compiler too)