refactor: remove usages of radash functions (#660)

### Summary of Changes

We were only using three functions from `radash` (`isEmpty`, `group`,
`last`). These are now replaced by custom implementations and the
dependency to `radash` is removed.

Author: lars-reimann

.github/dependabot.yml

@@ -20,15 +20,3 @@ updates:
     directory: '/docs'
     schedule:
       interval: 'monthly'
-
-  # DSL
-  - package-ecosystem: 'npm'
-    directory: '/DSL'
-    schedule:
-      interval: 'monthly'
-
-  # Runner
-  - package-ecosystem: 'pip'
-    directory: '/Runner'
-    schedule:
-      interval: 'monthly'

package-lock.json

@@ -106,7 +106,6 @@
         "commander": "^11.1.0",
         "glob": "^10.3.10",
         "langium": "^2.0.2",
-        "radash": "^11.0.0",
         "true-myth": "^7.1.0",
         "vscode-languageclient": "^9.0.1",
         "vscode-languageserver": "^9.0.1"

package.json

@@ -66,7 +66,6 @@ import {
     moduleMembersOrEmpty,
     statementsOrEmpty,
 } from '../language/helpers/nodeProperties.js';
-import { group } from 'radash';
 import { IdManager } from '../language/helpers/idManager.js';
 import { isInStubFile } from '../language/helpers/fileExtensions.js';
 import {
@@ -76,6 +75,7 @@ import {
     NullConstant,
     StringConstant,
 } from '../language/partialEvaluation/model.js';
+import { groupBy } from '../helpers/collectionUtils.js';
 
 export const CODEGEN_PREFIX = '__gen_';
 const BLOCK_LAMBDA_PREFIX = `${CODEGEN_PREFIX}block_lambda_`;
@@ -229,16 +229,16 @@ const generatePipeline = function (
 };
 
 const generateImports = function (importSet: ImportData[]): string[] {
-    const qualifiedImports = Array.from(importSet)
+    const qualifiedImports = importSet
         .filter((importStmt) => importStmt.declarationName === undefined)
         .sort((a, b) => a.importPath.localeCompare(b.importPath))
         .map(generateQualifiedImport);
-    const groupedImports = Object.entries(
-        group(
-            Array.from(importSet).filter((importStmt) => importStmt.declarationName !== undefined),
-            (importStmt) => importStmt.importPath,
-        ),
-    ).sort(([key1, _value1], [key2, _value2]) => key1.localeCompare(key2));
+    const groupedImports = groupBy(
+        importSet.filter((importStmt) => importStmt.declarationName !== undefined),
+        (importStmt) => importStmt.importPath,
+    )
+        .toArray()
+        .sort(([key1, _value1], [key2, _value2]) => key1.localeCompare(key2));
     const declaredImports: string[] = [];
     for (const [key, value] of groupedImports) {
         const importedDecls =

src/cli/generator.ts

@@ -0,0 +1,85 @@
+import { Stream, stream } from 'langium';
+
+/**
+ * Returns the values of the iterable that are labeled the same as a previous value. The first value with a label is
+ * not included. Neither are values with an `undefined` label.
+ *
+ * @example
+ *     const id = (value: any) => value;
+ *     duplicatesBy([1, 2, 1, 3], id) // [1]
+ */
+export const duplicatesBy = <T, K>(iterable: Iterable<T>, labeler: (element: T) => K | undefined): Stream<T> => {
+    return stream(duplicatedByGenerator(iterable, labeler));
+};
+
+const duplicatedByGenerator = function* <T, K>(
+    iterable: Iterable<T>,
+    labeler: (element: T) => K | undefined,
+): Generator<T, void> {
+    const knownLabels = new Set<K>();
+
+    for (const value of iterable) {
+        const label = labeler(value);
+        if (label === undefined) {
+            continue;
+        }
+
+        if (knownLabels.has(label)) {
+            yield value;
+        } else {
+            knownLabels.add(label);
+        }
+    }
+};
+
+/**
+ * Returns the values of the iterable grouped by their label. Values with an `undefined` label are not included.
+ */
+export const groupBy = <T, K>(iterable: Iterable<T>, labeler: (element: T) => K | undefined): Stream<[K, T[]]> => {
+    const groups = new Map<K, T[]>();
+
+    for (const value of iterable) {
+        const label = labeler(value);
+        if (label === undefined) {
+            continue;
+        }
+
+        const group = groups.get(label);
+        if (group === undefined) {
+            groups.set(label, [value]);
+        } else {
+            group.push(value);
+        }
+    }
+
+    return stream(groups.entries());
+};
+
+/**
+ * Returns whether the iterable has no values.
+ */
+export const isEmpty = (iterable: Iterable<unknown>): boolean => {
+    return iterable[Symbol.iterator]().next().done === true;
+};
+
+/**
+ * Returns the last element of the array, or `undefined` if the array is empty.
+ */
+export const last = <T>(array: T[]): T | undefined => {
+    return array[array.length - 1];
+};
+
+/**
+ * Returns the unique value in the iterable, or `undefined` if none or multiple exist.
+ */
+export const uniqueOrUndefined = <T>(iterable: Iterable<T>): T | undefined => {
+    const iterator = iterable[Symbol.iterator]();
+    const { value: first } = iterator.next();
+    const { done } = iterator.next();
+
+    if (done) {
+        return first;
+    } else {
+        return undefined;
+    }
+};

src/helpers/collectionUtils.ts

@@ -1,5 +1,5 @@
 /**
- * Handles the mapping of objects, usually nodes of an Safe-DS AST, to their IDs.
+ * Handles the mapping of objects, usually nodes of a Safe-DS AST, to their IDs.
  */
 export class IdManager<T extends WeakKey> {
     /**

src/language/helpers/stringUtils.ts renamed to src/helpers/stringUtils.ts

@@ -10,12 +10,12 @@ import {
 } from 'langium';
 import * as ast from '../generated/ast.js';
 import { annotationCallsOrEmpty, literalsOrEmpty, typeArgumentsOrEmpty } from '../helpers/nodeProperties.js';
-import { last } from 'radash';
 import noSpace = Formatting.noSpace;
 import newLine = Formatting.newLine;
 import newLines = Formatting.newLines;
 import oneSpace = Formatting.oneSpace;
 import indent = Formatting.indent;
+import { last } from '../../helpers/collectionUtils.js';
 
 const newLinesWithIndent = function (count: number, options?: FormattingActionOptions): FormattingAction {
     return {

src/language/helpers/collectionUtils.ts

@@ -10,7 +10,7 @@ import {
 } from '../generated/ast.js';
 import { stream } from 'langium';
 import { parametersOrEmpty } from '../helpers/nodeProperties.js';
-import { isEmpty } from 'radash';
+import { isEmpty } from '../../helpers/collectionUtils.js';
 
 export type ParameterSubstitutions = Map<SdsParameter, EvaluatedNode>;
 export type ResultSubstitutions = Map<SdsAbstractResult, EvaluatedNode>;