diff --git a/Makefile b/Makefile index 3a8acf7..b917775 100644 --- a/Makefile +++ b/Makefile @@ -3,5 +3,8 @@ all: gen test: gen go test ./... +fmt: gen + go fmt ./... + gen: (cd core && make gen) diff --git a/core/math.go b/core/math.go index 11679d4..db899d0 100644 --- a/core/math.go +++ b/core/math.go @@ -16,714 +16,589 @@ func mathReduce(fn mathReduceFn, zero types.Elem, s seq.Seq) types.Elem { return seq.Reduce(reduceFn, zero, s) } - - - func plusInt(a, b types.Elem) types.Elem { - return types.GoType{ Int(a) + Int(b) } + return types.GoType{Int(a) + Int(b)} } func plusInt8(a, b types.Elem) types.Elem { - return types.GoType{ Int8(a) + Int8(b) } + return types.GoType{Int8(a) + Int8(b)} } func plusInt16(a, b types.Elem) types.Elem { - return types.GoType{ Int16(a) + Int16(b) } + return types.GoType{Int16(a) + Int16(b)} } func plusInt32(a, b types.Elem) types.Elem { - return types.GoType{ Int32(a) + Int32(b) } + return types.GoType{Int32(a) + Int32(b)} } func plusInt64(a, b types.Elem) types.Elem { - return types.GoType{ Int64(a) + Int64(b) } + return types.GoType{Int64(a) + Int64(b)} } func plusUint(a, b types.Elem) types.Elem { - return types.GoType{ Uint(a) + Uint(b) } + return types.GoType{Uint(a) + Uint(b)} } func plusUint8(a, b types.Elem) types.Elem { - return types.GoType{ Uint8(a) + Uint8(b) } + return types.GoType{Uint8(a) + Uint8(b)} } func plusUint16(a, b types.Elem) types.Elem { - return types.GoType{ Uint16(a) + Uint16(b) } + return types.GoType{Uint16(a) + Uint16(b)} } func plusUint32(a, b types.Elem) types.Elem { - return types.GoType{ Uint32(a) + Uint32(b) } + return types.GoType{Uint32(a) + Uint32(b)} } func plusUint64(a, b types.Elem) types.Elem { - return types.GoType{ Uint64(a) + Uint64(b) } + return types.GoType{Uint64(a) + Uint64(b)} } func plusFloat32(a, b types.Elem) types.Elem { - return types.GoType{ Float32(a) + Float32(b) } + return types.GoType{Float32(a) + Float32(b)} } func plusFloat64(a, b types.Elem) types.Elem { - return types.GoType{ Float64(a) + Float64(b) } + return types.GoType{Float64(a) + Float64(b)} } func plusComplex64(a, b types.Elem) types.Elem { - return types.GoType{ Complex64(a) + Complex64(b) } + return types.GoType{Complex64(a) + Complex64(b)} } func plusComplex128(a, b types.Elem) types.Elem { - return types.GoType{ Complex128(a) + Complex128(b) } + return types.GoType{Complex128(a) + Complex128(b)} } - func plusString(a, b types.Elem) types.Elem { - return types.GoType{ String(a) + String(b) } + return types.GoType{String(a) + String(b)} } func Plus(s seq.Seq) types.Elem { var first, zero types.Elem - + if seq.Empty(s) { - return types.GoType{ 0 } + return types.GoType{0} } first, _, _ = s.FirstRest() - var fn mathReduceFn switch first.(types.GoType).V.(type) { - + case int: fn = plusInt - - zero = types.GoType{ int(0) } - - + zero = types.GoType{int(0)} + case int8: fn = plusInt8 - - zero = types.GoType{ int8(0) } - - + zero = types.GoType{int8(0)} + case int16: fn = plusInt16 - - zero = types.GoType{ int16(0) } - - + zero = types.GoType{int16(0)} + case int32: fn = plusInt32 - - zero = types.GoType{ int32(0) } - - + zero = types.GoType{int32(0)} + case int64: fn = plusInt64 - - zero = types.GoType{ int64(0) } - - + zero = types.GoType{int64(0)} + case uint: fn = plusUint - - zero = types.GoType{ uint(0) } - - + zero = types.GoType{uint(0)} + case uint8: fn = plusUint8 - - zero = types.GoType{ uint8(0) } - - + zero = types.GoType{uint8(0)} + case uint16: fn = plusUint16 - - zero = types.GoType{ uint16(0) } - - + zero = types.GoType{uint16(0)} + case uint32: fn = plusUint32 - - zero = types.GoType{ uint32(0) } - - + zero = types.GoType{uint32(0)} + case uint64: fn = plusUint64 - - zero = types.GoType{ uint64(0) } - - + zero = types.GoType{uint64(0)} + case float32: fn = plusFloat32 - - zero = types.GoType{ float32(0) } - - + zero = types.GoType{float32(0)} + case float64: fn = plusFloat64 - - zero = types.GoType{ float64(0) } - - + zero = types.GoType{float64(0)} + case complex64: fn = plusComplex64 - - zero = types.GoType{ complex64(0) } - - + zero = types.GoType{complex64(0)} + case complex128: fn = plusComplex128 - - zero = types.GoType{ complex128(0) } - - - + zero = types.GoType{complex128(0)} + case string: fn = plusString zero = types.GoType{string("")} - + default: panic(fmt.Sprintf("$#v cannot have Plus called on it", first)) } return mathReduce(fn, zero, s) } - - - func minusInt(a, b types.Elem) types.Elem { - return types.GoType{ Int(a) - Int(b) } + return types.GoType{Int(a) - Int(b)} } func minusInt8(a, b types.Elem) types.Elem { - return types.GoType{ Int8(a) - Int8(b) } + return types.GoType{Int8(a) - Int8(b)} } func minusInt16(a, b types.Elem) types.Elem { - return types.GoType{ Int16(a) - Int16(b) } + return types.GoType{Int16(a) - Int16(b)} } func minusInt32(a, b types.Elem) types.Elem { - return types.GoType{ Int32(a) - Int32(b) } + return types.GoType{Int32(a) - Int32(b)} } func minusInt64(a, b types.Elem) types.Elem { - return types.GoType{ Int64(a) - Int64(b) } + return types.GoType{Int64(a) - Int64(b)} } func minusUint(a, b types.Elem) types.Elem { - return types.GoType{ Uint(a) - Uint(b) } + return types.GoType{Uint(a) - Uint(b)} } func minusUint8(a, b types.Elem) types.Elem { - return types.GoType{ Uint8(a) - Uint8(b) } + return types.GoType{Uint8(a) - Uint8(b)} } func minusUint16(a, b types.Elem) types.Elem { - return types.GoType{ Uint16(a) - Uint16(b) } + return types.GoType{Uint16(a) - Uint16(b)} } func minusUint32(a, b types.Elem) types.Elem { - return types.GoType{ Uint32(a) - Uint32(b) } + return types.GoType{Uint32(a) - Uint32(b)} } func minusUint64(a, b types.Elem) types.Elem { - return types.GoType{ Uint64(a) - Uint64(b) } + return types.GoType{Uint64(a) - Uint64(b)} } func minusFloat32(a, b types.Elem) types.Elem { - return types.GoType{ Float32(a) - Float32(b) } + return types.GoType{Float32(a) - Float32(b)} } func minusFloat64(a, b types.Elem) types.Elem { - return types.GoType{ Float64(a) - Float64(b) } + return types.GoType{Float64(a) - Float64(b)} } func minusComplex64(a, b types.Elem) types.Elem { - return types.GoType{ Complex64(a) - Complex64(b) } + return types.GoType{Complex64(a) - Complex64(b)} } func minusComplex128(a, b types.Elem) types.Elem { - return types.GoType{ Complex128(a) - Complex128(b) } + return types.GoType{Complex128(a) - Complex128(b)} } - func Minus(s seq.Seq) types.Elem { var first, zero types.Elem - + if seq.Empty(s) { panic("Minus cannot be called with no arguments") } zero, s, _ = s.FirstRest() first = zero - var fn mathReduceFn switch first.(types.GoType).V.(type) { - + case int: fn = minusInt - - + case int8: fn = minusInt8 - - + case int16: fn = minusInt16 - - + case int32: fn = minusInt32 - - + case int64: fn = minusInt64 - - + case uint: fn = minusUint - - + case uint8: fn = minusUint8 - - + case uint16: fn = minusUint16 - - + case uint32: fn = minusUint32 - - + case uint64: fn = minusUint64 - - + case float32: fn = minusFloat32 - - + case float64: fn = minusFloat64 - - + case complex64: fn = minusComplex64 - - + case complex128: fn = minusComplex128 - - - + default: panic(fmt.Sprintf("$#v cannot have Minus called on it", first)) } return mathReduce(fn, zero, s) } - - - func multInt(a, b types.Elem) types.Elem { - return types.GoType{ Int(a) * Int(b) } + return types.GoType{Int(a) * Int(b)} } func multInt8(a, b types.Elem) types.Elem { - return types.GoType{ Int8(a) * Int8(b) } + return types.GoType{Int8(a) * Int8(b)} } func multInt16(a, b types.Elem) types.Elem { - return types.GoType{ Int16(a) * Int16(b) } + return types.GoType{Int16(a) * Int16(b)} } func multInt32(a, b types.Elem) types.Elem { - return types.GoType{ Int32(a) * Int32(b) } + return types.GoType{Int32(a) * Int32(b)} } func multInt64(a, b types.Elem) types.Elem { - return types.GoType{ Int64(a) * Int64(b) } + return types.GoType{Int64(a) * Int64(b)} } func multUint(a, b types.Elem) types.Elem { - return types.GoType{ Uint(a) * Uint(b) } + return types.GoType{Uint(a) * Uint(b)} } func multUint8(a, b types.Elem) types.Elem { - return types.GoType{ Uint8(a) * Uint8(b) } + return types.GoType{Uint8(a) * Uint8(b)} } func multUint16(a, b types.Elem) types.Elem { - return types.GoType{ Uint16(a) * Uint16(b) } + return types.GoType{Uint16(a) * Uint16(b)} } func multUint32(a, b types.Elem) types.Elem { - return types.GoType{ Uint32(a) * Uint32(b) } + return types.GoType{Uint32(a) * Uint32(b)} } func multUint64(a, b types.Elem) types.Elem { - return types.GoType{ Uint64(a) * Uint64(b) } + return types.GoType{Uint64(a) * Uint64(b)} } func multFloat32(a, b types.Elem) types.Elem { - return types.GoType{ Float32(a) * Float32(b) } + return types.GoType{Float32(a) * Float32(b)} } func multFloat64(a, b types.Elem) types.Elem { - return types.GoType{ Float64(a) * Float64(b) } + return types.GoType{Float64(a) * Float64(b)} } func multComplex64(a, b types.Elem) types.Elem { - return types.GoType{ Complex64(a) * Complex64(b) } + return types.GoType{Complex64(a) * Complex64(b)} } func multComplex128(a, b types.Elem) types.Elem { - return types.GoType{ Complex128(a) * Complex128(b) } + return types.GoType{Complex128(a) * Complex128(b)} } - func Mult(s seq.Seq) types.Elem { var first, zero types.Elem - + if seq.Empty(s) { - return types.GoType{ 1 } + return types.GoType{1} } first, _, _ = s.FirstRest() - var fn mathReduceFn switch first.(types.GoType).V.(type) { - + case int: fn = multInt - - zero = types.GoType{ int(1) } - - + zero = types.GoType{int(1)} + case int8: fn = multInt8 - - zero = types.GoType{ int8(1) } - - + zero = types.GoType{int8(1)} + case int16: fn = multInt16 - - zero = types.GoType{ int16(1) } - - + zero = types.GoType{int16(1)} + case int32: fn = multInt32 - - zero = types.GoType{ int32(1) } - - + zero = types.GoType{int32(1)} + case int64: fn = multInt64 - - zero = types.GoType{ int64(1) } - - + zero = types.GoType{int64(1)} + case uint: fn = multUint - - zero = types.GoType{ uint(1) } - - + zero = types.GoType{uint(1)} + case uint8: fn = multUint8 - - zero = types.GoType{ uint8(1) } - - + zero = types.GoType{uint8(1)} + case uint16: fn = multUint16 - - zero = types.GoType{ uint16(1) } - - + zero = types.GoType{uint16(1)} + case uint32: fn = multUint32 - - zero = types.GoType{ uint32(1) } - - + zero = types.GoType{uint32(1)} + case uint64: fn = multUint64 - - zero = types.GoType{ uint64(1) } - - + zero = types.GoType{uint64(1)} + case float32: fn = multFloat32 - - zero = types.GoType{ float32(1) } - - + zero = types.GoType{float32(1)} + case float64: fn = multFloat64 - - zero = types.GoType{ float64(1) } - - + zero = types.GoType{float64(1)} + case complex64: fn = multComplex64 - - zero = types.GoType{ complex64(1) } - - + zero = types.GoType{complex64(1)} + case complex128: fn = multComplex128 - - zero = types.GoType{ complex128(1) } - - - + zero = types.GoType{complex128(1)} + default: panic(fmt.Sprintf("$#v cannot have Mult called on it", first)) } return mathReduce(fn, zero, s) } - - - func divInt(a, b types.Elem) types.Elem { - return types.GoType{ Int(a) / Int(b) } + return types.GoType{Int(a) / Int(b)} } func divInt8(a, b types.Elem) types.Elem { - return types.GoType{ Int8(a) / Int8(b) } + return types.GoType{Int8(a) / Int8(b)} } func divInt16(a, b types.Elem) types.Elem { - return types.GoType{ Int16(a) / Int16(b) } + return types.GoType{Int16(a) / Int16(b)} } func divInt32(a, b types.Elem) types.Elem { - return types.GoType{ Int32(a) / Int32(b) } + return types.GoType{Int32(a) / Int32(b)} } func divInt64(a, b types.Elem) types.Elem { - return types.GoType{ Int64(a) / Int64(b) } + return types.GoType{Int64(a) / Int64(b)} } func divUint(a, b types.Elem) types.Elem { - return types.GoType{ Uint(a) / Uint(b) } + return types.GoType{Uint(a) / Uint(b)} } func divUint8(a, b types.Elem) types.Elem { - return types.GoType{ Uint8(a) / Uint8(b) } + return types.GoType{Uint8(a) / Uint8(b)} } func divUint16(a, b types.Elem) types.Elem { - return types.GoType{ Uint16(a) / Uint16(b) } + return types.GoType{Uint16(a) / Uint16(b)} } func divUint32(a, b types.Elem) types.Elem { - return types.GoType{ Uint32(a) / Uint32(b) } + return types.GoType{Uint32(a) / Uint32(b)} } func divUint64(a, b types.Elem) types.Elem { - return types.GoType{ Uint64(a) / Uint64(b) } + return types.GoType{Uint64(a) / Uint64(b)} } func divFloat32(a, b types.Elem) types.Elem { - return types.GoType{ Float32(a) / Float32(b) } + return types.GoType{Float32(a) / Float32(b)} } func divFloat64(a, b types.Elem) types.Elem { - return types.GoType{ Float64(a) / Float64(b) } + return types.GoType{Float64(a) / Float64(b)} } func divComplex64(a, b types.Elem) types.Elem { - return types.GoType{ Complex64(a) / Complex64(b) } + return types.GoType{Complex64(a) / Complex64(b)} } func divComplex128(a, b types.Elem) types.Elem { - return types.GoType{ Complex128(a) / Complex128(b) } + return types.GoType{Complex128(a) / Complex128(b)} } - func Div(s seq.Seq) types.Elem { var first, zero types.Elem - + if seq.Empty(s) { panic("Div cannot be called with no arguments") } zero, s, _ = s.FirstRest() first = zero - var fn mathReduceFn switch first.(types.GoType).V.(type) { - + case int: fn = divInt - - + case int8: fn = divInt8 - - + case int16: fn = divInt16 - - + case int32: fn = divInt32 - - + case int64: fn = divInt64 - - + case uint: fn = divUint - - + case uint8: fn = divUint8 - - + case uint16: fn = divUint16 - - + case uint32: fn = divUint32 - - + case uint64: fn = divUint64 - - + case float32: fn = divFloat32 - - + case float64: fn = divFloat64 - - + case complex64: fn = divComplex64 - - + case complex128: fn = divComplex128 - - - + default: panic(fmt.Sprintf("$#v cannot have Div called on it", first)) } return mathReduce(fn, zero, s) } - - - func modInt(a, b types.Elem) types.Elem { - return types.GoType{ Int(a) % Int(b) } + return types.GoType{Int(a) % Int(b)} } func modInt8(a, b types.Elem) types.Elem { - return types.GoType{ Int8(a) % Int8(b) } + return types.GoType{Int8(a) % Int8(b)} } func modInt16(a, b types.Elem) types.Elem { - return types.GoType{ Int16(a) % Int16(b) } + return types.GoType{Int16(a) % Int16(b)} } func modInt32(a, b types.Elem) types.Elem { - return types.GoType{ Int32(a) % Int32(b) } + return types.GoType{Int32(a) % Int32(b)} } func modInt64(a, b types.Elem) types.Elem { - return types.GoType{ Int64(a) % Int64(b) } + return types.GoType{Int64(a) % Int64(b)} } func modUint(a, b types.Elem) types.Elem { - return types.GoType{ Uint(a) % Uint(b) } + return types.GoType{Uint(a) % Uint(b)} } func modUint8(a, b types.Elem) types.Elem { - return types.GoType{ Uint8(a) % Uint8(b) } + return types.GoType{Uint8(a) % Uint8(b)} } func modUint16(a, b types.Elem) types.Elem { - return types.GoType{ Uint16(a) % Uint16(b) } + return types.GoType{Uint16(a) % Uint16(b)} } func modUint32(a, b types.Elem) types.Elem { - return types.GoType{ Uint32(a) % Uint32(b) } + return types.GoType{Uint32(a) % Uint32(b)} } func modUint64(a, b types.Elem) types.Elem { - return types.GoType{ Uint64(a) % Uint64(b) } + return types.GoType{Uint64(a) % Uint64(b)} } - func Mod(s seq.Seq) types.Elem { var first, zero types.Elem - + if seq.Empty(s) { panic("Mod cannot be called with no arguments") } zero, s, _ = s.FirstRest() first = zero - var fn mathReduceFn switch first.(types.GoType).V.(type) { - + case int: fn = modInt - - + case int8: fn = modInt8 - - + case int16: fn = modInt16 - - + case int32: fn = modInt32 - - + case int64: fn = modInt64 - - + case uint: fn = modUint - - + case uint8: fn = modUint8 - - + case uint16: fn = modUint16 - - + case uint32: fn = modUint32 - - + case uint64: fn = modUint64 - - - + default: panic(fmt.Sprintf("$#v cannot have Mod called on it", first)) } return mathReduce(fn, zero, s) } - diff --git a/core/mathgen/mathgen.go b/core/mathgen/mathgen.go index 38326f9..fa96320 100644 --- a/core/mathgen/mathgen.go +++ b/core/mathgen/mathgen.go @@ -15,30 +15,30 @@ type MathOpType struct { // The standard types for which math operations work upon. These don't include // byte and rune because those are aliases of int8 and int32, respectively var MathOpTypes = []MathOpType{ - {"Int", "int"}, - {"Int8", "int8"}, - {"Int16", "int16"}, - {"Int32", "int32"}, - {"Int64", "int64"}, - {"Uint", "uint"}, - {"Uint8", "uint8"}, - {"Uint16", "uint16"}, - {"Uint32", "uint32"}, - {"Uint64", "uint64"}, - {"Float32", "float32"}, - {"Float64", "float64"}, - {"Complex64", "complex64"}, + {"Int", "int"}, + {"Int8", "int8"}, + {"Int16", "int16"}, + {"Int32", "int32"}, + {"Int64", "int64"}, + {"Uint", "uint"}, + {"Uint8", "uint8"}, + {"Uint16", "uint16"}, + {"Uint32", "uint32"}, + {"Uint64", "uint64"}, + {"Float32", "float32"}, + {"Float64", "float64"}, + {"Complex64", "complex64"}, {"Complex128", "complex128"}, } var MathOpsIntOnly = []MathOpType{ - {"Int", "int"}, - {"Int8", "int8"}, - {"Int16", "int16"}, - {"Int32", "int32"}, - {"Int64", "int64"}, - {"Uint", "uint"}, - {"Uint8", "uint8"}, + {"Int", "int"}, + {"Int8", "int8"}, + {"Int16", "int16"}, + {"Int32", "int32"}, + {"Int64", "int64"}, + {"Uint", "uint"}, + {"Uint8", "uint8"}, {"Uint16", "uint16"}, {"Uint32", "uint32"}, {"Uint64", "uint64"}, @@ -53,7 +53,7 @@ type MathOp struct { // Will be the first item in the reduce, and allows for the function being // called with an empty seq. If empty string than the first item in the // given sequence is used and an empty sequence is not allowed - Unit string + Unit string // This is going to be the same for all ops, it's just convenient to have // here diff --git a/core/mathgen/mathgen.tpl b/core/mathgen/mathgen.tpl index f710322..71476f7 100644 --- a/core/mathgen/mathgen.tpl +++ b/core/mathgen/mathgen.tpl @@ -15,52 +15,43 @@ func mathReduce(fn mathReduceFn, zero types.Elem, s seq.Seq) types.Elem { } return seq.Reduce(reduceFn, zero, s) } - -{{range .}} -{{$mathOp := .}} -{{range .OpTypes}} +{{range .}}{{$mathOp := .}}{{range .OpTypes}} func {{$mathOp.Private}}{{.CastFn}}(a, b types.Elem) types.Elem { - return types.GoType{ {{.CastFn}}(a) {{$mathOp.Op}} {{.CastFn}}(b) } + return types.GoType{{`{`}}{{.CastFn}}(a) {{$mathOp.Op}} {{.CastFn}}(b)} } -{{end}} -{{if $mathOp.IncludeString}} +{{end}}{{if $mathOp.IncludeString}} func {{$mathOp.Private}}String(a, b types.Elem) types.Elem { - return types.GoType{ String(a) {{$mathOp.Op}} String(b) } + return types.GoType{String(a) {{$mathOp.Op}} String(b)} } {{end}} func {{$mathOp.Public}}(s seq.Seq) types.Elem { var first, zero types.Elem - {{if (eq $mathOp.Unit "")}} +{{if (eq $mathOp.Unit "")}} if seq.Empty(s) { panic("{{$mathOp.Public}} cannot be called with no arguments") } zero, s, _ = s.FirstRest() first = zero - {{else}} +{{else}} if seq.Empty(s) { - return types.GoType{ {{$mathOp.Unit}} } + return types.GoType{{`{`}}{{$mathOp.Unit}}} } first, _, _ = s.FirstRest() - {{end}} - +{{end}} var fn mathReduceFn switch first.(types.GoType).V.(type) { - {{range .OpTypes}} +{{range .OpTypes}} case {{.Type}}: - fn = {{$mathOp.Private}}{{.CastFn}} - {{if (ne $mathOp.Unit "")}} - zero = types.GoType{ {{.Type}}({{$mathOp.Unit}}) } - {{end}} - {{end}} - {{if $mathOp.IncludeString}} + fn = {{$mathOp.Private}}{{.CastFn}}{{if (ne $mathOp.Unit "")}} + zero = types.GoType{{`{`}}{{.Type}}({{$mathOp.Unit}})}{{end}} +{{end}}{{if $mathOp.IncludeString}} case string: fn = {{$mathOp.Private}}String zero = types.GoType{string("")} - {{end}} +{{end}} default: panic(fmt.Sprintf("$#v cannot have {{$mathOp.Public}} called on it", first)) } return mathReduce(fn, zero, s) -} -{{end}} +}{{end}} diff --git a/eval/eval.go b/eval/eval.go index 95459a6..c8100c7 100644 --- a/eval/eval.go +++ b/eval/eval.go @@ -45,12 +45,11 @@ func Eval(p *pkgctx.PkgCtx, el types.Elem) types.Elem { if !ok || !first.Equal(colon) { return el } - + fnEl, args, ok := rest.FirstRest() if !ok { Bail(el, "Empty list after colon, no function given") } - var fnName string if gt, ok := fnEl.(types.GoType); ok {