lang: core: Simplify list and map lookup default functions

examples/lang/lookup_default.mcl

@@ -0,0 +1,22 @@
+import "fmt"
+
+$some_list = ["l", "m", "n",]
+
+$some_map = {
+	"ottawa" => 6,
+	"toronto" => 7,
+	"montreal" => 8,
+	"vancouver" => 9,
+}
+
+print "letter" {
+	msg => fmt.printf("letter: %s", $some_list[13] || "j"),
+
+	Meta:autogroup => false,
+}
+
+print "city" {
+	msg => fmt.printf("city: %d", $some_map["montréal"] || 13),
+
+	Meta:autogroup => false,
+}

lang/core/list_lookup_default.go

@@ -34,206 +34,39 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/purpleidea/mgmt/lang/funcs"
+	"github.com/purpleidea/mgmt/lang/funcs/simple"
-	"github.com/purpleidea/mgmt/lang/interfaces"
 	"github.com/purpleidea/mgmt/lang/types"
-	"github.com/purpleidea/mgmt/util/errwrap"
 )
 
 const (
 	// ListLookupDefaultFuncName is the name this function is registered as.
 	ListLookupDefaultFuncName = "list_lookup_default"
-
-	// arg names...
-	listLookupDefaultArgNameList    = "list"
-	listLookupDefaultArgNameIndex   = "index"
-	listLookupDefaultArgNameDefault = "default"
 )
 
 func init() {
-	funcs.Register(ListLookupDefaultFuncName, func() interfaces.Func { return &ListLookupDefaultFunc{} }) // must register the func and name
+	simple.Register(ListLookupDefaultFuncName, &simple.Scaffold{
+		T: types.NewType("func(list []?1, index int, default ?1) ?1"),
+		F: ListLookupDefault,
+	})
 }
 
