some minor optimizations

- remove a matchcontinue
- do not operate twice on list
- make function tail recursive
- avoid tuples

Belonging to [master]:
  - #1947

Compiler/BackEnd/AdjacencyMatrix.mo

@@ -191,25 +191,23 @@ public function getOtherEqSysAdjacencyMatrix
   input BackendDAE.AdjacencyMatrix mnew;
   output BackendDAE.AdjacencyMatrix outMNew;
 algorithm
-  outMNew := matchcontinue (m)
+  outMNew := match (m)
     local
       list<Integer> row;
 
-    case (_) equation
-      true = intGt(index, size);
+    case (_) guard intGt(index, size)
     then mnew;
 
-    case (_) equation
-      true = intGt(skip[index], 0);
-      row = List.select(m[index], Util.intPositive);
-      row = List.select1r(row, isAssigned, rowskip);
+    case (_) guard intGt(skip[index], 0)
+      equation
+      row = list(r for r guard intGt(r,0) and intGt(rowskip[r], 0) in m[index]);
       arrayUpdate(mnew, index, row);
     then getOtherEqSysAdjacencyMatrix(m, size, index+1, skip, rowskip, mnew);
 
     case (_) equation
       arrayUpdate(mnew,index,{});
     then getOtherEqSysAdjacencyMatrix(m, size, index+1, skip, rowskip, mnew);
-  end matchcontinue;
+  end match;
 end getOtherEqSysAdjacencyMatrix;
 
 protected function isAssigned
@@ -226,9 +224,13 @@ public function transposeAdjacencyMatrix
   input BackendDAE.AdjacencyMatrix m;
   input Integer nRowsMt;
   output BackendDAE.AdjacencyMatrixT mt;
+protected
+  Integer i = 1;
 algorithm
   mt := arrayCreate(nRowsMt, {});
-  ((mt, _)) := Array.fold(m, transposeRow, (mt, 1));
+  for e in m loop
+    (mt, i) := transposeRow(e, mt, i);
+  end for;
 end transposeAdjacencyMatrix;
 
 protected function transposeRow "author: PA
@@ -239,25 +241,24 @@ protected function transposeRow "author: PA
   inputs:  (int list list, int /* row */,int /* iter */)
   outputs:  int list"
   input list<Integer> row;
-  input tuple<BackendDAE.AdjacencyMatrixT, Integer> inTpl "(m,index)";
-  output tuple<BackendDAE.AdjacencyMatrixT, Integer> outTpl;
+  input output BackendDAE.AdjacencyMatrixT mt;
+  input output Integer indx;
 algorithm
-  outTpl := match (row, inTpl)
+  (mt, indx) := match (row)
     local
-      Integer i, indx, indx1, iabs;
+      Integer i, indx1, iabs;
       list<Integer> res, col;
-      BackendDAE.AdjacencyMatrixT mt;
 
-    case ({}, (mt, indx))
-    then ((mt, indx+1));
+    case {}
+    then (mt, indx+1);
 
-    case (i::res, (mt, indx)) equation
+    case i::res equation
       iabs = intAbs(i);
       mt = Array.expand(iabs - arrayLength(mt), mt, {});
       col = mt[iabs];
       indx1 = if intLt(i, 0) then -indx else indx;
       arrayUpdate(mt, iabs, indx1::col);
-    then transposeRow(res, (mt, indx));
+    then transposeRow(res, mt, indx);
   end match;
 end transposeRow;
 

Compiler/BackEnd/EvaluateFunctions.mo

@@ -614,7 +614,7 @@ algorithm
       list<DAE.Exp> eLst;
   case(DAE.TUPLE(PR = eLst))
     algorithm
-      then List.fold(List.map(eLst,hasUnknownType),boolOr,false);
+      then List.mapBoolOr(eLst,hasUnknownType);
   case(DAE.CREF(ty=DAE.T_UNKNOWN()))
     then true;
   else
@@ -634,7 +634,7 @@ algorithm
     list<DAE.Exp> eLst;
   case(DAE.TUPLE(PR = eLst))
     algorithm
-      then List.fold(List.map(eLst,hasMultipleArrayDimensions),boolOr,false);
+      then List.mapBoolOr(eLst,hasMultipleArrayDimensions);
   case(DAE.CREF(ty=ty))
     algorithm
     if Types.isArray(ty) then

Compiler/FrontEnd/Expression.mo

@@ -4726,10 +4726,7 @@ algorithm
 
   case(_, _ :: _ , _)
     equation
-      i = listLength(iDims) - 1;
-      d = List.last(iDims);
-      (dims, _) = List.split(iDims,i);
-
+      (d, dims) = List.splitLast(iDims);
       explst = listToArray3(inList,d,inType);
       arrexp = listToArray2(explst,dims,inType);
     then

Compiler/FrontEnd/ExpressionSimplify.mo

@@ -1103,7 +1103,7 @@ algorithm
     case (DAE.CALL(path=Absyn.IDENT("max"),expLst={DAE.ARRAY(array=es)},attr=DAE.CALL_ATTR(ty=tp)))
       equation
         i1 = listLength(es);
-        es = List.union(es,es);
+        es = List.union(es,{});
         i2 = listLength(es);
         if i1 == i2
         then
@@ -1122,7 +1122,7 @@ algorithm
     case (DAE.CALL(path=Absyn.IDENT("min"),expLst={DAE.ARRAY(array=es)},attr=DAE.CALL_ATTR(ty=tp)))
       equation
         i1 = listLength(es);
-        es = List.union(es,es);
+        es = List.union(es,{});
         i2 = listLength(es);
         if i1 == i2
         then

Compiler/FrontEnd/OperatorOverloading.mo

@@ -2121,8 +2121,8 @@ algorithm
         args = List.map(args, List.rest);
         tys2 = List.mapMap(args, listHead, Types.funcArgType);
         // We only look for constructors that are not of the initial type. Filter duplicates.
-        tys1 = List.setDifference(List.union(tys1,tys1),{inType1});
-        tys2 = List.setDifference(List.union(tys2,tys2),{inType2});
+        tys1 = List.setDifference(List.union(tys1,{}),{inType1});
+        tys2 = List.setDifference(List.union(tys2,{}),{inType2});
         // Get the constructors
         (cache,tys1) = getOperatorFuncsOrEmpty(inCache,env,tys1,"'constructor'",info,{});
         (cache,tys2) = getOperatorFuncsOrEmpty(cache,env,tys2,"'constructor'",info,{});

Compiler/Util/List.mo

@@ -7095,7 +7095,7 @@ algorithm
       list<T> rest1,rest2;
 
     case (el1 :: rest1, el2 :: rest2)
-      then referenceEq(el1,el2) and allReferenceEq(rest1,rest2);
+      then if referenceEq(el1,el2) then allReferenceEq(rest1,rest2) else false;
 
     case ({},{}) then true;
     else false;