remove crop(), fill(), fit(), order(), and shape()

compiler/rungen/expr.go

@@ -308,9 +308,6 @@ func (b *Builder) compileAssignment(node *dag.Assignment) (expr.Assignment, erro
 }
 
 func (b *Builder) compileCall(call *dag.CallExpr) (expr.Evaluator, error) {
-	if tf := expr.NewShaperTransform(call.Tag); tf != 0 {
-		return b.compileShaper(call.Args, tf)
-	}
 	// First check if call is to a user defined function, otherwise check for
 	// builtin function.
 	var fn expr.Function
@@ -361,18 +358,6 @@ func (b *Builder) compileMapCall(a *dag.MapCallExpr) (expr.Evaluator, error) {
 	return expr.NewMapCall(b.sctx(), e, lambda), nil
 }
 
-func (b *Builder) compileShaper(args []dag.Expr, tf expr.ShaperTransform) (expr.Evaluator, error) {
-	field, err := b.compileExpr(args[0])
-	if err != nil {
-		return nil, err
-	}
-	typExpr, err := b.compileExpr(args[1])
-	if err != nil {
-		return nil, err
-	}
-	return expr.NewShaper(b.sctx(), field, typExpr, tf)
-}
-
 func (b *Builder) compileExprs(in []dag.Expr) ([]expr.Evaluator, error) {
 	var exprs []expr.Evaluator
 	for _, e := range in {

compiler/rungen/vexpr.go

@@ -191,9 +191,6 @@ func (b *Builder) compileVamCall(call *dag.CallExpr) (vamexpr.Evaluator, error)
 	if call.Tag == "cast" {
 		return b.compileVamCast(call.Args)
 	}
-	if tf := expr.NewShaperTransform(call.Tag); tf != 0 {
-		return b.compileVamShaper(call.Args, tf)
-	}
 	var fn vamexpr.Function
 	if f, ok := b.funcs[call.Tag]; ok {
 		var err error
@@ -256,14 +253,6 @@ func (b *Builder) compileVamCast(args []dag.Expr) (vamexpr.Evaluator, error) {
 	return vamexpr.NewSamExpr(e), nil
 }
 
-func (b *Builder) compileVamShaper(args []dag.Expr, tf expr.ShaperTransform) (vamexpr.Evaluator, error) {
-	shaper, err := b.compileShaper(args, tf)
-	if err != nil {
-		return nil, err
-	}
-	return vamexpr.NewSamExpr(shaper), nil
-}
-
 func (b *Builder) compileVamRecordExpr(e *dag.RecordExpr) (vamexpr.Evaluator, error) {
 	var elems []vamexpr.RecordElem
 	for _, elem := range e.Elems {

compiler/semantic/expr.go

@@ -724,11 +724,6 @@ func (t *translator) semCallByName(call *ast.Call, name string, args []sem.Expr)
 	}
 	nameLower := strings.ToLower(name)
 	switch {
-	case expr.NewShaperTransform(nameLower) != 0:
-		if err := function.CheckArgCount(nargs, 2, 2); err != nil {
-			t.error(call, err)
-			return badExpr()
-		}
 	case nameLower == "map":
 		return t.semMapCall(call, args)
 	case nameLower == "grep":

runtime/sam/expr/shaper.go

@@ -25,82 +25,6 @@ const (
 	Order
 )
 
-func NewShaperTransform(s string) ShaperTransform {
-	switch s {
-	case "crop":
-		return Crop
-	case "fill":
-		return Fill
-	case "fit":
-		return Crop | Fill
-	case "order":
-		return Order
-	case "shape":
-		return Cast | Fill | Order
-	}
-	return 0
-}
-
-// NewShaper returns a shaper that will shape the result of expr
-// to the type returned by typeExpr according to tf.
-func NewShaper(sctx *super.Context, expr, typeExpr Evaluator, tf ShaperTransform) (Evaluator, error) {
-	if l, ok := typeExpr.(*Literal); ok {
-		typeVal := l.val
-		switch id := typeVal.Type().ID(); {
-		case id == super.IDType:
-			typ, err := sctx.LookupByValue(typeVal.Bytes())
-			if err != nil {
-				return nil, err
-			}
-			return NewConstShaper(sctx, expr, typ, tf), nil
-		case id == super.IDString && tf == Cast:
-			name := super.DecodeString(typeVal.Bytes())
-			if _, err := super.NewContext().LookupTypeNamed(name, super.TypeNull); err != nil {
-				return nil, err
-			}
-			return &casterNamedType{sctx, expr, name}, nil
-		}
-		return nil, fmt.Errorf("shaper type argument is not a type: %s", sup.FormatValue(typeVal))
-	}
-	return &Shaper{
-		sctx:       sctx,
-		expr:       expr,
-		typeExpr:   typeExpr,
-		transforms: tf,
-		shapers:    make(map[super.Type]*ConstShaper),
-	}, nil
-}
-
-type Shaper struct {
-	sctx       *super.Context
-	expr       Evaluator
-	typeExpr   Evaluator
-	transforms ShaperTransform
-
-	shapers map[super.Type]*ConstShaper
-}
-
-func (s *Shaper) Eval(this super.Value) super.Value {
-	typeVal := s.typeExpr.Eval(this)
-	switch id := typeVal.Type().ID(); {
-	case id == super.IDType:
-		typ, err := s.sctx.LookupByValue(typeVal.Bytes())
-		if err != nil {
-			return s.sctx.NewError(err)
-		}
-		shaper, ok := s.shapers[typ]
-		if !ok {
-			shaper = NewConstShaper(s.sctx, s.expr, typ, s.transforms)
-			s.shapers[typ] = shaper
-		}
-		return shaper.Eval(this)
-	case id == super.IDString && s.transforms == Cast:
-		name := super.DecodeString(typeVal.Bytes())
-		return (&casterNamedType{s.sctx, s.expr, name}).Eval(this)
-	}
-	return s.sctx.WrapError("shaper type argument is not a type", typeVal)
-}
-
 type ConstShaper struct {
 	sctx       *super.Context
 	expr       Evaluator