kode4food/ale

Similar blocks of code found in 2 locations. Consider refactoring.

Open

var (
    quoteSym  = env.RootSymbol("quote")
    consSym   = env.RootSymbol("cons")
    listSym   = env.RootSymbol("list")
    vectorSym = env.RootSymbol("vector")

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

const (
    MakeSpecial = data.Local("!make-special")
    Resolve     = data.Local(".resolve")
    Evaluate    = data.Local(".eval")
    ForEach     = data.Local(".for-each")

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

func doNumEq(vm *VM) {
    vm.SP++
    SP1 := vm.SP + 1
    vm.MEM[SP1] = data.Bool(
        data.EqualTo == vm.MEM[SP1].(data.Number).Cmp(

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

func doNumGt(vm *VM) {
    vm.SP++
    SP1 := vm.SP + 1
    vm.MEM[SP1] = data.Bool(
        data.GreaterThan == vm.MEM[SP1].(data.Number).Cmp(

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

func doNumLt(vm *VM) {
    vm.SP++
    SP1 := vm.SP + 1
    vm.MEM[SP1] = data.Bool(
        data.LessThan == vm.MEM[SP1].(data.Number).Cmp(

• Read up
  Read up

Method mapWrapper.Wrap has 5 return statements (exceeds 4 allowed).

Open

func (w *mapWrapper) Wrap(c *Context, v reflect.Value) (data.Value, error) {
    if !v.IsValid() {
        return data.Null, nil
    }
    c, err := c.Push(v)

Method mapWrapper.Unwrap has 5 return statements (exceeds 4 allowed).

Open

func (w *mapWrapper) Unwrap(v data.Value) (reflect.Value, error) {
    s, ok := v.(data.Sequence)
    if !ok {
        return _emptyValue, errors.New(ErrValueMustBeSequence)
    }

Method List.Equal has 5 return statements (exceeds 4 allowed).

Open

func (l *List) Equal(other Value) bool {
    if l == nil {
        return l == other
    }
    cr, ok := other.(*List)

Function expand1 has 5 return statements (exceeds 4 allowed).

Open

func expand1(ns env.Namespace, v data.Value) (data.Value, bool) {
    l, ok := v.(*data.List) // it's got to be a list
    if !ok {
        return v, false
    }

Method Object.Equal has 5 return statements (exceeds 4 allowed).

Open

func (o *Object) Equal(other Value) bool {
    if o == nil || o == other {
        return o == other
    }
    r, ok := other.(*Object)

Method paramCases.isReachable has 5 return statements (exceeds 4 allowed).

Open

func (pc *paramCases) isReachable(i int, isRest bool) bool {
    if len(pc.cases) == 0 {
        return true
    }
    if pc.hasRest {

Method encoder.ResolveScoped has 5 return statements (exceeds 4 allowed).

Open

func (e *encoder) ResolveScoped(n data.Local) (*ScopedCell, bool) {
    if i, ok := e.ResolveLocal(n); ok {
        return newScopedCell(LocalScope, i.Cell), true
    }
    if _, ok := e.ResolveParam(n); ok {

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func (complex128Wrapper) Wrap(_ *Context, v reflect.Value) (data.Value, error) {
    c := v.Complex()
    r := data.Float(real(c))
    i := data.Float(imag(c))
    return data.NewCons(r, i), nil

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func (complex64Wrapper) Wrap(_ *Context, v reflect.Value) (data.Value, error) {
    c := v.Complex()
    r := data.Float(real(c))
    i := data.Float(imag(c))
    return data.NewCons(r, i), nil

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func (e *asmEncoder) copy() *asmEncoder {
    res := *e
    res.args = maps.Clone(res.args)
    res.private = maps.Clone(res.private)
    res.labels = maps.Clone(res.labels)

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func (e *Encoded) Copy() *Encoded {
    res := *e
    res.Code = slices.Clone(e.Code)
    res.Constants = slices.Clone(e.Constants)
    res.Closure = slices.Clone(e.Closure)

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func (a *Applicable) Equal(other Type) bool {
    if a == other {
        return true
    }
    if other, ok := other.(*Applicable); ok {

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func doDiv(vm *VM) {
    vm.SP++
    SP1 := vm.SP + 1
    vm.MEM[SP1] = vm.MEM[SP1].(data.Number).Div(
        vm.MEM[vm.SP].(data.Number),

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func (r *Record) Equal(other Type) bool {
    if r == other {
        return true
    }
    if other, ok := other.(*Record); ok {

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func doSub(vm *VM) {
    vm.SP++
    SP1 := vm.SP + 1
    vm.MEM[SP1] = vm.MEM[SP1].(data.Number).Sub(
        vm.MEM[vm.SP].(data.Number),

• Read up
  Read up