Rewrite Catalog

Simplifies module includes

module :[module_define] = struct include :[[module_include]] end

module :[module_define] = :[module_include]

module That_queue : Queue_intf = struct
  include Linked_queue
end

-module That_queue : Queue_intf = struct
-  include Linked_queue
-end
+module That_queue : Queue_intf = Linked_queue

Removes redundant continue statement in for loops.

for (:[1]) { continue; }

for (:[1]) {}

int main() {
  for (i = 0; i < 10; i++) { continue; }
}

 int main() {
-  for (i = 0; i < 10; i++) { continue; }
+  for (i = 0; i < 10; i++) {}
 }

Uses Equal instead of Compare for bytes

if bytes.Compare(:[1], :[2]) == 0 {:[3]}

if bytes.Equal(:[1], :[2]) {:[3]}

if bytes.Compare(x, y) == 0 {}

-if bytes.Compare(x, y) == 0 {}
+if bytes.Equal(x, y) {}

Uses Contains for string matching instead of checking index

if strings.Index(:[1], :[2]) != -1 {:[3]}

if strings.Contains(:[1], :[2]) {:[3]}

if strings.Index(x, y) != -1 {}

-if strings.Index(x, y) != -1 {}
+if strings.Contains(x, y) {}

Removes redundant nil checks.

if :[var_check] != nil {
  for :[defines] := range :[var_use] {:[inner_body]}
}

where :[var_check] == :[var_use]

for :[defines] := range :[var_use] {:[inner_body]}

func (HTTPRequest *HTTPRequest) run(client *Client) ([]byte, error) {
	var err error
	values := make(url.Values)
	if HTTPRequest.Parameters != nil {
		for k, v := range HTTPRequest.Parameters {
			values.Set(k, fmt.Sprintf("%v", v))
		}
	}
}

 func (HTTPRequest *HTTPRequest) run(client *Client) ([]byte, error) {
 	var err error
 	values := make(url.Values)
-	if HTTPRequest.Parameters != nil {
-		for k, v := range HTTPRequest.Parameters {
+	for k, v := range HTTPRequest.Parameters {
 			values.Set(k, fmt.Sprintf("%v", v))
 		}
-	}
 }

Simplifies if not conditionals to if-not

(if (not :[1]) :[2] :[3])

(if-not :[1] :[2] :[3])

'(if (not test) then else)

-'(if (not test) then else)
+'(if-not test then else)

Simplifies if conditionals to use when

(if :[1] :[2] nil)

(when :[1] :[2])

'(if test then nil)

-'(if test then nil)
+'(when test then)

Simplifies assoc calls to assoc-in

(assoc :[coll0] :[key0] (assoc (get :[coll1] :[key1]) :[key2] :[val]))

where :[coll0] == :[coll1], :[key0] == :[key1]

(assoc-in :[coll0] [:[key0] :[key2]] :[val])

'(assoc coll k0 (assoc (get coll k0) k1 a))

-'(assoc coll k0 (assoc (get coll k0) k1 a))
+'(assoc-in coll [k0 k1] a)

Replaces where type checks with a more readable whereType

.where((:[var_bind]) => :[var_use] is :[[type]])

where :[var_bind] == :[var_use]

.whereType<:[type]>()

iterable.where((e) => e is T)

-iterable.where((e) => e is T)
+iterable.whereType<T>()

Removes redundant continue statement in for loops.

if (!:[container].isEmpty)

if (:[container].isNotEmpty)

void main() {
    var todo = [];
    if (!todo.isEmpty) print('things to do...');
}

 void main() {
     var todo = [];
-    if (!todo.isEmpty) print('things to do...');
+    if (todo.isNotEmpty) print('things to do...');
 }

Replaces length checks with a more readable and performant getters.

if (:[container].length != 0)

if (:[container].isNotEmpty)

void main() {
    var lunchBox = [];
    if (lunchBox.length != 0) print('ready to eat...');
}

 void main() {
     var lunchBox = [];
-    if (lunchBox.length != 0) print('ready to eat...');
+    if (lunchBox.isNotEmpty) print('ready to eat...');
 }

Removes single redundant field names.

{ :[[field]]: :[[use]] }

where :[field] == :[use]

{ :[field] }

let bar: u8 = 123;
struct Foo {
    bar: u8,
}
let foo = Foo { bar: bar };

 struct Foo {
     bar: u8,
 }
-let foo = Foo { bar: bar };
+let foo = Foo { bar };

Uses ++ infix operator instead of List.append

lists:append(:[1], :[2])

:[1] ++ :[2]

get_values(T, Key, lists:append(V, Acc)).

-get_values(T, Key, lists:append(V, Acc)).
+get_values(T, Key, V ++ Acc).

Simplifies List.map to a list comprehension.

lists:map(fun :[fn_name]/1, :[list] end)

[:[fn_name](V1) || V1 <- :[list]]

lists:map(fun x/1, l end)

-lists:map(fun x/1, l end)
+[x(V1) || V1 <- l]

Simplifies a consecutive pipe left operation |> for map

|> :[[container1]].map :[[fn1]]
|> :[[container2]].map :[[fn2]]

where :[container1] == :[container2],
match :[container1] {
| "List" -> true
| "Array" -> true
| "Set" -> true
}

|> :[container1].map (:[fn1] >> :[fn2])

typeRefs
        |> allRefs
        |> importsWithoutSelf apiSubmodule importingFrom
        |> List.map toModuleName
        |> List.map toImportString
        |> String.join "\n"

 typeRefs
         |> allRefs
         |> importsWithoutSelf apiSubmodule importingFrom
-        |> List.map toModuleName
-        |> List.map toImportString
+        |> List.map (toModuleName >> toImportString)
         |> String.join "\n"

Simplifies folds that checks a “for-all” condition.

.foldLeft(true)(:[1] && :[2])

where :[1] == :[2]

.forall(identity)

val l = List(true, false, false, true)
val andAll = l.foldLeft(true)(_ && _)

 val l = List(true, false, false, true)
-val andAll = l.foldLeft(true)(_ && _)
+val andAll = l.forall(identity)

Simplifies .filter(...).size call chains to use .count

.filter(:[1]).size

.count(:[1])

object Test {
  val list = List(1,2,3,4).filter(_ % 2 == 0).size
}

 object Test {
-  val list = List(1,2,3,4).filter(_ % 2 == 0).size
+  val list = List(1,2,3,4).count(_ % 2 == 0)
 }