-var _ interfaces.BuildableFunc = &ListLookupDefaultFunc{} // ensure it meets this expectation
+// ListLookupDefault returns the value corresponding to the input index in the
-
+// list. If the value is not present, it returns the default value supplied.
-// ListLookupDefaultFunc is a list index lookup function. If you provide a
+func ListLookupDefault(ctx context.Context, input []types.Value) (types.Value, error) {
-// negative index, then it will return the default value you specified for this
+	l := input[0].(*types.ListValue)
-// function.
+	index := input[1].Int()
-// TODO: Eventually we will deprecate this function when the function engine can
-// support passing a value for erroring functions. (Bad index could be an err!)
-type ListLookupDefaultFunc struct {
-	// TODO: Logically should this be ported to be the type of the elements?
-	Type *types.Type // Kind == List, that is used as the list we lookup in
-
-	init *interfaces.Init
-	last types.Value // last value received to use for diff
-
-	result types.Value // last calculated output
-}
-
-// String returns a simple name for this function. This is needed so this struct
-// can satisfy the pgraph.Vertex interface.
-func (obj *ListLookupDefaultFunc) String() string {
-	return ListLookupDefaultFuncName
-}
-
-// ArgGen returns the Nth arg name for this function.
-func (obj *ListLookupDefaultFunc) ArgGen(index int) (string, error) {
-	seq := []string{listLookupDefaultArgNameList, listLookupDefaultArgNameIndex, listLookupDefaultArgNameDefault}
-	if l := len(seq); index >= l {
-		return "", fmt.Errorf("index %d exceeds arg length of %d", index, l)
-	}
-	return seq[index], nil
-}
-
-// helper
-func (obj *ListLookupDefaultFunc) sig() *types.Type {
-	// func(list []?1, index int, default ?1) ?1
-	v := "?1"
-	if obj.Type != nil { // don't panic if called speculatively
-		v = obj.Type.Val.String()
-	}
-	return types.NewType(fmt.Sprintf(
-		"func(%s []%s, %s int, %s %s) %s",
-		listLookupDefaultArgNameList, v,
-		listLookupDefaultArgNameIndex,
-		listLookupDefaultArgNameDefault, v,
-		v,
-	))
-}
-
-// Build is run to turn the polymorphic, undetermined function, into the
-// specific statically typed version. It is usually run after Unify completes,
-// and must be run before Info() and any of the other Func interface methods are
-// used. This function is idempotent, as long as the arg isn't changed between
-// runs.
-func (obj *ListLookupDefaultFunc) Build(typ *types.Type) (*types.Type, error) {
-	// typ is the KindFunc signature we're trying to build...
-	if typ.Kind != types.KindFunc {
-		return nil, fmt.Errorf("input type must be of kind func")
-	}
-
-	if len(typ.Ord) != 3 {
-		return nil, fmt.Errorf("the listlookup function needs exactly three args")
-	}
-	if typ.Out == nil {
-		return nil, fmt.Errorf("return type of function must be specified")
-	}
-	if typ.Map == nil {
-		return nil, fmt.Errorf("invalid input type")
-	}
-
-	tList, exists := typ.Map[typ.Ord[0]]
-	if !exists || tList == nil {
-		return nil, fmt.Errorf("first arg must be specified")
-	}
-
-	tIndex, exists := typ.Map[typ.Ord[1]]
-	if !exists || tIndex == nil {
-		return nil, fmt.Errorf("second arg must be specified")
-	}
-
-	tDefault, exists := typ.Map[typ.Ord[2]]
-	if !exists || tDefault == nil {
-		return nil, fmt.Errorf("third arg must be specified")
-	}
-
-	if tIndex != nil && tIndex.Kind != types.KindInt {
-		return nil, fmt.Errorf("index must be int kind")
-	}
-
-	if err := tList.Val.Cmp(tDefault); err != nil {
-		return nil, errwrap.Wrapf(err, "default must match list val type")
-	}
-
-	if err := tList.Val.Cmp(typ.Out); err != nil {
-		return nil, errwrap.Wrapf(err, "return type must match list val type")
-	}
-
-	obj.Type = tList // list type
-	return obj.sig(), nil
-}
-
-// Validate tells us if the input struct takes a valid form.
-func (obj *ListLookupDefaultFunc) Validate() error {
-	if obj.Type == nil { // build must be run first
-		return fmt.Errorf("type is still unspecified")
-	}
-	if obj.Type.Kind != types.KindList {
-		return fmt.Errorf("type must be a kind of list")
-	}
-	return nil
-}
-
-// Info returns some static info about itself. Build must be called before this
-// will return correct data.
-func (obj *ListLookupDefaultFunc) Info() *interfaces.Info {
-	return &interfaces.Info{
-		Pure: true,
-		Memo: false,
-		Sig:  obj.sig(), // helper
-		Err:  obj.Validate(),
-	}
-}
-
-// Init runs some startup code for this function.
-func (obj *ListLookupDefaultFunc) Init(init *interfaces.Init) error {
-	obj.init = init
-	return nil
-}
-
-// Stream returns the changing values that this func has over time.
-func (obj *ListLookupDefaultFunc) Stream(ctx context.Context) error {
-	defer close(obj.init.Output) // the sender closes
-	for {
-		select {
-		case input, ok := <-obj.init.Input:
-			if !ok {
-				return nil // can't output any more
-			}
-			//if err := input.Type().Cmp(obj.Info().Sig.Input); err != nil {
-			//	return errwrap.Wrapf(err, "wrong function input")
-			//}
-
-			if obj.last != nil && input.Cmp(obj.last) == nil {
-				continue // value didn't change, skip it
-			}
-			obj.last = input // store for next
-
-			l := (input.Struct()[listLookupDefaultArgNameList]).(*types.ListValue)
-			index := input.Struct()[listLookupDefaultArgNameIndex].Int()
-			def := input.Struct()[listLookupDefaultArgNameDefault]
 
 	// TODO: should we handle overflow by returning default?
 	if index > math.MaxInt { // max int size varies by arch
-				return fmt.Errorf("list index overflow, got: %d, max is: %d", index, math.MaxInt)
+		return nil, fmt.Errorf("list index overflow, got: %d, max is: %d", index, math.MaxInt)
+	}
+	if index < 0 { // lists can't have negative indexes (for now)
+		return nil, fmt.Errorf("list index negative, got: %d", index)
 	}
 
-			// negative index values are "not found" here!
-			var result types.Value
 	val, exists := l.Lookup(int(index))
-			if exists {
+	if !exists {
-				result = val
+		return input[2], nil // default value
-			} else {
-				result = def
-			}
-
-			// if previous input was `2 + 4`, but now it
-			// changed to `1 + 5`, the result is still the
-			// same, so we can skip sending an update...
-			if obj.result != nil && result.Cmp(obj.result) == nil {
-				continue // result didn't change
-			}
-			obj.result = result // store new result
-
-		case <-ctx.Done():
-			return nil
-		}
-
-		select {
-		case obj.init.Output <- obj.result: // send
-		case <-ctx.Done():
-			return nil
-		}
 	}
+	return val, nil
 }

lang/core/lookup_default.go

@@ -108,16 +108,30 @@ func (obj *LookupDefaultFunc) Build(typ *types.Type) (*types.Type, error) {
 		return nil, fmt.Errorf("first arg must have a type")
 	}
 
+	name := ""
 	if tListOrMap.Kind == types.KindList {
-		obj.fn = &ListLookupDefaultFunc{} // set it
+		name = ListLookupDefaultFuncName
-		return obj.fn.Build(typ)
 	}
 	if tListOrMap.Kind == types.KindMap {
-		obj.fn = &MapLookupDefaultFunc{} // set it
+		name = MapLookupDefaultFuncName
-		return obj.fn.Build(typ)
+	}
+	if name == "" {
+		return nil, fmt.Errorf("we must lookup from either a list or a map")
 	}
 
-	return nil, fmt.Errorf("we must lookup from either a list or a map")
+	f, err := funcs.Lookup(name)
+	if err != nil {
+		// programming error
+		return nil, err
+	}
+	bf, ok := f.(interfaces.BuildableFunc)
+	if !ok {
+		// programming error
+		return nil, fmt.Errorf("not a BuildableFunc")
+	}
+	obj.fn = bf
+
+	return obj.fn.Build(typ)
 }
 
 // Validate tells us if the input struct takes a valid form.

lang/core/map_lookup_default.go

@@ -31,204 +31,31 @@ package core
 
 import (
 	"context"
-	"fmt"
 
-	"github.com/purpleidea/mgmt/lang/funcs"
+	"github.com/purpleidea/mgmt/lang/funcs/simple"
-	"github.com/purpleidea/mgmt/lang/interfaces"
 	"github.com/purpleidea/mgmt/lang/types"
-	"github.com/purpleidea/mgmt/util/errwrap"
 )
 
 const (
 	// MapLookupDefaultFuncName is the name this function is registered as.
 	MapLookupDefaultFuncName = "map_lookup_default"
-
-	// arg names...
-	mapLookupDefaultArgNameMap = "map"
-	mapLookupDefaultArgNameKey = "key"
-	mapLookupDefaultArgNameDef = "default"
 )
 
 func init() {
-	funcs.Register(MapLookupDefaultFuncName, func() interfaces.Func { return &MapLookupDefaultFunc{} }) // must register the func and name
+	simple.Register(MapLookupDefaultFuncName, &simple.Scaffold{
+		T: types.NewType("func(map map{?1: ?2}, key ?1, default ?2) ?2"),
+		F: MapLookupDefault,
+	})
 }
 
-var _ interfaces.BuildableFunc = &MapLookupDefaultFunc{} // ensure it meets this expectation
+// MapLookupDefault returns the value corresponding to the input key in the map.
+// If the value is not present, it returns the default value supplied.
+func MapLookupDefault(ctx context.Context, input []types.Value) (types.Value, error) {
+	m := input[0].(*types.MapValue)
 
-// MapLookupDefaultFunc is a key map lookup function. If you provide a missing
+	val, exists := m.Lookup(input[1])
-// key, then it will return the default value you specified for this function.
+	if !exists {
-// TODO: Eventually we will deprecate this function when the function engine can
+		return input[2], nil // default value
-// support passing a value for erroring functions. (Bad index could be an err!)
+	}
-type MapLookupDefaultFunc struct {
+	return val, nil
-	Type *types.Type // Kind == Map, that is used as the map we lookup
-
-	init *interfaces.Init
-	last types.Value // last value received to use for diff
-
-	result types.Value // last calculated output
-}
-
-// String returns a simple name for this function. This is needed so this struct
-// can satisfy the pgraph.Vertex interface.
-func (obj *MapLookupDefaultFunc) String() string {
-	return MapLookupDefaultFuncName
-}
-
-// ArgGen returns the Nth arg name for this function.
-func (obj *MapLookupDefaultFunc) ArgGen(index int) (string, error) {
-	seq := []string{mapLookupDefaultArgNameMap, mapLookupDefaultArgNameKey, mapLookupDefaultArgNameDef}
-	if l := len(seq); index >= l {
-		return "", fmt.Errorf("index %d exceeds arg length of %d", index, l)
-	}
-	return seq[index], nil
-}
-
-// helper
-func (obj *MapLookupDefaultFunc) sig() *types.Type {
-	// func(map map{?1: ?2}, key ?1) ?2
-	k := "?1"
-	v := "?2"
-	m := fmt.Sprintf("map{%s: %s}", k, v)
-	if obj.Type != nil { // don't panic if called speculatively
-		k = obj.Type.Key.String()
-		v = obj.Type.Val.String()
-		m = obj.Type.String()
-	}
-	return types.NewType(fmt.Sprintf(
-		"func(%s %s, %s %s, %s %s) %s",
-		mapLookupDefaultArgNameMap, m,
-		mapLookupDefaultArgNameKey, k,
-		mapLookupDefaultArgNameDef, v,
-		v,
-	))
-}
-
-// Build is run to turn the polymorphic, undetermined function, into the
-// specific statically typed version. It is usually run after Unify completes,
-// and must be run before Info() and any of the other Func interface methods are
-// used. This function is idempotent, as long as the arg isn't changed between
-// runs.
-func (obj *MapLookupDefaultFunc) Build(typ *types.Type) (*types.Type, error) {
-	// typ is the KindFunc signature we're trying to build...
-	if typ.Kind != types.KindFunc {
-		return nil, fmt.Errorf("input type must be of kind func")
-	}
-
-	if len(typ.Ord) != 3 {
-		return nil, fmt.Errorf("the maplookup function needs exactly three args")
-	}
-	if typ.Out == nil {
-		return nil, fmt.Errorf("return type of function must be specified")
-	}
-	if typ.Map == nil {
-		return nil, fmt.Errorf("invalid input type")
-	}
-
-	tMap, exists := typ.Map[typ.Ord[0]]
-	if !exists || tMap == nil {
-		return nil, fmt.Errorf("first arg must be specified")
-	}
-
-	tKey, exists := typ.Map[typ.Ord[1]]
-	if !exists || tKey == nil {
-		return nil, fmt.Errorf("second arg must be specified")
-	}
-
-	tDef, exists := typ.Map[typ.Ord[2]]
-	if !exists || tDef == nil {
-		return nil, fmt.Errorf("third arg must be specified")
-	}
-
-	if err := tMap.Key.Cmp(tKey); err != nil {
-		return nil, errwrap.Wrapf(err, "key must match map key type")
-	}
-
-	if err := tMap.Val.Cmp(tDef); err != nil {
-		return nil, errwrap.Wrapf(err, "default must match map val type")
-	}
-
-	if err := tMap.Val.Cmp(typ.Out); err != nil {
-		return nil, errwrap.Wrapf(err, "return type must match map val type")
-	}
-
-	obj.Type = tMap // map type
-	return obj.sig(), nil
-}
-
-// Validate tells us if the input struct takes a valid form.
-func (obj *MapLookupDefaultFunc) Validate() error {
-	if obj.Type == nil { // build must be run first
-		return fmt.Errorf("type is still unspecified")
-	}
-	if obj.Type.Kind != types.KindMap {
-		return fmt.Errorf("type must be a kind of map")
-	}
-	return nil
-}
-
-// Info returns some static info about itself. Build must be called before this
-// will return correct data.
-func (obj *MapLookupDefaultFunc) Info() *interfaces.Info {
-	return &interfaces.Info{
-		Pure: true,
-		Memo: false,
-		Sig:  obj.sig(), // helper
-		Err:  obj.Validate(),
-	}
-}
-
-// Init runs some startup code for this function.
-func (obj *MapLookupDefaultFunc) Init(init *interfaces.Init) error {
-	obj.init = init
-	return nil
-}
-
-// Stream returns the changing values that this func has over time.
-func (obj *MapLookupDefaultFunc) Stream(ctx context.Context) error {
-	defer close(obj.init.Output) // the sender closes
-	for {
-		select {
-		case input, ok := <-obj.init.Input:
-			if !ok {
-				return nil // can't output any more
-			}
-			//if err := input.Type().Cmp(obj.Info().Sig.Input); err != nil {
-			//	return errwrap.Wrapf(err, "wrong function input")
-			//}
-
-			if obj.last != nil && input.Cmp(obj.last) == nil {
-				continue // value didn't change, skip it
-			}
-			obj.last = input // store for next
-
-			m := (input.Struct()[mapLookupDefaultArgNameMap]).(*types.MapValue)
-			key := input.Struct()[mapLookupDefaultArgNameKey]
-			def := input.Struct()[mapLookupDefaultArgNameDef]
-
-			var result types.Value
-			val, exists := m.Lookup(key)
-			if exists {
-				result = val
-			} else {
-				result = def
-			}
-
-			// if previous input was `2 + 4`, but now it
-			// changed to `1 + 5`, the result is still the
-			// same, so we can skip sending an update...
-			if obj.result != nil && result.Cmp(obj.result) == nil {
-				continue // result didn't change
-			}
-			obj.result = result // store new result
-
-		case <-ctx.Done():
-			return nil
-		}
-
-		select {
-		case obj.init.Output <- obj.result: // send
-		case <-ctx.Done():
-			return nil
-		}
-	}
 }